diff options
29 files changed, 654 insertions, 133 deletions
diff --git a/ctrl/libhicnctrl/src/modules/hicn_light.c b/ctrl/libhicnctrl/src/modules/hicn_light.c index 1af6c79e2..658043b7f 100644 --- a/ctrl/libhicnctrl/src/modules/hicn_light.c +++ b/ctrl/libhicnctrl/src/modules/hicn_light.c @@ -1155,7 +1155,7 @@ static ssize_t hicnlight_prepare(hc_sock_t *sock, hc_request_t *request, */ static int hicnlight_process(hc_sock_t *sock, size_t count) { hc_sock_light_data_t *s = (hc_sock_light_data_t *)sock->data; - int rc; + int rc = -99; if (count > 0) s->woff += count; diff --git a/hicn-light/src/hicn/cli/hicns.c b/hicn-light/src/hicn/cli/hicns.c index fa668062d..c03fa8599 100644 --- a/hicn-light/src/hicn/cli/hicns.c +++ b/hicn-light/src/hicn/cli/hicns.c @@ -58,7 +58,7 @@ int shell(hc_sock_t *s) { hc_command_t command = {0}; char *pos; - if ((pos = strchr(line, '\n')) != NULL) { + if (line != NULL && (pos = strchr(line, '\n')) != NULL) { *pos = '\0'; } else { fprintf(stderr, "Error while reading command.\n"); diff --git a/hicn-light/src/hicn/config/configuration.c b/hicn-light/src/hicn/config/configuration.c index f38c4f22f..b7e931e53 100644 --- a/hicn-light/src/hicn/config/configuration.c +++ b/hicn-light/src/hicn/config/configuration.c @@ -46,6 +46,8 @@ #include <hicn/utils/punting.h> #include <hicn/util/log.h> #include <hicn/face.h> +#include <hicn/util/slab.h> +#include <hicn/util/sstrncpy.h> #include "configuration.h" @@ -63,6 +65,10 @@ (msg)->header.seq_num = (seq_number); \ } while (0); +typedef struct { + char prefix[MAXSZ_HICN_PREFIX]; +} prefix_key_t; + struct configuration_s { const char *fn_config; uint16_t port; @@ -72,7 +78,10 @@ struct configuration_s { const char *logfile; int logfile_fd; bool daemon; + kh_strategy_map_t *strategy_map; + slab_t *prefix_keys; + size_t n_suffixes_per_split; int_manifest_split_strategy_t split_strategy; }; @@ -95,6 +104,7 @@ configuration_t *configuration_create() { #endif configuration_set_loglevel(config, loglevel_from_str(DEFAULT_LOGLEVEL)); config->strategy_map = kh_init_strategy_map(); + config->prefix_keys = slab_create(prefix_key_t, SLAB_INIT_SIZE); config->n_suffixes_per_split = DEFAULT_N_SUFFIXES_PER_SPLIT; config->split_strategy = DEFAULT_DISAGGREGATION_STRATEGY; @@ -104,13 +114,8 @@ configuration_t *configuration_create() { void configuration_free(configuration_t *config) { assert(config); - const char *k_prefix; - unsigned _; - (void)_; - - // Free the strategy hashmap - kh_foreach(config->strategy_map, k_prefix, _, { free((char *)k_prefix); }); kh_destroy_strategy_map(config->strategy_map); + slab_free(config->prefix_keys); free(config); } @@ -202,7 +207,11 @@ bool configuration_get_daemon(const configuration_t *config) { void configuration_set_strategy(configuration_t *config, const char *prefix, strategy_type_t strategy_type) { int res; - khiter_t k = kh_put_strategy_map(config->strategy_map, strdup(prefix), &res); + prefix_key_t *prefix_copy = slab_get(prefix_key_t, config->prefix_keys); + strcpy_s(prefix_copy->prefix, sizeof(prefix_key_t), prefix); + + khiter_t k = + kh_put_strategy_map(config->strategy_map, prefix_copy->prefix, &res); kh_value(config->strategy_map, k) = strategy_type; } diff --git a/hicn-light/src/hicn/core/connection_table.c b/hicn-light/src/hicn/core/connection_table.c index 7bc0e2f4c..a6b114c01 100644 --- a/hicn-light/src/hicn/core/connection_table.c +++ b/hicn-light/src/hicn/core/connection_table.c @@ -19,6 +19,7 @@ */ #include <hicn/util/log.h> +#include <hicn/util/sstrncpy.h> #include "connection.h" #include "connection_table.h" @@ -27,6 +28,10 @@ */ #define DEFAULT_CONNECTION_TABLE_SIZE 64 +typedef struct { + char name[SYMBOLIC_NAME_LEN]; +} name_key_t; + connection_table_t *_connection_table_create(size_t init_size, size_t max_size) { if (init_size == 0) init_size = DEFAULT_CONNECTION_TABLE_SIZE; @@ -38,7 +43,9 @@ connection_table_t *_connection_table_create(size_t init_size, /* Initialize indices */ table->id_by_pair = kh_init_ct_pair(); + table->pair_keys = slab_create(address_pair_t, SLAB_INIT_SIZE); table->id_by_name = kh_init_ct_name(); + table->name_keys = slab_create(name_key_t, SLAB_INIT_SIZE); /* * We start by allocating a reasonably-sized pool, as this will eventually @@ -50,26 +57,20 @@ connection_table_t *_connection_table_create(size_t init_size, } void connection_table_free(connection_table_t *table) { - const char *k_name; - const address_pair_t *k_pair; - unsigned v_conn_id; + unsigned conn_id; + kh_foreach_value(table->id_by_name, conn_id, { + connection_t *connection = connection_table_get_by_id(table, conn_id); + const char *name = connection_get_name(connection); - connection_t *connection; - const char *name; - kh_foreach(table->id_by_name, k_name, v_conn_id, { - connection = connection_table_get_by_id(table, v_conn_id); - name = connection_get_name(connection); INFO("Removing connection %s [%d]", name, connection->fd); connection_finalize(connection); }); - (void)v_conn_id; - kh_foreach(table->id_by_name, k_name, v_conn_id, { free((char *)k_name); }); - kh_foreach(table->id_by_pair, k_pair, v_conn_id, - { free((address_pair_t *)k_pair); }); - kh_destroy_ct_pair(table->id_by_pair); + slab_free(table->pair_keys); kh_destroy_ct_name(table->id_by_name); + slab_free(table->name_keys); + pool_free(table->connections); free(table); } @@ -93,12 +94,15 @@ connection_t *connection_table_allocate(const connection_table_t *table, int rc; // Add in name hash table - khiter_t k = kh_put_ct_name(table->id_by_name, strdup(name), &rc); + name_key_t *name_copy = slab_get(name_key_t, table->name_keys); + strcpy_s(name_copy->name, sizeof(name_key_t), name); + + khiter_t k = kh_put_ct_name(table->id_by_name, name_copy->name, &rc); assert(rc == KH_ADDED || rc == KH_RESET); kh_value(table->id_by_name, k) = (unsigned int)id; // Add in pair hash table - address_pair_t *pair_copy = (address_pair_t *)malloc(sizeof(address_pair_t)); + address_pair_t *pair_copy = slab_get(address_pair_t, table->pair_keys); memcpy(pair_copy, pair, sizeof(address_pair_t)); k = kh_put_ct_pair(table->id_by_pair, pair_copy, &rc); @@ -125,14 +129,14 @@ void connection_table_deallocate(const connection_table_t *table, // Remove from name hash table khiter_t k = kh_get_ct_name(table->id_by_name, name); assert(k != kh_end(table->id_by_name)); - free((char *)kh_key(table->id_by_name, k)); kh_del_ct_name(table->id_by_name, k); + slab_put(table->name_keys, kh_key(table->id_by_name, k)); // Remove from pair hash table k = kh_get_ct_pair(table->id_by_pair, pair); assert(k != kh_end(table->id_by_pair)); - free((address_pair_t *)kh_key(table->id_by_pair, k)); kh_del_ct_pair(table->id_by_pair, k); + slab_put(table->pair_keys, kh_key(table->id_by_pair, k)); assert(kh_size(table->id_by_name) == kh_size(table->id_by_pair)); pool_put(table->connections, conn); diff --git a/hicn-light/src/hicn/core/connection_table.h b/hicn-light/src/hicn/core/connection_table.h index 566443d93..dcfb1e1dd 100644 --- a/hicn-light/src/hicn/core/connection_table.h +++ b/hicn-light/src/hicn/core/connection_table.h @@ -32,6 +32,7 @@ #include <hicn/util/khash.h> #include <hicn/util/hash.h> +#include <hicn/util/slab.h> #include "address_pair.h" #include "connection.h" #include <hicn/util/pool.h> @@ -48,7 +49,9 @@ typedef struct { size_t max_size; kh_ct_pair_t *id_by_pair; + slab_t *pair_keys; kh_ct_name_t *id_by_name; + slab_t *name_keys; connection_t *connections; // pool } connection_table_t; diff --git a/hicn-light/src/hicn/core/forwarder.c b/hicn-light/src/hicn/core/forwarder.c index 72bb22118..60493a9c5 100644 --- a/hicn-light/src/hicn/core/forwarder.c +++ b/hicn-light/src/hicn/core/forwarder.c @@ -805,7 +805,7 @@ int _forwarder_forward_aggregated_interest( assert(msgbuf_id_is_valid(msgbuf_id) && msgbuf_get_type(msgbuf) == HICN_PACKET_TYPE_INTEREST); - bool ret = -1; + int ret = -1; fib_entry_t *fib_entry = fib_match_msgbuf(forwarder->fib, msgbuf); if (!fib_entry) goto END; @@ -843,9 +843,8 @@ int _forwarder_forward_aggregated_interest( BITMAP_SIZE * sizeof(hicn_uword)); size_t suffix_index = 0; // Position of suffix in initial manifest - interest_manifest_header_t *manifest; + interest_manifest_header_t *manifest = NULL; size_t payload_size; - int ret; while (suffix_index < total_suffixes) { // If more than one sub-manifest, // clone original interest manifest and update suffix @@ -869,9 +868,9 @@ int _forwarder_forward_aggregated_interest( // Update manifest bitmap in current msgbuf - ret = + int ret = _forwarder_get_interest_manifest(msgbuf, &manifest, &payload_size); - assert(ret == 0); + _ASSERT(ret == 0); memcpy(manifest->request_bitmap, curr_bitmap, BITMAP_SIZE * sizeof(hicn_uword)); WITH_TRACE({ @@ -980,7 +979,7 @@ static ssize_t forwarder_process_aggregated_interest( // then just iterate the interest manifest and update the suffix in the name // struct hicn_name_suffix_t *suffix; - int pos; + unsigned long pos; interest_manifest_foreach_suffix(int_manifest_header, suffix, pos) { // Update name hicn_name_set_suffix(&name_copy, *suffix); @@ -1088,7 +1087,7 @@ static ssize_t forwarder_process_interest(forwarder_t *forwarder, pkt_cache_save_suffixes_for_prefix( forwarder->pkt_cache, hicn_name_get_prefix(msgbuf_get_name(msgbuf))); - if (!int_manifest_header) + if (ret == -1) return forwarder_process_single_interest(forwarder, msgbuf_pool, msgbuf, msgbuf_id); return forwarder_process_aggregated_interest(forwarder, int_manifest_header, diff --git a/hicn-light/src/hicn/core/listener_table.c b/hicn-light/src/hicn/core/listener_table.c index c130399a5..4a0f74a13 100644 --- a/hicn-light/src/hicn/core/listener_table.c +++ b/hicn-light/src/hicn/core/listener_table.c @@ -19,6 +19,7 @@ */ #include <hicn/util/log.h> +#include <hicn/util/sstrncpy.h> #include "listener_table.h" #include "listener.h" @@ -27,6 +28,10 @@ */ #define DEFAULT_LISTENER_TABLE_SIZE 64 +typedef struct { + char name[SYMBOLIC_NAME_LEN]; +} name_key_t; + listener_table_t *_listener_table_create(size_t init_size, size_t max_size) { if (init_size == 0) init_size = DEFAULT_LISTENER_TABLE_SIZE; @@ -37,7 +42,9 @@ listener_table_t *_listener_table_create(size_t init_size, size_t max_size) { /* Initialize indices */ table->id_by_name = kh_init_lt_name(); + table->name_keys = slab_create(name_key_t, SLAB_INIT_SIZE); table->id_by_key = kh_init_lt_key(); + table->listener_keys = slab_create(listener_key_t, SLAB_INIT_SIZE); /* * We start by allocating a reasonably-sized pool, as this will eventually @@ -49,25 +56,19 @@ listener_table_t *_listener_table_create(size_t init_size, size_t max_size) { } void listener_table_free(listener_table_t *table) { - const char *k_name; - const listener_key_t *k_key; - unsigned v; - - listener_t *listener; - const char *name; - kh_foreach(table->id_by_key, k_key, v, { - listener = listener_table_get_by_id(table, v); - name = listener_get_name(listener); + unsigned listener_id; + kh_foreach_value(table->id_by_key, listener_id, { + listener_t *listener = listener_table_get_by_id(table, listener_id); + const char *name = listener_get_name(listener); INFO("Removing listener %s [%d]", name, listener->fd); listener_finalize(listener); }); - (void)v; - kh_foreach(table->id_by_name, k_name, v, { free((char *)k_name); }); - kh_foreach(table->id_by_key, k_key, v, { free((listener_key_t *)k_key); }); - kh_destroy_lt_name(table->id_by_name); + slab_free(table->name_keys); kh_destroy_lt_key(table->id_by_key); + slab_free(table->listener_keys); + pool_free(table->listeners); free(table); } @@ -83,12 +84,15 @@ listener_t *listener_table_allocate(const listener_table_t *table, int rc; // Add in name hash table - khiter_t k = kh_put_lt_name(table->id_by_name, strdup(name), &rc); + name_key_t *name_copy = slab_get(name_key_t, table->name_keys); + strcpy_s(name_copy->name, sizeof(name_key_t), name); + + khiter_t k = kh_put_lt_name(table->id_by_name, name_copy->name, &rc); assert(rc == KH_ADDED || rc == KH_RESET); kh_value(table->id_by_name, k) = (unsigned int)id; // Add in key hash table - listener_key_t *key_copy = (listener_key_t *)malloc(sizeof(listener_key_t)); + listener_key_t *key_copy = slab_get(listener_key_t, table->listener_keys); memcpy(key_copy, key, sizeof(listener_key_t)); k = kh_put_lt_key(table->id_by_key, key_copy, &rc); @@ -107,14 +111,14 @@ void listener_table_deallocate(const listener_table_t *table, // Remove from name hash table khiter_t k = kh_get_lt_name(table->id_by_name, name); assert(k != kh_end(table->id_by_name)); - free((char *)kh_key(table->id_by_name, k)); kh_del_lt_name(table->id_by_name, k); + slab_put(table->name_keys, kh_key(table->id_by_name, k)); // Remove from key hash table k = kh_get_lt_key(table->id_by_key, key); assert(k != kh_end(table->id_by_key)); - free((listener_key_t *)kh_key(table->id_by_key, k)); kh_del_lt_key(table->id_by_key, k); + slab_put(table->listener_keys, kh_key(table->id_by_key, k)); assert(kh_size(table->id_by_name) == kh_size(table->id_by_key)); pool_put(table->listeners, listener); diff --git a/hicn-light/src/hicn/core/listener_table.h b/hicn-light/src/hicn/core/listener_table.h index 27c5daa04..062d1748e 100644 --- a/hicn-light/src/hicn/core/listener_table.h +++ b/hicn-light/src/hicn/core/listener_table.h @@ -32,6 +32,7 @@ #include <hicn/util/khash.h> #include <hicn/util/hash.h> +#include <hicn/util/slab.h> #include "address.h" #include "listener.h" #include <hicn/util/pool.h> @@ -48,7 +49,9 @@ typedef struct { size_t max_size; kh_lt_key_t *id_by_key; + slab_t *listener_keys; kh_lt_name_t *id_by_name; + slab_t *name_keys; listener_t *listeners; // pool } listener_table_t; diff --git a/hicn-light/src/hicn/core/packet_cache.c b/hicn-light/src/hicn/core/packet_cache.c index 9d0b041c3..7fa18b48f 100644 --- a/hicn-light/src/hicn/core/packet_cache.c +++ b/hicn-light/src/hicn/core/packet_cache.c @@ -84,13 +84,9 @@ const char *_pkt_cache_verdict_str[] = { * Free the two level packet cache structure (helper) */ void _prefix_map_free(kh_pkt_cache_prefix_t *prefix_to_suffixes) { - const hicn_name_prefix_t *key; - kh_pkt_cache_suffix_t *value; - kh_foreach(prefix_to_suffixes, key, value, { - //(void)key; - free((hicn_name_prefix_t *)key); - kh_destroy_pkt_cache_suffix(value); - }); + kh_pkt_cache_suffix_t *suffix; + kh_foreach_value(prefix_to_suffixes, suffix, + { kh_destroy_pkt_cache_suffix(suffix); }); kh_destroy_pkt_cache_prefix(prefix_to_suffixes); } @@ -99,7 +95,7 @@ void _prefix_map_free(kh_pkt_cache_prefix_t *prefix_to_suffixes) { */ kh_pkt_cache_suffix_t *_get_suffixes(kh_pkt_cache_prefix_t *prefix_to_suffixes, const hicn_name_prefix_t *prefix, - bool create) { + bool create, slab_t *prefix_keys) { khiter_t k = kh_get_pkt_cache_prefix(prefix_to_suffixes, prefix); /* Return suffixes if found... */ @@ -114,8 +110,8 @@ kh_pkt_cache_suffix_t *_get_suffixes(kh_pkt_cache_prefix_t *prefix_to_suffixes, */ kh_pkt_cache_suffix_t *suffixes = kh_init_pkt_cache_suffix(); - hicn_name_prefix_t *prefix_copy = malloc(sizeof(hicn_name_prefix_t)); - *prefix_copy = *prefix; + hicn_name_prefix_t *prefix_copy = slab_get(hicn_name_prefix_t, prefix_keys); + memcpy(prefix_copy, prefix, sizeof(hicn_name_prefix_t)); int rc; k = kh_put_pkt_cache_prefix(prefix_to_suffixes, prefix_copy, &rc); @@ -129,8 +125,9 @@ kh_pkt_cache_suffix_t *_get_suffixes(kh_pkt_cache_prefix_t *prefix_to_suffixes, */ void _remove_suffix(kh_pkt_cache_prefix_t *prefixes, const hicn_name_prefix_t *prefix, - const hicn_name_suffix_t suffix) { - kh_pkt_cache_suffix_t *suffixes = _get_suffixes(prefixes, prefix, false); + const hicn_name_suffix_t suffix, slab_t *prefix_keys) { + kh_pkt_cache_suffix_t *suffixes = + _get_suffixes(prefixes, prefix, false, prefix_keys); assert(suffixes != NULL); khiter_t k = kh_get_pkt_cache_suffix(suffixes, suffix); @@ -159,8 +156,10 @@ void __add_suffix(kh_pkt_cache_suffix_t *suffixes, hicn_name_suffix_t suffix, */ void _add_suffix(kh_pkt_cache_prefix_t *prefixes, const hicn_name_prefix_t *prefix, - const hicn_name_suffix_t suffix, unsigned val) { - kh_pkt_cache_suffix_t *suffixes = _get_suffixes(prefixes, prefix, true); + const hicn_name_suffix_t suffix, unsigned val, + slab_t *prefix_keys) { + kh_pkt_cache_suffix_t *suffixes = + _get_suffixes(prefixes, prefix, true, prefix_keys); assert(suffixes != NULL); __add_suffix(suffixes, suffix, val); @@ -184,9 +183,10 @@ unsigned __get_suffix(kh_pkt_cache_suffix_t *suffixes, unsigned _get_suffix(kh_pkt_cache_prefix_t *prefixes, const hicn_name_prefix_t *prefix, - hicn_name_suffix_t suffix) { + hicn_name_suffix_t suffix, slab_t *prefix_keys) { /* create is false as this function is always called by lookup */ - kh_pkt_cache_suffix_t *suffixes = _get_suffixes(prefixes, prefix, false); + kh_pkt_cache_suffix_t *suffixes = + _get_suffixes(prefixes, prefix, false, prefix_keys); if (!suffixes) { return HICN_INVALID_SUFFIX; } @@ -197,11 +197,11 @@ unsigned _get_suffix(kh_pkt_cache_prefix_t *prefixes, * Lookup in both the first and second levels of the packet cache (helper) */ unsigned _get_suffix_from_name(kh_pkt_cache_prefix_t *prefixes, - const hicn_name_t *name) { + const hicn_name_t *name, slab_t *prefix_keys) { const hicn_name_prefix_t *prefix = hicn_name_get_prefix(name); const hicn_name_suffix_t suffix = hicn_name_get_suffix(name); - return _get_suffix(prefixes, prefix, suffix); + return _get_suffix(prefixes, prefix, suffix, prefix_keys); } void pkt_cache_save_suffixes_for_prefix(pkt_cache_t *pkt_cache, @@ -216,8 +216,9 @@ void pkt_cache_save_suffixes_for_prefix(pkt_cache_t *pkt_cache, // Update cached prefix information pkt_cache->cached_prefix = *prefix; pkt_cache->cached_suffixes = - _get_suffixes(pkt_cache->prefix_to_suffixes, prefix, true); // XXX - // + _get_suffixes(pkt_cache->prefix_to_suffixes, prefix, true, + pkt_cache->prefix_keys); // XXX + // } void pkt_cache_reset_suffixes_for_prefix(pkt_cache_t *pkt_cache) { @@ -237,6 +238,7 @@ pkt_cache_t *pkt_cache_create(size_t cs_size) { if (!pkt_cache->cs) return NULL; pkt_cache->prefix_to_suffixes = kh_init_pkt_cache_prefix(); + pkt_cache->prefix_keys = slab_create(hicn_name_prefix_t, SLAB_INIT_SIZE); pool_init(pkt_cache->entries, DEFAULT_PKT_CACHE_SIZE, 0); pkt_cache->cached_prefix = HICN_NAME_PREFIX_EMPTY; @@ -250,6 +252,7 @@ void pkt_cache_free(pkt_cache_t *pkt_cache) { // Free prefix hash table and pool _prefix_map_free(pkt_cache->prefix_to_suffixes); + slab_free(pkt_cache->prefix_keys); pool_free(pkt_cache->entries); // Free PIT and CS @@ -261,8 +264,10 @@ void pkt_cache_free(pkt_cache_t *pkt_cache) { kh_pkt_cache_suffix_t *pkt_cache_get_suffixes(const pkt_cache_t *pkt_cache, const hicn_name_prefix_t *prefix, - bool create) { - return _get_suffixes(pkt_cache->prefix_to_suffixes, prefix, create); + bool create, + slab_t *prefix_keys) { + return _get_suffixes(pkt_cache->prefix_to_suffixes, prefix, create, + prefix_keys); } pkt_cache_entry_t *pkt_cache_allocate(pkt_cache_t *pkt_cache) { @@ -286,7 +291,8 @@ void pkt_cache_add_to_index(const pkt_cache_t *pkt_cache, (unsigned int)id); } else { _add_suffix(pkt_cache->prefix_to_suffixes, hicn_name_get_prefix(name), - hicn_name_get_suffix(name), (unsigned int)id); + hicn_name_get_suffix(name), (unsigned int)id, + pkt_cache->prefix_keys); } } @@ -296,7 +302,7 @@ void pkt_cache_add_to_index(const pkt_cache_t *pkt_cache, void pkt_cache_remove_from_index(const pkt_cache_t *pkt_cache, const hicn_name_t *name) { _remove_suffix(pkt_cache->prefix_to_suffixes, hicn_name_get_prefix(name), - hicn_name_get_suffix(name)); + hicn_name_get_suffix(name), pkt_cache->prefix_keys); // TODO #if 0 @@ -321,7 +327,8 @@ pkt_cache_entry_t *pkt_cache_lookup(pkt_cache_t *pkt_cache, index = __get_suffix(pkt_cache->cached_suffixes, hicn_name_get_suffix(name)); } else { - index = _get_suffix_from_name(pkt_cache->prefix_to_suffixes, name); + index = _get_suffix_from_name(pkt_cache->prefix_to_suffixes, name, + pkt_cache->prefix_keys); } if (index == HICN_INVALID_SUFFIX) { @@ -364,7 +371,7 @@ void pkt_cache_cs_remove_entry(pkt_cache_t *pkt_cache, pkt_cache_entry_t *entry, // XXX const hicn_name_t *name = msgbuf_get_name(msgbuf); _remove_suffix(pkt_cache->prefix_to_suffixes, hicn_name_get_prefix(&entry->name), - hicn_name_get_suffix(&entry->name)); + hicn_name_get_suffix(&entry->name), pkt_cache->prefix_keys); // Do not update the LRU cache for evicted entries if (!is_evicted) cs_vft[pkt_cache->cs->type]->remove_entry(pkt_cache, entry); @@ -391,7 +398,7 @@ void pkt_cache_pit_remove_entry(pkt_cache_t *pkt_cache, const hicn_name_t *name = &entry->name; _remove_suffix(pkt_cache->prefix_to_suffixes, hicn_name_get_prefix(name), - hicn_name_get_suffix(name)); + hicn_name_get_suffix(name), pkt_cache->prefix_keys); pool_put(pkt_cache->entries, entry); diff --git a/hicn-light/src/hicn/core/packet_cache.h b/hicn-light/src/hicn/core/packet_cache.h index dcbc20c7d..1abdc57c2 100644 --- a/hicn-light/src/hicn/core/packet_cache.h +++ b/hicn-light/src/hicn/core/packet_cache.h @@ -41,6 +41,7 @@ #define HICNLIGHT_PACKET_CACHE_H #include <hicn/util/khash.h> +#include <hicn/util/slab.h> #include "content_store.h" #include "pit.h" #include "msgbuf_pool.h" @@ -112,6 +113,7 @@ typedef struct { cs_t *cs; pkt_cache_entry_t *entries; kh_pkt_cache_prefix_t *prefix_to_suffixes; + slab_t *prefix_keys; // Cached prefix info to avoid double lookups, // used for both single interest speculation and interest manifest @@ -455,19 +457,19 @@ unsigned __get_suffix(kh_pkt_cache_suffix_t *suffixes, hicn_name_suffix_t suffix); unsigned _get_suffix(kh_pkt_cache_prefix_t *prefixes, const hicn_name_prefix_t *prefix, - hicn_name_suffix_t suffix); + hicn_name_suffix_t suffix, slab_t *prefix_keys); void __add_suffix(kh_pkt_cache_suffix_t *suffixes, hicn_name_suffix_t suffix, unsigned val); void _add_suffix(kh_pkt_cache_prefix_t *prefixes, - const hicn_name_prefix_t *prefix, hicn_name_suffix_t suffix, - unsigned val); + const hicn_name_prefix_t *prefix, + const hicn_name_suffix_t suffix, unsigned val, slab_t *slab); void _remove_suffix(kh_pkt_cache_prefix_t *prefixes, - const hicn_name_prefix_t *prefix, - hicn_name_suffix_t suffix); + const hicn_name_prefix_t *prefix, hicn_name_suffix_t suffix, + slab_t *slab); void _prefix_map_free(kh_pkt_cache_prefix_t *prefix_to_suffixes); kh_pkt_cache_suffix_t *_get_suffixes(kh_pkt_cache_prefix_t *prefix_to_suffixes, const hicn_name_prefix_t *prefix, - bool create); + bool create, slab_t *prefix_keys); #endif /************** Content Store *****************************/ diff --git a/hicn-light/src/hicn/test/test-configuration.cc b/hicn-light/src/hicn/test/test-configuration.cc index b631bb20b..2d3b5329f 100644 --- a/hicn-light/src/hicn/test/test-configuration.cc +++ b/hicn-light/src/hicn/test/test-configuration.cc @@ -69,6 +69,7 @@ TEST_F(ConfigurationTest, SetLogParameters) { EXPECT_EQ(log_file, LOG_FILE); int write_fd = configuration_get_logfile_fd(config); EXPECT_NE(write_fd, -1); + configuration_flush_log(); } TEST_F(ConfigurationTest, SetStrategyParameter) { diff --git a/hicn-light/src/hicn/test/test-connection_table.cc b/hicn-light/src/hicn/test/test-connection_table.cc index 171921b53..6723d0ff1 100644 --- a/hicn-light/src/hicn/test/test-connection_table.cc +++ b/hicn-light/src/hicn/test/test-connection_table.cc @@ -28,14 +28,18 @@ extern "C" { #define WITH_TESTS #include <hicn/core/connection_table.h> #include <hicn/util/log.h> +#include <hicn/validation.h> } -#define CONNECTION_NAME "connection_name_test" -#define CONNECTION_NAME_2 "connection_name_test_2" +#define CONNECTION_NAME "conn_name" +#define CONNECTION_NAME_2 "conn_name_2" class ConnectionTableTest : public ::testing::Test { protected: ConnectionTableTest() { + assert(is_symbolic_name(CONNECTION_NAME, SYMBOLIC_NAME_LEN)); + assert(is_symbolic_name(CONNECTION_NAME_2, SYMBOLIC_NAME_LEN)); + log_conf.log_level = LOG_WARN; conn_table_ = connection_table_create(); diff --git a/hicn-light/src/hicn/test/test-listener_table.cc b/hicn-light/src/hicn/test/test-listener_table.cc index f4af02ee1..6bd2a6ab7 100644 --- a/hicn-light/src/hicn/test/test-listener_table.cc +++ b/hicn-light/src/hicn/test/test-listener_table.cc @@ -28,14 +28,18 @@ extern "C" { #define WITH_TESTS #include <hicn/core/listener_table.h> #include <hicn/util/log.h> +#include <hicn/validation.h> } -#define LISTENER_NAME "listener_name_test" -#define LISTENER_NAME_2 "listener_name_test_2" +#define LISTENER_NAME "listener_name" +#define LISTENER_NAME_2 "listener_name_2" class ListenerTableTest : public ::testing::Test { protected: ListenerTableTest() { + assert(is_symbolic_name(LISTENER_NAME, SYMBOLIC_NAME_LEN)); + assert(is_symbolic_name(LISTENER_NAME_2, SYMBOLIC_NAME_LEN)); + log_conf.log_level = LOG_INFO; listener_table_ = listener_table_create(); diff --git a/hicn-light/src/hicn/test/test-packet_cache.cc b/hicn-light/src/hicn/test/test-packet_cache.cc index 76fdb4516..37f4fe985 100644 --- a/hicn-light/src/hicn/test/test-packet_cache.cc +++ b/hicn-light/src/hicn/test/test-packet_cache.cc @@ -96,25 +96,26 @@ class PacketCacheTest : public ::testing::Test { TEST_F(PacketCacheTest, LowLevelOperations) { kh_pkt_cache_prefix_t *prefix_to_suffixes = kh_init_pkt_cache_prefix(); const hicn_name_prefix_t *prefix = hicn_name_get_prefix(&name); - _add_suffix(prefix_to_suffixes, prefix, 1, 11); - _add_suffix(prefix_to_suffixes, prefix, 2, 22); + _add_suffix(prefix_to_suffixes, prefix, 1, 11, pkt_cache->prefix_keys); + _add_suffix(prefix_to_suffixes, prefix, 2, 22, pkt_cache->prefix_keys); - unsigned id = _get_suffix(prefix_to_suffixes, prefix, 1); + unsigned id = + _get_suffix(prefix_to_suffixes, prefix, 1, pkt_cache->prefix_keys); EXPECT_EQ(id, 11UL); - id = _get_suffix(prefix_to_suffixes, prefix, 2); + id = _get_suffix(prefix_to_suffixes, prefix, 2, pkt_cache->prefix_keys); EXPECT_EQ(id, 22UL); - id = _get_suffix(prefix_to_suffixes, prefix, 5); + id = _get_suffix(prefix_to_suffixes, prefix, 5, pkt_cache->prefix_keys); EXPECT_EQ(id, HICN_INVALID_SUFFIX); - _add_suffix(prefix_to_suffixes, prefix, 5, 55); - id = _get_suffix(prefix_to_suffixes, prefix, 5); + _add_suffix(prefix_to_suffixes, prefix, 5, 55, pkt_cache->prefix_keys); + id = _get_suffix(prefix_to_suffixes, prefix, 5, pkt_cache->prefix_keys); EXPECT_EQ(id, 55UL); - _remove_suffix(prefix_to_suffixes, prefix, 2); - _add_suffix(prefix_to_suffixes, prefix, 2, 222); - id = _get_suffix(prefix_to_suffixes, prefix, 2); + _remove_suffix(prefix_to_suffixes, prefix, 2, pkt_cache->prefix_keys); + _add_suffix(prefix_to_suffixes, prefix, 2, 222, pkt_cache->prefix_keys); + id = _get_suffix(prefix_to_suffixes, prefix, 2, pkt_cache->prefix_keys); EXPECT_EQ(id, 222UL); _prefix_map_free(prefix_to_suffixes); @@ -585,13 +586,15 @@ TEST_F(PacketCacheTest, PerformanceDoubleLookup) { for (int seq = 0; seq < N_OPS; seq++) { hicn_name_set_suffix(&tmp, seq); _add_suffix(prefix_to_suffixes, hicn_name_get_prefix(&tmp), - hicn_name_get_suffix(&tmp), hicn_name_get_suffix(&tmp)); + hicn_name_get_suffix(&tmp), hicn_name_get_suffix(&tmp), + pkt_cache->prefix_keys); } // Read from hash table for (int seq = 0; seq < N_OPS; seq++) { hicn_name_set_suffix(&tmp, seq); - _get_suffix(prefix_to_suffixes, hicn_name_get_prefix(&tmp), seq); + _get_suffix(prefix_to_suffixes, hicn_name_get_prefix(&tmp), seq, + pkt_cache->prefix_keys); } _prefix_map_free(prefix_to_suffixes); @@ -605,7 +608,8 @@ TEST_F(PacketCacheTest, PerformanceCachedLookup) { auto elapsed_time_single = get_execution_time([&]() { kh_pkt_cache_prefix_t *prefix_to_suffixes = kh_init_pkt_cache_prefix(); kh_pkt_cache_suffix_t *suffixes = - _get_suffixes(prefix_to_suffixes, hicn_name_get_prefix(&tmp), true); + _get_suffixes(prefix_to_suffixes, hicn_name_get_prefix(&tmp), true, + pkt_cache->prefix_keys); // Add to hash table for (int seq = 0; seq < N_OPS; seq++) { @@ -638,7 +642,8 @@ TEST_F(PacketCacheTest, PerformanceCachedLookupRandom) { auto elapsed_time_single_rand = get_execution_time([&]() { kh_pkt_cache_prefix_t *prefix_to_suffixes = kh_init_pkt_cache_prefix(); kh_pkt_cache_suffix_t *suffixes = - _get_suffixes(prefix_to_suffixes, hicn_name_get_prefix(&tmp), true); + _get_suffixes(prefix_to_suffixes, hicn_name_get_prefix(&tmp), true, + pkt_cache->prefix_keys); // Add to hash table for (int seq = 0; seq < N_OPS; seq++) { diff --git a/hicn-plugin/src/interest_pcslookup_node.c b/hicn-plugin/src/interest_pcslookup_node.c index 743227c18..4947b67ff 100644 --- a/hicn-plugin/src/interest_pcslookup_node.c +++ b/hicn-plugin/src/interest_pcslookup_node.c @@ -200,7 +200,7 @@ hicn_interest_manifest_pcslookup_node_inline (vlib_main_t *vm, u32 next0 = HICN_INTEREST_PCSLOOKUP_NEXT_ERROR_DROP; hicn_pcs_entry_t *pcs_entry = NULL; interest_manifest_header_t *int_manifest_header = NULL; - int pos = 0; + unsigned long pos = 0; rt = vlib_node_get_runtime_data (vm, hicn_interest_pcslookup_node.index); diff --git a/lib/includes/CMakeLists.txt b/lib/includes/CMakeLists.txt index 61af7eca8..3c79fb891 100644 --- a/lib/includes/CMakeLists.txt +++ b/lib/includes/CMakeLists.txt @@ -47,6 +47,7 @@ set(LIBHICN_HEADER_FILES_UTIL ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/pool.h ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/ring.h ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/set.h + ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/slab.h ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/sstrncpy.h ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/token.h ${CMAKE_CURRENT_SOURCE_DIR}/hicn/util/types.h @@ -55,4 +56,3 @@ set(LIBHICN_HEADER_FILES_UTIL ) set_property(GLOBAL PROPERTY LIBHICN_HEADER_FILES_UTIL_PROPERTY "${LIBHICN_HEADER_FILES_UTIL}") - diff --git a/lib/includes/hicn/util/log.h b/lib/includes/hicn/util/log.h index 6b35d1fef..b9b7725d6 100644 --- a/lib/includes/hicn/util/log.h +++ b/lib/includes/hicn/util/log.h @@ -20,12 +20,15 @@ #include <stdio.h> // FILE #include <time.h> // time, localtime -#define LOG_FATAL 0 -#define LOG_ERROR 1 -#define LOG_WARN 2 -#define LOG_INFO 3 -#define LOG_DEBUG 4 -#define LOG_TRACE 5 +typedef enum +{ + LOG_FATAL, + LOG_ERROR, + LOG_WARN, + LOG_INFO, + LOG_DEBUG, + LOG_TRACE +} log_level_t; typedef struct { diff --git a/lib/includes/hicn/util/slab.h b/lib/includes/hicn/util/slab.h new file mode 100644 index 000000000..2c6546add --- /dev/null +++ b/lib/includes/hicn/util/slab.h @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2022 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @brief The slab is used to store elements of the same size. + * + * The slab contains blocks of contiguous memory. Each block contains multiple + * chunks. An element is stored inside a chunk and the chunk has a header with + * a pointer to the block it belongs to. + * + * Blocks are stored in two doubly-linked lists: 'full' for blocks that + * are already full, 'partial_or_empty' for blocks with available chunks. When + * a block becomes full it is moved into the 'full' list and vice versa. + * + * When allocationg an element, a block is taken from the 'partial_or_empty' + * list if such list is not empty. If empty, a new block of contiguous memory + * is created and put in the 'partial_or_empty' list. Then, a chunk is taken + * from the block. When releasing an element, the block it belongs to is + * retrieved from the chunk header and used to release the chunk. + * + * Blocks are created with increasing capacity (i.e. number of chunks they + * contain) such that every new block allocaion doubles the total number of + * chunks stored in the slab. + */ + +#ifndef UTIL_SLAB_H +#define UTIL_SLAB_H + +#include <stddef.h> + +#define SLAB_INIT_SIZE 32 + +/* CHUNK */ + +typedef struct block_s block_t; +typedef struct +{ + block_t *block; // Pointer to the block that contains the chunk +} chunk_hdr_t; + +#define CHUNK_HDRLEN SIZEOF_ALIGNED (chunk_hdr_t) +#define chunk_hdr(chunk) ((chunk_hdr_t *) ((uint8_t *) (chunk) -CHUNK_HDRLEN)) + +/* BLOCK */ + +struct block_s +{ + void *pool; + block_t *prev; + block_t *next; +}; + +/* SLAB */ + +typedef struct +{ + size_t num_chunks; // Total number of chunks (from all blocks) currently + // stored in the slab + size_t chunk_size; + block_t *full; + block_t *partial_or_empty; +} slab_t; + +/* Internal API */ + +slab_t *_slab_create (size_t elt_size, size_t num_elts); +void *_slab_get (slab_t *slab); +void _slab_put (slab_t *slab, void *elt); + +/* Public API */ + +/** + * @brief Create a slab able to store elements of type 'TYPE'. + * + * @param[in] TYPE Type of the elements to store in the slab. + * @param[in] SIZE Initial size of the slab, i.e. size of the initial block. + * @return slab_t* The slab created, NULL if error. + */ +#define slab_create(TYPE, SIZE) _slab_create (sizeof (TYPE), SIZE) + +/** + * @brief Free a slab. + * + * @param[in] slab Slab to free. + */ +void slab_free (slab_t *slab); + +/** + * @brief Get an element from the slab. + * + * @param[in] TYPE Type of the elements stored in the slab. + * @param[in] SLAB Slab to take the element from. + * @return TYPE* Element retrieved from the slab + */ +#define slab_get(TYPE, SLAB) (TYPE *) _slab_get (SLAB) + +/** + * @brief Same as 'slab_get' but with a different signature, to avoid passing + * the type that is instead inferred from the element. + * + * @param[in] SLAB Slab to take the element from. + * @param[in, out] ELT Element retrieved from the slab. + */ +#define slab_get2(SLAB, ELT) ELT = (typeof (*(ELT)) *) _slab_get (SLAB) + +/** + * @brief Put an element back into the slab. + * + * @param[in] SLAB Slab to return the element to. + * @param[in] ELT Element to put in the slab. + */ +#define slab_put(SLAB, ELT) _slab_put (SLAB, (void *) ELT) + +#endif /* UTIL_SLAB_H */ diff --git a/lib/includes/hicn/util/sstrncpy.h b/lib/includes/hicn/util/sstrncpy.h index 81427be6b..0b397c26b 100644 --- a/lib/includes/hicn/util/sstrncpy.h +++ b/lib/includes/hicn/util/sstrncpy.h @@ -20,6 +20,7 @@ #define __STDC_WANT_LIB_EXT1__ 1 #endif +#include <errno.h> #include <string.h> #ifdef __STDC_LIB_EXT1__ diff --git a/lib/src/CMakeLists.txt b/lib/src/CMakeLists.txt index 10c39fae2..27446a493 100644 --- a/lib/src/CMakeLists.txt +++ b/lib/src/CMakeLists.txt @@ -36,6 +36,7 @@ list(APPEND LIBHICN_SOURCE_FILES util/log.c util/pool.c util/ring.c + util/slab.c util/types.c util/vector.c ) diff --git a/lib/src/test/CMakeLists.txt b/lib/src/test/CMakeLists.txt index 17cf835d2..d828c8dd8 100644 --- a/lib/src/test/CMakeLists.txt +++ b/lib/src/test/CMakeLists.txt @@ -27,6 +27,7 @@ list(APPEND TESTS_SRC test_khash.cc test_pool.cc test_ring.cc + test_slab.cc test_vector.cc ) diff --git a/lib/src/test/test_interest_manifest.cc b/lib/src/test/test_interest_manifest.cc index da7531fd3..25ac83728 100644 --- a/lib/src/test/test_interest_manifest.cc +++ b/lib/src/test/test_interest_manifest.cc @@ -152,7 +152,7 @@ TEST_F (InterestManifestTest, SerializeDeserialize) EXPECT_THAT (header->n_suffixes, ::testing::Eq (n_suffixes)); int i = 0; - int pos; + unsigned long pos; interest_manifest_foreach_suffix (header, suffix, pos) { if (pos == 0) @@ -169,7 +169,7 @@ TEST_F (InterestManifestTest, SerializeDeserialize) TEST_F (InterestManifestTest, ForEach) { - int pos; + unsigned long pos; hicn_name_suffix_t *suffix = nullptr; auto header = reinterpret_cast<interest_manifest_header_t *> (buffer); interest_manifest_init (header, 0); diff --git a/lib/src/test/test_khash.cc b/lib/src/test/test_khash.cc index b0423ab5d..70b2f2258 100644 --- a/lib/src/test/test_khash.cc +++ b/lib/src/test/test_khash.cc @@ -159,11 +159,11 @@ TEST_F (KHashTest, Collisions) k = kh_put_test_map (map, &key1, &ret); EXPECT_EQ (ret, 1); - kh_val (map, k) = 15; + kh_val (map, k) = 15u; k = kh_put_test_map (map, &key2, &ret); EXPECT_EQ (ret, 1); - kh_val (map, k) = 27; + kh_val (map, k) = 27u; k = kh_get_test_map (map, &key1); ASSERT_NE (k, kh_end (map)); diff --git a/lib/src/test/test_slab.cc b/lib/src/test/test_slab.cc new file mode 100644 index 000000000..15deff3c1 --- /dev/null +++ b/lib/src/test/test_slab.cc @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2022 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <gtest/gtest.h> + +extern "C" +{ +#include <hicn/util/slab.h> +} + +class SlabTest : public ::testing::Test +{ +protected: + SlabTest () {} + virtual ~SlabTest () { slab_free (slab); } + + slab_t *slab; +}; + +typedef struct +{ + int index; + int val; +} element_t; + +TEST_F (SlabTest, SlabCreateAndGetSingleChunk) +{ + slab = slab_create (element_t, 16); + ASSERT_NE (slab, nullptr); + + element_t *e = slab_get (element_t, slab); + ASSERT_NE (e, nullptr); + slab_put (slab, e); +} + +TEST_F (SlabTest, SlabGetChunks) +{ + slab = slab_create (element_t, 2); + + // Force creation of multiple blocks (since initial size is only 2) + for (int i = 0; i < 100; i++) + { + element_t *e = slab_get (element_t, slab); + EXPECT_NE (e, nullptr); + } +} + +TEST_F (SlabTest, SlabGetAndPutChunksNoResize) +{ + constexpr int NUM_ELEMENTS = 64; + element_t *elements[NUM_ELEMENTS]; + for (int i = 0; i < NUM_ELEMENTS; i++) + elements[i] = NULL; + + // Initial size=NUM_ELEMENTS, only one block will be created + slab = slab_create (element_t, NUM_ELEMENTS); + + for (int i = 0; i < NUM_ELEMENTS; i++) + { + elements[i] = slab_get (element_t, slab); + EXPECT_NE (elements[i], nullptr); + } + + // Release all chunks + for (int i = 0; i < NUM_ELEMENTS; i++) + slab_put (slab, elements[i]); +} + +TEST_F (SlabTest, SlabGetAndPutChunks) +{ + constexpr int NUM_ELEMENTS = 100; + element_t *elements[NUM_ELEMENTS]; + for (int i = 0; i < NUM_ELEMENTS; i++) + elements[i] = NULL; + + // Initial size=2 while NUM_ELEMENTS=100, to force creation of multiple + // blocks + slab = slab_create (sizeof (element_t), 2); + + for (int i = 0; i < NUM_ELEMENTS; i++) + { + elements[i] = slab_get (element_t, slab); + EXPECT_NE (elements[i], nullptr); + } + + // Release all chunks + for (int i = 0; i < NUM_ELEMENTS; i++) + slab_put (slab, elements[i]); +} + +TEST_F (SlabTest, SlabGetAndPutSomeChunks) +{ + slab = slab_create (element_t, 2); + + constexpr int NUM_ELEMENTS = 100; + element_t *elements[NUM_ELEMENTS]; + for (int i = 0; i < NUM_ELEMENTS; i++) + elements[i] = NULL; + + // Get chunks... + for (int i = 0; i < NUM_ELEMENTS; i++) + { + elements[i] = slab_get (element_t, slab); + EXPECT_NE (elements[i], nullptr); + + // ...and return only some of them + if (i % 5 == 0) + slab_put (slab, elements[i]); + } +} + +TEST_F (SlabTest, SlabGetSameChunkTwice) +{ + slab = slab_create (element_t, 1); + + // Get chunk and update it before returning it + element_t *e = slab_get (element_t, slab); + ASSERT_NE (e, nullptr); + element_t *prev = e; + e->index = 2; + e->val = 3; + slab_put (slab, e); + + // Get a chunk again: it should return the previous one + // without wiping its memory + e = slab_get (element_t, slab); + ASSERT_NE (e, nullptr); + EXPECT_EQ (e, prev); + EXPECT_EQ (e->index, 2); + EXPECT_EQ (e->val, 3); + + // Try to get an additional chunk: it should return a new chunk + // (different from previous one) + e = slab_get (element_t, slab); + EXPECT_NE (e, prev); +}
\ No newline at end of file diff --git a/lib/src/util/slab.c b/lib/src/util/slab.c new file mode 100644 index 000000000..763dcb444 --- /dev/null +++ b/lib/src/util/slab.c @@ -0,0 +1,203 @@ +/* + * Copyright (c) 2022 Cisco and/or its affiliates. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at: + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <hicn/util/pool.h> +#include <hicn/util/slab.h> +#include <stdlib.h> + +/* BLOCK LINKED LISTS */ + +static void +block_add_to_head (block_t **head_ptr, block_t *block) +{ + if (head_ptr == NULL || block == NULL) + return; + + block->prev = NULL; + if (*head_ptr != NULL) + { + block->next = *head_ptr; + block->next->prev = block; + } + + *head_ptr = block; +} + +static block_t * +block_remove_from_head (block_t **head_ptr) +{ + if (head_ptr == NULL || *head_ptr == NULL) + return NULL; + + block_t *old_head = *head_ptr; + *head_ptr = old_head->next; + + if (*head_ptr != NULL) + (*head_ptr)->prev = NULL; + return old_head; +} + +static void +block_remove (block_t **head_ptr, block_t *block) +{ + if (*head_ptr == NULL || block == NULL) + return; + + if (block == *head_ptr) + *head_ptr = block->next; + if (block->next != NULL) + block->next->prev = block->prev; + if (block->prev != NULL) + block->prev->next = block->next; +} + +static bool +is_block_list_empty (block_t *block) +{ + return block == NULL; +} + +static void +block_list_free (block_t **head) +{ + if (head == NULL || *head == NULL) + return; + + block_t *curr_block = *head; + while (curr_block != NULL) + { + block_t *next = curr_block->next; + pool_free (curr_block->pool); + free (curr_block); + + curr_block = next; + } + + *head = NULL; +} + +/* BLOCK */ + +static bool +is_block_full (block_t *block) +{ + return pool_get_free_indices_size (block->pool) == 0; +} + +static void +block_set_ptr_in_chunks (block_t *block, size_t chunk_size) +{ + void *chunk = block->pool; + + // Cannot use `pool_foreach()` since it requires to know the type + // while here we use a generic (void *) + for (int i = 0; i < pool_get_alloc_size (block->pool); i++) + { + chunk_hdr_t *hdr = (chunk_hdr_t *) chunk; + hdr->block = block; + + chunk = (uint8_t *) (chunk) + chunk_size; // Move to next chunk + } +} + +static block_t * +block_create (size_t chunk_size, size_t num_chunks) +{ + block_t *block = malloc (sizeof (block_t)); + if (block == NULL) + return NULL; + + block->prev = block->next = NULL; + _pool_init (&block->pool, chunk_size, num_chunks, 0); + block_set_ptr_in_chunks (block, chunk_size); + + return block; +} + +/* SLAB */ + +slab_t * +_slab_create (size_t elt_size, size_t num_elts) +{ + // Initialize slab + slab_t *slab = malloc (sizeof (slab_t)); + if (slab == NULL) + return NULL; + + *slab = (slab_t){ .num_chunks = next_pow2 (num_elts), + .chunk_size = CHUNK_HDRLEN + elt_size, + .full = NULL, + .partial_or_empty = NULL }; + + // Add initial empty block to partial or empty list + block_t *block = block_create (slab->chunk_size, slab->num_chunks); + block_add_to_head (&slab->partial_or_empty, block); + + return slab; +} + +void +slab_free (slab_t *slab) +{ + block_list_free (&slab->full); + block_list_free (&slab->partial_or_empty); + free (slab); +} + +void * +_slab_get (slab_t *slab) +{ + // Create new empty block if none with available chunks + if (is_block_list_empty (slab->partial_or_empty)) + { + block_t *block = block_create (slab->chunk_size, slab->num_chunks); + block_add_to_head (&slab->partial_or_empty, block); + + slab->num_chunks *= 2; // Grow size exponentially + } + + // Get chunck from first block in 'partial_or_empty' list + void *chunk; + _pool_get (&slab->partial_or_empty->pool, &chunk, slab->chunk_size); + + // If the current block (i.e. head of 'partial_or_empty' list) if full, + // move it to the 'full' list + if (is_block_full (slab->partial_or_empty)) + { + block_t *block = block_remove_from_head (&slab->partial_or_empty); + block_add_to_head (&slab->full, block); + } + + return (uint8_t *) chunk + CHUNK_HDRLEN; +} + +void +_slab_put (slab_t *slab, void *chunk) +{ + // Get which block the chunk (that we want to release) belong to + chunk_hdr_t *hdr = chunk_hdr (chunk); + block_t *block = hdr->block; + + // Put chunk back into block + bool is_full = is_block_full (block); + _pool_put (&block->pool, (void *) &hdr, slab->chunk_size); + + // If the block was previously full, move it to 'partial_or_empty' list + if (is_full) + { + block_remove (&slab->full, block); + block_add_to_head (&slab->partial_or_empty, block); + } +}
\ No newline at end of file diff --git a/scripts/functions.sh b/scripts/functions.sh index e5484b02e..d6d8bf84e 100644 --- a/scripts/functions.sh +++ b/scripts/functions.sh @@ -81,13 +81,16 @@ function download_artifacts() { [[ -n ${GERRIT_PATCHSET_NUMBER:-} ]]; then # Retrieve the Jenkins URL of the build relative to this PATCHSET - JENKINS_URL=$( + JENKINS_URLS=$( curl -s "https://${GERRIT_HOST}/r/changes/${GERRIT_CHANGE_NUMBER}/detail" | tail -n +2 | jq '.messages[].message?' | grep -E "Patch Set ${GERRIT_PATCHSET_NUMBER}:.*hicn-verify-build.*build_success-hicn-ubuntu2004-$(uname -m)" | grep -Eo "https?://jenkins.fd.io/job/hicn-verify-build-hicn-ubuntu2004-$(uname -m)[^ ]+" ) - ARTIFACTS_URL="${JENKINS_URL}/artifact/packages/*zip*/packages.zip" + + # Transform string to array and get last + JENKINS_URLS_ARRAY=(${JENKINS_URLS}) + ARTIFACTS_URL="${JENKINS_URLS_ARRAY[-1]}/artifact/packages/*zip*/packages.zip" # Download artifacts curl -o "${SCRIPT_PATH}/../packages.zip" -L "${ARTIFACTS_URL}" diff --git a/tests/1-node.yml b/tests/1-node.yml index 515ca6871..eb8c19f34 100644 --- a/tests/1-node.yml +++ b/tests/1-node.yml @@ -4,6 +4,8 @@ services: build: context: .. dockerfile: ${DOCKERFILE} + args: + - BASE_IMAGE image: hicn-base privileged: true container_name: forwarder diff --git a/tests/2-nodes-vpp-memif-replication.yml b/tests/2-nodes-vpp-memif-replication.yml index 9fbb57a40..54b9840ad 100644 --- a/tests/2-nodes-vpp-memif-replication.yml +++ b/tests/2-nodes-vpp-memif-replication.yml @@ -1,18 +1,11 @@ version: "3" services: - vpp_client_memif: - build: - context: .. - dockerfile: ${DOCKERFILE} - stdin_open: true - tty: true - working_dir: /workspace + client: container_name: ${TEST_VPP_MEMIF_REPLICATION}-client - hostname: client + networks: [] volumes: - /tmp/memif:/memif:z - ..:/workspace:z - entrypoint: [/bin/bash, -c] command: - | if [ -d /workspace/build-dev ]; then @@ -69,19 +62,12 @@ services: sudo vppctl hicn strategy set 2 prefix b002::/64 tail -f /dev/null - vpp_server_memif: - build: - context: .. - dockerfile: ${DOCKERFILE} - stdin_open: true - tty: true - working_dir: /workspace + server: container_name: ${TEST_VPP_MEMIF_REPLICATION}-server - hostname: server + networks: [] volumes: - /tmp/memif:/memif:z - ..:/workspace:z - entrypoint: [/bin/bash, -c] command: - | if [ -d /workspace/build-dev ]; then diff --git a/tests/2-nodes.yml b/tests/2-nodes.yml index 064ed5453..05a69359e 100644 --- a/tests/2-nodes.yml +++ b/tests/2-nodes.yml @@ -4,6 +4,8 @@ services: build: context: .. dockerfile: ${DOCKERFILE} + args: + - BASE_IMAGE privileged: true stdin_open: true hostname: client |