Jan Kończak

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
===== Yet another reason that makes concurrent programming harder. =====

Below, there is a piece of code that can be compiled by issuing:
<code bash>gcc -g -O0 sb.c -o sb</code>

The program forks and uses shared memory, so concurrency is involved.
\\
__Analyze the code and tell which results can be output.__
\\
Remember that newly allocated anonymous shared memory is always zeroed. 

Run the program multiple times with the following command, and observe the results:
<code bash>( for((i=0;i<10000;++i)); do ./sb; done ) | sort | uniq -c</code>

Finally, explain the results.

<html><div style="line-height:1em"></html>
<code c sb.c>
#include <unistd.h>
#include <sys/mman.h>
#include <stdatomic.h>
#include <stdio.h>

struct data {
    atomic_char vA, vB, control[3];
    volatile char data[64*3];
};

int main(){
    struct data * const s = mmap(NULL, sizeof(struct data),
                                 PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
    
    atomic_char * const control = s->control;
    volatile char * const a = s->data + 64;
    volatile char * const b = s->data + 64*2;
    
    volatile char dummy = s->vA + s->vB + *a + *b;
    
    if(!fork()){
        
        control[0]++;
        while(control[0]!=2);
        
        *b = 1;
        //while(--dummy);
        s->vA = *a;
        
        control[1]=1;
        return 0;
        
    } else {
    
        control[0]++;
        while(control[0]!=2);
        
        *a = 1;
        s->vB = *b;
        
        while(control[1]!=1);
        
        printf("%d %d\n",s->vA, s->vB);
        return 0;
    }
}
</code>
<html></div></html>


~~META:
language = en
~~