X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/bd6274487954af16de90c357090e2d698d886cd1..fa92714018ad2134de97bf403cbebeee6d863b3f:/src/xbt/dict.c

diff --git a/src/xbt/dict.c b/src/xbt/dict.c
index c28171f432..c97f224a32 100644
--- a/src/xbt/dict.c
+++ b/src/xbt/dict.c
@@ -10,12 +10,20 @@
 #include <string.h>
 #include "xbt/ex.h"
 #include "xbt/log.h"
+#include "xbt/mallocator.h"
+#include "xbt_modinter.h"
 #include "dict_private.h"
 
 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dict,xbt,
    "Dictionaries provide the same functionnalities than hash tables");
 /*####[ Private prototypes ]#################################################*/
 
+static xbt_mallocator_t dict_mallocator = NULL;
+static void* dict_mallocator_new_f(void);
+static void dict_mallocator_free_f(void* dict);
+static void dict_mallocator_reset_f(void* dict);
+
+
 /*####[ Code ]###############################################################*/
 
 /**
@@ -36,14 +44,23 @@ xbt_dict_t xbt_dict_new(void) {
  * \see xbt_dict_new(), xbt_dict_free()
  */
 xbt_dict_t xbt_dict_new_ext(int hashsize) {
-  int i;
-  xbt_dict_t dict = xbt_new0(s_xbt_dict_t, 1);
+  xbt_dict_t dict;
+
+  if (dict_mallocator == NULL) {
+    /* first run */
+    dict_mallocator = xbt_mallocator_new(256,
+					 dict_mallocator_new_f,
+					 dict_mallocator_free_f,
+					 dict_mallocator_reset_f);
+    dict_elm_mallocator = xbt_mallocator_new(256,
+					     dict_elm_mallocator_new_f,
+					     dict_elm_mallocator_free_f,
+					     dict_elm_mallocator_reset_f);
+  }
+
+  dict = xbt_mallocator_get(dict_mallocator);
   dict->table_size = hashsize;
   dict->table = xbt_new0(xbt_dictelm_t, dict->table_size);
-
-  for (i = 0; i < hashsize; i++) {
-    dict->table[i] = NULL;
-  }
   dict->count = 0;
 
   return dict;
@@ -58,17 +75,22 @@ xbt_dict_t xbt_dict_new_ext(int hashsize) {
 void xbt_dict_free(xbt_dict_t *dict) {
   int i;
   xbt_dictelm_t current, previous;
+  int table_size;
+  xbt_dictelm_t *table;
+
   if (dict != NULL && *dict != NULL) {
-    for (i = 0; i < (*dict)->table_size; i++) {
-      current = (*dict)->table[i];
+    table_size = (*dict)->table_size;
+    table = (*dict)->table;
+    for (i = 0; i < table_size; i++) {
+      current = table[i];
       while (current != NULL) {
 	previous = current;
 	current = current->next;
 	xbt_dictelm_free(previous);
       }
     }
-    xbt_free((*dict)->table);
-    xbt_free(*dict);
+    xbt_free(table);
+    xbt_mallocator_release(dict_mallocator, *dict);
     *dict = NULL;
   }
 }
@@ -105,12 +127,13 @@ void xbt_dict_hashsize_set(xbt_dict_t dict, int hashsize) {
 /**
  * Returns the hash code of a string.
  */
-unsigned int xbt_dict_hash(const char *str) {
+static unsigned int xbt_dict_hash(const char *str, int str_len) {
   /* fast implementation of djb2 algorithm */
   unsigned int hash = 5381;
   int c;
   
-  while ((c = *str++)) {
+  while (str_len--) {
+    c = *str++;
     hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
   }
   
@@ -136,7 +159,7 @@ void xbt_dict_set_ext(xbt_dict_t      dict,
 		      void_f_pvoid_t  *free_ctn) {
   xbt_assert(dict);
 
-  unsigned int hash_code = xbt_dict_hash(key) % dict->table_size;
+  unsigned int hash_code = xbt_dict_hash(key,key_len) % dict->table_size;
   xbt_dictelm_t current, previous = NULL;
 
   current = dict->table[hash_code];
@@ -204,7 +227,7 @@ void *xbt_dict_get_ext(xbt_dict_t      dict,
 		       int             key_len) {
   xbt_assert(dict);
 
-  unsigned int hash_code = xbt_dict_hash(key) % dict->table_size;
+  unsigned int hash_code = xbt_dict_hash(key,key_len) % dict->table_size;
   xbt_dictelm_t current;
 
   current = dict->table[hash_code];
@@ -283,7 +306,7 @@ void xbt_dict_remove_ext(xbt_dict_t  dict,
 			 int          key_len) {
   xbt_assert(dict);
 
-  unsigned int hash_code = xbt_dict_hash(key) % dict->table_size;
+  unsigned int hash_code = xbt_dict_hash(key,key_len) % dict->table_size;
   xbt_dictelm_t current, previous = NULL;
 
   current = dict->table[hash_code];
@@ -362,7 +385,7 @@ int xbt_dict_length(xbt_dict_t dict) {
 void xbt_dict_add_element(xbt_dict_t dict, xbt_dictelm_t element) {
   xbt_assert(dict);
 
-  int hashcode = xbt_dict_hash(element->key) % dict->table_size;
+  int hashcode = xbt_dict_hash(element->key,element->key_len) % dict->table_size;
   element->next = dict->table[hashcode];
   dict->table[hashcode] = element;
 }
@@ -397,6 +420,31 @@ void xbt_dict_dump(xbt_dict_t     dict,
   }
 }
 
+/**
+ * Destroy the dict mallocators.
+ * This is an internal XBT function called by xbt_exit().
+ */
+void xbt_dict_exit(void) {
+  if (dict_mallocator != NULL) {
+    xbt_mallocator_free(dict_mallocator);
+    xbt_mallocator_free(dict_elm_mallocator);
+  }
+}
+
+static void* dict_mallocator_new_f(void) {
+  return xbt_new(s_xbt_dict_t, 1);
+}
+
+static void dict_mallocator_free_f(void* dict) {
+  xbt_free(dict);
+}
+
+static void dict_mallocator_reset_f(void* dict) {
+  /* nothing to do because all fields are
+   * initialized in xbt_dict_new
+   */
+}
+
 #ifdef SIMGRID_TEST
 #include "xbt.h"
 #include "xbt/ex.h"
@@ -411,11 +459,10 @@ static void print_str(void *str) {
   printf("%s",(char*)PRINTF_STR(str));
 }
 
-static void debuged_add(xbt_dict_t head,const char*key)
-{
-  char *data=xbt_strdup(key);
+static void debuged_add_ext(xbt_dict_t head,const char*key,const char*data_to_fill) {
+  char *data=xbt_strdup(data_to_fill);
 
-  xbt_test_log1("Add %s",PRINTF_STR(key));
+  xbt_test_log2("Add %s under %s",PRINTF_STR(data_to_fill),PRINTF_STR(key));
 
   xbt_dict_set(head,key,data,&free);
   if (XBT_LOG_ISENABLED(xbt_dict,xbt_log_priority_debug)) {
@@ -423,6 +470,9 @@ static void debuged_add(xbt_dict_t head,const char*key)
     fflush(stdout);
   }
 }
+static void debuged_add(xbt_dict_t head,const char*key) {
+   debuged_add_ext(head,key,key);
+}
 
 static void fill(xbt_dict_t *head) {
   xbt_test_add0("Fill in the dictionnary");
@@ -439,14 +489,21 @@ static void fill(xbt_dict_t *head) {
   debuged_add(*head,"123457");
 }
 
-static void search(xbt_dict_t head,const char*key) {
-  void *data;
+
+static void search_ext(xbt_dict_t head,const char*key, const char *data) {
+  void *found;
   
   xbt_test_add1("Search %s",key);
-  data=xbt_dict_get(head,key);
-  xbt_test_log1("Found %s",(char *)data);
+  found=xbt_dict_get(head,key);
+  xbt_test_log1("Found %s",(char *)found);
   if (data)
-    xbt_test_assert0(!strcmp((char*)data,key),"Key and data do not match");
+    xbt_test_assert1(found,"data do not match expectations: found NULL while searching for %s",data);
+  if (found)
+    xbt_test_assert2(!strcmp((char*)data,found),"data do not match expectations: found %s while searching for %s", (char*)found, data);
+}
+
+static void search(xbt_dict_t head,const char*key) {
+  search_ext(head,key,key);
 }
 
 static void debuged_remove(xbt_dict_t head,const char*key) {
@@ -470,18 +527,21 @@ static void traverse(xbt_dict_t head) {
 }
 
 static void search_not_found(xbt_dict_t head, const char *data) {
+  int ok=0;
   xbt_ex_t e;
 
   xbt_test_add1("Search %s (expected not to be found)",data);
 
   TRY {    
-    data = xbt_dict_get(head,"Can't be found");
+    data = xbt_dict_get(head, data);
     THROW1(unknown_error,0,"Found something which shouldn't be there (%s)",data);
   } CATCH(e) {
     if (e.category != not_found_error) 
       xbt_test_exception(e);
     xbt_ex_free(e);
+    ok=1;
   }
+  xbt_test_assert0(ok,"Exception not raised");
 }
 
 static void count(xbt_dict_t dict, int length) {
@@ -501,6 +561,10 @@ XBT_TEST_UNIT("basic",test_dict_basic,"Basic usage: change, retrieve, traverse")
   xbt_test_add0("Traverse the full dictionnary");
   fill(&head);
   count(head, 7);
+   
+  debuged_add_ext(head,"toto","tutu");
+  search_ext(head,"toto","tutu");
+  debuged_remove(head,"toto");
 
   search(head,"12a");
   traverse(head);
@@ -622,7 +686,7 @@ XBT_TEST_UNIT("nulldata",test_dict_nulldata,"NULL data management"){
 
   xbt_test_add0("Store NULL under 'null'");
   xbt_dict_set(head,"null",NULL,NULL);
-  search(head,"null");
+  search_ext(head,"null",NULL);
 
   xbt_test_add0("Check whether I see it while traversing...");
   {