Question

I have created a FIFO where I can do non-blocking writes into in this way:

// others, searching for a non-blocking FIFO-writer may copy this ;-)
mkfifo("/tmp/myfifo", S_IRWXU);
int fifo_fd = open("/tmp/myfifo", O_RDWR);
fcntl(fifo_fd, F_SETFL, fcntl(fifo_fd, F_GETFL) | O_NONBLOCK);

// and then in a loop:
LOGI("Writing into fifo.");
if (write(fifo_fd, data, count) < 0) {
    LOGE("Failed to write into fifo: %s", strerror(errno));
}

The non-blocking write works perfect.

On the other side, I open the FIFO for read and do the same fcntl() to make the read() non-blocking.

I now would like to make several (cpu-intensive) calculations on the write side, but ONLY if there is a reader attached.

Therefor I need to find a way on the write side, to detect if the FIFO is opended for read somewhere else.

Has anyone an idea how to achieve this?

Answer 1

I now would like to make several (cpu-intensive) calculations on the write side, but ONLY if there is a reader attached.

For that you can simply create a socket, and when a consumer connects to it, do some work and write back.
But I think a better solution is to have calculation results ready for consumers before they connect (or open FIFO). but you don’t want the producer working if work is not being consumed. So define N, number of work results you’re willing to keep available for consumption and let the producer (or producers) work and save results in a queue of size N until it’s full.
You could implement this with threads, one thread listens for connections, pops from the queue and writes to the consumer and one or more producer threads working and pushing to the queue.
Or you could use POSIX message queues to avoid threading headaches. Create a queue of size N, independent producers (multiple processes written in different languages) could push to the queue until its full, and multiple independent consumers pop from it.