jekyll-theme-gaeblogx 0.1.0

data/assets/file-seek1.c

@@ -0,0 +1,87 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+
+/*
+ * seek the file in the first argument to the location specified in the
+ * second
+ */
+int main(int argc, char **argv)
+{
+	int my_file_desc;
+	char file_name[4096];
+	char read_buffer[4096];
+	int i;
+	int r;
+	off_t offset;
+	off_t where;
+
+	if(argc < 3) {
+		printf("need to specify a file name and an offset\n");
+		exit(1);
+	}
+
+	/*
+	 * zero out the buffer for the file name
+	 */
+	for(i=0; i < sizeof(file_name); i++) {
+		file_name[i] = 0;
+	}
+
+	/*
+	 * copy the argument into a local buffer
+	 */
+	strncpy(file_name,argv[1],sizeof(file_name));
+	file_name[sizeof(file_name)-1] = 0;
+
+	/*
+	 * get the offset from the second argument
+	 */
+	offset = (off_t)atoi(argv[2]);
+
+	/*
+	 * try and open the file for reading
+	 */
+	my_file_desc = open(file_name,O_RDONLY,0);
+	if(my_file_desc < 0) {
+		printf("failed to open %s for reading\n",file_name);
+		exit(1);
+	}
+
+	/*
+	 * seek to the offset specified in the second argument
+	 */
+	where = lseek(my_file_desc,offset,SEEK_SET);
+
+	if(where < 0) {
+		printf("lseek to %d in file %s failed\n",
+			(int)offset,
+			file_name);
+		close(my_file_desc);
+		exit(1);
+	}
+
+	for(i=0; i < sizeof(read_buffer); i++) {
+		read_buffer[i] = 0;
+	}
+	r = read(my_file_desc,read_buffer,sizeof(read_buffer)-1);
+
+	/*
+	 * read and print until EOF
+	 */
+	while(r > 0) {
+		printf("%s",read_buffer);
+		for(i=0; i < sizeof(read_buffer); i++) {
+			read_buffer[i] = 0;
+		}
+		r = read(my_file_desc,read_buffer,sizeof(read_buffer)-1);
+	}
+	close(my_file_desc);
+
+	return(0);
+
+}
+
+

data/assets/fork-1.c

@@ -0,0 +1,35 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+
+/*
+ * simple program calling fork
+ */
+int main(int argc, char **argv)
+{
+	pid_t child_id;
+	pid_t my_id;
+
+	my_id = getpid();
+	printf("pid: %d -- I am the parent about to call fork\n",
+			(int)my_id);
+
+	child_id = fork();
+	if(child_id != 0) {
+		my_id = getpid();
+		printf("pid: %d -- I just forked a child with id %d\n",
+			(int)my_id,
+			(int)child_id);
+	} else {
+		my_id = getpid();
+		printf("pid: %d -- I am the child\n",my_id);
+	}
+
+	printf("pid: %d -- I am exiting\n",my_id);
+	exit(0);
+
+}
+
+

data/assets/fork-2.c

@@ -0,0 +1,44 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+
+/*
+ * simple program calling fork and wait
+ */
+int main(int argc, char **argv)
+{
+	pid_t child_id;
+	pid_t my_id;
+	int child_status;
+	int i;
+
+	child_id = fork();
+	if(child_id != 0) {
+		my_id = getpid();
+		printf("pid: %d -- I just forked a child with id %d\n",
+			(int)my_id,
+			(int)child_id);
+		printf("pid: %d -- I am waiting for process %d to finish\n",
+			(int)my_id,
+			(int)child_id);
+		wait(&child_status);
+		printf("pid: %d -- my child has completed with status: %d\n",
+			(int)my_id,
+			child_status);
+	} else {
+		my_id = getpid();
+		printf("pid: %d -- I am the child and I am going to count to 10\n",
+			(int)my_id);
+		for(i=0; i < 10; i++) {
+			printf("pid: %d -- %d\n",my_id,i+1);
+		}
+	}
+
+	printf("pid: %d -- I am exiting\n",my_id);
+	exit(0);
+
+}
+
+

data/assets/fork-3.c

@@ -0,0 +1,60 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+
+/*
+ * run a program using fork and execve
+ */
+int main(int argc, char **argv, char **envp)
+{
+	pid_t child_id;
+	pid_t my_id;
+	int child_status;
+	int i;
+	char file_name[4096];
+	int err;
+
+	if(argc < 2) {
+		printf("must specify file name as first argument\n");
+		exit(1);
+	}
+
+	memset(file_name,0,sizeof(file_name));
+	strncpy(file_name,argv[1],sizeof(file_name));
+
+	child_id = fork();
+	if(child_id != 0) {
+		my_id = getpid();
+		printf("pid: %d -- I forked pid: %d for: %s\n",
+			my_id,
+			child_id,
+			file_name);
+		wait(&child_status);
+		printf("pid: %d -- %s has completed with status: %d\n",
+			(int)my_id,
+			file_name,
+			child_status);
+	} else {
+		my_id = getpid();
+		printf("pid: %d -- I am the child and I am going to exec %s\n",
+			(int)my_id,
+			file_name);
+		err = execve(file_name,&(argv[1]),envp);
+		/*
+		 * not reached if execve is successful
+		 */
+		printf("pid: %d -- execve of %s failed with error %d\n",
+			(int)my_id,
+			file_name,
+			err);
+
+	}
+
+	printf("pid: %d -- I am exiting\n",my_id);
+	exit(0);
+
+}
+
+

