Qfyilyi

We have an application that consits on a CORE process that is connected with multiple processes (they are all children of the CORE process).

To exchange data, they use different shared memory areas. These areas are created like this:

fd_value = shm_open(shm_key, O_CREAT | O_RDWR | O_EXCL , S_IRWXU);

pshm = mmap(NULL, memory_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_value, 0);

And the different processes attach to these areas like this:

shm_fd = shm_open(shm_key, O_RDWR, S_IRWXU);

pshm = mmap(NULL, memory_size, PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);

This creates several descriptor files located in /dev/shm/

Currently, each process has a periodic timer. The process sleeps until the timer expires, then it wakes up, checks if there are new data in that shared memory area, and if not, it goes back to sleep in a infinite loop. If there is new data it performs some routines and again goes back to sleep.

However, this introduces a latency in the data transmitted as sometimes it occurs the data arrives right after the process has gone to sleep, so the data needs a whole period of the timer to be seen by the process and be processed.

We can always reduce the period (increase the frequency) but this increases the CPU usage a lot.

How could we implement a more optimal solution with some "polling" mechanism to poll the data written in the shared memory area so the process receives a signal every time new data is written rather than having to wake up periodically?

How would we need to configure the shared memory areas in order to achieve this?