clearing read stream buffers

[JG]

Does anyone know a standard (or supported on Linux, Mac, Win32) way to
clear a read stream buffer (standard ANSI C file stream)?

I would even settle for a platform specific way of doing it.

And no, I know I can use direct low level I/O or non-buffered to do
reads, but for my app, I need the buffering. I can implement myself,
but this is not optimal.

Example, I open a read only file using fopen(). I periodically know
from external methods, that the underlying file has been updated.
Before I do my next read on the stream, I want to flush the read
buffers and force it to read from disk (or kernel cache).

fflush seems to work on Linux, but not sure it is standard.

I don't see any function to do this, but it seems very needed.

I can also trigger a flush of the buffers by fseeking to a much
different area of the file. Does any fseek, even offseting by 1 index
always force a flusshing of the buffers?

[Luke Wu]

JG wrote:

Does anyone know a standard (or supported on Linux, Mac, Win32) way to clear a read stream buffer (standard ANSI C file stream)?

I would even settle for a platform specific way of doing it.

And no, I know I can use direct low level I/O or non-buffered to do
reads, but for my app, I need the buffering. I can implement myself,
but this is not optimal.

once you've determined that there is still a bunch of characters
sitting in the input stream (should include '\n' at least), then you
can use:

while( (c = fgetc(FOOFILE) != '\n' )
;

[jschultz]

Luke Wu wrote:

once you've determined that there is still a bunch of characters
sitting in the input stream (should include '\n' at least), then you
can use:

while( (c = fgetc(FOOFILE) != '\n' )
;

He is not asking the typical "How do I forget whatever is in stdin
question?"

He is asking with an actual file on disk (not a pipe/terminal/etc) that
he performs a read upon, how can he portably and efficiently FORCE an
open read stream to re-read data he wants from disk. The problem being
that a write from another thread/stream/fd/process has changed the
underlying file and he wants to ensure that the input stream doesn't
just re-give him what is in its buffers from an earlier read.

[Lawrence Kirby]

On Fri, 11 Feb 2005 08:28:27 -0800, JG wrote:

Does anyone know a standard (or supported on Linux, Mac, Win32) way to
clear a read stream buffer (standard ANSI C file stream)?

I would even settle for a platform specific way of doing it.

And no, I know I can use direct low level I/O or non-buffered to do
reads, but for my app, I need the buffering. I can implement myself,
but this is not optimal.

Example, I open a read only file using fopen(). I periodically know
from external methods, that the underlying file has been updated.
Before I do my next read on the stream, I want to flush the read
buffers and force it to read from disk (or kernel cache).
The only sure way I can think of is to close and reopen the stream, using,
say, freopen().
fflush seems to work on Linux, but not sure it is standard.
It isn't. In standard C applying fflush() to an input stream invokes
undefined behaviour.
I don't see any function to do this, but it seems very needed.
I know what you mean, although surprisingly I don't remember needing it.
I can also trigger a flush of the buffers by fseeking to a much
different area of the file. Does any fseek, even offseting by 1 index
always force a flusshing of the buffers?

I hope not, that would be inefficient if the data at the new position was
already in the buffer. This approach seems to be your best bet however
short of closing and reopening the file. Maybe a double seek, one to some
far off position and then to the position you want. Even that isn't 100%
guaranteed though.

Lawrence

[jschultz]

One way I was thinking of doing this is:

if (setvbuf(read_s tream, NULL, _IONBF, 0) != 0 ||
setvbuf(read_st ream, NULL, _IOFBF, 0) != 0) {
return -1;
}

/* do read */

Any comments from the peanut gallery about how advisable / guaranteed
this is to work?

[infobahn]

Luke Wu wrote:

JG wrote:

Does anyone know a standard (or supported on Linux, Mac, Win32) way

to

clear a read stream buffer (standard ANSI C file stream)?

I would even settle for a platform specific way of doing it.

And no, I know I can use direct low level I/O or non-buffered to do
reads, but for my app, I need the buffering. I can implement myself,
but this is not optimal.

once you've determined that there is still a bunch of characters
sitting in the input stream (should include '\n' at least), then you
can use:

while( (c = fgetc(FOOFILE) != '\n' )
;

You missed a ), and forgot to check for EOF.

while( (c = fgetc(FOOFILE)) != '\n' && c != EOF)
;

[Ben Pfaff]

"jschultz" <js******@d-fusion.net> writes:

One way I was thinking of doing this is:

if (setvbuf(read_s tream, NULL, _IONBF, 0) != 0 ||
setvbuf(read_st ream, NULL, _IOFBF, 0) != 0) {
return -1;
}

From C99:

The setvbuf function may be used only after the stream
pointed to by stream has been associated with an open file
and before any other operation (other than an unsuccessful
call to setvbuf) is performed on the stream.

Thus, calling setvbuf() twice is always undefined, regardless of
when you do it. But you're only allowed to do it at all just
after the file is opened.
--
Here's a tip: null pointers don't have to be *dull* pointers!

[Alan Balmer]

On 11 Feb 2005 09:01:46 -0800, "jschultz" <js******@d-fusion.net>
wrote:

Luke Wu wrote:

once you've determined that there is still a bunch of characters
sitting in the input stream (should include '\n' at least), then you
can use:

while( (c = fgetc(FOOFILE) != '\n' )
;

He is not asking the typical "How do I forget whatever is in stdin
question?"

He is asking with an actual file on disk (not a pipe/terminal/etc) that
he performs a read upon, how can he portably and efficiently FORCE an
open read stream to re-read data he wants from disk. The problem being
that a write from another thread/stream/fd/process has changed the
underlying file and he wants to ensure that the input stream doesn't
just re-give him what is in its buffers from an earlier read.

fclose(), fopen()?

--
Al Balmer
Balmer Consulting
re************* ***********@att .net

[jschultz]

Ok, so it seems the only portable and guaranteed way to force a C input
stream to re-read from disk is to close/re-open/re-seek the file?
Doesn't that seem like a lot of overkill for a simple/common idea?

[jschultz]

I mean performance overkill specifically. Because our program needs to
do these kinds of reads very quickly and opening/closing/seeking and
THEN reading seems like a ton more work than it should be.