In-class exercises

Author: Margo Seltzer

storage2/Makefile

@@ -0,0 +1,22 @@
+PROGRAMS = w01_sync w02_syscall w03_stdio 
+
+INCLUDES = -I.
+
+CFLAGS = -g -O3 -Wall -std=gnu11 $(INCLUDES)
+
+all: $(PROGRAMS)
+
+%.o:%.c
+	$(CC) $(CFLAGS) -c $<
+
+w01_sync: w01_sync.o
+	$(CC) $(CFLAGS) -o $@ w01_sync.o
+
+w02_syscall: w02_syscall.o
+	$(CC) $(CFLAGS) -o $@ w02_syscall.o
+
+w03_stdio: w03_stdio.o
+	$(CC) $(CFLAGS) -o $@ w03_stdio.o
+
+clean:
+	rm -f $(PROGRAMS) *.o core a.out data

storage2/README.txt

@@ -0,0 +1,9 @@
+Beginning of cache exercises. It's possible that some of the performance
+differences illustrated here will not be apparent in the appliance, so
+you may need/want to run them directly on your laptop/desktop. They are
+relatively simple programs that should translate easily.
+
+w01 (super slow) O_WRONLY | O_CREAT | O_TRUNC | O_SYNC (1 byte/write)
+w02 (quick) O_WRONLY | O_CREAT | O_TRUNC (1 byte/write)
+w03 (super quick) stdio (1 byte/write)
+

storage2/iobench.h

@@ -0,0 +1,42 @@
+#ifndef IOBENCH_H
+#define IOBENCH_H
+
+#define _GNU_SOURCE 1
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include <limits.h>
+#include <sys/time.h>
+
+static inline double tstamp(void) {
+    struct timeval tv;
+    gettimeofday(&tv, 0);
+    return tv.tv_sec + tv.tv_usec / 1000000.;
+}
+
+// Print a report to stderr of # bytes printed, elapsed time, and rate.
+static inline void report(size_t n, double elapsed) {
+    fprintf(stderr, "\r%zd bytes   %g sec   %g byte/sec     ",
+            n, elapsed, n / elapsed);
+}
+
+// Return the size of a file.
+static inline ssize_t filesize(int fd) {
+    struct stat s;
+    int r = fstat(fd, &s);
+    if (r >= 0 && S_ISREG(s.st_mode) && s.st_size <= SSIZE_MAX)
+        return s.st_size;
+    else
+        return -1;
+}
+
+#ifndef PRINT_FREQUENCY
+#define PRINT_FREQUENCY 4096
+#endif
+
+#endif

storage2/w01_sync.c

@@ -0,0 +1,37 @@
+#include "iobench.h"
+
+int main() {
+    int fd = STDOUT_FILENO;
+    if (isatty(fd))
+        fd = open("data", O_WRONLY | O_CREAT | O_TRUNC | O_SYNC, 0666);
+    if (fd < 0) {
+        perror("open");
+        exit(1);
+    }
+    /*
+     * All the other benchmarks use a size of approximately 5 MB, however,
+     * this benchmark is painfully slow and trying to write that much will
+     * take too long, so we reduce it by a factor of 100.
+     */
+    // size_t size = 5120000;
+    size_t size = 51200;
+    const char *buf = "6";
+    double start = tstamp();
+
+    size_t n = 0;
+    while (n < size) {
+        // Write 1 character at a time, using the write system call.
+        ssize_t r = write(fd, buf, 1);
+        if (r != 1) {
+            perror("write");
+            exit(1);
+        }
+        n += r;
+        if (n % PRINT_FREQUENCY == 0)
+            report(n, tstamp() - start);
+    }
+
+    close(fd);
+    report(n, tstamp() - start);
+    fprintf(stderr, "\n");
+}

storage2/w02_syscall.c

@@ -0,0 +1,37 @@
+#include "iobench.h"
+
+int main() {
+    int fd = STDOUT_FILENO;
+    if (isatty(fd))
+        fd = open("data", O_WRONLY | O_CREAT | O_TRUNC, 0666);
+    if (fd < 0) {
+        perror("open");
+        exit(1);
+    }
+
+    /*
+     * All the other benchmarks use a size of approximately 5 MB, however,
+     * this benchmark is painfully slow and trying to write that much will
+     * take too long, so we reduce it by a factor of 100.
+     */
+    // size_t size = 5120000;
+    size_t size = 51200;
+    const char* buf = "6";
+    double start = tstamp();
+
+    size_t n = 0;
+    while (n < size) {
+        ssize_t r = write(fd, buf, 1);
+        if (r != 1) {
+            perror("write");
+            exit(1);
+        }
+        n += r;
+        if (n % PRINT_FREQUENCY == 0)
+            report(n, tstamp() - start);
+    }
+
+    close(fd);
+    report(n, tstamp() - start);
+    fprintf(stderr, "\n");
+}

storage2/w03_stdio.c

@@ -0,0 +1,37 @@
+#include "iobench.h"
+
+int main() {
+    FILE* f = stdout;
+    if (isatty(fileno(f)))
+        f = fopen("data", "w");
+    if (!f) {
+        perror("fopen");
+        exit(1);
+    }
+
+    /*
+     * All the other benchmarks use a size of approximately 5 MB, however,
+     * this benchmark is painfully slow and trying to write that much will
+     * take too long, so we reduce it by a factor of 100.
+     */
+    // size_t size = 5120000;
+    size_t size = 51200;
+    const char* buf = "6";
+    double start = tstamp();
+
+    size_t n = 0;
+    while (n < size) {
+        size_t r = fwrite(buf, 1, 1, f);
+        if (r != 1) {
+            perror("write");
+            exit(1);
+        }
+        n += r;
+        if (n % PRINT_FREQUENCY == 0)
+            report(n, tstamp() - start);
+    }
+
+    fclose(f);
+    report(n, tstamp() - start);
+    fprintf(stderr, "\n");
+}