Cheers. I am given a text file e.g. of 10 lines, which is segmented. For example, we have 5 segments each containing 2 lines inside them (e.g. segment 1 loads lines 1 and 2, segment 2 loads lines 3 and 4, and so on...) .

I want to be able to spawn children processes which randomly select a segment and retrieve it SYNCHRONIZED. To be able to make that connection between the parent and child processes I must use shared memory. So I fork() for the children, which select a segment which is then requested to the parent processes which acts like a server, getting requests and placing the requested segment into shared memory to be then read by the children. My goal is to synchronize the following problem.

For the purposes of the exercise I am asked to use semaphores to achieve the FIFO line of recall. So when a process is blocked, it is saved in a QUEUE inside the semaphore, and when the semaphore is then "signaled", it unblocks the first blocked process.

I am aware that I am looking at a variation of the one writer / multiple readers problem. However, I find it very difficult to continue and can't find how to place semaphores in a way such as to achieve the desired result. I also know that I must use a array of semaphores, one for each segment. I have wrote some C code, but I am missing the main synchronization scheme implementation to achieve the above.

Here is some C-style pseudocode of what I have so far.

I don't know I am going to be able to keep the information as of which segment is the next one to be unblocked. E.g. if I am serving segment 1 and a request for 3,4,4 come in, how when I am done with 1, I will switch to 3 (as it came first), and when I am done with it, I am going to unblock both requests needing 4. Also since we know which segment is first and last, I think these should be responsible for the communication with the parent/server.

Any help/hint would be greatly appreciated, as I feel like I have stuck a wall.

And I feel you have forgotten your previous question.

1 members found this post helpful.

Hi! Well no, because now I am informed I have to do the FIFO management of the processes via semaphores, so I will not be explicitly using a FIFO queue created by me, but a one created indirectly via semaphores.

You could quote the actual text of your homework instead of your interpretation.

Hi again. This is what I have done. I have translated and quoted the actual text as I was given it, in the 3rd paragraph. I have just not placed in quotes.

You can still edit your post and add the quotation marks.

@gzorp: I think the point being made is that you never responded to those who provided helpful replies in your other thread but simply abandoned it, and them. Please be respectful of the time that others put into reading your questions and sharing their knowledge - sharing is an interactive process!

And, per the LQ Rules, please do not post homework assignments verbatim. We're happy to assist if you have specific questions or have hit a stumbling point, however. Let us know what you've already tried and what references you have used (including class notes, books, and Google searches) and we'll do our best to help. Also, keep in mind that your instructor might also be an LQ member.

1 members found this post helpful.

Why do you think this? Is this from part of the assignment that you haven't posted here?

It's been quoted on the 4th paragraph of my question. It's an instruction given by my professor.

Both third and fourth paragraphs in OP look like your own ideas, not the authentic source.

Thanks for your answer. I did not abandon the thread. I had a question for which some useful ideas were provided, but it does not apply to what I now want to achieve now, that's why it is a separate question. Since my approach changed, I cannot report anything new to the old answer since I will no longer work on it. Also, what constitutes "homework"? I had a question about a given task, which I did my due diligence for, I know my theory, but I have hit a stumbling point as you say. One thing I have learned to do as a junior computer scientist is ask questions about things when I can't overcome a problem. I never asked for an answer given on a silver platter. I just wanted a hint or an idea/some pseudocode on how to approach it, and get unstuck. So I think even if my professor is also a LQ member, I haven't made any mistake I should be condemned for. I will keep your suggestions in mind.

Okay, the reason I asked about it is if you read e.g., https://manned.org/sem_post.3p you'll see that semaphores don't always guarantee FIFO ordering. So I wonder if you could have misunderstood your professor's instructions.

Are the fields in struct shared also given in the instructions? It seems like you could just use the counter of the semaphore itself (sem_getvalue()), so most of the fields except for array_of_semaphores and data wouldn't be needed.

I would suggest adding an exit() at the end of childProcess(), otherwise you will get a lot of unexpected grandchild processes. Also, I don't think it makes any sense to have requestBuffer be in shared memory (because that would prevent you from handling more than one request at a time).

Yeah I think this is a key point. You need to actually implement a FIFO queue. And then, and only then, you use the semaphores to prevent race conditions.

... and if you can use C++, these things have already been built and perfected for(!) you. You can grab a "FIFO queue" right off the shelf. Most other things, too. The implementations are just as efficient but the human-labor is considerably less. "Do not do a thing already done."

Also always bear in mind the underlying hardware, which is getting and servicing all of the requests coming from everywhere. If the device is "SSD" then this is much less of a problem because "it's really memory," but if the device is rotating there are now mechanical considerations. (Also, [virtual] memory considerations.) If you exceed the physical ability of the hardware, you will probably create a "sophisticated" process that is actually much slower(!) than a simpler one: "dozens of threads, all stuck in traffic on a two-lane road behind a drawbridge."

"Asynchronous message-passing" often turns out to be more efficient (and, more scalable) than "shared memory." Only one process receives requests for information, and sends the information back in a reply. It uses a (non-shared) memory segment as a buffer, or simply relies upon the filesystem to do so. It issues asynchronous requests for data to be retrieved from backing storage, and is notified when each of these requests complete. Only this one process knows – or, needs to know – the full picture.

And, guess what: there are already libraries out there which do all of this, in various languages. Check places like "github" and "sourceforge" and search them very carefully before you set out to write anything "new." (Because, it undoubtedly isn't.)

I think your professor is not doing you any favors by having you take the wrong approach.

The problem is easily solved by writing a multithreaded program. With threads, memory is shared by default. Synchronization becomes easy.

Of course, if you did that, you will likely receive an "F" for not following instructions even if the solution was technically superior.
Ed