Semaphore: synchronization mechanismMessage queues: message-based communicationShared memory: communication through a common memory regionIPC
persistent structures in the operating system
operating system imposes limits for the size and number of IPCs
if not cleanup up properly, the system will refuse to allow the creation of new IPCs
ipcs: see all existing IPCs
ipcrm: delete an IPC using command , as long as you have permissions on that IPC
**> ipcs**
------ Message Queues --------
key msqid owner perms used-bytes messages
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x58df7f12 0 rares 644 100 0
------ Semaphore Arrays --------
key semid owner perms nsems
**> ipcrm -M 0x58df7f12**
Shared memory API
shmget: create or get a handle to an existing shared memory segmentshmat: attach - map the shared memory segment to a pointer in your processshmdt: detach - unmap the shared memory segment from you pointershmctl: control (configure, delete, etc.) the shared memory segmentExamples
/*
Implement two programs that communicate through a shared memory segment
containing four integers: a, b, s, and p.
The first program set a and b to some values,
and the second sets s to the a+b and p to a*b;
*/
// header.h
struct absp {
int a;
int b;
int s;
int p;
};
//Program A
#include "header.h"
int main() {
int shmid, k = 0;
struct absp *x;
shmid = shmget(1234, sizeof(struct absp), IPC_CREAT | 0600);
x = shmat(shmid, 0, 0);
while(1) {
x->a = k++ % 100;
x->b = k++ % 100;
if(x->p == x->s) {
break;
}
}
shmdt(x);
shmctl(shmid, IPC_RMID, NULL);
return 0;
}
// Program B
#include "header.h"
int main() {
int shmid;
struct absp *x;
shmid = shmget(1234, 0, 0);
x = shmat(shmid, 0, 0);
while(1) {
x->s = x->a + x->b;
x->p = x->a * x->b;
if(x->p == x->s) {
break;
}
}
shmdt(x);
return 0;
}
/*
a. The programs above will not function in any way close to what we want,
because we have no mechanisms to ensure they work on the shared memory in turns.
Instead, they work ignoring the presence of the other.
b. If the two programs are started manually one by one,
it is likely that program A deletes the shared memory before B is done with it,
resulting in errors.
This can happen if A finds p and s being equal simply because
their value happens to be zero, and then breaks from the loop
and deletes the shared memory.
c. So, shared memory without synchronization mechanisms is guaranteed
to cause trouble.
*/
Threads
POSIX threads (Pthreads)
native threads implementation in Linux, but every modern operating system provides thread creation libraries
/*
Basic thread creation example, using the Pthreads library.
*/
#include <stdio.h>
#include <pthread.h>
void* f(void* a) {
printf("f\\n");
return NULL;
}
int main(int argc, char** argv) {
pthread_t t;
pthread_create(&t, NULL, f, NULL);
printf("main\\n");
pthread_join(t, NULL);
return 0;
}
/*
a. A thread always executes a given function, in our case f().
b. The Pthread library requires the thread function to have a specific
signature. It should have a single void* argument and it should return void*.
c. The call to pthread_create creates and starts a thread
that executes the given function pointer f, and populates the thread handler t.
d. The second argument to pthread_create is a pointer to pthread_attr_t
which controls various aspects of the thread creation and execution.
In our case, by setting it to NULL, we use the default settings.
e. The fourth argument to pthread_create is the argument
to be passed to the function f().
In our case, f() doesn’t use its argument, so we pass NULL.
f. The call to pthread_join waits for the thread identified by the handle t
to finish.
g. The second argument to pthread_join will contain the value
returned by function f().
Passing it as NULL means we do not need this value, so we ignore it.
h. To compile a program that uses Pthreads,
you need to either pass the -pthread argument to gcc, or to tell it
to use the Pthreads library, which you can do passing the -lpthread argument.
gcc -Wall -g -o a a.c -pthread or gcc -Wall -g -o a a.c -lpthread
i. The output of this program depends on how the operating system schedules
the execution of these threads, consequently we may see the two printf-ed
values displayed in any order.
This is essential to understanding how concurrency works.
*/
#include <stdio.h>
#include <pthread.h>
int n = 1;
void* fa(void* a) {
int i;
for(i=0; i<n; i++) {
printf("fa\\n");
}
return NULL;
}
void* fb(void* a) {
int i;
for(i=0; i<n; i++) {
printf("fb\\n");
}
return NULL;
}
int main(int argc, char** argv) {
int i;
pthread_t ta, tb;
if(argc > 1) {
sscanf(argv[1], "%d", &n);
}
pthread_create(&ta, NULL, fa, NULL);
pthread_create(&tb, NULL, fb, NULL);
for(i=0; i<n; i++) {
printf("main\\n");
}
pthread_join(ta, NULL);
pthread_join(tb, NULL);
return 0;
}
/*
We now have two thread functions that is each run in a separate thread
b. The command line argument specifies how many iterations each thread will do.
Notice that each thread has access to the global variables.
c. To show the thread scheduling without having long printouts,
we pipe the output of the program through uniq -c
without sorting the out first, thus displaying how many iterations
each thread did before the scheduler switched to another.
*/