+void xbt_dict_dump(xbt_dict_t dict, void_f_pvoid_t output)
+{
+ int i;
+ xbt_dictelm_t element;
+ printf("Dict %p:\n", dict);
+ if (dict != NULL) {
+ for (i = 0; i < dict->table_size; i++) {
+ element = dict->table[i];
+ if (element) {
+ printf("[\n");
+ while (element != NULL) {
+ printf(" %s -> '", element->key);
+ if (output != NULL) {
+ (*output) (element->content);
+ }
+ printf("'\n");
+ element = element->next;
+ }
+ printf("]\n");
+ } else {
+ printf("[]\n");
+ }
+ }
+ }
+}
+
+xbt_dynar_t all_sizes = NULL;
+/** @brief shows some debugging info about the bucklet repartition */
+void xbt_dict_dump_sizes(xbt_dict_t dict)
+{
+
+ int i;
+ unsigned int count;
+ unsigned int size;
+ xbt_dictelm_t element;
+ xbt_dynar_t sizes = xbt_dynar_new(sizeof(int), NULL);
+
+ printf("Dict %p: %d bucklets, %d used cells (of %d) ", dict, dict->count,
+ dict->fill, dict->table_size);
+ if (dict != NULL) {
+ for (i = 0; i < dict->table_size; i++) {
+ element = dict->table[i];
+ size = 0;
+ if (element) {
+ while (element != NULL) {
+ size++;
+ element = element->next;
+ }
+ }
+ if (xbt_dynar_length(sizes) <= size) {
+ int prevsize = 1;
+ xbt_dynar_set(sizes, size, &prevsize);
+ } else {
+ int prevsize;
+ xbt_dynar_get_cpy(sizes, size, &prevsize);
+ prevsize++;
+ xbt_dynar_set(sizes, size, &prevsize);
+ }
+ }
+ if (!all_sizes)
+ all_sizes = xbt_dynar_new(sizeof(int), NULL);
+
+ 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_mallocator != NULL) {
+ /* Already created. I guess we want to switch to MC mode, so kill the previously created mallocator */
+ xbt_mallocator_free(dict_mallocator);
+ xbt_mallocator_free(dict_elm_mallocator);
+ }
+
+ 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);
+}
+
+/**
+ * Destroy the dict mallocators.
+ * This is an internal XBT function during the lib initialization
+ */
+void xbt_dict_postexit(void)
+{
+ if (dict_mallocator != NULL) {
+ xbt_mallocator_free(dict_mallocator);
+ dict_mallocator = NULL;
+ xbt_mallocator_free(dict_elm_mallocator);
+ dict_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);
+ }
+}
+
+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"
+#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)
+{
+ char *data = xbt_strdup(data_to_fill);
+
+ 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)) {
+ xbt_dict_dump(head, (void (*)(void *)) &printf);
+ 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");
+
+ *head = xbt_dict_new();
+ debuged_add(*head, "12");
+ debuged_add(*head, "12a");
+ debuged_add(*head, "12b");
+ debuged_add(*head, "123");
+ debuged_add(*head, "123456");
+ /* Child becomes child of what to add */
+ debuged_add(*head, "1234");
+ /* Need of common ancestor */
+ debuged_add(*head, "123457");
+}
+
+
+static void search_ext(xbt_dict_t head, const char *key, const char *data)
+{
+ void *found;
+
+ xbt_test_add1("Search %s", key);
+ found = xbt_dict_get(head, key);
+ xbt_test_log1("Found %s", (char *) found);
+ if (data)
+ 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)
+{
+
+ xbt_test_add1("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_log3("Seen #%d: %s->%s", ++i, PRINTF_STR(key),
+ PRINTF_STR(data));
+ } else {
+ xbt_test_log2("Seen #%d: %s", ++i, PRINTF_STR(key));
+ }
+ xbt_test_assert2(!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_add1("Search %s (expected not to be found)", data);
+
+ TRY {
+ 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)
+{
+ xbt_dict_cursor_t cursor;
+ char *key;
+ void *data;
+ int effective = 0;
+
+
+ xbt_test_add1("Count elements (expecting %d)", length);
+ xbt_test_assert2(xbt_dict_length(dict) == length,
+ "Announced length(%d) != %d.", xbt_dict_length(dict),
+ length);
+
+ xbt_dict_foreach(dict, cursor, key, data)
+ effective++;
+
+ xbt_test_assert2(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, *key2;
+ void *data;
+ int effective = 0;
+
+
+ xbt_test_add1
+ ("Count elements (expecting %d), and test the getkey function",
+ length);
+ xbt_test_assert2(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_assert2(!strcmp(key, key2),
+ "The data was registered under %s instead of %s as expected",
+ key2, key);
+ }
+
+ xbt_test_assert2(effective == length, "Effective length(%d) != %d.",
+ effective, length);
+
+}
+
+xbt_ex_t e;
+xbt_dict_t head = NULL;
+char *data;
+
+
+XBT_TEST_UNIT("basic", test_dict_basic, "Basic usage: change, retrieve, traverse")
+{
+ xbt_test_add0("Traversal the null dictionary");
+ traverse(head);
+
+ xbt_test_add0("Traversal and search the empty dictionary");
+ head = 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);
+
+ xbt_test_add0("Traverse the full dictionary");
+ fill(&head);
+ count_check_get_key(head, 7);
+
+ debuged_add_ext(head, "toto", "tutu");
+ search_ext(head, "toto", "tutu");
+ debuged_remove(head, "toto");
+
+ search(head, "12a");
+ traverse(head);
+
+ xbt_test_add0("Free the dictionary (twice)");
+ xbt_dict_free(&head);
+ xbt_dict_free(&head);
+
+ /* CHANGING */
+ fill(&head);
+ count_check_get_key(head, 7);
+ xbt_test_add0("Change 123 to 'Changed 123'");
+ xbt_dict_set(head, "123", strdup("Changed 123"), &free);
+ count_check_get_key(head, 7);
+
+ xbt_test_add0("Change 123 back to '123'");
+ xbt_dict_set(head, "123", strdup("123"), &free);
+ count_check_get_key(head, 7);
+
+ xbt_test_add0("Change 12a to 'Dummy 12a'");
+ xbt_dict_set(head, "12a", strdup("Dummy 12a"), &free);
+ count_check_get_key(head, 7);
+
+ xbt_test_add0("Change 12a to '12a'");
+ xbt_dict_set(head, "12a", strdup("12a"), &free);
+ count_check_get_key(head, 7);
+
+ xbt_test_add0("Traverse the resulting dictionary");
+ traverse(head);