Add shell1 programs.

Author: kohler

shell1/.gitignore

@@ -0,0 +1,7 @@
+filtermultiples
+forkmix
+forkmix2
+manyfork
+pipedemo
+pipesizer
+primesieve

shell1/GNUmakefile

@@ -0,0 +1,23 @@
+PROGRAMS = forkmix forkmix2 manyfork \
+	pipedemo pipesizer \
+	filtermultiples primesieve
+
+all: $(PROGRAMS)
+
+include ../common/rules.mk
+
+%.o: %.c $(BUILDSTAMP)
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(DEPCFLAGS) $(O) -o $@ -c $<
+
+%-profgen: %-profgen.o
+	$(CC) -fprofile-generate $^ -o $@
+
+$(PROGRAMS): %: %.o
+	$(CC) $(CFLAGS) $(O) -o $@ $^
+
+
+clean:
+	rm -f *.o $(PROGRAMS)
+	rm -rf $(DEPSDIR) *.dSYM
+
+.PHONY: all clean

shell1/filtermultiples.c

@@ -0,0 +1,15 @@
+#include "helpers.h"
+
+int main(int argc, char** argv) {
+    assert(argc >= 2);
+    int p = strtol(argv[1], NULL, 10);
+    assert(p > 1);
+
+    char buf[BUFSIZ];
+    while (fgets(buf, BUFSIZ, stdin))
+        if (isdigit((unsigned char) buf[0])) {
+            int i = strtol(buf, NULL, 10);
+            if (i % p != 0)
+                printf("%d\n", i);
+        }
+}

shell1/forkmix.c

@@ -0,0 +1,15 @@
+#include "helpers.h"
+
+int main(void) {
+    pid_t p1 = fork();
+    assert(p1 >= 0);
+
+    const char* text;
+    if (p1 == 0)
+        text = "BABY\n";
+    else
+        text = "mother\n";
+
+    for (int i = 0; i != 1000000; ++i)
+        fputs(text, stdout);
+}

shell1/forkmix2.c

@@ -0,0 +1,19 @@
+#include "helpers.h"
+
+int main(int argc, char* argv[]) {
+    assert(argc >= 2);
+
+    pid_t p1 = fork();
+    assert(p1 >= 0);
+
+    FILE* f = fopen(argv[1], "w");
+
+    const char* text;
+    if (p1 == 0)
+        text = "BABY\n";
+    else
+        text = "mama\n";
+
+    for (int i = 0; i != 1000000; ++i)
+        fputs(text, f);
+}

shell1/helpers.h

@@ -0,0 +1,59 @@
+#ifndef HELPERS_H
+#define HELPERS_H
+#include <unistd.h>
+#include <stdio.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+#include <signal.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <sys/select.h>
+#include <sched.h>
+#include <errno.h>
+
+// timestamp()
+//    Return the current time as a double.
+
+static inline double timestamp(void) {
+    struct timeval tv;
+    gettimeofday(&tv, NULL);
+    return tv.tv_sec + tv.tv_usec / 1000000.0;
+}
+
+
+// nfork()
+//    Like `fork()`, but nondeterministically runs the child first.
+//
+//    This is actually no different from `fork`, since the OS is allowed to
+//    run either process first (or to run them in parallel on multiple
+//    cores), but in practice it is rare that the child runs first. This
+//    function is useful for shaking out race conditions.
+
+static inline pid_t nfork(void) {
+    pid_t p = fork();
+    if (p > 0) {
+        struct timeval tv;
+        gettimeofday(&tv, NULL);
+        if (tv.tv_usec % 7 < 4)
+            sched_yield();
+    }
+    return p;
+}
+
+
+// handle_signal(signo, handler)
+//    Install `handler` as the signal handler for `signo`.
+//    The `handler` is automatically re-installed after signal delivery.
+//    Has the same interface as `signal()` (`man 2 signal`), but is portable.
+
+static inline int handle_signal(int signo, void (*handler)(int)) {
+    struct sigaction sa;
+    sa.sa_handler = handler;    // call `handler` on signal
+    sigemptyset(&sa.sa_mask);   // don't block other signals in handler
+    sa.sa_flags = 0;            // don't restart system calls
+    return sigaction(signo, &sa, NULL);
+}
+
+#endif

