Merge branch 'dev'

Author: Tanner

.gitignore

@@ -5,4 +5,6 @@ cache
 tiny/*
 .proxy/*
 .noproxy/*
-.vscode/*
+.vscode/*
+requests.txt
+requests.log

Makefile

@@ -16,8 +16,12 @@ csapp.o: csapp.c csapp.h
 proxy.o: proxy.c csapp.h
 	$(CC) $(CFLAGS) -c proxy.c
 
-proxy: proxy.o csapp.o
+cache.o: cache.c cache.h
+	$(CC) $(CFLAGS) -c cache.c
+
+proxy: proxy.o csapp.o cache.o
 	$(CC) $(CFLAGS) proxy.o csapp.o -o proxy $(LDFLAGS)
+	
 
 # Creates a tarball in ../proxylab-handin.tar that you can then
 # hand in. DO NOT MODIFY THIS!

cache.c

@@ -0,0 +1,140 @@
+#include "cache.h"
+
+cacheList* initCache() {
+    cacheList* list = Malloc(sizeof(*list));
+    list->head = list->tail = NULL;
+    list->lock = Malloc(sizeof(*(list->lock)));
+    pthread_rwlock_init((list->lock), NULL);
+    list->bytesLeft = MAX_CACHE_SIZE;
+
+    return list;
+}
+
+void deleteCache(cacheList* list) {
+    if (list) {
+        cacheNode* tmpHead = list->head;
+        while (tmpHead) {
+            cacheNode* tmp = tmpHead;
+            tmpHead = tmp->next;
+            deleteNode(tmp);
+        }
+        pthread_rwlock_destroy(list->lock);
+        free(list->lock);
+        free(list);
+    }
+
+}
+
+void initNode(cacheNode* node) {
+    if (node) {
+        node->next = NULL;
+        node->prev = NULL;
+        node->length = 0;
+	}
+}
+
+void setNode(cacheNode* node, char* key, unsigned int length) {
+    if (node) {
+        node->key = Malloc(sizeof(char) * length);
+        memcpy(node->key, key, length);
+        node->length = length;
+    }
+}
+
+int addNode(cacheNode* node, cacheList* list) {
+    if (list) {
+        pthread_rwlock_wrlock(list->lock);
+        // Make sure there is room for the next object, if not then forget don't add it
+        if (node != NULL && (node->length < list->bytesLeft)) {
+            
+            if (!list->tail) {
+                list->head = list->tail = node;                
+            }
+            else {
+                list->tail->next = node;
+                node->prev = list->tail;
+                list->tail = node;
+            }
+            
+            list->bytesLeft -= node->length;
+        }
+        else {
+            pthread_rwlock_unlock(list->lock);
+            return -1;
+        }
+        pthread_rwlock_unlock(list->lock);
+    }
+    return 0;
+}
+
+void deleteNode(cacheNode* node) {
+    if (node) {
+        // Free the arrays inside the node first then free the node up
+        if (node->key) {
+            free(node->key);
+        }
+        if (node->value) {
+            free(node->value);
+        }
+        free(node);
+    }
+}
+
+cacheNode* findNode(cacheList* list, char* key) {
+    if (list) {
+        cacheNode* tmp = list->head;
+        while (tmp) {
+            if (strcmp(tmp->key, key) == 0) {
+                return tmp;
+            }
+
+            tmp = tmp->next;
+        }
+    }
+    return NULL;
+}
+
+int readNodeContent(cacheList* list, char* key, char* value, unsigned int *len) {
+    if (!list) {
+        return -1;
+    }
+
+    pthread_rwlock_rdlock(list->lock);
+
+    cacheNode* tmp = findNode(list, key);
+
+    if (!tmp) {
+        pthread_rwlock_unlock(list->lock);
+        return -1;
+    }
+
+    *len = tmp->length;
+    memcpy(value, tmp->value, *len);
+    pthread_rwlock_unlock(list->lock);
+
+    return 0;
+
+}
+
+int insertNodeContent(cacheList* list, char* key, char* value, unsigned int len) {
+    if (!list) {
+        return -1;
+    }
+
+    cacheNode* tmp = Malloc(sizeof(*tmp));
+    initNode(tmp);
+    setNode(tmp, key, len);
+
+    if (!tmp) {
+        return -1;
+    }
+
+    tmp->value = Malloc(sizeof(char) * len);
+    memcpy(tmp->value, value, len);
+    if (addNode(tmp, list) == -1) {
+        deleteNode(tmp);
+        return -2;
+    }
+
+    return 0;
+}

cache.h

@@ -0,0 +1,44 @@
+#ifndef __CACHE_H__
+#define __CACHE_H__
+
+#include "csapp.h"
+#include <pthread.h>
+
+#define MAX_CACHE_SIZE 1049000
+#define MAX_OBJECT_SIZE 102400
+
+/*
+* A cacheNode is a response (value) from a web server
+* that is connected with a particular request (key)
+*/
+typedef struct cacheNode {
+	char* key;
+	char* value;
+	struct cacheNode* prev;
+	struct cacheNode* next;
+	unsigned int length;
+} cacheNode;
+
+/*
+* A cache is a linked list of cacheNodes
+*/ 
+typedef struct cacheList {
+	cacheNode* head;
+	cacheNode* tail;
+	pthread_rwlock_t* lock;
+	unsigned int bytesLeft;
+} cacheList;
+
+cacheList* initCache();
+void deleteCache(cacheList* list);
+void initNode(cacheNode* node);
+void setNode(cacheNode* node, char* index, unsigned int length);
+int addNode(cacheNode* node, cacheList* list);
+void deleteNode(cacheNode* node);
+cacheNode* findNode(cacheList* list, char* index);
+
+int readNodeContent(cacheList* list, char* index, char* content, unsigned int *len);
+int insertNodeContent(cacheList* list, char* index, char* content, unsigned int len);
+
+
+#endif

