Voir la source de 20150119:TP:C:Fork:EN

[[category:EPITA:TP:20142015]]
== Introduction ==

The purpose of this session is to introduce <tt>fork(2)</tt> and <tt>wait(2)</tt> by a series of examples.

== Simple fork ==

=== Make it work ===

* '''Here is a simple example of code, headers have been removed, use manual pages to find them:'''

<source lang="C">
// basic_fork.c: simple example of fork

/*
 * MESSAGE is a simple wrapper around printf so that printf call display the
 * PID in front of the message
 * Must have at least 2 arguments, NULL can be used for the empty case
 */
# define MESSAGE(fmt_, args...) printf("(%u): " fmt_, getpid(), args);

int main() {
  int           fork_ret, x = 0;
  fork_ret = fork();
  if (fork_ret == -1)
    err(1, "Fork failed");
  if (fork_ret) {
    MESSAGE("Inside parent\n", NULL);
    MESSAGE("Initial x: %d\n", x);
    x = -42;
  } else {
    MESSAGE("Inside child\n", NULL);
    MESSAGE("Initial x: %d\n", x);
    x = 42;
  }
  MESSAGE("parent id: %u\n", getppid());
  MESSAGE("new x:%d\n", x);
  return 0;
}
</source>

Run the code several time and observe the output.

=== Write your own ===

The purpose of this exercise is to launch two different algoritms on the same
data using <tt>fork(2)</tt>.

Here is the base code:

<source lang="C">
# define MESSAGE(fmt_, args...) printf("(%u): " fmt_, getpid(), args);

void random_fill(int tab[], size_t len) {
  for (int *cur = tab; cur != tab + len; ++cur)
    *cur = random() % 1024;
}

void swap(int *a, int *b) {
  int           c = *a;
  *a = *b;
  *b = c;
}

void sort01(int tab[], size_t len) {
  for (size_t i = 0; i < len; ++i) {
    size_t      min = i;
    for (size_t j = i + 1; j < len; ++j)
      if (tab[j] < tab[min]) min = j;
    swap(tab + i, tab + min);
  }
}

void sort02(int tab[], size_t len) {
  int           move = 1;
  for (size_t i = 0; i < len && move; ++i) {
    move = 0;
    for (size_t j = 0; j < len - i - 1; ++j) {
      if (tab[j] > tab[j + 1]) {
        move = 1;
        swap(tab + j, tab + j + 1);
      }
    }
  }
}

int is_sorted(int tab[], size_t len) {
  size_t        j;
  for (j = 1; j < len && tab[j - 1] <= tab[j]; ++j) {}
  return j == len;
}
</source>

Your goal is to write a program that:

* fill an array of random integers (using the function <tt>random_fill()</tt>.)
* fork:
** the parent runs the algoritm <tt>sort01</tt> on the array
** the child runs the algoritm <tt>sort02</tt> on the array
* both processes (child and parent) verify the sorted array with (<tt>is_sorted</tt>) and write a message using (<tt>MESSAGE</tt>.)

* '''Write the full program, compile it an run it.'''
* '''Bonus question: name the algoritms <tt>sort01</tt> and <tt>sort02</tt>'''

== Waiting and time measure ==

We now want to run the previous algoritms (<tt>sort01</tt> and <tt>sort02</tt>) and do some time measures.

=== Running and waiting ===

Our first step is to write the program that will fork and run the two algorithms. The program will follow this schema:

* Fill an array of random integers
* Do a first fork:
** the child runs <tt>sort01</tt>
** the parent wait (using <tt>wait(2)</tt>) for the death of its child
* Do a second fork:
** the child runs <tt>sort02</tt>
** the parent wait (using <tt>wait(2)</tt>) for the death of its child

=== Wall Clock Time ===

You'll need <tt>clock_gettime(2)</tt> to do time measures: we get the time before the fork and after the wait, the difference will give you the time of execution of the child (and thus the execution time of the algorithms.) To ensure a correct time measure, you'll need the option <tt>CLOCK_MONOTONIC</tt>.

=== CPU and system time ===

In order to get more advanced time information, we need to get access to the <tt>rusage</tt> data structure corresponding to the child. For that, you need to replace <tt>wait(2)</tt> with <tt>wait3(2)</tt>.

=== The program ===

You can now write the main program. This program will display the execution time of each algorithm.