shell1/manyfork.c

@@ -0,0 +1,15 @@
+#include "helpers.h"
+
+int main(void) {
+    int nprocesses = 10000;
+    double start_time = timestamp();
+    for (int i = 0; i != nprocesses; ++i) {
+        pid_t p1 = fork();
+        assert(p1 >= 0);
+        if (p1 == 0)
+            exit(0);
+    }
+    double delta = timestamp() - start_time;
+    printf("%d processes in %g sec (%g proc/sec)\n", nprocesses,
+           delta, nprocesses / delta);
+}

shell1/pipedemo.c

@@ -0,0 +1,31 @@
+#include "helpers.h"
+
+int main(void) {
+    int pipefd[2];
+    int r = pipe(pipefd);
+    if (r < 0) {
+        fprintf(stderr, "pipe: %s\n", strerror(errno));
+        // or, shorter: `perror("pipe");`
+        exit(1);
+    }
+
+    pid_t p1 = fork();
+    assert(p1 >= 0);
+
+    if (p1 == 0) {
+        const char* buf = "Hello from your child!\n";
+        ssize_t nw = write(pipefd[1], buf, strlen(buf));
+        assert(nw == (ssize_t) strlen(buf));
+        exit(0);
+    }
+
+    FILE* f = fdopen(pipefd[0], "r");
+    close(pipefd[1]);
+    while (!feof(f)) {
+        char buf[BUFSIZ];
+        if (fgets(buf, BUFSIZ, f) != NULL)
+            fprintf(stderr, "pipe says: %s\n", buf);
+    }
+    fprintf(stderr, "pipe closed\n");
+    fclose(f);
+}

shell1/pipesizer.c

@@ -0,0 +1,15 @@
+#include "helpers.h"
+
+int main(void) {
+    int pipefd[2];
+    int r = pipe(pipefd);
+    assert(r >= 0);
+
+    size_t x = 0;
+    while (1) {
+        ssize_t nr = write(pipefd[1], "!", 1);
+        assert(nr == 1);
+        ++x;
+        printf("%zu\n", x);
+    }
+}

shell1/primesieve.c

@@ -0,0 +1,54 @@
+#include "helpers.h"
+
+int main(void) {
+    char primebuf[1024];
+    primebuf[0] = 0;
+
+    // sieve of Eratosthenes
+    while (1) {
+        // create next child
+        int pipefd[2];
+        int r = pipe(pipefd);
+        assert(r >= 0);
+
+        pid_t pid = fork();
+        assert(pid >= 0);
+
+        // run child
+        if (pid == 0) {
+            close(pipefd[0]);
+            dup2(pipefd[1], STDOUT_FILENO);
+            close(pipefd[1]);
+
+            if (strcmp(primebuf, "") == 0) {
+                // first child: print all numbers starting from 2
+                char* argv[] = { "seq", "2", "1000000", NULL };
+                execvp(argv[0], argv);
+            } else {
+                // later children: filter multiples of last prime
+                char* argv[] = { "./filtermultiples", primebuf, NULL };
+                execv(argv[0], argv);
+            }
+
+            assert(0);
+        }
+
+        // set standard input to read from child
+        close(pipefd[1]);
+        dup2(pipefd[0], STDIN_FILENO);
+        close(pipefd[0]);
+
+        // read next prime from standard input
+        char* buf = primebuf;
+        ssize_t nread;
+        while ((nread = read(STDIN_FILENO, buf, 1)) == 1
+               && isdigit((unsigned char) *buf))
+            ++buf;
+        if (nread != 1 || *buf != '\n')
+            exit(0);
+        *buf = 0;
+
+        // print prime
+        printf("%s\n", primebuf);
+    }
+}