> Take this snippet:

> const
>   sfile: integer = -1;

> procedure open(_file: integer);
> begin
> {$ifdef fast}
>   if _file <> sfile then
>     begin;
>       sfile:= _file;
> {$endif}
>       close(datatout);
>       assign(datatout, files[_file]);
>       settextbuf(datatout, databuf^, 8192);

>       if __first_event then
>         begin
>           rewrite(datatout);
>           __first_event:= false;
>         end
>       else
>         append(datatout);
> {$ifdef fast}
>     end;
> {$endif}
> end; {open}

> > Take this snippet:

> > const
> >   sfile: integer = -1;

> > procedure open(_file: integer);
> > begin
> > {$ifdef fast}
> >   if _file <> sfile then
> >     begin;
> >       sfile:= _file;
> > {$endif}
> >       close(datatout);
> >       assign(datatout, files[_file]);
> >       settextbuf(datatout, databuf^, 8192);

> Are you SURE that this SetTextBuf is done also in your
> first rewrite (which is not shown here obviously)?
> Cannot find any other reason for your experience :-)
> If not, how often do you skip the code here...

> -----> snip

> Yes, it is!

> > Yes, it is!
> ....
> This was a doubtful idea only. Let me make a more professional
> suggestion:

> Open/create as many files as you need, and send the appropriate
> file to your procedures as a Var parameter or even berrer as a
> pointer to the file. This makes it unnecessary to open and
> close them so frequently.

> Var ProtFiles : Array[1..xxx] of Text;
>     PT     : ^Text;

> Procedure AnyProc;
> Begin
>   Writeln(PT^,...);
> End;

>   PT^ := @ProtFiles[3];
>   AnyProc;

> In case the file handles exhausted, look for the article in the
> TP-links site, FAQ-page, about >15 handles.

>const
>  sfile: integer = -1;

>procedure open(_file: integer);
>begin
>{$ifdef fast}
>  if _file <> sfile then
>    begin;
>      sfile:= _file;
>{$endif}
>      close(datatout);
>      assign(datatout, files[_file]);
>      settextbuf(datatout, databuf^, 8192);

>      if __first_event then
>        begin
>          rewrite(datatout);
>          __first_event:= false;
>        end
>      else
>        append(datatout);
>{$ifdef fast}
>    end;
>{$endif}
>end; {open}

>It's used a program in which many procedures can write their results to one
>of two files (a per event file and a summary file). Going through the
>program, I suddenly realized that I had never tracked calls to "open", and
>much to my surprise I discovered that on several occasions it's called with
>the same value for _file on several consecutive invovations. So I added the
>conditionals, and timed again, clean DOS, SMARTDRV with write caching, and
>running both the old and the new versions several times in alternating
>succession. Much to my surprise the old version, which performs the code
>dozens of times more than the the new version, is actually faster! (NB: The
>file is initially opened for summary data in the main program)

>Does anyone have an explanation?

> >const
> >  sfile: integer = -1;

> >procedure open(_file: integer);
> >begin
> >{$ifdef fast}
> >  if _file <> sfile then
> >    begin;
> >      sfile:= _file;
> >{$endif}
> >      close(datatout);
> >      assign(datatout, files[_file]);
> >      settextbuf(datatout, databuf^, 8192);

> >      if __first_event then
> >        begin
> >          rewrite(datatout);
> >          __first_event:= false;
> >        end
> >      else
> >        append(datatout);
> >{$ifdef fast}
> >    end;
> >{$endif}
> >end; {open}

> >It's used a program in which many procedures can write their results to one
> >of two files (a per event file and a summary file). Going through the
> >program, I suddenly realized that I had never tracked calls to "open", and
> >much to my surprise I discovered that on several occasions it's called with
> >the same value for _file on several consecutive invovations. So I added the
> >conditionals, and timed again, clean DOS, SMARTDRV with write caching, and
> >running both the old and the new versions several times in alternating
> >succession. Much to my surprise the old version, which performs the code
> >dozens of times more than the the new version, is actually faster! (NB: The
> >file is initially opened for summary data in the main program)

> >Does anyone have an explanation?

> I initially assumed that you were opening the file if actually needed.
> However, re-reading your code with the {$ifdef} more carefully, I see
> that the extra code is not actually doing anything that affects the
> process so the code is probably a bit slower just due to the extra bits
> you've added.

> If you change the code to:

> const
>   sfile: integer = -1;

> procedure open(_file: integer);
> begin
>   if _file <> sfile then
>     begin
>       sfile:= _file;

> {only close then assign and rewrite/append the file if different to old
> one - otherwise you do not actually need to do anything so the if..then
> is checking that you have a different file}

>       close(datatout);
>       assign(datatout, files[_file]);
>       settextbuf(datatout, databuf^, 8192);

>       if __first_event then
>         begin
>           rewrite(datatout);
>           __first_event:= false;
>         end
>       else
>         append(datatout);
>     end;
> end; {open}

>> I initially assumed that you were opening the file if actually needed.
>> However, re-reading your code with the {$ifdef} more carefully, I see
>> that the extra code is not actually doing anything that affects the
>> process so the code is probably a bit slower just due to the extra bits
>> you've added.

>Yes, but don't you think (that's at least what I did!) that a simple if test
>should be quite a lot faster than closing a file, and opening another one?

> <opening and closing file if needed>

> >> I initially assumed that you were opening the file if actually needed.
> >> However, re-reading your code with the {$ifdef} more carefully, I see
> >> that the extra code is not actually doing anything that affects the
> >> process so the code is probably a bit slower just due to the extra bits
> >> you've added.

> >Yes, but don't you think (that's at least what I did!) that a simple if test
> >should be quite a lot faster than closing a file, and opening another one?

> Should definitely be faster. The file opening/closing overhead is
> significant if needed to be called a lot of times in the program.

> >{$ifdef fast}
> >  if _file <> sfile then
> >    begin;
> >      sfile:= _file;
> >{$endif}
> >      close(datatout);
> >      assign(datatout, files[_file]);

> The problem with your {$ifdef fast}/{$endif} pairs is that they are
> adding the conditional test to the file number but you then run the
> close/assign/open part as well.

> const
>   sfile: integer = -1;

> procedure open(_file: integer);
> begin

> {$ifdef fast}
>   if _file = sfile then exit else
>     begin
> {$endif}
>       sfile:= _file;
>       close(datatout);
>       assign(datatout, files[_file]);
>       settextbuf(datatout, databuf^, 8192);

>       if __first_event then
>         begin
>           rewrite(datatout);
>           __first_event:= false;
>         end
>       else
>         append(datatout);
> {$ifdef fast}
>     end;
> {$endif}
> end; {open}

> Yes, and it is a great advantage. I keep source handy for V5, V5.5, V6
> and V7 and find it invaluable not only for version changes but for
> switching on and off things like stack and range checks. IMHO, the usage
> of conditionals is very underrated.