lru cache

Author: seckcoder

proxylab-handout/Makefile

@@ -15,24 +15,24 @@ all: proxy
 %.o: %.c
 	$(CC) $(CFLAGS) -c $<
 
-H_FILES = util.h dstring.h csapp.h
+H_FILES = util.h bytes.h csapp.h cache.h
 
-OBJ_SRC = csapp.c dstring.c util.c
+OBJ_SRC = csapp.c bytes.c util.c cache.c
 
 PROXY_SRC = $(OBJ_SRC) proxy.c
 
 PROXY_OBJ = $(PROXY_SRC:%c=%o)
 
 
 proxy: $(PROXY_OBJ) $(H_FILES)
-	$(CC) $(LDFLAGS) $(PROXY_OBJ) -o $@
+	$(CC) $(CFLAGS) $(LDFLAGS) $(PROXY_OBJ) -o $@
 
 TEST_SRC = $(OBJ_SRC) test.c
 
 TEST_OBJ = $(TEST_SRC:%c=%o)
 
 test: $(TEST_OBJ) $(H_FILES)
-	$(CC) $(LDFLAGS) $(TEST_OBJ) -o $@
+	$(CC) $(CFLAGS) $(LDFLAGS) $(TEST_OBJ) -o $@
 
 # Creates a tarball in ../proxylab-handin.tar that you should then
 # hand in to Autolab. DO NOT MODIFY THIS!

proxylab-handout/bytes.c

@@ -0,0 +1,74 @@
+#include "bytes.h"
+#include <string.h>
+
+#define DEFAULT_LENGTH 1024
+
+void bytes_malloc(Bytes *pstr)
+{
+    pstr->size = DEFAULT_LENGTH;
+    pstr->buf = (char *)malloc(pstr->size * sizeof(char));
+    pstr->len = 0;
+}
+
+void bytes_free(Bytes *pstr)
+{
+    pstr->len = 0;
+    pstr->size = 0;
+    free(pstr->buf);
+}
+
+/* ceil_divide: a divide by b, return ceil value
+ * Assert a > b.
+ */
+inline static size_t ceil_divide(size_t a, size_t b)
+{
+    size_t m = 2;
+    for (m = 2; m * b < a; m+=1) {}
+    return m;
+}
+
+/* bytes_append : append cstr to the end of pstr.
+ * Assert cstr and pstr is not overlapped.
+ *
+ * TODO: support overlapping
+ */
+void bytes_append(Bytes *pstr, const char *cstr)
+{
+    size_t cstr_len = strlen(cstr);
+    bytes_appendn(pstr, cstr, cstr_len);
+}
+
+void bytes_appendn(Bytes *pstr, const char *buf, size_t buf_len)
+{
+    if (pstr->len + buf_len + 1 <= pstr->size) {
+        int i;
+        for (i = 0; i < buf_len; i++) {
+            pstr->buf[pstr->len+i] = buf[i];
+        }
+        pstr->len += buf_len;
+    } else {
+        size_t multipler = ceil_divide((buf_len + pstr->len + 1),
+                pstr->size);
+        size_t new_size = multipler * pstr->size;
+        char *new_buf = (char *)malloc(new_size*sizeof(char));
+        int i;
+        for (i = 0; i < pstr->len; i++) {
+            new_buf[i] = pstr->buf[i];
+        }
+        for (i = 0; i < buf_len; i++) {
+            new_buf[pstr->len+i] = buf[i];
+        }
+        pstr->len += buf_len;
+        pstr->size = new_size;
+        pstr->buf = new_buf;
+    }
+}
+
+/* return bytes as a cstr */
+void bytes_cstr(Bytes str, char *cstr)
+{
+    for (int i = 0; i < str.len; i++) {
+        cstr[i] = str.buf[i];
+    }
+    cstr[str.len] = '\0';
+}

proxylab-handout/bytes.h

@@ -0,0 +1,26 @@
+#ifndef __DBYTES_H__
+#define __DBYTES_H__
+
+#include <stdlib.h>
+
+typedef struct Bytes {
+    char *buf;
+    size_t size; /* content size */
+    size_t len; /* bytes length */
+} Bytes;
+
+#define bytes_length(str) ((str).len)
+#define bytes_buf(str) ((str).buf)
+#define bytes_size(str) ((str).size)
+#define bytes_ref(str, i) (bytes_buf(str)[(i)])
+
+void bytes_malloc(Bytes *pstr);
+
+void bytes_free(Bytes *pstr);
+
+void bytes_append(Bytes *pstr, const char *cstr);
+void bytes_appendn(Bytes *pstr, const char *buf, size_t buf_len);
+
+void bytes_cstr(Bytes str, char *cstr);
+
+#endif

proxylab-handout/cache.c

