FIFO problem in Watcom

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct s_produit)); //
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is equal to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor, and the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to the FIFO it`s
working fine
// If i write to each 500ms i got the write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: rparent@sigma-techno.com
Web: www.sigma-techno.com



\


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: rparent@sigma-techno.com
Web: www.sigma-techno.com

EAGAIN simply means you need to try the function again.

Roger Parent wrote:

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct s_produit)); //
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is equal to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor, and the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to the FIFO it`s
working fine
// If i write to each 500ms i got the write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com

Yes i know it, but why i got this, when i’m using O_NONBLOCK with the FIFO,
is this because O_NONBLOCK is using temporary file or for any other reason.


“rectech” <rectech@iname.com> a écrit dans le message news:
3A6CA553.CA28A656@iname.com

EAGAIN simply means you need to try the function again.

Roger Parent wrote:

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to
this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct s_produit)); //
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is equal to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor, and the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to the FIFO
it`s
working fine
// If i write to each 500ms i got the
write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com

Well you ask not to block :wink: If you write faster then the
“device” can handle it or if its internal buffer is full, the best
it can do is to return EGAIN since you asked the write
to NOT block.

Imagine writting in a serial port set at 9600. If you write
at a rate equivalent to 115200, what else then returning
EGAIN would you expect write to do if you ask it not
to block.

“Roger Parent” <rparent@sigma-techno.com> wrote in message
news:94jvue$2vv$1@inn.qnx.com

Yes i know it, but why i got this, when i’m using O_NONBLOCK with the
FIFO,
is this because O_NONBLOCK is using temporary file or for any other
reason.


“rectech” <> rectech@iname.com> > a écrit dans le message news:
3A6CA553.CA28A656@iname.com> …
EAGAIN simply means you need to try the function again.

Roger Parent wrote:

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to
this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct s_produit)); //
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is equal
to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor, and the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to the FIFO
it`s
working fine
// If i write to each 500ms i got the
write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com

Try removing O_NONBLOCK to see how long it actually will take to perform the
write. It might not be as bad as you think.

KenR
Thanks Mario for clarifying my comment - I was too brief.

Mario Charest wrote:

Well you ask not to block > :wink: > If you write faster then the
“device” can handle it or if its internal buffer is full, the best
it can do is to return EGAIN since you asked the write
to NOT block.

Imagine writting in a serial port set at 9600. If you write
at a rate equivalent to 115200, what else then returning
EGAIN would you expect write to do if you ask it not
to block.

“Roger Parent” <> rparent@sigma-techno.com> > wrote in message
news:94jvue$2vv$> 1@inn.qnx.com> …
Yes i know it, but why i got this, when i’m using O_NONBLOCK with the
FIFO,
is this because O_NONBLOCK is using temporary file or for any other
reason.


“rectech” <> rectech@iname.com> > a écrit dans le message news:
3A6CA553.CA28A656@iname.com> …
EAGAIN simply means you need to try the function again.

