Home/ Questions/Q 3352792
In Process

The Archive Base Latest Questions

Editorial Team
  • 0
Asked: 2026-05-18T02:04:23+00:00

I was implementing some simple Producer/Consumer program that had some semaphores and shared memory.

  • 0

I was implementing some simple Producer/Consumer program that had some semaphores and shared memory. To keep things simple, let’s assume that there’s just a block of shared memory and a semaphore in my program.

At first, I though that I only had to consider as critical section bits of code that’d try to write to the shared memory block. But as the shared memory block consists of, let’s say, 1024bytes, I can’t read all the data at the same time (it’s not an atomic operation), so it is indeed possible that while I’m reading from it, the Producer comes and starts writing in it, so the reader will get half old data, half new data. From this, I can only think that I also have to put shared memory reading logic inside a “semaphore” block.

Now, I have lots of code that looks like this:

if (sharedMemory[0] == '0') { ... }

In this case, I am just looking for a single char in memory. I guess I don’t have to worry about puting a semaphore around this, do I?

And what if instead I have something like

if (sharedMemory[0] == '0' && sharedMemory[1] == '1') { ... }

From my perspective, I guess that as this are 2 operations, I’d have to consider this as a critical section, thus having to put a semaphore around it. Am I right?

Thanks!

Share

Leave an answer

You must login to add an answer.

Need An Account,

1 Answer

  1. Editorial Team

    Technically, on a multicore or multiprocessor system the only thing that’s atomic are assembly opcodes which are specifically documented as being atomic. Even reading a single byte presents a (quite small) chance the another processor will come along and modify it before you’re doing reading it, except in some cases that deals with CPU cache and aligned chunks of memory (Fun thread: http://software.intel.com/en-us/forums/showthread.php?t=76744, Interesting read: http://www.corensic.com/CorensicBlog/tabid/101/EntryId/8/Memory-Consistency-Models.aspx)

    You must either use types which internally guarantee atomicity or specifically protect accesses on multithreaded multicore systems.

    (The answer may change slightly on IL platforms like .NET and JVMs since they make their own guarantees about what’s atomic and what isn’t).

    • 0