Home/ Questions/Q 6796329
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-26T18:27:15+00:00

I’m writing a basic UNIX program that involves processes sending messages to each other.

  • 0

I’m writing a basic UNIX program that involves processes sending messages to each other. My idea to synchronize the processes is to simply have an array of flags to indicate whether or not a process has reached a certain point in the code.

For example, I want all the processes to wait until they’ve all been created. I also want them to wait until they’ve all finished sending messages to each other before they begin reading their pipes.

I’m aware that a process performs a copy-on-write operation when it writes to a previously defined variable.

What I’m wondering is, if I make an array of flags, will the pointer to that array be copied, or will the entire array be copied (thus making my idea useless).

I’d also like any tips on inter-process communication and process synchronization.

EDIT: The processes are writing to each other process’ pipe. Each process will send the following information:

typedef struct MessageCDT{
    pid_t destination;
    pid_t source;
    int num;
} Message;

So, just the source of the message and some random number. Then each process will print out the message to stdout: Something along the lines of “process 20 received 5724244 from process 3”.

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    Unix processes have independent address spaces. This means that the memory in one is totally separate from the memory in another. When you call fork(), you get a new copy of the process. Immediately on return from fork(), the only thing different between the two processes is fork()’s return value. All of the data in the two processes are the same, but they are copies. Updating memory in one cannot be known by the other, unless you take steps to share the memory.

    There are many choices for interprocess communication (IPC) in Unix, including shared memory, semaphores, pipes (named and unnamed), sockets, message queues and signals. If you Google these things you will find lots to read.

    In your particular case, trying to make several processes wait until they all reach a certain point, I might use a semaphore or shared memory, depending on whether there is some master process that started them all or not.

    If there is a master process that launches the others, then the master could setup the semaphore with a count equal to the number of processes to synchronize and then launch them. Each child could then decrement the semaphore value and wait for the semaphore value to reach zero.

    If there is no master process, then I might create a shared memory segment that contains a count of processes and a flag for each process. But when you have two or more processes using shared memory, then you also need some kind of locking mechanism (probably a semaphore again) to ensure that two processes do not try to update the shared memory simultaneously.

    Keep in mind that reading a pipe that nobody is writing to will block the reader until data appears. I don’t know what your processes do, but perhaps that is synchronization enough? One other thing to consider if you have multiple processes writing to a given pipe, their data may become interleaved if the writes are larger than PIPE_BUF. The value and location of this macro are system dependent.

    -Kevin

    • 0