because pipes aren't alwasy the most convenient/efficient mechanism
developed ~ early 1980s
predates Posix IPC, but same basic goals
predates rise of threading (next topic)
Message queue
like structured pipe: can handle higher-level prototocols
guaranty: no partial reads
Semaphores
protect against concurrent updates
more later (stay tuned)
Shared memory
System V Message Queues
int msgid = msgget(key_t key, int msgflg);
int msgsnd(int msgid, struct msgbuf *msgp, size_t msgsz, int msgflg);
struct msgbuf {
long mtype,
char mtext[]
};
C-style casting wizardry: superimpose msgbuf onto your own data structure.
mtype: use pattern matching on receive.
ssize_t msgrcv(
int msgid,
void * msgp, // pointer to user-allocated space
size_t msgsz,
long msgtype, // pattern matching: select message with this type
int msgflg
);
System V Semaphores
Semaphore (in real life): flag
flag up: resource available
flag down: wait for resource
Up/down (binary value): similar to mutex
Semaphores are more complicated: counter
decrement counter
if counter >0, get token
otherwise, no tokens available: wait until counter > 0
increment counter, release token
API:
int semid = semget(key_t key, int nsems, int semflag); // create/open semaphore set
int sem_op(
int semid,
struct sembuf *sops
unsigned nsops
);
struct sembuf {
unsignes short sem_num,
short sem_op, // >0: increment; < 0: decrement or wait; 0: wait for zero
short sem_flag // IPC_NOWAIT: return immediately (failure if counter is 0)
);
Shared Memory
process must explicitly request this
via system calls
handled by kernel memory management
memory map: data structure
2 virtual memory segments/pages mapped to same real memory (frame)
kernel is doing this mapping anyway
about the fastest you can do IPC: no double buffering
kernel datastructure: shmid_ds: similar to file structure (inode)
permissions
timestamps
size (#pages)
frames (array of pointers)
...
API:
#include <sys/ipc.h>
#include <sys/shm.h>
// create/access shared memory
int shmid = shmget(
key_t key,
size_t size,
int shmflg
);
shmid: small non-negative integer, like file descriptor (-1 for failure)
key_t: typedef for long
"identifier" -- like filename
must be shared across all processes wishing to share that piece of memory
ftok(3): take pathname & proj_id to generate key_t (hash)
shmflag: bitmapped flags
symbolic constants, ored together
owner/group/other permissions: like file
IPC_CREAT | IPC_EXCL
create if it doesn't exist & fail if it does
So we hae a shmid (descriptor), now what?
shmctl: get/set flags
shmat/shmdt: attach/detach
void* shmat(int shmid, const void *shmaddr, in t shmflg)
prefer: shmaddr = NULL
more portable
let system decide where to put it
Example flag: SHM_RDONLY
read-only segment
consumer in producer-consumer
subscriber in pub-sub
shmat returns void * pointer
can use like any other pointer in C
be careful to avoid scribbling over memory at the same time another process is scribbling
need synchronization mechanism to avoid clobbering data
cast to any meaningful type
pointer arithmetic (arrays)
be careful not to scribble outside the lines
Usage:
application requests ponter to block of n bytes (like malloc)
application must cast memory into appropriate data structures
applications must synchronize concurrent access
e.g. semaphore/mutex
Most common uses case: both processes execute same program
why not just use threads?
JVM: multiple programs in single VM session
multithreading
Sample code on slide (bad example)
spin lock (busy wait)
assumes count++/count-- is atomic (we'll revisit this)
mmap(2): map file to memory
alternative to read/write
kernel still needs to manage block I/O
Shared lilbraries .so (DLL in Windows)
all programs do I/O:
standard library: buffered & formatted
each process has "copy" of library
only need single copy in memory if all processes map virtual memory to same real memory
Dynamic linking: link at load time
that's why linking & loading are often conflated
Threads
Processes are protected against stomping/clobbering each other
separate memory spaces
hardware controls set by kernel
Kernel has total access to processes's address space
