mjhjmtu

We're implementing an embedded Linux system and have to provide a live updating graph on a website that shows data coming from a background process in the system.

The question is how to optimally share data between:

1. The data generating process that regularly updates a ring buffer with new values, written in C.




2. The webserver CGI function that must fetch the latest contents of the buffer. We use Python for CGI's (nginx+wsgi+flask).

I currently lean towards making a unix socket solution for this, but I gather this would require multithreading in the C program to make sure the background process isn't disturbed.

I wonder if there isn't a simpler way. Could we map the buffer memory directly to be a virtual file? What about using a normal file on a RAM disk as the buffer and just seeking and writing to it?

Simple solution using files and atomic rename which can be easily implemented using scripting languages.

Sender

• write data into file A
  


• rename file A to B
  

The rename is atomic, and it can be done while the receiver is processing the old file.

The sender will not block if the receiver does not read the data.

Receiver

1. 
   

   If it is no problem to process the same data twice:

   
   
   
   • open file B
     
   
   
   • read data
   
   
   • close file
   
   

   This option also works when there is more than one receiver, e.g. multiple CGI processes of the web server.

   
   


2. 
   

   If the receiver should not process the same data twice:

   
   
   
   • rename file B to C
     
   
   
   • if successful, read and process file C
     
   
   
   • optionally delete file C
     
   
   

   This option works with a single receiver only.

   
   

In both cases old data will be lost if the sender writes data faster than the receiver can read it.

Of course there are other options.