Voir la source de 20150126:TP:C:Times:EN

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

Our goal is now to use <tt>execvp</tt> to run programs from our C code.

== Replacing our Program ==

* '''Write the program <tt>runls.c</tt> that replace itself with the command <tt>ls -l</tt>'''

== Running any command ==

=== Simple replacement ===

We now want to run any command, the idea is to use the <tt>argv</tt> array of
our program. We want the following behavior:

<pre>
> make runcmd
clang -Wall -Wextra -std=c99 -O3    runcmd.c   -o runcmd
> ./runcmd
runcmd: Need a command
> ./runcmd ls
>>> running command <<<
	ls
Makefile  foo.c  forkexec.c  mytime.c  runcmd  runcmd.c  runls.c
> ./runcmd ls -l
>>> running command <<<
	ls -l
total 32
-rw-r--r-- 1 feanor feanor  118 19 janv. 18:52 Makefile
-rw-r--r-- 1 feanor feanor   87 19 janv. 19:32 foo.c
-rw-r--r-- 1 feanor feanor  367 19 janv. 18:55 forkexec.c
-rw-r--r-- 1 feanor feanor 1489 19 janv. 19:44 mytime.c
-rwxr-xr-x 1 feanor feanor 7723 22 janv. 09:01 runcmd
-rw-r--r-- 1 feanor feanor  479 19 janv. 19:25 runcmd.c
-rw-r--r-- 1 feanor feanor  219 19 janv. 18:52 runls.c
> ./runcmd cat foo.c
>>> running command <<<
	cat foo.c
# include <stdlib.h>

int main() {
  int           *p = NULL;
  *p = 42;
  return 0;
}
>
</pre>

* '''Write the program <tt>runcmd.c</tt> that take on its command line a program name and its arguments and run it using <tt>execvp</tt>'''

=== Using fork ===

We now want to extend the previous program using <tt>fork(2)</tt>. The schema
is pretty simple: we first fork a child process, in the child we perform the
exec, while in the parent, we wait for the child termination. In order to
''see'' the parent waiting, you'll print an extra message after the child
termination.

The output is pretty similar to the previous one:

<pre>
> make runcmd
clang -Wall -Wextra -std=c99 -O3    runcmd.c   -o runcmd
> ./runcmd
runcmd: Need a command
> ./runcmd ls
>>> running command <<<
	ls
Makefile  foo.c  forkexec.c  mytime.c  runcmd  runcmd.c  runls.c
>>> done <<<
> ./runcmd ls -l
>>> running command <<<
	ls -l
total 32
-rw-r--r-- 1 feanor feanor  118 19 janv. 18:52 Makefile
-rw-r--r-- 1 feanor feanor   87 19 janv. 19:32 foo.c
-rw-r--r-- 1 feanor feanor  367 19 janv. 18:55 forkexec.c
-rw-r--r-- 1 feanor feanor 1489 19 janv. 19:44 mytime.c
-rwxr-xr-x 1 feanor feanor 7723 22 janv. 09:01 runcmd
-rw-r--r-- 1 feanor feanor  479 19 janv. 19:25 runcmd.c
-rw-r--r-- 1 feanor feanor  219 19 janv. 18:52 runls.c
>>> done <<<
> ./runcmd cat foo.c
>>> running command <<<
	cat foo.c
# include <stdlib.h>

int main() {
  int           *p = NULL;
  *p = 42;
  return 0;
}
>>> done <<<
>
</pre>

== Time ==

We now want to implement a program similar to <tt>time(1)</tt>: it runs a
command and print timing information. We want the behavior of <tt>time
-p</tt>. Here is an example of running time (note that we call it with full
path to avoid using the shell version):

<pre>
> cat ack.c
# include <stdio.h>
# include <stdlib.h>

unsigned acker(unsigned m, unsigned n) {
  return (m?(n?(acker(m-1,acker(m,n-1))):acker(m-1,1)):n+1);
}

int main() {
  printf("%u\n", acker(3,12));
  return 0;
}
> make ack
clang -Wall -Wextra -std=c99 -O3    ack.c   -o ack
> /usr/bin/time -p ./ack
32765
real 4.50
user 4.49
sys 0.00
>
</pre>

=== How it work ===

In order to implement your version of <tt>time</tt>, you can start with the
code of the previous exercise that fork/exec command passed as argument and
extend it with time measure using <tt>clock_gettime(2)</tt> (for real time)
before the fork and after the wait. In order to get user and sys time, you'll
need to replace <tt>wait</tt> with <tt>wait3</tt> in order to access the
<tt>rusage</tt> structure of the child.

For the display, you can store your various time in variables of type
<tt>double</tt> print them using the format <tt>%g</tt> in <tt>printf(3)</tt>.

=== Status and execution failure ===

The time program leave with the same exit code as the one of its child (which
can be obtain using <tt>wait3(2)</tt> and macros like <tt>WEXITSTATUS</tt>).

<pre>
> cat exit42.c
int main() {
  return 42;
}
> make exit42
clang -Wall -Wextra -std=c99 -O3    exit42.c   -o exit42
> ./exit42
> echo $?
42
> /usr/bin/time -p ./exit42
Command exited with non-zero status 42
real 0.00
user 0.00
sys 0.00
> echo $?
42
</pre>

As you can see in this example, the command also print a message when the exit
code is different from <tt>0</tt>.

For execution failure, we also follow the behavior of <tt>time</tt>:

<pre>
> /usr/bin/time -p toto
/usr/bin/time: cannot run toto: No such file or directory
Command exited with non-zero status 127
real 0.00
user 0.00
sys 0.00
> echo $?
127
> cat foo.c
# include <stdlib.h>

int main() {
  int           *p = NULL;
  *p = 42;
  return 0;
}
> make foo
clang -Wall -Wextra -std=c99 -O3    foo.c   -o foo
> /usr/bin/time -p ./foo
Command terminated by signal 4
real 0.18
user 0.00
sys 0.00
</pre>

Your program must have the same behavior as <tt>time(1)</tt> for all these cases.

=== Program ===

* '''Write the program <tt>mytime</tt> that take its arguments as a command to be run and output the execution time following the format of <tt>time -p</tt>.'''

<pre>
> make mytime
clang -Wall -Wextra -std=c99 -O3    mytime.c   -o mytime
> ./mytime ./ack
32765
real: 4.5098
user: 4.5
sys: 0
> ./mytime toto
mytime: cannot run toto: No such file or directory
Command exited with non-zero status 127
real: 0.000632002
user: 0
sys: 0
> echo $?
127
> ./mytime ./foo
Command terminated by signal 4
real: 0.00936465
user: 0
sys: 0.003333
> echo $?
4
> ./mytime ./exit42
Command exited with non-zero status 42
real: 0.00198869
user: 0
sys: 0
> echo $?
42
</pre>

Things you need:

* <tt>wait3(2)</tt> and associated macros (<tt>WIFEXITED</tt>, <tt>WEXITSTATUS</tt>, <tt>WIFSIGNALED</tt> and <tt>WTERMSIG</tt>)
* <tt>execvp</tt>
* <tt>fork</tt>