+ xbt_dynar_foreach(sizes, count, size) {
+ /* Copy values of this one into all_sizes */
+ int prevcount;
+ if (xbt_dynar_length(all_sizes) <= count) {
+ prevcount = size;
+ xbt_dynar_set(all_sizes, count, &prevcount);
+ } else {
+ xbt_dynar_get_cpy(all_sizes, count, &prevcount);
+ prevcount += size;
+ xbt_dynar_set(all_sizes, count, &prevcount);
+ }
+
+ /* Report current sizes */
+ if (count == 0)
+ continue;
+ if (size == 0)
+ continue;
+ printf("%delm x %u cells; ", count, size);
+ }
+ }
+ printf("\n");
+ xbt_dynar_free(&sizes);
+}
+
+/**
+ * Create the dict mallocators.
+ * This is an internal XBT function called during the lib initialization.
+ * It can be used several times to recreate the mallocator, for example when you switch to MC mode
+ */
+void xbt_dict_preinit(void)
+{
+ if (dict_elm_mallocator != NULL) {
+ /* Already created. I guess we want to switch to MC mode, so kill the previously created mallocator */
+ xbt_mallocator_free(dict_elm_mallocator);
+ xbt_mallocator_free(dict_het_elm_mallocator);
+ }
+
+ dict_elm_mallocator = xbt_mallocator_new(256,
+ dict_elm_mallocator_new_f,
+ dict_elm_mallocator_free_f,
+ dict_elm_mallocator_reset_f);
+ dict_het_elm_mallocator = xbt_mallocator_new(256,
+ dict_het_elm_mallocator_new_f,
+ dict_het_elm_mallocator_free_f,
+ dict_het_elm_mallocator_reset_f);
+}
+
+/**
+ * Destroy the dict mallocators.
+ * This is an internal XBT function during the lib initialization
+ */
+void xbt_dict_postexit(void)
+{
+ if (dict_elm_mallocator != NULL) {
+ xbt_mallocator_free(dict_elm_mallocator);
+ dict_elm_mallocator = NULL;
+ xbt_mallocator_free(dict_het_elm_mallocator);
+ dict_het_elm_mallocator = NULL;
+ }
+ if (all_sizes) {
+ unsigned int count;
+ int size;
+ double avg = 0;
+ int total_count = 0;
+ printf("Overall stats:");
+ xbt_dynar_foreach(all_sizes, count, size) {
+ if (count == 0)
+ continue;
+ if (size == 0)
+ continue;
+ printf("%delm x %d cells; ", count, size);
+ avg += count * size;
+ total_count += size;
+ }
+ printf("; %f elm per cell\n", avg / (double) total_count);
+ }
+}
+
+#ifdef SIMGRID_TEST
+#include "xbt.h"
+#include "xbt/ex.h"
+#include "portable.h"
+
+XBT_LOG_EXTERNAL_CATEGORY(xbt_dict);
+XBT_LOG_DEFAULT_CATEGORY(xbt_dict);
+
+XBT_TEST_SUITE("dict", "Dict data container");
+
+static void print_str(void *str)
+{
+ printf("%s", (char *) PRINTF_STR(str));
+}
+
+static void debuged_add_ext(xbt_dict_t head, const char *key,
+ const char *data_to_fill, void_f_pvoid_t free_f)
+{
+ char *data = xbt_strdup(data_to_fill);
+
+ xbt_test_log("Add %s under %s", PRINTF_STR(data_to_fill),
+ PRINTF_STR(key));
+
+ xbt_dict_set(head, key, data, free_f);
+ if (XBT_LOG_ISENABLED(xbt_dict, xbt_log_priority_debug)) {
+ xbt_dict_dump(head, (void (*)(void *)) &printf);
+ fflush(stdout);
+ }
+}
+
+static void debuged_add(xbt_dict_t head, const char *key, void_f_pvoid_t free_f)
+{
+ debuged_add_ext(head, key, key, free_f);
+}
+
+static void fill(xbt_dict_t * head, int homogeneous)
+{
+ void_f_pvoid_t free_f = homogeneous ? NULL : &free;
+
+ xbt_test_add("Fill in the dictionnary");
+
+ *head = homogeneous ? xbt_dict_new_homogeneous(&free) : xbt_dict_new();
+ debuged_add(*head, "12", free_f);
+ debuged_add(*head, "12a", free_f);
+ debuged_add(*head, "12b", free_f);
+ debuged_add(*head, "123", free_f);
+ debuged_add(*head, "123456", free_f);
+ /* Child becomes child of what to add */
+ debuged_add(*head, "1234", free_f);
+ /* Need of common ancestor */
+ debuged_add(*head, "123457", free_f);
+}
+
+
+static void search_ext(xbt_dict_t head, const char *key, const char *data)
+{
+ void *found;
+
+ xbt_test_add("Search %s", key);
+ found = xbt_dict_get(head, key);
+ xbt_test_log("Found %s", (char *) found);
+ if (data)
+ xbt_test_assert(found,
+ "data do not match expectations: found NULL while searching for %s",
+ data);
+ if (found)
+ xbt_test_assert(!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)
+{
+
+ xbt_test_add("Remove '%s'", PRINTF_STR(key));
+ xbt_dict_remove(head, key);
+ /* xbt_dict_dump(head,(void (*)(void*))&printf); */
+}
+
+
+static void traverse(xbt_dict_t head)
+{
+ xbt_dict_cursor_t cursor = NULL;
+ char *key;
+ char *data;
+ int i = 0;
+
+ xbt_dict_foreach(head, cursor, key, data) {
+ if (!key || !data || strcmp(key, data)) {
+ xbt_test_log("Seen #%d: %s->%s", ++i, PRINTF_STR(key),
+ PRINTF_STR(data));
+ } else {
+ xbt_test_log("Seen #%d: %s", ++i, PRINTF_STR(key));
+ }
+ xbt_test_assert(!data || !strcmp(key, data),
+ "Key(%s) != value(%s). Aborting", key, data);
+ }
+}
+
+static void search_not_found(xbt_dict_t head, const char *data)
+{
+ int ok = 0;
+ xbt_ex_t e;
+
+ xbt_test_add("Search %s (expected not to be found)", data);
+
+ TRY {
+ data = xbt_dict_get(head, data);
+ THROWF(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_assert(ok, "Exception not raised");
+}
+
+static void count(xbt_dict_t dict, int length)
+{
+ xbt_dict_cursor_t cursor;
+ char *key;
+ void *data;
+ int effective = 0;
+
+
+ xbt_test_add("Count elements (expecting %d)", length);
+ xbt_test_assert(xbt_dict_length(dict) == length,
+ "Announced length(%d) != %d.", xbt_dict_length(dict),
+ length);
+
+ xbt_dict_foreach(dict, cursor, key, data)
+ effective++;
+
+ xbt_test_assert(effective == length, "Effective length(%d) != %d.",
+ effective, length);
+
+}
+
+static void count_check_get_key(xbt_dict_t dict, int length)
+{
+ xbt_dict_cursor_t cursor;
+ char *key;
+ _XBT_GNUC_UNUSED char *key2;
+ void *data;
+ int effective = 0;
+
+
+ xbt_test_add
+ ("Count elements (expecting %d), and test the getkey function",
+ length);
+ xbt_test_assert(xbt_dict_length(dict) == length,
+ "Announced length(%d) != %d.", xbt_dict_length(dict),
+ length);
+
+ xbt_dict_foreach(dict, cursor, key, data) {
+ effective++;
+ key2 = xbt_dict_get_key(dict, data);
+ xbt_assert(!strcmp(key, key2),
+ "The data was registered under %s instead of %s as expected",
+ key2, key);
+ }
+
+ xbt_test_assert(effective == length, "Effective length(%d) != %d.",
+ effective, length);
+
+}
+
+xbt_ex_t e;
+xbt_dict_t head = NULL;
+char *data;
+
+static void basic_test(int homogeneous)
+{
+ void_f_pvoid_t free_f;
+
+ xbt_test_add("Traversal the null dictionary");
+ traverse(head);
+
+ xbt_test_add("Traversal and search the empty dictionary");
+ head = homogeneous ? xbt_dict_new_homogeneous(&free) : xbt_dict_new();
+ traverse(head);
+ TRY {
+ debuged_remove(head, "12346");
+ }
+ CATCH(e) {
+ if (e.category != not_found_error)
+ xbt_test_exception(e);
+ xbt_ex_free(e);
+ }
+ xbt_dict_free(&head);
+
+ free_f = homogeneous ? NULL : &free;
+
+ xbt_test_add("Traverse the full dictionary");
+ fill(&head, homogeneous);
+ count_check_get_key(head, 7);
+
+ debuged_add_ext(head, "toto", "tutu", free_f);
+ search_ext(head, "toto", "tutu");
+ debuged_remove(head, "toto");
+
+ search(head, "12a");
+ traverse(head);
+
+ xbt_test_add("Free the dictionary (twice)");
+ xbt_dict_free(&head);
+ xbt_dict_free(&head);
+
+ /* CHANGING */
+ fill(&head, homogeneous);
+ count_check_get_key(head, 7);
+ xbt_test_add("Change 123 to 'Changed 123'");
+ xbt_dict_set(head, "123", strdup("Changed 123"), free_f);
+ count_check_get_key(head, 7);
+
+ xbt_test_add("Change 123 back to '123'");
+ xbt_dict_set(head, "123", strdup("123"), free_f);
+ count_check_get_key(head, 7);
+
+ xbt_test_add("Change 12a to 'Dummy 12a'");
+ xbt_dict_set(head, "12a", strdup("Dummy 12a"), free_f);
+ count_check_get_key(head, 7);
+
+ xbt_test_add("Change 12a to '12a'");
+ xbt_dict_set(head, "12a", strdup("12a"), free_f);
+ count_check_get_key(head, 7);
+
+ xbt_test_add("Traverse the resulting dictionary");
+ traverse(head);
+
+ /* RETRIEVE */
+ xbt_test_add("Search 123");
+ data = xbt_dict_get(head, "123");
+ xbt_test_assert(data);
+ xbt_test_assert(!strcmp("123", data));
+
+ search_not_found(head, "Can't be found");
+ search_not_found(head, "123 Can't be found");
+ search_not_found(head, "12345678 NOT");
+
+ search(head, "12a");
+ search(head, "12b");
+ search(head, "12");
+ search(head, "123456");
+ search(head, "1234");
+ search(head, "123457");
+
+ xbt_test_add("Traverse the resulting dictionary");
+ traverse(head);
+
+ /* xbt_dict_dump(head,(void (*)(void*))&printf); */
+
+ xbt_test_add("Free the dictionary twice");
+ xbt_dict_free(&head);
+ xbt_dict_free(&head);
+
+ xbt_test_add("Traverse the resulting dictionary");
+ traverse(head);
+}
+
+XBT_TEST_UNIT("basic_heterogeneous", test_dict_basic_heterogeneous, "Basic usage: change, retrieve, traverse: heterogeneous dict")
+{
+ basic_test(0);
+}
+
+XBT_TEST_UNIT("basic_homogeneous", test_dict_basic_homogeneous, "Basic usage: change, retrieve, traverse: homogeneous dict")
+{
+ basic_test(1);
+}
+
+static void remove_test(int homogeneous)
+{
+ fill(&head, homogeneous);
+ count(head, 7);
+ xbt_test_add("Remove non existing data");
+ TRY {
+ debuged_remove(head, "Does not exist");
+ }
+ CATCH(e) {
+ if (e.category != not_found_error)
+ xbt_test_exception(e);
+ xbt_ex_free(e);
+ }
+ traverse(head);
+
+ xbt_dict_free(&head);
+
+ xbt_test_add
+ ("Remove each data manually (traversing the resulting dictionary each time)");
+ fill(&head, homogeneous);
+ debuged_remove(head, "12a");
+ traverse(head);
+ count(head, 6);
+ debuged_remove(head, "12b");
+ traverse(head);
+ count(head, 5);
+ debuged_remove(head, "12");
+ traverse(head);
+ count(head, 4);
+ debuged_remove(head, "123456");
+ traverse(head);
+ count(head, 3);
+ TRY {
+ debuged_remove(head, "12346");
+ }
+ CATCH(e) {
+ if (e.category != not_found_error)
+ xbt_test_exception(e);
+ xbt_ex_free(e);
+ traverse(head);
+ }
+ debuged_remove(head, "1234");
+ traverse(head);
+ debuged_remove(head, "123457");
+ traverse(head);
+ debuged_remove(head, "123");
+ traverse(head);
+ TRY {
+ debuged_remove(head, "12346");
+ }
+ CATCH(e) {
+ if (e.category != not_found_error)
+ xbt_test_exception(e);
+ xbt_ex_free(e);
+ }
+ traverse(head);
+
+ xbt_test_add
+ ("Free dict, create new fresh one, and then reset the dict");
+ xbt_dict_free(&head);
+ fill(&head, homogeneous);
+ xbt_dict_reset(head);
+ count(head, 0);
+ traverse(head);
+
+ xbt_test_add("Free the dictionary twice");
+ xbt_dict_free(&head);
+ xbt_dict_free(&head);
+}
+
+XBT_TEST_UNIT("remove_heterogeneous", test_dict_remove_heterogeneous, "Removing some values: heterogeneous dict")
+{
+ remove_test(0);