data/assets/fork-4.c

@@ -0,0 +1,64 @@
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/wait.h>
+
+/*
+ * run a program using fork and execve
+ * pring the status correctly
+ */
+int main(int argc, char **argv, char **envp)
+{
+	pid_t child_id;
+	pid_t my_id;
+	int child_status;
+	int i;
+	char file_name[4096];
+	int err;
+
+	if(argc < 2) {
+		printf("must specify file name as first argument\n");
+		exit(1);
+	}
+
+	memset(file_name,0,sizeof(file_name));
+	strncpy(file_name,argv[1],sizeof(file_name));
+
+	child_id = fork();
+	if(child_id != 0) {
+		my_id = getpid();
+		printf("pid: %d -- I forked pid: %d for: %s\n",
+			my_id,
+			child_id,
+			file_name);
+		wait(&child_status);
+		if(WIFEXITED(child_status)) {
+			printf("pid: %d -- %s has completed with status: %d\n",
+				(int)my_id,
+				file_name,
+				WEXITSTATUS(child_status));
+		}
+	} else {
+		my_id = getpid();
+		printf("pid: %d -- I am the child and I am going to exec %s\n",
+			(int)my_id,
+			file_name);
+		err = execve(file_name,&(argv[1]),envp);
+		/*
+		 * not reached if execve is successful
+		 */
+		printf("pid: %d -- execve of %s failed with error %d\n",
+			(int)my_id,
+			file_name,
+			err);
+
+	}
+
+	printf("pid: %d -- I am exiting\n",my_id);
+	exit(0);
+
+}
+
+

data/assets/joinall-1.c

@@ -0,0 +1,163 @@
+/*
+ * cs170 -- Rich wolski
+ * ping-pong code illustrating kt_joinall() functionality
+ */
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "kt.h"
+
+#define RAND() (drand48())
+
+struct thread_arg
+{
+	int id;
+	int count;
+	double *shared_counter;
+	kt_sem next;
+	int *finished;
+	int verbose;
+};
+
+/*
+ * bumps the shared counter by 1 each time it is enabled
+ */
+void *PingPongThread(void *arg)
+{
+	struct thread_arg *ta = (struct thread_arg *)arg;
+	int i;
+
+	for(i=0; i < ta->count; i++) {
+		P_kt_sem(ta->next);
+			*(ta->shared_counter) =
+				*(ta->shared_counter) + 1.0;
+		if(ta->verbose == 1) {
+			printf("thread %d: incremented shared counter to %f\n",
+				ta->id,
+				*(ta->shared_counter));
+		}
+		V_kt_sem(ta->next);
+	}
+
+	*(ta->finished) = *(ta->finished) + 1;
+
+	kt_exit();
+	return(NULL);
+}
+
+#define ARGS "t:VC:"
+char *Usage = "ping-pong-joinall -C count -t threads -V <verbose on>\n";
+
+
+int main(int argc, char **argv)
+{
+	int c;
+	int threads;
+	struct thread_arg *ta;
+	void **ids;
+	double counter;
+	int done_threads;
+	int count;
+	int verbose;
+	int i;
+	kt_sem sema;
+	
+
+	/*
+	 * defaults
+	 */
+	threads = 1;
+	counter = 0;
+	count = 1;
+	while((c = getopt(argc,argv,ARGS)) != EOF) {
+		switch(c) {
+			case 'C':
+				count = atoi(optarg);
+				break;
+			case 't':
+				threads = atoi(optarg);
+				break;
+			case 'V':
+				verbose = 1;
+				break;
+			default:
+				fprintf(stderr,
+					"unrecognized command %c\n",
+						(char)c);
+				fprintf(stderr,"usage: %s",Usage);
+				exit(1);
+		}
+	}
+
+	ids = (void **)malloc(threads*sizeof(void *));
+	if(ids == NULL) {
+		exit(1);
+	}
+
+	ta = (struct thread_arg *)malloc(threads*sizeof(struct thread_arg));
+	if(ta == NULL) {
+		exit(1);
+	}
+
+	sema = make_kt_sem(0);
+	if(sema == NULL) {
+		exit(1);
+	}
+
+	done_threads = 0;
+	for(i=0; i < threads; i++) {
+		ta[i].id = i;
+		ta[i].next = sema;
+		ta[i].count = count;
+		ta[i].shared_counter = &counter;
+		ta[i].finished = &done_threads;
+		ta[i].verbose = verbose;
+		ids[i] = kt_fork(PingPongThread,(void *)&ta[i]);
+		if(ids[i] == NULL) {
+			fprintf(stderr,"thread create %d failed\n",i);
+			exit(1);
+		}
+	}
+
+	V_kt_sem(sema);	/* enable a thread */
+	/*
+ 	 * loop showing progress
+ 	 */
+	while(done_threads < threads) {
+		printf("shared counter: %f\n",counter);
+		fflush(stdout);
+		kt_joinall(); /* gets here when all else is stopped */
+	}
+
+	/*
+	 * join with the threads after exit
+	 */
+	for(i=0; i < threads; i++) {
+		kt_join(ids[i]);
+	}
+
+	kill_kt_sem(sema);
+	free(ta);
+	free(ids);
+
+	printf("final count: %f\n",counter);
+
+	return(0);
+}
+		
+
+
+		
+		
+		
+
+	
+	
+
+
+
+	
+	
+