diff options
Diffstat (limited to 'src')
37 files changed, 1 insertions, 12383 deletions
diff --git a/src/vppinfra/CMakeLists.txt b/src/vppinfra/CMakeLists.txt index f2279d0857c..e667eb03e8c 100644 --- a/src/vppinfra/CMakeLists.txt +++ b/src/vppinfra/CMakeLists.txt @@ -47,7 +47,6 @@ set(VPPINFRA_SRCS elf.c elog.c error.c - fheap.c fifo.c format.c graph.c @@ -68,7 +67,6 @@ set(VPPINFRA_SRCS random_isaac.c rbtree.c serialize.c - slist.c socket.c std-formats.c string.c @@ -87,7 +85,6 @@ set(VPPINFRA_SRCS valloc.c vec.c vector.c - zvec.c ) set(VPPINFRA_HEADERS @@ -109,12 +106,6 @@ set(VPPINFRA_HEADERS clib.h cpu.h crc32.h - cuckoo_8_8.h - cuckoo_16_8.h - cuckoo_common.h - cuckoo_debug.h - cuckoo_template.h - cuckoo_template.c dlist.h dlmalloc.h elf_clib.h @@ -122,12 +113,8 @@ set(VPPINFRA_HEADERS elog.h error_bootstrap.h error.h - fheap.h fifo.h file.h - flowhash_24_16.h - flowhash_8_8.h - flowhash_template.h format.h graph.h hash.h @@ -149,7 +136,6 @@ set(VPPINFRA_HEADERS os.h pcap.h pcap_funcs.h - pipeline.h pmalloc.h pool.h pmc.h @@ -160,7 +146,6 @@ set(VPPINFRA_HEADERS rbtree.h serialize.h sha2.h - slist.h smp.h socket.h sparse_vec.h @@ -190,8 +175,6 @@ set(VPPINFRA_HEADERS vector_neon.h vector_sse42.h xxhash.h - xy.h - zvec.h linux/syscall.h linux/sysfs.h ) @@ -218,12 +201,10 @@ option(VPP_BUILD_VPPINFRA_TESTS "Build vppinfra tests." OFF) if(VPP_BUILD_VPPINFRA_TESTS) foreach(test bihash_vec88 - cuckoo_template dlist elf elog fifo - flowhash_template format fpool hash @@ -238,16 +219,13 @@ if(VPP_BUILD_VPPINFRA_TESTS) random_isaac rwlock serialize - slist socket spinlock time time_range - timing_wheel tw_timer valloc vec - zvec ) add_vpp_executable(test_${test} SOURCES test_${test}.c @@ -255,7 +233,7 @@ if(VPP_BUILD_VPPINFRA_TESTS) ) endforeach() - foreach(test bihash_template cuckoo_bihash) + foreach(test bihash_template) add_vpp_executable(test_${test} SOURCES test_${test}.c LINK_LIBRARIES vppinfra Threads::Threads diff --git a/src/vppinfra/anneal.c b/src/vppinfra/anneal.c deleted file mode 100644 index 35d10946482..00000000000 --- a/src/vppinfra/anneal.c +++ /dev/null @@ -1,172 +0,0 @@ -/* - Copyright (c) 2011 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 <vppinfra/anneal.h> - -/* - * Optimize an objective function by simulated annealing - * - * Here are a couple of short, easily-understood - * descriptions of simulated annealing: - * - * http://www.cs.sandia.gov/opt/survey/sa.html - * Numerical Recipes in C, 2nd ed., 444ff - * - * The description in the Wikipedia is not helpful. - * - * The algorithm tries to produce a decent answer to combinatorially - * explosive optimization problems by analogy to slow cooling - * of hot metal, aka annealing. - * - * There are (at least) three problem-dependent annealing parameters - * to consider: - * - * t0, the initial "temperature. Should be set so that the probability - * of accepting a transition to a higher cost configuration is - * initially about 0.8. - * - * ntemps, the number of temperatures to use. Each successive temperature - * is some fraction of the previous temperature. - * - * nmoves_per_temp, the number of configurations to try at each temperature - * - * It is a black art to set ntemps, nmoves_per_temp, and the rate - * at which the temperature drops. Go too fast with too few iterations, - * and the computation falls into a local minimum instead of the - * (desired) global minimum. - */ - -void -clib_anneal (clib_anneal_param_t * p) -{ - f64 t; - f64 cost, prev_cost, delta_cost, initial_cost, best_cost; - f64 random_accept, delta_cost_over_t; - f64 total_increase = 0.0, average_increase; - u32 i, j; - u32 number_of_increases = 0; - u32 accepted_this_temperature; - u32 best_saves_this_temperature; - int accept; - - t = p->initial_temperature; - best_cost = initial_cost = prev_cost = p->anneal_metric (p->opaque); - p->anneal_save_best_configuration (p->opaque); - - if (p->flags & CLIB_ANNEAL_VERBOSE) - fformat (stdout, "Initial cost %.2f\n", initial_cost); - - for (i = 0; i < p->number_of_temperatures; i++) - { - accepted_this_temperature = 0; - best_saves_this_temperature = 0; - - p->anneal_restore_best_configuration (p->opaque); - cost = best_cost; - - for (j = 0; j < p->number_of_configurations_per_temperature; j++) - { - p->anneal_new_configuration (p->opaque); - cost = p->anneal_metric (p->opaque); - - delta_cost = cost - prev_cost; - - /* cost function looks better, accept this move */ - if (p->flags & CLIB_ANNEAL_MINIMIZE) - accept = delta_cost < 0.0; - else - accept = delta_cost > 0.0; - - if (accept) - { - if (p->flags & CLIB_ANNEAL_MINIMIZE) - if (cost < best_cost) - { - if (p->flags & CLIB_ANNEAL_VERBOSE) - fformat (stdout, "New best cost %.2f\n", cost); - best_cost = cost; - p->anneal_save_best_configuration (p->opaque); - best_saves_this_temperature++; - } - - accepted_this_temperature++; - prev_cost = cost; - continue; - } - - /* cost function worse, keep stats to suggest t0 */ - total_increase += (p->flags & CLIB_ANNEAL_MINIMIZE) ? - delta_cost : -delta_cost; - - number_of_increases++; - - /* - * Accept a higher cost with Pr { e^(-(delta_cost / T)) }, - * equivalent to rnd[0,1] < e^(-(delta_cost / T)) - * - * AKA, the Boltzmann factor. - */ - random_accept = random_f64 (&p->random_seed); - - delta_cost_over_t = delta_cost / t; - - if (random_accept < exp (-delta_cost_over_t)) - { - accepted_this_temperature++; - prev_cost = cost; - continue; - } - p->anneal_restore_previous_configuration (p->opaque); - } - - if (p->flags & CLIB_ANNEAL_VERBOSE) - { - fformat (stdout, "Temp %.2f, cost %.2f, accepted %d, bests %d\n", t, - prev_cost, accepted_this_temperature, - best_saves_this_temperature); - fformat (stdout, "Improvement %.2f\n", initial_cost - prev_cost); - fformat (stdout, "-------------\n"); - } - - t = t * p->temperature_step; - } - - /* - * Empirically, one wants the probability of accepting a move - * at the initial temperature to be about 0.8. - */ - average_increase = total_increase / (f64) number_of_increases; - p->suggested_initial_temperature = average_increase / 0.22; /* 0.22 = -ln (0.8) */ - - p->final_temperature = t; - p->final_metric = p->anneal_metric (p->opaque); - - if (p->flags & CLIB_ANNEAL_VERBOSE) - { - fformat (stdout, "Average cost increase from a bad move: %.2f\n", - average_increase); - fformat (stdout, "Suggested t0 = %.2f\n", - p->suggested_initial_temperature); - } -} - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/anneal.h b/src/vppinfra/anneal.h deleted file mode 100644 index 148d38ba551..00000000000 --- a/src/vppinfra/anneal.h +++ /dev/null @@ -1,89 +0,0 @@ -/* - Copyright (c) 2011 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. -*/ - -#ifndef __included_anneal_h__ -#define __included_anneal_h__ - -#include <vppinfra/clib.h> -#include <vppinfra/format.h> -#include <vppinfra/random.h> -#include <math.h> - -typedef struct -{ - /* Initial temperature */ - f64 initial_temperature; - - /* Temperature fraction at each step, 0.95 is reasonable */ - f64 temperature_step; - - /* Number of temperatures used */ - u32 number_of_temperatures; - - /* Number of configurations tried at each temperature */ - u32 number_of_configurations_per_temperature; - - u32 flags; -#define CLIB_ANNEAL_VERBOSE (1<<0) -#define CLIB_ANNEAL_MINIMIZE (1<<1) /* mutually exclusive */ -#define CLIB_ANNEAL_MAXIMIZE (1<<2) /* mutually exclusive */ - - /* Random number seed, set to ensure repeatable results */ - u32 random_seed; - - /* Opaque data passed to callbacks */ - void *opaque; - - /* Final temperature (output) */ - f64 final_temperature; - - /* Final metric (output) */ - f64 final_metric; - - /* Suggested initial temperature (output) */ - f64 suggested_initial_temperature; - - - /*--- Callbacks ---*/ - - /* objective function to minimize */ - f64 (*anneal_metric) (void *opaque); - - /* Generate a new configuration */ - void (*anneal_new_configuration) (void *opaque); - - /* Restore the previous configuration */ - void (*anneal_restore_previous_configuration) (void *opaque); - - /* Save best configuration found e.g at a certain temperature */ - void (*anneal_save_best_configuration) (void *opaque); - - /* restore best configuration found e.g at a certain temperature */ - void (*anneal_restore_best_configuration) (void *opaque); - -} clib_anneal_param_t; - -void clib_anneal (clib_anneal_param_t * p); - -#endif /* __included_anneal_h__ */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/cuckoo_16_8.h b/src/vppinfra/cuckoo_16_8.h deleted file mode 100644 index b667ff6cbb8..00000000000 --- a/src/vppinfra/cuckoo_16_8.h +++ /dev/null @@ -1,128 +0,0 @@ -/* - * Copyright (c) 2017 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. - */ -#undef CLIB_CUCKOO_TYPE - -#define CLIB_CUCKOO_TYPE _16_8 -#define CLIB_CUCKOO_KVP_PER_BUCKET (4) -#define CLIB_CUCKOO_LOG2_KVP_PER_BUCKET (2) -#define CLIB_CUCKOO_BFS_MAX_STEPS (2000) -#define CLIB_CUCKOO_BFS_MAX_PATH_LENGTH (8) - -#ifndef __included_cuckoo_16_8_h__ -#define __included_cuckoo_16_8_h__ - -#include <vppinfra/heap.h> -#include <vppinfra/format.h> -#include <vppinfra/pool.h> -#include <vppinfra/xxhash.h> -#include <vppinfra/cuckoo_debug.h> -#include <vppinfra/cuckoo_common.h> - -#undef CLIB_CUCKOO_OPTIMIZE_PREFETCH -#undef CLIB_CUCKOO_OPTIMIZE_UNROLL -#undef CLIB_CUCKOO_OPTIMIZE_USE_COUNT_LIMITS_SEARCH -#define CLIB_CUCKOO_OPTIMIZE_PREFETCH 1 -#define CLIB_CUCKOO_OPTIMIZE_UNROLL 1 -#define CLIB_CUCKOO_OPTIMIZE_USE_COUNT_LIMITS_SEARCH 1 - -#if __SSE4_2__ && !defined (__i386__) -#include <x86intrin.h> -#endif - -/** 8 octet key, 8 octet key value pair */ -typedef struct -{ - u64 key[2]; /**< the key */ - u64 value; /**< the value */ -} clib_cuckoo_kv_16_8_t; - -/** Decide if a clib_cuckoo_kv_16_8_t instance is free - @param v- pointer to the (key,value) pair -*/ -always_inline int -clib_cuckoo_kv_is_free_16_8 (const clib_cuckoo_kv_16_8_t * v) -{ - if (v->key[0] == ~0ULL && v->value == ~0ULL) - return 1; - return 0; -} - -always_inline void -clib_cuckoo_kv_set_free_16_8 (clib_cuckoo_kv_16_8_t * v) -{ - clib_memset (v, 0xff, sizeof (*v)); -} - -/** Format a clib_cuckoo_kv_16_8_t instance - @param s - u8 * vector under construction - @param args (vararg) - the (key,value) pair to format - @return s - the u8 * vector under construction -*/ -always_inline u8 * -format_cuckoo_kvp_16_8 (u8 * s, va_list * args) -{ - clib_cuckoo_kv_16_8_t *v = va_arg (*args, clib_cuckoo_kv_16_8_t *); - - if (clib_cuckoo_kv_is_free_16_8 (v)) - { - s = format (s, " -- empty -- "); - } - else - { - s = - format (s, "key %llu%llu value %llu", v->key[0], v->key[1], v->value); - } - return s; -} - -always_inline u64 -clib_cuckoo_hash_16_8 (clib_cuckoo_kv_16_8_t * v) -{ -#ifdef clib_crc32c_uses_intrinsics - return clib_crc32c ((u8 *) v->key, 16); -#else - u64 tmp = v->key[0] ^ v->key[1]; - return clib_xxhash (tmp); -#endif -} - -/** Compare two clib_cuckoo_kv_16_8_t instances - @param a - first key - @param b - second key -*/ -always_inline int -clib_cuckoo_key_compare_16_8 (u64 * a, u64 * b) -{ -#if defined(CLIB_HAVE_VEC128) && defined(CLIB_HAVE_VEC128_UNALIGNED_LOAD_STORE) - u64x2 v; - v = u64x2_load_unaligned (a) ^ u64x2_load_unaligned (b); - return u64x2_is_all_zero (v); -#else - return ((a[0] ^ b[0]) | (a[1] ^ b[1])) == 0; -#endif -} - -#undef __included_cuckoo_template_h__ -#include <vppinfra/cuckoo_template.h> - -#endif /* __included_cuckoo_16_8_h__ */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/cuckoo_8_8.h b/src/vppinfra/cuckoo_8_8.h deleted file mode 100644 index 67af79c0e50..00000000000 --- a/src/vppinfra/cuckoo_8_8.h +++ /dev/null @@ -1,120 +0,0 @@ -/* - * Copyright (c) 2017 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. - */ -#undef CLIB_CUCKOO_TYPE - -#define CLIB_CUCKOO_TYPE _8_8 -#define CLIB_CUCKOO_KVP_PER_BUCKET (4) -#define CLIB_CUCKOO_LOG2_KVP_PER_BUCKET (2) -#define CLIB_CUCKOO_BFS_MAX_STEPS (2000) -#define CLIB_CUCKOO_BFS_MAX_PATH_LENGTH (8) - -#ifndef __included_cuckoo_8_8_h__ -#define __included_cuckoo_8_8_h__ - -#include <vppinfra/heap.h> -#include <vppinfra/format.h> -#include <vppinfra/pool.h> -#include <vppinfra/xxhash.h> -#include <vppinfra/cuckoo_debug.h> -#include <vppinfra/cuckoo_common.h> - -#undef CLIB_CUCKOO_OPTIMIZE_PREFETCH -#undef CLIB_CUCKOO_OPTIMIZE_UNROLL -#undef CLIB_CUCKOO_OPTIMIZE_USE_COUNT_LIMITS_SEARCH -#define CLIB_CUCKOO_OPTIMIZE_PREFETCH 1 -#define CLIB_CUCKOO_OPTIMIZE_UNROLL 1 -#define CLIB_CUCKOO_OPTIMIZE_USE_COUNT_LIMITS_SEARCH 1 - -#if __SSE4_2__ && !defined (__i386__) -#include <x86intrin.h> -#endif - -/** 8 octet key, 8 octet key value pair */ -typedef struct -{ - u64 key; /**< the key */ - u64 value; /**< the value */ -} clib_cuckoo_kv_8_8_t; - -/** Decide if a clib_cuckoo_kv_8_8_t instance is free - @param v- pointer to the (key,value) pair -*/ -always_inline int -clib_cuckoo_kv_is_free_8_8 (const clib_cuckoo_kv_8_8_t * v) -{ - if (v->key == ~0ULL && v->value == ~0ULL) - return 1; - return 0; -} - -always_inline void -clib_cuckoo_kv_set_free_8_8 (clib_cuckoo_kv_8_8_t * v) -{ - clib_memset (v, 0xff, sizeof (*v)); -} - -/** Format a clib_cuckoo_kv_8_8_t instance - @param s - u8 * vector under construction - @param args (vararg) - the (key,value) pair to format - @return s - the u8 * vector under construction -*/ -always_inline u8 * -format_cuckoo_kvp_8_8 (u8 * s, va_list * args) -{ - clib_cuckoo_kv_8_8_t *v = va_arg (*args, clib_cuckoo_kv_8_8_t *); - - if (clib_cuckoo_kv_is_free_8_8 (v)) - { - s = format (s, " -- empty -- "); - } - else - { - s = format (s, "key %llu value %llu", v->key, v->value); - } - return s; -} - -always_inline u64 -clib_cuckoo_hash_8_8 (clib_cuckoo_kv_8_8_t * v) -{ -#if defined(clib_crc32c_uses_intrinsics) && !defined (__i386__) - return crc32_u64 (0, v->key); -#else - return clib_xxhash (v->key); -#endif -} - -/** Compare two clib_cuckoo_kv_8_8_t instances - @param a - first key - @param b - second key -*/ -always_inline int -clib_cuckoo_key_compare_8_8 (u64 a, u64 b) -{ - return a == b; -} - -#undef __included_cuckoo_template_h__ -#include <vppinfra/cuckoo_template.h> - -#endif /* __included_cuckoo_8_8_h__ */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/cuckoo_common.h b/src/vppinfra/cuckoo_common.h deleted file mode 100644 index ea0fc30084b..00000000000 --- a/src/vppinfra/cuckoo_common.h +++ /dev/null @@ -1,59 +0,0 @@ -/* - Copyright (c) 2017 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. -*/ - -/* - * Note: to instantiate the template multiple times in a single file, - * #undef __included_cuckoo_template_h__... - */ -#ifndef __included_cuckoo_common_h__ -#define __included_cuckoo_common_h__ - -#include <vppinfra/types.h> - -#define CLIB_CUCKOO_OPTIMIZE_PREFETCH 1 -#define CLIB_CUCKOO_OPTIMIZE_UNROLL 1 -#define CLIB_CUCKOO_OPTIMIZE_USE_COUNT_LIMITS_SEARCH 1 - -#define foreach_clib_cuckoo_error(F) \ - F (CLIB_CUCKOO_ERROR_SUCCESS, 0, "success") \ - F (CLIB_CUCKOO_ERROR_NOT_FOUND, -1, "object not found") \ - F (CLIB_CUCKOO_ERROR_AGAIN, -2, "object busy") - -typedef enum -{ -#define F(n, v, s) n = v, - foreach_clib_cuckoo_error (F) -#undef F -} clib_cuckoo_error_e; - -typedef struct -{ - uword bucket1; - uword bucket2; - u8 reduced_hash; -} clib_cuckoo_lookup_info_t; - -#endif /* __included_cuckoo_common_h__ */ - -/** @endcond */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/cuckoo_debug.h b/src/vppinfra/cuckoo_debug.h deleted file mode 100644 index eb236509935..00000000000 --- a/src/vppinfra/cuckoo_debug.h +++ /dev/null @@ -1,83 +0,0 @@ -/* - * Copyright (c) 2017 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. - */ -/** - * @file - * @brief cuckoo debugs - */ -#ifndef __included_cuckoo_debug_h__ -#define __included_cuckoo_debug_h__ - -/* controls debug counters */ -#define CLIB_CUCKOO_DEBUG_COUNTERS (0) - -/* controls debug prints */ -#define CLIB_CUCKOO_DEBUG (0) - -/* controls garbage collection related debug prints */ -#define CLIB_CUCKOO_DEBUG_GC (0) - -#if CLIB_CUCKOO_DEBUG -#define CLIB_CUCKOO_DEBUG_FILE_DEF \ - static const char *__file = NULL; \ - { \ - __file = strrchr (__FILE__, '/'); \ - if (__file) \ - { \ - ++__file; \ - } \ - else \ - { \ - __file = __FILE__; \ - } \ - } - -#define CLIB_CUCKOO_DBG(fmt, ...) \ - do \ - { \ - CLIB_CUCKOO_DEBUG_FILE_DEF \ - static u8 *_s = NULL; \ - _s = format (_s, "DBG:%s:%d:%s():" fmt, __file, __LINE__, __func__, \ - ##__VA_ARGS__); \ - printf ("%.*s\n", vec_len (_s), _s); \ - vec_reset_length (_s); \ - } \ - while (0); - -#define CLIB_CUCKOO_ERR(fmt, ...) \ - do \ - { \ - CLIB_CUCKOO_DEBUG_FILE_DEF \ - static u8 *_s = NULL; \ - _s = format (_s, "ERR:%s:%d:%s():" fmt, __file, __LINE__, __func__, \ - ##__VA_ARGS__); \ - printf ("%.*s\n", vec_len (_s), _s); \ - vec_reset_length (_s); \ - } \ - while (0); - -#else -#define CLIB_CUCKOO_DBG(...) -#define CLIB_CUCKOO_ERR(...) -#endif - -#endif /* __included_cuckoo_debug_h__ */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/cuckoo_template.c b/src/vppinfra/cuckoo_template.c deleted file mode 100644 index 8cd2a2be2b5..00000000000 --- a/src/vppinfra/cuckoo_template.c +++ /dev/null @@ -1,1002 +0,0 @@ -/* - * Copyright (c) 2017 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. - */ - -/* - * cuckoo hash implementation based on paper - * 'Algorithmic Improvements for Fast Concurrent Cuckoo Hashing' - * by Xiaozhou Li, David G. Andersen, Michael Kaminsky, Michael J. Freedman - * and their libcuckoo implementation (https://github.com/efficient/libcuckoo) - */ - -#include <vppinfra/vec.h> - -int CV (clib_cuckoo_search) (CVT (clib_cuckoo) * h, - CVT (clib_cuckoo_kv) * search_v, - CVT (clib_cuckoo_kv) * return_v) -{ - CVT (clib_cuckoo_kv) tmp = *search_v; - int rv = CV (clib_cuckoo_search_inline) (h, &tmp); - if (CLIB_CUCKOO_ERROR_SUCCESS == rv) - { - *return_v = tmp; - } - return rv; -} - -static -CVT (clib_cuckoo_bucket) * -CV (clib_cuckoo_bucket_at_index) (CVT (clib_cuckoo) * h, uword bucket) -{ - return vec_elt_at_index (h->buckets, bucket); -} - -static uword CV (clib_cuckoo_get_nbuckets) (CVT (clib_cuckoo) * h) -{ - return vec_len (h->buckets); -} - -static inline uword -CV (clib_cuckoo_elt_in_bucket_to_offset) (CVT (clib_cuckoo_bucket) * b, - CVT (clib_cuckoo_kv) * e) -{ - ASSERT (e >= b->elts); - ASSERT (e <= &b->elts[sizeof (b->elts) / sizeof (b->elts[0]) - 1]); - return e - b->elts; -} - -u8 *CV (format_cuckoo_elt) (u8 * s, va_list * args) -{ - CVT (clib_cuckoo_kv) * elt = va_arg (*args, CVT (clib_cuckoo_kv) *); - unsigned reduced_hash = va_arg (*args, unsigned); - if (CV (clib_cuckoo_kv_is_free) (elt)) - { - s = format (s, "[ -- empty -- ]"); - } - else - { - s = format (s, "[%U, reduced hash: %u]", CV (format_cuckoo_kvp), elt, - reduced_hash); - } - return s; -} - -u8 *CV (format_cuckoo_bucket) (u8 * s, va_list * args) -{ - CVT (clib_cuckoo_bucket) * bucket = - va_arg (*args, CVT (clib_cuckoo_bucket) *); - int i = 0; - - /* *INDENT-OFF* */ - clib_cuckoo_bucket_foreach_idx (i) - { - CVT (clib_cuckoo_kv) *elt = bucket->elts + i; - s = format (s, "bucket %p, offset %d: %U\n", bucket, i, - CV (format_cuckoo_elt), elt, bucket->reduced_hashes[i]); - } - /* *INDENT-ON* */ - clib_cuckoo_bucket_aux_t aux = bucket->aux; - s = format (s, "version: %lld, use count: %d\n", - clib_cuckoo_bucket_aux_get_version (aux), - clib_cuckoo_bucket_aux_get_use_count (aux)); - return s; -} - -#if CLIB_CUCKOO_DEBUG -static void CV (clib_cuckoo_deep_self_check) (CVT (clib_cuckoo) * h) -{ - CVT (clib_cuckoo_bucket) * bucket; - uword bucket_idx = 0; - /* *INDENT-OFF* */ - clib_cuckoo_foreach_bucket (bucket, h, { - int i = 0; - int used = 0; - clib_cuckoo_bucket_foreach_idx (i) - { - CVT (clib_cuckoo_kv) *elt = bucket->elts + i; - if (!CV (clib_cuckoo_kv_is_free) (elt)) - { - u64 hash = CV (clib_cuckoo_hash) (elt); - clib_cuckoo_lookup_info_t lookup = - CV (clib_cuckoo_calc_lookup) (h->buckets, hash); - CVT (clib_cuckoo_kv) kv = *elt; - int rv = CV (clib_cuckoo_search) (h, &kv, &kv); - if (CLIB_CUCKOO_ERROR_SUCCESS != rv) - { - CLIB_CUCKOO_DBG ("Search for elt `%U' failed!", - CV (format_cuckoo_elt), elt, - bucket->reduced_hashes[i]); - CLIB_CUCKOO_DBG ("%U", CV (format_cuckoo), h, 1); - } - ASSERT (lookup.bucket1 == bucket_idx || lookup.bucket2 == bucket_idx); - ASSERT (CLIB_CUCKOO_ERROR_SUCCESS == rv); - ++used; - } - } - clib_cuckoo_bucket_aux_t aux = bucket->aux; - ASSERT (used == clib_cuckoo_bucket_aux_get_use_count (aux)); - ++bucket_idx; - }); - /* *INDENT-ON* */ - // CLIB_CUCKOO_DBG ("Deep self check passed: %U", CV (format_cuckoo), h); -} - -#define CLIB_CUCKOO_DEEP_SELF_CHECK(h) CV (clib_cuckoo_deep_self_check) (h) -#define CLIB_CUCKOO_ASSERT_BUCKET_SORTED(b) \ - do \ - { \ - int i; \ - int min_free = CLIB_CUCKOO_KVP_PER_BUCKET; \ - int max_used = 0; \ - clib_cuckoo_bucket_foreach_idx (i) \ - { \ - if (!CV (clib_cuckoo_kv_is_free) (b->elts + i)) \ - { \ - max_used = i; \ - } \ - if (CV (clib_cuckoo_kv_is_free) (b->elts + \ - (CLIB_CUCKOO_KVP_PER_BUCKET - i))) \ - { \ - min_free = i; \ - } \ - } \ - ASSERT (min_free > max_used); \ - } \ - while (0) - -#else -#define CLIB_CUCKOO_DEEP_SELF_CHECK(h) -#define CLIB_CUCKOO_ASSERT_BUCKET_SORTED(b) -#endif - -void CV (clib_cuckoo_init) (CVT (clib_cuckoo) * h, const char *name, - uword nbuckets, - void (*garbage_callback) (CVT (clib_cuckoo) *, - void *), - void *garbage_ctx) -{ - uword log2_nbuckets = max_log2 (nbuckets); - nbuckets = 1ULL << (log2_nbuckets); - CLIB_CUCKOO_DBG ("New cuckoo, adjusted nbuckets %wu", nbuckets); - CVT (clib_cuckoo_bucket) * buckets = NULL; - vec_validate_aligned (buckets, nbuckets - 1, CLIB_CACHE_LINE_BYTES); - ASSERT (nbuckets == vec_len (buckets)); - h->buckets = buckets; - clib_spinlock_init (&h->writer_lock); - /* mark all elements free ... */ - CVT (clib_cuckoo_bucket) * bucket; - /* *INDENT-OFF* */ - clib_cuckoo_foreach_bucket ( - bucket, h, { clib_memset (bucket->elts, 0xff, sizeof (bucket->elts)); }); - /* *INDENT-ON* */ - h->name = name; - h->garbage_callback = garbage_callback; - h->garbage_ctx = garbage_ctx; -} - -void CV (clib_cuckoo_free) (CVT (clib_cuckoo) * h) -{ - clib_memset (h, 0, sizeof (*h)); -} - -static clib_cuckoo_bucket_aux_t -CV (clib_cuckoo_bucket_version_bump_and_lock) (CVT (clib_cuckoo_bucket) * b) -{ - clib_cuckoo_bucket_aux_t aux = b->aux; - u64 version = clib_cuckoo_bucket_aux_get_version (aux); - u8 use_count = clib_cuckoo_bucket_aux_get_use_count (aux); - u8 writer_flag = clib_cuckoo_bucket_aux_get_writer_flag (aux); - ASSERT (0 == writer_flag); - aux = clib_cuckoo_bucket_aux_pack (version + 1, use_count, 1); - b->aux = aux; - return aux; -} - -static void CV (clib_cuckoo_bucket_unlock) (CVT (clib_cuckoo_bucket) * b, - clib_cuckoo_bucket_aux_t aux) -{ - u64 version = clib_cuckoo_bucket_aux_get_version (aux); - u8 use_count = clib_cuckoo_bucket_aux_get_use_count (aux); - u8 writer_flag = clib_cuckoo_bucket_aux_get_writer_flag (aux); - ASSERT (1 == writer_flag); - aux = clib_cuckoo_bucket_aux_pack (version, use_count, 0); - b->aux = aux; -} - -#define CLIB_CUCKOO_DEBUG_PATH (1) -#define CLIB_CUCKOO_DEBUG_PATH_DETAIL (0) - -#if CLIB_CUCKOO_DEBUG && CLIB_CUCKOO_DEBUG_PATH -static u8 *CV (format_cuckoo_path) (u8 * s, va_list * args); -#endif - -static clib_cuckoo_path_t *CV (clib_cuckoo_path_get) (CVT (clib_cuckoo) * h) -{ - clib_cuckoo_path_t *path; - pool_get (h->paths, path); - clib_memset (path, 0, sizeof (*path)); -#if CLIB_CUCKOO_DEBUG_PATH_DETAIL - CLIB_CUCKOO_DBG ("Get path @%lu", (long unsigned) (path - h->paths)); -#endif - return path; -} - -static void CV (clib_cuckoo_path_put) (CVT (clib_cuckoo) * h, uword path_idx) -{ - clib_cuckoo_path_t *path = pool_elt_at_index (h->paths, path_idx); -#if CLIB_CUCKOO_DEBUG_PATH_DETAIL - CLIB_CUCKOO_DBG ("Put path @%lu", (long unsigned) (path - h->paths)); -#endif - pool_put (h->paths, path); -} - -static clib_cuckoo_path_t *CV (clib_cuckoo_path_begin) (CVT (clib_cuckoo) * h, - uword bucket, - uword next_offset) -{ - ASSERT (next_offset < CLIB_CUCKOO_KVP_PER_BUCKET); - clib_cuckoo_path_t *new_path = CV (clib_cuckoo_path_get) (h); - new_path->length = 1; - new_path->data = next_offset; - new_path->start = bucket; - new_path->bucket = bucket; -#if CLIB_CUCKOO_DEBUG_PATH - CLIB_CUCKOO_DBG ("Create new path @%wu, length: %u data: %llu bucket: %wu " - "next-offset: %wu", - new_path - h->paths, new_path->length, - (long long unsigned) new_path->data, new_path->bucket, - next_offset); -#endif - return new_path; -} - -/** - * create a new path based on existing path extended by adding a bucket - * and offset - */ -static uword CV (clib_cuckoo_path_extend) (CVT (clib_cuckoo) * h, - uword path_idx, uword bucket, - unsigned offset) -{ - ASSERT (offset < CLIB_CUCKOO_KVP_PER_BUCKET); - clib_cuckoo_path_t *new_path = CV (clib_cuckoo_path_get) (h); - uword new_path_idx = new_path - h->paths; - clib_cuckoo_path_t *path = pool_elt_at_index (h->paths, path_idx); - new_path->start = path->start; - new_path->length = path->length + 1; - new_path->data = (path->data << CLIB_CUCKOO_LOG2_KVP_PER_BUCKET) + offset; - new_path->bucket = bucket; -#if CLIB_CUCKOO_DEBUG_PATH - CLIB_CUCKOO_DBG ("Extend path @%wu, new path @%wu, %U", path_idx, - new_path_idx, CV (format_cuckoo_path), h, new_path_idx); -#endif - return new_path_idx; -} - -/** return the offset of the last element in the path */ -static uword CV (clib_cuckoo_path_peek_offset) (const clib_cuckoo_path_t * - path) -{ - ASSERT (path->length > 0); - uword mask = (1 << CLIB_CUCKOO_LOG2_KVP_PER_BUCKET) - 1; - uword offset = path->data & mask; - return offset; -} - -static -CVT (clib_cuckoo_kv) * -CV (clib_cuckoo_bucket_find_empty) (CVT (clib_cuckoo_bucket) * bucket) -{ - clib_cuckoo_bucket_aux_t aux = bucket->aux; - u8 use_count = clib_cuckoo_bucket_aux_get_use_count (aux); - if (use_count < CLIB_CUCKOO_KVP_PER_BUCKET) - { - return bucket->elts + use_count; - } - return NULL; -} - -/** - * walk the cuckoo path two ways, - * first backwards, extracting offsets, - * then forward, extracting buckets - * - * buckets and offsets are arrays filled with elements extracted from path - * the arrays must be able to contain CLIB_CUCKOO_BFS_MAX_PATH_LENGTH elements - */ -static void -clib_cuckoo_path_walk (CVT (clib_cuckoo) * h, uword path_idx, - uword * buckets, uword * offsets) -{ - clib_cuckoo_path_t *path = pool_elt_at_index (h->paths, path_idx); - ASSERT (path->length > 0); - u64 data = path->data; - uword mask = (1 << CLIB_CUCKOO_LOG2_KVP_PER_BUCKET) - 1; - uword i; - for (i = path->length; i > 0; --i) - { - uword offset = data & mask; - offsets[i - 1] = offset; - data >>= CLIB_CUCKOO_LOG2_KVP_PER_BUCKET; - } - buckets[0] = path->start; - for (i = 1; i < path->length; ++i) - { - CVT (clib_cuckoo_bucket) * b = - CV (clib_cuckoo_bucket_at_index) (h, buckets[i - 1]); - buckets[i] = - clib_cuckoo_get_other_bucket (CV (clib_cuckoo_get_nbuckets) (h), - buckets[i - 1], - b->reduced_hashes[offsets[i - 1]]); - } -} - -#if CLIB_CUCKOO_DEBUG && CLIB_CUCKOO_DEBUG_PATH -static u8 *CV (format_cuckoo_path) (u8 * s, va_list * args) -{ - CVT (clib_cuckoo) * h = va_arg (*args, CVT (clib_cuckoo) *); - uword path_idx = va_arg (*args, uword); - clib_cuckoo_path_t *p = pool_elt_at_index (h->paths, path_idx); - uword buckets[CLIB_CUCKOO_BFS_MAX_PATH_LENGTH]; - uword offsets[CLIB_CUCKOO_BFS_MAX_PATH_LENGTH]; - clib_cuckoo_path_walk (h, path_idx, buckets, offsets); - s = format (s, "length %u: ", p->length); - for (uword i = p->length - 1; i > 0; --i) - { - s = format (s, "%wu[%wu]->", buckets[i], offsets[i]); - } - if (p->length) - { - s = format (s, "%wu[%wu]", buckets[0], offsets[0]); - } - return s; -} -#endif - -/* - * perform breadth-first search in the cuckoo hash, finding the closest - * empty slot, i.e. one which requires minimum swaps to move it - * to one of the buckets provided - */ -static int CV (clib_cuckoo_find_empty_slot_bfs) (CVT (clib_cuckoo) * h, - clib_cuckoo_lookup_info_t * - lookup, uword * path_idx_out, - uword * found_bucket, - CVT (clib_cuckoo_kv) * - *found_elt) -{ - uword *tail; - ASSERT (!vec_len (h->bfs_search_queue)); - clib_cuckoo_path_t *tmp; - pool_flush (tmp, h->paths,); - int rv = CLIB_CUCKOO_ERROR_AGAIN; - int counter = 0; - /* start by creating paths starting in each of the buckets ... */ - vec_add2 (h->bfs_search_queue, tail, CLIB_CUCKOO_KVP_PER_BUCKET); - int i; - for (i = 0; i < CLIB_CUCKOO_KVP_PER_BUCKET; ++i) - { - clib_cuckoo_path_t *path = - CV (clib_cuckoo_path_begin) (h, lookup->bucket1, i); - tail[i] = path - h->paths; - } - if (lookup->bucket1 != lookup->bucket2) - { - vec_add2 (h->bfs_search_queue, tail, CLIB_CUCKOO_KVP_PER_BUCKET); - for (i = 0; i < CLIB_CUCKOO_KVP_PER_BUCKET; ++i) - { - clib_cuckoo_path_t *path = - CV (clib_cuckoo_path_begin) (h, lookup->bucket2, i); - tail[i] = path - h->paths; - } - } - while (1) - { - if (counter >= CLIB_CUCKOO_BFS_MAX_STEPS) - { -#if CLIB_CUCKOO_DEBUG_COUNTERS - ++h->steps_exceeded; -#endif - break; - } - if (counter >= vec_len (h->bfs_search_queue)) - { -#if CLIB_CUCKOO_DEBUG_COUNTERS - ++h->bfs_queue_emptied; -#endif - break; - } - const uword path_idx = vec_elt (h->bfs_search_queue, counter); - const clib_cuckoo_path_t *path = pool_elt_at_index (h->paths, path_idx); -#if CLIB_CUCKOO_DEBUG_PATH - CLIB_CUCKOO_DBG ("Examine path @%wu: %U", path_idx, - CV (format_cuckoo_path), h, path_idx); -#endif - /* TODO prefetch ? */ - /* search the alternative bucket for free space */ - int offset = CV (clib_cuckoo_path_peek_offset) (path); - CVT (clib_cuckoo_bucket) * bucket = - CV (clib_cuckoo_bucket_at_index) (h, path->bucket); - uword other_bucket = - clib_cuckoo_get_other_bucket (CV (clib_cuckoo_get_nbuckets) (h), - path->bucket, - bucket->reduced_hashes[offset]); - CLIB_CUCKOO_DBG - ("Path ends in bucket %wu, offset #%wu, other bucket is %wu", - path->bucket, CV (clib_cuckoo_path_peek_offset) (path), - other_bucket); - if (path->bucket != other_bucket) - { - if ((*found_elt = - CV (clib_cuckoo_bucket_find_empty) (CV - (clib_cuckoo_bucket_at_index) - (h, other_bucket)))) - { - /* found empty element */ - *found_bucket = other_bucket; - *path_idx_out = path_idx; - rv = CLIB_CUCKOO_ERROR_SUCCESS; -#if CLIB_CUCKOO_DEBUG_PATH - CLIB_CUCKOO_DBG ("Bucket with empty slot:\n%U", - CV (format_cuckoo_bucket), - CV (clib_cuckoo_bucket_at_index) (h, - other_bucket)); -#endif - goto out; - } - /* extend the current path with possible next buckets and add to - * queue */ - if (path->length < CLIB_CUCKOO_BFS_MAX_PATH_LENGTH && - vec_len (h->bfs_search_queue) < CLIB_CUCKOO_BFS_MAX_STEPS) - { - uword *tail; - vec_add2 (h->bfs_search_queue, tail, - CLIB_CUCKOO_KVP_PER_BUCKET); - for (i = 0; i < CLIB_CUCKOO_KVP_PER_BUCKET; ++i) - { - uword new_path_idx = - CV (clib_cuckoo_path_extend) (h, path_idx, other_bucket, - i); - tail[i] = new_path_idx; - } - } - } - else - { - CLIB_CUCKOO_DBG ("Discard path @%wu, loop detected", path_idx); - } - /* done with this path - put back to pool for later reuse */ - CV (clib_cuckoo_path_put) (h, path_idx); - ++counter; - } -out: - vec_reset_length (h->bfs_search_queue); - return rv; -} - -static void CV (clib_cuckoo_swap_elts_in_bucket) (CVT (clib_cuckoo_bucket) * - b, uword e1, uword e2) -{ - CVT (clib_cuckoo_kv) kv; - clib_memcpy (&kv, b->elts + e1, sizeof (kv)); - clib_memcpy (b->elts + e1, b->elts + e2, sizeof (kv)); - clib_memcpy (b->elts + e2, &kv, sizeof (kv)); - u8 reduced_hash = b->reduced_hashes[e1]; - b->reduced_hashes[e1] = b->reduced_hashes[e2]; - b->reduced_hashes[e2] = reduced_hash; -} - -static void CV (clib_cuckoo_bucket_tidy) (CVT (clib_cuckoo_bucket) * b) -{ - int i = 0; - int j = CLIB_CUCKOO_KVP_PER_BUCKET - 1; - while (i != j) - { - int min_free = i; - int max_used = j; - while (!CV (clib_cuckoo_kv_is_free) (&b->elts[min_free])) - { - ++min_free; - } - while (CV (clib_cuckoo_kv_is_free) (&b->elts[max_used])) - { - --max_used; - } - if (min_free < max_used) - { - CV (clib_cuckoo_swap_elts_in_bucket) (b, min_free, max_used); - i = min_free + 1; - j = max_used - 1; - } - else - { - break; - } - } -} - -static void CV (clib_cuckoo_free_locked_elt) (CVT (clib_cuckoo_kv) * elt) -{ - /* - * FIXME - improve performance by getting rid of this clib_memset - make all - * functions in this file not rely on clib_cuckoo_kv_is_free but instead - * take use_count into account */ - clib_memset (elt, 0xff, sizeof (*elt)); -} - -static void CV (clib_cuckoo_free_elt_in_bucket) (CVT (clib_cuckoo_bucket) * b, - CVT (clib_cuckoo_kv) * elt) -{ - clib_cuckoo_bucket_aux_t aux = - CV (clib_cuckoo_bucket_version_bump_and_lock) (b); - int use_count = clib_cuckoo_bucket_aux_get_use_count (aux); - int offset = elt - b->elts; - ASSERT (offset < use_count); - CV (clib_cuckoo_free_locked_elt) (elt); - if (offset != use_count - 1) - { - CV (clib_cuckoo_bucket_tidy) (b); - } - aux = clib_cuckoo_bucket_aux_set_use_count (aux, use_count - 1); - CV (clib_cuckoo_bucket_unlock) (b, aux); -} - -static void CV (clib_cuckoo_set_locked_elt) (CVT (clib_cuckoo_bucket) * b, - CVT (clib_cuckoo_kv) * elt, - CVT (clib_cuckoo_kv) * kvp, - u8 reduced_hash) -{ - int offset = CV (clib_cuckoo_elt_in_bucket_to_offset) (b, elt); - clib_memcpy (elt, kvp, sizeof (*elt)); - b->reduced_hashes[offset] = reduced_hash; - CLIB_CUCKOO_DBG ("Set bucket %p, offset %d, %U", b, offset, - CV (format_cuckoo_elt), elt, b->reduced_hashes[offset]); -} - -static void CV (clib_cuckoo_set_elt) (CVT (clib_cuckoo_bucket) * b, - CVT (clib_cuckoo_kv) * elt, - CVT (clib_cuckoo_kv) * kvp, - u8 reduced_hash) -{ - clib_cuckoo_bucket_aux_t aux = - CV (clib_cuckoo_bucket_version_bump_and_lock) (b); - CV (clib_cuckoo_set_locked_elt) (b, elt, kvp, reduced_hash); - CV (clib_cuckoo_bucket_unlock) (b, aux); -} - -static int CV (clib_cuckoo_add_slow) (CVT (clib_cuckoo) * h, - CVT (clib_cuckoo_kv) * kvp, - clib_cuckoo_lookup_info_t * lookup, - u8 reduced_hash) -{ - uword path_idx; - uword empty_bucket_idx; - CVT (clib_cuckoo_kv) * empty_elt; - int rv = CV (clib_cuckoo_find_empty_slot_bfs) (h, lookup, &path_idx, - &empty_bucket_idx, - &empty_elt); - if (CLIB_CUCKOO_ERROR_SUCCESS == rv) - { - uword buckets[CLIB_CUCKOO_BFS_MAX_PATH_LENGTH]; - uword offsets[CLIB_CUCKOO_BFS_MAX_PATH_LENGTH]; - clib_cuckoo_path_walk (h, path_idx, buckets, offsets); - /* - * walk back the path, moving the free element forward to one of our - * buckets ... - */ - clib_cuckoo_path_t *path = pool_elt_at_index (h->paths, path_idx); - CVT (clib_cuckoo_bucket) * empty_bucket = - CV (clib_cuckoo_bucket_at_index) (h, empty_bucket_idx); - int i; - for (i = path->length - 1; i >= 0; --i) - { - /* copy the key-value in path to the bucket with empty element */ - CVT (clib_cuckoo_bucket) * b = - CV (clib_cuckoo_bucket_at_index) (h, buckets[i]); - CVT (clib_cuckoo_kv) * elt = b->elts + offsets[i]; - clib_cuckoo_bucket_aux_t empty_aux = - CV (clib_cuckoo_bucket_version_bump_and_lock) (empty_bucket); - CV (clib_cuckoo_set_locked_elt) - (empty_bucket, empty_elt, elt, b->reduced_hashes[elt - b->elts]); - if (i == path->length - 1) - { - /* we only need to increase the use count for the bucket with - * free element - all other buckets' use counts won't change */ - empty_aux = clib_cuckoo_bucket_aux_set_use_count (empty_aux, - clib_cuckoo_bucket_aux_get_use_count - (empty_aux) + - 1); - } - CV (clib_cuckoo_bucket_unlock) (empty_bucket, empty_aux); - /* - * the element now exists in both places - in the previously empty - * element and in its original bucket - we can now safely overwrite - * the element in the original bucket with previous element in path - * without loosing data (and we don't need to modify the use count) - */ - empty_bucket = b; - empty_elt = elt; - } - /* now we have a place to put the kvp in ... */ - CV (clib_cuckoo_set_elt) (empty_bucket, empty_elt, kvp, reduced_hash); - CLIB_CUCKOO_DBG ("Slow insert success, bucket: %p\n%U", empty_bucket, - CV (format_cuckoo_bucket), empty_bucket); -#if CLIB_CUCKOO_DEBUG_COUNTERS - ++h->slow_adds; -#endif - } - return rv; -} - -static int CV (clib_cuckoo_add_fast) (CVT (clib_cuckoo) * h, - clib_cuckoo_lookup_info_t * lookup, - CVT (clib_cuckoo_kv) * kvp, - u8 reduced_hash) -{ - CVT (clib_cuckoo_kv) * elt; - CVT (clib_cuckoo_bucket) * bucket1 = - CV (clib_cuckoo_bucket_at_index) (h, lookup->bucket1); - if ((elt = CV (clib_cuckoo_bucket_find_empty) (bucket1))) - { - clib_cuckoo_bucket_aux_t aux = - CV (clib_cuckoo_bucket_version_bump_and_lock) (bucket1); - CV (clib_cuckoo_set_locked_elt) (bucket1, elt, kvp, reduced_hash); - aux = - clib_cuckoo_bucket_aux_set_use_count (aux, - clib_cuckoo_bucket_aux_get_use_count - (aux) + 1); - CV (clib_cuckoo_bucket_unlock) (bucket1, aux); -#if CLIB_CUCKOO_DEBUG_COUNTERS - ++h->fast_adds; -#endif - return CLIB_CUCKOO_ERROR_SUCCESS; - } - CVT (clib_cuckoo_bucket) * bucket2 = - CV (clib_cuckoo_bucket_at_index) (h, lookup->bucket2); - if ((elt = - CV (clib_cuckoo_bucket_find_empty) (CV (clib_cuckoo_bucket_at_index) - (h, lookup->bucket2)))) - { - clib_cuckoo_bucket_aux_t aux = - CV (clib_cuckoo_bucket_version_bump_and_lock) (bucket2); - CV (clib_cuckoo_set_locked_elt) (bucket2, elt, kvp, reduced_hash); - aux = - clib_cuckoo_bucket_aux_set_use_count (aux, - clib_cuckoo_bucket_aux_get_use_count - (aux) + 1); - CV (clib_cuckoo_bucket_unlock) (bucket2, aux); -#if CLIB_CUCKOO_DEBUG_COUNTERS - ++h->fast_adds; -#endif - return CLIB_CUCKOO_ERROR_SUCCESS; - } - return CLIB_CUCKOO_ERROR_AGAIN; -} - -/** - * perform garbage collection - * - * this function assumes there is no other thread touching the cuckoo hash, - * not even a reader, it's meant to be called from main thread - * in a stop-the-world situation - */ -void CV (clib_cuckoo_garbage_collect) (CVT (clib_cuckoo) * h) -{ - CLIB_MEMORY_BARRIER (); - CVT (clib_cuckoo_bucket) * *b; - /* *INDENT-OFF* */ - vec_foreach (b, h->to_be_freed) - { - if (*b == h->buckets) - { - continue; - } -#if CLIB_CUCKOO_DEBUG_GC - fformat (stdout, "gc: free %p\n", *b); -#endif - vec_free (*b); - } - /* *INDENT-ON* */ - vec_free (h->to_be_freed); - CLIB_MEMORY_BARRIER (); -} - -/** - * expand and rehash a cuckoo hash - * - * 1. double the size of the hash table - * 2. move items to new locations derived from the new size - */ -static void CV (clib_cuckoo_rehash) (CVT (clib_cuckoo) * h) -{ - CVT (clib_cuckoo_bucket) * old = h->buckets; - uword old_nbuckets = vec_len (old); - uword new_nbuckets = 2 * old_nbuckets; - CVT (clib_cuckoo_bucket) * new = - vec_dup_aligned (old, CLIB_CACHE_LINE_BYTES); - /* allocate space */ - vec_validate_aligned (new, new_nbuckets - 1, CLIB_CACHE_LINE_BYTES); - ASSERT (new_nbuckets == vec_len (new)); - /* store old pointer in to-be-freed list */ - vec_add1 (h->to_be_freed, old); - /* mark new elements as free */ - CVT (clib_cuckoo_bucket) * bucket; - for (bucket = new + old_nbuckets; bucket < vec_end (new); ++bucket) - { - clib_memset (bucket->elts, 0xff, sizeof (bucket->elts)); - } - /* - * this for loop manipulates the new (unseen) memory, so no locks - * are required here - */ - uword old_bucket_idx; - for (old_bucket_idx = 0; old_bucket_idx < old_nbuckets; ++old_bucket_idx) - { - /* items in old bucket might be moved to new bucket */ - uword new_bucket_idx = old_bucket_idx + old_nbuckets; - CVT (clib_cuckoo_bucket) * old_bucket = new + old_bucket_idx; - CVT (clib_cuckoo_bucket) * new_bucket = new + new_bucket_idx; - int i = 0; - int moved = 0; - clib_cuckoo_bucket_aux_t aux = old_bucket->aux; - for (i = 0; i < clib_cuckoo_bucket_aux_get_use_count (aux); ++i) - { - CVT (clib_cuckoo_kv) * elt = old_bucket->elts + i; - u64 hash = CV (clib_cuckoo_hash) (elt); - clib_cuckoo_lookup_info_t old_lookup = - CV (clib_cuckoo_calc_lookup) (old, hash); - clib_cuckoo_lookup_info_t new_lookup = - CV (clib_cuckoo_calc_lookup) (new, hash); - if ((old_bucket_idx == old_lookup.bucket1 && - new_bucket_idx == new_lookup.bucket1) || - (old_bucket_idx == old_lookup.bucket2 && - new_bucket_idx == new_lookup.bucket2)) - { - /* move the item to new bucket */ - CVT (clib_cuckoo_kv) * empty_elt = new_bucket->elts + moved; - ASSERT (empty_elt); - CV (clib_cuckoo_set_locked_elt) - (new_bucket, empty_elt, elt, old_bucket->reduced_hashes[i]); - CV (clib_cuckoo_free_locked_elt) (elt); - ++moved; - } - } - if (moved) - { - CV (clib_cuckoo_bucket_tidy) (old_bucket); - aux = - clib_cuckoo_bucket_aux_set_use_count (aux, - clib_cuckoo_bucket_aux_get_use_count - (aux) - moved); - old_bucket->aux = aux; - aux = new_bucket->aux; - aux = - clib_cuckoo_bucket_aux_set_use_count (aux, - clib_cuckoo_bucket_aux_get_use_count - (aux) + moved); - new_bucket->aux = aux; - } - } - h->buckets = new; -#if CLIB_CUCKOO_DEBUG_COUNTERS - ++h->rehashes; -#endif - h->garbage_callback (h, h->garbage_ctx); -} - -static int CV (clib_cuckoo_bucket_search_internal) (CVT (clib_cuckoo) * h, - uword bucket, - CVT (clib_cuckoo_kv) * - kvp, - CVT (clib_cuckoo_kv) * - *found) -{ - CVT (clib_cuckoo_bucket) * b = CV (clib_cuckoo_bucket_at_index) (h, bucket); - int i; - /* *INDENT-OFF* */ - clib_cuckoo_bucket_foreach_idx_unrolled (i, { - CVT (clib_cuckoo_kv) *elt = &b->elts[i]; - if (CV (clib_cuckoo_key_compare) (elt->key, kvp->key)) - { - *found = elt; - return CLIB_CUCKOO_ERROR_SUCCESS; - } - }); - /* *INDENT-ON* */ - return CLIB_CUCKOO_ERROR_NOT_FOUND; -} - -int CV (clib_cuckoo_add_del) (CVT (clib_cuckoo) * h, - CVT (clib_cuckoo_kv) * kvp, int is_add, - int dont_overwrite) -{ - CLIB_CUCKOO_DBG ("%s %U", is_add ? "Add" : "Del", CV (format_cuckoo_kvp), - kvp); - clib_cuckoo_lookup_info_t lookup; - u64 hash = CV (clib_cuckoo_hash) (kvp); - u8 reduced_hash = clib_cuckoo_reduce_hash (hash); - clib_spinlock_lock (&h->writer_lock); -restart: - lookup = CV (clib_cuckoo_calc_lookup) (h->buckets, hash); - CVT (clib_cuckoo_bucket) * b = - CV (clib_cuckoo_bucket_at_index) (h, lookup.bucket1); - CVT (clib_cuckoo_kv) * found; - int rv = - CV (clib_cuckoo_bucket_search_internal) (h, lookup.bucket1, kvp, &found); - if (CLIB_CUCKOO_ERROR_SUCCESS != rv) - { - ASSERT (CLIB_CUCKOO_ERROR_NOT_FOUND == rv); - b = CV (clib_cuckoo_bucket_at_index) (h, lookup.bucket2); - rv = CV (clib_cuckoo_bucket_search_internal) (h, lookup.bucket2, kvp, - &found); - } - if (CLIB_CUCKOO_ERROR_SUCCESS == rv) - { - if (is_add) - { - if (dont_overwrite) - { - CLIB_CUCKOO_DBG ("Refused replacing existing %U", - CV (format_cuckoo_elt), found, - b->reduced_hashes[found - b->elts]); - rv = CLIB_CUCKOO_ERROR_AGAIN; - } - else - { - /* prevent readers reading this bucket while we switch the values */ - clib_cuckoo_bucket_aux_t aux = - CV (clib_cuckoo_bucket_version_bump_and_lock) (b); - clib_memcpy (&found->value, &kvp->value, sizeof (found->value)); - CLIB_CUCKOO_DBG ("Replaced existing %U", CV (format_cuckoo_elt), - found, b->reduced_hashes[found - b->elts]); - CV (clib_cuckoo_bucket_unlock) (b, aux); - rv = CLIB_CUCKOO_ERROR_SUCCESS; - } - } - else - { - CV (clib_cuckoo_free_elt_in_bucket) (b, found); - rv = CLIB_CUCKOO_ERROR_SUCCESS; - } - CLIB_CUCKOO_DEEP_SELF_CHECK (h); - goto unlock; - } - if (!is_add) - { - CLIB_CUCKOO_DBG ("%U not present in table", CV (format_cuckoo_kvp), - kvp); - rv = CLIB_CUCKOO_ERROR_NOT_FOUND; - goto unlock; - } - /* from this point on, it's add code only */ - ASSERT (CLIB_CUCKOO_ERROR_NOT_FOUND == rv); - /* fast path: try to search for unoccupied slot in one of the buckets */ - rv = CV (clib_cuckoo_add_fast) (h, &lookup, kvp, reduced_hash); - CLIB_CUCKOO_DEEP_SELF_CHECK (h); - if (CLIB_CUCKOO_ERROR_SUCCESS != rv) - { - CLIB_CUCKOO_DBG - ("Fast insert failed, bucket 1: %wu, bucket 2: %wu\n%U%U", - lookup.bucket1, lookup.bucket2, CV (format_cuckoo_bucket), - CV (clib_cuckoo_bucket_at_index) (h, lookup.bucket1), - CV (format_cuckoo_bucket), - CV (clib_cuckoo_bucket_at_index) (h, lookup.bucket2)); - /* slow path */ - rv = CV (clib_cuckoo_add_slow) (h, kvp, &lookup, reduced_hash); - CLIB_CUCKOO_DEEP_SELF_CHECK (h); - if (CLIB_CUCKOO_ERROR_SUCCESS != rv) - { - CLIB_CUCKOO_DBG ("Slow insert failed, rehash required:\n%U", - CV (format_cuckoo), h, 1); - /* ultra slow path */ - CV (clib_cuckoo_rehash) (h); - CLIB_CUCKOO_DEEP_SELF_CHECK (h); - CLIB_CUCKOO_DBG ("Restarting add after rehash..."); - goto restart; - } - } -unlock: - clib_spinlock_unlock (&h->writer_lock); - return rv; -} - -u8 *CV (format_cuckoo) (u8 * s, va_list * args) -{ - CVT (clib_cuckoo) * h = va_arg (*args, CVT (clib_cuckoo) *); - int verbose = va_arg (*args, int); - - s = format (s, "Hash table %s\n", h->name ? h->name : "(unnamed)"); - - uword free = 0; - uword used = 0; - uword use_count_total = 0; - float load_factor; - CVT (clib_cuckoo_bucket) * b; - /* *INDENT-OFF* */ - clib_cuckoo_foreach_bucket (b, h, { - if (verbose) - { - s = format (s, "%U", CV (format_cuckoo_bucket), b); - } - int i; - clib_cuckoo_bucket_foreach_idx (i) - { - CVT (clib_cuckoo_kv) *elt = &b->elts[i]; - if (CV (clib_cuckoo_kv_is_free) (elt)) - { - ++free; - } - else - { - ++used; - } - } - clib_cuckoo_bucket_aux_t aux = b->aux; - use_count_total += clib_cuckoo_bucket_aux_get_use_count (aux); - }); - /* *INDENT-ON* */ - s = format (s, "Used slots: %wu\n", used); - s = format (s, "Use count total: %wu\n", use_count_total); - s = format (s, "Free slots: %wu\n", free); - if (free + used != 0) - load_factor = ((float) used) / ((float) (free + used)); - else - load_factor = 0.0; - s = format (s, "Load factor: %.2f\n", load_factor); -#if CLIB_CUCKOO_DEBUG_COUNTERS - s = format (s, "BFS attempts limited by max steps: %lld\n", - h->steps_exceeded); - s = format (s, "BFS cutoffs due to empty queue: %lld\n", - h->bfs_queue_emptied); - s = format (s, "Fast adds: %lld\n", h->fast_adds); - s = format (s, "Slow adds: %lld\n", h->slow_adds); - s = format (s, "Rehashes: %lld\n", h->rehashes); -#endif - return s; -} - -float CV (clib_cuckoo_calculate_load_factor) (CVT (clib_cuckoo) * h) -{ - uword nonfree = 0; - uword all = 0; - CVT (clib_cuckoo_bucket) * bucket; - /* *INDENT-OFF* */ - clib_cuckoo_foreach_bucket (bucket, h, { - int i; - clib_cuckoo_bucket_foreach_idx (i) - { - CVT (clib_cuckoo_kv) *elt = bucket->elts + i; - ++all; - if (!CV (clib_cuckoo_kv_is_free) (elt)) - { - ++nonfree; - } - } - }); - /* *INDENT-ON* */ - if (all) - return (float) nonfree / (float) all; - else - return 0.0; -} - -/** @endcond */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/cuckoo_template.h b/src/vppinfra/cuckoo_template.h deleted file mode 100644 index 364c2919d96..00000000000 --- a/src/vppinfra/cuckoo_template.h +++ /dev/null @@ -1,460 +0,0 @@ -/* - Copyright (c) 2017 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. -*/ - -/* - * cuckoo hash implementation based on paper - * 'Algorithmic Improvements for Fast Concurrent Cuckoo Hashing' - * by Xiaozhou Li, David G. Andersen, Michael Kaminsky, Michael J. Freedman - * and their libcuckoo implementation (https://github.com/efficient/libcuckoo) - */ - -/* - * Note: to instantiate the template multiple times in a single file, - * #undef __included_cuckoo_template_h__... - */ -#ifndef __included_cuckoo_template_h__ -#define __included_cuckoo_template_h__ - -#include <vppinfra/heap.h> -#include <vppinfra/format.h> -#include <vppinfra/pool.h> -#include <vppinfra/lock.h> -#include <vppinfra/error.h> -#include <vppinfra/hash.h> -#include <vppinfra/cache.h> - -#ifndef CLIB_CUCKOO_TYPE -#error CLIB_CUCKOO_TYPE not defined -#endif - -#ifndef CLIB_CUCKOO_BFS_MAX_STEPS -#error CLIB_CUCKOO_BFS_MAX_STEPS not defined -#endif - -#ifndef CLIB_CUCKOO_KVP_PER_BUCKET -#error CLIB_CUCKOO_KVP_PER_BUCKET not defined -#endif - -#ifndef CLIB_CUCKOO_LOG2_KVP_PER_BUCKET -#error CLIB_CUCKOO_LOG2_KVP_PER_BUCKET not defined -#endif - -#ifndef CLIB_CUCKOO_BFS_MAX_PATH_LENGTH -#error CLIB_CUCKOO_BFS_MAX_PATH_LENGTH not defined -#endif - -STATIC_ASSERT (CLIB_CUCKOO_KVP_PER_BUCKET == - (1 << CLIB_CUCKOO_LOG2_KVP_PER_BUCKET), - "CLIB_CUCKOO_KVP_PER_BUCKET != (1 << CLIB_CUCKOO_LOG2_KVP_PER_BUCKET"); - -#define _cv(a, b) a##b -#define __cv(a, b) _cv (a, b) -#define CV(a) __cv (a, CLIB_CUCKOO_TYPE) - -#define _cvt(a, b) a##b##_t -#define __cvt(a, b) _cvt (a, b) -#define CVT(a) __cvt (a, CLIB_CUCKOO_TYPE) - -typedef u64 clib_cuckoo_bucket_aux_t; - -#define CLIB_CUCKOO_USE_COUNT_BIT_WIDTH (1 + CLIB_CUCKOO_LOG2_KVP_PER_BUCKET) - -always_inline u64 -clib_cuckoo_bucket_aux_get_version (clib_cuckoo_bucket_aux_t aux) -{ - return aux >> (1 + CLIB_CUCKOO_USE_COUNT_BIT_WIDTH); -} - -always_inline int -clib_cuckoo_bucket_aux_get_use_count (clib_cuckoo_bucket_aux_t aux) -{ - u64 use_count_mask = (1 << CLIB_CUCKOO_USE_COUNT_BIT_WIDTH) - 1; - return (aux >> 1) & use_count_mask; -} - -always_inline int -clib_cuckoo_bucket_aux_get_writer_flag (clib_cuckoo_bucket_aux_t aux) -{ - return aux & 1; -} - -always_inline clib_cuckoo_bucket_aux_t -clib_cuckoo_bucket_aux_pack (u64 version, int use_count, int writer_flag) -{ - return (version << (1 + CLIB_CUCKOO_USE_COUNT_BIT_WIDTH)) + - (use_count << 1) + writer_flag; -} - -always_inline clib_cuckoo_bucket_aux_t -clib_cuckoo_bucket_aux_set_version (clib_cuckoo_bucket_aux_t aux, u64 version) -{ - int use_count = clib_cuckoo_bucket_aux_get_use_count (aux); - int writer_flag = clib_cuckoo_bucket_aux_get_writer_flag (aux); - return clib_cuckoo_bucket_aux_pack (version, use_count, writer_flag); -} - -always_inline clib_cuckoo_bucket_aux_t -clib_cuckoo_bucket_aux_set_use_count (clib_cuckoo_bucket_aux_t aux, - int use_count) -{ - u64 version = clib_cuckoo_bucket_aux_get_version (aux); - int writer_flag = clib_cuckoo_bucket_aux_get_writer_flag (aux); - return clib_cuckoo_bucket_aux_pack (version, use_count, writer_flag); -} - -always_inline clib_cuckoo_bucket_aux_t -clib_cuckoo_bucket_aux_set_writer_flag (clib_cuckoo_bucket_aux_t aux, - int writer_flag) -{ - u64 version = clib_cuckoo_bucket_aux_get_version (aux); - int use_count = clib_cuckoo_bucket_aux_get_use_count (aux); - return clib_cuckoo_bucket_aux_pack (version, use_count, writer_flag); -} - -#define PATH_BITS_REQ \ - (CLIB_CUCKOO_BFS_MAX_PATH_LENGTH * CLIB_CUCKOO_LOG2_KVP_PER_BUCKET) - -#if PATH_BITS_REQ <= 8 -typedef u8 path_data_t; -#elif PATH_BITS_REQ <= 16 -typedef u16 path_data_t; -#elif PATH_BITS_REQ <= 32 -typedef u32 path_data_t; -#elif PATH_BITS_REQ <= 64 -typedef u64 path_data_t; -#else -#error no suitable datatype for path storage... -#endif - -typedef struct -{ - /** bucket where this path begins */ - u64 start; - /** bucket at end of path */ - u64 bucket; - /** length of the path */ - u8 length; - /** holds compressed offsets in buckets along path */ - path_data_t data; -} clib_cuckoo_path_t; - -typedef struct -{ - CLIB_CACHE_LINE_ALIGN_MARK (cacheline0); - - /** reduced hashes corresponding to elements */ - u8 reduced_hashes[CLIB_CUCKOO_KVP_PER_BUCKET]; - - /** auxiliary data - version, writer flag and used count */ - volatile clib_cuckoo_bucket_aux_t aux; - - /** cuckoo elements in this bucket */ - CVT (clib_cuckoo_kv) elts[CLIB_CUCKOO_KVP_PER_BUCKET]; -} CVT (clib_cuckoo_bucket); - -#define clib_cuckoo_bucket_foreach_idx(var) \ - for (var = 0; var < CLIB_CUCKOO_KVP_PER_BUCKET; var++) - -#if CLIB_CUCKOO_OPTIMIZE_UNROLL -#if CLIB_CUCKOO_KVP_PER_BUCKET == 2 -#define clib_cuckoo_bucket_foreach_idx_unrolled(var, body) \ - do \ - { \ - var = 0; \ - body; \ - var = 1; \ - body; \ - } \ - while (0); -#elif CLIB_CUCKOO_KVP_PER_BUCKET == 4 -#define clib_cuckoo_bucket_foreach_idx_unrolled(var, body) \ - do \ - { \ - var = 0; \ - body; \ - var = 1; \ - body; \ - var = 2; \ - body; \ - var = 3; \ - body; \ - } \ - while (0); -#elif CLIB_CUCKOO_KVP_PER_BUCKET == 8 -#define clib_cuckoo_bucket_foreach_idx_unrolled(var, body) \ - do \ - { \ - var = 0; \ - body; \ - var = 1; \ - body; \ - var = 2; \ - body; \ - var = 3; \ - body; \ - var = 4; \ - body; \ - var = 5; \ - body; \ - var = 6; \ - body; \ - var = 7; \ - body; \ - } \ - while (0); -#else -#define clib_cuckoo_bucket_foreach_idx_unrolled(var, body) \ - clib_cuckoo_bucket_foreach_idx (var) \ - { \ - body; \ - } -#endif -#else /* CLIB_CUCKOO_OPTIMIZE_UNROLL */ -#define clib_cuckoo_bucket_foreach_idx_unrolled(var, body) \ - clib_cuckoo_bucket_foreach_idx (var) \ - { \ - body; \ - } -#endif /* CLIB_CUCKOO_OPTIMIZE_UNROLL */ - -#define clib_cuckoo_bucket_foreach_elt_index(var, bucket) \ - for (var = 0; var < CLIB_CUCKOO_KVP_PER_BUCKET; ++i) - -#define clib_cuckoo_foreach_bucket(var, h, body) \ - do \ - { \ - CVT (clib_cuckoo_bucket) *__buckets = h->buckets; \ - vec_foreach (var, __buckets) \ - { \ - body; \ - } \ - } \ - while (0) - -typedef struct CV (clib_cuckoo) -{ - /** vector of elements containing key-value pairs and auxiliary data */ - CVT (clib_cuckoo_bucket) * volatile buckets; - - /** garbage to be freed once its safe to do so .. */ - CVT (clib_cuckoo_bucket) * *to_be_freed; - - /** hash table name */ - const char *name; - - /** pool of cuckoo paths (reused when doing bfd search) */ - clib_cuckoo_path_t *paths; - - /** - * vector used as queue when doing cuckoo path searches - holds offsets - * in paths pool - */ - uword *bfs_search_queue; - - /** - * writer lock - whether this lock is taken or not has zero effect on - * readers - */ - clib_spinlock_t writer_lock; - - /** caller context passed to callback with garbage notification */ - void *garbage_ctx; - - /** - * garbage notify function - called when some garbage needs to be collected - * in main thread while other threads are stopped - */ - void (*garbage_callback) (struct CV (clib_cuckoo) * h, void *garbage_ctx); - -#if CLIB_CUCKOO_DEBUG_COUNTERS - u64 steps_exceeded; - u64 bfs_queue_emptied; - u64 fast_adds; - u64 slow_adds; - u64 rehashes; -#endif - -} CVT (clib_cuckoo); - -void CV (clib_cuckoo_init) (CVT (clib_cuckoo) * h, const char *name, - uword nbuckets, - void (*garbage_callback) (CVT (clib_cuckoo) *, - void *), - void *garbage_ctx); - -void CV (clib_cuckoo_garbage_collect) (CVT (clib_cuckoo) * h); - -void CV (clib_cuckoo_free) (CVT (clib_cuckoo) * h); - -int CV (clib_cuckoo_add_del) (CVT (clib_cuckoo) * h, - CVT (clib_cuckoo_kv) * add_v, int is_add, - int dont_overwrite); -int CV (clib_cuckoo_search) (CVT (clib_cuckoo) * h, - CVT (clib_cuckoo_kv) * search_v, - CVT (clib_cuckoo_kv) * return_v); - -void CV (clib_cuckoo_foreach_key_value_pair) (CVT (clib_cuckoo) * h, - void *callback, void *arg); - -float CV (clib_cuckoo_calc_load) (CVT (clib_cuckoo) * h); - -format_function_t CV (format_cuckoo); -format_function_t CV (format_cuckoo_kvp); - -always_inline u8 -clib_cuckoo_reduce_hash (u64 hash) -{ - u32 v32 = ((u32) hash) ^ ((u32) (hash >> 32)); - u16 v16 = ((u16) v32) ^ ((u16) (v32 >> 16)); - u8 v8 = ((u8) v16) ^ ((u8) (v16 >> 8)); - return v8; -} - -always_inline u64 -clib_cuckoo_get_other_bucket (u64 nbuckets, u64 bucket, u8 reduced_hash) -{ - u64 mask = (nbuckets - 1); - return (bucket ^ ((reduced_hash + 1) * 0xc6a4a7935bd1e995)) & mask; -} - -always_inline clib_cuckoo_lookup_info_t -CV (clib_cuckoo_calc_lookup) (CVT (clib_cuckoo_bucket) * buckets, u64 hash) -{ - clib_cuckoo_lookup_info_t lookup; - u64 nbuckets = vec_len (buckets); - u64 mask = (nbuckets - 1); - lookup.bucket1 = hash & mask; -#if CLIB_CUCKOO_OPTIMIZE_PREFETCH - CLIB_PREFETCH (vec_elt_at_index (buckets, lookup.bucket1), - sizeof (*buckets), LOAD); -#endif - u8 reduced_hash = clib_cuckoo_reduce_hash (hash); - lookup.bucket2 = - clib_cuckoo_get_other_bucket (nbuckets, lookup.bucket1, reduced_hash); -#if CLIB_CUCKOO_OPTIMIZE_PREFETCH - CLIB_PREFETCH (vec_elt_at_index (buckets, lookup.bucket2), - sizeof (*buckets), LOAD); -#endif - lookup.reduced_hash = reduced_hash; - ASSERT (lookup.bucket1 < nbuckets); - ASSERT (lookup.bucket2 < nbuckets); - return lookup; -} - -/** - * search for key within bucket - */ -always_inline int CV (clib_cuckoo_bucket_search) (CVT (clib_cuckoo_bucket) * - b, - CVT (clib_cuckoo_kv) * kvp, - u8 reduced_hash) -{ - clib_cuckoo_bucket_aux_t bucket_aux; - u8 writer_flag; - do - { - bucket_aux = b->aux; - writer_flag = clib_cuckoo_bucket_aux_get_writer_flag (bucket_aux); - } - while (PREDICT_FALSE (writer_flag)); /* loop while writer flag is set */ - - int i; -#if CLIB_CUCKOO_OPTIMIZE_USE_COUNT_LIMITS_SEARCH - const int use_count = clib_cuckoo_bucket_aux_get_use_count (bucket_aux); -#endif - /* *INDENT-OFF* */ - clib_cuckoo_bucket_foreach_idx_unrolled (i, { -#if CLIB_CUCKOO_OPTIMIZE_USE_COUNT_LIMITS_SEARCH - if (i > use_count) - { - break; - } -#endif - if (CV (clib_cuckoo_key_compare) (kvp->key, b->elts[i].key)) - { - kvp->value = b->elts[i].value; - clib_cuckoo_bucket_aux_t bucket_aux2 = b->aux; - if (PREDICT_TRUE (clib_cuckoo_bucket_aux_get_version (bucket_aux) == - clib_cuckoo_bucket_aux_get_version (bucket_aux2))) - { - /* yay, fresh data */ - return CLIB_CUCKOO_ERROR_SUCCESS; - } - else - { - /* oops, modification detected */ - return CLIB_CUCKOO_ERROR_AGAIN; - } - } - }); - /* *INDENT-ON* */ - return CLIB_CUCKOO_ERROR_NOT_FOUND; -} - -always_inline int -CV (clib_cuckoo_search_inline_with_hash) (CVT (clib_cuckoo) * h, u64 hash, - CVT (clib_cuckoo_kv) * kvp) -{ - CVT (clib_cuckoo_bucket) * buckets = h->buckets; - uword bucket1, bucket2; - u8 reduced_hash; - u64 nbuckets = vec_len (buckets); - u64 mask = nbuckets - 1; - int rv; - - bucket1 = hash & mask; - reduced_hash = clib_cuckoo_reduce_hash (hash); - -again: - rv = CV (clib_cuckoo_bucket_search) (vec_elt_at_index (buckets, bucket1), - kvp, reduced_hash); - - if (rv == CLIB_CUCKOO_ERROR_SUCCESS) - return CLIB_CUCKOO_ERROR_SUCCESS; - - if (PREDICT_FALSE (rv == CLIB_CUCKOO_ERROR_AGAIN)) - goto again; - - bucket2 = clib_cuckoo_get_other_bucket (nbuckets, bucket1, reduced_hash); - rv = CV (clib_cuckoo_bucket_search) (vec_elt_at_index (buckets, bucket2), - kvp, reduced_hash); - - /* change to 2nd bucket could bump the item to 1st bucket and the bucket - * indexes might not even be valid anymore - restart the search */ - if (PREDICT_FALSE (rv == CLIB_CUCKOO_ERROR_AGAIN)) - goto again; - - return rv; -} - -always_inline int CV (clib_cuckoo_search_inline) (CVT (clib_cuckoo) * h, - CVT (clib_cuckoo_kv) * kvp) -{ - u64 hash = CV (clib_cuckoo_hash) (kvp); - return CV (clib_cuckoo_search_inline_with_hash) (h, hash, kvp); -} - -#endif /* __included_cuckoo_template_h__ */ - -/** @endcond */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/fheap.c b/src/vppinfra/fheap.c deleted file mode 100644 index 034168e85ab..00000000000 --- a/src/vppinfra/fheap.c +++ /dev/null @@ -1,473 +0,0 @@ -/* - * Copyright (c) 2015 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 <vppinfra/fheap.h> - -/* Fibonacci heaps. */ -always_inline fheap_node_t * -fheap_get_node (fheap_t * f, u32 i) -{ - return i != ~0 ? vec_elt_at_index (f->nodes, i) : 0; -} - -always_inline fheap_node_t * -fheap_get_root (fheap_t * f) -{ - return fheap_get_node (f, f->min_root); -} - -static void -fheap_validate (fheap_t * f) -{ - fheap_node_t *n, *m; - uword ni, si; - - if (!CLIB_DEBUG || !f->enable_validate) - return; - - vec_foreach_index (ni, f->nodes) - { - n = vec_elt_at_index (f->nodes, ni); - - if (!n->is_valid) - continue; - - /* Min root must have minimal key. */ - m = vec_elt_at_index (f->nodes, f->min_root); - ASSERT (n->key >= m->key); - - /* Min root must have no parent. */ - if (ni == f->min_root) - ASSERT (n->parent == ~0); - - /* Check sibling linkages. */ - if (n->next_sibling == ~0) - ASSERT (n->prev_sibling == ~0); - else if (n->prev_sibling == ~0) - ASSERT (n->next_sibling == ~0); - else - { - fheap_node_t *prev, *next; - u32 si = n->next_sibling, si_start = si; - do - { - m = vec_elt_at_index (f->nodes, si); - prev = vec_elt_at_index (f->nodes, m->prev_sibling); - next = vec_elt_at_index (f->nodes, m->next_sibling); - ASSERT (prev->next_sibling == si); - ASSERT (next->prev_sibling == si); - si = m->next_sibling; - } - while (si != si_start); - } - - /* Loop through all siblings. */ - { - u32 n_siblings = 0; - - foreach_fheap_node_sibling (f, si, n->next_sibling, ( - { - m = - vec_elt_at_index - (f->nodes, si); - /* All siblings must have same parent. */ - ASSERT (m->parent - == - n-> - parent); - n_siblings += 1;} - )); - - /* Either parent is non-empty or there are siblings present. */ - if (n->parent == ~0 && ni != f->min_root) - ASSERT (n_siblings > 0); - } - - /* Loop through all children. */ - { - u32 found_first_child = n->first_child == ~0; - u32 n_children = 0; - - foreach_fheap_node_sibling (f, si, n->first_child, ( - { - m = - vec_elt_at_index - (f->nodes, si); - /* Children must have larger keys than their parent. */ - ASSERT (m->key >= - n->key); - if - (!found_first_child) - found_first_child = - si == - n->first_child; - n_children += 1;} - )); - - /* Check that first child is present on list. */ - ASSERT (found_first_child); - - /* Make sure rank is correct. */ - ASSERT (n->rank == n_children); - } - } - - /* Increment serial number for each successful validate. - Failure can be used as condition for gdb breakpoints. */ - f->validate_serial++; -} - -always_inline void -fheap_node_add_sibling (fheap_t * f, u32 ni, u32 ni_to_add) -{ - fheap_node_t *n = vec_elt_at_index (f->nodes, ni); - fheap_node_t *n_to_add = vec_elt_at_index (f->nodes, ni_to_add); - fheap_node_t *n_next = fheap_get_node (f, n->next_sibling); - fheap_node_t *parent; - - /* Empty list? */ - if (n->next_sibling == ~0) - { - ASSERT (n->prev_sibling == ~0); - n->next_sibling = n->prev_sibling = ni_to_add; - n_to_add->next_sibling = n_to_add->prev_sibling = ni; - } - else - { - /* Add node after existing node. */ - n_to_add->prev_sibling = ni; - n_to_add->next_sibling = n->next_sibling; - - n->next_sibling = ni_to_add; - n_next->prev_sibling = ni_to_add; - } - - n_to_add->parent = n->parent; - parent = fheap_get_node (f, n->parent); - if (parent) - parent->rank += 1; -} - -void -fheap_add (fheap_t * f, u32 ni, u32 key) -{ - fheap_node_t *r, *n; - u32 ri; - - n = vec_elt_at_index (f->nodes, ni); - - clib_memset (n, 0, sizeof (n[0])); - n->parent = n->first_child = n->next_sibling = n->prev_sibling = ~0; - n->key = key; - - r = fheap_get_root (f); - ri = f->min_root; - if (!r) - { - /* No root? Add node as new root. */ - f->min_root = ni; - } - else - { - /* Add node as sibling of current root. */ - fheap_node_add_sibling (f, ri, ni); - - /* New node may become new root. */ - if (r->key > n->key) - f->min_root = ni; - } - - fheap_validate (f); -} - -always_inline u32 -fheap_node_remove_internal (fheap_t * f, u32 ni, u32 invalidate) -{ - fheap_node_t *n = vec_elt_at_index (f->nodes, ni); - u32 prev_ni = n->prev_sibling; - u32 next_ni = n->next_sibling; - u32 list_has_single_element = prev_ni == ni; - fheap_node_t *prev = fheap_get_node (f, prev_ni); - fheap_node_t *next = fheap_get_node (f, next_ni); - fheap_node_t *p = fheap_get_node (f, n->parent); - - if (p) - { - ASSERT (p->rank > 0); - p->rank -= 1; - p->first_child = list_has_single_element ? ~0 : next_ni; - } - - if (prev) - { - ASSERT (prev->next_sibling == ni); - prev->next_sibling = next_ni; - } - if (next) - { - ASSERT (next->prev_sibling == ni); - next->prev_sibling = prev_ni; - } - - n->prev_sibling = n->next_sibling = ni; - n->parent = ~0; - n->is_valid = invalidate == 0; - - return list_has_single_element ? ~0 : next_ni; -} - -always_inline u32 -fheap_node_remove (fheap_t * f, u32 ni) -{ - return fheap_node_remove_internal (f, ni, /* invalidate */ 0); -} - -always_inline u32 -fheap_node_remove_and_invalidate (fheap_t * f, u32 ni) -{ - return fheap_node_remove_internal (f, ni, /* invalidate */ 1); -} - -static void -fheap_link_root (fheap_t * f, u32 ni) -{ - fheap_node_t *n = vec_elt_at_index (f->nodes, ni); - fheap_node_t *r, *lo, *hi; - u32 ri, lo_i, hi_i, k; - - while (1) - { - k = n->rank; - vec_validate_init_empty (f->root_list_by_rank, k, ~0); - ri = f->root_list_by_rank[k]; - r = fheap_get_node (f, ri); - if (!r) - { - f->root_list_by_rank[k] = ni; - return; - } - - f->root_list_by_rank[k] = ~0; - - /* Sort n/r into lo/hi by their keys. */ - lo = r, lo_i = ri; - hi = n, hi_i = ni; - if (hi->key < lo->key) - { - u32 ti; - fheap_node_t *tn; - ti = lo_i, tn = lo; - lo = hi, lo_i = hi_i; - hi = tn, hi_i = ti; - } - - /* Remove larger key. */ - fheap_node_remove (f, hi_i); - - /* Add larger key as child of smaller one. */ - if (lo->first_child == ~0) - { - hi->parent = lo_i; - lo->first_child = hi_i; - lo->rank = 1; - } - else - fheap_node_add_sibling (f, lo->first_child, hi_i); - - /* Following Fredman & Trajan: "When making a root node X a child of another node in a linking step, - we unmark X". */ - hi->is_marked = 0; - - ni = lo_i; - n = lo; - } -} - -u32 -fheap_del_min (fheap_t * f, u32 * min_key) -{ - fheap_node_t *r = fheap_get_root (f); - u32 to_delete_min_ri = f->min_root; - u32 ri, ni; - - /* Empty heap? */ - if (!r) - return ~0; - - /* Root's children become siblings. Call this step a; see below. */ - if (r->first_child != ~0) - { - u32 ci, cni, rni; - fheap_node_t *c, *cn, *rn; - - /* Splice child & root circular lists together. */ - ci = r->first_child; - c = vec_elt_at_index (f->nodes, ci); - - cni = c->next_sibling; - rni = r->next_sibling; - cn = vec_elt_at_index (f->nodes, cni); - rn = vec_elt_at_index (f->nodes, rni); - - r->next_sibling = cni; - c->next_sibling = rni; - cn->prev_sibling = to_delete_min_ri; - rn->prev_sibling = ci; - } - - /* Remove min root. */ - ri = fheap_node_remove_and_invalidate (f, to_delete_min_ri); - - /* Find new min root from among siblings including the ones we've just added. */ - f->min_root = ~0; - if (ri != ~0) - { - u32 ri_last, ri_next, i, min_ds; - - r = fheap_get_node (f, ri); - ri_last = r->prev_sibling; - while (1) - { - /* Step a above can put children (with r->parent != ~0) on root list. */ - r->parent = ~0; - - ri_next = r->next_sibling; - fheap_link_root (f, ri); - if (ri == ri_last) - break; - ri = ri_next; - r = fheap_get_node (f, ri); - } - - min_ds = ~0; - vec_foreach_index (i, f->root_list_by_rank) - { - ni = f->root_list_by_rank[i]; - if (ni == ~0) - continue; - f->root_list_by_rank[i] = ~0; - r = fheap_get_node (f, ni); - if (r->key < min_ds) - { - f->min_root = ni; - min_ds = r->key; - ASSERT (r->parent == ~0); - } - } - } - - /* Return deleted min root. */ - r = vec_elt_at_index (f->nodes, to_delete_min_ri); - if (min_key) - *min_key = r->key; - - fheap_validate (f); - - return to_delete_min_ri; -} - -static void -fheap_mark_parent (fheap_t * f, u32 pi) -{ - fheap_node_t *p = vec_elt_at_index (f->nodes, pi); - - /* Parent is a root: do nothing. */ - if (p->parent == ~0) - return; - - /* If not marked, mark it. */ - if (!p->is_marked) - { - p->is_marked = 1; - return; - } - - /* Its a previously marked, non-root parent. - Cut edge to its parent and add to root list. */ - fheap_node_remove (f, pi); - fheap_node_add_sibling (f, f->min_root, pi); - - /* Unmark it since its now a root node. */ - p->is_marked = 0; - - /* "Cascading cuts": check parent. */ - if (p->parent != ~0) - fheap_mark_parent (f, p->parent); -} - -/* Set key to new smaller value. */ -void -fheap_decrease_key (fheap_t * f, u32 ni, u32 new_key) -{ - fheap_node_t *n = vec_elt_at_index (f->nodes, ni); - fheap_node_t *r = fheap_get_root (f); - - n->key = new_key; - - if (n->parent != ~0) - { - fheap_mark_parent (f, n->parent); - - /* Remove node and add to root list. */ - fheap_node_remove (f, ni); - fheap_node_add_sibling (f, f->min_root, ni); - } - - if (n->key < r->key) - f->min_root = ni; - - fheap_validate (f); -} - -void -fheap_del (fheap_t * f, u32 ni) -{ - fheap_node_t *n; - - n = vec_elt_at_index (f->nodes, ni); - - if (n->parent == ~0) - { - ASSERT (ni == f->min_root); - fheap_del_min (f, 0); - } - else - { - u32 ci; - - fheap_mark_parent (f, n->parent); - - /* Add children to root list. */ - foreach_fheap_node_sibling (f, ci, n->first_child, ( - { - fheap_node_remove - (f, ci); - fheap_node_add_sibling - (f, f->min_root, - ci);} - )); - - fheap_node_remove_and_invalidate (f, ni); - } - - fheap_validate (f); -} - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/fheap.h b/src/vppinfra/fheap.h deleted file mode 100644 index 1dbd52bad76..00000000000 --- a/src/vppinfra/fheap.h +++ /dev/null @@ -1,140 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -#ifndef included_clib_fheap_h -#define included_clib_fheap_h - -/* Fibonacci Heaps Fredman, M. L.; Tarjan (1987). - "Fibonacci heaps and their uses in improved network optimization algorithms" */ - -#include <vppinfra/vec.h> - -typedef struct -{ - /* Node index of parent. */ - u32 parent; - - /* Node index of first child. */ - u32 first_child; - - /* Next and previous nodes in doubly linked list of siblings. */ - u32 next_sibling, prev_sibling; - - /* Key (distance) for this node. Parent always has key - <= than keys of children. */ - u32 key; - - /* Number of children (as opposed to descendents). */ - u32 rank; - - u32 is_marked; - - /* Set to one when node is inserted; zero when deleted. */ - u32 is_valid; -} fheap_node_t; - -#define foreach_fheap_node_sibling(f,ni,first_ni,body) \ -do { \ - u32 __fheap_foreach_first_ni = (first_ni); \ - u32 __fheap_foreach_ni = __fheap_foreach_first_ni; \ - u32 __fheap_foreach_next_ni; \ - fheap_node_t * __fheap_foreach_n; \ - if (__fheap_foreach_ni != ~0) \ - while (1) \ - { \ - __fheap_foreach_n = fheap_get_node ((f), __fheap_foreach_ni); \ - __fheap_foreach_next_ni = __fheap_foreach_n -> next_sibling; \ - (ni) = __fheap_foreach_ni; \ - \ - body; \ - \ - /* End of circular list? */ \ - if (__fheap_foreach_next_ni == __fheap_foreach_first_ni) \ - break; \ - \ - __fheap_foreach_ni = __fheap_foreach_next_ni; \ - \ - } \ -} while (0) - -typedef struct -{ - u32 min_root; - - /* Vector of nodes. */ - fheap_node_t *nodes; - - u32 *root_list_by_rank; - - u32 enable_validate; - - u32 validate_serial; -} fheap_t; - -/* Initialize empty heap. */ -always_inline void -fheap_init (fheap_t * f, u32 n_nodes) -{ - fheap_node_t *save_nodes = f->nodes; - u32 *save_root_list = f->root_list_by_rank; - - clib_memset (f, 0, sizeof (f[0])); - - f->nodes = save_nodes; - f->root_list_by_rank = save_root_list; - - vec_validate (f->nodes, n_nodes - 1); - vec_reset_length (f->root_list_by_rank); - - f->min_root = ~0; -} - -always_inline void -fheap_free (fheap_t * f) -{ - vec_free (f->nodes); - vec_free (f->root_list_by_rank); -} - -always_inline u32 -fheap_find_min (fheap_t * f) -{ - return f->min_root; -} - -always_inline u32 -fheap_is_empty (fheap_t * f) -{ - return f->min_root == ~0; -} - -/* Add/delete nodes. */ -void fheap_add (fheap_t * f, u32 ni, u32 key); -void fheap_del (fheap_t * f, u32 ni); - -/* Delete and return minimum. */ -u32 fheap_del_min (fheap_t * f, u32 * min_key); - -/* Change key value. */ -void fheap_decrease_key (fheap_t * f, u32 ni, u32 new_key); - -#endif /* included_clib_fheap_h */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/flowhash_24_16.h b/src/vppinfra/flowhash_24_16.h deleted file mode 100644 index 64ee0796c7a..00000000000 --- a/src/vppinfra/flowhash_24_16.h +++ /dev/null @@ -1,77 +0,0 @@ -/* - * Copyright (c) 2012 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. - */ - -#ifndef SRC_VPPINFRA_FLOWHASH_24_16_H_ -#define SRC_VPPINFRA_FLOWHASH_24_16_H_ - -#ifdef __included_flowhash_template_h__ -#undef __included_flowhash_template_h__ -#endif - -#include <vppinfra/clib.h> -#include <vppinfra/xxhash.h> -#include <vppinfra/crc32.h> - -typedef struct { - u64 as_u64[3]; -} flowhash_skey_24_16_t; - -typedef struct { - u64 as_u64[3]; -} flowhash_lkey_24_16_t; - -typedef struct { - u64 as_u64[2]; -} flowhash_value_24_16_t; - -#define FLOWHASH_TYPE _24_16 -#include <vppinfra/flowhash_template.h> -#undef FLOWHASH_TYPE - -static_always_inline -u32 flowhash_hash_24_16(flowhash_lkey_24_16_t *k) -{ -#ifdef clib_crc32c_uses_intrinsics - return clib_crc32c ((u8 *) &k->as_u64[0], 24); -#else - u64 val = 0; - val ^= k->as_u64[0]; - val ^= k->as_u64[1]; - val ^= k->as_u64[2]; - return (u32)clib_xxhash (val); -#endif -} - -static_always_inline -u8 flowhash_cmp_key_24_16(flowhash_skey_24_16_t *a, - flowhash_lkey_24_16_t *b) -{ - u8 val = 0; - val |= (a->as_u64[0] != b->as_u64[0]); - val |= (a->as_u64[1] != b->as_u64[1]); - val |= (a->as_u64[2] != b->as_u64[2]); - return val; -} - -static_always_inline -void flowhash_cpy_key_24_16(flowhash_skey_24_16_t *dst, - flowhash_lkey_24_16_t *src) -{ - dst->as_u64[0] = src->as_u64[0]; - dst->as_u64[1] = src->as_u64[1]; - dst->as_u64[2] = src->as_u64[2]; -} - -#endif /* SRC_VPPINFRA_FLOWHASH_24_16_H_ */ diff --git a/src/vppinfra/flowhash_8_8.h b/src/vppinfra/flowhash_8_8.h deleted file mode 100644 index 4a5cfc0a0c6..00000000000 --- a/src/vppinfra/flowhash_8_8.h +++ /dev/null @@ -1,67 +0,0 @@ -/* - * Copyright (c) 2012 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. - */ - -#ifndef SRC_VPPINFRA_FLOWHASH_8_8_H_ -#define SRC_VPPINFRA_FLOWHASH_8_8_H_ - -#ifdef __included_flowhash_template_h__ -#undef __included_flowhash_template_h__ -#endif - -#include <vppinfra/clib.h> -#include <vppinfra/xxhash.h> -#include <vppinfra/crc32.h> - -typedef struct { - u64 as_u64[1]; -} flowhash_skey_8_8_t; - -typedef struct { - u64 as_u64[1]; -} flowhash_lkey_8_8_t; - -typedef struct { - u64 as_u64[1]; -} flowhash_value_8_8_t; - -#define FLOWHASH_TYPE _8_8 -#include <vppinfra/flowhash_template.h> -#undef FLOWHASH_TYPE - -static_always_inline -u32 flowhash_hash_8_8(flowhash_lkey_8_8_t *k) -{ -#ifdef clib_crc32c_uses_intrinsics - return clib_crc32c ((u8 *) &k->as_u64[0], 8); -#else - return clib_xxhash (k->as_u64[0]); -#endif -} - -static_always_inline -u8 flowhash_cmp_key_8_8(flowhash_skey_8_8_t *a, - flowhash_lkey_8_8_t *b) -{ - return a->as_u64[0] != b->as_u64[0]; -} - -static_always_inline -void flowhash_cpy_key_8_8(flowhash_skey_8_8_t *dst, - flowhash_lkey_8_8_t *src) -{ - dst->as_u64[0] = src->as_u64[0]; -} - -#endif /* SRC_VPPINFRA_FLOWHASH_8_8_H_ */ diff --git a/src/vppinfra/flowhash_template.h b/src/vppinfra/flowhash_template.h deleted file mode 100644 index d7a621c1754..00000000000 --- a/src/vppinfra/flowhash_template.h +++ /dev/null @@ -1,608 +0,0 @@ -/* - * Copyright (c) 2012 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. - */ - -/* - * Author: Pierre Pfister <ppfister@cisco.com> - * - * DISCLAIMER ! - * - * This most likely is not the hash table you are looking for !! - * - * This structure targets a very specific and quite narrow set of use-cases - * that are not covered by other hash tables. - * - * Read the following text carefully, or ask the author or one of VPP's - * committers to make sure this is what you are looking for. - * - * - * -- Abstract: - * This hash table intends to provide a very fast lookup and insertion of - * key-value pairs for flow tables (although it might be used for other - * purposes), with additional support for lazy-timeouts. - * In particular, it was designed to minimize blocking reads, register usage and - * cache-lines accesses during a typical lookup. - * This hash table therefore provides stateful packet processing - * without performance degradation even when every single lookup has to fetch - * memory from RAM. - * This hash table is not thread-safe and requires executing a garbage - * collection function to clean-up chained buckets. - * - * -- Overview: - * - * One first aspect of this hash table is that it is self-contained in a single - * bulk of memory. Each entry contains a key, a value, and a 32 bits timeout - * value; occupies a full and single cache line; and is identified by a unique - * 32 bits index. The entry index zero is reserved and used when an entry - * could not be found nor inserted. Which means it is not necessary to - * immediately check whether an insertion or lookup was successful before - * behaving accordingly. One can just keep doing business as usual and - * check for the error later. - * - * Each entry is associated with a timeout value (which unit or clock is up to - * the user of the hash table). An entry which timeout is strictly smaller - * than the current time is considered empty, whereas an entry which timeout is - * greater or equal to the current time contains a valid key-value pair. - * - * Hash table lookup and insertion are equivalent: - * - An entry index is always returned (possibly index 0 if no entry could be - * found nor created). - * - The returned entry always has its key set to the provided key. - * - Timeout value will be greater than the provided current time whenever a - * valid entry was found, strictly smaller otherwise. In particular, one can - * not differentiate between an entry which was just created, and an entry - * which already existed in the past but got timeouted in between. - * - * As mentioned earlier, entry index zero is used as an invalid entry which may - * be manipulated as a normal one. Entries which index go from 1 to - * N (where N is a power of 2) are used as direct buckets, each containing a - * single entry. In the absence of hash collision, a single entry which location - * can deterministically be determined from the key-hash and the hash table - * header is accessed (One single cache line, without indirection). This - * allows for efficient pre-fetching of the key-value for more than 95% of - * accesses. - * - * In order to handle hash collisions (i.e. when multiple keys - * end-up in the same bucket), entries which index are greater than N are - * grouped into M groups of 16 collision entries. Such groups are linked - * with regular entries whenever a collision needs to be handled. - * When looking up a key with a bucket where a collision occurred, unused bits - * from the key hash are used to select two entries (from the collision bucket) - * where the new entry might be inserted. - * - * Once an entry is inserted, it will never be moved as long as the entry - * timeout value remains greater or equal to the provided current time value. - * The entry index can therefore be stored in other data structure as a way - * to bypass the hash lookup. But when doing so, one should check if the - * present key is the actual looked-up key. - * - * -- Garbage Collection: - * - * Since there is no explicit element removal, a garbage collector mechanism - * is required in order to remove buckets used for hash collisions. This - * is done by calling the flowhash_gc function on a regular basis. Each call - * to this function examines a single fixed entry. It shall therefore be called - * as many times as there are fixed entries in the hash table in order to - * ensure a full inspection. - * - * -- Time and timeout mechanism: - * - * The hash table makes use of a time value between in [1, 2^32 - 1]. - * The provided time value shall keep increasing, and looping is not handled. - * When seconds are used, the system should run for 136 years without any issue. - * If milliseconds are used, a shift should be operated on all timeout values - * on a regular basis (more than every 49 days). - */ - -#ifndef __included_flowhash_template_h__ -#define __included_flowhash_template_h__ - -#include <vppinfra/clib.h> -#include <vppinfra/mem.h> -#include <vppinfra/cache.h> - -#ifndef FLOWHASH_TYPE -#error FLOWHASH_TYPE not defined -#endif - -#define _fv(a,b) a##b -#define __fv(a,b) _fv(a,b) -#define FV(a) __fv(a,FLOWHASH_TYPE) - -#define _fvt(a,b) a##b##_t -#define __fvt(a,b) _fvt(a,b) -#define FVT(a) __fvt(a,FLOWHASH_TYPE) - -/* Same for all flowhash variants */ -#ifndef __included_flowhash_common__ - -#define FLOWHASH_INVALID_ENTRY_INDEX 0 - -#define FLOWHASH_ENTRIES_PER_BUCKETS_LOG 4 -#define FLOWHASH_ENTRIES_PER_BUCKETS (1 << FLOWHASH_ENTRIES_PER_BUCKETS_LOG) - -#endif /* ifndef __included_flowhash_common__ */ - - /** - * @brief Compare a stored key with a lookup key. - * - * This function must be defined to use this template. It must return 0 - * when the two keys are identical, and a different value otherwise. - */ -static_always_inline -u8 FV(flowhash_cmp_key)(FVT(flowhash_skey) *a, FVT(flowhash_lkey) *b); - - /** - * @brief Hash a lookup key into a 32 bit integer. - * - * This function must be defined to use this template. - * It must provides close to 32 bits of entropy distributed amongst - * all 32 bits of the provided value. - * Keys that are equal must have the same hash. - */ - static_always_inline - u32 FV(flowhash_hash)(FVT(flowhash_lkey) *k); - -/** - * @brief Copy a lookup key into a destination stored key. - * - * This function must be defined to use this template. It must modify the dst - * key such that a later call to flowhash_cmp_key with the same arguments - * would return 0. - */ -static_always_inline -void FV(flowhash_cpy_key)(FVT(flowhash_skey) *dst, FVT(flowhash_lkey) *src); - -/** - * @brief One flow hash entry used for both direct buckets and collision - * buckets. - */ -typedef struct { - /* Each entry is cache-line aligned. */ - CLIB_CACHE_LINE_ALIGN_MARK (cacheline0); - - /* Key is first to take advantage of alignment. */ - FVT(flowhash_skey) key; - - /* Entry value. */ - FVT(flowhash_value) value; - - /* Timeout value */ - u32 timeout; - - /* Entry index to the chained bucket. */ - u32 chained_entry_index; -} FVT(flowhash_entry); - -typedef struct FVT(__flowhash_struct) { - /* Cache aligned to simplify allocation. */ - CLIB_CACHE_LINE_ALIGN_MARK (cacheline0); - - /* Array going downward containing free bucket indices */ - u32 free_buckets_indices[0]; - - /* Negative index of the first free bucket */ - i32 free_buckets_position; - - /* Number of fixed buckets minus one */ - u32 fixed_entries_mask; - - /* Allocated pointer for this hash table */ - void *mem; - - u32 collision_buckets_mask; - u32 total_entries; - - u64 not_enough_buckets_counter; - u64 collision_lookup_counter; - u64 garbage_collection_counter; - - u32 gc_counter; - - /* Entry array containing: - * - 1 Dummy entry for error return - * - (buckets_mask + 1) Fixed buckets - * - chained_buckets Chained Buckets - */ - FVT(flowhash_entry) entries[0]; -} FVT(flowhash); - -/* Same for all flowhash variants */ -#ifndef __included_flowhash_common__ -#define __included_flowhash_common__ - -/** - * @brief Test whether a returned entry index corresponds to an overflow event. - */ -#define flowhash_is_overflow(ei) \ - ((ei) == FLOWHASH_INVALID_ENTRY_INDEX) - -/** - * @brief Iterate over all entries in the hash table. - * - * Iterate over all entries in the hash table, not including the first invalid - * entry (at index 0), but including all chained hash collision buckets. - * - */ -#define flowhash_foreach_entry(h, ei) \ - for (ei = 1; \ - ei < (h)->total_entries; \ - ei++) - -/** - * @brief Iterate over all currently valid entries. - * - * Iterate over all entries in the hash table which timeout value is greater - * or equal to the current time. - */ -#define flowhash_foreach_valid_entry(h, ei, now) \ - flowhash_foreach_entry(h, ei) \ - if (((now) <= (h)->entries[ei].timeout)) - -/** - * @brief Timeout variable from a given entry. - */ -#define flowhash_timeout(h, ei) (h)->entries[ei].timeout - -/** - * @brief Indicates whether the entry is being used. - */ -#define flowhash_is_timeouted(h, ei, time_now) \ - ((time_now) > flowhash_timeout(h, ei)) - -/** - * @brief Get the key from the entry index, casted to the provided type. - */ -#define flowhash_key(h, ei) (&(h)->entries[ei].key) - -/** - * @brief Get the value from the entry index, casted to the provided type. - */ -#define flowhash_value(h, ei) (&(h)->entries[ei].value) - -/** - * @brief Get the number of octets allocated to this structure. - */ -#define flowhash_memory_size(h) clib_mem_size((h)->mem) - -/** - * @brief Test whether the entry index is in hash table boundaries. - */ -#define flowhash_is_valid_entry_index(h, ei) (ei < (h)->total_entries) - -/** - * @brief Adjust, if necessary, provided parameters such as being valid flowhash - * sizes. - */ -static -void flowhash_validate_sizes(u32 *fixed_entries, u32 *collision_buckets) -{ - /* Find power of two greater or equal to the provided value */ - if (*fixed_entries < FLOWHASH_ENTRIES_PER_BUCKETS) - *fixed_entries = FLOWHASH_ENTRIES_PER_BUCKETS; - if (*fixed_entries > (1 << (32 - FLOWHASH_ENTRIES_PER_BUCKETS_LOG))) - *fixed_entries = (1 << (32 - FLOWHASH_ENTRIES_PER_BUCKETS_LOG)); - - *fixed_entries -= 1; - *fixed_entries |= *fixed_entries >> 16; - *fixed_entries |= *fixed_entries >> 8; - *fixed_entries |= *fixed_entries >> 4; - *fixed_entries |= *fixed_entries >> 2; - *fixed_entries |= *fixed_entries >> 1; - *fixed_entries += 1; - - if (*collision_buckets != 0) - { - if (*collision_buckets < CLIB_CACHE_LINE_BYTES/sizeof(u32)) - *collision_buckets = CLIB_CACHE_LINE_BYTES/sizeof(u32); - - *collision_buckets -= 1; - *collision_buckets |= *collision_buckets >> 16; - *collision_buckets |= *collision_buckets >> 8; - *collision_buckets |= *collision_buckets >> 4; - *collision_buckets |= *collision_buckets >> 2; - *collision_buckets |= *collision_buckets >> 1; - *collision_buckets += 1; - } -} - -/** - * @brief Prefetch the the hash entry bucket. - * - * This should be performed approximately 200-300 cycles before lookup - * if the table is located in RAM. Or 30-40 cycles before lookup - * in case the table is located in L3. - */ -#define flowhash_prefetch(h, hash) \ - CLIB_PREFETCH (&(h)->entries[((hash) & (h)->fixed_entries_mask) + 1], \ - sizeof((h)->entries[0]), LOAD) - -#endif /* ifndef __included_flowhash_common__ */ - -/** - * @brief Allocate a flowhash structure. - * - * @param[in] fixed_entries The number of fixed entries in the hash table. - * @param[in] chained_buckets The number of chained buckets. - * - * fixed_entries and chained_buckets parameters may not be used as is but - * modified in order to fit requirements. - * - * Since the flowhash does not support dynamic resizing, it is fairly - * important to choose the parameters carefully. In particular the performance - * gain from using this structure comes from an efficient lookup in the - * absence of hash collision. - * As a rule of thumbs, if the number of active entries (flows) is M, - * there should be about 16*M fixed entries, and M/16 collision buckets. - * Which represents 17*M allocated entries. - * - * For example: - * M = 2^20 total_size ~= 1GiB collision ~= 3% - * M = 2^18 total_size ~= 250MiB collision ~= 3% - * M = 2^10 total_size ~= 1MiB collision ~= 6% - * - */ -static_always_inline -FVT(flowhash) *FV(flowhash_alloc)(u32 fixed_entries, u32 collision_buckets) -{ - FVT(flowhash) *h; - uword size; - void *mem; - u32 entries; - - flowhash_validate_sizes(&fixed_entries, &collision_buckets); - - entries = 1 + fixed_entries + - collision_buckets * FLOWHASH_ENTRIES_PER_BUCKETS; - size = sizeof(*h) + sizeof(h->entries[0]) * entries + - sizeof(h->free_buckets_indices[0]) * collision_buckets; - - mem = clib_mem_alloc_aligned(size, CLIB_CACHE_LINE_BYTES); - h = mem + collision_buckets * sizeof(h->free_buckets_indices[0]); - h->mem = mem; - - /* Fill free elements list */ - int i; - clib_memset(h->entries, 0, sizeof(h->entries[0]) * entries); - for (i = 1; i <= collision_buckets; i++) - { - h->free_buckets_indices[-i] = - entries - i * FLOWHASH_ENTRIES_PER_BUCKETS; - } - - /* Init buckets */ - for (i=0; i < entries; i++) - { - h->entries[i].chained_entry_index = FLOWHASH_INVALID_ENTRY_INDEX; - h->entries[i].timeout = 0; - } - - h->free_buckets_position = -collision_buckets; - h->fixed_entries_mask = fixed_entries - 1; - h->collision_buckets_mask = collision_buckets - 1; - h->total_entries = entries; - h->not_enough_buckets_counter = 0; - h->collision_lookup_counter = 0; - h->garbage_collection_counter = 0; - h->gc_counter = 0; - - return h; -} - -/** - * @brief Free the flow hash memory. - */ -static_always_inline -void FV(flowhash_free)(FVT(flowhash) *h) -{ - clib_mem_free(h->mem); -} - -static void -FV(__flowhash_get_chained) (FVT(flowhash) *h, FVT(flowhash_lkey) *k, - u32 hash, u32 time_now, u32 *ei); - -/** - * @brief Retrieves an entry index corresponding to a provided key and its hash. - * - * @param h The hash table pointer. - * @param k[in] A pointer to the key value. - * @param hash[in] The hash of the key. - * @param time_now[in] The current time. - * @param ei[out] A pointer set to the found entry index. - * - * This function always sets ei value to a valid entry index which can then be - * used to access the stored value as well as get or set its associated timeout. - * The key stored in the returned entry is always set to the provided key. - * - * In case the provided key is not found, and no entry could be created - * (either because there is no hash collision bucket available or - * the candidate entries in the collision bucket were already used), ei is - * set to the special value FLOWHASH_INVALID_ENTRY_INDEX (which can be tested - * with the flowhash_is_overflow macro). - * - * The timeout value is never modified during a lookup. - * - Use the flowhash_is_timeouted macro to test whether the returned entry - * was already valid, or is proposed for insertion. - * - Use the flowhash_timeout macro to get and set the entry timeout value. - * - */ -static_always_inline -void FV(flowhash_get) (FVT(flowhash) *h, FVT(flowhash_lkey) *k, - u32 hash, u32 time_now, u32 *ei) -{ - *ei = (hash & h->fixed_entries_mask) + 1; - - if (PREDICT_FALSE(FV(flowhash_cmp_key)(&h->entries[*ei].key, k) != 0)) - { - if (PREDICT_TRUE(time_now > h->entries[*ei].timeout && - (h->entries[*ei].chained_entry_index == - FLOWHASH_INVALID_ENTRY_INDEX))) - { - FV(flowhash_cpy_key)(&h->entries[*ei].key, k); - } - else - { - FV(__flowhash_get_chained)(h, k, hash, time_now, ei); - } - } -} - -static_always_inline void -FV(__flowhash_get_chained) (FVT(flowhash) *h, FVT(flowhash_lkey) *k, - u32 hash, u32 time_now, u32 *ei) -{ - h->collision_lookup_counter++; - - if (h->entries[*ei].chained_entry_index == FLOWHASH_INVALID_ENTRY_INDEX) - { - /* No chained entry yet. Let's chain one. */ - if (h->free_buckets_position == 0) - { - /* Oops. No more buckets available. */ - h->not_enough_buckets_counter++; - *ei = FLOWHASH_INVALID_ENTRY_INDEX; - h->entries[FLOWHASH_INVALID_ENTRY_INDEX].timeout = - time_now - 1; - FV(flowhash_cpy_key)( - &h->entries[FLOWHASH_INVALID_ENTRY_INDEX].key, k); - return; - } - - /* Forward link */ - h->entries[*ei].chained_entry_index = - h->free_buckets_indices[h->free_buckets_position]; - - /* Backward link (for garbage collection) */ - h->entries[h->free_buckets_indices[h->free_buckets_position]]. - chained_entry_index = *ei; - - /* Move pointer */ - h->free_buckets_position++; - } - - /* Get the two indexes where to look at. */ - u32 bi0 = h->entries[*ei].chained_entry_index + - (hash >> (32 - FLOWHASH_ENTRIES_PER_BUCKETS_LOG)); - u32 bi1 = bi0 + 1; - bi1 = (bi0 & (FLOWHASH_ENTRIES_PER_BUCKETS - 1)) ? bi1 : - bi1 - FLOWHASH_ENTRIES_PER_BUCKETS; - - /* It is possible that we wait while comparing bi0 key. - * It's better to prefetch bi1 so we don't wait twice. */ - CLIB_PREFETCH(&h->entries[bi1], sizeof (h->entries[0]), READ); - - if (FV(flowhash_cmp_key)(&h->entries[bi0].key, k) == 0) - { - *ei = bi0; - return; - } - - if (FV(flowhash_cmp_key)(&h->entries[bi1].key, k) == 0) - { - *ei = bi1; - return; - } - - if (h->entries[*ei].timeout >= time_now) - { - *ei = FLOWHASH_INVALID_ENTRY_INDEX; - *ei = (time_now > h->entries[bi0].timeout) ? bi0 : *ei; - *ei = (time_now > h->entries[bi1].timeout) ? bi1 : *ei; - } - - FV(flowhash_cpy_key)(&h->entries[*ei].key, k); -} - -static_always_inline void -FV(flowhash_gc)(FVT(flowhash) *h, u32 time_now, - u32 *freed_index, u32 *freed_len) -{ - u32 ei; - if (freed_index) - *freed_len = 0; - - if (PREDICT_FALSE(h->collision_buckets_mask == (((u32)0) - 1))) - return; - - /* prefetch two rounds in advance */ - ei = 2 + h->fixed_entries_mask + - ((h->gc_counter + 2) & h->collision_buckets_mask) * - FLOWHASH_ENTRIES_PER_BUCKETS; - CLIB_PREFETCH(&h->entries[ei], sizeof (h->entries[0]), READ); - - /* prefetch one round in advance */ - ei = 2 + h->fixed_entries_mask + - ((h->gc_counter + 1) & h->collision_buckets_mask) * - FLOWHASH_ENTRIES_PER_BUCKETS; - if (h->entries[ei].chained_entry_index != FLOWHASH_INVALID_ENTRY_INDEX) - { - CLIB_PREFETCH(&h->entries[ei], 4 * CLIB_CACHE_LINE_BYTES, READ); - } - - /* do GC */ - ei = 2 + h->fixed_entries_mask + - ((h->gc_counter) & h->collision_buckets_mask) * - FLOWHASH_ENTRIES_PER_BUCKETS; - if (h->entries[ei].chained_entry_index != FLOWHASH_INVALID_ENTRY_INDEX) - { - u8 found = 0; - int i; - for (i=0; i<FLOWHASH_ENTRIES_PER_BUCKETS; i++) - { - if (time_now <= h->entries[ei + i].timeout) - { - found = 1; - break; - } - } - - if (!found) - { - /* Tell caller we freed this */ - if (freed_index) - { - *freed_index = ei; - *freed_len = FLOWHASH_ENTRIES_PER_BUCKETS; - } - /* The bucket is not used. Let's free it. */ - h->free_buckets_position--; - /* Reset forward link */ - h->entries[h->entries[ei].chained_entry_index].chained_entry_index = - FLOWHASH_INVALID_ENTRY_INDEX; - /* Reset back link */ - h->entries[ei].chained_entry_index = FLOWHASH_INVALID_ENTRY_INDEX; - /* Free element */ - h->free_buckets_indices[h->free_buckets_position] = ei; - /* Count the garbage collection event */ - h->garbage_collection_counter++; - } - } - - h->gc_counter++; -} - -static_always_inline -u32 FV(flowhash_elts)(FVT(flowhash) *h, u32 time_now) -{ - u32 tot = 0; - u32 ei; - - flowhash_foreach_valid_entry(h, ei, time_now) - tot++; - - return tot; -} - -#endif /* __included_flowhash_template_h__ */ diff --git a/src/vppinfra/pfhash.h b/src/vppinfra/pfhash.h deleted file mode 100644 index 2884fa81cf9..00000000000 --- a/src/vppinfra/pfhash.h +++ /dev/null @@ -1,276 +0,0 @@ -/* - Copyright (c) 2013 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. -*/ - -#ifndef included_clib_pfhash_h -#define included_clib_pfhash_h - - -#include <vppinfra/clib.h> -#include <vppinfra/hash.h> -#include <vppinfra/pool.h> - -#if defined(CLIB_HAVE_VEC128) && ! defined (__ALTIVEC__) - -typedef struct -{ - /* 3 x 16 = 48 key bytes */ - union - { - u32x4 k_u32x4[3]; - u64 k_u64[6]; - } kb; - /* 3 x 4 = 12 value bytes */ - u32 values[3]; - u32 pad; -} pfhash_kv_16_t; - -typedef struct -{ - /* 5 x 8 = 40 key bytes */ - union - { - u64 k_u64[5]; - } kb; - - /* 5 x 4 = 20 value bytes */ - u32 values[5]; - u32 pad; -} pfhash_kv_8_t; - -typedef struct -{ - /* 4 x 8 = 32 key bytes */ - union - { - u64 k_u64[4]; - } kb; - - /* 4 x 8 = 32 value bytes */ - u64 values[4]; -} pfhash_kv_8v8_t; - -typedef struct -{ - /* 8 x 4 = 32 key bytes */ - union - { - u32x4 k_u32x4[2]; - u32 kb[8]; - } kb; - - /* 8 x 4 = 32 value bytes */ - u32 values[8]; -} pfhash_kv_4_t; - -typedef union -{ - pfhash_kv_16_t kv16; - pfhash_kv_8_t kv8; - pfhash_kv_8v8_t kv8v8; - pfhash_kv_4_t kv4; -} pfhash_kv_t; - -typedef struct -{ - /* Bucket vector */ - u32 *buckets; -#define PFHASH_BUCKET_OVERFLOW (u32)~0 - - /* Pool of key/value pairs */ - pfhash_kv_t *kvp; - - /* overflow plain-o-hash */ - uword *overflow_hash; - - /* Pretty-print name */ - u8 *name; - - u32 key_size; - u32 value_size; - - u32 overflow_count; - u32 nitems; - u32 nitems_in_overflow; -} pfhash_t; - -void pfhash_init (pfhash_t * p, char *name, u32 key_size, u32 value_size, - u32 nbuckets); -void pfhash_free (pfhash_t * p); -u64 pfhash_get (pfhash_t * p, u32 bucket, void *key); -void pfhash_set (pfhash_t * p, u32 bucket, void *key, void *value); -void pfhash_unset (pfhash_t * p, u32 bucket, void *key); - -format_function_t format_pfhash; - -static inline void -pfhash_prefetch_bucket (pfhash_t * p, u32 bucket) -{ - CLIB_PREFETCH (&p->buckets[bucket], CLIB_CACHE_LINE_BYTES, LOAD); -} - -static inline u32 -pfhash_read_bucket_prefetch_kv (pfhash_t * p, u32 bucket) -{ - u32 bucket_contents = p->buckets[bucket]; - if (PREDICT_TRUE ((bucket_contents & PFHASH_BUCKET_OVERFLOW) == 0)) - CLIB_PREFETCH (&p->kvp[bucket_contents], CLIB_CACHE_LINE_BYTES, LOAD); - return bucket_contents; -} - -/* - * pfhash_search_kv_16 - * See if the supplied 16-byte key matches one of three 16-byte (key,value) pairs. - * Return the indicated value, or ~0 if no match - * - * Note: including the overflow test, the fast path is 35 instrs - * on x86_64. Elves will steal your keyboard in the middle of the night if - * you "improve" it without checking the generated code! - */ -static inline u32 -pfhash_search_kv_16 (pfhash_t * p, u32 bucket_contents, u32x4 * key) -{ - u32x4 diff0, diff1, diff2; - u32 is_equal0, is_equal1, is_equal2; - u32 no_match; - pfhash_kv_16_t *kv; - u32 rv; - - if (PREDICT_FALSE (bucket_contents == PFHASH_BUCKET_OVERFLOW)) - { - uword *hp; - hp = hash_get_mem (p->overflow_hash, key); - if (hp) - return hp[0]; - return (u32) ~ 0; - } - - kv = &p->kvp[bucket_contents].kv16; - - diff0 = u32x4_sub (kv->kb.k_u32x4[0], key[0]); - diff1 = u32x4_sub (kv->kb.k_u32x4[1], key[0]); - diff2 = u32x4_sub (kv->kb.k_u32x4[2], key[0]); - - no_match = is_equal0 = (i16) u32x4_zero_byte_mask (diff0); - is_equal1 = (i16) u32x4_zero_byte_mask (diff1); - no_match |= is_equal1; - is_equal2 = (i16) u32x4_zero_byte_mask (diff2); - no_match |= is_equal2; - /* If any of the three items matched, no_match will be zero after this line */ - no_match = ~no_match; - - rv = (is_equal0 & kv->values[0]) - | (is_equal1 & kv->values[1]) | (is_equal2 & kv->values[2]) | no_match; - - return rv; -} - -static inline u32 -pfhash_search_kv_8 (pfhash_t * p, u32 bucket_contents, u64 * key) -{ - pfhash_kv_8_t *kv; - u32 rv = (u32) ~ 0; - - if (PREDICT_FALSE (bucket_contents == PFHASH_BUCKET_OVERFLOW)) - { - uword *hp; - hp = hash_get_mem (p->overflow_hash, key); - if (hp) - return hp[0]; - return (u32) ~ 0; - } - - kv = &p->kvp[bucket_contents].kv8; - - rv = (kv->kb.k_u64[0] == key[0]) ? kv->values[0] : rv; - rv = (kv->kb.k_u64[1] == key[0]) ? kv->values[1] : rv; - rv = (kv->kb.k_u64[2] == key[0]) ? kv->values[2] : rv; - rv = (kv->kb.k_u64[3] == key[0]) ? kv->values[3] : rv; - rv = (kv->kb.k_u64[4] == key[0]) ? kv->values[4] : rv; - - return rv; -} - -static inline u64 -pfhash_search_kv_8v8 (pfhash_t * p, u32 bucket_contents, u64 * key) -{ - pfhash_kv_8v8_t *kv; - u64 rv = (u64) ~ 0; - - if (PREDICT_FALSE (bucket_contents == PFHASH_BUCKET_OVERFLOW)) - { - uword *hp; - hp = hash_get_mem (p->overflow_hash, key); - if (hp) - return hp[0]; - return (u64) ~ 0; - } - - kv = &p->kvp[bucket_contents].kv8v8; - - rv = (kv->kb.k_u64[0] == key[0]) ? kv->values[0] : rv; - rv = (kv->kb.k_u64[1] == key[0]) ? kv->values[1] : rv; - rv = (kv->kb.k_u64[2] == key[0]) ? kv->values[2] : rv; - rv = (kv->kb.k_u64[3] == key[0]) ? kv->values[3] : rv; - - return rv; -} - -static inline u32 -pfhash_search_kv_4 (pfhash_t * p, u32 bucket_contents, u32 * key) -{ - u32x4 vector_key; - u32x4 is_equal[2]; - u32 zbm[2], winner_index; - pfhash_kv_4_t *kv; - - if (PREDICT_FALSE (bucket_contents == PFHASH_BUCKET_OVERFLOW)) - { - uword *hp; - hp = hash_get_mem (p->overflow_hash, key); - if (hp) - return hp[0]; - return (u32) ~ 0; - } - - kv = &p->kvp[bucket_contents].kv4; - - vector_key = u32x4_splat (key[0]); - - is_equal[0] = (kv->kb.k_u32x4[0] == vector_key); - is_equal[1] = (kv->kb.k_u32x4[1] == vector_key); - zbm[0] = ~u32x4_zero_byte_mask (is_equal[0]) & 0xFFFF; - zbm[1] = ~u32x4_zero_byte_mask (is_equal[1]) & 0xFFFF; - - if (PREDICT_FALSE ((zbm[0] == 0) && (zbm[1] == 0))) - return (u32) ~ 0; - - winner_index = min_log2 (zbm[0]) >> 2; - winner_index = zbm[1] ? (4 + (min_log2 (zbm[1]) >> 2)) : winner_index; - - return kv->values[winner_index]; -} - -#endif /* CLIB_HAVE_VEC128 */ - -#endif /* included_clib_pfhash_h */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/phash.c b/src/vppinfra/phash.c deleted file mode 100644 index 52c29b33f78..00000000000 --- a/src/vppinfra/phash.c +++ /dev/null @@ -1,1017 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2005 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -/* This is all stolen from Bob Jenkins and reworked for clib. Thanks - once again Bob for the great work. */ - -/* ------------------------------------------------------------------------------- -perfect.c: code to generate code for a hash for perfect hashing. -(c) Bob Jenkins, September 1996, December 1999 -You may use this code in any way you wish, and it is free. No warranty. -I hereby place this in the public domain. -Source is http://burtleburtle.net/bob/c/perfect.c - -This generates a minimal perfect hash function. That means, given a -set of n keys, this determines a hash function that maps each of -those keys into a value in 0..n-1 with no collisions. - -The perfect hash function first uses a normal hash function on the key -to determine (a,b) such that the pair (a,b) is distinct for all -keys, then it computes a^scramble[tab[b]] to get the final perfect hash. -tab[] is an array of 1-byte values and scramble[] is a 256-term array of -2-byte or 4-byte values. If there are n keys, the length of tab[] is a -power of two between n/3 and n. - -I found the idea of computing distinct (a,b) values in "Practical minimal -perfect hash functions for large databases", Fox, Heath, Chen, and Daoud, -Communications of the ACM, January 1992. They found the idea in Chichelli -(CACM Jan 1980). Beyond that, our methods differ. - -The key is hashed to a pair (a,b) where a in 0..*alen*-1 and b in -0..*blen*-1. A fast hash function determines both a and b -simultaneously. Any decent hash function is likely to produce -hashes so that (a,b) is distinct for all pairs. I try the hash -using different values of *salt* until all pairs are distinct. - -The final hash is (a XOR scramble[tab[b]]). *scramble* is a -predetermined mapping of 0..255 into 0..smax-1. *tab* is an -array that we fill in in such a way as to make the hash perfect. - -First we fill in all values of *tab* that are used by more than one -key. We try all possible values for each position until one works. - -This leaves m unmapped keys and m values that something could hash to. -If you treat unmapped keys as lefthand nodes and unused hash values -as righthand nodes, and draw a line connecting each key to each hash -value it could map to, you get a bipartite graph. We attempt to -find a perfect matching in this graph. If we succeed, we have -determined a perfect hash for the whole set of keys. - -*scramble* is used because (a^tab[i]) clusters keys around *a*. ------------------------------------------------------------------------------- -*/ - -#include <vppinfra/bitmap.h> -#include <vppinfra/format.h> -#include <vppinfra/phash.h> -#include <vppinfra/random.h> - -static void -init_keys_direct_u32 (phash_main_t * pm) -{ - int n_keys_left, b_mask, a_shift; - u32 seed; - phash_key_t *k; - - seed = pm->hash_seed; - b_mask = (1 << pm->b_bits) - 1; - a_shift = BITS (seed) - pm->a_bits; - - k = pm->keys; - n_keys_left = vec_len (pm->keys); - - while (n_keys_left >= 2) - { - u32 x0, y0, z0; - u32 x1, y1, z1; - - x0 = y0 = z0 = seed; - x1 = y1 = z1 = seed; - x0 += (u32) k[0].key; - x1 += (u32) k[1].key; - - hash_mix32 (x0, y0, z0); - hash_mix32 (x1, y1, z1); - - k[0].b = z0 & b_mask; - k[1].b = z1 & b_mask; - k[0].a = z0 >> a_shift; - k[1].a = z1 >> a_shift; - if (PREDICT_FALSE (a_shift >= BITS (z0))) - k[0].a = k[1].a = 0; - - k += 2; - n_keys_left -= 2; - } - - if (n_keys_left >= 1) - { - u32 x0, y0, z0; - - x0 = y0 = z0 = seed; - x0 += k[0].key; - - hash_mix32 (x0, y0, z0); - - k[0].b = z0 & b_mask; - k[0].a = z0 >> a_shift; - if (PREDICT_FALSE (a_shift >= BITS (z0))) - k[0].a = 0; - - k += 1; - n_keys_left -= 1; - } -} - -static void -init_keys_direct_u64 (phash_main_t * pm) -{ - int n_keys_left, b_mask, a_shift; - u64 seed; - phash_key_t *k; - - seed = pm->hash_seed; - b_mask = (1 << pm->b_bits) - 1; - a_shift = BITS (seed) - pm->a_bits; - - k = pm->keys; - n_keys_left = vec_len (pm->keys); - - while (n_keys_left >= 2) - { - u64 x0, y0, z0; - u64 x1, y1, z1; - - x0 = y0 = z0 = seed; - x1 = y1 = z1 = seed; - x0 += (u64) k[0].key; - x1 += (u64) k[1].key; - - hash_mix64 (x0, y0, z0); - hash_mix64 (x1, y1, z1); - - k[0].b = z0 & b_mask; - k[1].b = z1 & b_mask; - k[0].a = z0 >> a_shift; - k[1].a = z1 >> a_shift; - if (PREDICT_FALSE (a_shift >= BITS (z0))) - k[0].a = k[1].a = 0; - - k += 2; - n_keys_left -= 2; - } - - if (n_keys_left >= 1) - { - u64 x0, y0, z0; - - x0 = y0 = z0 = seed; - x0 += k[0].key; - - hash_mix64 (x0, y0, z0); - - k[0].b = z0 & b_mask; - k[0].a = z0 >> a_shift; - if (PREDICT_FALSE (a_shift >= BITS (z0))) - k[0].a = 0; - - k += 1; - n_keys_left -= 1; - } -} - -static void -init_keys_indirect_u32 (phash_main_t * pm) -{ - int n_keys_left, b_mask, a_shift; - u32 seed; - phash_key_t *k; - - seed = pm->hash_seed; - b_mask = (1 << pm->b_bits) - 1; - a_shift = BITS (seed) - pm->a_bits; - - k = pm->keys; - n_keys_left = vec_len (pm->keys); - - while (n_keys_left >= 2) - { - u32 xyz[6]; - u32 x0, y0, z0; - u32 x1, y1, z1; - - pm->key_seed2 (pm->private, k[0].key, k[1].key, &xyz); - - x0 = y0 = z0 = seed; - x1 = y1 = z1 = seed; - x0 += xyz[0]; - y0 += xyz[1]; - z0 += xyz[2]; - x1 += xyz[3]; - y1 += xyz[4]; - z1 += xyz[5]; - - hash_mix32 (x0, y0, z0); - hash_mix32 (x1, y1, z1); - - k[0].b = z0 & b_mask; - k[1].b = z1 & b_mask; - k[0].a = z0 >> a_shift; - k[1].a = z1 >> a_shift; - if (PREDICT_FALSE (a_shift >= BITS (z0))) - k[0].a = k[1].a = 0; - - k += 2; - n_keys_left -= 2; - } - - if (n_keys_left >= 1) - { - u32 xyz[3]; - u32 x0, y0, z0; - - pm->key_seed1 (pm->private, k[0].key, &xyz); - - x0 = y0 = z0 = seed; - x0 += xyz[0]; - y0 += xyz[1]; - z0 += xyz[2]; - - hash_mix32 (x0, y0, z0); - - k[0].b = z0 & b_mask; - k[0].a = z0 >> a_shift; - if (PREDICT_FALSE (a_shift >= BITS (z0))) - k[0].a = 0; - - k += 1; - n_keys_left -= 1; - } -} - -static void -init_keys_indirect_u64 (phash_main_t * pm) -{ - int n_keys_left, b_mask, a_shift; - u64 seed; - phash_key_t *k; - - seed = pm->hash_seed; - b_mask = (1 << pm->b_bits) - 1; - a_shift = BITS (seed) - pm->a_bits; - - k = pm->keys; - n_keys_left = vec_len (pm->keys); - - while (n_keys_left >= 2) - { - u64 xyz[6]; - u64 x0, y0, z0; - u64 x1, y1, z1; - - pm->key_seed2 (pm->private, k[0].key, k[1].key, &xyz); - - x0 = y0 = z0 = seed; - x1 = y1 = z1 = seed; - x0 += xyz[0]; - y0 += xyz[1]; - z0 += xyz[2]; - x1 += xyz[3]; - y1 += xyz[4]; - z1 += xyz[5]; - - hash_mix64 (x0, y0, z0); - hash_mix64 (x1, y1, z1); - - k[0].b = z0 & b_mask; - k[1].b = z1 & b_mask; - k[0].a = z0 >> a_shift; - k[1].a = z1 >> a_shift; - if (PREDICT_FALSE (a_shift >= BITS (z0))) - k[0].a = k[1].a = 0; - - k += 2; - n_keys_left -= 2; - } - - if (n_keys_left >= 1) - { - u64 xyz[3]; - u64 x0, y0, z0; - - pm->key_seed1 (pm->private, k[0].key, &xyz); - - x0 = y0 = z0 = seed; - x0 += xyz[0]; - y0 += xyz[1]; - z0 += xyz[2]; - - hash_mix64 (x0, y0, z0); - - k[0].b = z0 & b_mask; - k[0].a = z0 >> a_shift; - if (PREDICT_FALSE (a_shift >= BITS (z0))) - k[0].a = 0; - - k += 1; - n_keys_left -= 1; - } -} - -/* - * insert keys into table according to key->b - * check if the initial hash might work - */ -static int -init_tabb (phash_main_t * pm) -{ - int no_collisions; - phash_tabb_t *tb; - phash_key_t *k, *l; - - if (pm->key_seed1) - { - if (pm->flags & PHASH_FLAG_MIX64) - init_keys_indirect_u64 (pm); - else - init_keys_indirect_u32 (pm); - } - else - { - if (pm->flags & PHASH_FLAG_MIX64) - init_keys_direct_u64 (pm); - else - init_keys_direct_u32 (pm); - } - - if (!pm->tabb) - vec_resize (pm->tabb, 1 << pm->b_bits); - else - vec_foreach (tb, pm->tabb) phash_tabb_free (tb); - - /* Two keys with the same (a,b) guarantees a collision */ - no_collisions = 1; - vec_foreach (k, pm->keys) - { - u32 i, *ki; - - tb = pm->tabb + k->b; - ki = tb->keys; - for (i = 0; i < vec_len (ki); i++) - { - l = pm->keys + ki[i]; - if (k->a == l->a) - { - /* Given keys are supposed to be unique. */ - if (pm->key_is_equal - && pm->key_is_equal (pm->private, l->key, k->key)) - clib_error ("duplicate keys"); - no_collisions = 0; - goto done; - } - } - - vec_add1 (tb->keys, k - pm->keys); - } - -done: - return no_collisions; -} - -/* Try to apply an augmenting list */ -static int -apply (phash_main_t * pm, u32 tail, u32 rollback) -{ - phash_key_t *k; - phash_tabb_t *pb; - phash_tabq_t *q_child, *q_parent; - u32 ki, i, hash, child, parent; - u32 stabb; /* scramble[tab[b]] */ - int no_collision; - - no_collision = 1; - - /* Walk from child to parent until root is reached. */ - for (child = tail - 1; child; child = parent) - { - q_child = &pm->tabq[child]; - parent = q_child->parent_q; - q_parent = &pm->tabq[parent]; - - /* find parent's list of siblings */ - ASSERT (q_parent->b_q < vec_len (pm->tabb)); - pb = pm->tabb + q_parent->b_q; - - /* erase old hash values */ - stabb = pm->scramble[pb->val_b]; - for (i = 0; i < vec_len (pb->keys); i++) - { - ki = pb->keys[i]; - k = pm->keys + ki; - hash = k->a ^ stabb; - - /* Erase hash for all of child's siblings. */ - if (ki == pm->tabh[hash]) - pm->tabh[hash] = ~0; - } - - /* change pb->val_b, which will change the hashes of all parent siblings */ - pb->val_b = rollback ? q_child->oldval_q : q_child->newval_q; - - /* set new hash values */ - stabb = pm->scramble[pb->val_b]; - for (i = 0; i < vec_len (pb->keys); i++) - { - ki = pb->keys[i]; - k = pm->keys + ki; - - hash = k->a ^ stabb; - if (rollback) - { - if (parent == 0) - continue; /* root never had a hash */ - } - else if (pm->tabh[hash] != ~0) - { - /* Very rare case: roll back any changes. */ - apply (pm, tail, /* rollback changes */ 1); - no_collision = 0; - goto done; - } - pm->tabh[hash] = ki; - } - } - -done: - return no_collision; -} - - -/* -------------------------------------------------------------------------------- -augment(): Add item to the mapping. - -Construct a spanning tree of *b*s with *item* as root, where each -parent can have all its hashes changed (by some new val_b) with -at most one collision, and each child is the b of that collision. - -I got this from Tarjan's "Data Structures and Network Algorithms". The -path from *item* to a *b* that can be remapped with no collision is -an "augmenting path". Change values of tab[b] along the path so that -the unmapped key gets mapped and the unused hash value gets used. - -Assuming 1 key per b, if m out of n hash values are still unused, -you should expect the transitive closure to cover n/m nodes before -an unused node is found. Sum(i=1..n)(n/i) is about nlogn, so expect -this approach to take about nlogn time to map all single-key b's. -------------------------------------------------------------------------------- - -high_water: a value higher than any now in tabb[].water_b. -*/ -static int -augment (phash_main_t * pm, u32 b_root, u32 high_water) -{ - u32 q; /* current position walking through the queue */ - u32 tail; /* tail of the queue. 0 is the head of the queue. */ - phash_tabb_t *tb_parent, *tb_child, *tb_hit; - phash_key_t *k_parent, *k_child; - u32 v, v_limit; /* possible value for myb->val_b */ - u32 i, ki, hash; - - v_limit = - 1 << ((pm->flags & PHASH_FLAG_USE_SCRAMBLE) ? pm->s_bits : BITS (u8)); - - /* Initialize the root of the spanning tree. */ - pm->tabq[0].b_q = b_root; - tail = 1; - - /* construct the spanning tree by walking the queue, add children to tail */ - for (q = 0; q < tail; q++) - { - if ((pm->flags & PHASH_FLAG_FAST_MODE) - && !(pm->flags & PHASH_FLAG_MINIMAL) && q == 1) - break; /* don't do transitive closure */ - - tb_parent = pm->tabb + pm->tabq[q].b_q; /* the b for this node */ - - for (v = 0; v < v_limit; v++) - { - tb_child = 0; - - for (i = 0; i < vec_len (tb_parent->keys); i++) - { - ki = tb_parent->keys[i]; - k_parent = pm->keys + ki; - - hash = k_parent->a ^ pm->scramble[v]; - if (hash >= pm->hash_max) - goto try_next_v; /* hash code out of bounds => we can't use this v */ - - ki = pm->tabh[hash]; - if (ki == ~0) - continue; - - k_child = pm->keys + ki; - tb_hit = pm->tabb + k_child->b; - - if (tb_child) - { - /* Hit at most one child b. */ - if (tb_child == tb_hit) - goto try_next_v; - } - else - { - /* Remember this as child b. */ - tb_child = tb_hit; - if (tb_hit->water_b == high_water) - goto try_next_v; /* already explored */ - } - } - - /* tb_parent with v has either one or zero collisions. */ - - /* add child b to the queue of reachable things */ - if (tb_child) - tb_child->water_b = high_water; - pm->tabq[tail].b_q = tb_child ? tb_child - pm->tabb : ~0; - pm->tabq[tail].newval_q = v; /* how to make parent (myb) use this hash */ - pm->tabq[tail].oldval_q = tb_parent->val_b; /* need this for rollback */ - pm->tabq[tail].parent_q = q; - ++tail; - - /* Found a v with no collisions? */ - if (!tb_child) - { - /* Try to apply the augmenting path. */ - if (apply (pm, tail, /* rollback */ 0)) - return 1; /* success, item was added to the perfect hash */ - --tail; /* don't know how to handle such a child! */ - } - - try_next_v: - ; - } - } - return 0; -} - - -static phash_tabb_t *sort_tabb; - -static int -phash_tabb_compare (void *a1, void *a2) -{ - u32 *b1 = a1; - u32 *b2 = a2; - phash_tabb_t *tb1, *tb2; - - tb1 = sort_tabb + b1[0]; - tb2 = sort_tabb + b2[0]; - - return ((int) vec_len (tb2->keys) - (int) vec_len (tb1->keys)); -} - -/* find a mapping that makes this a perfect hash */ -static int -perfect (phash_main_t * pm) -{ - u32 i; - - /* clear any state from previous attempts */ - if (vec_bytes (pm->tabh)) - clib_memset (pm->tabh, ~0, vec_bytes (pm->tabh)); - - vec_validate (pm->tabb_sort, vec_len (pm->tabb) - 1); - for (i = 0; i < vec_len (pm->tabb_sort); i++) - pm->tabb_sort[i] = i; - - sort_tabb = pm->tabb; - - vec_sort_with_function (pm->tabb_sort, phash_tabb_compare); - - /* In descending order by number of keys, map all *b*s */ - for (i = 0; i < vec_len (pm->tabb_sort); i++) - { - if (!augment (pm, pm->tabb_sort[i], i + 1)) - return 0; - } - - /* Success! We found a perfect hash of all keys into 0..nkeys-1. */ - return 1; -} - - -/* - * Find initial a_bits = log2 (a_max), b_bits = log2 (b_max). - * Initial a_max and b_max values were found empirically. Some factors: - * - * If s_max<256 there is no scramble, so tab[b] needs to cover 0..s_max-1. - * - * a_max and b_max must be powers of 2 because the values in 0..a_max-1 and - * 0..b_max-1 are produced by applying a bitmask to the initial hash function. - * - * a_max must be less than s_max, in fact less than n_keys, because otherwise - * there would often be no i such that a^scramble[i] is in 0..n_keys-1 for - * all the *a*s associated with a given *b*, so there would be no legal - * value to assign to tab[b]. This only matters when we're doing a minimal - * perfect hash. - * - * It takes around 800 trials to find distinct (a,b) with nkey=s_max*(5/8) - * and a_max*b_max = s_max*s_max/32. - * - * Values of b_max less than s_max/4 never work, and s_max/2 always works. - * - * We want b_max as small as possible because it is the number of bytes in - * the huge array we must create for the perfect hash. - * - * When nkey <= s_max*(5/8), b_max=s_max/4 works much more often with - * a_max=s_max/8 than with a_max=s_max/4. Above s_max*(5/8), b_max=s_max/4 - * doesn't seem to care whether a_max=s_max/8 or a_max=s_max/4. I think it - * has something to do with 5/8 = 1/8 * 5. For example examine 80000, - * 85000, and 90000 keys with different values of a_max. This only matters - * if we're doing a minimal perfect hash. - * - * When a_max*b_max <= 1<<U32BITS, the initial hash must produce one integer. - * Bigger than that it must produce two integers, which increases the - * cost of the hash per character hashed. - */ -static void -guess_initial_parameters (phash_main_t * pm) -{ - u32 s_bits, s_max, a_max, b_max, n_keys; - int is_minimal, is_fast_mode; - const u32 b_max_use_scramble_threshold = 4096; - - is_minimal = (pm->flags & PHASH_FLAG_MINIMAL) != 0; - is_fast_mode = (pm->flags & PHASH_FLAG_FAST_MODE) != 0; - - n_keys = vec_len (pm->keys); - s_bits = max_log2 (n_keys); - s_max = 1 << s_bits; - a_max = 0; - - if (is_minimal) - { - switch (s_bits) - { - case 0: - a_max = 1; - b_max = 1; - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - /* - * Was: a_max = is_minimal ? s_max / 2 : s_max; - * However, we know that is_minimal must be true, so the - * if-arm of the ternary expression is always executed. - */ - a_max = s_max / 2; - b_max = s_max / 2; - break; - case 9: - case 10: - case 11: - case 12: - case 13: - case 14: - case 15: - case 16: - case 17: - if (is_fast_mode) - { - a_max = s_max / 2; - b_max = s_max / 4; - } - else if (s_max / 4 < b_max_use_scramble_threshold) - { - if (n_keys <= s_max * 0.52) - a_max = b_max = s_max / 8; - else - a_max = b_max = s_max / 4; - } - else - { - a_max = ((n_keys <= s_max * (5.0 / 8.0)) ? s_max / 8 : - (n_keys <= - s_max * (3.0 / 4.0)) ? s_max / 4 : s_max / 2); - b_max = s_max / 4; /* always give the small size a shot */ - } - break; - case 18: - if (is_fast_mode) - a_max = b_max = s_max / 2; - else - { - a_max = s_max / 8; /* never require the multiword hash */ - b_max = (n_keys <= s_max * (5.0 / 8.0)) ? s_max / 4 : s_max / 2; - } - break; - case 19: - case 20: - a_max = (n_keys <= s_max * (5.0 / 8.0)) ? s_max / 8 : s_max / 2; - b_max = (n_keys <= s_max * (5.0 / 8.0)) ? s_max / 4 : s_max / 2; - break; - default: - /* Just find a hash as quick as possible. - We'll be thrashing virtual memory at this size. */ - a_max = b_max = s_max / 2; - break; - } - } - else - { - /* Non-minimal perfect hash. */ - if (is_fast_mode && n_keys > s_max * 0.8) - { - s_max *= 2; - s_bits += 1; - } - - if (s_max / 4 <= (1 << 14)) - b_max = ((n_keys <= s_max * 0.56) ? s_max / 32 : - (n_keys <= s_max * 0.74) ? s_max / 16 : s_max / 8); - else - b_max = ((n_keys <= s_max * 0.6) ? s_max / 16 : - (n_keys <= s_max * 0.8) ? s_max / 8 : s_max / 4); - - if (is_fast_mode && b_max < s_max / 8) - b_max = s_max / 8; - - if (a_max < 1) - a_max = 1; - if (b_max < 1) - b_max = 1; - } - - ASSERT (s_max == (1 << s_bits)); - ASSERT (is_pow2 (a_max)); - ASSERT (is_pow2 (b_max)); - pm->s_bits = s_bits; - pm->a_bits = min_log2 (a_max); - pm->b_bits = min_log2 (b_max); - if (b_max >= b_max_use_scramble_threshold) - pm->flags |= PHASH_FLAG_USE_SCRAMBLE; -} - -/* compute p(x), where p is a permutation of 0..(1<<nbits)-1 */ -/* permute(0)=0. This is intended and useful. */ -always_inline u32 -scramble_permute (u32 x, u32 nbits) -{ - int i; - int mask = (1 << nbits) - 1; - int const2 = 1 + nbits / 2; - int const3 = 1 + nbits / 3; - int const4 = 1 + nbits / 4; - int const5 = 1 + nbits / 5; - for (i = 0; i < 20; i++) - { - x = (x + (x << const2)) & mask; - x = (x ^ (x >> const3)); - x = (x + (x << const4)) & mask; - x = (x ^ (x >> const5)); - } - return x; -} - -/* initialize scramble[] with distinct random values in 0..smax-1 */ -static void -scramble_init (phash_main_t * pm) -{ - u32 i; - - /* fill scramble[] with distinct random integers in 0..smax-1 */ - vec_validate (pm->scramble, (1 << (pm->s_bits < 8 ? 8 : pm->s_bits)) - 1); - for (i = 0; i < vec_len (pm->scramble); i++) - pm->scramble[i] = scramble_permute (i, pm->s_bits); -} - -/* Try to find a perfect hash function. */ -clib_error_t * -phash_find_perfect_hash (phash_main_t * pm) -{ - clib_error_t *error = 0; - u32 max_a_bits, n_tries_this_a_b, want_minimal; - - /* guess initial values for s_max, a_max and b_max */ - guess_initial_parameters (pm); - - want_minimal = pm->flags & PHASH_FLAG_MINIMAL; - -new_s: - if (pm->b_bits == 0) - pm->a_bits = pm->s_bits; - - max_a_bits = pm->s_bits - want_minimal; - if (max_a_bits < 1) - max_a_bits = 1; - - pm->hash_max = want_minimal ? vec_len (pm->keys) : (1 << pm->s_bits); - - scramble_init (pm); - - /* Allocate working memory. */ - vec_free (pm->tabh); - vec_validate_init_empty (pm->tabh, pm->hash_max - 1, ~0); - vec_free (pm->tabq); - vec_validate (pm->tabq, 1 << pm->b_bits); - - /* Actually find the perfect hash */ - n_tries_this_a_b = 0; - while (1) - { - /* Choose random hash seeds until keys become unique. */ - pm->hash_seed = random_u64 (&pm->random_seed); - pm->n_seed_trials++; - if (init_tabb (pm)) - { - /* Found unique (A, B). */ - - /* Hash may already be perfect. */ - if (pm->b_bits == 0) - goto done; - - pm->n_perfect_calls++; - if (perfect (pm)) - goto done; - - goto increase_b; - } - - /* Keep trying with different seed value. */ - n_tries_this_a_b++; - if (n_tries_this_a_b < 2048) - continue; - - /* Try to put more bits in (A,B) to make distinct (A,B) more likely */ - if (pm->a_bits < max_a_bits) - pm->a_bits++; - else if (pm->b_bits < pm->s_bits) - { - increase_b: - vec_resize (pm->tabb, vec_len (pm->tabb)); - vec_resize (pm->tabq, vec_len (pm->tabq)); - pm->b_bits++; - } - else - { - /* Can't increase (A, B) any more, so try increasing S. */ - goto new_s; - } - } - -done: - /* Construct mapping table for hash lookups. */ - if (!error) - { - u32 b, v; - - pm->a_shift = ((pm->flags & PHASH_FLAG_MIX64) ? 64 : 32) - pm->a_bits; - pm->b_mask = (1 << pm->b_bits) - 1; - - vec_resize (pm->tab, vec_len (pm->tabb)); - for (b = 0; b < vec_len (pm->tabb); b++) - { - v = pm->tabb[b].val_b; - - /* Apply scramble now for small enough value of b_bits. */ - if (!(pm->flags & PHASH_FLAG_USE_SCRAMBLE)) - v = pm->scramble[v]; - - pm->tab[b] = v; - } - } - - /* Free working memory. */ - phash_main_free_working_memory (pm); - - return error; -} - -/* Slow hash computation for general keys. */ -uword -phash_hash_slow (phash_main_t * pm, uword key) -{ - u32 a, b, v; - - if (pm->flags & PHASH_FLAG_MIX64) - { - u64 x0, y0, z0; - - x0 = y0 = z0 = pm->hash_seed; - - if (pm->key_seed1) - { - u64 xyz[3]; - pm->key_seed1 (pm->private, key, &xyz); - x0 += xyz[0]; - y0 += xyz[1]; - z0 += xyz[2]; - } - else - x0 += key; - - hash_mix64 (x0, y0, z0); - - a = z0 >> pm->a_shift; - b = z0 & pm->b_mask; - } - else - { - u32 x0, y0, z0; - - x0 = y0 = z0 = pm->hash_seed; - - if (pm->key_seed1) - { - u32 xyz[3]; - pm->key_seed1 (pm->private, key, &xyz); - x0 += xyz[0]; - y0 += xyz[1]; - z0 += xyz[2]; - } - else - x0 += key; - - hash_mix32 (x0, y0, z0); - - a = z0 >> pm->a_shift; - b = z0 & pm->b_mask; - } - - v = pm->tab[b]; - if (pm->flags & PHASH_FLAG_USE_SCRAMBLE) - v = pm->scramble[v]; - return a ^ v; -} - -/* Verify that perfect hash is perfect. */ -clib_error_t * -phash_validate (phash_main_t * pm) -{ - phash_key_t *k; - uword *unique_bitmap = 0; - clib_error_t *error = 0; - - vec_foreach (k, pm->keys) - { - uword h = phash_hash_slow (pm, k->key); - - if (h >= pm->hash_max) - { - error = clib_error_return (0, "hash out of range %wd", h); - goto done; - } - - if (clib_bitmap_get (unique_bitmap, h)) - { - error = clib_error_return (0, "hash non-unique"); - goto done; - } - - unique_bitmap = clib_bitmap_ori (unique_bitmap, h); - } - -done: - clib_bitmap_free (unique_bitmap); - return error; -} - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/phash.h b/src/vppinfra/phash.h deleted file mode 100644 index 3dc59c724f7..00000000000 --- a/src/vppinfra/phash.h +++ /dev/null @@ -1,194 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2005 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#ifndef included_phash_h -#define included_phash_h - -#include <vppinfra/hash.h> /* for Bob's mixing functions */ - -typedef struct -{ - /* Maybe either pointer to vector or inline word. */ - uword key; - - /* Hash code (A, B). */ - u32 a, b; -} phash_key_t; - -/* Table indexed by B. */ -typedef struct -{ - /* Vector of key indices with this same value of B. */ - u32 *keys; - - /* hash=a^tabb[b].val_b */ - u32 val_b; - - /* High watermark of who has visited this map node. */ - u32 water_b; -} phash_tabb_t; - -always_inline void -phash_tabb_free (phash_tabb_t * b) -{ - vec_free (b->keys); - b->val_b = b->water_b = 0; -} - -typedef struct -{ - /* b that currently occupies this hash */ - u32 b_q; - - /* Queue position of parent that could use this hash. */ - u32 parent_q; - - /* What to change parent tab[b] to use this hash. */ - u32 newval_q; - - /* Original value of tab[b]. */ - u32 oldval_q; -} phash_tabq_t; - -typedef struct -{ - u8 a_bits, b_bits, s_bits, a_shift; - u32 b_mask; - u32 *tab; - u32 *scramble; - - /* Seed value for hash mixer. */ - u64 hash_seed; - - u32 flags; - - /* Key functions want 64 bit keys. - Use hash_mix64 rather than hash_mix32. */ -#define PHASH_FLAG_MIX64 (1 << 0) -#define PHASH_FLAG_MIX32 (0 << 0) - - /* When b_bits is large enough (>= 12) we scramble. */ -#define PHASH_FLAG_USE_SCRAMBLE (1 << 1) - - /* Slow mode gives smaller tables but at the expense of more run time. */ -#define PHASH_FLAG_SLOW_MODE (0 << 2) -#define PHASH_FLAG_FAST_MODE (1 << 2) - - /* Generate minimal perfect hash instead of perfect hash. */ -#define PHASH_FLAG_NON_MINIMAL (0 << 3) -#define PHASH_FLAG_MINIMAL (1 << 3) - - /* vec_len (keys) for minimal hash; - 1 << s_bits for non-minimal hash. */ - u32 hash_max; - - /* Vector of keys. */ - phash_key_t *keys; - - /* Used by callbacks to identify keys. */ - void *private; - - /* Key comparison callback. */ - int (*key_is_equal) (void *private, uword key1, uword key2); - - /* Callback to reduce single key -> hash seeds. */ - void (*key_seed1) (void *private, uword key, void *seed); - - /* Callback to reduce two key2 -> hash seeds. */ - void (*key_seed2) (void *private, uword key1, uword key2, void *seed); - - /* Stuff used to compute perfect hash. */ - u32 random_seed; - - /* Stuff indexed by B. */ - phash_tabb_t *tabb; - - /* Table of B ordered by number of keys in tabb[b]. */ - u32 *tabb_sort; - - /* Unique key (or ~0 if none) for a given hash - H = A ^ scramble[tab[B].val_b]. */ - u32 *tabh; - - /* Stuff indexed by q. */ - phash_tabq_t *tabq; - - /* Stats. */ - u32 n_seed_trials, n_perfect_calls; -} phash_main_t; - -always_inline void -phash_main_free_working_memory (phash_main_t * pm) -{ - vec_free (pm->tabb); - vec_free (pm->tabq); - vec_free (pm->tabh); - vec_free (pm->tabb_sort); - if (!(pm->flags & PHASH_FLAG_USE_SCRAMBLE)) - vec_free (pm->scramble); -} - -always_inline void -phash_main_free (phash_main_t * pm) -{ - phash_main_free_working_memory (pm); - vec_free (pm->tab); - vec_free (pm->keys); - clib_memset (pm, 0, sizeof (pm[0])); -} - -/* Slow hash computation for general keys. */ -uword phash_hash_slow (phash_main_t * pm, uword key); - -/* Main routine to compute perfect hash. */ -clib_error_t *phash_find_perfect_hash (phash_main_t * pm); - -/* Validates that hash is indeed perfect. */ -clib_error_t *phash_validate (phash_main_t * pm); - -/* Unit test. */ -int phash_test_main (unformat_input_t * input); - -#endif /* included_phash_h */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/pipeline.h b/src/vppinfra/pipeline.h deleted file mode 100644 index 5a9799b455e..00000000000 --- a/src/vppinfra/pipeline.h +++ /dev/null @@ -1,176 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - * pipeline.h: software pipeline infrastructure - * - * Copyright (c) 2010 Eliot Dresselhaus - * - * Permission is hereby granted, free of charge, to any person obtaining - * a copy of this software and associated documentation files (the - * "Software"), to deal in the Software without restriction, including - * without limitation the rights to use, copy, modify, merge, publish, - * distribute, sublicense, and/or sell copies of the Software, and to - * permit persons to whom the Software is furnished to do so, subject to - * the following conditions: - * - * The above copyright notice and this permission notice shall be - * included in all copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - */ - -#ifndef included_clib_pipeline_h -#define included_clib_pipeline_h - -#define clib_pipeline_stage(F,TYPE,ARG,I,BODY) \ - always_inline void F##_inline (void * _, u32 I) \ - { TYPE ARG = _; { BODY; } } \ - never_inline void F##_no_inline (TYPE ARG, u32 I) \ - { F##_inline (ARG, I); } - -#define clib_pipeline_stage_static(F,TYPE,ARG,I,BODY) \ - static_always_inline void F##_inline (void * _, u32 I) \ - { TYPE ARG = _; { BODY; } } \ - never_inline void F##_no_inline (TYPE ARG, u32 I) \ - { F##_inline (ARG, I); } - -#define clib_pipeline_stage_no_inline(F,TYPE,ARG,I,BODY) \ - never_inline void F##_no_inline (void * _, u32 I) \ - { TYPE ARG = _; { BODY; } } \ - never_inline void F##_inline (TYPE ARG, u32 I) \ - { F##_no_inline (ARG, I); } - -#define _clib_pipeline_var(v) _clib_pipeline_##v - -#define clib_pipeline_stage_execute(F,A,I,S) \ - F##_##S (A, _clib_pipeline_var(i) - (I)) - -#define clib_pipeline_main_stage(F,A,I) \ - clib_pipeline_stage_execute (F, A, I, inline) -#define clib_pipeline_init_stage(F,A,I) \ - if (_clib_pipeline_var(i) >= (I)) clib_pipeline_stage_execute (F, A, I, no_inline) -#define clib_pipeline_exit_stage(F,A,I) \ - if (_clib_pipeline_var(i) >= (I) && _clib_pipeline_var(i) - (I) < _clib_pipeline_var(n_vectors)) \ - clib_pipeline_stage_execute (F, A, I, no_inline) - -#define clib_pipeline_init_loop \ - for (_clib_pipeline_var(i) = 0; \ - _clib_pipeline_var(i) < \ - clib_min (_clib_pipeline_var(n_stages) - 1, \ - _clib_pipeline_var(n_vectors)); \ - _clib_pipeline_var(i)++) - -#define clib_pipeline_main_loop \ - for (; _clib_pipeline_var(i) < _clib_pipeline_var(n_vectors); \ - _clib_pipeline_var(i)++) - -#define clib_pipeline_exit_loop \ - for (; _clib_pipeline_var(i) < (_clib_pipeline_var(n_vectors) \ - + _clib_pipeline_var(n_stages) - 1); \ - _clib_pipeline_var(i)++) - -#define clib_pipeline_run_2_stage(N,ARG,STAGE0,STAGE1) \ -do { \ - uword _clib_pipeline_var(n_vectors) = (N); \ - uword _clib_pipeline_var(n_stages) = 2; \ - uword _clib_pipeline_var(i); \ - \ - clib_pipeline_init_loop \ - { \ - clib_pipeline_init_stage (STAGE0, ARG, 0); \ - } \ - \ - clib_pipeline_main_loop \ - { \ - clib_pipeline_main_stage (STAGE0, ARG, 0); \ - clib_pipeline_main_stage (STAGE1, ARG, 1); \ - } \ - \ - clib_pipeline_exit_loop \ - { \ - clib_pipeline_exit_stage (STAGE1, ARG, 1); \ - } \ -} while (0) - -#define clib_pipeline_run_3_stage(N,ARG,STAGE0,STAGE1,STAGE2) \ -do { \ - uword _clib_pipeline_var(n_vectors) = (N); \ - uword _clib_pipeline_var(n_stages) = 3; \ - uword _clib_pipeline_var(i); \ - \ - clib_pipeline_init_loop \ - { \ - clib_pipeline_init_stage (STAGE0, ARG, 0); \ - clib_pipeline_init_stage (STAGE1, ARG, 1); \ - } \ - \ - clib_pipeline_main_loop \ - { \ - clib_pipeline_main_stage (STAGE0, ARG, 0); \ - clib_pipeline_main_stage (STAGE1, ARG, 1); \ - clib_pipeline_main_stage (STAGE2, ARG, 2); \ - } \ - \ - clib_pipeline_exit_loop \ - { \ - clib_pipeline_exit_stage (STAGE1, ARG, 1); \ - clib_pipeline_exit_stage (STAGE2, ARG, 2); \ - } \ -} while (0) - -#define clib_pipeline_run_4_stage(N,ARG,STAGE0,STAGE1,STAGE2,STAGE3) \ -do { \ - uword _clib_pipeline_var(n_vectors) = (N); \ - uword _clib_pipeline_var(n_stages) = 4; \ - uword _clib_pipeline_var(i); \ - \ - clib_pipeline_init_loop \ - { \ - clib_pipeline_init_stage (STAGE0, ARG, 0); \ - clib_pipeline_init_stage (STAGE1, ARG, 1); \ - clib_pipeline_init_stage (STAGE2, ARG, 2); \ - } \ - \ - clib_pipeline_main_loop \ - { \ - clib_pipeline_main_stage (STAGE0, ARG, 0); \ - clib_pipeline_main_stage (STAGE1, ARG, 1); \ - clib_pipeline_main_stage (STAGE2, ARG, 2); \ - clib_pipeline_main_stage (STAGE3, ARG, 3); \ - } \ - \ - clib_pipeline_exit_loop \ - { \ - clib_pipeline_exit_stage (STAGE1, ARG, 1); \ - clib_pipeline_exit_stage (STAGE2, ARG, 2); \ - clib_pipeline_exit_stage (STAGE3, ARG, 3); \ - } \ -} while (0) - -#endif /* included_clib_pipeline_h */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/qhash.c b/src/vppinfra/qhash.c deleted file mode 100644 index 3b5a175065d..00000000000 --- a/src/vppinfra/qhash.c +++ /dev/null @@ -1,859 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2006 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#include <vppinfra/qhash.h> - -#define QHASH_ALL_VALID ((1 << QHASH_KEYS_PER_BUCKET) - 1) - -void * -_qhash_resize (void *v, uword length, uword elt_bytes) -{ - qhash_t *h; - uword l; - - l = clib_max (max_log2 (length), 2 + QHASH_LOG2_KEYS_PER_BUCKET); - - /* Round up if less than 1/2 full. */ - l += ((f64) length / (f64) (1 << l)) < .5; - - v = _vec_resize (0, 1 << l, elt_bytes << l, sizeof (h[0]), - /* align */ sizeof (uword)); - - h = qhash_header (v); - h->n_elts = 0; - h->log2_hash_size = l; - h->hash_keys = - clib_mem_alloc_aligned_no_fail (sizeof (h->hash_keys[0]) << l, - CLIB_CACHE_LINE_BYTES); - vec_resize (h->hash_key_valid_bitmap, - 1 << (l - QHASH_LOG2_KEYS_PER_BUCKET)); - clib_memset (v, ~0, elt_bytes << l); - - return v; -} - -static u8 min_log2_table[256]; - -static inline uword -qhash_min_log2 (uword x) -{ - ASSERT (is_pow2 (x)); - ASSERT (x < 256); - return min_log2_table[x]; -} - -static void -qhash_min_log2_init () -{ - int i; - for (i = 0; i < 256; i++) - min_log2_table[i] = min_log2 (i); -} - -always_inline uword -qhash_get_valid_elt_mask (qhash_t * h, uword i) -{ - return h->hash_key_valid_bitmap[i / QHASH_KEYS_PER_BUCKET]; -} - -always_inline void -qhash_set_valid_elt_mask (qhash_t * h, uword i, uword mask) -{ - h->hash_key_valid_bitmap[i / QHASH_KEYS_PER_BUCKET] = mask; -} - -always_inline uword -qhash_search_bucket (uword * hash_keys, uword search_key, uword m) -{ - uword t; -#define _(i) ((hash_keys[i] == search_key) << i) - t = (_(0) | _(1) | _(2) | _(3)); - if (QHASH_KEYS_PER_BUCKET > 4) - t |= (_(4) | _(5) | _(6) | _(7)); - if (QHASH_KEYS_PER_BUCKET > 8) - t |= (_(8) | _(9) | _(10) | _(11) | _(12) | _(13) | _(14) | _(15)); -#undef _ - return m & t; -} - -/* Lookup multiple keys in the same hash table. */ -void -qhash_get_multiple (void *v, - uword * search_keys, - uword n_search_keys, u32 * result_indices) -{ - qhash_t *h = qhash_header (v); - uword *k, *hash_keys; - uword n_left, bucket_mask; - u32 *r; - - if (!v) - { - clib_memset (result_indices, ~0, - sizeof (result_indices[0]) * n_search_keys); - return; - } - - bucket_mask = pow2_mask (h->log2_hash_size) & ~(QHASH_KEYS_PER_BUCKET - 1); - - k = search_keys; - n_left = n_search_keys; - hash_keys = h->hash_keys; - r = result_indices; - - while (n_left >= 2) - { - u32 a0, b0, c0, bi0, valid0, match0; - u32 a1, b1, c1, bi1, valid1, match1; - uword k0, k1, *h0, *h1; - - k0 = k[0]; - k1 = k[1]; - n_left -= 2; - k += 2; - - a0 = a1 = h->hash_seeds[0]; - b0 = b1 = h->hash_seeds[1]; - c0 = c1 = h->hash_seeds[2]; - a0 ^= k0; - a1 ^= k1; -#if uword_bits == 64 - b0 ^= k0 >> 32; - b1 ^= k1 >> 32; -#endif - - hash_mix32_step_1 (a0, b0, c0); - hash_mix32_step_1 (a1, b1, c1); - hash_mix32_step_2 (a0, b0, c0); - hash_mix32_step_2 (a1, b1, c1); - hash_mix32_step_3 (a0, b0, c0); - hash_mix32_step_3 (a1, b1, c1); - - bi0 = c0 & bucket_mask; - bi1 = c1 & bucket_mask; - - h0 = hash_keys + bi0; - h1 = hash_keys + bi1; - - /* Search two buckets. */ - valid0 = qhash_get_valid_elt_mask (h, bi0); - valid1 = qhash_get_valid_elt_mask (h, bi1); - - match0 = qhash_search_bucket (h0, k0, valid0); - match1 = qhash_search_bucket (h1, k1, valid1); - - bi0 += qhash_min_log2 (match0); - bi1 += qhash_min_log2 (match1); - - r[0] = match0 ? bi0 : ~0; - r[1] = match1 ? bi1 : ~0; - r += 2; - - /* Full buckets trigger search of overflow hash. */ - if (PREDICT_FALSE (!match0 && valid0 == QHASH_ALL_VALID)) - { - uword *p = hash_get (h->overflow_hash, k0); - r[-2] = p ? p[0] : ~0; - } - - /* Full buckets trigger search of overflow hash. */ - if (PREDICT_FALSE (!match1 && valid1 == QHASH_ALL_VALID)) - { - uword *p = hash_get (h->overflow_hash, k1); - r[-1] = p ? p[0] : ~0; - } - } - - while (n_left >= 1) - { - u32 a0, b0, c0, bi0, valid0, match0; - uword k0, *h0; - - k0 = k[0]; - n_left -= 1; - k += 1; - - a0 = h->hash_seeds[0]; - b0 = h->hash_seeds[1]; - c0 = h->hash_seeds[2]; - a0 ^= k0; -#if uword_bits == 64 - b0 ^= k0 >> 32; -#endif - - hash_mix32 (a0, b0, c0); - - bi0 = c0 & bucket_mask; - - h0 = hash_keys + bi0; - - /* Search one bucket. */ - valid0 = qhash_get_valid_elt_mask (h, bi0); - match0 = qhash_search_bucket (h0, k0, valid0); - - bi0 += qhash_min_log2 (match0); - - r[0] = match0 ? bi0 : ~0; - r += 1; - - /* Full buckets trigger search of overflow hash. */ - if (PREDICT_FALSE (!match0 && valid0 == QHASH_ALL_VALID)) - { - uword *p = hash_get (h->overflow_hash, k0); - r[-1] = p ? p[0] : ~0; - } - } -} - -/* Lookup multiple keys in the same hash table. - Returns index of first matching key. */ -u32 -qhash_get_first_match (void *v, - uword * search_keys, - uword n_search_keys, uword * matching_key) -{ - qhash_t *h = qhash_header (v); - uword *k, *hash_keys; - uword n_left, match_mask, bucket_mask; - - if (!v) - return ~0; - - match_mask = 0; - bucket_mask = pow2_mask (h->log2_hash_size) & ~(QHASH_KEYS_PER_BUCKET - 1); - - k = search_keys; - n_left = n_search_keys; - hash_keys = h->hash_keys; - while (n_left >= 2) - { - u32 a0, b0, c0, bi0, valid0; - u32 a1, b1, c1, bi1, valid1; - uword k0, k1, *h0, *h1; - - k0 = k[0]; - k1 = k[1]; - n_left -= 2; - k += 2; - - a0 = a1 = h->hash_seeds[0]; - b0 = b1 = h->hash_seeds[1]; - c0 = c1 = h->hash_seeds[2]; - a0 ^= k0; - a1 ^= k1; -#if uword_bits == 64 - b0 ^= k0 >> 32; - b1 ^= k1 >> 32; -#endif - - hash_mix32_step_1 (a0, b0, c0); - hash_mix32_step_1 (a1, b1, c1); - hash_mix32_step_2 (a0, b0, c0); - hash_mix32_step_2 (a1, b1, c1); - hash_mix32_step_3 (a0, b0, c0); - hash_mix32_step_3 (a1, b1, c1); - - bi0 = c0 & bucket_mask; - bi1 = c1 & bucket_mask; - - h0 = hash_keys + bi0; - h1 = hash_keys + bi1; - - /* Search two buckets. */ - valid0 = qhash_get_valid_elt_mask (h, bi0); - valid1 = qhash_get_valid_elt_mask (h, bi1); - match_mask = qhash_search_bucket (h0, k0, valid0); - match_mask |= (qhash_search_bucket (h1, k1, valid1) - << QHASH_KEYS_PER_BUCKET); - if (match_mask) - { - uword bi, is_match1; - - bi = qhash_min_log2 (match_mask); - is_match1 = bi >= QHASH_KEYS_PER_BUCKET; - - bi += ((is_match1 ? bi1 : bi0) - - (is_match1 << QHASH_LOG2_KEYS_PER_BUCKET)); - *matching_key = (k - 2 - search_keys) + is_match1; - return bi; - } - - /* Full buckets trigger search of overflow hash. */ - if (PREDICT_FALSE (valid0 == QHASH_ALL_VALID - || valid1 == QHASH_ALL_VALID)) - { - uword *p = 0; - uword ki = k - 2 - search_keys; - - if (valid0 == QHASH_ALL_VALID) - p = hash_get (h->overflow_hash, k0); - - if (!p && valid1 == QHASH_ALL_VALID) - { - p = hash_get (h->overflow_hash, k1); - ki++; - } - - if (p) - { - *matching_key = ki; - return p[0]; - } - } - } - - while (n_left >= 1) - { - u32 a0, b0, c0, bi0, valid0; - uword k0, *h0; - - k0 = k[0]; - n_left -= 1; - k += 1; - - a0 = h->hash_seeds[0]; - b0 = h->hash_seeds[1]; - c0 = h->hash_seeds[2]; - a0 ^= k0; -#if uword_bits == 64 - b0 ^= k0 >> 32; -#endif - - hash_mix32 (a0, b0, c0); - - bi0 = c0 & bucket_mask; - - h0 = hash_keys + bi0; - - /* Search one bucket. */ - valid0 = qhash_get_valid_elt_mask (h, bi0); - match_mask = qhash_search_bucket (h0, k0, valid0); - if (match_mask) - { - uword bi; - bi = bi0 + qhash_min_log2 (match_mask); - *matching_key = (k - 1 - search_keys); - return bi; - } - - /* Full buckets trigger search of overflow hash. */ - if (PREDICT_FALSE (valid0 == QHASH_ALL_VALID)) - { - uword *p = hash_get (h->overflow_hash, k0); - if (p) - { - *matching_key = (k - 1 - search_keys); - return p[0]; - } - } - } - - return ~0; -} - -static void * -qhash_set_overflow (void *v, uword elt_bytes, - uword key, uword bi, uword * n_elts, u32 * result) -{ - qhash_t *h = qhash_header (v); - uword *p = hash_get (h->overflow_hash, key); - uword i; - - bi /= QHASH_KEYS_PER_BUCKET; - - if (p) - i = p[0]; - else - { - uword l = vec_len (h->overflow_free_indices); - if (l > 0) - { - i = h->overflow_free_indices[l - 1]; - _vec_len (h->overflow_free_indices) = l - 1; - } - else - i = (1 << h->log2_hash_size) + hash_elts (h->overflow_hash); - hash_set (h->overflow_hash, key, i); - vec_validate (h->overflow_counts, bi); - h->overflow_counts[bi] += 1; - *n_elts += 1; - - l = vec_len (v); - if (i >= l) - { - uword dl = round_pow2 (1 + i - l, 8); - v = _vec_resize (v, dl, (l + dl) * elt_bytes, sizeof (h[0]), - /* align */ sizeof (uword)); - clib_memset (v + l * elt_bytes, ~0, dl * elt_bytes); - } - } - - *result = i; - - return v; -} - -static uword -qhash_unset_overflow (void *v, uword key, uword bi, uword * n_elts) -{ - qhash_t *h = qhash_header (v); - uword *p = hash_get (h->overflow_hash, key); - uword result; - - bi /= QHASH_KEYS_PER_BUCKET; - - if (p) - { - result = p[0]; - hash_unset (h->overflow_hash, key); - ASSERT (bi < vec_len (h->overflow_counts)); - ASSERT (h->overflow_counts[bi] > 0); - ASSERT (*n_elts > 0); - vec_add1 (h->overflow_free_indices, result); - h->overflow_counts[bi] -= 1; - *n_elts -= 1; - } - else - result = ~0; - - return result; -} - -always_inline uword -qhash_find_free (uword i, uword valid_mask) -{ - return first_set (~valid_mask & pow2_mask (QHASH_KEYS_PER_BUCKET)); -} - -void * -_qhash_set_multiple (void *v, - uword elt_bytes, - uword * search_keys, - uword n_search_keys, u32 * result_indices) -{ - qhash_t *h = qhash_header (v); - uword *k, *hash_keys; - uword n_left, n_elts, bucket_mask; - u32 *r; - - if (vec_len (v) < n_search_keys) - v = _qhash_resize (v, n_search_keys, elt_bytes); - - if (qhash_min_log2 (2) != 1) - { - qhash_min_log2_init (); - ASSERT (qhash_min_log2 (2) == 1); - } - - ASSERT (v != 0); - - bucket_mask = pow2_mask (h->log2_hash_size) & ~(QHASH_KEYS_PER_BUCKET - 1); - - hash_keys = h->hash_keys; - k = search_keys; - r = result_indices; - n_left = n_search_keys; - n_elts = h->n_elts; - - while (n_left >= 2) - { - u32 a0, b0, c0, bi0, match0, valid0, free0; - u32 a1, b1, c1, bi1, match1, valid1, free1; - uword k0, *h0; - uword k1, *h1; - - k0 = k[0]; - k1 = k[1]; - - /* Keys must be unique. */ - ASSERT (k0 != k1); - - n_left -= 2; - k += 2; - - a0 = a1 = h->hash_seeds[0]; - b0 = b1 = h->hash_seeds[1]; - c0 = c1 = h->hash_seeds[2]; - a0 ^= k0; - a1 ^= k1; -#if uword_bits == 64 - b0 ^= k0 >> 32; - b1 ^= k1 >> 32; -#endif - - hash_mix32_step_1 (a0, b0, c0); - hash_mix32_step_1 (a1, b1, c1); - hash_mix32_step_2 (a0, b0, c0); - hash_mix32_step_2 (a1, b1, c1); - hash_mix32_step_3 (a0, b0, c0); - hash_mix32_step_3 (a1, b1, c1); - - bi0 = c0 & bucket_mask; - bi1 = c1 & bucket_mask; - - h0 = hash_keys + bi0; - h1 = hash_keys + bi1; - - /* Search two buckets. */ - valid0 = qhash_get_valid_elt_mask (h, bi0); - valid1 = qhash_get_valid_elt_mask (h, bi1); - - match0 = qhash_search_bucket (h0, k0, valid0); - match1 = qhash_search_bucket (h1, k1, valid1); - - /* Find first free element starting at hash offset into bucket. */ - free0 = qhash_find_free (c0 & (QHASH_KEYS_PER_BUCKET - 1), valid0); - - valid1 = valid1 | (bi0 == bi1 ? free0 : 0); - free1 = qhash_find_free (c1 & (QHASH_KEYS_PER_BUCKET - 1), valid1); - - n_elts += (match0 == 0) + (match1 == 0); - - match0 = match0 ? match0 : free0; - match1 = match1 ? match1 : free1; - - valid0 |= match0; - valid1 |= match1; - - h0 += qhash_min_log2 (match0); - h1 += qhash_min_log2 (match1); - - if (PREDICT_FALSE (!match0 || !match1)) - goto slow_path2; - - h0[0] = k0; - h1[0] = k1; - r[0] = h0 - hash_keys; - r[1] = h1 - hash_keys; - r += 2; - qhash_set_valid_elt_mask (h, bi0, valid0); - qhash_set_valid_elt_mask (h, bi1, valid1); - continue; - - slow_path2: - if (!match0) - { - n_elts -= 1; - v = qhash_set_overflow (v, elt_bytes, k0, bi0, &n_elts, &r[0]); - } - else - { - h0[0] = k0; - r[0] = h0 - hash_keys; - qhash_set_valid_elt_mask (h, bi0, valid0); - } - if (!match1) - { - n_elts -= 1; - v = qhash_set_overflow (v, elt_bytes, k1, bi1, &n_elts, &r[1]); - } - else - { - h1[0] = k1; - r[1] = h1 - hash_keys; - qhash_set_valid_elt_mask (h, bi1, valid1); - } - r += 2; - } - - while (n_left >= 1) - { - u32 a0, b0, c0, bi0, match0, valid0, free0; - uword k0, *h0; - - k0 = k[0]; - n_left -= 1; - k += 1; - - a0 = h->hash_seeds[0]; - b0 = h->hash_seeds[1]; - c0 = h->hash_seeds[2]; - a0 ^= k0; -#if uword_bits == 64 - b0 ^= k0 >> 32; -#endif - - hash_mix32 (a0, b0, c0); - - bi0 = c0 & bucket_mask; - - h0 = hash_keys + bi0; - - valid0 = qhash_get_valid_elt_mask (h, bi0); - - /* Find first free element starting at hash offset into bucket. */ - free0 = qhash_find_free (c0 & (QHASH_KEYS_PER_BUCKET - 1), valid0); - - match0 = qhash_search_bucket (h0, k0, valid0); - - n_elts += (match0 == 0); - - match0 = match0 ? match0 : free0; - - valid0 |= match0; - - h0 += qhash_min_log2 (match0); - - if (PREDICT_FALSE (!match0)) - goto slow_path1; - - h0[0] = k0; - r[0] = h0 - hash_keys; - r += 1; - qhash_set_valid_elt_mask (h, bi0, valid0); - continue; - - slow_path1: - n_elts -= 1; - v = qhash_set_overflow (v, elt_bytes, k0, bi0, &n_elts, &r[0]); - r += 1; - } - - h = qhash_header (v); - h->n_elts = n_elts; - - return v; -} - -static uword -unset_slow_path (void *v, uword elt_bytes, - uword k0, uword bi0, uword valid0, uword match0, - uword * n_elts) -{ - qhash_t *h = qhash_header (v); - uword i, j = 0, k, l, t = ~0; - hash_pair_t *p, *found; - - if (!match0) - { - if (valid0 == QHASH_ALL_VALID) - t = qhash_unset_overflow (v, k0, bi0, n_elts); - return t; - } - - i = bi0 / QHASH_KEYS_PER_BUCKET; - t = bi0 + qhash_min_log2 (match0); - - if (valid0 == QHASH_ALL_VALID - && i < vec_len (h->overflow_counts) && h->overflow_counts[i] > 0) - { - found = 0; - /* *INDENT-OFF* */ - hash_foreach_pair (p, h->overflow_hash, ({ - j = qhash_hash_mix (h, p->key) / QHASH_KEYS_PER_BUCKET; - if (j == i) - { - found = p; - break; - } - })); - /* *INDENT-ON* */ - ASSERT (found != 0); - ASSERT (j == i); - - l = found->value[0]; - k = found->key; - hash_unset3 (h->overflow_hash, k, &j); - vec_add1 (h->overflow_free_indices, j); - h->overflow_counts[i] -= 1; - - qhash_set_valid_elt_mask (h, bi0, valid0); - - h->hash_keys[t] = k; - clib_memswap (v + t * elt_bytes, v + l * elt_bytes, elt_bytes); - t = l; - } - else - qhash_set_valid_elt_mask (h, bi0, valid0 ^ match0); - - return t; -} - -void -_qhash_unset_multiple (void *v, - uword elt_bytes, - uword * search_keys, - uword n_search_keys, u32 * result_indices) -{ - qhash_t *h = qhash_header (v); - uword *k, *hash_keys; - uword n_left, n_elts, bucket_mask; - u32 *r; - - if (!v) - { - uword i; - for (i = 0; i < n_search_keys; i++) - result_indices[i] = ~0; - } - - bucket_mask = pow2_mask (h->log2_hash_size) & ~(QHASH_KEYS_PER_BUCKET - 1); - - hash_keys = h->hash_keys; - k = search_keys; - r = result_indices; - n_left = n_search_keys; - n_elts = h->n_elts; - - while (n_left >= 2) - { - u32 a0, b0, c0, bi0, match0, valid0; - u32 a1, b1, c1, bi1, match1, valid1; - uword k0, *h0; - uword k1, *h1; - - k0 = k[0]; - k1 = k[1]; - - /* Keys must be unique. */ - ASSERT (k0 != k1); - - n_left -= 2; - k += 2; - - a0 = a1 = h->hash_seeds[0]; - b0 = b1 = h->hash_seeds[1]; - c0 = c1 = h->hash_seeds[2]; - a0 ^= k0; - a1 ^= k1; -#if uword_bits == 64 - b0 ^= k0 >> 32; - b1 ^= k1 >> 32; -#endif - - hash_mix32_step_1 (a0, b0, c0); - hash_mix32_step_1 (a1, b1, c1); - hash_mix32_step_2 (a0, b0, c0); - hash_mix32_step_2 (a1, b1, c1); - hash_mix32_step_3 (a0, b0, c0); - hash_mix32_step_3 (a1, b1, c1); - - bi0 = c0 & bucket_mask; - bi1 = c1 & bucket_mask; - - h0 = hash_keys + bi0; - h1 = hash_keys + bi1; - - /* Search two buckets. */ - valid0 = qhash_get_valid_elt_mask (h, bi0); - valid1 = qhash_get_valid_elt_mask (h, bi1); - - match0 = qhash_search_bucket (h0, k0, valid0); - match1 = qhash_search_bucket (h1, k1, valid1); - - n_elts -= (match0 != 0) + (match1 != 0); - - if (PREDICT_FALSE (valid0 == QHASH_ALL_VALID - || valid1 == QHASH_ALL_VALID)) - goto slow_path2; - - valid0 ^= match0; - qhash_set_valid_elt_mask (h, bi0, valid0); - - valid1 = bi0 == bi1 ? valid0 : valid1; - valid1 ^= match1; - - qhash_set_valid_elt_mask (h, bi1, valid1); - - r[0] = match0 ? bi0 + qhash_min_log2 (match0) : ~0; - r[1] = match1 ? bi1 + qhash_min_log2 (match1) : ~0; - r += 2; - continue; - - slow_path2: - r[0] = unset_slow_path (v, elt_bytes, k0, bi0, valid0, match0, &n_elts); - if (bi0 == bi1) - { - /* Search again in same bucket to test new overflow element. */ - valid1 = qhash_get_valid_elt_mask (h, bi0); - if (!match1) - { - match1 = qhash_search_bucket (h1, k1, valid1); - n_elts -= (match1 != 0); - } - } - r[1] = unset_slow_path (v, elt_bytes, k1, bi1, valid1, match1, &n_elts); - r += 2; - } - - while (n_left >= 1) - { - u32 a0, b0, c0, bi0, match0, valid0; - uword k0, *h0; - - k0 = k[0]; - n_left -= 1; - k += 1; - - a0 = h->hash_seeds[0]; - b0 = h->hash_seeds[1]; - c0 = h->hash_seeds[2]; - a0 ^= k0; -#if uword_bits == 64 - b0 ^= k0 >> 32; -#endif - - hash_mix32 (a0, b0, c0); - - bi0 = c0 & bucket_mask; - - h0 = hash_keys + bi0; - - valid0 = qhash_get_valid_elt_mask (h, bi0); - - match0 = qhash_search_bucket (h0, k0, valid0); - n_elts -= (match0 != 0); - qhash_set_valid_elt_mask (h, bi0, valid0 ^ match0); - - r[0] = match0 ? bi0 + qhash_min_log2 (match0) : ~0; - r += 1; - - if (PREDICT_FALSE (valid0 == QHASH_ALL_VALID)) - r[-1] = unset_slow_path (v, elt_bytes, k0, bi0, valid0, match0, - &n_elts); - } - - h->n_elts = n_elts; -} - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/qhash.h b/src/vppinfra/qhash.h deleted file mode 100644 index 9dbbd971ade..00000000000 --- a/src/vppinfra/qhash.h +++ /dev/null @@ -1,169 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2006 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#ifndef included_qhash_h -#define included_qhash_h - -#include <vppinfra/cache.h> -#include <vppinfra/hash.h> - -/* Word hash tables. */ -typedef struct -{ - /* Number of elements in hash. */ - u32 n_elts; - - u32 log2_hash_size; - - /* Jenkins hash seeds. */ - u32 hash_seeds[3]; - - /* Fall back CLIB hash for overflow in fixed sized buckets. */ - uword *overflow_hash; - - u32 *overflow_counts, *overflow_free_indices; - - u8 *hash_key_valid_bitmap; - - uword *hash_keys; -} qhash_t; - -always_inline qhash_t * -qhash_header (void *v) -{ - return vec_header (v, sizeof (qhash_t)); -} - -always_inline uword -qhash_elts (void *v) -{ - return v ? qhash_header (v)->n_elts : 0; -} - -always_inline uword -qhash_n_overflow (void *v) -{ - return v ? hash_elts (qhash_header (v)->overflow_hash) : 0; -} - -#define QHASH_LOG2_KEYS_PER_BUCKET 2 -#define QHASH_KEYS_PER_BUCKET (1 << QHASH_LOG2_KEYS_PER_BUCKET) - -always_inline uword -qhash_hash_mix (qhash_t * h, uword key) -{ - u32 a, b, c; - - a = h->hash_seeds[0]; - b = h->hash_seeds[1]; - c = h->hash_seeds[2]; - - a ^= key; -#if uword_bits == 64 - b ^= key >> 32; -#endif - - hash_mix32 (a, b, c); - - return c & pow2_mask (h->log2_hash_size); -} - -#define qhash_resize(v,n) (v) = _qhash_resize ((v), (n), sizeof ((v)[0])) - -#define qhash_foreach(var,v,body) - -#define qhash_set_multiple(v,keys,n,results) \ - (v) = _qhash_set_multiple ((v), sizeof ((v)[0]), (keys), (n), (results)) - -#define qhash_unset_multiple(v,keys,n,results) \ - _qhash_unset_multiple ((v), sizeof ((v)[0]), (keys), (n), (results)) - -#define qhash_get(v,key) \ -({ \ - uword _qhash_get_k = (key); \ - qhash_get_first_match ((v), &_qhash_get_k, 1, &_qhash_get_k); \ -}) - -#define qhash_set(v,k) \ -({ \ - uword _qhash_set_k = (k); \ - qhash_set_multiple ((v), &_qhash_set_k, 1, &_qhash_set_k); \ - _qhash_set_k; \ -}) - -#define qhash_unset(v,k) \ -({ \ - uword _qhash_unset_k = (k); \ - qhash_unset_multiple ((v), &_qhash_unset_k, 1, &_qhash_unset_k); \ - _qhash_unset_k; \ -}) - -void *_qhash_resize (void *v, uword length, uword elt_bytes); - -/* Lookup multiple keys in the same hash table. */ -void -qhash_get_multiple (void *v, - uword * search_keys, - uword n_search_keys, u32 * result_indices); - -/* Lookup multiple keys in the same hash table. - Returns index of first matching key. */ -u32 -qhash_get_first_match (void *v, - uword * search_keys, - uword n_search_keys, uword * matching_key); - -/* Set/unset helper functions. */ -void *_qhash_set_multiple (void *v, - uword elt_bytes, - uword * search_keys, - uword n_search_keys, u32 * result_indices); -void -_qhash_unset_multiple (void *v, - uword elt_bytes, - uword * search_keys, - uword n_search_keys, u32 * result_indices); - -#endif /* included_qhash_h */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/slist.c b/src/vppinfra/slist.c deleted file mode 100644 index 5598871c884..00000000000 --- a/src/vppinfra/slist.c +++ /dev/null @@ -1,336 +0,0 @@ -/* - Copyright (c) 2012 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 <vppinfra/slist.h> - -/* - * skip-list implementation - * - * Good news / bad news. As balanced binary tree schemes go, - * this one seems pretty fast and is reasonably simple. There's a very - * limited amount that can be done to mitigate sdram read latency. - * - * Each active clib_slist_elt_t is on from 1 to N lists. Each active element - * is always on the "level-0" list. Since most elements are *only* on - * level 0, we keep the level 0 (and level 1) in the element. For those - * elements on more than two lists, we switch to a vector. Hence, the - * "n" union in slib_slist_elt_t. - * - * The low-order bit of elt->n.next0[0] is 1 for inlined next indices, - * 0 for vector indices (since the allocator always aligns to at least - * a 4-byte boundary). We can only represent 2e9 items, but since the - * practical performance limit is O(1e7), it doesn't matter. - * - * We create a "head" element which (by construction) is always - * lexically lighter than any other element. This makes a large number - * of irritating special cases go away. - * - * User code is in charge of comparing a supplied key with - * the key component of a user pool element. The user tells this code - * to add or delete (opaque key, 32-bit integer) pairs to the skip-list. - * - * The algorithm adds new elements to one or more lists. - * For levels greater than zero, the probability of a new element landing on - * a list is branching_factor**N. Branching_factor = 0.2 seems to work - * OK, yielding about 50 compares per search at O(1e7) items. - */ - -clib_error_t * -clib_slist_init (clib_slist_t * sp, f64 branching_factor, - clib_slist_key_compare_function_t compare, - format_function_t format_user_element) -{ - clib_slist_elt_t *head; - clib_memset (sp, 0, sizeof (sp[0])); - sp->branching_factor = branching_factor; - sp->format_user_element = format_user_element; - sp->compare = compare; - sp->seed = 0xdeaddabe; - pool_get (sp->elts, head); - vec_add1 (head->n.nexts, (u32) ~ 0); - head->user_pool_index = (u32) ~ 0; - vec_validate (sp->path, 1); - vec_validate (sp->occupancy, 0); - - return 0; -} - -/* - * slist_search_internal - */ -static inline clib_slist_search_result_t -slist_search_internal (clib_slist_t * sp, void *key, int need_full_path) -{ - int level, comp_result; - clib_slist_elt_t *search_elt, *head_elt; - - sp->ncompares = 0; - /* - * index 0 is the magic listhead element which is - * lexically lighter than / to the left of every element - */ - search_elt = head_elt = pool_elt_at_index (sp->elts, 0); - - /* - * Initial negotiating position, only the head_elt is - * lighter than the supplied key - */ - clib_memset (sp->path, 0, vec_len (head_elt->n.nexts) * sizeof (u32)); - - /* Walk the fastest lane first */ - level = vec_len (head_elt->n.nexts) - 1; - _vec_len (sp->path) = level + 1; - - while (1) - { - u32 next_index_this_level; - clib_slist_elt_t *prefetch_elt; - - /* - * Prefetching the next element at this level makes a measurable - * difference, but doesn't fix the dependent read stall problem - */ - prefetch_elt = sp->elts + - clib_slist_get_next_at_level (search_elt, level); - - CLIB_PREFETCH (prefetch_elt, CLIB_CACHE_LINE_BYTES, READ); - - /* Compare the key with the current element */ - comp_result = (search_elt == head_elt) ? 1 : - sp->compare (key, search_elt->user_pool_index); - - sp->ncompares++; - /* key "lighter" than this element */ - if (comp_result < 0) - { - /* - * Back up to previous item on this list - * and search the next finer-grained list - * starting there. - */ - search_elt = pool_elt_at_index (sp->elts, sp->path[level]); - next_list: - if (level > 0) - { - level--; - continue; - } - else - { - return CLIB_SLIST_NO_MATCH; - } - } - /* Match */ - if (comp_result == 0) - { - /* - * If we're trying to delete an element, we need to - * track down all of the elements which point at it. - * Otherwise, don't bother with it - */ - if (need_full_path && level > 0) - { - search_elt = pool_elt_at_index (sp->elts, sp->path[level]); - level--; - continue; - } - level = vec_len (head_elt->n.nexts); - sp->path[level] = search_elt - sp->elts; - _vec_len (sp->path) = level + 1; - return CLIB_SLIST_MATCH; - } - /* - * comp_result positive, key is to the right of - * this element - */ - sp->path[level] = search_elt - sp->elts; - - /* Out of list at this level? */ - next_index_this_level = - clib_slist_get_next_at_level (search_elt, level); - if (next_index_this_level == (u32) ~ 0) - goto next_list; - - /* No, try the next element */ - search_elt = pool_elt_at_index (sp->elts, next_index_this_level); - } - return 0; /* notreached */ -} - -u32 -clib_slist_search (clib_slist_t * sp, void *key, u32 * ncompares) -{ - clib_slist_search_result_t rv; - - rv = slist_search_internal (sp, key, 0 /* dont need full path */ ); - if (rv == CLIB_SLIST_MATCH) - { - clib_slist_elt_t *elt; - elt = pool_elt_at_index (sp->elts, sp->path[vec_len (sp->path) - 1]); - if (ncompares) - *ncompares = sp->ncompares; - return elt->user_pool_index; - } - return (u32) ~ 0; -} - -void -clib_slist_add (clib_slist_t * sp, void *key, u32 user_pool_index) -{ - clib_slist_elt_t *new_elt; - clib_slist_search_result_t search_result; - int level; - - search_result = slist_search_internal (sp, key, - 0 /* don't need full path */ ); - - /* Special case: key exists, just replace user_pool_index */ - if (PREDICT_FALSE (search_result == CLIB_SLIST_MATCH)) - { - clib_slist_elt_t *elt; - elt = pool_elt_at_index (sp->elts, sp->path[0]); - elt->user_pool_index = user_pool_index; - return; - } - - pool_get (sp->elts, new_elt); - new_elt->n.nexts = 0; - new_elt->user_pool_index = user_pool_index; - - /* sp->path lists elements to the left of key, by level */ - for (level = 0; level < vec_len (sp->path); level++) - { - clib_slist_elt_t *prev_elt_this_level; - u32 prev_elt_next_index_this_level; - - /* Add to list at the current level */ - prev_elt_this_level = pool_elt_at_index (sp->elts, sp->path[level]); - prev_elt_next_index_this_level = clib_slist_get_next_at_level - (prev_elt_this_level, level); - - clib_slist_set_next_at_level (new_elt, prev_elt_next_index_this_level, - level); - - clib_slist_set_next_at_level (prev_elt_this_level, new_elt - sp->elts, - level); - sp->occupancy[level]++; - - /* Randomly add to the next-higher level */ - if (random_f64 (&sp->seed) > sp->branching_factor) - break; - } - { - /* Time to add a new ply? */ - clib_slist_elt_t *head_elt = pool_elt_at_index (sp->elts, 0); - int top_level = vec_len (head_elt->n.nexts) - 1; - if (((f64) sp->occupancy[top_level]) * sp->branching_factor > 1.0) - { - vec_add1 (sp->occupancy, 0); - vec_add1 (head_elt->n.nexts, (u32) ~ 0); - /* full match case returns n+1 items */ - vec_validate (sp->path, vec_len (head_elt->n.nexts)); - } - } -} - -clib_slist_search_result_t -clib_slist_del (clib_slist_t * sp, void *key) -{ - clib_slist_search_result_t search_result; - clib_slist_elt_t *del_elt; - int level; - - search_result = slist_search_internal (sp, key, 1 /* need full path */ ); - - if (PREDICT_FALSE (search_result == CLIB_SLIST_NO_MATCH)) - return search_result; - - del_elt = pool_elt_at_index (sp->elts, sp->path[vec_len (sp->path) - 1]); - ASSERT (vec_len (sp->path) > 1); - - for (level = 0; level < vec_len (sp->path) - 1; level++) - { - clib_slist_elt_t *path_elt; - u32 path_elt_next_index; - - path_elt = pool_elt_at_index (sp->elts, sp->path[level]); - path_elt_next_index = clib_slist_get_next_at_level (path_elt, level); - - /* Splice the item out of the list if it's adjacent to the victim */ - if (path_elt_next_index == del_elt - sp->elts) - { - sp->occupancy[level]--; - path_elt_next_index = clib_slist_get_next_at_level (del_elt, level); - clib_slist_set_next_at_level (path_elt, path_elt_next_index, level); - } - } - - /* If this element is on more than two lists it has a vector of nexts */ - if (!(del_elt->n.next0[0] & 1)) - vec_free (del_elt->n.nexts); - pool_put (sp->elts, del_elt); - return CLIB_SLIST_MATCH; -} - -u8 * -format_slist (u8 * s, va_list * args) -{ - clib_slist_t *sl = va_arg (*args, clib_slist_t *); - int verbose = va_arg (*args, int); - int i; - clib_slist_elt_t *head_elt, *elt; - - s = format (s, "slist 0x%x, %u items, branching_factor %.2f\n", sl, - sl->occupancy ? sl->occupancy[0] : 0, sl->branching_factor); - - if (pool_elts (sl->elts) == 0) - return s; - - head_elt = pool_elt_at_index (sl->elts, 0); - - for (i = 0; i < vec_len (head_elt->n.nexts); i++) - { - s = format (s, "level %d: %d elts\n", i, - sl->occupancy ? sl->occupancy[i] : 0); - - if (verbose && head_elt->n.nexts[i] != (u32) ~ 0) - { - elt = pool_elt_at_index (sl->elts, head_elt->n.nexts[i]); - while (elt) - { - u32 next_index; - s = format (s, "%U(%d) ", sl->format_user_element, - elt->user_pool_index, elt - sl->elts); - next_index = clib_slist_get_next_at_level (elt, i); - ASSERT (next_index != 0x7fffffff); - if (next_index == (u32) ~ 0) - break; - else - elt = pool_elt_at_index (sl->elts, next_index); - } - } - s = format (s, "\n"); - } - return s; -} - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/slist.h b/src/vppinfra/slist.h deleted file mode 100644 index a7c77e27c96..00000000000 --- a/src/vppinfra/slist.h +++ /dev/null @@ -1,145 +0,0 @@ -/* - Copyright (c) 2012 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. -*/ - -#ifndef included_slist_h -#define included_slist_h - -#include <stdarg.h> -#include <vppinfra/clib.h> -#include <vppinfra/vec.h> -#include <vppinfra/pool.h> -#include <vppinfra/error.h> -#include <vppinfra/format.h> -#include <vppinfra/cache.h> - -typedef word (clib_slist_key_compare_function_t) - (void *key, u32 elt_pool_index); - -typedef enum -{ - CLIB_SLIST_MATCH = 0, - CLIB_SLIST_NO_MATCH -} clib_slist_search_result_t; - -typedef struct -{ - /* Vector of next elements. Every valid instance has at least one */ - union - { - u32 next0[2]; - u32 *nexts; - } n; - - /* Index of item in user's pool */ - u32 user_pool_index; - /* $$$ pad to even divisor of cache line */ -} clib_slist_elt_t; - -static inline u32 -clib_slist_get_next_at_level (clib_slist_elt_t * elt, int level) -{ - if (elt->n.next0[0] & 1) - { - ASSERT (level < 2); - if (level == 1) - return elt->n.next0[1]; - /* preserve ~0 (end of list) */ - return (elt->n.next0[0] == (u32) ~ 0) ? elt->n.next0[0] : - (elt->n.next0[0] >> 1); - } - else - { - ASSERT (level < vec_len (elt->n.nexts)); - return elt->n.nexts[level]; - } -} - -static inline void -clib_slist_set_next_at_level (clib_slist_elt_t * elt, u32 index, int level) -{ - u32 old_level0_value[2]; - /* level0 and not a vector */ - if (level < 2 && (elt->n.next0[0] == 0 || elt->n.next0[0] & 1)) - { - if (level == 0) - { - elt->n.next0[0] = (index << 1) | 1; - return; - } - elt->n.next0[1] = index; - return; - } - /* have to save old level0 values? */ - if (elt->n.next0[0] & 1) - { - old_level0_value[0] = (elt->n.next0[0] == (u32) ~ 0) ? - elt->n.next0[0] : elt->n.next0[0] >> 1; - old_level0_value[1] = elt->n.next0[1]; - elt->n.nexts = 0; - vec_add1 (elt->n.nexts, old_level0_value[0]); - vec_add1 (elt->n.nexts, old_level0_value[1]); - } - vec_validate (elt->n.nexts, level); - elt->n.nexts[level] = index; -} - - -typedef struct -{ - /* pool of skip-list elements */ - clib_slist_elt_t *elts; - - /* last search path */ - u32 *path; - - /* last search number of compares */ - u32 ncompares; - - /* occupancy stats */ - u32 *occupancy; - - /* Comparison function */ - clib_slist_key_compare_function_t *compare; - - /* Format function */ - format_function_t *format_user_element; - - /* items appear in successive plies with Pr (1 / branching_factor) */ - f64 branching_factor; - - /* random seed */ - u32 seed; -} clib_slist_t; - -clib_error_t *clib_slist_init (clib_slist_t * sp, f64 branching_factor, - clib_slist_key_compare_function_t compare, - format_function_t format_user_element); - -format_function_t format_slist; - -void clib_slist_add (clib_slist_t * sp, void *key, u32 user_pool_index); -clib_slist_search_result_t clib_slist_del (clib_slist_t * sp, void *key); -u32 clib_slist_search (clib_slist_t * sp, void *key, u32 * ncompares); - -#endif /* included_slist_h */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/test_cuckoo_bihash.c b/src/vppinfra/test_cuckoo_bihash.c deleted file mode 100644 index e992e26fa7d..00000000000 --- a/src/vppinfra/test_cuckoo_bihash.c +++ /dev/null @@ -1,451 +0,0 @@ -/* - * Copyright (c) 2017 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. - */ - -__thread int thread_id = 0; - -#include <vppinfra/time.h> -#include <vppinfra/cache.h> -#include <vppinfra/error.h> -#include <vppinfra/heap.h> -#include <vppinfra/format.h> -#include <vppinfra/pool.h> -#include <vppinfra/error.h> -#include <vppinfra/hash.h> -#include <vppinfra/cache.h> - -#define os_get_cpu_number() (thread_id) - -#include <vppinfra/cuckoo_8_8.h> -#include <vppinfra/cuckoo_template.h> -#include <vppinfra/cuckoo_template.c> - -#include <vppinfra/bihash_8_8.h> -#include <vppinfra/bihash_template.h> -#include <vppinfra/bihash_template.c> - -#include <pthread.h> - -#define MAX_THREADS 255 - -typedef struct -{ - void *tm; - int thread_idx; - u64 nlookups; -} thread_data_t; - -typedef struct -{ - u64 deadline; - u64 seed; - u32 nbuckets; - u32 nitems; - u32 runtime; - int verbose; - int non_random_keys; - int nthreads; - int search_iter; - uword *key_hash; - u64 *keys; - CVT (clib_cuckoo) ch; - BVT (clib_bihash) bh; - clib_time_t clib_time; - u64 *key_add_del_sequence; - u8 *key_op_sequence; - u64 *key_search_sequence[MAX_THREADS]; - unformat_input_t *input; - u64 nadds; - u64 ndels; - pthread_t bwriter_thread; - pthread_t breader_threads[MAX_THREADS]; - pthread_t cwriter_thread; - pthread_t creader_threads[MAX_THREADS]; - thread_data_t wthread_data; - thread_data_t rthread_data[MAX_THREADS]; -} test_main_t; - -test_main_t test_main; - -uword -vl (void *v) -{ - return vec_len (v); -} - -#define w_thread(x, guts) \ - void *x##writer_thread (void *v) \ - { \ - test_main_t *tm = v; \ - uword counter = 0; \ - u64 nadds = 0; \ - u64 ndels = 0; \ - u64 deadline = tm->deadline; \ - do \ - { \ - for (counter = 0; counter < vec_len (tm->key_add_del_sequence); \ - ++counter) \ - { \ - u64 idx = tm->key_add_del_sequence[counter]; \ - u8 op = tm->key_op_sequence[counter]; \ - if (op) \ - { \ - ++nadds; \ - } \ - else \ - { \ - ++ndels; \ - } \ - guts; \ - if (clib_cpu_time_now () > deadline) \ - { \ - break; \ - } \ - } \ - } \ - while (clib_cpu_time_now () < deadline); \ - tm->nadds = nadds; \ - tm->ndels = ndels; \ - return NULL; \ - } - -/* *INDENT-OFF* */ -w_thread (b, { - BVT (clib_bihash_kv) kv; - kv.key = tm->keys[idx]; - kv.value = *hash_get (tm->key_hash, kv.key); - BV (clib_bihash_add_del) (&tm->bh, &kv, op); -}); -/* *INDENT-ON* */ - -/* *INDENT-OFF* */ -w_thread (c, { - CVT (clib_cuckoo_kv) kv; - kv.key = tm->keys[idx]; - kv.value = *hash_get (tm->key_hash, kv.key); - CV (clib_cuckoo_add_del) (&tm->ch, &kv, op, 0); -}); -/* *INDENT-ON* */ - -#define r_thread(x, guts) \ - void *x##reader_thread (void *v) \ - { \ - thread_data_t *data = v; \ - thread_id = data->thread_idx; \ - test_main_t *tm = data->tm; \ - uword thread_idx = data->thread_idx; \ - u64 *idx; \ - uword nlookups = 0; \ - u64 deadline = tm->deadline; \ - do \ - { \ - vec_foreach (idx, tm->key_search_sequence[thread_idx]) \ - { \ - guts; \ - ++nlookups; \ - if (clib_cpu_time_now () > deadline) \ - { \ - break; \ - } \ - } \ - } \ - while (clib_cpu_time_now () < deadline); \ - data->nlookups = nlookups; \ - return NULL; \ - } - -/* *INDENT-OFF* */ -r_thread (c, { - CVT (clib_cuckoo_kv) kv; - kv.key = tm->keys[*idx]; - kv.value = *hash_get (tm->key_hash, kv.key); - CV (clib_cuckoo_search) (&tm->ch, &kv, &kv); -}); -/* *INDENT-ON* */ - -/* *INDENT-OFF* */ -r_thread (b, { - BVT (clib_bihash_kv) kv; - kv.key = tm->keys[*idx]; - kv.value = *hash_get (tm->key_hash, kv.key); - BV (clib_bihash_search) (&tm->bh, &kv, &kv); -}); -/* *INDENT-ON* */ - -#define run_threads(x) \ - do \ - { \ - \ - before = clib_time_now (&tm->clib_time); \ - tm->deadline = clib_cpu_time_now () + \ - tm->runtime * tm->clib_time.clocks_per_second; \ - fformat (stdout, #x "-> Start threads..., runtime is %llu second(s)\n", \ - (long long unsigned)tm->runtime); \ - \ - /* \ - fformat (stdout, #x "-> Writer thread only...\n"); \ - if (0 != \ - pthread_create (&tm->x##writer_thread, NULL, x##writer_thread, tm)) \ - { \ - perror ("pthread_create()"); \ - abort (); \ - } \ - \ - if (0 != pthread_join (tm->x##writer_thread, NULL)) \ - { \ - perror ("pthread_join()"); \ - abort (); \ - } \ - \ - delta = clib_time_now (&tm->clib_time) - before; \ - fformat (stdout, #x "-> %wu adds, %wu dels in %.6f seconds\n", \ - tm->nadds, tm->ndels, delta); \ - tm->nadds = 0; \ - tm->ndels = 0; \ - */ \ - \ - fformat (stdout, #x "-> Writer + %d readers\n", tm->nthreads); \ - before = clib_time_now (&tm->clib_time); \ - tm->deadline = clib_cpu_time_now () + \ - tm->runtime * tm->clib_time.clocks_per_second; \ - if (0 != \ - pthread_create (&tm->x##writer_thread, NULL, x##writer_thread, tm)) \ - { \ - perror ("pthread_create()"); \ - abort (); \ - } \ - \ - for (i = 0; i < tm->nthreads; i++) \ - { \ - tm->rthread_data[i].nlookups = 0; \ - if (0 != pthread_create (&tm->x##reader_threads[i], NULL, \ - x##reader_thread, &tm->rthread_data[i])) \ - { \ - perror ("pthread_create()"); \ - abort (); \ - } \ - } \ - \ - if (0 != pthread_join (tm->x##writer_thread, NULL)) \ - { \ - perror ("pthread_join()"); \ - abort (); \ - } \ - \ - for (i = 0; i < tm->nthreads; i++) \ - { \ - if (0 != pthread_join (tm->x##reader_threads[i], NULL)) \ - { \ - perror ("pthread_join()"); \ - abort (); \ - } \ - } \ - \ - delta = clib_time_now (&tm->clib_time) - before; \ - \ - total_searches = 0; \ - for (i = 0; i < tm->nthreads; ++i) \ - { \ - u64 nlookups = tm->rthread_data[i].nlookups; \ - fformat (stdout, #x "-> Thread #%d: %u searches\n", i, nlookups); \ - total_searches += nlookups; \ - } \ - \ - if (delta > 0) \ - { \ - ops = (tm->nadds + tm->ndels) / (f64)delta; \ - fformat (stdout, #x "-> %.f add/dels per second\n", ops); \ - sps = ((f64)total_searches) / delta; \ - fformat (stdout, #x "-> %.f searches per second\n", sps); \ - } \ - \ - fformat (stdout, \ - #x "-> %wu adds, %wu dels, %lld searches in %.6f seconds\n", \ - tm->nadds, tm->ndels, total_searches, delta); \ - } \ - while (0); - -static void -cb (CVT (clib_cuckoo) * h, void *ctx) -{ - fformat (stdout, "Garbage callback called...\n"); -} - -static clib_error_t * -test_cuckoo_bihash (test_main_t * tm) -{ - int i; - uword *p; - uword total_searches; - f64 before, delta; - f64 ops = 0, sps = 0; - f64 bops = 0, bsps = 0; - f64 cops = 0, csps = 0; - CVT (clib_cuckoo) * ch; - BVT (clib_bihash) * bh; - - ch = &tm->ch; - bh = &tm->bh; - - CV (clib_cuckoo_init) (ch, "test", 1, cb, NULL); - BV (clib_bihash_init) (bh, (char *) "test", tm->nbuckets, 256 << 20); - - fformat (stdout, "Pick %lld unique %s keys...\n", tm->nitems, - tm->non_random_keys ? "non-random" : "random"); - - for (i = 0; i < tm->nitems; i++) - { - u64 rndkey; - - if (tm->non_random_keys == 0) - { - - again: - rndkey = random_u64 (&tm->seed); - - p = hash_get (tm->key_hash, rndkey); - if (p) - goto again; - } - else - rndkey = (u64) (i + 1) << 16; - - hash_set (tm->key_hash, rndkey, i + 1); - vec_add1 (tm->keys, rndkey); - - int j; - for (j = 0; j < tm->nthreads; ++j) - { - u64 *x = tm->key_search_sequence[j]; - vec_add1 (x, random_u64 (&tm->seed) % tm->nitems); - tm->key_search_sequence[j] = x; - } - vec_add1 (tm->key_add_del_sequence, - random_u64 (&tm->seed) % tm->nitems); - vec_add1 (tm->key_op_sequence, (rndkey % 10 < 8) ? 1 : 0); - } - - int thread_counter = 0; - tm->wthread_data.tm = tm; - tm->wthread_data.thread_idx = thread_counter; - for (i = 0; i < tm->nthreads; ++i) - { - tm->rthread_data[i].tm = tm; - tm->rthread_data[i].thread_idx = thread_counter; - tm->rthread_data[i].nlookups = 0; - ++thread_counter; - } - - int iter; - for (iter = 0; iter < tm->search_iter; ++iter) - { - fformat (stdout, "Bihash test #%d\n", iter); - run_threads (b); - bops = ops; - bsps = sps; - fformat (stdout, "%U", BV (format_bihash), bh, 0); - fformat (stdout, "Cuckoo test #%d\n", iter); - run_threads (c); - cops = ops; - csps = sps; - fformat (stdout, "%U", CV (format_cuckoo), ch, 0); - fformat (stdout, - "Bihash add/del speed is %.2f%% of cuckoo add/del speed\n", - bops / cops * 100); - fformat (stdout, - "Bihash search speed is %.2f%% of cuckoo search speed\n", - bsps / csps * 100); - } - return 0; -} - -clib_error_t * -test_cuckoo_bihash_main (test_main_t * tm) -{ - unformat_input_t *i = tm->input; - clib_error_t *error; - - while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) - { - if (unformat (i, "seed %u", &tm->seed)) - ; - else if (unformat (i, "nbuckets %d", &tm->nbuckets)) - ; - else if (unformat (i, "non-random-keys")) - tm->non_random_keys = 1; - else if (unformat (i, "nitems %d", &tm->nitems)) - ; - else if (unformat (i, "search_iter %d", &tm->search_iter)) - ; - else if (unformat (i, "verbose %d", &tm->verbose)) - ; - else if (unformat (i, "runtime %d", &tm->runtime)) - ; - else if (unformat (i, "nthreads %d", &tm->nthreads)) - ; - else if (unformat (i, "verbose")) - tm->verbose = 1; - else - return clib_error_return (0, "unknown input '%U'", - format_unformat_error, i); - } - - error = test_cuckoo_bihash (tm); - - return error; -} - -#ifdef CLIB_UNIX -int -main (int argc, char *argv[]) -{ - unformat_input_t i; - clib_error_t *error; - test_main_t *tm = &test_main; - clib_memset (&test_main, 0, sizeof (test_main)); - - clib_mem_init (0, 3ULL << 30); - - tm->input = &i; - tm->seed = 0xdeaddabe; - - tm->nbuckets = 2; - tm->nitems = 5; - tm->verbose = 1; - tm->nthreads = 1; - clib_time_init (&tm->clib_time); - tm->runtime = 1; - tm->search_iter = 1; - tm->key_hash = hash_create (0, sizeof (uword)); - - unformat_init_command_line (&i, argv); - error = test_cuckoo_bihash_main (tm); - unformat_free (&i); - - if (error) - { - clib_error_report (error); - return 1; - } - return 0; -} -#endif /* CLIB_UNIX */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/test_cuckoo_template.c b/src/vppinfra/test_cuckoo_template.c deleted file mode 100644 index 9619dc2e802..00000000000 --- a/src/vppinfra/test_cuckoo_template.c +++ /dev/null @@ -1,318 +0,0 @@ -/* - * Copyright (c) 2017 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 <vppinfra/time.h> -#include <vppinfra/cache.h> -#include <vppinfra/error.h> -#include <vppinfra/heap.h> -#include <vppinfra/format.h> -#include <vppinfra/pool.h> -#include <vppinfra/error.h> -#include <vppinfra/hash.h> -#include <vppinfra/cache.h> - -#include <vppinfra/time.h> -#include <vppinfra/cache.h> -#include <vppinfra/error.h> - -#include <vppinfra/cuckoo_8_8.h> -#include <vppinfra/cuckoo_template.h> -#include <vppinfra/cuckoo_template.c> - -typedef struct -{ - u64 seed; - u32 nbuckets; - u32 nitems; - u32 search_iter; - int careful_delete_tests; - int verbose; - int non_random_keys; - uword *key_hash; - u64 *keys; - CVT (clib_cuckoo) hash; - clib_time_t clib_time; - - unformat_input_t *input; - -} test_main_t; - -test_main_t test_main; - -uword -vl (void *v) -{ - return vec_len (v); -} - -void -do_search (test_main_t * tm, CVT (clib_cuckoo) * h) -{ - int i, j; - CVT (clib_cuckoo_kv) kv; - for (j = 0; j < tm->search_iter; j++) - { - for (i = 0; i < tm->nitems; i++) - { - kv.key = tm->keys[i]; - if (CV (clib_cuckoo_search) (h, &kv, &kv) < 0) - if (CV (clib_cuckoo_search) (h, &kv, &kv) < 0) - clib_warning ("[%d] search for key %llu failed unexpectedly\n", - i, tm->keys[i]); - if (kv.value != (u64) (i + 1)) - clib_warning - ("[%d] search for key %llu returned %llu, not %llu\n", i, - tm->keys[i], kv.value, (u64) (i + 1)); - } - } -} - -static void -cb (CVT (clib_cuckoo) * h, void *ctx) -{ - fformat (stdout, "Garbage callback called..."); - if (clib_cpu_time_now () % 3) - { - fformat (stdout, "collecting garbage...\n"); - CV (clib_cuckoo_garbage_collect) (h); - } - else - { - fformat (stdout, "ignoring for now...\n"); - } -} - -static clib_error_t * -test_cuckoo (test_main_t * tm) -{ - int i; - uword *p; - uword total_searches; - f64 before, delta; - CVT (clib_cuckoo) * h; - CVT (clib_cuckoo_kv) kv; - - h = &tm->hash; - - CV (clib_cuckoo_init) (h, "test", tm->nbuckets, cb, NULL); - - fformat (stdout, "Pick %lld unique %s keys...\n", tm->nitems, - tm->non_random_keys ? "non-random" : "random"); - - for (i = 0; i < tm->nitems; i++) - { - u64 rndkey; - - if (tm->non_random_keys == 0) - { - - again: - rndkey = random_u64 (&tm->seed); - - p = hash_get (tm->key_hash, rndkey); - if (p) - goto again; - } - else - rndkey = (u64) (i + 1) << 16; - - hash_set (tm->key_hash, rndkey, i + 1); - vec_add1 (tm->keys, rndkey); - } - - fformat (stdout, "Add items...\n"); - for (i = 0; i < tm->nitems; i++) - { - kv.key = tm->keys[i]; - kv.value = i + 1; - - CV (clib_cuckoo_add_del) (h, &kv, 1 /* is_add */ , - 0 /* overwrite */ ); - - if (tm->verbose > 1) - { - fformat (stdout, "--------------------\n"); - fformat (stdout, "After adding key %llu value %lld...\n", - tm->keys[i], (u64) (i + 1)); - fformat (stdout, "%U", CV (format_cuckoo), h, - 2 /* very verbose */ ); - } - - CVT (clib_cuckoo_kv) kv2; - int rv = CV (clib_cuckoo_search) (h, &kv, &kv2); - ASSERT (CLIB_CUCKOO_ERROR_SUCCESS == rv); - } - - fformat (stdout, "%U", CV (format_cuckoo), h, 0 /* very verbose */ ); - - fformat (stdout, "Search for items %d times...\n", tm->search_iter); - - before = clib_time_now (&tm->clib_time); - - do_search (tm, h); - - delta = clib_time_now (&tm->clib_time) - before; - total_searches = (uword) tm->search_iter * (uword) tm->nitems; - - if (delta > 0) - fformat (stdout, "%.f searches per second\n", - ((f64) total_searches) / delta); - - fformat (stdout, "%lld searches in %.6f seconds\n", total_searches, delta); - -#if 0 - int j; - fformat (stdout, "Standard E-hash search for items %d times...\n", - tm->search_iter); - - before = clib_time_now (&tm->clib_time); - - for (j = 0; j < tm->search_iter; j++) - { - for (i = 0; i < tm->nitems; i++) - { - p = hash_get (tm->key_hash, tm->keys[i]); - if (p == 0 || p[0] != (uword) (i + 1)) - clib_warning ("ugh, couldn't find %lld\n", tm->keys[i]); - } - } - - delta = clib_time_now (&tm->clib_time) - before; - total_searches = (uword) tm->search_iter * (uword) tm->nitems; - - fformat (stdout, "%lld searches in %.6f seconds\n", total_searches, delta); - - if (delta > 0) - fformat (stdout, "%.f searches per second\n", - ((f64) total_searches) / delta); - -#endif - fformat (stdout, "Delete items...\n"); - - for (i = 0; i < tm->nitems; i++) - { - int j; - int rv; - - kv.key = tm->keys[i]; - kv.value = (u64) (i + 1); - rv = CV (clib_cuckoo_add_del) (h, &kv, 0 /* is_add */ , - 0 /* dont_overwrite */ ); - - if (rv < 0) - clib_warning ("delete key %lld not ok but should be", tm->keys[i]); - - if (tm->careful_delete_tests) - { - for (j = 0; j < tm->nitems; j++) - { - kv.key = tm->keys[j]; - rv = CV (clib_cuckoo_search) (h, &kv, &kv); - if (j <= i && rv >= 0) - { - clib_warning - ("i %d j %d search ok but should not be, value %lld", i, - j, kv.value); - } - if (j > i && rv < 0) - { - clib_warning ("i %d j %d search not ok but should be", i, - j); - } - } - } - } - - fformat (stdout, "After deletions, should be empty...\n"); - - fformat (stdout, "%U", CV (format_cuckoo), h, 0 /* very verbose */ ); - return 0; -} - -clib_error_t * -test_cuckoo_main (test_main_t * tm) -{ - unformat_input_t *i = tm->input; - clib_error_t *error; - - while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) - { - if (unformat (i, "seed %u", &tm->seed)) - ; - else if (unformat (i, "nbuckets %d", &tm->nbuckets)) - ; - else if (unformat (i, "non-random-keys")) - tm->non_random_keys = 1; - else if (unformat (i, "nitems %d", &tm->nitems)) - ; - else if (unformat (i, "careful %d", &tm->careful_delete_tests)) - ; - else if (unformat (i, "verbose %d", &tm->verbose)) - ; - else if (unformat (i, "search %d", &tm->search_iter)) - ; - else if (unformat (i, "verbose")) - tm->verbose = 1; - else - return clib_error_return (0, "unknown input '%U'", - format_unformat_error, i); - } - - error = test_cuckoo (tm); - - return error; -} - -#ifdef CLIB_UNIX -int -main (int argc, char *argv[]) -{ - unformat_input_t i; - clib_error_t *error; - test_main_t *tm = &test_main; - - clib_mem_init (0, 3ULL << 30); - - tm->input = &i; - tm->seed = 0xdeaddabe; - - tm->nbuckets = 2; - tm->nitems = 100000; - tm->verbose = 1; - tm->search_iter = 10000; - tm->careful_delete_tests = 0; - tm->key_hash = hash_create (0, sizeof (uword)); - clib_time_init (&tm->clib_time); - - unformat_init_command_line (&i, argv); - error = test_cuckoo_main (tm); - unformat_free (&i); - - if (error) - { - clib_error_report (error); - return 1; - } - return 0; -} -#endif /* CLIB_UNIX */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/test_flowhash_template.c b/src/vppinfra/test_flowhash_template.c deleted file mode 100644 index 19ac4edf2e2..00000000000 --- a/src/vppinfra/test_flowhash_template.c +++ /dev/null @@ -1,257 +0,0 @@ -/* - * Copyright (c) 2015 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 <vppinfra/time.h> -#include <vppinfra/cache.h> -#include <vppinfra/error.h> - -#include <vppinfra/heap.h> -#include <vppinfra/format.h> -#include <vppinfra/random.h> -#include <vppinfra/hash.h> - -#include <vppinfra/flowhash_8_8.h> - -/* Not actually tested here. But included for compilation purposes. */ -#include <vppinfra/flowhash_24_16.h> - -typedef struct -{ - u64 seed; - u32 fixed_entries; - u32 collision_buckets; - u32 nitems; - u32 iterations; - u32 prefetch; - int non_random_keys; - uword *key_hash; - flowhash_lkey_8_8_t *keys; - flowhash_8_8_t *hash; - clib_time_t clib_time; - unformat_input_t *input; -} test_main_t; - -test_main_t test_main; - -static clib_error_t * -test_flowhash (test_main_t * tm) -{ - f64 before, delta; - u64 total; - u32 overflow; - int i, j; - uword *p; - tm->hash = flowhash_alloc_8_8 (tm->fixed_entries, tm->collision_buckets); - if (tm->hash == NULL) - return clib_error_return (0, "Could not alloc hash"); - - fformat (stdout, "Allocated hash memory size: %llu\n", - flowhash_memory_size (tm->hash)); - - fformat (stdout, "Pick %lld unique %s keys...\n", - tm->nitems, tm->non_random_keys ? "non-random" : "random"); - - for (i = 0; i < tm->nitems; i++) - { - flowhash_lkey_8_8_t rndkey; - if (tm->non_random_keys == 0) - { - again: - rndkey.as_u64[0] = random_u64 (&tm->seed); - if ((p = hash_get (tm->key_hash, rndkey.as_u64[0]))) - goto again; - } - else - rndkey.as_u64[0] = (u64) (i + 1) << 16; - - hash_set (tm->key_hash, rndkey.as_u64[0], i + 1); - vec_add1 (tm->keys, rndkey); - } - - hash_free (tm->key_hash); - - /* Additions */ - overflow = 0; - before = clib_time_now (&tm->clib_time); - fformat (stdout, "Adding %u items...\n", tm->nitems); - for (i = 0; i < tm->nitems; i++) - { - u32 hash = flowhash_hash_8_8 (&tm->keys[i]); - u32 ei; - flowhash_get_8_8 (tm->hash, &tm->keys[i], hash, 1, &ei); - if (flowhash_is_overflow (ei)) - overflow++; - - /* Set value (No matter if success) */ - flowhash_value (tm->hash, ei)->as_u64[0] = i + 1; - - /* Save value until time > 1 */ - flowhash_timeout (tm->hash, ei) = 1; - } - - delta = clib_time_now (&tm->clib_time) - before; - total = tm->nitems; - fformat (stdout, "%lld additions in %.6f seconds\n", total, delta); - if (delta > 0) - fformat (stdout, "%.f additions per second\n", ((f64) total) / delta); - - fformat (stdout, "%u elements in table\n", flowhash_elts_8_8 (tm->hash, 1)); - fformat (stdout, "Flowhash counters:\n"); - fformat (stdout, " collision-lookup: %lu\n", - tm->hash->collision_lookup_counter); - fformat (stdout, " not-enough-buckets: %lu\n", - tm->hash->not_enough_buckets_counter); - fformat (stdout, " overflows: %lu\n", overflow); - - /* Lookups (very similar to additions) */ - overflow = 0; - before = clib_time_now (&tm->clib_time); - fformat (stdout, "Looking up %u items %u times...\n", tm->nitems, - tm->iterations); - - for (j = 0; j < tm->iterations; j++) - { - i = 0; - if (tm->prefetch) - for (; i < tm->nitems - tm->prefetch; i++) - { - u32 ei; - u32 hash = flowhash_hash_8_8 (&tm->keys[i + tm->prefetch]); - flowhash_prefetch (tm->hash, hash); - hash = flowhash_hash_8_8 (&tm->keys[i]); - flowhash_get_8_8 (tm->hash, &tm->keys[i], hash, 1, &ei); - if (flowhash_is_overflow (ei)) - overflow++; - else if (flowhash_timeout (tm->hash, ei) != 1) - clib_warning ("Key not found: %lld\n", tm->keys[i].as_u64[0]); - else if (flowhash_value (tm->hash, ei)->as_u64[0] != i + 1) - clib_warning ("Value mismatch for key %lld\n", - tm->keys[i].as_u64[0]); - } - - for (; i < tm->nitems; i++) - { - u32 ei; - u32 hash = flowhash_hash_8_8 (&tm->keys[i]); - flowhash_get_8_8 (tm->hash, &tm->keys[i], hash, 1, &ei); - if (flowhash_is_overflow (ei)) - overflow++; - else if (flowhash_timeout (tm->hash, ei) != 1) - clib_warning ("Key not found: %lld\n", tm->keys[i].as_u64[0]); - else if (flowhash_value (tm->hash, ei)->as_u64[0] != i + 1) - clib_warning ("Value mismatch for key %lld\n", - tm->keys[i].as_u64[0]); - } - } - - delta = clib_time_now (&tm->clib_time) - before; - total = tm->nitems * tm->iterations; - fformat (stdout, "%lld lookups in %.6f seconds\n", total, delta); - if (delta > 0) - fformat (stdout, "%.f lookups per second\n", ((f64) total) / delta); - - /* Delete */ - for (i = 0; i < tm->nitems; i++) - { - u32 hash = flowhash_hash_8_8 (&tm->keys[i]); - u32 ei; - flowhash_get_8_8 (tm->hash, &tm->keys[i], hash, 1, &ei); - flowhash_timeout (tm->hash, ei) = 0; - } - - fformat (stdout, "%u elements in table\n", flowhash_elts_8_8 (tm->hash, 1)); - - vec_free (tm->keys); - flowhash_free_8_8 (tm->hash); - - return NULL; -} - -clib_error_t * -test_flowhash_main (test_main_t * tm) -{ - unformat_input_t *i = tm->input; - clib_error_t *error; - - while (unformat_check_input (i) != UNFORMAT_END_OF_INPUT) - { - if (unformat (i, "seed %u", &tm->seed)) - ; - else if (unformat (i, "fixed-entries %d", &tm->fixed_entries)) - ; - else if (unformat (i, "collision-buckets %d", &tm->collision_buckets)) - ; - else if (unformat (i, "non-random-keys")) - tm->non_random_keys = 1; - else if (unformat (i, "nitems %d", &tm->nitems)) - ; - else if (unformat (i, "prefetch %d", &tm->prefetch)) - ; - else if (unformat (i, "iterations %d", &tm->iterations)) - ; - else - return clib_error_return (0, "unknown input '%U'", - format_unformat_error, i); - } - - error = test_flowhash (tm); - return error; -} - -#ifdef CLIB_UNIX -int -main (int argc, char *argv[]) -{ - - unformat_input_t i; - clib_error_t *error; - test_main_t *tm = &test_main; - - clib_mem_init (0, 3ULL << 30); - - tm->fixed_entries = 8 << 20; - tm->collision_buckets = 1 << 20; - tm->seed = 0xdeadf00l; - tm->iterations = 1; - tm->input = &i; - tm->nitems = 1000; - tm->non_random_keys = 0; - tm->key_hash = hash_create (0, sizeof (uword)); - tm->prefetch = 0; - clib_time_init (&tm->clib_time); - - unformat_init_command_line (&i, argv); - error = test_flowhash_main (tm); - unformat_free (&i); - - if (error) - { - clib_error_report (error); - return 1; - } - return 0; - - return 0; -} -#endif /* CLIB_UNIX */ - - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/test_phash.c b/src/vppinfra/test_phash.c deleted file mode 100644 index 47711c28dbc..00000000000 --- a/src/vppinfra/test_phash.c +++ /dev/null @@ -1,151 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2005 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#include <vppinfra/phash.h> -#include <vppinfra/format.h> -#include <vppinfra/random.h> - -static int verbose; -#define if_verbose(format,args...) \ - if (verbose) { clib_warning(format, ## args); } - -int -test_phash_main (unformat_input_t * input) -{ - phash_main_t _pm = { 0 }, *pm = &_pm; - int n_keys, random_keys; - u32 seed; - clib_error_t *error; - - random_keys = 1; - n_keys = 1000; - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (0 == unformat (input, "keys %d", &n_keys) - && 0 == unformat (input, "verbose %=", &verbose, 1) - && 0 == unformat (input, "random-keys %=", &random_keys, 1) - && 0 == unformat (input, "sequential-keys %=", &random_keys, 0) - && 0 == unformat (input, "seed %d", &pm->random_seed) - && 0 == unformat (input, "64-bit %|", &pm->flags, PHASH_FLAG_MIX64) - && 0 == unformat (input, "32-bit %|", &pm->flags, PHASH_FLAG_MIX32) - && 0 == unformat (input, "fast %|", &pm->flags, - PHASH_FLAG_FAST_MODE) - && 0 == unformat (input, "slow %|", &pm->flags, - PHASH_FLAG_SLOW_MODE) - && 0 == unformat (input, "minimal %|", &pm->flags, - PHASH_FLAG_MINIMAL) - && 0 == unformat (input, "non-minimal %|", &pm->flags, - PHASH_FLAG_NON_MINIMAL)) - clib_error ("unknown input `%U'", format_unformat_error, input); - } - - if (!pm->random_seed) - pm->random_seed = random_default_seed (); - - if_verbose - ("%d %d-bit keys, random seed %d, %s mode, looking for %sminimal hash", - n_keys, (pm->flags & PHASH_FLAG_MIX64) ? 64 : 32, pm->random_seed, - (pm->flags & PHASH_FLAG_FAST_MODE) ? "fast" : "slow", - (pm->flags & PHASH_FLAG_MINIMAL) ? "" : "non-"); - - seed = pm->random_seed; - - /* Initialize random keys. */ - { - phash_key_t *k; - - vec_resize (pm->keys, n_keys); - vec_foreach (k, pm->keys) - { - k->key = k - pm->keys; - if (random_keys) - { - if (pm->flags & PHASH_FLAG_MIX64) - k->key = random_u64 (&seed); - else - k->key = random_u32 (&seed); - } - } - } - - error = phash_find_perfect_hash (pm); - if (error) - { - clib_error_report (error); - return 1; - } - else - { - if_verbose ("(%d,%d) (a,b) bits, %d seeds tried, %d tree walks", - pm->a_bits, pm->b_bits, - pm->n_seed_trials, pm->n_perfect_calls); - - error = phash_validate (pm); - if (error) - { - clib_error_report (error); - return 1; - } - } - - return 0; -} - -#ifdef CLIB_UNIX -int -main (int argc, char *argv[]) -{ - unformat_input_t i; - int res; - - clib_mem_init (0, 64ULL << 20); - - verbose = (argc > 1); - unformat_init_command_line (&i, argv); - res = test_phash_main (&i); - unformat_free (&i); - return res; -} -#endif - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/test_qhash.c b/src/vppinfra/test_qhash.c deleted file mode 100644 index a520fa4bd77..00000000000 --- a/src/vppinfra/test_qhash.c +++ /dev/null @@ -1,335 +0,0 @@ -/* - * Copyright (c) 2015 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 <vppinfra/bitmap.h> -#include <vppinfra/os.h> -#include <vppinfra/qhash.h> -#include <vppinfra/random.h> -#include <vppinfra/time.h> - -typedef struct -{ - u32 n_iter, seed, n_keys, n_hash_keys, verbose; - - u32 max_vector; - - uword *hash; - - uword *keys_in_hash_bitmap; - - u32 *qhash; - - uword *keys; - - uword *lookup_keys; - uword *lookup_key_indices; - u32 *lookup_results; - - u32 *get_multiple_results; - - clib_time_t time; - - f64 overflow_fraction, ave_elts; - f64 get_time, hash_get_time; - f64 set_time, set_count; - f64 unset_time, unset_count; - f64 hash_set_time, hash_unset_time; -} test_qhash_main_t; - -clib_error_t * -test_qhash_main (unformat_input_t * input) -{ - clib_error_t *error = 0; - test_qhash_main_t _tm, *tm = &_tm; - uword i, iter; - - clib_memset (tm, 0, sizeof (tm[0])); - tm->n_iter = 10; - tm->seed = 1; - tm->n_keys = 10; - tm->max_vector = 1; - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "iter %d", &tm->n_iter)) - ; - else if (unformat (input, "seed %d", &tm->seed)) - ; - else if (unformat (input, "keys %d", &tm->n_keys)) - ; - else if (unformat (input, "size %d", &tm->n_hash_keys)) - ; - else if (unformat (input, "vector %d", &tm->max_vector)) - ; - else if (unformat (input, "verbose")) - tm->verbose = 1; - else - { - error = clib_error_create ("unknown input `%U'\n", - format_unformat_error, input); - goto done; - } - } - - if (!tm->seed) - tm->seed = random_default_seed (); - - clib_time_init (&tm->time); - - clib_warning ("iter %d, seed %u, keys %d, max vector %d, ", - tm->n_iter, tm->seed, tm->n_keys, tm->max_vector); - - vec_resize (tm->keys, tm->n_keys); - vec_resize (tm->get_multiple_results, tm->n_keys); - for (i = 0; i < vec_len (tm->keys); i++) - tm->keys[i] = random_uword (&tm->seed); - - if (!tm->n_hash_keys) - tm->n_hash_keys = 2 * max_pow2 (tm->n_keys); - tm->n_hash_keys = clib_max (tm->n_keys, tm->n_hash_keys); - qhash_resize (tm->qhash, tm->n_hash_keys); - - { - qhash_t *h = qhash_header (tm->qhash); - int i; - for (i = 0; i < ARRAY_LEN (h->hash_seeds); i++) - h->hash_seeds[i] = random_uword (&tm->seed); - } - - vec_resize (tm->lookup_keys, tm->max_vector); - vec_resize (tm->lookup_key_indices, tm->max_vector); - vec_resize (tm->lookup_results, tm->max_vector); - - for (iter = 0; iter < tm->n_iter; iter++) - { - uword *p, j, n, is_set; - - n = tm->max_vector; - - is_set = random_u32 (&tm->seed) & 1; - is_set |= hash_elts (tm->hash) < (tm->n_keys / 4); - if (hash_elts (tm->hash) > (3 * tm->n_keys) / 4) - is_set = 0; - - _vec_len (tm->lookup_keys) = n; - _vec_len (tm->lookup_key_indices) = n; - j = 0; - while (j < n) - { - i = random_u32 (&tm->seed) % vec_len (tm->keys); - if (clib_bitmap_get (tm->keys_in_hash_bitmap, i) != is_set) - { - f64 t[2]; - tm->lookup_key_indices[j] = i; - tm->lookup_keys[j] = tm->keys[i]; - t[0] = clib_time_now (&tm->time); - if (is_set) - hash_set (tm->hash, tm->keys[i], i); - else - hash_unset (tm->hash, tm->keys[i]); - t[1] = clib_time_now (&tm->time); - if (is_set) - tm->hash_set_time += t[1] - t[0]; - else - tm->hash_unset_time += t[1] - t[0]; - tm->keys_in_hash_bitmap - = clib_bitmap_set (tm->keys_in_hash_bitmap, i, is_set); - j++; - } - } - - { - f64 t[2]; - - if (is_set) - { - t[0] = clib_time_now (&tm->time); - qhash_set_multiple (tm->qhash, - tm->lookup_keys, - vec_len (tm->lookup_keys), - tm->lookup_results); - t[1] = clib_time_now (&tm->time); - tm->set_time += t[1] - t[0]; - tm->set_count += vec_len (tm->lookup_keys); - for (i = 0; i < vec_len (tm->lookup_keys); i++) - { - uword r = tm->lookup_results[i]; - *vec_elt_at_index (tm->qhash, r) = tm->lookup_key_indices[i]; - } - } - else - { - t[0] = clib_time_now (&tm->time); - qhash_unset_multiple (tm->qhash, - tm->lookup_keys, - vec_len (tm->lookup_keys), - tm->lookup_results); - t[1] = clib_time_now (&tm->time); - tm->unset_time += t[1] - t[0]; - tm->unset_count += vec_len (tm->lookup_keys); - - for (i = 0; i < vec_len (tm->lookup_keys); i++) - { - uword r = tm->lookup_results[i]; - *vec_elt_at_index (tm->qhash, r) = ~0; - } - } - } - - if (qhash_elts (tm->qhash) != hash_elts (tm->hash)) - os_panic (); - - { - qhash_t *h; - uword i, k, l, count; - - h = qhash_header (tm->qhash); - - for (i = k = 0; k < vec_len (h->hash_key_valid_bitmap); k++) - i += count_set_bits (h->hash_key_valid_bitmap[k]); - k = hash_elts (h->overflow_hash); - l = qhash_elts (tm->qhash); - if (i + k != l) - os_panic (); - - count = hash_elts (h->overflow_hash); - for (i = 0; i < (1 << h->log2_hash_size); i++) - count += tm->qhash[i] != ~0; - if (count != qhash_elts (tm->qhash)) - os_panic (); - - { - u32 *tmp = 0; - - /* *INDENT-OFF* */ - hash_foreach (k, l, h->overflow_hash, ({ - j = qhash_hash_mix (h, k) / QHASH_KEYS_PER_BUCKET; - vec_validate (tmp, j); - tmp[j] += 1; - })); - /* *INDENT-ON* */ - - for (k = 0; k < vec_len (tmp); k++) - { - if (k >= vec_len (h->overflow_counts)) - os_panic (); - if (h->overflow_counts[k] != tmp[k]) - os_panic (); - } - for (; k < vec_len (h->overflow_counts); k++) - if (h->overflow_counts[k] != 0) - os_panic (); - - vec_free (tmp); - } - } - - { - f64 t[2]; - - t[0] = clib_time_now (&tm->time); - qhash_get_multiple (tm->qhash, tm->keys, vec_len (tm->keys), - tm->get_multiple_results); - t[1] = clib_time_now (&tm->time); - tm->get_time += t[1] - t[0]; - - for (i = 0; i < vec_len (tm->keys); i++) - { - u32 r; - - t[0] = clib_time_now (&tm->time); - p = hash_get (tm->hash, tm->keys[i]); - t[1] = clib_time_now (&tm->time); - tm->hash_get_time += t[1] - t[0]; - - r = qhash_get (tm->qhash, tm->keys[i]); - if (p) - { - if (p[0] != i) - os_panic (); - if (*vec_elt_at_index (tm->qhash, r) != i) - os_panic (); - } - else - { - if (r != ~0) - os_panic (); - } - if (r != tm->get_multiple_results[i]) - os_panic (); - } - } - - tm->overflow_fraction += - ((f64) qhash_n_overflow (tm->qhash) / qhash_elts (tm->qhash)); - tm->ave_elts += qhash_elts (tm->qhash); - } - - fformat (stderr, "%d iter %.6e overflow, %.4f ave. elts\n", - tm->n_iter, - tm->overflow_fraction / tm->n_iter, tm->ave_elts / tm->n_iter); - - tm->get_time /= tm->n_iter * vec_len (tm->keys); - tm->hash_get_time /= tm->n_iter * vec_len (tm->keys); - - tm->set_time /= tm->set_count; - tm->unset_time /= tm->unset_count; - tm->hash_set_time /= tm->set_count; - tm->hash_unset_time /= tm->unset_count; - - fformat (stderr, - "get/set/unset clocks %.2e %.2e %.2e clib %.2e %.2e %.2e ratio %.2f %.2f %.2f\n", - tm->get_time * tm->time.clocks_per_second, - tm->set_time * tm->time.clocks_per_second, - tm->unset_time * tm->time.clocks_per_second, - tm->hash_get_time * tm->time.clocks_per_second, - tm->hash_set_time * tm->time.clocks_per_second, - tm->hash_unset_time * tm->time.clocks_per_second, - tm->hash_get_time / tm->get_time, tm->hash_set_time / tm->set_time, - tm->hash_unset_time / tm->unset_time); - - -done: - return error; -} - -#ifdef CLIB_UNIX -int -main (int argc, char *argv[]) -{ - unformat_input_t i; - clib_error_t *error; - - clib_mem_init (0, 64ULL << 20); - - unformat_init_command_line (&i, argv); - error = test_qhash_main (&i); - unformat_free (&i); - if (error) - { - clib_error_report (error); - return 1; - } - else - return 0; -} -#endif /* CLIB_UNIX */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/test_slist.c b/src/vppinfra/test_slist.c deleted file mode 100644 index 3c3cbf73ca9..00000000000 --- a/src/vppinfra/test_slist.c +++ /dev/null @@ -1,228 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ - -#ifdef CLIB_UNIX -#include <unistd.h> -#include <stdlib.h> -#include <stdio.h> -#endif - -#include <vppinfra/slist.h> - -typedef struct -{ - u32 *random_pool; - u32 seed; - u32 iter; - u32 verbose; - f64 branching_factor; - clib_slist_t slist; -} test_main_t; - -test_main_t test_main; - -#define foreach_simple_test \ -_(2) \ -_(4) \ -_(3) \ -_(1) - - -void -run_test (test_main_t * tm) -{ - int i; - u32 *tv; - u32 ncompares; - u64 total_compares = 0; - - if (1) - { - /* - * Add a bunch of random numbers to the skip-list, - * sorting them. - */ - for (i = 0; i < tm->iter; i++) - { - pool_get (tm->random_pool, tv); - *tv = random_u32 (&tm->seed); - clib_slist_add (&tm->slist, tv, tv - tm->random_pool); - } - /* make sure we can find each one */ - for (i = 0; i < tm->iter; i++) - { - u32 search_result; - tv = pool_elt_at_index (tm->random_pool, i); - - search_result = clib_slist_search (&tm->slist, tv, &ncompares); - ASSERT (search_result == i); - - total_compares += ncompares; - } - - fformat (stdout, "%.2f avg compares/search\n", - (f64) total_compares / (f64) i); - - fformat (stdout, "%U\n", format_slist, &tm->slist, - tm->iter < 1000 /* verbose */ ); - - /* delete half of them */ - for (i = tm->iter / 2; i < tm->iter; i++) - { - tv = pool_elt_at_index (tm->random_pool, i); - (void) clib_slist_del (&tm->slist, tv); - } - - /* make sure we can find the set we should find, and no others */ - for (i = 0; i < tm->iter; i++) - { - u32 search_result; - tv = pool_elt_at_index (tm->random_pool, i); - - search_result = clib_slist_search (&tm->slist, tv, &ncompares); - if (i >= tm->iter / 2) - ASSERT (search_result == (u32) ~ 0); - else - ASSERT (search_result == i); - - } - - fformat (stdout, "%U\n", format_slist, &tm->slist, - tm->iter < 1000 /* verbose */ ); - - /* delete the rest */ - for (i = 0; i < tm->iter; i++) - { - tv = pool_elt_at_index (tm->random_pool, i); - - (void) clib_slist_del (&tm->slist, tv); - } - - fformat (stdout, "%U\n", format_slist, &tm->slist, - tm->iter < 1000 /* verbose */ ); - } - else - { - -#define _(n) \ - do { \ - pool_get (tm->random_pool, tv); \ - *tv = n; \ - clib_slist_add (&tm->slist, tv, tv - tm->random_pool); \ - fformat(stdout, "%U\n", format_slist, &tm->slist, 1 /* verbose */); \ - } while (0); - foreach_simple_test; -#undef _ - } - - return; -} - -word -test_compare (void *key, u32 elt_index) -{ - u32 *k = (u32 *) key; - u32 elt = test_main.random_pool[elt_index]; - - if (*k < elt) - return -1; - if (*k > elt) - return 1; - return 0; -} - -u8 * -test_format (u8 * s, va_list * args) -{ - u32 elt_index = va_arg (*args, u32); - u32 elt = test_main.random_pool[elt_index]; - - return format (s, "%u", elt); -} - -void -initialize_slist (test_main_t * tm) -{ - clib_slist_init (&tm->slist, tm->branching_factor, - test_compare, test_format); -} - -int -test_slist_main (unformat_input_t * input) -{ - test_main_t *tm = &test_main; - u32 tmp; - - tm->seed = 0xbabeb00b; - tm->iter = 100000; - tm->verbose = 1; - tm->branching_factor = 1.0 / 5.0; - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "seed %d", &tm->seed)) - continue; - else if (unformat (input, "iter %d", &tm->iter)) - continue; - else if (unformat (input, "verbose")) - tm->verbose = 1; - else if (unformat (input, "branch %d", &tmp)) - { - if (tmp > 0) - tm->branching_factor = 1.0 / (f64) tmp; - else - fformat (stderr, "warning: branch = 0, ignored\n"); - } - else - { - clib_error ("unknown input `%U'", format_unformat_error, input); - goto usage; - } - } - initialize_slist (tm); - run_test (tm); - - return 0; - -usage: - fformat (stderr, "usage: test_slist seed <seed> iter <iter> [verbose]\n"); - return 1; - -} - -#ifdef CLIB_UNIX -int -main (int argc, char *argv[]) -{ - unformat_input_t i; - int ret; - - clib_mem_init (0, (u64) 4 << 30); - - unformat_init_command_line (&i, argv); - ret = test_slist_main (&i); - unformat_free (&i); - - return ret; -} -#endif /* CLIB_UNIX */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/test_timing_wheel.c b/src/vppinfra/test_timing_wheel.c deleted file mode 100644 index 48020d520a0..00000000000 --- a/src/vppinfra/test_timing_wheel.c +++ /dev/null @@ -1,391 +0,0 @@ -/* - * Copyright (c) 2015 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 <vppinfra/bitmap.h> -#include <vppinfra/error.h> -#include <vppinfra/format.h> -#include <vppinfra/pool.h> -#include <vppinfra/random.h> -#include <vppinfra/time.h> -#include <vppinfra/timing_wheel.h> -#include <vppinfra/zvec.h> - -#include <vppinfra/math.h> - -#if __GNUC__ < 4 -#define SQRT(a) a -#else -#define SQRT(a) sqrt(a) -#endif - -typedef struct -{ - uword n_iter; - - u32 n_events; - u32 seed; - u32 verbose; - - /* Time is "synthetic" e.g. not taken from CPU timer. */ - u32 synthetic_time; - - clib_time_t time; - timing_wheel_t timing_wheel; - - u64 *events; - - f64 max_time; - f64 wait_time; - - f64 total_iterate_time; - f64 time_iterate_start; - - f64 time_per_status_update; - f64 time_next_status_update; -} test_timing_wheel_main_t; - -typedef struct -{ - f64 dt; - f64 fraction; - u64 count; -} test_timing_wheel_tmp_t; - -static void -set_event (test_timing_wheel_main_t * tm, uword i) -{ - timing_wheel_t *w = &tm->timing_wheel; - u64 cpu_time; - - cpu_time = w->current_time_index << w->log2_clocks_per_bin; - if (tm->synthetic_time) - cpu_time += random_u32 (&tm->seed) % tm->n_iter; - else - cpu_time += - random_f64 (&tm->seed) * tm->max_time * tm->time.clocks_per_second; - - timing_wheel_insert (w, cpu_time, i); - timing_wheel_validate (w); - tm->events[i] = cpu_time; -} - -static int -test_timing_wheel_tmp_cmp (void *a1, void *a2) -{ - test_timing_wheel_tmp_t *f1 = a1; - test_timing_wheel_tmp_t *f2 = a2; - - return f1->dt < f2->dt ? -1 : (f1->dt > f2->dt ? +1 : 0); -} - -clib_error_t * -test_timing_wheel_main (unformat_input_t * input) -{ - clib_error_t *error = 0; - test_timing_wheel_main_t _tm, *tm = &_tm; - timing_wheel_t *w = &tm->timing_wheel; - uword iter, i; - - clib_memset (tm, 0, sizeof (tm[0])); - tm->n_iter = 10; - tm->time_per_status_update = 0; - tm->n_events = 100; - tm->seed = 1; - tm->synthetic_time = 1; - tm->max_time = 1; - tm->wait_time = 1e-3; - - w->validate = 0; - w->n_wheel_elt_time_bits = 32; - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "iter %wd", &tm->n_iter)) - ; - else if (unformat (input, "events %d", &tm->n_events)) - ; - else - if (unformat (input, "elt-time-bits %d", &w->n_wheel_elt_time_bits)) - ; - else if (unformat (input, "seed %d", &tm->seed)) - ; - else if (unformat (input, "verbose")) - tm->verbose = 1; - else if (unformat (input, "validate")) - w->validate = 1; - - else if (unformat (input, "real-time")) - tm->synthetic_time = 0; - else if (unformat (input, "synthetic-time")) - tm->synthetic_time = 1; - else if (unformat (input, "max-time %f", &tm->max_time)) - ; - else if (unformat (input, "wait-time %f", &tm->wait_time)) - ; - else if (unformat (input, "iter-time %f", &tm->total_iterate_time)) - ; - else if (unformat (input, "print %f", &tm->time_per_status_update)) - ; - - else - { - error = clib_error_create ("unknown input `%U'\n", - format_unformat_error, input); - goto done; - } - } - - if (!tm->seed) - tm->seed = random_default_seed (); - - clib_time_init (&tm->time); - - if (tm->synthetic_time) - { - w->min_sched_time = tm->time.seconds_per_clock; - w->max_sched_time = w->min_sched_time * 256; - timing_wheel_init (w, 0, tm->time.clocks_per_second); - } - else - { - timing_wheel_init (w, clib_cpu_time_now (), tm->time.clocks_per_second); - } - - clib_warning ("iter %wd, events %d, seed %u, %U", - tm->n_iter, tm->n_events, tm->seed, - format_timing_wheel, &tm->timing_wheel, /* verbose */ 0); - - /* Make some events. */ - vec_resize (tm->events, tm->n_events); - for (i = 0; i < vec_len (tm->events); i++) - set_event (tm, i); - - { - u32 *expired = 0; - f64 ave_error = 0; - f64 rms_error = 0; - f64 max_error = 0, min_error = 1e30; - u32 *error_hist = 0; - uword n_expired = 0; - uword *expired_bitmap[2] = { 0 }; - uword n_events_in_wheel = vec_len (tm->events); - - vec_resize (expired, 32); - vec_resize (error_hist, 1024); - - tm->time_iterate_start = clib_time_now (&tm->time); - tm->time_next_status_update = - tm->time_iterate_start + tm->time_per_status_update; - - if (tm->total_iterate_time != 0) - tm->n_iter = ~0; - - for (iter = 0; iter < tm->n_iter || n_events_in_wheel > 0; iter++) - { - u64 cpu_time, min_next_time[2]; - - if (tm->synthetic_time) - cpu_time = iter << w->log2_clocks_per_bin; - else - cpu_time = clib_cpu_time_now (); - - _vec_len (expired) = 0; - expired = - timing_wheel_advance (w, cpu_time, expired, &min_next_time[0]); - timing_wheel_validate (w); - - /* Update bitmap of expired events. */ - if (w->validate) - { - for (i = 0; i < vec_len (tm->events); i++) - { - uword is_expired; - - is_expired = - (cpu_time >> w->log2_clocks_per_bin) >= - (tm->events[i] >> w->log2_clocks_per_bin); - expired_bitmap[0] = - clib_bitmap_set (expired_bitmap[0], i, is_expired); - - /* Validate min next time. */ - if (is_expired) - ASSERT (min_next_time[0] > tm->events[i]); - else - ASSERT (min_next_time[0] <= tm->events[i]); - } - } - - n_expired += vec_len (expired); - for (i = 0; i < vec_len (expired); i++) - { - word j, idt; - i64 dt_cpu; - f64 fdt_cpu; - - j = expired[i]; - expired_bitmap[1] = clib_bitmap_ori (expired_bitmap[1], j); - - dt_cpu = cpu_time - tm->events[j]; - - /* Event must be scheduled in correct bin. */ - if (tm->synthetic_time) - ASSERT (dt_cpu >= 0 && dt_cpu <= (1 << w->log2_clocks_per_bin)); - - fdt_cpu = dt_cpu * tm->time.seconds_per_clock; - - ave_error += fdt_cpu; - rms_error += fdt_cpu * fdt_cpu; - - if (fdt_cpu > max_error) - max_error = fdt_cpu; - if (fdt_cpu < min_error) - min_error = fdt_cpu; - - idt = - (cpu_time >> w->log2_clocks_per_bin) - - (tm->events[j] >> w->log2_clocks_per_bin); - idt = zvec_signed_to_unsigned (idt); - vec_validate (error_hist, idt); - error_hist[idt] += 1; - } - - if (w->validate) - for (i = 0; i < vec_len (tm->events); i++) - { - int is_expired = clib_bitmap_get (expired_bitmap[0], i); - int is_expired_w = clib_bitmap_get (expired_bitmap[1], i); - ASSERT (is_expired == is_expired_w); - } - - min_next_time[1] = ~0; - for (i = 0; i < vec_len (tm->events); i++) - { - if (!clib_bitmap_get (expired_bitmap[1], i)) - min_next_time[1] = clib_min (min_next_time[1], tm->events[i]); - } - if (min_next_time[0] != min_next_time[1]) - clib_error ("min next time wrong 0x%Lx != 0x%Lx", min_next_time[0], - min_next_time[1]); - - if (tm->time_per_status_update != 0 - && clib_time_now (&tm->time) >= tm->time_next_status_update) - { - f64 ave = 0, rms = 0; - - tm->time_next_status_update += tm->time_per_status_update; - if (n_expired > 0) - { - ave = ave_error / n_expired; - rms = SQRT (rms_error / n_expired - ave * ave); - } - - clib_warning - ("%12wd iter done %10wd expired; ave. error %.4e +- %.4e, range %.4e %.4e", - iter, n_expired, ave, rms, min_error, max_error); - } - - if (tm->total_iterate_time != 0 - && (clib_time_now (&tm->time) - tm->time_iterate_start - >= tm->total_iterate_time)) - tm->n_iter = iter; - - /* Add new events to wheel to replace expired ones. */ - n_events_in_wheel -= vec_len (expired); - if (iter < tm->n_iter) - { - for (i = 0; i < vec_len (expired); i++) - { - uword j = expired[i]; - set_event (tm, j); - expired_bitmap[1] = - clib_bitmap_andnoti (expired_bitmap[1], j); - } - n_events_in_wheel += vec_len (expired); - } - } - - ave_error /= n_expired; - rms_error = SQRT (rms_error / n_expired - ave_error * ave_error); - - clib_warning - ("%wd iter done %wd expired; ave. error %.4e +- %.4e, range %.4e %.4e", - 1 + iter, n_expired, ave_error, rms_error, min_error, max_error); - - { - test_timing_wheel_tmp_t *fs, *f; - f64 total_fraction; - - fs = 0; - for (i = 0; i < vec_len (error_hist); i++) - { - if (error_hist[i] == 0) - continue; - vec_add2 (fs, f, 1); - f->dt = - (((i64) zvec_unsigned_to_signed (i) << w->log2_clocks_per_bin) * - tm->time.seconds_per_clock); - f->fraction = (f64) error_hist[i] / (f64) n_expired; - f->count = error_hist[i]; - } - - vec_sort_with_function (fs, test_timing_wheel_tmp_cmp); - - total_fraction = 0; - vec_foreach (f, fs) - { - total_fraction += f->fraction; - if (f == fs) - fformat (stdout, "%=12s %=16s %=16s %s\n", "Error max", "Fraction", - "Total", "Count"); - fformat (stdout, "%12.4e %16.4f%% %16.4f%% %Ld\n", f->dt, - f->fraction * 100, total_fraction * 100, f->count); - } - } - - clib_warning ("%U", format_timing_wheel, w, /* verbose */ 1); - } - -done: - return error; -} - -#ifdef CLIB_UNIX -int -main (int argc, char *argv[]) -{ - unformat_input_t i; - clib_error_t *error; - - clib_mem_init (0, 64ULL << 20); - - unformat_init_command_line (&i, argv); - error = test_timing_wheel_main (&i); - unformat_free (&i); - if (error) - { - clib_error_report (error); - return 1; - } - else - return 0; -} -#endif /* CLIB_UNIX */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/test_vhash.c b/src/vppinfra/test_vhash.c deleted file mode 100644 index 594d46c38df..00000000000 --- a/src/vppinfra/test_vhash.c +++ /dev/null @@ -1,759 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2010 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#if 0 -#ifdef __OPTIMIZE__ -#undef CLIB_DEBUG -#endif -#endif - -#include <vppinfra/bitmap.h> -#include <vppinfra/error.h> -#include <vppinfra/os.h> -#include <vppinfra/random.h> -#include <vppinfra/time.h> -#include <vppinfra/vhash.h> - -#ifdef CLIB_HAVE_VEC128 - -typedef struct -{ - u32 n_iter; - u32 seed; - u32 verbose; - u32 n_keys; - u32 log2_size; - u32 n_key_u32; - - u32 n_vectors_div_4; - u32 n_vectors_mod_4; - - u32 *keys; - u32 *results; - - u32 *vhash_get_key_indices; - u32 *vhash_get_results; - - u32 *vhash_key_indices; - u32 *vhash_results; - - vhash_t vhash; - - uword **key_hash; - - struct - { - u64 n_clocks; - u64 n_vectors; - u64 n_calls; - } get_stats, set_stats, unset_stats; -} test_vhash_main_t; - -always_inline u32 -test_vhash_key_gather (void *_tm, u32 vi, u32 wi, u32 n_key_u32s) -{ - test_vhash_main_t *tm = _tm; - ASSERT (n_key_u32s == tm->n_key_u32); - ASSERT (wi < n_key_u32s); - vi = vec_elt (tm->vhash_key_indices, vi); - return vec_elt (tm->keys, vi * n_key_u32s + wi); -} - -always_inline u32x4 -test_vhash_4key_gather (void *_tm, u32 vi, u32 wi, u32 n_key_u32s) -{ - test_vhash_main_t *tm = _tm; - u32 *p; - u32x4_union_t x; - - ASSERT (n_key_u32s == tm->n_key_u32); - ASSERT (wi < n_key_u32s); - - p = vec_elt_at_index (tm->vhash_key_indices, vi + 0); - x.as_u32[0] = tm->keys[p[0] * n_key_u32s + wi]; - x.as_u32[1] = tm->keys[p[1] * n_key_u32s + wi]; - x.as_u32[2] = tm->keys[p[2] * n_key_u32s + wi]; - x.as_u32[3] = tm->keys[p[3] * n_key_u32s + wi]; - return x.as_u32x4; -} - -always_inline u32 -test_vhash_get_result (void *_tm, - u32 vector_index, u32 result_index, u32 n_key_u32s) -{ - test_vhash_main_t *tm = _tm; - u32 *p = vec_elt_at_index (tm->vhash_results, vector_index); - p[0] = result_index; - return result_index; -} - -always_inline u32x4 -test_vhash_get_4result (void *_tm, - u32 vector_index, u32x4 results, u32 n_key_u32s) -{ - test_vhash_main_t *tm = _tm; - u32 *p = vec_elt_at_index (tm->vhash_results, vector_index); - *(u32x4 *) p = results; - return results; -} - -always_inline u32 -test_vhash_set_result (void *_tm, - u32 vector_index, u32 old_result, u32 n_key_u32s) -{ - test_vhash_main_t *tm = _tm; - u32 *p = vec_elt_at_index (tm->vhash_results, vector_index); - u32 new_result = p[0]; - p[0] = old_result; - return new_result; -} - -always_inline u32 -test_vhash_unset_result (void *_tm, u32 i, u32 old_result, u32 n_key_u32s) -{ - test_vhash_main_t *tm = _tm; - u32 *p = vec_elt_at_index (tm->vhash_results, i); - p[0] = old_result; - return 0; -} - -#define _(N_KEY_U32) \ - always_inline u32 \ - test_vhash_key_gather_##N_KEY_U32 (void * _tm, u32 vi, u32 i) \ - { return test_vhash_key_gather (_tm, vi, i, N_KEY_U32); } \ - \ - always_inline u32x4 \ - test_vhash_key_gather_4_##N_KEY_U32 (void * _tm, u32 vi, u32 i) \ - { return test_vhash_4key_gather (_tm, vi, i, N_KEY_U32); } \ - \ - clib_pipeline_stage \ - (test_vhash_gather_keys_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_gather_4key_stage \ - (&tm->vhash, \ - /* vector_index */ i, \ - test_vhash_key_gather_4_##N_KEY_U32, \ - tm, \ - N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (test_vhash_gather_keys_mod_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_gather_key_stage \ - (&tm->vhash, \ - /* vector_index */ tm->n_vectors_div_4, \ - /* n_vectors */ tm->n_vectors_mod_4, \ - test_vhash_key_gather_##N_KEY_U32, \ - tm, \ - N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage \ - (test_vhash_hash_finalize_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_finalize_stage (&tm->vhash, i, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (test_vhash_hash_finalize_mod_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_finalize_stage (&tm->vhash, tm->n_vectors_div_4, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage \ - (test_vhash_get_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_get_4_stage (&tm->vhash, \ - /* vector_index */ i, \ - test_vhash_get_4result, \ - tm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (test_vhash_get_mod_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_get_stage (&tm->vhash, \ - /* vector_index */ tm->n_vectors_div_4, \ - /* n_vectors */ tm->n_vectors_mod_4, \ - test_vhash_get_result, \ - tm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage \ - (test_vhash_set_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_set_stage (&tm->vhash, \ - /* vector_index */ i, \ - /* n_vectors */ VECTOR_WORD_TYPE_LEN (u32), \ - test_vhash_set_result, \ - tm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (test_vhash_set_mod_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_set_stage (&tm->vhash, \ - /* vector_index */ tm->n_vectors_div_4, \ - /* n_vectors */ tm->n_vectors_mod_4, \ - test_vhash_set_result, \ - tm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage \ - (test_vhash_unset_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_unset_stage (&tm->vhash, \ - /* vector_index */ i, \ - /* n_vectors */ VECTOR_WORD_TYPE_LEN (u32), \ - test_vhash_unset_result, \ - tm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (test_vhash_unset_mod_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_unset_stage (&tm->vhash, \ - /* vector_index */ tm->n_vectors_div_4, \ - /* n_vectors */ tm->n_vectors_mod_4, \ - test_vhash_unset_result, \ - tm, N_KEY_U32); \ - }) - -_(1); -_(2); -_(3); -_(4); -_(5); -_(6); - -#undef _ - -#define _(N_KEY_U32) \ - clib_pipeline_stage \ - (test_vhash_hash_mix_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_mix_stage (&tm->vhash, i, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (test_vhash_hash_mix_mod_stage_##N_KEY_U32, \ - test_vhash_main_t *, tm, i, \ - { \ - vhash_mix_stage (&tm->vhash, tm->n_vectors_div_4, N_KEY_U32); \ - }) - -_(4); -_(5); -_(6); - -#undef _ - -typedef enum -{ - GET, SET, UNSET, -} test_vhash_op_t; - -static void -test_vhash_op (test_vhash_main_t * tm, - u32 * key_indices, - u32 * results, uword n_keys, test_vhash_op_t op) -{ - vhash_validate_sizes (&tm->vhash, tm->n_key_u32, n_keys); - - tm->vhash_results = results; - tm->vhash_key_indices = key_indices; - tm->n_vectors_div_4 = n_keys / 4; - tm->n_vectors_mod_4 = n_keys % 4; - - if (tm->n_vectors_div_4 > 0) - { - switch (tm->n_key_u32) - { - default: - ASSERT (0); - break; - -#define _(N_KEY_U32) \ - case N_KEY_U32: \ - if (op == GET) \ - clib_pipeline_run_3_stage \ - (tm->n_vectors_div_4, \ - tm, \ - test_vhash_gather_keys_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_stage_##N_KEY_U32, \ - test_vhash_get_stage_##N_KEY_U32); \ - else if (op == SET) \ - clib_pipeline_run_3_stage \ - (tm->n_vectors_div_4, \ - tm, \ - test_vhash_gather_keys_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_stage_##N_KEY_U32, \ - test_vhash_set_stage_##N_KEY_U32); \ - else \ - clib_pipeline_run_3_stage \ - (tm->n_vectors_div_4, \ - tm, \ - test_vhash_gather_keys_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_stage_##N_KEY_U32, \ - test_vhash_unset_stage_##N_KEY_U32); \ - break; - - _(1); - _(2); - _(3); - -#undef _ - -#define _(N_KEY_U32) \ - case N_KEY_U32: \ - if (op == GET) \ - clib_pipeline_run_4_stage \ - (tm->n_vectors_div_4, \ - tm, \ - test_vhash_gather_keys_stage_##N_KEY_U32, \ - test_vhash_hash_mix_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_stage_##N_KEY_U32, \ - test_vhash_get_stage_##N_KEY_U32); \ - else if (op == SET) \ - clib_pipeline_run_4_stage \ - (tm->n_vectors_div_4, \ - tm, \ - test_vhash_gather_keys_stage_##N_KEY_U32, \ - test_vhash_hash_mix_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_stage_##N_KEY_U32, \ - test_vhash_set_stage_##N_KEY_U32); \ - else \ - clib_pipeline_run_4_stage \ - (tm->n_vectors_div_4, \ - tm, \ - test_vhash_gather_keys_stage_##N_KEY_U32, \ - test_vhash_hash_mix_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_stage_##N_KEY_U32, \ - test_vhash_unset_stage_##N_KEY_U32); \ - break; - - _(4); - _(5); - _(6); - -#undef _ - } - } - - - if (tm->n_vectors_mod_4 > 0) - { - switch (tm->n_key_u32) - { - default: - ASSERT (0); - break; - -#define _(N_KEY_U32) \ - case N_KEY_U32: \ - if (op == GET) \ - clib_pipeline_run_3_stage \ - (1, \ - tm, \ - test_vhash_gather_keys_mod_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_mod_stage_##N_KEY_U32, \ - test_vhash_get_mod_stage_##N_KEY_U32); \ - else if (op == SET) \ - clib_pipeline_run_3_stage \ - (1, \ - tm, \ - test_vhash_gather_keys_mod_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_mod_stage_##N_KEY_U32, \ - test_vhash_set_mod_stage_##N_KEY_U32); \ - else \ - clib_pipeline_run_3_stage \ - (1, \ - tm, \ - test_vhash_gather_keys_mod_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_mod_stage_##N_KEY_U32, \ - test_vhash_unset_mod_stage_##N_KEY_U32); \ - break; - - _(1); - _(2); - _(3); - -#undef _ - -#define _(N_KEY_U32) \ - case N_KEY_U32: \ - if (op == GET) \ - clib_pipeline_run_4_stage \ - (1, \ - tm, \ - test_vhash_gather_keys_mod_stage_##N_KEY_U32, \ - test_vhash_hash_mix_mod_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_mod_stage_##N_KEY_U32, \ - test_vhash_get_mod_stage_##N_KEY_U32); \ - else if (op == SET) \ - clib_pipeline_run_4_stage \ - (1, \ - tm, \ - test_vhash_gather_keys_mod_stage_##N_KEY_U32, \ - test_vhash_hash_mix_mod_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_mod_stage_##N_KEY_U32, \ - test_vhash_set_mod_stage_##N_KEY_U32); \ - else \ - clib_pipeline_run_4_stage \ - (1, \ - tm, \ - test_vhash_gather_keys_mod_stage_##N_KEY_U32, \ - test_vhash_hash_mix_mod_stage_##N_KEY_U32, \ - test_vhash_hash_finalize_mod_stage_##N_KEY_U32, \ - test_vhash_unset_mod_stage_##N_KEY_U32); \ - break; - - _(4); - _(5); - _(6); - -#undef _ - } - } -} - -int -test_vhash_main (unformat_input_t * input) -{ - clib_error_t *error = 0; - test_vhash_main_t _tm, *tm = &_tm; - vhash_t *vh = &tm->vhash; - uword i, j; - - clib_memset (tm, 0, sizeof (tm[0])); - tm->n_iter = 100; - tm->seed = 1; - tm->n_keys = 1; - tm->n_key_u32 = 1; - tm->log2_size = 8; - tm->verbose = 0; - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (unformat (input, "iter %d", &tm->n_iter)) - ; - else if (unformat (input, "seed %d", &tm->seed)) - ; - else if (unformat (input, "n-keys %d", &tm->n_keys)) - ; - else if (unformat (input, "log2-size %d", &tm->log2_size)) - ; - else if (unformat (input, "key-words %d", &tm->n_key_u32)) - ; - else if (unformat (input, "verbose %=", &tm->verbose, 1)) - ; - else - { - error = clib_error_create ("unknown input `%U'\n", - format_unformat_error, input); - goto done; - } - } - - if (tm->seed == 0) - tm->seed = random_default_seed (); - - clib_warning ("iter %d seed %d n-keys %d log2-size %d key-words %d", - tm->n_iter, tm->seed, tm->n_keys, tm->log2_size, - tm->n_key_u32); - - { - u32 seeds[3]; - seeds[0] = seeds[1] = seeds[2] = 0xdeadbeef; - vhash_init (vh, tm->log2_size, tm->n_key_u32, seeds); - } - - /* Choose unique keys. */ - vec_resize (tm->keys, tm->n_keys * tm->n_key_u32); - vec_resize (tm->key_hash, tm->n_key_u32); - for (i = j = 0; i < vec_len (tm->keys); i++, j++) - { - j = j == tm->n_key_u32 ? 0 : j; - do - { - tm->keys[i] = random_u32 (&tm->seed); - } - while (hash_get (tm->key_hash[j], tm->keys[i])); - hash_set (tm->key_hash[j], tm->keys[i], 0); - } - - vec_resize (tm->results, tm->n_keys); - for (i = 0; i < vec_len (tm->results); i++) - { - do - { - tm->results[i] = random_u32 (&tm->seed); - } - while (tm->results[i] == ~0); - } - - vec_resize_aligned (tm->vhash_get_results, tm->n_keys, - CLIB_CACHE_LINE_BYTES); - vec_clone (tm->vhash_get_key_indices, tm->results); - for (i = 0; i < vec_len (tm->vhash_get_key_indices); i++) - tm->vhash_get_key_indices[i] = i; - - { - uword *is_set_bitmap = 0; - uword *to_set_bitmap = 0; - uword *to_unset_bitmap = 0; - u32 *to_set = 0, *to_unset = 0; - u32 *to_set_results = 0, *to_unset_results = 0; - u64 t[2]; - - for (i = 0; i < tm->n_iter; i++) - { - vec_reset_length (to_set); - vec_reset_length (to_unset); - vec_reset_length (to_set_results); - vec_reset_length (to_unset_results); - - do - { - to_set_bitmap = clib_bitmap_random (to_set_bitmap, - tm->n_keys, &tm->seed); - } - while (clib_bitmap_is_zero (to_set_bitmap)); - to_unset_bitmap = clib_bitmap_dup_and (to_set_bitmap, is_set_bitmap); - to_set_bitmap = clib_bitmap_andnot (to_set_bitmap, to_unset_bitmap); - - /* *INDENT-OFF* */ - clib_bitmap_foreach (j, to_set_bitmap, ({ - vec_add1 (to_set, j); - vec_add1 (to_set_results, tm->results[j]); - })); - /* *INDENT-ON* */ - /* *INDENT-OFF* */ - clib_bitmap_foreach (j, to_unset_bitmap, ({ - vec_add1 (to_unset, j); - vec_add1 (to_unset_results, 0xdeadbeef); - })); - /* *INDENT-ON* */ - - if (vec_len (to_set) > 0) - { - t[0] = clib_cpu_time_now (); - test_vhash_op (tm, to_set, to_set_results, vec_len (to_set), SET); - t[1] = clib_cpu_time_now (); - tm->set_stats.n_clocks += t[1] - t[0]; - tm->set_stats.n_vectors += vec_len (to_set); - tm->set_stats.n_calls += 1; - is_set_bitmap = clib_bitmap_or (is_set_bitmap, to_set_bitmap); - } - - t[0] = clib_cpu_time_now (); - test_vhash_op (tm, tm->vhash_get_key_indices, - tm->vhash_get_results, - vec_len (tm->vhash_get_key_indices), GET); - t[1] = clib_cpu_time_now (); - tm->get_stats.n_clocks += t[1] - t[0]; - tm->get_stats.n_vectors += vec_len (tm->vhash_get_key_indices); - tm->get_stats.n_calls += 1; - - for (j = 0; j < vec_len (tm->vhash_get_results); j++) - { - u32 r0 = tm->vhash_get_results[j]; - u32 r1 = tm->results[j]; - if (clib_bitmap_get (is_set_bitmap, j)) - { - if (r0 != r1) - os_panic (); - } - else - { - if (r0 != ~0) - os_panic (); - } - } - - if (vh->n_elts != clib_bitmap_count_set_bits (is_set_bitmap)) - os_panic (); - - if (vec_len (to_unset) > 0) - { - t[0] = clib_cpu_time_now (); - test_vhash_op (tm, to_unset, to_unset_results, - vec_len (to_unset), UNSET); - t[1] = clib_cpu_time_now (); - tm->unset_stats.n_clocks += t[1] - t[0]; - tm->unset_stats.n_vectors += vec_len (to_unset); - tm->unset_stats.n_calls += 1; - is_set_bitmap = - clib_bitmap_andnot (is_set_bitmap, to_unset_bitmap); - } - - t[0] = clib_cpu_time_now (); - test_vhash_op (tm, tm->vhash_get_key_indices, - tm->vhash_get_results, - vec_len (tm->vhash_get_key_indices), GET); - t[1] = clib_cpu_time_now (); - tm->get_stats.n_clocks += t[1] - t[0]; - tm->get_stats.n_vectors += vec_len (tm->vhash_get_key_indices); - tm->get_stats.n_calls += 1; - - for (j = 0; j < vec_len (tm->vhash_get_results); j++) - { - u32 r0 = tm->vhash_get_results[j]; - u32 r1 = tm->results[j]; - if (clib_bitmap_get (is_set_bitmap, j)) - { - if (r0 != r1) - os_panic (); - } - else - { - if (r0 != ~0) - os_panic (); - } - } - - if (vh->n_elts != clib_bitmap_count_set_bits (is_set_bitmap)) - os_panic (); - } - - vhash_resize (vh, tm->log2_size + 1); - - test_vhash_op (tm, tm->vhash_get_key_indices, - tm->vhash_get_results, - vec_len (tm->vhash_get_key_indices), GET); - - for (j = 0; j < vec_len (tm->vhash_get_results); j++) - { - u32 r0 = tm->vhash_get_results[j]; - u32 r1 = tm->results[j]; - if (clib_bitmap_get (is_set_bitmap, j)) - { - if (r0 != r1) - os_panic (); - } - else - { - if (r0 != ~0) - os_panic (); - } - } - - if (vh->n_elts != clib_bitmap_count_set_bits (is_set_bitmap)) - os_panic (); - } - - { - clib_time_t ct; - - clib_time_init (&ct); - - clib_warning ("%.4e clocks/get %.4e gets/call %.4e gets/sec", - (f64) tm->get_stats.n_clocks / - (f64) tm->get_stats.n_vectors, - (f64) tm->get_stats.n_vectors / (f64) tm->get_stats.n_calls, - (f64) tm->get_stats.n_vectors / - (f64) (tm->get_stats.n_clocks * ct.seconds_per_clock)); - if (tm->set_stats.n_calls > 0) - clib_warning ("%.4e clocks/set %.4e sets/call %.4e sets/sec", - (f64) tm->set_stats.n_clocks / - (f64) tm->set_stats.n_vectors, - (f64) tm->set_stats.n_vectors / - (f64) tm->set_stats.n_calls, - (f64) tm->set_stats.n_vectors / - (f64) (tm->set_stats.n_clocks * ct.seconds_per_clock)); - if (tm->unset_stats.n_calls > 0) - clib_warning ("%.4e clocks/unset %.4e unsets/call %.4e unsets/sec", - (f64) tm->unset_stats.n_clocks / - (f64) tm->unset_stats.n_vectors, - (f64) tm->unset_stats.n_vectors / - (f64) tm->unset_stats.n_calls, - (f64) tm->unset_stats.n_vectors / - (f64) (tm->unset_stats.n_clocks * ct.seconds_per_clock)); - } - -done: - if (error) - clib_error_report (error); - return 0; -} - -#endif /* CLIB_HAVE_VEC128 */ - -#ifndef CLIB_HAVE_VEC128 -int -test_vhash_main (unformat_input_t * input) -{ - clib_error ("compiled without vector support"); - return 0; -} -#endif - -#ifdef CLIB_UNIX -int -main (int argc, char *argv[]) -{ - unformat_input_t i; - int r; - - clib_mem_init (0, 64ULL << 20); - - unformat_init_command_line (&i, argv); - r = test_vhash_main (&i); - unformat_free (&i); - return r; -} -#endif - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/test_zvec.c b/src/vppinfra/test_zvec.c deleted file mode 100644 index 7d777fabf83..00000000000 --- a/src/vppinfra/test_zvec.c +++ /dev/null @@ -1,119 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2005 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#include <vppinfra/zvec.h> -#include <vppinfra/format.h> -#include <vppinfra/random.h> - -static int verbose; -#define if_verbose(format,args...) \ - if (verbose) { clib_warning(format, ## args); } - -int -test_zvec_main (unformat_input_t * input) -{ - uword n_iterations; - uword i; - u32 seed; - - n_iterations = 1024; - seed = 0; - - while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT) - { - if (0 == unformat (input, "iter %d", &n_iterations) - && 0 == unformat (input, "seed %d", &seed)) - clib_error ("unknown input `%U'", format_unformat_error, input); - } - - if_verbose ("%d iterations, seed %d\n", n_iterations, seed); - - for (i = 0; i < n_iterations; i++) - { - uword coding, data, d[2], limit, n_zdata_bits[2]; - - if (seed) - coding = random_u32 (&seed); - else - coding = i; - - limit = coding - 1; - if (limit > (1 << 16)) - limit = 1 << 16; - for (data = 0; data <= limit; data++) - { - d[0] = zvec_encode (coding, data, &n_zdata_bits[0]); - - if (coding != 0) - ASSERT ((d[0] >> n_zdata_bits[0]) == 0); - - d[1] = zvec_decode (coding, d[0], &n_zdata_bits[1]); - ASSERT (data == d[1]); - - ASSERT (n_zdata_bits[0] == n_zdata_bits[1]); - } - } - - return 0; -} - -#ifdef CLIB_UNIX -int -main (int argc, char *argv[]) -{ - unformat_input_t i; - int ret; - - clib_mem_init (0, 64ULL << 20); - - verbose = (argc > 1); - unformat_init_command_line (&i, argv); - ret = test_zvec_main (&i); - unformat_free (&i); - - return ret; -} -#endif /* CLIB_UNIX */ - - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/unix-kelog.c b/src/vppinfra/unix-kelog.c deleted file mode 100644 index 88428ee8f2e..00000000000 --- a/src/vppinfra/unix-kelog.c +++ /dev/null @@ -1,415 +0,0 @@ -/* - Copyright (c) 2010 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 <vppinfra/error.h> -#include <vppinfra/unix.h> -#include <vppinfra/elog.h> -#include <vppinfra/format.h> -#include <vppinfra/os.h> - -#include <sys/types.h> -#include <sys/stat.h> -#include <fcntl.h> -#include <time.h> - -typedef enum -{ - RUNNING = 0, - WAKEUP, -} sched_event_type_t; - -typedef struct -{ - u32 cpu; - u8 *task; - u32 pid; - f64 timestamp; - sched_event_type_t type; -} sched_event_t; - -void -kelog_init (elog_main_t * em, char *kernel_tracer, u32 n_events) -{ - int enable_fd, current_tracer_fd, data_fd; - int len; - struct timespec ts, ts2; - char *trace_enable = "/debug/tracing/tracing_enabled"; - char *current_tracer = "/debug/tracing/current_tracer"; - char *trace_data = "/debug/tracing/trace"; - f64 realtime, monotonic; - f64 freq, secs_per_clock; - - ASSERT (kernel_tracer); - - /*$$$$ fixme */ - n_events = 1 << 18; - - /* init first so we won't hurt ourselves if we bail */ - elog_init (em, n_events); - - enable_fd = open (trace_enable, O_RDWR); - if (enable_fd < 0) - { - clib_warning ("Couldn't open %s", trace_enable); - return; - } - /* disable kernel tracing */ - if (write (enable_fd, "0\n", 2) != 2) - { - clib_unix_warning ("disable tracing"); - close (enable_fd); - return; - } - - /* - * open + clear the data buffer. - * see .../linux/kernel/trace/trace.c:tracing_open() - */ - data_fd = open (trace_data, O_RDWR | O_TRUNC); - if (data_fd < 0) - { - clib_warning ("Couldn't open+clear %s", trace_data); - return; - } - close (data_fd); - - /* configure tracing */ - current_tracer_fd = open (current_tracer, O_RDWR); - - if (current_tracer_fd < 0) - { - clib_warning ("Couldn't open %s", current_tracer); - close (enable_fd); - return; - } - - len = strlen (kernel_tracer); - - if (write (current_tracer_fd, kernel_tracer, len) != len) - { - clib_unix_warning ("configure trace"); - close (current_tracer_fd); - close (enable_fd); - return; - } - - close (current_tracer_fd); - - /* - * The kernel event log uses CLOCK_MONOTONIC timestamps, - * not CLOCK_REALTIME timestamps. These differ by a constant - * but the constant is not available in user mode. - * This estimate will be off by one syscall round-trip. - */ - clib_time_init (&em->cpu_timer); - em->init_time.cpu = em->cpu_timer.init_cpu_time; - syscall (SYS_clock_gettime, CLOCK_MONOTONIC, &ts); - - /* enable kernel tracing */ - if (write (enable_fd, "1\n", 2) != 2) - { - clib_unix_warning ("enable tracing"); - close (enable_fd); - return; - } - - close (enable_fd); -} - - -u8 * -format_sched_event (u8 * s, va_list * va) -{ - sched_event_t *e = va_arg (*va, sched_event_t *); - - s = format (s, "cpu %d task %10s type %s timestamp %12.6f\n", - e->cpu, e->task, e->type ? "WAKEUP " : "RUNNING", e->timestamp); - - return s; -} - -sched_event_t * -parse_sched_switch_trace (u8 * tdata, u32 * index) -{ - u8 *cp = tdata + *index; - u8 *limit = tdata + vec_len (tdata); - int colons; - static sched_event_t event; - sched_event_t *e = &event; - static u8 *task_name; - u32 secs, usecs; - int i; - -again: - /* eat leading w/s */ - while (cp < limit && (*cp == ' ' && *cp == '\t')) - cp++; - if (cp == limit) - return 0; - - /* header line */ - if (*cp == '#') - { - while (cp < limit && (*cp != '\n')) - cp++; - if (*cp == '\n') - { - cp++; - goto again; - } - clib_warning ("bugger 0"); - return 0; - } - - while (cp < limit && *cp != ']') - cp++; - - if (*cp == 0) - return 0; - - if (*cp != ']') - { - clib_warning ("bugger 0.1"); - return 0; - } - - cp++; - while (cp < limit && (*cp == ' ' && *cp == '\t')) - cp++; - if (cp == limit) - { - clib_warning ("bugger 0.2"); - return 0; - } - - secs = atoi (cp); - - while (cp < limit && (*cp != '.')) - cp++; - - if (cp == limit) - { - clib_warning ("bugger 0.3"); - return 0; - } - - cp++; - - usecs = atoi (cp); - - e->timestamp = ((f64) secs) + ((f64) usecs) * 1e-6; - - /* eat up to third colon */ - for (i = 0; i < 3; i++) - { - while (cp < limit && *cp != ':') - cp++; - cp++; - } - --cp; - if (*cp != ':') - { - clib_warning ("bugger 1"); - return 0; - } - /* aim at '>' (switch-to) / '+' (wakeup) */ - cp += 5; - if (cp >= limit) - { - clib_warning ("bugger 2"); - return 0; - } - if (*cp == '>') - e->type = RUNNING; - else if (*cp == '+') - e->type = WAKEUP; - else - { - clib_warning ("bugger 3"); - return 0; - } - - cp += 3; - if (cp >= limit) - { - clib_warning ("bugger 4"); - return 0; - } - - e->cpu = atoi (cp); - cp += 4; - - if (cp >= limit) - { - clib_warning ("bugger 4"); - return 0; - } - while (cp < limit && (*cp == ' ' || *cp == '\t')) - cp++; - - e->pid = atoi (cp); - - for (i = 0; i < 2; i++) - { - while (cp < limit && *cp != ':') - cp++; - cp++; - } - --cp; - if (*cp != ':') - { - clib_warning ("bugger 5"); - return 0; - } - - cp += 3; - if (cp >= limit) - { - clib_warning ("bugger 6"); - return 0; - } - while (cp < limit && (*cp != ' ' && *cp != '\n')) - { - vec_add1 (task_name, *cp); - cp++; - } - vec_add1 (task_name, 0); - /* _vec_len() = 0 in caller */ - e->task = task_name; - - if (cp < limit) - cp++; - - *index = cp - tdata; - return e; -} - -static u32 -elog_id_for_pid (elog_main_t * em, u8 * name, u32 pid) -{ - uword *p, r; - mhash_t *h = &em->string_table_hash; - - if (!em->string_table_hash.hash) - mhash_init (h, sizeof (uword), sizeof (pid)); - - p = mhash_get (h, &pid); - if (p) - return p[0]; - r = elog_string (em, "%s(%d)", name, pid); - mhash_set (h, &pid, r, /* old_value */ 0); - return r; -} - -void -kelog_collect_sched_switch_trace (elog_main_t * em) -{ - int enable_fd, data_fd; - char *trace_enable = "/debug/tracing/tracing_enabled"; - char *trace_data = "/debug/tracing/trace"; - u8 *data = 0; - u8 *dp; - int bytes, total_bytes; - u32 pos; - sched_event_t *evt; - u64 nsec_to_add; - u32 index; - f64 clocks_per_sec; - - enable_fd = open (trace_enable, O_RDWR); - if (enable_fd < 0) - { - clib_warning ("Couldn't open %s", trace_enable); - return; - } - /* disable kernel tracing */ - if (write (enable_fd, "0\n", 2) != 2) - { - clib_unix_warning ("disable tracing"); - close (enable_fd); - return; - } - close (enable_fd); - - /* Read the trace data */ - data_fd = open (trace_data, O_RDWR); - if (data_fd < 0) - { - clib_warning ("Couldn't open %s", trace_data); - return; - } - - /* - * Extract trace into a vector. Note that seq_printf() [kernel] - * is not guaranteed to produce 4096 bytes at a time. - */ - vec_validate (data, 4095); - total_bytes = 0; - pos = 0; - while (1) - { - bytes = read (data_fd, data + pos, 4096); - if (bytes <= 0) - break; - - total_bytes += bytes; - _vec_len (data) = total_bytes; - - pos = vec_len (data); - vec_validate (data, vec_len (data) + 4095); - } - vec_add1 (data, 0); - - /* Synthesize events */ - em->is_enabled = 1; - - index = 0; - while ((evt = parse_sched_switch_trace (data, &index))) - { - u64 fake_cpu_clock; - - fake_cpu_clock = evt->timestamp * em->cpu_timer.clocks_per_second; - { - ELOG_TYPE_DECLARE (e) = - { - .format = "%d: %s %s",.format_args = "i4T4t4",.n_enum_strings = - 2,.enum_strings = - { - "running", "wakeup",} - ,}; - struct - { - u32 cpu, string_table_offset, which; - } *ed; - - ed = elog_event_data_not_inline (em, &__ELOG_TYPE_VAR (e), - &em->default_track, fake_cpu_clock); - ed->cpu = evt->cpu; - ed->string_table_offset = elog_id_for_pid (em, evt->task, evt->pid); - ed->which = evt->type; - } - _vec_len (evt->task) = 0; - } - em->is_enabled = 0; -} - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/vhash.c b/src/vppinfra/vhash.c deleted file mode 100644 index 9120f502c91..00000000000 --- a/src/vppinfra/vhash.c +++ /dev/null @@ -1,772 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2010 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#include <vppinfra/vhash.h> - -#ifdef CLIB_HAVE_VEC128 - -/* Overflow search buckets have an extra u32x4 for saving key_hash data. - This makes it easier to refill main search bucket from overflow vector. */ -typedef struct -{ - /* 4 results for this bucket. */ - u32x4_union_t result; - - /* 4 hash codes for this bucket. These are used to refill main - search buckets from overflow buckets when space becomes available. */ - u32x4_union_t key_hash; - - /* n_key_u32s u32x4s of key data follow. */ - u32x4_union_t key[0]; -} vhash_overflow_search_bucket_t; - -always_inline void -set_overflow_result (vhash_overflow_search_bucket_t * b, - u32 i, u32 result, u32 key_hash) -{ - b->result.as_u32[i] = result; - b->key_hash.as_u32[i] = key_hash; -} - -always_inline void -free_overflow_bucket (vhash_overflow_buckets_t * ob, - vhash_overflow_search_bucket_t * b, u32 i) -{ - u32 o = (u32x4_union_t *) b - ob->search_buckets; - ASSERT (o < vec_len (ob->search_buckets)); - vec_add1 (ob->free_indices, 4 * o + i); -} - -always_inline vhash_overflow_search_bucket_t * -get_overflow_search_bucket (vhash_overflow_buckets_t * obs, u32 i, - u32 n_key_u32s) -{ - return ((vhash_overflow_search_bucket_t *) - vec_elt_at_index (obs->search_buckets, i)); -} - -always_inline vhash_overflow_search_bucket_t * -next_overflow_bucket (vhash_overflow_search_bucket_t * b, u32 n_key_u32s) -{ - return (vhash_overflow_search_bucket_t *) & b->key[n_key_u32s]; -} - -#define foreach_vhash_overflow_bucket(b,ob,n_key_u32s) \ - for ((b) = (vhash_overflow_search_bucket_t *) ob->search_buckets; \ - (u32x4_union_t *) (b) < vec_end (ob->search_buckets); \ - b = next_overflow_bucket (b, n_key_u32s)) - -u32 -vhash_get_overflow (vhash_t * h, u32 key_hash, u32 vi, u32 n_key_u32s) -{ - vhash_overflow_buckets_t *ob = vhash_get_overflow_buckets (h, key_hash); - vhash_overflow_search_bucket_t *b; - u32 i, result = 0; - - foreach_vhash_overflow_bucket (b, ob, n_key_u32s) - { - u32x4 r = b->result.as_u32x4; - - for (i = 0; i < n_key_u32s; i++) - r &= vhash_bucket_compare (h, &b->key[0], i, vi); - - result = vhash_merge_results (r); - if (result) - break; - } - - return result; -} - -u32 -vhash_set_overflow (vhash_t * h, - u32 key_hash, u32 vi, u32 new_result, u32 n_key_u32s) -{ - vhash_overflow_buckets_t *ob = vhash_get_overflow_buckets (h, key_hash); - vhash_overflow_search_bucket_t *b; - u32 i_set, i, old_result; - - foreach_vhash_overflow_bucket (b, ob, n_key_u32s) - { - u32x4 r; - - r = b->result.as_u32x4; - for (i = 0; i < n_key_u32s; i++) - r &= vhash_bucket_compare (h, &b->key[0], i, vi); - - old_result = vhash_merge_results (r); - if (old_result) - { - i_set = vhash_non_empty_result_index (r); - set_overflow_result (b, i_set, new_result, key_hash); - return old_result; - } - } - - /* Check free list. */ - if (vec_len (ob->free_indices) == 0) - { - /* Out of free overflow buckets. Resize. */ - u32 j, *p; - i = vec_len (ob->search_buckets); - vec_resize_aligned (ob->search_buckets, - sizeof (b[0]) / sizeof (u32x4) + n_key_u32s, - CLIB_CACHE_LINE_BYTES); - vec_add2 (ob->free_indices, p, 4); - for (j = 0; j < 4; j++) - p[j] = 4 * i + j; - } - - i = vec_pop (ob->free_indices); - - i_set = i & 3; - b = ((vhash_overflow_search_bucket_t *) - vec_elt_at_index (ob->search_buckets, i / 4)); - - /* Insert result. */ - set_overflow_result (b, i_set, new_result, key_hash); - - /* Insert key. */ - for (i = 0; i < n_key_u32s; i++) - b->key[i].as_u32[i_set] = vhash_get_key_word (h, i, vi); - - ob->n_overflow++; - h->n_elts++; - - return /* old result was invalid */ 0; -} - -u32 -vhash_unset_overflow (vhash_t * h, u32 key_hash, u32 vi, u32 n_key_u32s) -{ - vhash_overflow_buckets_t *ob = vhash_get_overflow_buckets (h, key_hash); - vhash_overflow_search_bucket_t *b; - u32 i_set, i, old_result; - - foreach_vhash_overflow_bucket (b, ob, n_key_u32s) - { - u32x4 r; - - r = b->result.as_u32x4; - for (i = 0; i < n_key_u32s; i++) - r &= vhash_bucket_compare (h, &b->key[0], i, vi); - - old_result = vhash_merge_results (r); - if (old_result) - { - i_set = vhash_non_empty_result_index (r); - - /* Invalidate result and invert key hash so that this will - never match since all keys in this overflow bucket have - matching key hashs. */ - set_overflow_result (b, i_set, 0, ~key_hash); - - free_overflow_bucket (ob, b, i_set); - - ASSERT (ob->n_overflow > 0); - ob->n_overflow--; - h->n_elts--; - return old_result; - } - } - - /* Could not find key. */ - return 0; -} - -void -vhash_unset_refill_from_overflow (vhash_t * h, - vhash_search_bucket_t * sb, - u32 key_hash, u32 n_key_u32s) -{ - vhash_overflow_buckets_t *obs = vhash_get_overflow_buckets (h, key_hash); - vhash_overflow_search_bucket_t *ob; - u32 i, j, i_refill, bucket_mask = h->bucket_mask.as_u32[0]; - - /* Find overflow element with matching key hash. */ - foreach_vhash_overflow_bucket (ob, obs, n_key_u32s) - { - for (i = 0; i < 4; i++) - { - if (!ob->result.as_u32[i]) - continue; - if ((ob->key_hash.as_u32[i] & bucket_mask) - != (key_hash & bucket_mask)) - continue; - - i_refill = vhash_empty_result_index (sb->result.as_u32x4); - sb->result.as_u32[i_refill] = ob->result.as_u32[i]; - for (j = 0; j < n_key_u32s; j++) - sb->key[j].as_u32[i_refill] = ob->key[j].as_u32[i]; - set_overflow_result (ob, i, 0, ~key_hash); - free_overflow_bucket (obs, ob, i); - return; - } - } -} - -void -vhash_init (vhash_t * h, u32 log2_n_keys, u32 n_key_u32, u32 * hash_seeds) -{ - uword i, j, m; - vhash_search_bucket_t *b; - - clib_memset (h, 0, sizeof (h[0])); - - /* Must have at least 4 keys (e.g. one search bucket). */ - log2_n_keys = clib_max (log2_n_keys, 2); - - h->log2_n_keys = log2_n_keys; - h->n_key_u32 = n_key_u32; - m = pow2_mask (h->log2_n_keys) & ~3; - for (i = 0; i < VECTOR_WORD_TYPE_LEN (u32); i++) - h->bucket_mask.as_u32[i] = m; - - /* Allocate and zero search buckets. */ - i = (sizeof (b[0]) / sizeof (u32x4) + n_key_u32) << (log2_n_keys - 2); - vec_validate_aligned (h->search_buckets, i - 1, CLIB_CACHE_LINE_BYTES); - - for (i = 0; i < ARRAY_LEN (h->find_first_zero_table); i++) - h->find_first_zero_table[i] = min_log2 (first_set (~i)); - - for (i = 0; i < ARRAY_LEN (h->hash_seeds); i++) - for (j = 0; j < VECTOR_WORD_TYPE_LEN (u32); j++) - h->hash_seeds[i].as_u32[j] = hash_seeds[i]; -} - -static_always_inline u32 -vhash_main_key_gather (void *_vm, u32 vi, u32 wi, u32 n_key_u32) -{ - vhash_main_t *vm = _vm; - return vec_elt (vm->keys, vi * n_key_u32 + wi); -} - -static_always_inline u32x4 -vhash_main_4key_gather (void *_vm, u32 vi, u32 wi, u32 n_key_u32s) -{ - vhash_main_t *vm = _vm; - u32x4_union_t x; - - ASSERT (n_key_u32s == vm->n_key_u32); - ASSERT (wi < n_key_u32s); - - x.as_u32[0] = vec_elt (vm->keys, (vi + 0) * n_key_u32s + wi); - x.as_u32[1] = vec_elt (vm->keys, (vi + 1) * n_key_u32s + wi); - x.as_u32[2] = vec_elt (vm->keys, (vi + 2) * n_key_u32s + wi); - x.as_u32[3] = vec_elt (vm->keys, (vi + 3) * n_key_u32s + wi); - return x.as_u32x4; -} - -static_always_inline u32 -vhash_main_set_result (void *_vm, u32 vi, u32 old_result, u32 n_key_u32) -{ - vhash_main_t *vm = _vm; - u32 *p = vec_elt_at_index (vm->results, vi); - u32 new_result = p[0]; - p[0] = old_result; - return new_result; -} - -static_always_inline u32 -vhash_main_get_result (void *_vm, u32 vi, u32 old_result, u32 n_key_u32) -{ - vhash_main_t *vm = _vm; - vec_elt (vm->results, vi) = old_result; - return old_result; -} - -static_always_inline u32x4 -vhash_main_get_4result (void *_vm, u32 vi, u32x4 old_result, u32 n_key_u32) -{ - vhash_main_t *vm = _vm; - u32x4 *p = (u32x4 *) vec_elt_at_index (vm->results, vi); - p[0] = old_result; - return old_result; -} - -#define _(N_KEY_U32) \ - static_always_inline u32 \ - vhash_main_key_gather_##N_KEY_U32 (void * _vm, u32 vi, u32 i) \ - { return vhash_main_key_gather (_vm, vi, i, N_KEY_U32); } \ - \ - static_always_inline u32x4 \ - vhash_main_4key_gather_##N_KEY_U32 (void * _vm, u32 vi, u32 i) \ - { return vhash_main_4key_gather (_vm, vi, i, N_KEY_U32); } \ - \ - clib_pipeline_stage_static \ - (vhash_main_gather_keys_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_gather_4key_stage \ - (vm->vhash, \ - /* vector_index */ i, \ - vhash_main_4key_gather_##N_KEY_U32, \ - vm, \ - N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (vhash_main_gather_keys_mod_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_gather_key_stage \ - (vm->vhash, \ - /* vector_index */ vm->n_vectors_div_4, \ - /* n_vectors */ vm->n_vectors_mod_4, \ - vhash_main_key_gather_##N_KEY_U32, \ - vm, \ - N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage \ - (vhash_main_hash_finalize_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_finalize_stage (vm->vhash, i, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (vhash_main_hash_finalize_mod_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_finalize_stage (vm->vhash, vm->n_vectors_div_4, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_static \ - (vhash_main_get_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_get_4_stage (vm->vhash, \ - /* vector_index */ i, \ - vhash_main_get_4result, \ - vm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (vhash_main_get_mod_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_get_stage (vm->vhash, \ - /* vector_index */ vm->n_vectors_div_4, \ - /* n_vectors */ vm->n_vectors_mod_4, \ - vhash_main_get_result, \ - vm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_static \ - (vhash_main_set_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_set_stage (vm->vhash, \ - /* vector_index */ i, \ - /* n_vectors */ VECTOR_WORD_TYPE_LEN (u32), \ - vhash_main_set_result, \ - vm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (vhash_main_set_mod_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_set_stage (vm->vhash, \ - /* vector_index */ vm->n_vectors_div_4, \ - /* n_vectors */ vm->n_vectors_mod_4, \ - vhash_main_set_result, \ - vm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_static \ - (vhash_main_unset_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_unset_stage (vm->vhash, \ - /* vector_index */ i, \ - /* n_vectors */ VECTOR_WORD_TYPE_LEN (u32), \ - vhash_main_get_result, \ - vm, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (vhash_main_unset_mod_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_unset_stage (vm->vhash, \ - /* vector_index */ vm->n_vectors_div_4, \ - /* n_vectors */ vm->n_vectors_mod_4, \ - vhash_main_get_result, \ - vm, N_KEY_U32); \ - }) - -_(1); -_(2); -_(3); -_(4); -_(5); -_(6); - -#undef _ - -#define _(N_KEY_U32) \ - clib_pipeline_stage \ - (vhash_main_hash_mix_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_mix_stage (vm->vhash, i, N_KEY_U32); \ - }) \ - \ - clib_pipeline_stage_no_inline \ - (vhash_main_hash_mix_mod_stage_##N_KEY_U32, \ - vhash_main_t *, vm, i, \ - { \ - vhash_mix_stage (vm->vhash, vm->n_vectors_div_4, N_KEY_U32); \ - }) - -_(4); -_(5); -_(6); - -#undef _ - -typedef enum -{ - GET, SET, UNSET, -} vhash_main_op_t; - -static void -vhash_main_op (vhash_main_t * vm, vhash_main_op_t op) -{ - u32 n_keys = vec_len (vm->results); - - vm->n_key_u32 = vm->vhash->n_key_u32; - - vhash_validate_sizes (vm->vhash, vm->n_key_u32, n_keys); - - vm->n_vectors_div_4 = n_keys / 4; - vm->n_vectors_mod_4 = n_keys % 4; - - if (vm->n_vectors_div_4 > 0) - { - switch (vm->n_key_u32) - { - default: - ASSERT (0); - break; - -#define _(N_KEY_U32) \ - case N_KEY_U32: \ - if (op == GET) \ - clib_pipeline_run_3_stage \ - (vm->n_vectors_div_4, \ - vm, \ - vhash_main_gather_keys_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_stage_##N_KEY_U32, \ - vhash_main_get_stage_##N_KEY_U32); \ - else if (op == SET) \ - clib_pipeline_run_3_stage \ - (vm->n_vectors_div_4, \ - vm, \ - vhash_main_gather_keys_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_stage_##N_KEY_U32, \ - vhash_main_set_stage_##N_KEY_U32); \ - else \ - clib_pipeline_run_3_stage \ - (vm->n_vectors_div_4, \ - vm, \ - vhash_main_gather_keys_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_stage_##N_KEY_U32, \ - vhash_main_unset_stage_##N_KEY_U32); \ - break; - - _(1); - _(2); - _(3); - -#undef _ - -#define _(N_KEY_U32) \ - case N_KEY_U32: \ - if (op == GET) \ - clib_pipeline_run_4_stage \ - (vm->n_vectors_div_4, \ - vm, \ - vhash_main_gather_keys_stage_##N_KEY_U32, \ - vhash_main_hash_mix_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_stage_##N_KEY_U32, \ - vhash_main_get_stage_##N_KEY_U32); \ - else if (op == SET) \ - clib_pipeline_run_4_stage \ - (vm->n_vectors_div_4, \ - vm, \ - vhash_main_gather_keys_stage_##N_KEY_U32, \ - vhash_main_hash_mix_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_stage_##N_KEY_U32, \ - vhash_main_set_stage_##N_KEY_U32); \ - else \ - clib_pipeline_run_4_stage \ - (vm->n_vectors_div_4, \ - vm, \ - vhash_main_gather_keys_stage_##N_KEY_U32, \ - vhash_main_hash_mix_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_stage_##N_KEY_U32, \ - vhash_main_unset_stage_##N_KEY_U32); \ - break; - - _(4); - _(5); - _(6); - -#undef _ - } - } - - - if (vm->n_vectors_mod_4 > 0) - { - switch (vm->n_key_u32) - { - default: - ASSERT (0); - break; - -#define _(N_KEY_U32) \ - case N_KEY_U32: \ - if (op == GET) \ - clib_pipeline_run_3_stage \ - (1, \ - vm, \ - vhash_main_gather_keys_mod_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_mod_stage_##N_KEY_U32, \ - vhash_main_get_mod_stage_##N_KEY_U32); \ - else if (op == SET) \ - clib_pipeline_run_3_stage \ - (1, \ - vm, \ - vhash_main_gather_keys_mod_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_mod_stage_##N_KEY_U32, \ - vhash_main_set_mod_stage_##N_KEY_U32); \ - else \ - clib_pipeline_run_3_stage \ - (1, \ - vm, \ - vhash_main_gather_keys_mod_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_mod_stage_##N_KEY_U32, \ - vhash_main_unset_mod_stage_##N_KEY_U32); \ - break; - - _(1); - _(2); - _(3); - -#undef _ - -#define _(N_KEY_U32) \ - case N_KEY_U32: \ - if (op == GET) \ - clib_pipeline_run_4_stage \ - (1, \ - vm, \ - vhash_main_gather_keys_mod_stage_##N_KEY_U32, \ - vhash_main_hash_mix_mod_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_mod_stage_##N_KEY_U32, \ - vhash_main_get_mod_stage_##N_KEY_U32); \ - else if (op == SET) \ - clib_pipeline_run_4_stage \ - (1, \ - vm, \ - vhash_main_gather_keys_mod_stage_##N_KEY_U32, \ - vhash_main_hash_mix_mod_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_mod_stage_##N_KEY_U32, \ - vhash_main_set_mod_stage_##N_KEY_U32); \ - else \ - clib_pipeline_run_4_stage \ - (1, \ - vm, \ - vhash_main_gather_keys_mod_stage_##N_KEY_U32, \ - vhash_main_hash_mix_mod_stage_##N_KEY_U32, \ - vhash_main_hash_finalize_mod_stage_##N_KEY_U32, \ - vhash_main_unset_mod_stage_##N_KEY_U32); \ - break; - - _(4); - _(5); - _(6); - -#undef _ - } - } -} - -void -vhash_main_get (vhash_main_t * vm) -{ - vhash_main_op (vm, GET); -} - -void -vhash_main_set (vhash_main_t * vm) -{ - vhash_main_op (vm, SET); -} - -void -vhash_main_unset (vhash_main_t * vm) -{ - vhash_main_op (vm, UNSET); -} - -u32 -vhash_resize_incremental (vhash_resize_t * vr, u32 vector_index, - u32 n_keys_this_call) -{ - vhash_t *old = vr->old; - vhash_main_t *vm = &vr->new; - vhash_t *new = vm->vhash; - uword i, j, n_key_u32; - - n_key_u32 = old->n_key_u32; - - if (vector_index == 0) - { - u32 hash_seeds[3]; - hash_seeds[0] = old->hash_seeds[0].as_u32[0]; - hash_seeds[1] = old->hash_seeds[1].as_u32[0]; - hash_seeds[2] = old->hash_seeds[2].as_u32[0]; - vhash_init (new, old->log2_n_keys + 1, n_key_u32, hash_seeds); - } - - vec_reset_length (vm->keys); - vec_reset_length (vm->results); - - if (0 == (vector_index >> old->log2_n_keys)) - { - for (i = vector_index; 0 == (i >> (old->log2_n_keys - 2)); i++) - { - vhash_search_bucket_t *b = - vhash_get_search_bucket_with_index (old, 4 * i, n_key_u32); - u32 r, *k; - -#define _(I) \ - if ((r = b->result.as_u32[I]) != 0) \ - { \ - vec_add1 (vm->results, r - 1); \ - vec_add2 (vm->keys, k, n_key_u32); \ - for (j = 0; j < n_key_u32; j++) \ - k[j] = b->key[j].as_u32[I]; \ - } - - _(0); - _(1); - _(2); - _(3); - -#undef _ - - if (vec_len (vm->results) >= n_keys_this_call) - { - vhash_main_op (vm, SET); - return i; - } - } - } - - /* Add overflow buckets. */ - { - vhash_overflow_buckets_t *ob; - vhash_overflow_search_bucket_t *b; - - for (ob = old->overflow_buckets; - ob < old->overflow_buckets + ARRAY_LEN (old->overflow_buckets); ob++) - { - foreach_vhash_overflow_bucket (b, ob, old->n_key_u32) - { - u32 r, *k; - -#define _(I) \ - if ((r = b->result.as_u32[I]) != 0) \ - { \ - vec_add1 (vm->results, r - 1); \ - vec_add2 (vm->keys, k, n_key_u32); \ - for (j = 0; j < n_key_u32; j++) \ - k[j] = b->key[j].as_u32[I]; \ - } - - _(0); - _(1); - _(2); - _(3); - -#undef _ - } - } - } - - vhash_main_op (vm, SET); - - /* Let caller know we are done. */ - return ~0; -} - -void -vhash_resize (vhash_t * old, u32 log2_n_keys) -{ - static vhash_resize_t vr; - vhash_t new; - u32 i = 0; - - vr.old = old; - vr.new.vhash = &new; - - while (1) - { - i = vhash_resize_incremental (&vr, i, 1024); - if (i == ~0) - break; - } - - vhash_free (old); - *old = new; -} - -#endif /* CLIB_HAVE_VEC128 */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/vhash.h b/src/vppinfra/vhash.h deleted file mode 100644 index 85dfb788308..00000000000 --- a/src/vppinfra/vhash.h +++ /dev/null @@ -1,850 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2010 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#ifndef included_clib_vhash_h -#define included_clib_vhash_h - -#include <vppinfra/vector.h> - -#ifdef CLIB_HAVE_VEC128 - -#include <vppinfra/cache.h> -#include <vppinfra/hash.h> -#include <vppinfra/pipeline.h> - -/* Gathers 32 bits worth of key with given index. */ -typedef u32 (vhash_key_function_t) (void *state, u32 vector_index, - u32 key_word_index); -typedef u32x4 (vhash_4key_function_t) (void *state, u32 vector_index, - u32 key_word_index); -/* Sets/gets result of hash lookup. */ -typedef u32 (vhash_result_function_t) (void *state, u32 vector_index, - u32 result, u32 n_key_u32); -typedef u32x4 (vhash_4result_function_t) (void *state, u32 vector_index, - u32x4 results, u32 n_key_u32); - -typedef struct -{ - u32x4_union_t hashed_key[3]; -} vhash_hashed_key_t; - -/* Search buckets are really this structure. */ -typedef struct -{ - /* 4 results for this bucket. - Zero is used to mark empty results. This means user can't use the result ~0 - since user results differ from internal results stored in buckets by 1. - e.g. internal result = user result + 1. */ - u32x4_union_t result; - - /* n_key_u32s u32x4s of key data follow. */ - u32x4_union_t key[0]; -} vhash_search_bucket_t; - -typedef struct -{ - u32x4_union_t *search_buckets; - - /* Vector of bucket free indices. */ - u32 *free_indices; - - /* Number of entries in this overflow bucket. */ - u32 n_overflow; -} vhash_overflow_buckets_t; - -typedef struct -{ - /* 2^log2_n_keys keys grouped in groups of 4. - Each bucket contains 4 results plus 4 keys for a - total of (1 + n_key_u32) u32x4s. */ - u32x4_union_t *search_buckets; - - /* When a bucket of 4 results/keys are full we search - the overflow. hash_key is used to select which overflow - bucket. */ - vhash_overflow_buckets_t overflow_buckets[16]; - - /* Total count of occupied elements in hash table. */ - u32 n_elts; - - u32 log2_n_keys; - - /* Number of 32 bit words in a hash key. */ - u32 n_key_u32; - - u32x4_union_t bucket_mask; - - /* table[i] = min_log2 (first_set (~i)). */ - u8 find_first_zero_table[16]; - - /* Hash seeds for Jenkins hash. */ - u32x4_union_t hash_seeds[3]; - - /* Key work space is a vector of length - n_key_u32s << log2_n_key_word_len_u32x. */ - u32 log2_n_key_word_len_u32x; - - /* Work space to store keys between pipeline stages. */ - u32x4_union_t *key_work_space; - - /* Hash work space to store Jenkins hash values between - pipeline stages. */ - vhash_hashed_key_t *hash_work_space; -} vhash_t; - -always_inline vhash_overflow_buckets_t * -vhash_get_overflow_buckets (vhash_t * h, u32 key) -{ - u32 i = (((key & h->bucket_mask.as_u32[0]) >> 2) & 0xf); - ASSERT (i < ARRAY_LEN (h->overflow_buckets)); - return h->overflow_buckets + i; -} - -always_inline uword -vhash_is_non_empty_overflow_bucket (vhash_t * h, u32 key) -{ - u32 i = (((key & h->bucket_mask.as_u32[0]) >> 2) & 0xf); - ASSERT (i < ARRAY_LEN (h->overflow_buckets)); - return h->overflow_buckets[i].n_overflow > 0; -} - -always_inline void -vhash_free_overflow_buckets (vhash_overflow_buckets_t * obs) -{ - vec_free (obs->search_buckets); - vec_free (obs->free_indices); -} - -always_inline void -vhash_free (vhash_t * h) -{ - uword i; - for (i = 0; i < ARRAY_LEN (h->overflow_buckets); i++) - vhash_free_overflow_buckets (&h->overflow_buckets[i]); - vec_free (h->search_buckets); - vec_free (h->key_work_space); - vec_free (h->hash_work_space); -} - -always_inline void -vhash_set_key_word (vhash_t * h, u32 wi, u32 vi, u32 value) -{ - u32 i0 = (wi << h->log2_n_key_word_len_u32x) + (vi / 4); - u32 i1 = vi % 4; - vec_elt (h->key_work_space, i0).as_u32[i1] = value; -} - -always_inline void -vhash_set_key_word_u32x (vhash_t * h, u32 wi, u32 vi, u32x value) -{ - u32 i0 = (wi << h->log2_n_key_word_len_u32x) + (vi / 4); - vec_elt (h->key_work_space, i0).as_u32x4 = value; -} - -always_inline u32 -vhash_get_key_word (vhash_t * h, u32 wi, u32 vi) -{ - u32 i0 = (wi << h->log2_n_key_word_len_u32x) + (vi / 4); - u32 i1 = vi % 4; - return vec_elt (h->key_work_space, i0).as_u32[i1]; -} - -always_inline u32x -vhash_get_key_word_u32x (vhash_t * h, u32 wi, u32 vi) -{ - u32 i0 = (wi << h->log2_n_key_word_len_u32x) + vi; - return vec_elt (h->key_work_space, i0).as_u32x4; -} - -always_inline void -vhash_validate_sizes (vhash_t * h, u32 n_key_u32, u32 n_vectors) -{ - u32 n, l; - - n = max_pow2 (n_vectors) / 4; - n = clib_max (n, 8); - - h->log2_n_key_word_len_u32x = l = min_log2 (n); - vec_validate_aligned (h->key_work_space, (n_key_u32 << l) - 1, - CLIB_CACHE_LINE_BYTES); - vec_validate_aligned (h->hash_work_space, n - 1, CLIB_CACHE_LINE_BYTES); -} - -always_inline void -vhash_gather_key_stage (vhash_t * h, - u32 vector_index, - u32 n_vectors, - vhash_key_function_t key_function, - void *state, u32 n_key_u32s) -{ - u32 i, j, vi; - - /* Gather keys for 4 packets (for 128 bit vector length e.g. u32x4). */ - for (i = 0; i < n_vectors; i++) - { - vi = vector_index * 4 + i; - for (j = 0; j < n_key_u32s; j++) - vhash_set_key_word (h, j, vi, key_function (state, vi, j)); - } -} - -always_inline void -vhash_gather_4key_stage (vhash_t * h, - u32 vector_index, - vhash_4key_function_t key_function, - void *state, u32 n_key_u32s) -{ - u32 j, vi; - vi = vector_index * 4; - for (j = 0; j < n_key_u32s; j++) - vhash_set_key_word_u32x (h, j, vi, key_function (state, vi, j)); -} - -always_inline void -vhash_mix_stage (vhash_t * h, u32 vector_index, u32 n_key_u32s) -{ - i32 i, n_left; - u32x a, b, c; - - /* Only need to do this for keys longer than 12 bytes. */ - ASSERT (n_key_u32s > 3); - - a = h->hash_seeds[0].as_u32x4; - b = h->hash_seeds[1].as_u32x4; - c = h->hash_seeds[2].as_u32x4; - for (i = 0, n_left = n_key_u32s - 3; n_left > 0; n_left -= 3, i += 3) - { - a += - vhash_get_key_word_u32x (h, n_key_u32s - 1 - (i + 0), vector_index); - if (n_left > 1) - b += - vhash_get_key_word_u32x (h, n_key_u32s - 1 - (i + 1), vector_index); - if (n_left > 2) - c += - vhash_get_key_word_u32x (h, n_key_u32s - 1 - (i + 2), vector_index); - - hash_v3_mix_u32x (a, b, c); - } - - /* Save away a, b, c for later finalize. */ - { - vhash_hashed_key_t *hk = - vec_elt_at_index (h->hash_work_space, vector_index); - hk->hashed_key[0].as_u32x4 = a; - hk->hashed_key[1].as_u32x4 = b; - hk->hashed_key[2].as_u32x4 = c; - } -} - -always_inline vhash_search_bucket_t * -vhash_get_search_bucket_with_index (vhash_t * h, u32 i, u32 n_key_u32s) -{ - return ((vhash_search_bucket_t *) - vec_elt_at_index (h->search_buckets, - (i / 4) * - ((sizeof (vhash_search_bucket_t) / - sizeof (u32x4)) + n_key_u32s))); -} - -always_inline vhash_search_bucket_t * -vhash_get_search_bucket (vhash_t * h, u32 key_hash, u32 n_key_u32s) -{ - u32 i = key_hash & h->bucket_mask.as_u32[0]; - return vhash_get_search_bucket_with_index (h, i, n_key_u32s); -} - -always_inline u32x4 -vhash_get_4_search_bucket_byte_offsets (vhash_t * h, u32x4 key_hash, - u32 n_key_u32s) -{ - vhash_search_bucket_t *b; - u32 n_bytes_per_bucket = sizeof (b[0]) + n_key_u32s * sizeof (b->key[0]); - u32x4 r = key_hash & h->bucket_mask.as_u32x4; - - /* Multiply with shifts and adds to get bucket byte offset. */ -#define _(x) u32x4_ishift_left (r, (x) - 2) - if (n_bytes_per_bucket == (1 << 5)) - r = _(5); - else if (n_bytes_per_bucket == ((1 << 5) + (1 << 4))) - r = _(5) + _(4); - else if (n_bytes_per_bucket == (1 << 6)) - r = _(6); - else if (n_bytes_per_bucket == ((1 << 6) + (1 << 4))) - r = _(6) + _(4); - else if (n_bytes_per_bucket == ((1 << 6) + (1 << 5))) - r = _(6) + _(5); - else if (n_bytes_per_bucket == ((1 << 6) + (1 << 5) + (1 << 4))) - r = _(6) + _(5) + _(4); - else - ASSERT (0); -#undef _ - return r; -} - -always_inline void -vhash_finalize_stage (vhash_t * h, u32 vector_index, u32 n_key_u32s) -{ - i32 n_left; - u32x a, b, c; - vhash_hashed_key_t *hk = - vec_elt_at_index (h->hash_work_space, vector_index); - - if (n_key_u32s <= 3) - { - a = h->hash_seeds[0].as_u32x4; - b = h->hash_seeds[1].as_u32x4; - c = h->hash_seeds[2].as_u32x4; - n_left = n_key_u32s; - } - else - { - a = hk->hashed_key[0].as_u32x4; - b = hk->hashed_key[1].as_u32x4; - c = hk->hashed_key[2].as_u32x4; - n_left = 3; - } - - if (n_left > 0) - a += vhash_get_key_word_u32x (h, 0, vector_index); - if (n_left > 1) - b += vhash_get_key_word_u32x (h, 1, vector_index); - if (n_left > 2) - c += vhash_get_key_word_u32x (h, 2, vector_index); - - hash_v3_finalize_u32x (a, b, c); - - /* Only save away last 32 bits of hash code. */ - hk->hashed_key[2].as_u32x4 = c; - - /* Prefetch buckets. This costs a bit for small tables but saves - big for large ones. */ - { - vhash_search_bucket_t *b0, *b1, *b2, *b3; - u32x4_union_t kh; - - kh.as_u32x4 = vhash_get_4_search_bucket_byte_offsets (h, c, n_key_u32s); - hk->hashed_key[1].as_u32x4 = kh.as_u32x4; - - b0 = (void *) h->search_buckets + kh.as_u32[0]; - b1 = (void *) h->search_buckets + kh.as_u32[1]; - b2 = (void *) h->search_buckets + kh.as_u32[2]; - b3 = (void *) h->search_buckets + kh.as_u32[3]; - - CLIB_PREFETCH (b0, sizeof (b0[0]) + n_key_u32s * sizeof (b0->key[0]), - READ); - CLIB_PREFETCH (b1, sizeof (b1[0]) + n_key_u32s * sizeof (b1->key[0]), - READ); - CLIB_PREFETCH (b2, sizeof (b2[0]) + n_key_u32s * sizeof (b2->key[0]), - READ); - CLIB_PREFETCH (b3, sizeof (b3[0]) + n_key_u32s * sizeof (b3->key[0]), - READ); - } -} - -always_inline u32 -vhash_merge_results (u32x4 r) -{ - r = r | u32x4_word_shift_right (r, 2); - r = r | u32x4_word_shift_right (r, 1); - return u32x4_get0 (r); -} - -/* Bucket is full if none of its 4 results are 0. */ -always_inline u32 -vhash_search_bucket_is_full (u32x4 r) -{ - return u32x4_zero_byte_mask (r) == 0; -} - -always_inline u32 -vhash_non_empty_result_index (u32x4 x) -{ - u32 empty_mask = u32x4_zero_byte_mask (x); - ASSERT (empty_mask != 0xffff); - return min_log2 (0xffff & ~empty_mask) / 4; -} - -always_inline u32 -vhash_empty_result_index (u32x4 x) -{ - u32 empty_mask = u32x4_zero_byte_mask (x); - ASSERT (empty_mask != 0); - return min_log2 (0xffff & empty_mask) / 4; -} - -always_inline u32x4 -vhash_bucket_compare (vhash_t * h, - u32x4_union_t * bucket, u32 key_word_index, u32 vi) -{ - u32 k = vhash_get_key_word (h, key_word_index, vi); - u32x4 x = { k, k, k, k }; - return (bucket[key_word_index].as_u32x4 == x); -} - -#define vhash_bucket_compare_4(h,wi,vi,b0,b1,b2,b3,cmp0,cmp1,cmp2,cmp3) \ -do { \ - u32x4 _k4 = vhash_get_key_word_u32x ((h), (wi), (vi)); \ - u32x4 _k0 = u32x4_splat_word (_k4, 0); \ - u32x4 _k1 = u32x4_splat_word (_k4, 1); \ - u32x4 _k2 = u32x4_splat_word (_k4, 2); \ - u32x4 _k3 = u32x4_splat_word (_k4, 3); \ - \ - cmp0 = (b0->key[wi].as_u32x4 == _k0); \ - cmp1 = (b1->key[wi].as_u32x4 == _k1); \ - cmp2 = (b2->key[wi].as_u32x4 == _k2); \ - cmp3 = (b3->key[wi].as_u32x4 == _k3); \ -} while (0) - -u32 vhash_get_overflow (vhash_t * h, u32 key_hash, u32 vi, u32 n_key_u32s); - -always_inline void -vhash_get_stage (vhash_t * h, - u32 vector_index, - u32 n_vectors, - vhash_result_function_t result_function, - void *state, u32 n_key_u32s) -{ - u32 i, j; - vhash_hashed_key_t *hk = - vec_elt_at_index (h->hash_work_space, vector_index); - vhash_search_bucket_t *b; - - for (i = 0; i < n_vectors; i++) - { - u32 vi = vector_index * 4 + i; - u32 key_hash = hk->hashed_key[2].as_u32[i]; - u32 result; - u32x4 r, r0; - - b = vhash_get_search_bucket (h, key_hash, n_key_u32s); - - r = r0 = b->result.as_u32x4; - for (j = 0; j < n_key_u32s; j++) - r &= vhash_bucket_compare (h, &b->key[0], j, vi); - - /* At this point only one of 4 results should be non-zero. - So we can or all 4 together and get the valid result (if there is one). */ - result = vhash_merge_results (r); - - if (!result && vhash_search_bucket_is_full (r0)) - result = vhash_get_overflow (h, key_hash, vi, n_key_u32s); - - result_function (state, vi, result - 1, n_key_u32s); - } -} - -always_inline void -vhash_get_4_stage (vhash_t * h, - u32 vector_index, - vhash_4result_function_t result_function, - void *state, u32 n_key_u32s) -{ - u32 i, vi; - vhash_hashed_key_t *hk = - vec_elt_at_index (h->hash_work_space, vector_index); - vhash_search_bucket_t *b0, *b1, *b2, *b3; - u32x4 r0, r1, r2, r3, r0_before, r1_before, r2_before, r3_before; - u32x4_union_t kh; - - kh.as_u32x4 = hk->hashed_key[1].as_u32x4; - - b0 = (void *) h->search_buckets + kh.as_u32[0]; - b1 = (void *) h->search_buckets + kh.as_u32[1]; - b2 = (void *) h->search_buckets + kh.as_u32[2]; - b3 = (void *) h->search_buckets + kh.as_u32[3]; - - r0 = r0_before = b0->result.as_u32x4; - r1 = r1_before = b1->result.as_u32x4; - r2 = r2_before = b2->result.as_u32x4; - r3 = r3_before = b3->result.as_u32x4; - - vi = vector_index * 4; - - for (i = 0; i < n_key_u32s; i++) - { - u32x4 c0, c1, c2, c3; - vhash_bucket_compare_4 (h, i, vector_index, - b0, b1, b2, b3, c0, c1, c2, c3); - r0 &= c0; - r1 &= c1; - r2 &= c2; - r3 &= c3; - } - - u32x4_transpose (r0, r1, r2, r3); - - /* Gather together 4 results. */ - { - u32x4_union_t r; - u32x4 ones = { 1, 1, 1, 1 }; - u32 not_found_mask; - - r.as_u32x4 = r0 | r1 | r2 | r3; - not_found_mask = u32x4_zero_byte_mask (r.as_u32x4); - not_found_mask &= ((vhash_search_bucket_is_full (r0_before) << (4 * 0)) - | (vhash_search_bucket_is_full (r1_before) << (4 * 1)) - | (vhash_search_bucket_is_full (r2_before) << (4 * 2)) - | (vhash_search_bucket_is_full (r3_before) << - (4 * 3))); - if (not_found_mask) - { - u32x4_union_t key_hash; - - key_hash.as_u32x4 = - hk->hashed_key[2].as_u32x4 & h->bucket_mask.as_u32x4; - - /* Slow path: one of the buckets may have been full and we need to search overflow. */ - if (not_found_mask & (1 << (4 * 0))) - r.as_u32[0] = vhash_get_overflow (h, key_hash.as_u32[0], - vi + 0, n_key_u32s); - if (not_found_mask & (1 << (4 * 1))) - r.as_u32[1] = vhash_get_overflow (h, key_hash.as_u32[1], - vi + 1, n_key_u32s); - if (not_found_mask & (1 << (4 * 2))) - r.as_u32[2] = vhash_get_overflow (h, key_hash.as_u32[2], - vi + 2, n_key_u32s); - if (not_found_mask & (1 << (4 * 3))) - r.as_u32[3] = vhash_get_overflow (h, key_hash.as_u32[3], - vi + 3, n_key_u32s); - } - - result_function (state, vi, r.as_u32x4 - ones, n_key_u32s); - } -} - -u32 -vhash_set_overflow (vhash_t * h, - u32 key_hash, u32 vi, u32 new_result, u32 n_key_u32s); - -always_inline void -vhash_set_stage (vhash_t * h, - u32 vector_index, - u32 n_vectors, - vhash_result_function_t result_function, - void *state, u32 n_key_u32s) -{ - u32 i, j, n_new_elts = 0; - vhash_hashed_key_t *hk = - vec_elt_at_index (h->hash_work_space, vector_index); - vhash_search_bucket_t *b; - - for (i = 0; i < n_vectors; i++) - { - u32 vi = vector_index * 4 + i; - u32 key_hash = hk->hashed_key[2].as_u32[i]; - u32 old_result, new_result; - u32 i_set; - u32x4 r, r0, cmp; - - b = vhash_get_search_bucket (h, key_hash, n_key_u32s); - - cmp = vhash_bucket_compare (h, &b->key[0], 0, vi); - for (j = 1; j < n_key_u32s; j++) - cmp &= vhash_bucket_compare (h, &b->key[0], j, vi); - - r0 = b->result.as_u32x4; - r = r0 & cmp; - - /* At this point only one of 4 results should be non-zero. - So we can or all 4 together and get the valid result (if there is one). */ - old_result = vhash_merge_results (r); - - if (!old_result && vhash_search_bucket_is_full (r0)) - old_result = vhash_get_overflow (h, key_hash, vi, n_key_u32s); - - /* Get new result; possibly do something with old result. */ - new_result = result_function (state, vi, old_result - 1, n_key_u32s); - - /* User cannot use ~0 as a hash result since a result of 0 is - used to mark unused bucket entries. */ - ASSERT (new_result + 1 != 0); - new_result += 1; - - /* Set over-writes existing result. */ - if (old_result) - { - i_set = vhash_non_empty_result_index (r); - b->result.as_u32[i_set] = new_result; - } - else - { - /* Set allocates new result. */ - u32 valid_mask; - - valid_mask = (((b->result.as_u32[0] != 0) << 0) - | ((b->result.as_u32[1] != 0) << 1) - | ((b->result.as_u32[2] != 0) << 2) - | ((b->result.as_u32[3] != 0) << 3)); - - /* Rotate 4 bit valid mask so that key_hash corresponds to bit 0. */ - i_set = key_hash & 3; - valid_mask = - ((valid_mask >> i_set) | (valid_mask << (4 - i_set))) & 0xf; - - /* Insert into first empty position in bucket after key_hash. */ - i_set = (i_set + h->find_first_zero_table[valid_mask]) & 3; - - if (valid_mask != 0xf) - { - n_new_elts += 1; - - b->result.as_u32[i_set] = new_result; - - /* Insert new key into search bucket. */ - for (j = 0; j < n_key_u32s; j++) - b->key[j].as_u32[i_set] = vhash_get_key_word (h, j, vi); - } - else - vhash_set_overflow (h, key_hash, vi, new_result, n_key_u32s); - } - } - - h->n_elts += n_new_elts; -} - -u32 vhash_unset_overflow (vhash_t * h, u32 key_hash, u32 vi, u32 n_key_u32s); - -void -vhash_unset_refill_from_overflow (vhash_t * h, - vhash_search_bucket_t * b, - u32 key_hash, u32 n_key_u32s); - -/* Note: Eliot tried doing 4 unsets at once and could not get a speed up - and abandoned vhash_unset_4_stage. */ -always_inline void -vhash_unset_stage (vhash_t * h, - u32 vector_index, - u32 n_vectors, - vhash_result_function_t result_function, - void *state, u32 n_key_u32s) -{ - u32 i, j, n_elts_unset = 0; - vhash_hashed_key_t *hk = - vec_elt_at_index (h->hash_work_space, vector_index); - vhash_search_bucket_t *b; - - for (i = 0; i < n_vectors; i++) - { - u32 vi = vector_index * 4 + i; - u32 key_hash = hk->hashed_key[2].as_u32[i]; - u32 old_result; - u32x4 cmp, r0; - - b = vhash_get_search_bucket (h, key_hash, n_key_u32s); - - cmp = vhash_bucket_compare (h, &b->key[0], 0, vi); - for (j = 1; j < n_key_u32s; j++) - cmp &= vhash_bucket_compare (h, &b->key[0], j, vi); - - r0 = b->result.as_u32x4; - - /* At this point cmp is all ones where key matches and zero otherwise. - So, this will invalidate results for matching key and do nothing otherwise. */ - b->result.as_u32x4 = r0 & ~cmp; - - old_result = vhash_merge_results (r0 & cmp); - - n_elts_unset += old_result != 0; - - if (vhash_search_bucket_is_full (r0)) - { - if (old_result) - vhash_unset_refill_from_overflow (h, b, key_hash, n_key_u32s); - else - old_result = vhash_unset_overflow (h, key_hash, vi, n_key_u32s); - } - - result_function (state, vi, old_result - 1, n_key_u32s); - } - ASSERT (h->n_elts >= n_elts_unset); - h->n_elts -= n_elts_unset; -} - -void vhash_init (vhash_t * h, u32 log2_n_keys, u32 n_key_u32, - u32 * hash_seeds); - -void vhash_resize (vhash_t * old, u32 log2_n_keys); - -typedef struct -{ - vhash_t *vhash; - - union - { - struct - { - u32 *keys; - u32 *results; - }; - - /* Vector layout for get keys. */ - struct - { - u32x4_union_t *get_keys; - u32x4_union_t *get_results; - }; - }; - - u32 n_vectors_div_4; - u32 n_vectors_mod_4; - - u32 n_key_u32; - - u32 n_keys; -} vhash_main_t; - -always_inline u32 -vhash_get_alloc_keys (vhash_main_t * vm, u32 n_keys, u32 n_key_u32) -{ - u32 i, n; - - i = vm->n_keys; - vm->n_keys = i + n_keys; - - n = (round_pow2 (vm->n_keys, 4) / 4) * n_key_u32; - - vec_validate_aligned (vm->get_keys, n - 1, sizeof (vm->get_keys[0])); - vec_validate_aligned (vm->get_results, n - 1, sizeof (vm->get_results[0])); - - return i; -} - -always_inline void -vhash_get_set_key_word (vhash_main_t * vm, u32 vi, u32 wi, u32 n_key_u32, - u32 value) -{ - u32x4_union_t *k = vec_elt_at_index (vm->get_keys, (vi / 4) * n_key_u32); - ASSERT (wi < n_key_u32); - k[wi].as_u32[vi % 4] = value; -} - -always_inline u32 -vhash_get_fetch_result (vhash_main_t * vm, u32 vi) -{ - u32x4_union_t *r = vec_elt_at_index (vm->get_results, vi / 4); - return r->as_u32[vi % 4]; -} - -void vhash_main_get (vhash_main_t * vm); - -always_inline u32 -vhash_set_alloc_keys (vhash_main_t * vm, u32 n_keys, u32 n_key_u32) -{ - u32 i; - - i = vm->n_keys; - vm->n_keys = i + n_keys; - - vec_resize (vm->keys, n_keys * n_key_u32); - vec_resize (vm->results, n_keys); - - return i; -} - -always_inline void -vhash_set_set_key_word (vhash_main_t * vm, u32 vi, u32 wi, u32 n_key_u32, - u32 value) -{ - u32 *k = vec_elt_at_index (vm->keys, vi * n_key_u32); - ASSERT (wi < n_key_u32); - k[wi] = value; -} - -always_inline void -vhash_set_set_result (vhash_main_t * vm, u32 vi, u32 result) -{ - u32 *r = vec_elt_at_index (vm->results, vi); - r[0] = result; -} - -always_inline u32 -vhash_set_fetch_old_result (vhash_main_t * vm, u32 vi) -{ - u32 *r = vec_elt_at_index (vm->results, vi); - return r[0]; -} - -void vhash_main_set (vhash_main_t * vm); - -always_inline u32 -vhash_unset_alloc_keys (vhash_main_t * vm, u32 n_keys, u32 n_key_u32) -{ - return vhash_set_alloc_keys (vm, n_keys, n_key_u32); -} - -always_inline void -vhash_unset_set_key_word (vhash_main_t * vm, u32 vi, u32 wi, u32 n_key_u32, - u32 value) -{ - vhash_set_set_key_word (vm, vi, wi, n_key_u32, value); -} - -always_inline void -vhash_unset_set_result (vhash_main_t * vm, u32 vi, u32 result) -{ - vhash_set_set_result (vm, vi, result); -} - -always_inline u32 -vhash_unset_fetch_old_result (vhash_main_t * vm, u32 vi) -{ - return vhash_set_fetch_old_result (vm, vi); -} - -void vhash_main_unset (vhash_main_t * vm); - -typedef struct -{ - vhash_main_t new; - - vhash_t *old; -} vhash_resize_t; - -u32 vhash_resize_incremental (vhash_resize_t * vr, u32 vector_index, - u32 n_vectors); - -#endif /* CLIB_HAVE_VEC128 */ - -#endif /* included_clib_vhash_h */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/xy.h b/src/vppinfra/xy.h deleted file mode 100644 index fb562161a62..00000000000 --- a/src/vppinfra/xy.h +++ /dev/null @@ -1,56 +0,0 @@ -/* (X,Y) coordinates. */ - -/* - Copyright (c) 2008 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#ifndef included_clib_xy_h -#define included_clib_xy_h - -#include <vppinfra/types.h> - -/* Basic definitions: coordinates and points. */ -typedef double xy_float_t; -typedef __complex__ double xy_t; -typedef __complex__ int ixy_t; - -typedef __complex__ char i8xy_t; -typedef __complex__ short i16xy_t; -typedef __complex__ int i32xy_t; - -/* X/Y components of a point: can be used as either rvalue/lvalue. */ -#define xy_x(x) __real__ (x) -#define xy_y(x) __imag__ (x) - -/* Unit vectors in x/y directions. */ -#define xy_x_unit_vector (1) -#define xy_y_unit_vector (1I) - -#endif /* included_clib_xy_h */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/zvec.c b/src/vppinfra/zvec.c deleted file mode 100644 index d062e5f7db1..00000000000 --- a/src/vppinfra/zvec.c +++ /dev/null @@ -1,442 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2001, 2002, 2003, 2005 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#include <vppinfra/bitmap.h> -#include <vppinfra/bitops.h> /* for next_with_same_number_of_set_bits */ -#include <vppinfra/error.h> /* for ASSERT */ -#include <vppinfra/mem.h> -#include <vppinfra/os.h> /* for os_panic */ -#include <vppinfra/vec.h> -#include <vppinfra/zvec.h> - -/* Consider coding as bitmap, coding = 2^c_0 + 2^c_1 + ... + 2^c_n - With c_0 < c_1 < ... < c_n. coding == 0 represents c_n = BITS (uword). - - Unsigned integers i = 0 ... are represented as follows: - - 0 <= i < 2^c_0 (i << 1) | (1 << 0) binary: i 1 - 2^c_0 <= i < 2^c_0 + 2^c_1 (i << 2) | (1 << 1) binary: i 1 0 - ... binary: i 0 ... 0 - - Smaller numbers use less bits. Coding is chosen so that encoding - of given histogram of typical values gives smallest number of bits. - The number and position of coding bits c_i are used to best fit the - histogram of typical values. -*/ - -/* Decode given compressed data. Return number of compressed data - bits used. */ -uword -zvec_decode (uword coding, uword zdata, uword * n_zdata_bits) -{ - uword c, d, result, n_bits; - uword explicit_end, implicit_end; - - result = 0; - n_bits = 0; - while (1) - { - c = first_set (coding); - implicit_end = c == coding; - explicit_end = (zdata & 1) & ~implicit_end; - d = (zdata >> explicit_end) & (c - 1); - if (explicit_end | implicit_end) - { - result += d; - n_bits += min_log2 (c) + explicit_end; - break; - } - n_bits += 1; - result += c; - coding ^= c; - zdata >>= 1; - } - - if (coding == 0) - n_bits = BITS (uword); - - *n_zdata_bits = n_bits; - return result; -} - -uword -zvec_encode (uword coding, uword data, uword * n_result_bits) -{ - uword c, shift, result; - uword explicit_end, implicit_end; - - /* Data must be in range. Note special coding == 0 - would break for data - 1 <= coding. */ - ASSERT (data <= coding - 1); - - shift = 0; - while (1) - { - c = first_set (coding); - implicit_end = c == coding; - explicit_end = ((data & (c - 1)) == data); - if (explicit_end | implicit_end) - { - uword t = explicit_end & ~implicit_end; - result = ((data << t) | t) << shift; - *n_result_bits = - /* data bits */ (c == 0 ? BITS (uword) : min_log2 (c)) - /* shift bits */ + shift + t; - return result; - } - data -= c; - coding ^= c; - shift++; - } - - /* Never reached. */ - ASSERT (0); - return ~0; -} - -always_inline uword -get_data (void *data, uword data_bytes, uword is_signed) -{ - if (data_bytes == 1) - return is_signed ? zvec_signed_to_unsigned (*(i8 *) data) : *(u8 *) data; - else if (data_bytes == 2) - return is_signed ? zvec_signed_to_unsigned (*(i16 *) data) : *(u16 *) - data; - else if (data_bytes == 4) - return is_signed ? zvec_signed_to_unsigned (*(i32 *) data) : *(u32 *) - data; - else if (data_bytes == 8) - return is_signed ? zvec_signed_to_unsigned (*(i64 *) data) : *(u64 *) - data; - else - { - os_panic (); - return ~0; - } -} - -always_inline void -put_data (void *data, uword data_bytes, uword is_signed, uword x) -{ - if (data_bytes == 1) - { - if (is_signed) - *(i8 *) data = zvec_unsigned_to_signed (x); - else - *(u8 *) data = x; - } - else if (data_bytes == 2) - { - if (is_signed) - *(i16 *) data = zvec_unsigned_to_signed (x); - else - *(u16 *) data = x; - } - else if (data_bytes == 4) - { - if (is_signed) - *(i32 *) data = zvec_unsigned_to_signed (x); - else - *(u32 *) data = x; - } - else if (data_bytes == 8) - { - if (is_signed) - *(i64 *) data = zvec_unsigned_to_signed (x); - else - *(u64 *) data = x; - } - else - { - os_panic (); - } -} - -always_inline uword * -zvec_encode_inline (uword * zvec, - uword * zvec_n_bits, - uword coding, - void *data, - uword data_stride, - uword n_data, uword data_bytes, uword is_signed) -{ - uword i; - - i = *zvec_n_bits; - while (n_data >= 1) - { - uword d0, z0, l0; - - d0 = get_data (data + 0 * data_stride, data_bytes, is_signed); - data += 1 * data_stride; - n_data -= 1; - - z0 = zvec_encode (coding, d0, &l0); - zvec = clib_bitmap_set_multiple (zvec, i, z0, l0); - i += l0; - } - - *zvec_n_bits = i; - return zvec; -} - -#define _(TYPE,IS_SIGNED) \ - uword * zvec_encode_##TYPE (uword * zvec, \ - uword * zvec_n_bits, \ - uword coding, \ - void * data, \ - uword data_stride, \ - uword n_data) \ - { \ - return zvec_encode_inline (zvec, zvec_n_bits, \ - coding, \ - data, data_stride, n_data, \ - /* data_bytes */ sizeof (TYPE), \ - /* is_signed */ IS_SIGNED); \ - } - -_(u8, /* is_signed */ 0); -_(u16, /* is_signed */ 0); -_(u32, /* is_signed */ 0); -_(u64, /* is_signed */ 0); -_(i8, /* is_signed */ 1); -_(i16, /* is_signed */ 1); -_(i32, /* is_signed */ 1); -_(i64, /* is_signed */ 1); - -#undef _ - -always_inline uword -coding_max_n_bits (uword coding) -{ - uword n_bits; - (void) zvec_decode (coding, 0, &n_bits); - return n_bits; -} - -always_inline void -zvec_decode_inline (uword * zvec, - uword * zvec_n_bits, - uword coding, - void *data, - uword data_stride, - uword n_data, uword data_bytes, uword is_signed) -{ - uword i, n_max; - - i = *zvec_n_bits; - n_max = coding_max_n_bits (coding); - while (n_data >= 1) - { - uword d0, z0, l0; - - z0 = clib_bitmap_get_multiple (zvec, i, n_max); - d0 = zvec_decode (coding, z0, &l0); - i += l0; - put_data (data + 0 * data_stride, data_bytes, is_signed, d0); - data += 1 * data_stride; - n_data -= 1; - } - *zvec_n_bits = i; -} - -#define _(TYPE,IS_SIGNED) \ - void zvec_decode_##TYPE (uword * zvec, \ - uword * zvec_n_bits, \ - uword coding, \ - void * data, \ - uword data_stride, \ - uword n_data) \ - { \ - return zvec_decode_inline (zvec, zvec_n_bits, \ - coding, \ - data, data_stride, n_data, \ - /* data_bytes */ sizeof (TYPE), \ - /* is_signed */ IS_SIGNED); \ - } - -_(u8, /* is_signed */ 0); -_(u16, /* is_signed */ 0); -_(u32, /* is_signed */ 0); -_(u64, /* is_signed */ 0); -_(i8, /* is_signed */ 1); -_(i16, /* is_signed */ 1); -_(i32, /* is_signed */ 1); -_(i64, /* is_signed */ 1); - -#undef _ - -/* Compute number of bits needed to encode given histogram. */ -static uword -zvec_coding_bits (uword coding, uword * histogram_counts, uword min_bits) -{ - uword n_type_bits, n_bits; - uword this_count, last_count, max_count_index; - uword i, b, l; - - n_bits = 0; - n_type_bits = 1; - last_count = 0; - max_count_index = vec_len (histogram_counts) - 1; - - /* Coding is not large enough to encode given data. */ - if (coding <= max_count_index) - return ~0; - - i = 0; - while (coding != 0) - { - b = first_set (coding); - l = min_log2 (b); - i += b; - - this_count = - histogram_counts[i > max_count_index ? max_count_index : i - 1]; - - /* No more data to encode? */ - if (this_count == last_count) - break; - - /* Last coding is i 0 ... 0 so we don't need an extra type bit. */ - if (coding == b) - n_type_bits--; - - n_bits += (this_count - last_count) * (n_type_bits + l); - - /* This coding cannot be minimal: so return. */ - if (n_bits >= min_bits) - return ~0; - - last_count = this_count; - coding ^= b; - n_type_bits++; - } - - return n_bits; -} - -uword -_zvec_coding_from_histogram (void *histogram, - uword histogram_len, - uword histogram_elt_count_offset, - uword histogram_elt_bytes, - uword max_value_to_encode, - zvec_coding_info_t * coding_return) -{ - uword coding, min_coding; - uword min_coding_bits, coding_bits; - uword i, n_bits_set, total_count; - uword *counts; - zvec_histogram_count_t *h_count = histogram + histogram_elt_count_offset; - - if (histogram_len < 1) - { - coding_return->coding = 0; - coding_return->min_coding_bits = 0; - coding_return->n_data = 0; - coding_return->n_codes = 0; - coding_return->ave_coding_bits = 0; - return 0; - } - - total_count = 0; - counts = vec_new (uword, histogram_len); - for (i = 0; i < histogram_len; i++) - { - zvec_histogram_count_t this_count = h_count[0]; - total_count += this_count; - counts[i] = total_count; - h_count = - (zvec_histogram_count_t *) ((void *) h_count + histogram_elt_bytes); - } - - min_coding = 0; - min_coding_bits = ~0; - - { - uword base_coding = - max_value_to_encode != - ~0 ? (1 + max_value_to_encode) : vec_len (counts); - uword max_coding = max_pow2 (2 * base_coding); - - for (n_bits_set = 1; n_bits_set <= 8; n_bits_set++) - { - for (coding = pow2_mask (n_bits_set); - coding < max_coding; - coding = next_with_same_number_of_set_bits (coding)) - { - coding_bits = zvec_coding_bits (coding, counts, min_coding_bits); - if (coding_bits >= min_coding_bits) - continue; - min_coding_bits = coding_bits; - min_coding = coding; - } - } - } - - if (coding_return) - { - coding_return->coding = min_coding; - coding_return->min_coding_bits = min_coding_bits; - coding_return->n_data = total_count; - coding_return->n_codes = vec_len (counts); - coding_return->ave_coding_bits = - (f64) min_coding_bits / (f64) total_count; - } - - vec_free (counts); - - return min_coding; -} - -u8 * -format_zvec_coding (u8 * s, va_list * args) -{ - zvec_coding_info_t *c = va_arg (*args, zvec_coding_info_t *); - return format (s, - "zvec coding 0x%x, %d elts, %d codes, %d bits total, %.4f ave bits/code", - c->coding, c->n_data, c->n_codes, c->min_coding_bits, - c->ave_coding_bits); -} - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ diff --git a/src/vppinfra/zvec.h b/src/vppinfra/zvec.h deleted file mode 100644 index 7d35a3fe41f..00000000000 --- a/src/vppinfra/zvec.h +++ /dev/null @@ -1,166 +0,0 @@ -/* - * Copyright (c) 2015 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. - */ -/* - Copyright (c) 2001, 2002, 2003 Eliot Dresselhaus - - Permission is hereby granted, free of charge, to any person obtaining - a copy of this software and associated documentation files (the - "Software"), to deal in the Software without restriction, including - without limitation the rights to use, copy, modify, merge, publish, - distribute, sublicense, and/or sell copies of the Software, and to - permit persons to whom the Software is furnished to do so, subject to - the following conditions: - - The above copyright notice and this permission notice shall be - included in all copies or substantial portions of the Software. - - THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, - EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF - MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND - NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE - LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION - OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION - WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -*/ - -#ifndef included_zvec_h -#define included_zvec_h - -#include <vppinfra/clib.h> -#include <vppinfra/error.h> /* for ASSERT */ -#include <vppinfra/format.h> - -/* zvec: compressed vectors. - - Data is entropy coded with 32 bit "codings". - - Consider coding as bitmap, coding = 2^c_0 + 2^c_1 + ... + 2^c_n - With c_0 < c_1 < ... < c_n. coding == 0 represents c_n = BITS (uword). - - Unsigned integers i = 0 ... are represented as follows: - - 0 <= i < 2^c_0 (i << 1) | (1 << 0) binary: i 1 - 2^c_0 <= i < 2^c_0 + 2^c_1 (i << 2) | (1 << 1) binary: i 1 0 - ... binary: i 0 ... 0 - - Smaller numbers use less bits. Coding is chosen so that encoding - of given histogram of typical values gives smallest number of bits. - The number and position of coding bits c_i are used to best fit the - histogram of typical values. -*/ - -typedef struct -{ - /* Smallest coding for given histogram of typical data. */ - u32 coding; - - /* Number of data in histogram. */ - u32 n_data; - - /* Number of codes (unique values) in histogram. */ - u32 n_codes; - - /* Number of bits in smallest coding of data. */ - u32 min_coding_bits; - - /* Average number of bits per code. */ - f64 ave_coding_bits; -} zvec_coding_info_t; - -/* Encode/decode data. */ -uword zvec_encode (uword coding, uword data, uword * n_result_bits); -uword zvec_decode (uword coding, uword zdata, uword * n_zdata_bits); - -format_function_t format_zvec_coding; - -typedef u32 zvec_histogram_count_t; - -#define zvec_coding_from_histogram(h,count_field,len,max_value_to_encode,zc) \ - _zvec_coding_from_histogram ((h), (len), \ - STRUCT_OFFSET_OF_VAR (h, count_field), \ - sizeof (h[0]), \ - max_value_to_encode, \ - (zc)) - -uword -_zvec_coding_from_histogram (void *_histogram, - uword histogram_len, - uword histogram_elt_count_offset, - uword histogram_elt_bytes, - uword max_value_to_encode, - zvec_coding_info_t * coding_info_return); - -#define _(TYPE,IS_SIGNED) \ - uword * zvec_encode_##TYPE (uword * zvec, uword * zvec_n_bits, uword coding, \ - void * data, uword data_stride, uword n_data); - -_(u8, /* is_signed */ 0); -_(u16, /* is_signed */ 0); -_(u32, /* is_signed */ 0); -_(u64, /* is_signed */ 0); -_(i8, /* is_signed */ 1); -_(i16, /* is_signed */ 1); -_(i32, /* is_signed */ 1); -_(i64, /* is_signed */ 1); - -#undef _ - -#define _(TYPE,IS_SIGNED) \ - void zvec_decode_##TYPE (uword * zvec, \ - uword * zvec_n_bits, \ - uword coding, \ - void * data, \ - uword data_stride, \ - uword n_data) - -_(u8, /* is_signed */ 0); -_(u16, /* is_signed */ 0); -_(u32, /* is_signed */ 0); -_(u64, /* is_signed */ 0); -_(i8, /* is_signed */ 1); -_(i16, /* is_signed */ 1); -_(i32, /* is_signed */ 1); -_(i64, /* is_signed */ 1); - -#undef _ - -/* Signed <=> unsigned conversion. - -1, -2, -3, ... => 1, 3, 5, ... odds - 0, +1, +2, +3, ... => 0, 2, 4, 6, ... evens */ -always_inline uword -zvec_signed_to_unsigned (word s) -{ - uword a = s < 0; - s = 2 * s + a; - return a ? -s : s; -} - -always_inline word -zvec_unsigned_to_signed (uword u) -{ - uword a = u & 1; - u >>= 1; - return a ? -u : u; -} - -#endif /* included_zvec_h */ - -/* - * fd.io coding-style-patch-verification: ON - * - * Local Variables: - * eval: (c-set-style "gnu") - * End: - */ |