Roger Parent wrote:

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to
this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct s_produit)); //
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is equal
to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor, and the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to the FIFO
it`s
working fine
// If i write to each 500ms i got the
write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com

Is your FIFO reader working? I believe the FIFO is memory resident up to a
point (I’ll have to look at some old notes.) Maybe your reader is not pulling
the data out of the FIFO and the data is being written to disk because it is
over a certain threshold.??

KenR

Mario Charest wrote:

“Roger Parent” <> rparent@sigma-techno.com> > wrote in message
news:94king$e6k$> 1@inn.qnx.com> …
I made the test without O_NONBLOCK and the write take 0 ms, write with
500ms
before each write after 90 writes it’s take approx 500ms to do the write
for
each write.


That seems to indicate that the first 90 writes go to a buffer (possibly
cache) then after
90 writes it wants to write to disk (I’m not familliar with how Fsys handles
fifo).

That all seems very normal to me. You will have to deal with EGAIN if
you don’t want your write to block.




“rectech” <> rectech@iname.com> > a écrit dans le message news:
3A6DB25D.13EB1945@iname.com> …
Try removing O_NONBLOCK to see how long it actually will take to perform
the
write. It might not be as bad as you think.

KenR
Thanks Mario for clarifying my comment - I was too brief.

Mario Charest wrote:

Well you ask not to block > :wink: > If you write faster then the
“device” can handle it or if its internal buffer is full, the best
it can do is to return EGAIN since you asked the write
to NOT block.

Imagine writting in a serial port set at 9600. If you write
at a rate equivalent to 115200, what else then returning
EGAIN would you expect write to do if you ask it not
to block.

“Roger Parent” <> rparent@sigma-techno.com> > wrote in message
news:94jvue$2vv$> 1@inn.qnx.com> …
Yes i know it, but why i got this, when i’m using O_NONBLOCK with
the
FIFO,
is this because O_NONBLOCK is using temporary file or for any other
reason.


“rectech” <> rectech@iname.com> > a écrit dans le message news:
3A6CA553.CA28A656@iname.com> …
EAGAIN simply means you need to try the function again.

Roger Parent wrote:

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to
write to
this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct
s_produit));
//
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is
equal
to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor,
and
the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to
the
FIFO
it`s
working fine
// If i write to each 500ms i got
the
write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com



\

I made the test without O_NONBLOCK and the write take 0 ms, write with 500ms
before each write after 90 writes it’s take approx 500ms to do the write for
each write.




“rectech” <rectech@iname.com> a écrit dans le message news:
3A6DB25D.13EB1945@iname.com

Try removing O_NONBLOCK to see how long it actually will take to perform
the
write. It might not be as bad as you think.

KenR
Thanks Mario for clarifying my comment - I was too brief.

Mario Charest wrote:

Well you ask not to block > :wink: > If you write faster then the
“device” can handle it or if its internal buffer is full, the best
it can do is to return EGAIN since you asked the write
to NOT block.

Imagine writting in a serial port set at 9600. If you write
at a rate equivalent to 115200, what else then returning
EGAIN would you expect write to do if you ask it not
to block.

“Roger Parent” <> rparent@sigma-techno.com> > wrote in message
news:94jvue$2vv$> 1@inn.qnx.com> …
Yes i know it, but why i got this, when i’m using O_NONBLOCK with the
FIFO,
is this because O_NONBLOCK is using temporary file or for any other
reason.


“rectech” <> rectech@iname.com> > a écrit dans le message news:
3A6CA553.CA28A656@iname.com> …
EAGAIN simply means you need to try the function again.

Roger Parent wrote:

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to
write to
this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct s_produit));
//
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is
equal
to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor, and
the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to the
FIFO
it`s
working fine
// If i write to each 500ms i got
the
write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com

\

“Roger Parent” <rparent@sigma-techno.com> wrote in message
news:94king$e6k$1@inn.qnx.com

I made the test without O_NONBLOCK and the write take 0 ms, write with
500ms
before each write after 90 writes it’s take approx 500ms to do the write
for
each write.

That seems to indicate that the first 90 writes go to a buffer (possibly
cache) then after
90 writes it wants to write to disk (I’m not familliar with how Fsys handles
fifo).

That all seems very normal to me. You will have to deal with EGAIN if
you don’t want your write to block.

“rectech” <> rectech@iname.com> > a écrit dans le message news:
3A6DB25D.13EB1945@iname.com> …
Try removing O_NONBLOCK to see how long it actually will take to perform
the
write. It might not be as bad as you think.

KenR
Thanks Mario for clarifying my comment - I was too brief.

Mario Charest wrote:

Well you ask not to block > :wink: > If you write faster then the
“device” can handle it or if its internal buffer is full, the best
it can do is to return EGAIN since you asked the write
to NOT block.

Imagine writting in a serial port set at 9600. If you write
at a rate equivalent to 115200, what else then returning
EGAIN would you expect write to do if you ask it not
to block.

“Roger Parent” <> rparent@sigma-techno.com> > wrote in message
news:94jvue$2vv$> 1@inn.qnx.com> …
Yes i know it, but why i got this, when i’m using O_NONBLOCK with
the
FIFO,
is this because O_NONBLOCK is using temporary file or for any other
reason.


“rectech” <> rectech@iname.com> > a écrit dans le message news:
3A6CA553.CA28A656@iname.com> …
EAGAIN simply means you need to try the function again.

Roger Parent wrote:

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to
write to
this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct
s_produit));
//
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is
equal
to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor,
and
the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to
the
FIFO
it`s
working fine
// If i write to each 500ms i got
the
write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com