@@ -0,0 +1,109 @@
+#include "cache.h"
+
+#define node_cache_size(pnode) (((pnode)->value_len)*sizeof(char))
+
+static lru_cache_node_t *create_empty_node()
+{
+    lru_cache_node_t *pnode = (lru_cache_node_t*)Malloc(sizeof(lru_cache_node_t));
+    pnode->value_len = 0;
+    pnode->key[0] = '\0';
+    pnode->value = NULL;
+    pnode->next = NULL;
+    pnode->prev = NULL;
+    return pnode;
+}
+
+static void free_node(lru_cache_node_t *pnode)
+{
+    free(pnode->value);
+    free(pnode);
+}
+static lru_cache_node_t *create_node_from(
+        const char *key,
+        const char *value,
+        size_t value_len)
+{
+    lru_cache_node_t *pnode = create_empty_node();
+    pnode->value = (char *)malloc(value_len*sizeof(char));
+    pnode->value_len = value_len;
+    strcpy(pnode->key, key);
+    for (int i = 0; i < value_len; i++) {
+        pnode->value[i] = value[i];
+    }
+    return pnode;
+}
+
+void lru_cache_init(lru_cache_t *pcache, size_t max_cache_size)
+{
+    pcache->max_cache_size = max_cache_size;
+    pcache->sentinel = create_empty_node();
+    pcache->sentinel->next = pcache->sentinel;
+    pcache->sentinel->prev = pcache->sentinel;
+}
+
+void lru_cache_free(lru_cache_t *pcache)
+{
+    lru_cache_node_t *cur, *next = NULL;
+    cur = pcache->sentinel->next;
+    while (cur != pcache->sentinel) {
+        next = cur->next;
+        free_node(cur);
+        cur = next;
+    }
+    free_node(pcache->sentinel);
+}
+
+
+static inline void lru_cache_insert_next(lru_cache_t *pcache,
+        lru_cache_node_t *prev,
+        lru_cache_node_t *pnode)
+{
+
+    pnode->next = prev->next;
+    pnode->prev = prev;
+    prev->next->prev = pnode;
+    prev->next = pnode;
+    pcache->cache_size += node_cache_size(pnode);
+}
+
+static inline void lru_cache_remove(lru_cache_t *pcache,
+        lru_cache_node_t *cur)
+{
+    cur->prev->next = cur->next;
+    cur->next->prev = cur->prev;
+    pcache->cache_size -= node_cache_size(cur);
+}
+
+/*
+ * assert prev->next != NULL
+ */
+static void lru_cache_raise(lru_cache_t *pcache, lru_cache_node_t *cur)
+{
+    // remove the node
+    lru_cache_remove(pcache, cur);
+    lru_cache_insert_next(pcache, pcache->sentinel, cur);
+}
+
+lru_cache_node_t *lru_cache_find(lru_cache_t *pcache, const char *key)
+{
+    for (lru_cache_node_t *cur = pcache->sentinel->next;
+            cur != pcache->sentinel; cur = cur->next) {
+        if (strcasecmp(cur->key, key) == 0) {
+            lru_cache_raise(pcache, cur);
+            return cur;
+        }
+    }
+    return NULL;
+}
+
+void lru_cache_insert(lru_cache_t *pcache,
+        const char *key,
+        const char *value,
+        size_t value_len)
+{
+    lru_cache_node_t *pnode = create_node_from(key, value, value_len);
+    lru_cache_insert_next(pcache, pcache->sentinel, pnode);
+    while (pcache->cache_size > pcache->max_cache_size) {
+        lru_cache_remove(pcache, lru_cache_tail(pcache));
+    }
+}

proxylab-handout/cache.h

@@ -0,0 +1,32 @@
+#ifndef __CACHE_H__
+#define __CACHE_H__
+
+#include "csapp.h"
+
+typedef struct lru_cache_node_t {
+    char *value;
+    size_t value_len;
+    // for simplicity, assume key is a null terminated string
+    char key[MAXLINE];
+    struct lru_cache_node_t *next;
+    struct lru_cache_node_t *prev;
+} lru_cache_node_t;
+
+typedef struct lru_cache_t {
+    size_t max_cache_size;
+    lru_cache_node_t *sentinel;
+    lru_cache_node_t *front; /* front points to most recently used */
+    // lru_cache_node_t *tail;  /* tail points to least recently used */
+    size_t cache_size;
+} lru_cache_t;
+
+void lru_cache_init(lru_cache_t *pcache, size_t max_cache_size);
+void lru_cache_free(lru_cache_t *pcache);
+
+lru_cache_node_t *lru_cache_find(lru_cache_t *pcache, const char *key);
+
+void lru_cache_insert(lru_cache_t *pcache, const char *key, const char *value, size_t value_len);
+
+#define lru_cache_tail(pcache) ((pcache)->sentinel->prev)
+
+#endif