MMAN | Micro Adversarial Network for Human | Machine Learning library

gcc -Wall -Wextra -ggdb3 -shared mem.c -O3 -o my_mem.so

is wrong, if you want to build a shared library. See dlopen(3) and elf(5) and ld.so(8).

You practically need a position-independent-code file, so use

To link a target with a library, use target_link_libraries. You would:

In short, you cannot get a guarantee that your shared memory object will be of precisely the size you ask ftruncate to be. That's because, as @user3386109 said, "The portion of the POSIX spec that you quoted starts with "If fildes refers to a regular file"".

If you want to constrain yourself to an arbitrary length, you can always use an auxiliary variable to keep track of the size you assume it to be (even if the actual size might actually differ, which may not be that important after all). Your code would look like:

Two main bugs:

• When calling sigaction, you have to set the SA_SIGINFO flag in act.sa_flags in order to have the second argument passed to your signal handler. As it stands that field is just uninitialized.

• mprotect requires that its addr argument be page aligned. (This will also require you to recompute the len argument accordingly to ensure the desired region is covered.) As a quick-and-dirty example, assuming the page size is 4096, you can mask off the corresponding low bits by ANDing with the bitwise complement of 4095.

[...] after the first client gets killed (e.g. using CTRL+C) while waiting for the broadcast, the server sometimes gets stuck in pthread_cond_broadcast [...]

Why?

Because killing the process may leave the CV and / or mutex in an inconsistent state. The same general thing can happen when one thread of a multithreaded process is forcibly killed, or when a multithreaded process forks. Indeed, given that the b processes spend most of their time waiting on the CV, it is pretty likely that they leave that inconsistent when they get terminated by a signal.

And how should this be done correctly?

To prevent the CV becoming inconsistent under such circumstances, you should ensure -- to the extent that it is possible -- that the b processes do not terminate while waiting on the CV. To protect them against that happening as a result of receiving a signal, set up a handler for the signal that raises a flag (of type sig_atomic_t). The process would then checks that flag after returning from the wait to determine whether it needs to terminate. Conceivably, you could also broadcast to the CV to ensure that the process proceeds with the termination as soon as possible.

Do note, however, that some signals cannot be caught or blocked, and the above approach cannot do anything about those. Some other signals can be caught, but obligate the handler to terminate the program to avoid undefined behavior, and the above approach doesn't help with those, either.

Additionally, there are other issues with your code, including

• you do not check the return values of your function calls, apparently assuming that they always succeed.

• you seem to have completely the wrong idea about the semantics of pthread_mutex_consistent():

  1. It is applicable only to robust mutexes, which yours are not configured to be.
  2. It is appropriate to call that function only after pthread_mutex_lock() indicates via its return value that the mutex is inconsistent, and after taking any action necessary to make program state guarded by the mutex consistent.
  3. Contrary to your claim in the comments, pthread_mutex_consistent() does not unlock the mutex. It just marks the mutex as having been returned to consistency. The mutex must still be unlocked before other threads can acquire it.
  4. Only the first thread / process to lock the mutex after it becomes inconsistent has the opportunity to make it consistent again. Thus, if you want to use a robust mutex in the example program then the a and b processes will both need to be prepared to handle inconsistent mutexes, and that at each point where they acquire the mutex.
  5. And since one place the b processes acquire the mutex is inside pthread_cond_wait(), and it does not have a documented mechanism to report on that event, robust mutexes probably are not a viable option for you.

You want MAP_PRIVATE flag to mmap. It is defined as following:

MAP_PRIVATE: Create a private copy-on-write mapping. Updates to the mapping are not visible to other processes mapping the same file, and are not carried through to the underlying file. It is unspecified whether changes made to the file after the mmap() call are visible in the mapped region.

This means that you'll get the file, but the first time you change the file, it will create a private copy just for you. All changes will go to this copy, and will disappear once program exits.

Change

Your code with the cast is correct and neccessary.

Each process has its own virtual memory address space. The mappings from virtual memory to physical memory are, in general, different for each process. While the shared memory may be in physical memory at address 0x1000, the producer process may have it mapped into virtual memory at address 0x7000, and the consumer process may have it mapped into virtual memory at address 0x4000.

Further, if the shared memory is swapped out of memory for some reason, the system could later reload it to a different physical address, say 0x13000, and update the mappings in the processes so that it appears at the same addresses as before in each of the producer and consumer processes.