driver.sh

@@ -16,8 +16,8 @@
 #   - Check maximum cache object size
 
 
-if [ -z "$6" ]; then
-	echo "Usage: $0 <mode> <basic_pts> <concurrency_pts> <log_pts> <cleanup_pts> <cache_pts>"
+if [ -z "$7" ]; then
+	echo "Usage: $0 <mode> <basic_pts> <concurrency_pts> <log_pts> <mem_mgmt_pts> <cleanup_pts> <cache_pts>"
 	exit
 fi
 
@@ -26,13 +26,14 @@ MODE=$1
 MAX_BASIC=$2
 MAX_CONCURRENCY=$3
 MAX_LOG=$4
-MAX_CLEANUP=$5
-MAX_CACHE=$6
+MAX_MEM_MGMT=$5
+MAX_CLEANUP=$6
+MAX_CACHE=$7
 
 if [ $MODE != "multiprocess" -a $MODE != "processpool" -a \
 	$MODE != "multithread" -a $MODE != "threadpool" -a \
 	$MODE != "epoll" ]; then
-	echo "Usage: $0 <mode> <basic_pts> <concurrency_pts> <log_pts> <cleanup_pts> <cache_pts>"
+	echo "Usage: $0 <mode> <basic_pts> <concurrency_pts> <log_pts> <mem_mgmt_pts> <cleanup_pts> <cache_pts>"
 	echo "mode should be one of: multiprocess, processpool, multithread, threadpool, epoll"
 	exit
 fi
@@ -91,7 +92,7 @@ function download_proxy {
     cd $1
     curl --max-time ${TIMEOUT} --silent --proxy $4 --output $2 $3
     (( $? == 28 )) && echo "Error: Fetch timed out after ${TIMEOUT} seconds"
-    cd $HOME_DIR
+    cd "$HOME_DIR"
 }
 
 #
@@ -100,9 +101,9 @@ function download_proxy {
 #
 function download_proxy_slow {
     cd $1
-    $HOME_DIR/slow-client.py $4 $3 1 ${TIMEOUT} $2
+    "$HOME_DIR"/slow-client.py $4 $3 1 ${TIMEOUT} $2
     (( $? == 1 )) && echo "Error: Fetch timed out after ${TIMEOUT} seconds"
-    cd $HOME_DIR
+    cd "$HOME_DIR"
 }
 
 #
@@ -113,7 +114,7 @@ function download_noproxy {
     cd $1
     curl --max-time ${TIMEOUT} --silent --output $2 $3 
     (( $? == 28 )) && echo "Error: Fetch timed out after ${TIMEOUT} seconds"
-    cd $HOME_DIR
+    cd "$HOME_DIR"
 }
 
 #
@@ -239,6 +240,26 @@ then
     exit
 fi
 
+# Make sure we have an existing executable slow-client.py file
+if [ ! -x ./slow-client.py ]
+then 
+    echo "Error: ./slow-client.py not found or not an executable file."
+    exit
+fi
+
+# At the moment, slow-client.py requires python2
+if ! python -V 2>&1 | grep -q "^Python 2"
+then 
+    echo "Error: ./slow-client.py requires python version 2."
+    exit
+fi
+
+# Check for valgrind
+if ! valgrind -h > /dev/null
+then 
+    exit
+fi
+
 # Create the test directories if needed
 if [ ! -d ${PROXY_DIR} ]
 then
@@ -284,6 +305,9 @@ proxy_pid=$!
 # Wait for the proxy to start in earnest
 wait_for_port_use "${proxy_port}"
 
+# Wait for threads to be initialized
+sleep 3
+
 num_threads_pre=`ps --no-headers -Lo lwp --pid $proxy_pid | sort -u | wc -l`
 num_processes_pre=`ps --no-headers -o pid --pid $proxy_pid --ppid $proxy_pid | sort -u | wc -l`
 
@@ -376,8 +400,9 @@ echo "logScore: $logScore/${MAX_LOG}"
 #
 
 echo ""
-echo "*** Cleanup ***"
+echo "*** Memory management and Cleanup ***"
 
+memmgmtScore=${MAX_MEM_MGMT}
 cleanupScore=${MAX_CLEANUP}
 def_lost=`grep 'definitely lost:' $VALGRIND_LOG | awk '{ print $4 }'`
 indir_lost=`grep 'indirectly lost:' $VALGRIND_LOG | awk '{ print $4 }'`
@@ -390,14 +415,15 @@ if [ \( -n "$def_lost" -a "$def_lost" != "0" \) -o \
 	\( -n "$indir_lost" -a "$indir_lost" != "0" \) -o \
 	\( -n "$poss_lost" -a "$poss_lost" != "0" \) ]; then
         echo "   Bytes lost, either definitely, indirectly, or possibly"
-	cleanupScore=`expr ${cleanupScore} - "(" ${MAX_CLEANUP} / 2 ")"`
+	memmgmtScore=`expr ${memmgmtScore} - ${MAX_MEM_MGMT}`
 fi
 
 if [ -n "$still_reach" -a "$still_reach" != "0" ]; then
         echo "   Bytes still reachable"
-	cleanupScore=`expr ${cleanupScore} - "(" ${MAX_CLEANUP} / 2 ")"`
+	cleanupScore=`expr ${cleanupScore} - ${MAX_CLEANUP}`
 fi
 
+echo "memmgmtScore: $memmgmtScore/${MAX_MEM_MGMT}"
 echo "cleanupScore: $cleanupScore/${MAX_CLEANUP}"
 
 ######