\

My running program read at each 1000ms.

“Roger Parent” <rparent@sigma-techno.com> a écrit dans le message news:
94huek$n1d$1@inn.qnx.com

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to
this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct s_produit)); //
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is equal to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor, and the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to the FIFO
it`s
working fine
// If i write to each 500ms i got the write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com



\


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com

Fast reply - try speeding up the reader to see if anything changes. I’ll look
for my old notes on FIFO’s - wish me luck…

Roger Parent wrote:

My running program read at each 1000ms.

“Roger Parent” <> rparent@sigma-techno.com> > a écrit dans le message news:
94huek$n1d$> 1@inn.qnx.com> …

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to
this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct s_produit)); //
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is equal to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor, and the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to the FIFO
it`s
working fine
// If i write to each 500ms i got the write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com



\


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com

FIFO’s are under Fsys’s control. Check out ‘use Fsys’ to change Fsys’s behavior.
Maybe add more to it’s cache (’-c’), reduce it’s delay (’-d’), or add to it’s
ramdisk (’-r’). That’s the best I found in my notes.

KenR

rectech wrote:

Fast reply - try speeding up the reader to see if anything changes. I’ll look
for my old notes on FIFO’s - wish me luck…

Roger Parent wrote:

My running program read at each 1000ms.

“Roger Parent” <> rparent@sigma-techno.com> > a écrit dans le message news:
94huek$n1d$> 1@inn.qnx.com> …

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to
this
FIFO.


write.c

fp_fifo = open(“fifoprod”,O_WRONLY | O_NONBLOCK);

