how synchronization is done in shared memory data linux c

Can anyone tell if there is better way of synchronization in shared memory?

Definitely, yes. I would say the way you waste CPU cycles in busy-wait (while (ShmPTR->status != FILLED) ;) is already a fatal mistake.

Note that POSIX shared memory has a much more sensible interface than the old SysV does. See man 7 shm_overview for details.

There are two distinct purposes for synchronization primitives:

1. Data synchronization

   To protect data against concurrent modification, and to ensure each reader gets a consistent view of the data, there are three basic approaches:

   • Atomic access

     Atomic access requires hardware support, and is typically only supported for native machine word sized units (32 or 64 bits).
      

   • Mutexes and condition variables

     Mutexes are mutually exclusive locks. The idea is to grab the mutex before examining or modifying the value.

     Condition variables are basically unordered queues for threads or processes to wait for a "condition". POSIX pthreads library includes facilities for atomically releasing a mutex and waiting on a condition variable. This makes waiting for a dataset to change trivial to implement, if each modifier signals or broadcasts on the condition variable after each modification.
      

   • Read-write locks.

     An rwlock is a primitive that allows any number of concurrent "read locks", but only one "write lock" to be held on it at any time. The idea is that each reader grabs a read lock before examining the data, and each writer a write lock before modifying it. This works best when the data is more often examined than modified, and a mechanism for waiting for a change to occur is not needed.
      

2. Process synchronization

   There are situations where threads and processes should wait (block) until some event has occurred. There are two most common primitives used for this:

   • Semaphores

     A POSIX semaphore is basically an opaque nonnegative counter you initialize to whatever (zero or positive value, within the limits set by the implementation).

     sem_wait() checks the counter. If it is nonzero, it decrements the counter and continues execution. If the counter is zero, it blocks until another thread/process calls sem_post() on the counter.

     sem_post() increments the counter. It is one of the rare synchronization primitives you can use in a signal handler.
      

   • Barriers

     A barrier is a synchronization primitive that blocks until there is a specific number of threads or processes blocking in the barrier, then releases them all at once.

     Linux does not implement POSIX barriers (pthread_barrier_init(), pthread_barrier_wait(), pthread_barrier_destroy()), but you can easily achieve the same using a mutex, a counter (counting the number of additional processes needed to release all waiters), and a condition variable.
      

There are many better ways of implementing the said server-client pair (where shared memory contains a flag and some data).

For data integrity and change management, a mutex and one or two condition variables should be used. (If the server may change the data at any time, one condition variable (changed) suffices; if the server must wait until a client has read the data before modifying it, two are needed (changed and observed).)

Here is an example structure you could use to describe the shared memory segment:

#ifndef   SHARED_H
#define   SHARED_H
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

struct shared_data {
    /* Shared memory data */
};

struct shared {
    pthread_mutex_t     lock;
    pthread_cond_t      change;     /* Condition variable for clients waiting on data changes */
    pthread_cond_t      observe;    /* Condition variable for server waiting on data observations */
    unsigned long       changed;    /* Number of times data has been changed */
    unsigned long       observed;   /* Number of times current data has been observed */
    struct shared_data  data;
};

/* Return the size of 'struct shared', rounded up to a multiple of page size. */
static inline size_t  shared_size_page_aligned(void)
{
    size_t  page, size;
    page = (size_t)sysconf(_SC_PAGESIZE);
    size = sizeof (struct shared) + page - 1;
    return size - (size % page);
}

#endif /* SHARED_H */

The changed and observed fields are counters, that help avoid any time-of-check-to-time-of-use race windows. It is important that before the shared memory is accessed the thread does pthread_mutex_lock(&(shared_memory->lock)), to ensure a consistent view of the data.

If a thread/process examines the data, it should do

    shared_memory->observed++;
    pthread_cond_broadcast(&(shared_memory->observe));
    pthread_mutex_unlock(&(shared_memory->lock));

and if a thread/process modifies the data, it should do

    shared_memory->modified++;
    shared_memory->observed = 0;
    pthread_cond_broadcast(&(shared_memory->change));
    pthread_mutex_unlock(&(shared_memory->lock));

to notify any waiters and update the counters, when unlocking the mutex.