Add from and to memory copy

TP/TP1/rendu/config.h

@@ -0,0 +1,7 @@
+#ifndef DEF_CONFIG_H
+#define DEF_CONFIG_H
+
+#define PAGE_SIZE 4096
+#define PAGE_COUNT 100
+
+#endif

TP/TP1/rendu/linked_list.c

@@ -29,7 +29,7 @@ void insertFirst(linkedList *list, int key, void *data) {
 
 //delete first item
 node* deleteFirst(linkedList *list) {
-    if (list->head == NULL) {
+    if (!list->head) {
         return NULL;
     }
 
@@ -50,7 +50,7 @@ node* find(linkedList *list, int key) {
     node* current = list->head;
 
     //if list is empty
-    if(list->head == NULL) {
+    if(!current) {
         return NULL;
     }
 
@@ -58,7 +58,7 @@ node* find(linkedList *list, int key) {
     while(current->key != key) {
 	
         //if it is last node
-        if(current->next == NULL) {
+        if(!current->next) {
             return NULL;
         } else {
             //go to next link
@@ -78,7 +78,7 @@ node* deleteElement(linkedList *list, int key) {
     node* previous = NULL;
 	
     //if list is empty
-    if(list->head == NULL) {
+    if(!list->head) {
         return NULL;
     }
 
@@ -86,7 +86,7 @@ node* deleteElement(linkedList *list, int key) {
     while(current->key != key) {
 
         //if it is last node
-        if(current->next == NULL) {
+        if(!current->next) {
             return NULL;
         } else {
             //store reference to current link
@@ -110,7 +110,7 @@ node* deleteElement(linkedList *list, int key) {
 
 //is list empty
 bool isEmpty(linkedList *list) {
-    return list->head == NULL;
+    return !list->head;
 }
 
 int length(linkedList *list) {

TP/TP1/rendu/linked_list.h

@@ -1,3 +1,6 @@
+#ifndef DEF_LLIST_H
+#define DEF_LLIST_H
+
 #include <stdbool.h>
 
 typedef struct node {
@@ -16,4 +19,6 @@ node* deleteFirst(linkedList *list);
 node* find(linkedList *list, int key);
 node* deleteElement(linkedList *list, int key);
 bool isEmpty(linkedList *list);
-int length(linkedList *list);
+int length(linkedList *list);
+
+#endif

TP/TP1/rendu/mmap.c

@@ -5,31 +5,32 @@
 
 #define CHECK_FERROR(f) { if (ferror(f)) {fprintf(stderr, "IO Error"); exit(1);} }
 
+#include "config.h"
 #include "mmap.h"
 
 MMap* mmap_init(){
     MMap *mmap = malloc(sizeof(MMap));
-    mmap->size = 4096*100;
+    mmap->size = PAGE_SIZE*PAGE_COUNT;
     mmap->memory = malloc(mmap->size);
     mmap->count = 0;
     mmap->support = malloc(sizeof(PageInfo));
-    mmap->support->data = malloc(4096);
+    mmap->support->data = malloc(PAGE_SIZE);
     mmap->free_list = createLinkedList();
-    // insert 100 pages in the free list
+    // insert PAGE_COUNT pages in the free list
-    for (int i=0; i < 100; i++) {
+    for (int i=0; i < PAGE_COUNT; i++) {
         PageInfo *page = malloc(sizeof(PageInfo));
-        page->data = mmap->memory + i*4096;
+        page->data = mmap->memory + i*PAGE_SIZE;
         page->key = i;
         insertFirst(mmap->free_list, i, page);
     }
     mmap->alloc_list = createLinkedList();
     mmap->swap = fopen("/tmp/myswap", "wb+");
     int tmp = -1;
-    for (int i=0; i < 100; i++) {
+    for (int i=0; i < PAGE_COUNT; i++) {
         fwrite(&tmp, sizeof(int), 1, mmap->swap);
     }
     char tmp2 = '\0';
-    for (int i=0; i < 100*4096; i++) {
+    for (int i=0; i < PAGE_COUNT*PAGE_SIZE; i++) {
             fwrite(&tmp2, 1, 1, mmap->swap);
     }
     return mmap;
@@ -74,7 +75,7 @@ int move_to_swap(MMap *mmap, PageInfo *page) {
     fseek(mmap->swap, 0, SEEK_SET);
     CHECK_FERROR(mmap->swap);
 
-    for (int i=0; i < 100; i++) {
+    for (int i=0; i < PAGE_COUNT; i++) {
         fread(&key, sizeof(int), 1, mmap->swap);
         CHECK_FERROR(mmap->swap);
 
@@ -85,10 +86,10 @@ int move_to_swap(MMap *mmap, PageInfo *page) {
             fwrite(&page->key, sizeof(int), 1, mmap->swap);
             CHECK_FERROR(mmap->swap);
 
-            fseek(mmap->swap, 100*sizeof(int) + i*4096, SEEK_SET);
+            fseek(mmap->swap, PAGE_COUNT*sizeof(int) + i*PAGE_SIZE, SEEK_SET);
             CHECK_FERROR(mmap->swap);
 
-            fwrite(page->data, 4096, 1, mmap->swap);
+            fwrite(page->data, PAGE_SIZE, 1, mmap->swap);
             CHECK_FERROR(mmap->swap);
 
             return 0;
@@ -102,17 +103,17 @@ PageInfo* read_from_swap(MMap* mmap, PageInfo *page) {
     fseek(mmap->swap, 0, SEEK_SET);
     CHECK_FERROR(mmap->swap);
 
-    for (int i=0; i < 100; i++) {
+    for (int i=0; i < PAGE_COUNT; i++) {
         (void)fread(&key, sizeof(int), 1, mmap->swap);
         CHECK_FERROR(mmap->swap);
 
         if (key != page->key)
             continue;
 
-        fseek(mmap->swap, 100*sizeof(int) + i*4096, SEEK_SET);
+        fseek(mmap->swap, PAGE_COUNT*sizeof(int) + i*PAGE_SIZE, SEEK_SET);
         CHECK_FERROR(mmap->swap);
 
-        fread(page->data, 4096, 1, mmap->swap);
+        fread(page->data, PAGE_SIZE, 1, mmap->swap);
         CHECK_FERROR(mmap->swap);
 
         fseek(mmap->swap, i*sizeof(int), SEEK_SET);
@@ -139,7 +140,7 @@ PageInfo* page_lookup(MMap* mmap, int key) {
         PageInfo* swapped_page = deleteFirst(mmap->alloc_list)->data;
         move_to_swap(mmap, swapped_page);
 
-        memcpy(swapped_page->data, mmap->support->data, 4096);
+        memcpy(swapped_page->data, mmap->support->data, PAGE_SIZE);
         swapped_page->key = key;
         insertFirst(mmap->alloc_list, key, swapped_page);
         return page;
@@ -157,7 +158,7 @@ void page_remove(MMap *mmap, int key) {
 }
 
 PageInfo *page_create(MMap *mmap, bool *moved_to_swap) {
-    if (mmap->count >= 200)
+    if (mmap->count >= 2*PAGE_COUNT)
         return NULL;
 
     PageInfo* page = page_alloc(mmap);

TP/TP1/rendu/mmap.h

@@ -1,3 +1,6 @@
+#ifndef DEF_MMAP_H
+#define DEF_MMAP_H
+
 #include <stdio.h>
 #include <stdbool.h>
 
@@ -28,4 +31,6 @@ int move_to_swap(MMap *mmap, PageInfo *page);
 PageInfo* read_from_swap(MMap* mmap, PageInfo *page);
 PageInfo *page_lookup(MMap *mmap, int key);
 void page_remove(MMap *mmap, int key);
-PageInfo *page_create(MMap *mmap, bool *moved_to_swap);
+PageInfo *page_create(MMap *mmap, bool *moved_to_swap);
+
+#endif

TP/TP1/rendu/test.c

@@ -1,8 +1,18 @@
 #include <string.h>
 
-#include "mmap.h"
+#include "vmap.h"
+
+int main() {
+    // Add more tests here
+    VMap* vmap = vmap_init();
+
+    char* data1 = my_malloc(vmap, 30*sizeof(char));
+    char* data2 = my_malloc(vmap, 30*sizeof(char));
+
+    my_copy(vmap, data1, data2, 30*sizeof(char));
+
+    my_free(vmap, data1);
+    my_free(vmap, data2);
 
-int main(int argc, char **argv) {
-    // Some really cool tests!
     return 0;
 }

TP/TP1/rendu/vmap.c

@@ -0,0 +1,162 @@
+#include <inttypes.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+
+#include "config.h"
+#include "vmap.h"
+
+VMap* vmap_init() {
+    VMap* vmap = (VMap*)malloc(sizeof(VMap));
+    vmap->mmap = mmap_init();
+    vmap->pages = createLinkedList();
+    vmap->index = 0;
+
+    return vmap;
+}
+
+PageMapInfo* vmap_new_page(VMap* vmap) {
+    PageMapInfo* page = (PageMapInfo*)malloc(sizeof(PageMapInfo));
+    
+    bool moved;
+    page->key = page_create(vmap->mmap, &moved)->key;
+    page->start = vmap->index;
+    page->cursor = 0;
+    page->nb_allocs = 0;
+    page->swapped = moved;
+
+    vmap->index += PAGE_SIZE;
+
+    insertFirst(vmap->pages, page->start, page);
+
+    return page;
+}
+
+int page_map_available_size(PageMapInfo* page) {
+    int avail = page->start + PAGE_SIZE - page->cursor;
+    assert(avail >= 0);
+    return avail;
+}
+
+
+void vmap_free_page(VMap* vmap, PageMapInfo* page) {
+    deleteElement(vmap->pages, page->key);
+    page_remove(vmap->mmap, page->key);
+    free(page);
+}
+
+PageMapInfo* vmap_get_page(VMap* vmap, void* ptr) {
+    node* current = vmap->pages->head;
+    while (current) {
+        PageMapInfo* page = current->data;
+        if (page->start <= (int64_t)ptr && page->start+PAGE_SIZE > (int64_t)ptr) {
+            return page;
+        }
+        current = current->next;
+    }
+    return NULL;
+}
+
+void vmap_unswap(VMap* vmap, PageMapInfo* page) {
+    if (!page->swapped)
+        return;
+
+    read_from_swap(vmap->mmap, page_lookup(vmap->mmap, page->key));
+    page->swapped = false;
+}
+
+
+void* my_malloc(VMap* vmap, int size) {
+    if (size > PAGE_SIZE) {
+        fprintf(stderr, "my_malloc: Requesting too much space: %d > %d\n", size, PAGE_SIZE);
+        exit(1);
+    }
+
+    // Parcours de la liste pour trouver un candidat. Sinon, nouvelle page
+    node* current = vmap->pages->head;
+    while (current) {
+        PageMapInfo* page = current->data;
+        if (page_map_available_size(page) >= size) {
+            void* ptr = (void*)((uint64_t)page->start+page->cursor);
+            page->cursor += size;
+            page->nb_allocs++;
+
+            return ptr;
+        }
+        current = current->next;
+    }
+
+    PageMapInfo* page = vmap_new_page(vmap);
+
+    void* ptr = (void*)((uint64_t)page->start+page->cursor);
+    page->cursor += size;
+    page->nb_allocs++;
+
+    return ptr;
+}
+
+void my_free(VMap* vmap, void* ptr) {
+    PageMapInfo* page = vmap_get_page(vmap, ptr);
+
+    if (!page) {
+        fprintf(stderr, "my_free: Double free or memory corrupted\n");
+        exit(1);
+    }
+
+    page->nb_allocs--;       
+    if (page->nb_allocs == 0) {
+        vmap_free_page(vmap, page);
+    }
+}
+
+void my_copy(VMap* vmap, void* src, void* dst, int size) {
+    PageMapInfo* page_map_src =  vmap_get_page(vmap, src);
+    PageMapInfo* page_map_dst =  vmap_get_page(vmap, dst);
+
+    if (((int64_t)src % PAGE_SIZE) + size >= PAGE_SIZE) {
+        fprintf(stderr, "my_copy: size not available in this src page\n");
+        exit(1);
+    }
+
+    if (((int64_t)dst % PAGE_SIZE) + size >= PAGE_SIZE) {
+        fprintf(stderr, "my_copy: size not available in this dst page\n");
+        exit(1);
+    }
+
+    if (page_map_src->swapped) {
+        vmap_unswap(vmap, page_map_src);
+    }
+    if (page_map_dst->swapped) {
+        vmap_unswap(vmap, page_map_dst);
+    }
+
+    PageInfo* page_src = page_lookup(vmap->mmap, page_map_src->key);
+    PageInfo* page_dst = page_lookup(vmap->mmap, page_map_dst->key);
+
+    memcpy(page_dst->data+((int64_t)src % PAGE_SIZE), page_src->data+((int64_t)dst % PAGE_SIZE), size);
+}
+
+void vmap_copy_to_memory(struct VMap *vmap, void *src, void *dst, int size) {
+    PageMapInfo* page_map = vmap_get_page(vmap, src);
+    PageInfo* page = page_lookup(vmap->mmap, page_map->key);
+
+    if (!page) {
+        fprintf(stderr, "vmap_copy_to_memory: page not found\n");
+        exit(1);
+    }
+    
+    memcpy(page->data + ((int64_t)src % PAGE_SIZE), dst, size);
+}
+
+void vmap_copy_from_memory(struct VMap *vmap, void *src, void *dst, int size) {
+    PageMapInfo* page_map = vmap_get_page(vmap, dst);
+    PageInfo* page = page_lookup(vmap->mmap, page_map->key);
+
+    if (!page) {
+        fprintf(stderr, "vmap_copy_to_memory: page not found\n");
+        exit(1);
+    }
+    
+    memcpy(src, page->data + ((int64_t)dst % PAGE_SIZE), size);
+}

TP/TP1/rendu/vmap.h

@@ -1,3 +1,34 @@
-void *my_malloc(int size);
+#ifndef DEF_VMAP_H
-void my_free(void *data);
+#define DEF_VMAP_H
-void my_copy(void *mem, void *data, int size);
+
+#include "mmap.h"
+
+typedef struct VMap {
+    MMap* mmap;
+    linkedList* pages;
+    int index; // index of virt memory
+} VMap;
+
+typedef struct PageMapInfo {
+    int start;
+    int key; // key for mmap
+    int cursor; // Last allocation end
+    int nb_allocs; // Free page if 0
+    bool swapped;
+} PageMapInfo;
+
+VMap* vmap_init();
+
+/**
+ * Get page hosting a certain pointer
+*/
+PageMapInfo* vmap_get_page(VMap* vmap, void* ptr);
+
+void vmap_copy_from_memory(struct VMap *vmap, void *src, void *dst, int size);
+void vmap_copy_to_memory(struct VMap *vmap, void *src, void *dst, int size);
+
+void* my_malloc(VMap* vmap, int size);
+void my_free(VMap* vmap, void* ptr);
+void my_copy(VMap* vmap, void* src, void* dst, int size);
+
+#endif