if(fp_fifo != -1)
{
for(;:wink:
{
errno = 0;
result = write(fp_fifo,produit,sizeof(struct s_produit)); //
sizeof(struct s_produit) = 121
errvalue = errno;

if(result == -1)
printf("\nErrvalue=%d",errvalue);

// I got errvalue=11 if i checked in the errno.h 11 is equal to
EAGAIN
// and EAGAIN in the write documentation saided this;
// The O_NONBLOCK flag is set for the file descriptor, and the
process would be delayed in the write operation

delay(1000); // 1000ms When i write to each 1000ms to the FIFO
it`s
working fine
// If i write to each 500ms i got the write
error EAGAIN after 90 write each 60% of the time
}
}

My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

Can someone help me or give me some hint.

Thanks Roger.


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com



\


Sigma Automatisation Inc.
6 Patrice Cote C.P.130
Trois-Pistoles, Qc G0L 4K0
Tel: 418-851-4254 ou 418-857-2172 Ext 121
Fax: 418-851-4580
Email: > rparent@sigma-techno.com
Web: > www.sigma-techno.com

Roger Parent <rparent@sigma-techno.com> wrote:

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to this
FIFO.



My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

There is a fixed maximum number of bytes that a FIFO will buffer.
(I think that value is #define PIPE_BUF 5120.) EAGAIN means
that the buffer is full, that is you have written 5120 bytes more
to the pipe than the reader process has read from the pipe. The
normal behaviour is for your process to block on the write at this
point – but you set O_NONBLOCK, so, instead, the write() call failed
returning -1 and setting errno to EAGAIN.

If you need longer queues, you might look at using Posix message
queues – run Mqueue, call mq_open(), etc. This give you control
over how large the queue is.

This may allow you to handle larger bursts of data, but you will still
have a problem if you always write to the queue faster than you read
from the queue.

-David


QNX Training Services
dagibbs@qnx.com

Hi David,

Why the PIPE_BUF of 5120 bytes, are full, i’m writing 121 bytes to each
500ms ?

Why the QNX accumulated to the buffer, when it gonna write to the FIFO ?

Do you have some information on that !

Thanks Roger.


“David Gibbs” <dagibbs@qnx.com> a écrit dans le message news:
94putb$bpr$6@nntp.qnx.com

Roger Parent <> rparent@sigma-techno.com> > wrote:

I’m using Qnx 4 and Watcom C 10.6, to write to a FIFO file.

I have made a FIFO file with mkfifo fifoprod and i using C to write to
this
FIFO.


My process cannot wait for the FIFO to write in the file.

What EAGAIN really means.

There is a fixed maximum number of bytes that a FIFO will buffer.
(I think that value is #define PIPE_BUF 5120.) EAGAIN means
that the buffer is full, that is you have written 5120 bytes more
to the pipe than the reader process has read from the pipe. The
normal behaviour is for your process to block on the write at this
point – but you set O_NONBLOCK, so, instead, the write() call failed
returning -1 and setting errno to EAGAIN.

If you need longer queues, you might look at using Posix message
queues – run Mqueue, call mq_open(), etc. This give you control
over how large the queue is.

This may allow you to handle larger bursts of data, but you will still
have a problem if you always write to the queue faster than you read
from the queue.

-David


QNX Training Services
dagibbs@qnx.com

Roger Parent <rparent@sigma-techno.com> wrote:

Hi David,

Why the PIPE_BUF of 5120 bytes, are full, i’m writing 121 bytes to each
500ms ?

How fast are you reading the data? If you write faster than you’re reading,
you’ll fill up the pipe.

Why the QNX accumulated to the buffer, when it gonna write to the FIFO ?

That “buffer” IS the FIFO. The thing you create on the disk with
mkfifo() is only an entry for the two processes using the pipe to
find each other. Extra data will not be written to disk to allow
you to continually write to the FIFO – they don’t work that way,
and they aren’t supposed to work that way.

A FIFO is a named pipe – an in-memory queue for doing IPC. In
many OSes it is implemented in the kernel, in QNX it happens to
be implemented in Fsys. It isn’t supposed to be “written” anywhere.

-David

QNX Training Services
dagibbs@qnx.com

I`m writing at 500ms and reading at 1000ms i going to change the reading
process.

If i have 2 process that writing to this PIPE, the PIPE is a 5120 bytes
PIPES or 10240 bytes.

“David Gibbs” <dagibbs@qnx.com> a écrit dans le message news:
95a7go$qre$1@nntp.qnx.com

Roger Parent <> rparent@sigma-techno.com> > wrote:
Hi David,

Why the PIPE_BUF of 5120 bytes, are full, i’m writing 121 bytes to each
500ms ?

How fast are you reading the data? If you write faster than you’re
reading,
you’ll fill up the pipe.

Why the QNX accumulated to the buffer, when it gonna write to the FIFO ?

That “buffer” IS the FIFO. The thing you create on the disk with
mkfifo() is only an entry for the two processes using the pipe to
find each other. Extra data will not be written to disk to allow
you to continually write to the FIFO – they don’t work that way,
and they aren’t supposed to work that way.

A FIFO is a named pipe – an in-memory queue for doing IPC. In
many OSes it is implemented in the kernel, in QNX it happens to
be implemented in Fsys. It isn’t supposed to be “written” anywhere.

-David

QNX Training Services
dagibbs@qnx.com

Roger Parent <rparent@sigma-techno.com> wrote:

I`m writing at 500ms and reading at 1000ms i going to change the reading
process.

That might do it.

If i have 2 process that writing to this PIPE, the PIPE is a 5120 bytes
PIPES or 10240 bytes.

One pipe/FIFO → one buffer → 5120 bytes. If you need more buffering,
as I said, you could go with a Message queue, where you can establish
exactly how big the queue will be when you create it – part of the
attributes you specify.

-David

QNX Training Services
dagibbs@qnx.com