lecture

Author: vagrant

storage4/stdio.c

@@ -29,7 +29,7 @@ int main(int argc, char *argv[]) {
 	// We're going to open a file for writing and
 	// loop writing our buffer to it (via stdio),
 	// sleeping between each write.
-	fp = fopen(datafile, "w+");
+	fp = fopen(datafile, "a+");
 	if (fp == NULL) {
 		perror("fopen");
 		exit(1);

storage5/GNUmakefile

@@ -0,0 +1,17 @@
+PROGRAMS = stdio syscall mmap
+
+all: $(PROGRAMS)
+
+include ../common/rules.mk
+
+%.o: %.c $(BUILDSTAMP)
+	$(CC) $(CPPFLAGS) $(CFLAGS) $(DEPCFLAGS) $(O) -o $@ -c $<
+
+%: %.o
+	$(CC) $(CFLAGS) -o $@ $^
+
+clean:
+	rm -f *.o $(PROGRAMS) *.out
+	rm -rf $(DEPSDIR) *.dSYM
+
+.PHONY: all clean

storage5/data.in

@@ -0,0 +1 @@
+AAABBBBABABBAAABABBBBBBBBABAABABAABBABBAABBAABBAABBABBAAAABBBAAAABAAAABBBBBBABBABBABBAABAABAAABAABBBBAAABAABAAAABABAAAABBBABBBBBBABBABABAAABABBBBAAABBBBBBBBABBABBBABBAAABAABABAAAABAAAABABBBABAAABBBBBAAABABAAAAAAAABBBBBABBBAABBABBABBAABBBAABBAAAABABAABAABBABBBABBAAAAABABAAAAABBAABBBAAAAABAAABABAABBBABABBBAABBAABBBAAABAAABAAABBBBABBBABAAABAABBBAABAABBABAABABBBBBBABAAABBBAABABABAAABBABBAAAABBAABBAAAABAABAAAABBBBBABBBBBBAABAAABAAAABAAABABAABAAAAABABBABAABBBBABABAAABBBAAABAAABABABBBBAAAAABAABBBAABABABAABBBAAAAABBAABAAABAAABAAABAABAAABAABAABAABAAABBBBBABBAAAABABAAAAABAAAABAAAAABBBAAABBBAABBBBAABABBABABBBBBBBABABAABBBABBBBABABBBAABAABBABABABABBAABABABBBAABABBAABAABAAABABBABBAABABBAAAABAAAAAAAABAAABBABABBBABAABAAABABAABBBBABBAAAAAAAAAAABBABBBBAAAABABABAAABBABBAABAABAABAABBAAAAAAAABBABBBBABBAABBABAABAAABBAAABBABBABBBBABABBBABAAABABAAABAABBBBABBAAABBABBABBAABAAAAABAABABAAAAAABAABABBABBBBAABAAABBABBABBABBABBABBABBABAABBAABAABBABAABABAABBBABAAAABABBABABABABABBABBBBBABBBBBBAABABBABBBAAABBABBAABAAAABBAABBAABBBBABABABBBAAAAABABAAAABAAAABAAAABABAAAAAABBBBABBAABBBBBBABABAAABABBABBAAAAABAAAABABBBBABAAABAAABABBBBBABAAAAAAABABBABABBBAABAAAABABABBBAABABBBAAABAAAABBBBABBBBABBBBBBABAAAAABABAABABBABAABABABAAAABBABABBBAABBAAABAAABBABBBBABABAAABBABAABBABABAAABBAAAABBBBABBBABABAAABAABBBBBBAAAAAAABBBABBBABBBABAAAABBABABABABAABBABABAABAAAABAABAABBABBBABBBBBBBBAABBBBBBBBAAABBBAABAAABAAABBAAAABBBAABAABAABBBBBAAAAAAAABBBBBBAABAAAABBABABBBABABAAAAABABAABBAAABBBBBABBABBBABABBBBBABABBBAAABAAABAABAABABAABAABABAABBBBAAAAABBABAAAAAABAABBABBBAAABAAAAAAABBBABBAABBAABAAAABBABBBABBBBAAAABAABAABABBBBBAABBBBBBBAABBBAABAABBABBABBAABAAAAAAAABBAABBBABAAABABBAABBBABBABAAABBBAAAAAAABABBAABBBBAAAABBABAAABBABABBAAABAABABABAAAABABBBAABAABABBABABAAAABBBBAAABABAAABBBABBBBABAABBBABAABAABABBBAAAAABABABAABAAAABBBABBAAABAABABBBBBBBABABBBAAABABAABBABBBABABBBAAAABBAABABBBABABAABAAABABAABAABABAABBAABBABAAAAAABABAABBBABBBBBABAABBABBAABABBAABABAABAABABBBBABBBBBBAABBBBBABABABBBABBABBABAABABABBAABABBBABBABABBABAAAAAAABBBBABABAABBAABAABBBBAABBAAAABBBBAABAABAABBAAABBAABBAABBAAAABABAABBABABBBABBABBBAAAABAABAABABBABBBAABBAABBABABAAABABAABBABABBBABBABBABBAABAAAABBAABBBAABBABBABBABABABAABABABBABABBBAABABAABABAABBBABABABABBBBAAABBABBBABBBABABABBBBBBBBBABABAAABABBABAAABABBBAAABBAAAAAABABBBBBAAAAAAAABABBBBAABAABABBBBBBABAABAABBBBBBBABBBBAAAABABABBABABABBAAAAABABBABBBABABAAAAABBAABABBBBBBABBAABABBABBAABAAAABBBABBBAABBAAABBBBAAAAABABBAAABABBABBBAAAAABAABAABABBABABBABBAAABAAAAABAAAAABBAAAAABAABABABABAAABBABBABBBAAAAAAAAAABAABABAABBAAABBBABBABAAAAAAAABAAAABAAAABBAAAAAABBAABAABBABAAAABBBBABAABAAABAABABBAABABABBBBBBBABAABBBABBBBBABBBABBBBBBAABBBBBAAABBBAABBBABBABAAABAABAABBBBBBAABAABBBAAAAABAAABBBAAAAABBABABABABABBBAAAAABAAABBABBBAAABBAABABBAABAABBBABBBBAAABBABBAAAABBBABBABAABAABBBAABBAAABBAABAAAAABBAABBBABBBBAABAAABABBAAABBAABABBBBABBABABBABABAABABABABABBBABBBAABBAABBAAAAABBABBAAAABBABBBAAABBBBABBABBBABBBABBABBBAABAAAABBAAABABAABBBAABAABBBBABBBBBBBAAAAABABAABBAABBBBBBBAAABABBBBBAAABBABABABAABBAAAAAABBABAAAABBBABAAAAAAAABABAAABAAAAABAAABAABABBBABAAABBAAAAABAABABBABABBAAABABABBABABBAAABAAAABABBBABBBAABBBBAABBAAAAABBABBBBBAABABBBBBBAAAAAAAAABABABBBAABBABBBBAABABABBBABBAABBBBBAABBBBBAAABBBBBAABBABABAABABABABABBABAAABBABBBAAABABBBAAABBAABAABABBBAAABBABBBAABBAAABBAAABABBAABABABABABABBAAAABABAABBBABBBABABBBABBABABBAABBBAABBAAAABAAAAABBBBABAAABBBBABBBBBABABABBAABABAAABABABABAABABBABABAABBBABBABAABAAAAABBABBBAAAABAAAABABBBBAABBBABABBAAABBAABABBAAABAABBABBABBAABBBBAABAAAAAABAABABBABABBAAABBBAAAABBAABAABBBBABBBBBBABAABAABABABBAABAAABBBBABBBABBBBABBBBABBABBBBABBBBABAAABAABBAABBAABBBAABBAABAABABABABABABBBABABAABABABAAABAABAABABAABBBAAAABBBBBBBBBBABABAABAABBAABABAABBABAABBBBBBBBAAABABAAAABBAABABBAAABAAABBAABABBBBAABABBBBABABBBAABBBAAAABAAAABBAABBBAAABAAAABAAAAABABBABBBBAAAABBABABAAABABBAAABBBAAAABBAABABBABAAABAAABBBABABBBBAABABBBBBABBBBBABBABABAAAAABBAABBBBAABBBBBABABBABABABAABBBABBBAABAAABBABABABAAAAABBABBABAABAAAABABAAABBBBAAABBAABBBABBBBAAABABAAABBBBABAABABBBBBAAAAABAAAABABBBAAABABBBBAABABABABAABBAABABBABBBBBBABAAABABBBAABABBAABBAABBABBBAABBAABBABABABABBBBAABABABBABBABBAABBBAABBBABBBAABABAAABABBBBABABBBAAABAA

storage5/mmap.c

@@ -0,0 +1,61 @@
+#define _BSD_SOURCE
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+
+// This is a 3-file setup:
+// Start with a file full of 4096 X's
+// If you run this with no arguments, we just mmap the file and repeatedly
+// read it.
+// If you pass an argument, we take the first character and randomly write
+// that character to an offset in the file.
+#define MMAP_FILE_SIZE 4096
+
+int main(int argc, char *argv[]) {
+	const char *datafile = "data.in";
+	char printchar;
+	int fd, is_reader;
+	char *buf;
+
+	if (argc < 2) {
+		// This is the reader process
+		is_reader = 1;
+	} else {
+		is_reader = 0;
+		printchar = argv[1][0];
+	}
+
+	// We're going to open a file for mmapping and then we're going to
+	// loop updating our character.
+	fd = open(datafile, O_RDWR);
+	if (fd < 0) {
+		perror("open");
+		exit(1);
+	}
+	// mmap 4096 bytes starting at offset 0
+	buf = mmap(NULL,
+	    MMAP_FILE_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+
+	// Seed the random number generator so that different processes
+	// will do different things.
+	srandom((unsigned int)getpid());
+	while (1) {
+		if (is_reader) {
+			// Output 64 bytes at a time
+			for (int i = 0; i < MMAP_FILE_SIZE; i += 64)
+				printf("%.64s\n", buf + i);
+			sleep(1);
+		} else {
+			// Pick an offset in the buffer and write to it.
+			buf[random() % MMAP_FILE_SIZE] = printchar;
+			usleep(1024);
+		}
+	}
+
+	exit(0);
+}

storage5/reset.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+sed -e 's/A/X/g' -e 's/B/X/g' data.in > data.out
+mv data.out data.in

storage5/stdio.c

@@ -0,0 +1,68 @@
+#define _BSD_SOURCE
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+
+// Try to emulate what we're doing in mmap with fwrite
+// This is a 3-file setup:
+// Start with a file full of 4096 X's
+// If you run this with no arguments, we just read the file and print it.
+// If you pass an argument, we take the first character and randomly write
+// that character to an offset in the file.
+#define MMAP_FILE_SIZE 4096
+
+int main(int argc, char *argv[]) {
+	const char *datafile = "data.in";
+	char printchar;
+	int is_reader;
+	char buf[MMAP_FILE_SIZE];
+	FILE *fp;
+	off_t off;
+
+	if (argc < 2) {
+		// This is the reader process
+		is_reader = 1;
+	} else {
+		is_reader = 0;
+		printchar = argv[1][0];
+	}
+
+	// We're going to open a file for mmapping and then we're going to
+	// loop updating our character.
+	fp = fopen(datafile, "r");
+	if (fp == NULL) {
+		perror("open");
+		exit(1);
+	}
+	// Seed the random number generator so that different processes
+	// will do different things.
+	srandom((unsigned int)getpid());
+	while (1) {
+		if (is_reader) {
+			if (fseek(fp, 0, SEEK_SET) != 0 ||
+			    fread(buf, MMAP_FILE_SIZE, 1, fp) != 1) {
+				perror("fread");
+				exit(1);
+			}
+			for (int i = 0; i < MMAP_FILE_SIZE; i += 64)
+				printf("%.64s\n", buf + i);
+			sleep(1);
+		} else {
+			// Pick an offset and write it using stdio.
+			off = random() % MMAP_FILE_SIZE;
+			if (fseek(fp, off, SEEK_SET) != off ||
+			    fwrite(&printchar, 1, 1, fp) != 1) {
+				perror("writer failed\n");
+				exit(1);
+			}
+			usleep(1024);
+		}
+	}
+
+	exit(0);
+}

storage5/syscall.c

@@ -0,0 +1,68 @@
+#define _BSD_SOURCE
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+
+// Try to emulate what we're doing in mmap with write
+// This is a 3-file setup:
+// Start with a file full of 4096 X's
+// If you run this with no arguments, we just read the file and print it.
+// If you pass an argument, we take the first character and randomly write
+// that character to an offset in the file.
+#define MMAP_FILE_SIZE 4096
+
+int main(int argc, char *argv[]) {
+	const char *datafile = "data.in";
+	char printchar;
+	int is_reader;
+	char buf[MMAP_FILE_SIZE];
+	int fd;
+	off_t off;
+
+	if (argc < 2) {
+		// This is the reader process
+		is_reader = 1;
+	} else {
+		is_reader = 0;
+		printchar = argv[1][0];
+	}
+
+	// We're going to open a file for mmapping and then we're going to
+	// loop updating our character.
+	fd = open(datafile, O_RDWR);
+	if (fd < 0) {
+		perror("open");
+		exit(1);
+	}
+	// Seed the random number generator so that different processes
+	// will do different things.
+	srandom((unsigned int)getpid());
+	while (1) {
+		if (is_reader) {
+			if (lseek(fd, 0, SEEK_SET) != 0 ||
+			    read(fd, buf, MMAP_FILE_SIZE) != 4096) {
+				perror("read");
+				exit(1);
+			}
+			for (int i = 0; i < MMAP_FILE_SIZE; i += 64)
+				printf("%.64s\n", buf + i);
+			sleep(1);
+		} else {
+			// Pick an offset and write it using stdio.
+			off = random() % MMAP_FILE_SIZE;
+			if (lseek(fd, off, SEEK_SET) != off ||
+			    write(fd, &printchar, 1) != 1) {
+				perror("writer failed\n");
+				exit(1);
+			}
+			usleep(1024);
+		}
+	}
+
+	exit(0);
+}