10-24-2001
Only one process (at a time) may have an open file descriptor for a shared memory segment. The interprocess communication that is used to insure proper file access is the semaphore.
When a semaphore is used correctly (and it can be tricky!) the problem with shared memory segmentation error will be solved (more than likely, unless you have a pointer or other C programming error).
Here is a basic algorithm:
[list=1][*]Create a shared memory segment.[*]Create a semaphore.[*]Process A acquires the semaphore used for the shared memory segment.[*]Process A opens the shared memory.[*]Process A does cool things with shared memory.[*]Process A closed the shared memory segment.[*]Process A releases the semaphore.[*]Process B has been waiting for the semaphore to be released.[*]Now that semaphore has been released......[*]Process B acquires the semaphore used for the shared memory segment.[*]Process B opens the shared memory.[*]Process B does cool things with shared memory.[*]Process B closed the shared memory segment.[*]Process B releases the semaphore.[/list=1]
Yadda, yadda, yadda....... does this help?
10 More Discussions You Might Find Interesting
1. UNIX for Advanced & Expert Users
I am running HP-UX B.11.11.
I'm increasing a parameter for a database engine so that it uses more memory to buffer the disk drive (to speed up performance). I have over 5GB of memory not being used.
But when I try to start the DB with the increased buffer parameter I get told.
"Not... (1 Reply)
Discussion started by: cjcamaro
1 Replies
2. Linux
Hi all :confused: ,
I am new to unix.I have been asked to implement shared memory in user's mode.What does this mean?What is the difference it makes in kernel mode and in users mode?What are the advantages of this impemenation(user's mode)?
And also i would like to know why exactly shared... (0 Replies)
Discussion started by: vijaya2006
0 Replies
3. Programming
hi all
I have been asked to implement shared memory in user mode?But :rolleyes: im not understanding how to do this.And what does it mean in user mode?Is it that we need to simulate what kernal does...like attaching ,detaching memory..etc...?
And would also like to know why shared memory is... (3 Replies)
Discussion started by: vijaya2006
3 Replies
4. Programming
what i want to do is have an int that can been written into by 2 processes but my code doesn't seem to work.
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <sys/shm.h>
#include<stdio.h>
#define KEY1 (1492)
int main()
{
int shmid;
volatile int * addr;... (6 Replies)
Discussion started by: ddx08
6 Replies
5. Programming
hi,
this is the problem: i want to swap a linked list between 4 processes (unrelated), is there any way i can do that just by sending a pointer to a structure?
//example
typedef struct node
{
int x;
char c;
struct node *next;
} node;
or i should send the items ( x,c ) by... (9 Replies)
Discussion started by: elzalem
9 Replies
6. Programming
I need to create a shared library to access an in memory DB. The DB is not huge, but big enough to make it cumbersome to carry around in every single process using the shared library. Luckily, it is pretty static information, so I don't need to worry much about synchronizing the data between... (12 Replies)
Discussion started by: DreamWarrior
12 Replies
7. Programming
I am writing a shared library in Linux (but compatible with other UNIXes) and I want to allow multiple instances to share a piece of memory -- 1 byte is enough. What's the "best" way to do this? I want to optimize for speed and portability.
Obviously, I'll have to worry about mutual exclusion. (0 Replies)
Discussion started by: otheus
0 Replies
8. UNIX for Advanced & Expert Users
Hi,
Using ipcs we can see shared memory, etc.. details. How can I add/remove shared memory(command name)?
Thanks,
Naga:cool: (2 Replies)
Discussion started by: Nagapandi
2 Replies
9. AIX
1.How to know wich process is using the shared memory?
2.How to flush (release) the process from the shared memory? (1 Reply)
Discussion started by: pchangba
1 Replies
10. Programming
Hello.
I am new to this forum and I would like to ask for advice about low level POSIX programming.
I have to implement a POSIX compliant C shared library.
A file will have some variables and the shared library will have some functions which need those variables.
There is one special... (5 Replies)
Discussion started by: iamjag
5 Replies
LEARN ABOUT LINUX
sem_overview
SEM_OVERVIEW(7) Linux Programmer's Manual SEM_OVERVIEW(7)
NAME
sem_overview - Overview of POSIX semaphores
DESCRIPTION
POSIX semaphores allow processes and threads to synchronize their actions.
A semaphore is an integer whose value is never allowed to fall below zero. Two operations can be performed on semaphores: increment the
semaphore value by one (sem_post(3)); and decrement the semaphore value by one (sem_wait(3)). If the value of a semaphore is currently
zero, then a sem_wait(3) operation will block until the value becomes greater than zero.
POSIX semaphores come in two forms: named semaphores and unnamed semaphores.
Named semaphores
A named semaphore is identified by a name of the form /somename; that is, a null-terminated string of up to NAME_MAX-4 (i.e., 251)
characters consisting of an initial slash, followed by one or more characters, none of which are slashes. Two processes can operate
on the same named semaphore by passing the same name to sem_open(3).
The sem_open(3) function creates a new named semaphore or opens an existing named semaphore. After the semaphore has been opened,
it can be operated on using sem_post(3) and sem_wait(3). When a process has finished using the semaphore, it can use sem_close(3)
to close the semaphore. When all processes have finished using the semaphore, it can be removed from the system using
sem_unlink(3).
Unnamed semaphores (memory-based semaphores)
An unnamed semaphore does not have a name. Instead the semaphore is placed in a region of memory that is shared between multiple
threads (a thread-shared semaphore) or processes (a process-shared semaphore). A thread-shared semaphore is placed in an area of
memory shared between by the threads of a process, for example, a global variable. A process-shared semaphore must be placed in a
shared memory region (e.g., a System V shared memory segment created using shmget(2), or a POSIX shared memory object built created
using shm_open(3)).
Before being used, an unnamed semaphore must be initialized using sem_init(3). It can then be operated on using sem_post(3) and
sem_wait(3). When the semaphore is no longer required, and before the memory in which it is located is deallocated, the semaphore
should be destroyed using sem_destroy(3).
The remainder of this section describes some specific details of the Linux implementation of POSIX semaphores.
Versions
Prior to kernel 2.6, Linux only supported unnamed, thread-shared semaphores. On a system with Linux 2.6 and a glibc that provides the NPTL
threading implementation, a complete implementation of POSIX semaphores is provided.
Persistence
POSIX named semaphores have kernel persistence: if not removed by sem_unlink(3), a semaphore will exist until the system is shut down.
Linking
Programs using the POSIX semaphores API must be compiled with cc -lrt to link against the real-time library, librt.
Accessing named semaphores via the file system
On Linux, named semaphores are created in a virtual file system, normally mounted under /dev/shm, with names of the form sem.somename.
(This is the reason that semaphore names are limited to NAME_MAX-4 rather than NAME_MAX characters.)
Since Linux 2.6.19, ACLs can be placed on files under this directory, to control object permissions on a per-user and per-group basis.
CONFORMING TO
POSIX.1-2001.
NOTES
System V semaphores (semget(2), semop(2), etc.) are an older semaphore API. POSIX semaphores provide a simpler, and better designed inter-
face than System V semaphores; on the other hand POSIX semaphores are less widely available (especially on older systems) than System V
semaphores.
EXAMPLE
An example of the use of various POSIX semaphore functions is shown in sem_wait(3).
SEE ALSO
sem_close(3), sem_destroy(3), sem_getvalue(3), sem_init(3), sem_open(3), sem_post(3), sem_unlink(3), sem_wait(3), pthreads(7)
COLOPHON
This page is part of release 3.27 of the Linux man-pages project. A description of the project, and information about reporting bugs, can
be found at http://www.kernel.org/doc/man-pages/.
Linux 2010-05-22 SEM_OVERVIEW(7)