Best communication method to thousand childs?

I am doing a project in which i have a father, that can have several children. From time to time i have to send a command to one of the children.

I can do this in several ways, but i want to learn a bit more, so i want to do it a way which is efficient, even if there are thousands of children.

Method 1: One pipe to each child. Very fast, but takes up resources (and seems to me limited to 510 pipes)

Method 2: Shared memory in which i place the child name. father unlocks a semaphore, and all children read from shared memory, the one that finds it's name in the memory segment executes the command also placed in the memory. Very low constant memory usage (only one shared memory segment), but a peak in memory usage because all the children will try to access the memory at the same time.

Method 3: One pipe to whom's exit is available to all the children. when father puts a message in the pipe it sends a signal to the child it is intended for, so that that child and only that one reads from the pipe. Very low constant memory usage, but i fear that if the messages are to many it slows down the computer because of to many signals beeing sent(my interpretation of signals is that they almost freeze to computer, so sending the in rapid succession takes up lot's of resources).

I am mostly divided between Method 1 and 3. It seems 1 is better if there are many commands, while 3 is better for larger number of children and not so many commands.

I would like opinions, as to my conclusions are correct or not, and which method you would use if there were thousands of children .

Thank You

I would guess a combination of both method 1 and 3. I don't know to give exact numbers, but if lets say 20 pipes isn't consider a lot of resourses, then you can use 20 pipes and give every 50 children a pipe. All or nothing wouldn't be the best option

IMO, if you've got that many child processes, you've got bigger things to worry about.

It's called "Re-arranging the deck chairs on the Titanic".

What do you mean?

In my pc it creates about 8000 children. It's slow but it works.

But the point of this, is what would be more efficient for larger numbers, and with a lot more powerful computer.

You could just use signals. kill() can send a signal to an individual process ID or process group ID.

gg

the problem is that signals are slow , because they generate interrupts. if i had to send many commands i would slow down a lot.

Signals require less resources than pipes and if I am not mistaken they are not any slower than pipes.

the use of signals is good because they dont take up any resources like a pipe when it is not beiing used.
but the problem is that a signal generates an interrupt. it halts current execution, variables have to be saved, and execution jumps to signal handler and etc . that is why i think that sending a message via a pipe is faster them sending and handling a signal

http://www.linuxjournal.com/article/3985

Signals aren't as slow as you think they are.

gg