git-lng-odp

git-lng-odp@lists.linaro.org

2 participants
1206 discussions

[COMMIT] branch master updated. v1.10.1.0-40-ga97db1b

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, master has been updated via a97db1b8b46b9656f964ccf09ce28941ae062507 (commit) via d1d06aa241b97e2f1919ee990168a21319a66143 (commit) via c2784fbafbf8a29b6daa48429133e25b777536cf (commit) via 9f0f2b86309aa8021ec937e7c0ee1d6f48b0d769 (commit) from c03685af2895b20a5e8a046ea910254a96ab15c4 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit a97db1b8b46b9656f964ccf09ce28941ae062507 Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Mon Jul 4 18:42:26 2016 +0300 example: hello: add hello world example application This is a minimal application which demonstrates the startup and shutdown steps of an ODP application. It can be also used to debug API related build problems, etc. It does not use helpers to minimize dependency to anything else than the ODP API header file. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/example/Makefile.am b/example/Makefile.am index 7f82c4d..37542af 100644 --- a/example/Makefile.am +++ b/example/Makefile.am @@ -1 +1 @@ -SUBDIRS = classifier generator ipsec packet time timer traffic_mgmt l2fwd_simple switch +SUBDIRS = classifier generator ipsec packet time timer traffic_mgmt l2fwd_simple switch hello diff --git a/example/hello/.gitignore b/example/hello/.gitignore new file mode 100644 index 0000000..7c11c4c --- /dev/null +++ b/example/hello/.gitignore @@ -0,0 +1,3 @@ +odp_hello +*.log +*.trs diff --git a/example/hello/Makefile.am b/example/hello/Makefile.am new file mode 100644 index 0000000..2e4e0ce --- /dev/null +++ b/example/hello/Makefile.am @@ -0,0 +1,11 @@ +include $(top_srcdir)/example/Makefile.inc + +bin_PROGRAMS = odp_hello$(EXEEXT) +odp_hello_LDFLAGS = $(AM_LDFLAGS) -static +odp_hello_CFLAGS = $(AM_CFLAGS) -I${top_srcdir}/example + +dist_odp_hello_SOURCES = odp_hello.c + +if test_example +TESTS = odp_hello +endif diff --git a/example/hello/odp_hello.c b/example/hello/odp_hello.c new file mode 100644 index 0000000..6d114ee --- /dev/null +++ b/example/hello/odp_hello.c @@ -0,0 +1,107 @@ +/* Copyright (c) 2016, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/* This is a minimal application which demonstrates the startup and shutdown + * steps of an ODP application. It can be also used to debug API related + * build problems, etc. It does not use helpers to minimize dependency to + * anything else than the ODP API header file. + */ + +/* Linux CPU affinity */ +#define _GNU_SOURCE +#include <sched.h> + +/* Linux PID */ +#include <sys/types.h> +#include <unistd.h> + +#include <stdio.h> +#include <string.h> + +#include <odp_api.h> + +typedef struct { + int cpu; + int num; +} options_t; + +static int parse_args(int argc, char *argv[], options_t *opt) +{ + static const char * const args[] = {"-c", "-n"}; + int i, tmp; + + for (i = 1; i < argc; i++) { + if ((strcmp(argv[i], args[0]) == 0) && + (sscanf(argv[i + 1], "%i", &tmp) == 1)) { + opt->cpu = tmp; + i++; + } else if ((strcmp(argv[i], args[1]) == 0) && + (sscanf(argv[i + 1], "%i", &tmp) == 1)) { + opt->num = tmp; + i++; + } else { + printf("\nUsage:\n" + " %s CPU number\n" + " %s Number of iterations\n\n", + args[0], args[1]); + return -1; + } + } + + return 0; +} + +int main(int argc, char *argv[]) +{ + odp_instance_t inst; + options_t opt; + pid_t pid; + cpu_set_t cpu_set; + int i; + + memset(&opt, 0, sizeof(opt)); + opt.cpu = 0; + opt.num = 1; + + if (parse_args(argc, argv, &opt)) + return -1; + + pid = getpid(); + CPU_ZERO(&cpu_set); + CPU_SET(opt.cpu, &cpu_set); + + if (sched_setaffinity(pid, sizeof(cpu_set_t), &cpu_set)) { + printf("Set CPU affinity failed.\n"); + return -1; + } + + if (odp_init_global(&inst, NULL, NULL)) { + printf("Global init failed.\n"); + return -1; + } + + if (odp_init_local(inst, ODP_THREAD_CONTROL)) { + printf("Local init failed.\n"); + return -1; + } + + for (i = 0; i < opt.num; i++) { + printf("Hello world from CPU %i!\n", odp_cpu_id()); + odp_time_wait_ns(ODP_TIME_SEC_IN_NS); + } + + if (odp_term_local()) { + printf("Local term failed.\n"); + return -1; + } + + if (odp_term_global(inst)) { + printf("Global term failed.\n"); + return -1; + } + + return 0; +} diff --git a/example/m4/configure.m4 b/example/m4/configure.m4 index 9731d81..bbda38f 100644 --- a/example/m4/configure.m4 +++ b/example/m4/configure.m4 @@ -19,4 +19,5 @@ AC_CONFIG_FILES([example/classifier/Makefile example/timer/Makefile example/traffic_mgmt/Makefile example/l2fwd_simple/Makefile - example/switch/Makefile]) + example/switch/Makefile + example/hello/Makefile]) commit d1d06aa241b97e2f1919ee990168a21319a66143 Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Mon Jul 4 18:42:25 2016 +0300 linux-gen: std_types: remove extra c headers Removed C header includes which are not needed for API definitions. ODP API depends on uint64_t, etc types in stdint.h, but not other C headers. As an exception, stdbool.h remains since 'true' and 'false' definitions may be used with odp_bool_t. It could be also removed later since true/false are not part of the API (where as uint64_t, etc types). Application needs to include other C library headers directly. ODP API does not specify which headers are included by odp_api.h. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/example/classifier/odp_classifier.c b/example/classifier/odp_classifier.c index 20e64ec..1bd2414 100644 --- a/example/classifier/odp_classifier.c +++ b/example/classifier/odp_classifier.c @@ -8,6 +8,7 @@ #include <string.h> #include <getopt.h> #include <unistd.h> +#include <inttypes.h> #include <example_debug.h> #include <odp_api.h> diff --git a/example/generator/odp_generator.c b/example/generator/odp_generator.c index 8393244..3fea112 100644 --- a/example/generator/odp_generator.c +++ b/example/generator/odp_generator.c @@ -13,6 +13,7 @@ #include <stdlib.h> #include <getopt.h> #include <unistd.h> +#include <inttypes.h> #include <sys/time.h> #include <example_debug.h> diff --git a/example/ipsec/odp_ipsec.c b/example/ipsec/odp_ipsec.c index 451bb2d..d8ca791 100644 --- a/example/ipsec/odp_ipsec.c +++ b/example/ipsec/odp_ipsec.c @@ -18,6 +18,7 @@ #include <stdlib.h> #include <getopt.h> #include <unistd.h> +#include <inttypes.h> #include <example_debug.h> diff --git a/example/packet/odp_pktio.c b/example/packet/odp_pktio.c index 564c63a..6e14abb 100644 --- a/example/packet/odp_pktio.c +++ b/example/packet/odp_pktio.c @@ -8,6 +8,7 @@ #include <string.h> #include <getopt.h> #include <unistd.h> +#include <inttypes.h> #include <example_debug.h> diff --git a/example/switch/odp_switch.c b/example/switch/odp_switch.c index 09835c0..5ce71a9 100644 --- a/example/switch/odp_switch.c +++ b/example/switch/odp_switch.c @@ -7,6 +7,8 @@ #include <stdio.h> #include <getopt.h> #include <unistd.h> +#include <stdlib.h> +#include <inttypes.h> #include <odp_api.h> #include <odp/helper/linux.h> diff --git a/example/time/time_global_test.c b/example/time/time_global_test.c index 372d96b..380ec52 100644 --- a/example/time/time_global_test.c +++ b/example/time/time_global_test.c @@ -7,6 +7,7 @@ #include <odp_api.h> #include <example_debug.h> #include <odp/helper/linux.h> +#include <inttypes.h> #define MAX_WORKERS 32 #define ITERATION_NUM 2048 diff --git a/example/timer/odp_timer_simple.c b/example/timer/odp_timer_simple.c index f33add9..98c08ce 100644 --- a/example/timer/odp_timer_simple.c +++ b/example/timer/odp_timer_simple.c @@ -12,6 +12,7 @@ #include <string.h> #include <stdlib.h> +#include <inttypes.h> #include <example_debug.h> /* ODP main header */ diff --git a/example/timer/odp_timer_test.c b/example/timer/odp_timer_test.c index cb58dfe..035ab2e 100644 --- a/example/timer/odp_timer_test.c +++ b/example/timer/odp_timer_test.c @@ -6,6 +6,7 @@ #include <string.h> #include <stdlib.h> +#include <inttypes.h> #include <example_debug.h> diff --git a/helper/chksum.c b/helper/chksum.c index 859d1ec..8f18881 100644 --- a/helper/chksum.c +++ b/helper/chksum.c @@ -9,6 +9,8 @@ #include <odp/helper/udp.h> #include <odp/helper/tcp.h> #include <odp/helper/chksum.h> +#include <stddef.h> +#include <stdbool.h> /* The following union type is used to "view" an ordered set of bytes (either * 2 or 4) as 1 or 2 16-bit quantities - using host endian order. */ diff --git a/helper/linux.c b/helper/linux.c index a1dbe52..bb4b22c 100644 --- a/helper/linux.c +++ b/helper/linux.c @@ -17,6 +17,7 @@ #include <stdlib.h> #include <string.h> #include <stdio.h> +#include <stdbool.h> #include <odp_api.h> #include <odp/helper/linux.h> diff --git a/platform/linux-generic/include/odp/api/std_types.h b/platform/linux-generic/include/odp/api/std_types.h index d4eeb5d..b61f33f 100644 --- a/platform/linux-generic/include/odp/api/std_types.h +++ b/platform/linux-generic/include/odp/api/std_types.h @@ -17,13 +17,11 @@ extern "C" { #endif -#include <stdlib.h> +/* uint64_t, uint32_t, etc */ #include <stdint.h> -#include <stddef.h> + +/* true and false for odp_bool_t */ #include <stdbool.h> -#include <stdint.h> -#include <inttypes.h> -#include <limits.h> /** @addtogroup odp_system ODP SYSTEM * @{ diff --git a/platform/linux-generic/include/odp_atomic_internal.h b/platform/linux-generic/include/odp_atomic_internal.h index 67e8f82..dca2175 100644 --- a/platform/linux-generic/include/odp_atomic_internal.h +++ b/platform/linux-generic/include/odp_atomic_internal.h @@ -20,6 +20,7 @@ #include <odp/api/align.h> #include <odp/api/hints.h> #include <odp/api/atomic.h> +#include <stdbool.h> #ifdef __cplusplus extern "C" { diff --git a/platform/linux-generic/include/odp_buffer_internal.h b/platform/linux-generic/include/odp_buffer_internal.h index a427a80..f21364c 100644 --- a/platform/linux-generic/include/odp_buffer_internal.h +++ b/platform/linux-generic/include/odp_buffer_internal.h @@ -31,6 +31,7 @@ extern "C" { #include <odp/api/event.h> #include <odp_forward_typedefs_internal.h> #include <odp_schedule_if.h> +#include <stddef.h> #define ODP_BITSIZE(x) \ ((x) <= 2 ? 1 : \ diff --git a/platform/linux-generic/include/odp_packet_socket.h b/platform/linux-generic/include/odp_packet_socket.h index 09a571b..ccff69a 100644 --- a/platform/linux-generic/include/odp_packet_socket.h +++ b/platform/linux-generic/include/odp_packet_socket.h @@ -12,6 +12,7 @@ #include <linux/if_ether.h> #include <sys/socket.h> #include <string.h> +#include <stddef.h> #include <odp/api/align.h> #include <odp/api/buffer.h> diff --git a/platform/linux-generic/odp_buffer.c b/platform/linux-generic/odp_buffer.c index 69f913d..e7e4d58 100644 --- a/platform/linux-generic/odp_buffer.c +++ b/platform/linux-generic/odp_buffer.c @@ -12,7 +12,7 @@ #include <string.h> #include <stdio.h> - +#include <inttypes.h> odp_buffer_t odp_buffer_from_event(odp_event_t ev) { diff --git a/platform/linux-generic/odp_classification.c b/platform/linux-generic/odp_classification.c index 0602a62..027a7ce 100644 --- a/platform/linux-generic/odp_classification.c +++ b/platform/linux-generic/odp_classification.c @@ -21,6 +21,7 @@ #include <odp/helper/eth.h> #include <string.h> #include <errno.h> +#include <stdbool.h> #include <odp/api/spinlock.h> #define LOCK(a) odp_spinlock_lock(a) diff --git a/platform/linux-generic/odp_hash.c b/platform/linux-generic/odp_hash.c index 0e09282..55876c3 100644 --- a/platform/linux-generic/odp_hash.c +++ b/platform/linux-generic/odp_hash.c @@ -40,6 +40,8 @@ #include <odp/api/hash.h> #include <odp/api/std_types.h> +#include <stddef.h> + static const uint32_t crc32c_tables[8][256] = {{ 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c index 9f81073..0a868e9 100644 --- a/platform/linux-generic/odp_packet.c +++ b/platform/linux-generic/odp_packet.c @@ -18,6 +18,7 @@ #include <errno.h> #include <string.h> #include <stdio.h> +#include <inttypes.h> /* * diff --git a/platform/linux-generic/odp_packet_io.c b/platform/linux-generic/odp_packet_io.c index 5b202e7..0b9939b 100644 --- a/platform/linux-generic/odp_packet_io.c +++ b/platform/linux-generic/odp_packet_io.c @@ -24,6 +24,7 @@ #include <odp/api/time.h> #include <string.h> +#include <inttypes.h> #include <sys/ioctl.h> #include <ifaddrs.h> #include <errno.h> diff --git a/platform/linux-generic/odp_pkt_queue.c b/platform/linux-generic/odp_pkt_queue.c index cbe1e74..7734ee9 100644 --- a/platform/linux-generic/odp_pkt_queue.c +++ b/platform/linux-generic/odp_pkt_queue.c @@ -10,6 +10,7 @@ #include <string.h> #include <malloc.h> #include <stdio.h> +#include <inttypes.h> #include <odp_api.h> #include <odp_pkt_queue_internal.h> #include <odp_debug_internal.h> diff --git a/platform/linux-generic/odp_pool.c b/platform/linux-generic/odp_pool.c index 5ed7080..ec6d86a 100644 --- a/platform/linux-generic/odp_pool.c +++ b/platform/linux-generic/odp_pool.c @@ -22,7 +22,7 @@ #include <string.h> #include <stdlib.h> - +#include <inttypes.h> #if ODP_CONFIG_POOLS > ODP_BUFFER_MAX_POOLS #error ODP_CONFIG_POOLS > ODP_BUFFER_MAX_POOLS diff --git a/platform/linux-generic/odp_queue.c b/platform/linux-generic/odp_queue.c index 1166a72..bec1e51 100644 --- a/platform/linux-generic/odp_queue.c +++ b/platform/linux-generic/odp_queue.c @@ -42,7 +42,7 @@ #endif #include <string.h> - +#include <inttypes.h> typedef struct queue_table_t { queue_entry_t queue[ODP_CONFIG_QUEUES]; diff --git a/platform/linux-generic/odp_shared_memory.c b/platform/linux-generic/odp_shared_memory.c index f432cf9..550af27 100644 --- a/platform/linux-generic/odp_shared_memory.c +++ b/platform/linux-generic/odp_shared_memory.c @@ -26,6 +26,7 @@ #include <stdio.h> #include <string.h> #include <errno.h> +#include <inttypes.h> ODP_STATIC_ASSERT(ODP_CONFIG_SHM_BLOCKS >= ODP_CONFIG_POOLS, "ODP_CONFIG_SHM_BLOCKS < ODP_CONFIG_POOLS"); diff --git a/platform/linux-generic/odp_sorted_list.c b/platform/linux-generic/odp_sorted_list.c index 554494b..8a1dc3a 100644 --- a/platform/linux-generic/odp_sorted_list.c +++ b/platform/linux-generic/odp_sorted_list.c @@ -10,6 +10,7 @@ #include <string.h> #include <malloc.h> #include <stdio.h> +#include <inttypes.h> #include <odp_debug_internal.h> #include <odp_sorted_list_internal.h> diff --git a/platform/linux-generic/odp_system_info.c b/platform/linux-generic/odp_system_info.c index fca35ce..bbe5358 100644 --- a/platform/linux-generic/odp_system_info.c +++ b/platform/linux-generic/odp_system_info.c @@ -15,6 +15,7 @@ #include <sched.h> #include <string.h> #include <stdio.h> +#include <inttypes.h> /* sysconf */ #include <unistd.h> diff --git a/platform/linux-generic/odp_timer.c b/platform/linux-generic/odp_timer.c index 996edf0..becea9d 100644 --- a/platform/linux-generic/odp_timer.c +++ b/platform/linux-generic/odp_timer.c @@ -28,6 +28,7 @@ #include <pthread.h> #include <unistd.h> #include <sys/syscall.h> +#include <inttypes.h> #include <odp/api/align.h> #include <odp_align_internal.h> diff --git a/platform/linux-generic/odp_timer_wheel.c b/platform/linux-generic/odp_timer_wheel.c index 865dd7e..f2c802a 100644 --- a/platform/linux-generic/odp_timer_wheel.c +++ b/platform/linux-generic/odp_timer_wheel.c @@ -10,6 +10,7 @@ #include <string.h> #include <malloc.h> #include <stdio.h> +#include <inttypes.h> #include <odp_timer_wheel_internal.h> #include <odp_traffic_mngr_internal.h> #include <odp_debug_internal.h> diff --git a/platform/linux-generic/odp_traffic_mngr.c b/platform/linux-generic/odp_traffic_mngr.c index 681df00..9cfa1fc 100644 --- a/platform/linux-generic/odp_traffic_mngr.c +++ b/platform/linux-generic/odp_traffic_mngr.c @@ -11,6 +11,8 @@ #include <string.h> #include <malloc.h> #include <stdio.h> +#include <stdbool.h> +#include <inttypes.h> #include <sys/types.h> #include <sys/stat.h> #include <sched.h> diff --git a/platform/linux-generic/pktio/loop.c b/platform/linux-generic/pktio/loop.c index dce33e5..1febacd 100644 --- a/platform/linux-generic/pktio/loop.c +++ b/platform/linux-generic/pktio/loop.c @@ -16,6 +16,8 @@ #include <odp/helper/ip.h> #include <errno.h> +#include <inttypes.h> +#include <limits.h> /* MAC address for the "loop" interface */ static const char pktio_loop_mac[] = {0x02, 0xe9, 0x34, 0x80, 0x73, 0x01}; diff --git a/platform/linux-generic/pktio/netmap.c b/platform/linux-generic/pktio/netmap.c index 847250b..08e49f4 100644 --- a/platform/linux-generic/pktio/netmap.c +++ b/platform/linux-generic/pktio/netmap.c @@ -22,6 +22,8 @@ #include <odp_classification_inlines.h> #include <odp_classification_internal.h> +#include <inttypes.h> + /* Disable netmap debug prints */ #ifndef ND #define ND(_fmt, ...) do {} while (0) diff --git a/platform/linux-generic/pktio/ring.c b/platform/linux-generic/pktio/ring.c index ec27f2c..3024f4a 100644 --- a/platform/linux-generic/pktio/ring.c +++ b/platform/linux-generic/pktio/ring.c @@ -73,6 +73,8 @@ #include <fcntl.h> #include <stdio.h> #include <string.h> +#include <stdbool.h> +#include <inttypes.h> #include "odph_debug.h" #include <odp_packet_io_ring_internal.h> #include <odp_internal.h> diff --git a/platform/linux-generic/pktio/sysfs.c b/platform/linux-generic/pktio/sysfs.c index 7aadc14..be0822d 100644 --- a/platform/linux-generic/pktio/sysfs.c +++ b/platform/linux-generic/pktio/sysfs.c @@ -8,6 +8,7 @@ #include <odp_packet_io_internal.h> #include <errno.h> #include <string.h> +#include <inttypes.h> static int sysfs_get_val(const char *fname, uint64_t *val) { diff --git a/platform/linux-generic/pktio/tap.c b/platform/linux-generic/pktio/tap.c index 8ba7bed..a9a8886 100644 --- a/platform/linux-generic/pktio/tap.c +++ b/platform/linux-generic/pktio/tap.c @@ -33,6 +33,7 @@ #include <fcntl.h> #include <unistd.h> #include <stdio.h> +#include <stdbool.h> #include <sys/ioctl.h> #include <sys/socket.h> #include <sys/types.h> diff --git a/test/performance/odp_l2fwd.c b/test/performance/odp_l2fwd.c index 2ceee74..164f7f5 100644 --- a/test/performance/odp_l2fwd.c +++ b/test/performance/odp_l2fwd.c @@ -19,6 +19,7 @@ #include <getopt.h> #include <unistd.h> #include <errno.h> +#include <inttypes.h> #include <test_debug.h> diff --git a/test/performance/odp_pktio_perf.c b/test/performance/odp_pktio_perf.c index 98ec681..18a1aa2 100644 --- a/test/performance/odp_pktio_perf.c +++ b/test/performance/odp_pktio_perf.c @@ -31,6 +31,7 @@ #include <stdlib.h> #include <stdio.h> #include <string.h> +#include <inttypes.h> #include <test_debug.h> #define PKT_BUF_NUM 8192 diff --git a/test/performance/odp_scheduling.c b/test/performance/odp_scheduling.c index c575b70..bd37f9b 100644 --- a/test/performance/odp_scheduling.c +++ b/test/performance/odp_scheduling.c @@ -12,6 +12,7 @@ #include <string.h> #include <stdlib.h> +#include <inttypes.h> #include <test_debug.h> diff --git a/test/platform/linux-generic/pktio_ipc/ipc_common.h b/test/platform/linux-generic/pktio_ipc/ipc_common.h index 7bc483f..a6b7c58 100644 --- a/test/platform/linux-generic/pktio_ipc/ipc_common.h +++ b/test/platform/linux-generic/pktio_ipc/ipc_common.h @@ -6,6 +6,7 @@ #define _POSIX_C_SOURCE 200809L #include <stdlib.h> +#include <inttypes.h> #include <string.h> #include <getopt.h> #include <unistd.h> diff --git a/test/validation/classification/odp_classification_testsuites.h b/test/validation/classification/odp_classification_testsuites.h index 023a267..aea3de1 100644 --- a/test/validation/classification/odp_classification_testsuites.h +++ b/test/validation/classification/odp_classification_testsuites.h @@ -9,6 +9,7 @@ #include <odp_api.h> #include <odp_cunit_common.h> +#include <stdbool.h> extern odp_testinfo_t classification_suite[]; extern odp_testinfo_t classification_suite_basic[]; diff --git a/test/validation/common/mask_common.c b/test/validation/common/mask_common.c index 5001364..b31534c 100644 --- a/test/validation/common/mask_common.c +++ b/test/validation/common/mask_common.c @@ -9,6 +9,8 @@ #include "odp_cunit_common.h" #include "mask_common.h" +#include <stdlib.h> + /* * The following strings are used to build masks with odp_*mask_from_str(). * Both 0x prefixed and non prefixed hex values are supported. diff --git a/test/validation/common/odp_cunit_common.h b/test/validation/common/odp_cunit_common.h index 52fe203..486a5ec 100644 --- a/test/validation/common/odp_cunit_common.h +++ b/test/validation/common/odp_cunit_common.h @@ -14,6 +14,7 @@ #define ODP_CUNICT_COMMON_H #include <stdint.h> +#include <inttypes.h> #include "CUnit/Basic.h" #include "CUnit/TestDB.h" #include <odp_api.h> commit c2784fbafbf8a29b6daa48429133e25b777536cf Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Mon Jul 4 18:42:24 2016 +0300 linux-gen: byteorder: remove dependency to linux headers Platform specific API files included endian.h and asm/byteorder.h. These are Linux headers and should not be visible to application through odp_api.h. Used __ORDER_LITTLE_ENDIAN__, etc instead which are supported by both gcc and clang. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/platform/linux-generic/include/odp/api/plat/byteorder_types.h b/platform/linux-generic/include/odp/api/plat/byteorder_types.h index 0a8e409..679d4cf 100644 --- a/platform/linux-generic/include/odp/api/plat/byteorder_types.h +++ b/platform/linux-generic/include/odp/api/plat/byteorder_types.h @@ -18,15 +18,15 @@ extern "C" { #endif -#ifndef __BYTE_ORDER +#ifndef __BYTE_ORDER__ #error __BYTE_ORDER not defined! #endif -#ifndef __BIG_ENDIAN +#ifndef __ORDER_BIG_ENDIAN__ #error __BIG_ENDIAN not defined! #endif -#ifndef __LITTLE_ENDIAN +#ifndef __ORDER_LITTLE_ENDIAN__ #error __LITTLE_ENDIAN not defined! #endif @@ -48,23 +48,16 @@ extern "C" { /** @addtogroup odp_compiler_optim * @{ */ - -#define ODP_BIG_ENDIAN __BIG_ENDIAN - -#define ODP_LITTLE_ENDIAN __LITTLE_ENDIAN - -#ifdef __BIG_ENDIAN_BITFIELD -#define ODP_BIG_ENDIAN_BITFIELD -#endif - -#ifdef __LITTLE_ENDIAN_BITFIELD -#define ODP_LITTLE_ENDIAN_BITFIELD -#endif - -#if __BYTE_ORDER == __LITTLE_ENDIAN -#define ODP_BYTE_ORDER ODP_LITTLE_ENDIAN -#elif __BYTE_ORDER == __BIG_ENDIAN -#define ODP_BYTE_ORDER ODP_BIG_ENDIAN +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ + #define ODP_LITTLE_ENDIAN 1 + #define ODP_BIG_ENDIAN 0 + #define ODP_BYTE_ORDER ODP_LITTLE_ENDIAN + #define ODP_LITTLE_ENDIAN_BITFIELD +#else + #define ODP_LITTLE_ENDIAN 0 + #define ODP_BIG_ENDIAN 1 + #define ODP_BYTE_ORDER ODP_BIG_ENDIAN + #define ODP_BIG_ENDIAN_BITFIELD #endif typedef uint16_t __odp_bitwise odp_u16le_t; diff --git a/platform/linux-generic/include/odp/api/std_types.h b/platform/linux-generic/include/odp/api/std_types.h index 5737e43..d4eeb5d 100644 --- a/platform/linux-generic/include/odp/api/std_types.h +++ b/platform/linux-generic/include/odp/api/std_types.h @@ -17,8 +17,6 @@ extern "C" { #endif -#include <endian.h> -#include <asm/byteorder.h> #include <stdlib.h> #include <stdint.h> #include <stddef.h> commit 9f0f2b86309aa8021ec937e7c0ee1d6f48b0d769 Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Mon Jul 4 18:42:23 2016 +0300 linux-gen: cpumask: remove dependency to sched.h Platform specific API files included sched.h for accessing cpu_set_t. This is problematic since application may need to include it also and possibly with GNU extension (with #define _GNU_SOURCE). Application should be able to include odp_api.h in any order relative to other headers, and with or without any (e.g. GNU) extensions. The odp_cpumask_t is defined with equal (or larger) size to Linux cpu_set_t and this is verified with build time asserts. Linux CPU_SET macros are used to access the mask as before. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/platform/linux-generic/include/odp/api/cpumask.h b/platform/linux-generic/include/odp/api/cpumask.h index 15bf25e..325ea52 100644 --- a/platform/linux-generic/include/odp/api/cpumask.h +++ b/platform/linux-generic/include/odp/api/cpumask.h @@ -17,10 +17,6 @@ extern "C" { #endif -#include <string.h> -#include <sched.h> - -#include <odp/api/std_types.h> #include <odp/api/plat/cpumask_types.h> #include <odp/api/spec/cpumask.h> diff --git a/platform/linux-generic/include/odp/api/plat/cpumask_types.h b/platform/linux-generic/include/odp/api/plat/cpumask_types.h index c59f407..c2727a4 100644 --- a/platform/linux-generic/include/odp/api/plat/cpumask_types.h +++ b/platform/linux-generic/include/odp/api/plat/cpumask_types.h @@ -23,6 +23,7 @@ extern "C" { */ #include <odp/api/std_types.h> +#include <odp/api/align.h> #define ODP_CPUMASK_SIZE 1024 @@ -34,8 +35,13 @@ extern "C" { * Don't access directly, use access functions. */ typedef struct odp_cpumask_t { - cpu_set_t set; /**< @private Mask*/ -} odp_cpumask_t; + /** @private CPU mask storage + * + * This is private to the implementation. + * Don't access directly, use access functions. + */ + uint8_t _u8[ODP_CPUMASK_SIZE / 8]; +} odp_cpumask_t ODP_ALIGNED(8); /** * @} diff --git a/platform/linux-generic/include/odp/api/std_clib.h b/platform/linux-generic/include/odp/api/std_clib.h index 1578d09..40c0ea8 100644 --- a/platform/linux-generic/include/odp/api/std_clib.h +++ b/platform/linux-generic/include/odp/api/std_clib.h @@ -12,6 +12,7 @@ extern "C" { #endif #include <odp/api/spec/std_types.h> +#include <string.h> static inline void *odp_memcpy(void *dst, const void *src, size_t num) { diff --git a/platform/linux-generic/odp_cpumask.c b/platform/linux-generic/odp_cpumask.c index 3d35ade..6bf2632 100644 --- a/platform/linux-generic/odp_cpumask.c +++ b/platform/linux-generic/odp_cpumask.c @@ -20,9 +20,13 @@ #include <errno.h> #include <sys/types.h> -/** @internal Compile time assert */ -ODP_STATIC_ASSERT(CPU_SETSIZE >= ODP_CPUMASK_SIZE, - "ODP_CPUMASK_SIZE__SIZE_ERROR"); +/* Check that mask can hold all system CPUs*/ +ODP_STATIC_ASSERT(ODP_CPUMASK_SIZE >= CPU_SETSIZE, + "ODP_CPUMASK_SIZE_TOO_SMALL"); + +/* Check that mask type is large enough */ +ODP_STATIC_ASSERT(sizeof(odp_cpumask_t) >= sizeof(cpu_set_t), + "ODP_CPUMASK_T_TOO_SMALL"); void odp_cpumask_from_str(odp_cpumask_t *mask, const char *str_in) { @@ -66,7 +70,7 @@ void odp_cpumask_from_str(odp_cpumask_t *mask, const char *str_in) } /* Copy the computed mask */ - memcpy(&mask->set, &cpuset, sizeof(cpuset)); + memcpy(mask, &cpuset, sizeof(cpuset)); } int32_t odp_cpumask_to_str(const odp_cpumask_t *mask, char *str, int32_t len) @@ -106,7 +110,7 @@ int32_t odp_cpumask_to_str(const odp_cpumask_t *mask, char *str, int32_t len) value = 0; do { /* Set bit to go into the current nibble */ - if (CPU_ISSET(cpu, &mask->set)) + if (CPU_ISSET(cpu, (const cpu_set_t *)mask)) value |= 1 << (cpu % 4); /* If we are on a nibble boundary flush value to string */ @@ -126,12 +130,12 @@ int32_t odp_cpumask_to_str(const odp_cpumask_t *mask, char *str, int32_t len) void odp_cpumask_zero(odp_cpumask_t *mask) { - CPU_ZERO(&mask->set); + CPU_ZERO((cpu_set_t *)mask); } void odp_cpumask_set(odp_cpumask_t *mask, int cpu) { - CPU_SET(cpu, &mask->set); + CPU_SET(cpu, (cpu_set_t *)mask); } void odp_cpumask_setall(odp_cpumask_t *mask) @@ -139,51 +143,54 @@ void odp_cpumask_setall(odp_cpumask_t *mask) int cpu; for (cpu = 0; cpu < CPU_SETSIZE; cpu++) - CPU_SET(cpu, &mask->set); + CPU_SET(cpu, (cpu_set_t *)mask); } void odp_cpumask_clr(odp_cpumask_t *mask, int cpu) { - CPU_CLR(cpu, &mask->set); + CPU_CLR(cpu, (cpu_set_t *)mask); } int odp_cpumask_isset(const odp_cpumask_t *mask, int cpu) { - return CPU_ISSET(cpu, &mask->set); + return CPU_ISSET(cpu, (const cpu_set_t *)mask); } int odp_cpumask_count(const odp_cpumask_t *mask) { - return CPU_COUNT(&mask->set); + return CPU_COUNT((const cpu_set_t *)mask); } void odp_cpumask_and(odp_cpumask_t *dest, const odp_cpumask_t *src1, const odp_cpumask_t *src2) { - CPU_AND(&dest->set, &src1->set, &src2->set); + CPU_AND((cpu_set_t *)dest, (const cpu_set_t *)src1, + (const cpu_set_t *)src2); } void odp_cpumask_or(odp_cpumask_t *dest, const odp_cpumask_t *src1, const odp_cpumask_t *src2) { - CPU_OR(&dest->set, &src1->set, &src2->set); + CPU_OR((cpu_set_t *)dest, (const cpu_set_t *)src1, + (const cpu_set_t *)src2); } void odp_cpumask_xor(odp_cpumask_t *dest, const odp_cpumask_t *src1, const odp_cpumask_t *src2) { - CPU_XOR(&dest->set, &src1->set, &src2->set); + CPU_XOR((cpu_set_t *)dest, (const cpu_set_t *)src1, + (const cpu_set_t *)src2); } int odp_cpumask_equal(const odp_cpumask_t *mask1, const odp_cpumask_t *mask2) { - return CPU_EQUAL(&mask1->set, &mask2->set); + return CPU_EQUAL((const cpu_set_t *)mask1, (const cpu_set_t *)mask2); } void odp_cpumask_copy(odp_cpumask_t *dest, const odp_cpumask_t *src) { - memcpy(&dest->set, &src->set, sizeof(src->set)); + memcpy(dest, src, sizeof(odp_cpumask_t)); } int odp_cpumask_first(const odp_cpumask_t *mask) diff --git a/platform/linux-generic/odp_init.c b/platform/linux-generic/odp_init.c index f58f410..f534759 100644 --- a/platform/linux-generic/odp_init.c +++ b/platform/linux-generic/odp_init.c @@ -9,6 +9,7 @@ #include <unistd.h> #include <odp_internal.h> #include <odp_schedule_if.h> +#include <string.h> struct odp_global_data_s odp_global_data; ----------------------------------------------------------------------- Summary of changes: example/Makefile.am | 2 +- example/classifier/odp_classifier.c | 1 + example/generator/odp_generator.c | 1 + {test/validation => example/hello}/.gitignore | 1 + example/hello/Makefile.am | 11 +++ example/hello/odp_hello.c | 107 +++++++++++++++++++++ example/ipsec/odp_ipsec.c | 1 + example/m4/configure.m4 | 3 +- example/packet/odp_pktio.c | 1 + example/switch/odp_switch.c | 2 + example/time/time_global_test.c | 1 + example/timer/odp_timer_simple.c | 1 + example/timer/odp_timer_test.c | 1 + helper/chksum.c | 2 + helper/linux.c | 1 + platform/linux-generic/include/odp/api/cpumask.h | 4 - .../include/odp/api/plat/byteorder_types.h | 33 +++---- .../include/odp/api/plat/cpumask_types.h | 10 +- platform/linux-generic/include/odp/api/std_clib.h | 1 + platform/linux-generic/include/odp/api/std_types.h | 10 +- .../linux-generic/include/odp_atomic_internal.h | 1 + .../linux-generic/include/odp_buffer_internal.h | 1 + platform/linux-generic/include/odp_packet_socket.h | 1 + platform/linux-generic/odp_buffer.c | 2 +- platform/linux-generic/odp_classification.c | 1 + platform/linux-generic/odp_cpumask.c | 39 +++++--- platform/linux-generic/odp_hash.c | 2 + platform/linux-generic/odp_init.c | 1 + platform/linux-generic/odp_packet.c | 1 + platform/linux-generic/odp_packet_io.c | 1 + platform/linux-generic/odp_pkt_queue.c | 1 + platform/linux-generic/odp_pool.c | 2 +- platform/linux-generic/odp_queue.c | 2 +- platform/linux-generic/odp_shared_memory.c | 1 + platform/linux-generic/odp_sorted_list.c | 1 + platform/linux-generic/odp_system_info.c | 1 + platform/linux-generic/odp_timer.c | 1 + platform/linux-generic/odp_timer_wheel.c | 1 + platform/linux-generic/odp_traffic_mngr.c | 2 + platform/linux-generic/pktio/loop.c | 2 + platform/linux-generic/pktio/netmap.c | 2 + platform/linux-generic/pktio/ring.c | 2 + platform/linux-generic/pktio/sysfs.c | 1 + platform/linux-generic/pktio/tap.c | 1 + test/performance/odp_l2fwd.c | 1 + test/performance/odp_pktio_perf.c | 1 + test/performance/odp_scheduling.c | 1 + test/platform/linux-generic/pktio_ipc/ipc_common.h | 1 + .../classification/odp_classification_testsuites.h | 1 + test/validation/common/mask_common.c | 2 + test/validation/common/odp_cunit_common.h | 1 + 51 files changed, 218 insertions(+), 54 deletions(-) copy {test/validation => example/hello}/.gitignore (54%) create mode 100644 example/hello/Makefile.am create mode 100644 example/hello/odp_hello.c hooks/post-receive --

9 years, 7 months

[COMMIT] branch master updated. v1.10.1.0-36-gc03685a

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, master has been updated via c03685af2895b20a5e8a046ea910254a96ab15c4 (commit) from c6bf23e2794ec2a54fa1724cd9d833d84aa39270 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit c03685af2895b20a5e8a046ea910254a96ab15c4 Author: Bill Fischofer <bill.fischofer(a)linaro.org> Date: Mon Jul 4 21:31:45 2016 -0500 linux-generic: schedule: simplify wait logic to avoid clang issues Resolve Bug https://bugs.linaro.org/show_bug.cgi?id=2387 by ensuring that t1 variable is seen as initialized in all paths in the SP Scheduler. Previous logic failed due to an apparent issue with clang. Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/platform/linux-generic/odp_schedule_sp.c b/platform/linux-generic/odp_schedule_sp.c index 8c45123..2e28aa4 100644 --- a/platform/linux-generic/odp_schedule_sp.c +++ b/platform/linux-generic/odp_schedule_sp.c @@ -364,9 +364,9 @@ static uint64_t schedule_wait_time(uint64_t ns) } static int schedule_multi(odp_queue_t *from, uint64_t wait, - odp_event_t events[], int max_events) + odp_event_t events[], int max_events ODP_UNUSED) { - (void)max_events; + odp_time_t t1; int update_t1 = 1; if (sched_local.cmd) { @@ -384,7 +384,6 @@ static int schedule_multi(odp_queue_t *from, uint64_t wait, sched_cmd_t *cmd; uint32_t qi; int num; - odp_time_t t1; cmd = sched_cmd(NUM_PRIO); ----------------------------------------------------------------------- Summary of changes: platform/linux-generic/odp_schedule_sp.c | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) hooks/post-receive --

9 years, 7 months

[COMMIT] branch api-next updated. v1.10.1.0-36-gc4aefb8

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, api-next has been updated via c4aefb88d31452b3add8cf16f9eef152525c3e93 (commit) via 52dbfc9fc964ca292a777f11336854e88538f46d (commit) from 1a24b758857eef4caf2a1801851315b6c93edd76 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit c4aefb88d31452b3add8cf16f9eef152525c3e93 Author: Ru Jia <jiaru(a)ict.ac.cn> Date: Thu Jun 30 16:15:32 2016 +0800 helper: test: add validation test of ip lookup table Signed-off-by: Ru Jia <jiaru(a)ict.ac.cn> Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/helper/test/Makefile.am b/helper/test/Makefile.am index 0811d28..d9eb437 100644 --- a/helper/test/Makefile.am +++ b/helper/test/Makefile.am @@ -10,7 +10,8 @@ EXECUTABLES = chksum$(EXEEXT) \ table$(EXEEXT) \ thread$(EXEEXT) \ parse$(EXEEXT)\ - process$(EXEEXT) + process$(EXEEXT) \ + iplookuptable$(EXEEXT) COMPILE_ONLY = odpthreads @@ -37,3 +38,4 @@ dist_process_SOURCES = process.c dist_parse_SOURCES = parse.c process_LDADD = $(LIB)/libodphelper-linux.la $(LIB)/libodp-linux.la dist_table_SOURCES = table.c +dist_iplookuptable_SOURCES = iplookuptable.c diff --git a/helper/test/iplookuptable.c b/helper/test/iplookuptable.c new file mode 100644 index 0000000..e1d2820 --- /dev/null +++ b/helper/test/iplookuptable.c @@ -0,0 +1,174 @@ +/* Copyright (c) 2016, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include <stdio.h> +#include <stdint.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> + +#include <odp_api.h> +#include <test_debug.h> +#include <../odph_iplookuptable.h> +#include <odp/helper/ip.h> + +static void print_prefix_info( + const char *msg, uint32_t ip, uint8_t cidr) +{ + int i = 0; + uint8_t *ptr = (uint8_t *)(&ip); + + printf("%s IP prefix: ", msg); + for (i = 3; i >= 0; i--) { + if (i != 3) + printf("."); + printf("%d", ptr[i]); + } + printf("/%d\n", cidr); +} + +/* + * Basic sequence of operations for a single key: + * - put short prefix + * - put long prefix + * - get (hit long prefix) + * - remove long prefix + * - get (hit short prefix) + */ +static int test_ip_lookup_table(void) +{ + odph_iplookup_prefix_t prefix1, prefix2; + odph_table_t table; + int ret; + uint64_t value1 = 1, value2 = 2, result = 0; + uint32_t lkp_ip = 0; + + table = odph_iplookup_table_create( + "prefix_test", 0, 0, sizeof(uint32_t)); + if (table == NULL) { + printf("IP prefix lookup table creation failed\n"); + return -1; + } + + ret = odph_ipv4_addr_parse(&prefix1.ip, "192.168.0.0"); + if (ret < 0) { + printf("Failed to get IP addr from str\n"); + odph_iplookup_table_destroy(table); + return -1; + } + prefix1.cidr = 11; + + ret = odph_ipv4_addr_parse(&prefix2.ip, "192.168.0.0"); + if (ret < 0) { + printf("Failed to get IP addr from str\n"); + odph_iplookup_table_destroy(table); + return -1; + } + prefix2.cidr = 24; + + ret = odph_ipv4_addr_parse(&lkp_ip, "192.168.0.1"); + if (ret < 0) { + printf("Failed to get IP addr from str\n"); + odph_iplookup_table_destroy(table); + return -1; + } + + /* test with standard put/get/remove functions */ + ret = odph_iplookup_table_put_value(table, &prefix1, &value1); + print_prefix_info("Add", prefix1.ip, prefix1.cidr); + if (ret < 0) { + printf("Failed to add ip prefix\n"); + odph_iplookup_table_destroy(table); + return -1; + } + + ret = odph_iplookup_table_get_value(table, &lkp_ip, &result, 0); + print_prefix_info("Lkp", lkp_ip, 32); + if (ret < 0 || result != 1) { + printf("Failed to find longest prefix\n"); + odph_iplookup_table_destroy(table); + return -1; + } + + /* add a longer prefix */ + ret = odph_iplookup_table_put_value(table, &prefix2, &value2); + print_prefix_info("Add", prefix2.ip, prefix2.cidr); + if (ret < 0) { + printf("Failed to add ip prefix\n"); + odph_iplookup_table_destroy(table); + return -1; + } + + ret = odph_iplookup_table_get_value(table, &lkp_ip, &result, 0); + print_prefix_info("Lkp", lkp_ip, 32); + if (ret < 0 || result != 2) { + printf("Failed to find longest prefix\n"); + odph_iplookup_table_destroy(table); + return -1; + } + + ret = odph_iplookup_table_remove_value(table, &prefix2); + print_prefix_info("Del", prefix2.ip, prefix2.cidr); + if (ret < 0) { + printf("Failed to delete ip prefix\n"); + odph_iplookup_table_destroy(table); + return -1; + } + + ret = odph_iplookup_table_get_value(table, &lkp_ip, &result, 0); + print_prefix_info("Lkp", lkp_ip, 32); + if (ret < 0 || result != 1) { + printf("Error: found result ater deleting\n"); + odph_iplookup_table_destroy(table); + return -1; + } + + ret = odph_iplookup_table_remove_value(table, &prefix1); + print_prefix_info("Del", prefix1.ip, prefix1.cidr); + if (ret < 0) { + printf("Failed to delete prefix\n"); + odph_iplookup_table_destroy(table); + return -1; + } + + odph_iplookup_table_destroy(table); + return 0; +} + +int main(int argc TEST_UNUSED, char *argv[] TEST_UNUSED) +{ + odp_instance_t instance; + int ret = 0; + + ret = odp_init_global(&instance, NULL, NULL); + if (ret != 0) { + fprintf(stderr, "Error: ODP global init failed.\n"); + exit(EXIT_FAILURE); + } + + ret = odp_init_local(instance, ODP_THREAD_WORKER); + if (ret != 0) { + fprintf(stderr, "Error: ODP local init failed.\n"); + exit(EXIT_FAILURE); + } + + if (test_ip_lookup_table() < 0) + printf("Test failed\n"); + else + printf("All tests passed\n"); + + if (odp_term_local()) { + fprintf(stderr, "Error: ODP local term failed.\n"); + exit(EXIT_FAILURE); + } + + if (odp_term_global(instance)) { + fprintf(stderr, "Error: ODP global term failed.\n"); + exit(EXIT_FAILURE); + } + + return ret; +} commit 52dbfc9fc964ca292a777f11336854e88538f46d Author: Ru Jia <jiaru(a)ict.ac.cn> Date: Thu Jun 30 16:15:31 2016 +0800 helper: table: add impl of ip lookup table This is an implementation of the 16,8,8 ip lookup (longest prefix matching) algorithm. The key of the table is 32-bit IPv4 address. Signed-off-by: Ru Jia <jiaru(a)ict.ac.cn> Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/helper/Makefile.am b/helper/Makefile.am index 116a1f0..24a0748 100644 --- a/helper/Makefile.am +++ b/helper/Makefile.am @@ -28,7 +28,8 @@ noinst_HEADERS = \ $(srcdir)/odph_hashtable.h \ $(srcdir)/odph_lineartable.h \ $(srcdir)/odph_cuckootable.h \ - $(srcdir)/odph_list_internal.h + $(srcdir)/odph_list_internal.h \ + $(srcdir)/odph_iplookuptable.h __LIB__libodphelper_linux_la_SOURCES = \ eth.c \ @@ -37,6 +38,7 @@ __LIB__libodphelper_linux_la_SOURCES = \ linux.c \ hashtable.c \ lineartable.c \ - cuckootable.c + cuckootable.c \ + iplookuptable.c lib_LTLIBRARIES = $(LIB)/libodphelper-linux.la diff --git a/helper/iplookuptable.c b/helper/iplookuptable.c new file mode 100644 index 0000000..5f80743 --- /dev/null +++ b/helper/iplookuptable.c @@ -0,0 +1,937 @@ +/* Copyright (c) 2016, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include <string.h> +#include <stdint.h> +#include <errno.h> +#include <stdio.h> + +#include "odph_iplookuptable.h" +#include "odph_list_internal.h" +#include "odph_debug.h" +#include <odp_api.h> + +/** @magic word, write to the first byte of the memory block + * to indicate this block is used by a ip lookup table + */ +#define ODPH_IP_LOOKUP_TABLE_MAGIC_WORD 0xCFCFFCFC + +/* The length(bit) of the IPv4 address */ +#define IP_LENGTH 32 + +/* The number of L1 entries */ +#define ENTRY_NUM_L1 (1 << 16) +/* The size of one L2\L3 subtree */ +#define ENTRY_NUM_SUBTREE (1 << 8) + +#define WHICH_CHILD(ip, cidr) ((ip >> (IP_LENGTH - cidr)) & 0x00000001) + +/** @internal entry struct + * Structure store an entry of the ip prefix table. + * Because of the leaf pushing, each entry of the table must have + * either a child entry, or a nexthop info. + * If child == 0 and index != ODP_BUFFER_INVALID, this entry has + * a nexthop info, index indicates the buffer that stores the + * nexthop value, and ptr points to the address of the buffer. + * If child == 1, this entry has a subtree, index indicates + * the buffer that stores the subtree, and ptr points to the + * address of the buffer. + */ +typedef struct { + union { + uint8_t u8; + struct { +#if ODP_BYTE_ORDER == ODP_BIG_ENDIAN + uint8_t child : 1; + uint8_t cidr : 7; +#else + uint8_t cidr : 7; + uint8_t child : 1; +#endif + }; + }; + union { + odp_buffer_t nexthop; + void *ptr; + }; +} prefix_entry_t; + +#define ENTRY_SIZE (sizeof(prefix_entry_t) + sizeof(odp_buffer_t)) +#define ENTRY_BUFF_ARR(x) ((odp_buffer_t *)((char *)x \ + + sizeof(prefix_entry_t) * ENTRY_NUM_SUBTREE)) + +/** @internal trie node struct + * In this IP lookup algorithm, we use a + * binary tire to detect the overlap prefix. + */ +typedef struct trie_node { + /* tree structure */ + struct trie_node *parent; + struct trie_node *left; + struct trie_node *right; + /* IP prefix length */ + uint8_t cidr; + /* Nexthop buffer index */ + odp_buffer_t nexthop; + /* Buffer that stores this node */ + odp_buffer_t buffer; +} trie_node_t; + +/** Number of L2\L3 entries(subtrees) per cache cube. */ +#define CACHE_NUM_SUBTREE (1 << 13) +/** Number of trie nodes per cache cube. */ +#define CACHE_NUM_TRIE (1 << 20) + +/** @typedef cache_type_t + * Cache node type + */ +typedef enum { + CACHE_TYPE_SUBTREE = 0, + CACHE_TYPE_TRIE +} cache_type_t; + +/** A IP lookup table structure. */ +typedef struct { + /**< for check */ + uint32_t magicword; + /** Name of the hash. */ + char name[ODPH_TABLE_NAME_LEN]; + /** Total L1 entries. */ + prefix_entry_t *l1e; + /** Root node of the binary trie */ + trie_node_t *trie; + /** Length of value. */ + uint32_t nexthop_len; + /** Queues of free slots (caches) + * There are two queues: + * - free_slots[CACHE_TYPE_SUBTREE] is used for L2 and + * L3 entries (subtrees). Each entry stores an 8-bit + * subtree. + * - free_slots[CACHE_TYPE_TRIE] is used for the binary + * trie. Each entry contains a trie node. + */ + odp_queue_t free_slots[2]; + /** The number of pool used by each queue. */ + uint32_t cache_count[2]; +} odph_iplookup_table_impl ODP_ALIGNED_CACHE; + +/*********************************************************** + ***************** Cache management ******************** + ***********************************************************/ + +/** Destroy all caches */ +static void +cache_destroy(odph_iplookup_table_impl *impl) +{ + odp_queue_t queue; + odp_event_t ev; + uint32_t i = 0, count = 0; + char pool_name[ODPH_TABLE_NAME_LEN + 8]; + + /* free all buffers in the queue */ + for (; i < 2; i++) { + queue = impl->free_slots[i]; + if (queue == ODP_QUEUE_INVALID) + continue; + + while ((ev = odp_queue_deq(queue)) + != ODP_EVENT_INVALID) { + odp_buffer_free(odp_buffer_from_event(ev)); + } + odp_queue_destroy(queue); + } + + /* destroy all cache pools */ + for (i = 0; i < 2; i++) { + for (count = 0; count < impl->cache_count[i]; count++) { + sprintf( + pool_name, "%s_%d_%d", + impl->name, i, count); + odp_pool_destroy(odp_pool_lookup(pool_name)); + } + } +} + +/** According to the type of cahce, set the value of + * a buffer to the initial value. + */ +static void +cache_init_buffer(odp_buffer_t buffer, cache_type_t type, uint32_t size) +{ + int i = 0; + void *addr = odp_buffer_addr(buffer); + + memset(addr, 0, size); + if (type == CACHE_TYPE_SUBTREE) { + prefix_entry_t *entry = (prefix_entry_t *)addr; + + for (i = 0; i < ENTRY_NUM_SUBTREE; i++, entry++) + entry->nexthop = ODP_BUFFER_INVALID; + } else if (type == CACHE_TYPE_TRIE) { + trie_node_t *node = (trie_node_t *)addr; + + node->buffer = buffer; + node->nexthop = ODP_BUFFER_INVALID; + } +} + +/** Create a new buffer pool, and insert its buffer into the queue. */ +static int +cache_alloc_new_pool( + odph_iplookup_table_impl *tbl, cache_type_t type) +{ + odp_pool_t pool; + odp_pool_param_t param; + odp_queue_t queue = tbl->free_slots[type]; + + odp_buffer_t buffer; + char pool_name[ODPH_TABLE_NAME_LEN + 8]; + uint32_t size = 0, num = 0; + + /* Create new pool (new free buffers). */ + param.type = ODP_POOL_BUFFER; + param.buf.align = ODP_CACHE_LINE_SIZE; + if (type == CACHE_TYPE_SUBTREE) { + num = CACHE_NUM_SUBTREE; + size = ENTRY_SIZE * ENTRY_NUM_SUBTREE; + } else if (type == CACHE_TYPE_TRIE) { + num = CACHE_NUM_TRIE; + size = sizeof(trie_node_t); + } else { + ODPH_DBG("wrong cache_type_t.\n"); + return -1; + } + param.buf.size = size; + param.buf.num = num; + + sprintf( + pool_name, "%s_%d_%d", + tbl->name, type, tbl->cache_count[type]); + pool = odp_pool_create(pool_name, &param); + if (pool == ODP_POOL_INVALID) { + ODPH_DBG("failed to create a new pool.\n"); + return -1; + } + + /* insert new free buffers into queue */ + while ((buffer = odp_buffer_alloc(pool)) + != ODP_BUFFER_INVALID) { + cache_init_buffer(buffer, type, size); + odp_queue_enq(queue, odp_buffer_to_event(buffer)); + } + + tbl->cache_count[type]++; + return 0; +} + +/** Get a new buffer from a cache list. If there is no + * available buffer, allocate a new pool. + */ +static odp_buffer_t +cache_get_buffer(odph_iplookup_table_impl *tbl, cache_type_t type) +{ + odp_buffer_t buffer = ODP_BUFFER_INVALID; + odp_queue_t queue = tbl->free_slots[type]; + + /* get free buffer from queue */ + buffer = odp_buffer_from_event( + odp_queue_deq(queue)); + + /* If there is no free buffer available, allocate new pool */ + if (buffer == ODP_BUFFER_INVALID) { + cache_alloc_new_pool(tbl, type); + buffer = odp_buffer_from_event(odp_queue_deq(queue)); + } + + return buffer; +} + +/*********************************************************** + ****************** Binary trie ******************** + ***********************************************************/ + +/* Initialize the root node of the trie */ +static int +trie_init(odph_iplookup_table_impl *tbl) +{ + trie_node_t *root = NULL; + odp_buffer_t buffer = cache_get_buffer(tbl, CACHE_TYPE_TRIE); + + if (buffer != ODP_BUFFER_INVALID) { + root = (trie_node_t *)odp_buffer_addr(buffer); + root->cidr = 0; + tbl->trie = root; + return 0; + } + + return -1; +} + +/* Destroy the whole trie (recursively) */ +static void +trie_destroy(odph_iplookup_table_impl *tbl, trie_node_t *trie) +{ + if (trie->left != NULL) + trie_destroy(tbl, trie->left); + if (trie->right != NULL) + trie_destroy(tbl, trie->right); + + /* destroy this node */ + odp_queue_enq( + tbl->free_slots[CACHE_TYPE_TRIE], + odp_buffer_to_event(trie->buffer)); +} + +/* Insert a new prefix node into the trie + * If the node is already existed, update its nexthop info, + * Return 0 and set nexthop pointer to INVALID. + * If the node is not exitsed, create this target node and + * all nodes along the path from root to the target node. + * Then return 0 and set nexthop pointer points to the + * new buffer. + * Return -1 for error. + */ +static int +trie_insert_node( + odph_iplookup_table_impl *tbl, trie_node_t *root, + uint32_t ip, uint8_t cidr, odp_buffer_t nexthop) +{ + uint8_t level = 0, child; + odp_buffer_t buf; + trie_node_t *node = root, *prev = root; + + /* create/update all nodes along the path + * from root to the new node. */ + for (level = 1; level <= cidr; level++) { + child = WHICH_CHILD(ip, level); + + node = child == 0 ? prev->left : prev->right; + /* If the child node doesn't exit, create it. */ + if (node == NULL) { + buf = cache_get_buffer(tbl, CACHE_TYPE_TRIE); + if (buf == ODP_BUFFER_INVALID) + return -1; + + node = (trie_node_t *)odp_buffer_addr(buf); + node->cidr = level; + node->parent = prev; + + if (child == 0) + prev->left = node; + else + prev->right = node; + } + prev = node; + } + + /* The final one is the target. */ + node->nexthop = nexthop; + return 0; +} + +/* Delete a node */ +static int +trie_delete_node( + odph_iplookup_table_impl *tbl, + trie_node_t *root, uint32_t ip, uint8_t cidr) +{ + if (root == NULL) + return -1; + + /* The default prefix (root node) cannot be deleted. */ + if (cidr == 0) + return -1; + + trie_node_t *node = root, *prev = NULL; + uint8_t level = 1, child = 0; + odp_buffer_t tmp; + + /* Find the target node. */ + for (level = 1; level <= cidr; level++) { + child = WHICH_CHILD(ip, level); + node = (child == 0) ? node->left : node->right; + if (node == NULL) { + ODPH_DBG("Trie node is not existed\n"); + return -1; + } + } + + node->nexthop = ODP_BUFFER_INVALID; + + /* Delete all redundant nodes along the path. */ + for (level = cidr; level > 0; level--) { + if ( + node->left != NULL || node->right != NULL || + node->nexthop != ODP_BUFFER_INVALID) + break; + + child = WHICH_CHILD(ip, level); + prev = node->parent; + + /* free trie node */ + tmp = node->buffer; + cache_init_buffer( + tmp, CACHE_TYPE_TRIE, sizeof(trie_node_t)); + odp_queue_enq( + tbl->free_slots[CACHE_TYPE_TRIE], + odp_buffer_to_event(tmp)); + + if (child == 0) + prev->left = NULL; + else + prev->right = NULL; + node = prev; + } + return 0; +} + +/* Detect the longest overlapping prefix. */ +static int +trie_detect_overlap( + trie_node_t *trie, uint32_t ip, uint8_t cidr, + uint8_t leaf_push, uint8_t *over_cidr, + odp_buffer_t *over_nexthop) +{ + uint8_t child = 0; + uint32_t level, limit = cidr > leaf_push ? leaf_push + 1 : cidr; + trie_node_t *node = trie, *longest = trie; + + for (level = 1; level < limit; level++) { + child = WHICH_CHILD(ip, level); + node = (child == 0) ? node->left : node->right; + if (node->nexthop != ODP_BUFFER_INVALID) + longest = node; + } + + *over_cidr = longest->cidr; + *over_nexthop = longest->nexthop; + return 0; +} + +/*********************************************************** + *************** IP prefix lookup table **************** + ***********************************************************/ + +odph_table_t +odph_iplookup_table_lookup(const char *name) +{ + odph_iplookup_table_impl *tbl = NULL; + + if (name == NULL || strlen(name) >= ODPH_TABLE_NAME_LEN) + return NULL; + + tbl = (odph_iplookup_table_impl *)odp_shm_addr(odp_shm_lookup(name)); + + if ( + tbl != NULL && + tbl->magicword == ODPH_IP_LOOKUP_TABLE_MAGIC_WORD && + strcmp(tbl->name, name) == 0) + return (odph_table_t)tbl; + + return NULL; +} + +odph_table_t +odph_iplookup_table_create( + const char *name, uint32_t ODP_IGNORED_1, + uint32_t ODP_IGNORED_2, uint32_t value_size) +{ + odph_iplookup_table_impl *tbl; + odp_shm_t shm_tbl; + odp_queue_t queue; + odp_queue_param_t qparam; + + unsigned i; + uint32_t impl_size, l1_size; + char queue_name[ODPH_TABLE_NAME_LEN + 2]; + + /* Check for valid parameters */ + if (strlen(name) == 0) { + ODPH_DBG("invalid parameters\n"); + return NULL; + } + + /* Guarantee there's no existing */ + tbl = (odph_iplookup_table_impl *)odph_iplookup_table_lookup(name); + if (tbl != NULL) { + ODPH_DBG("IP prefix table %s already exists\n", name); + return NULL; + } + + /* Calculate the sizes of different parts of IP prefix table */ + impl_size = sizeof(odph_iplookup_table_impl); + l1_size = ENTRY_SIZE * ENTRY_NUM_L1; + + shm_tbl = odp_shm_reserve( + name, impl_size + l1_size, + ODP_CACHE_LINE_SIZE, ODP_SHM_SW_ONLY); + + if (shm_tbl == ODP_SHM_INVALID) { + ODPH_DBG( + "shm allocation failed for odph_iplookup_table_impl %s\n", + name); + return NULL; + } + + tbl = (odph_iplookup_table_impl *)odp_shm_addr(shm_tbl); + memset(tbl, 0, impl_size + l1_size); + + /* header of this mem block is the table impl struct, + * then the l1 entries array. + */ + tbl->l1e = (prefix_entry_t *)((char *)tbl + impl_size); + for (i = 0; i < ENTRY_NUM_L1; i++) + tbl->l1e[i].nexthop = ODP_BUFFER_INVALID; + + /* Setup table context. */ + snprintf(tbl->name, sizeof(tbl->name), "%s", name); + tbl->magicword = ODPH_IP_LOOKUP_TABLE_MAGIC_WORD; + tbl->nexthop_len = value_size; + + /* Initialize cache */ + for (i = 0; i < 2; i++) { + tbl->cache_count[i] = 0; + + odp_queue_param_init(&qparam); + qparam.type = ODP_QUEUE_TYPE_PLAIN; + sprintf(queue_name, "%s_%d", name, i); + queue = odp_queue_create(queue_name, &qparam); + if (queue == ODP_QUEUE_INVALID) { + ODPH_DBG("failed to create queue"); + cache_destroy(tbl); + return NULL; + } + tbl->free_slots[i] = queue; + cache_alloc_new_pool(tbl, i); + } + + /* Initialize tire */ + if (trie_init(tbl) < 0) { + odp_shm_free(shm_tbl); + return NULL; + } + + return (odph_table_t)tbl; +} + +int +odph_iplookup_table_destroy(odph_table_t tbl) +{ + int i, j; + odph_iplookup_table_impl *impl = NULL; + prefix_entry_t *subtree = NULL; + odp_buffer_t *buff1 = NULL, *buff2 = NULL; + + if (tbl == NULL) + return -1; + + impl = (odph_iplookup_table_impl *)tbl; + + /* check magic word */ + if (impl->magicword != ODPH_IP_LOOKUP_TABLE_MAGIC_WORD) { + ODPH_DBG("wrong magicword for IP prefix table\n"); + return -1; + } + + /* destroy trie */ + trie_destroy(impl, impl->trie); + + /* free all L2 and L3 entries */ + buff1 = ENTRY_BUFF_ARR(impl->l1e); + for (i = 0; i < ENTRY_NUM_L1; i++) { + if ((impl->l1e[i]).child == 0) + continue; + + subtree = (prefix_entry_t *)impl->l1e[i].ptr; + buff2 = ENTRY_BUFF_ARR(subtree); + /* destroy all l3 subtrees of this l2 subtree */ + for (j = 0; j < ENTRY_NUM_SUBTREE; j++) { + if (subtree[j].child == 0) + continue; + odp_queue_enq( + impl->free_slots[CACHE_TYPE_TRIE], + odp_buffer_to_event(buff2[j])); + } + /* destroy this l2 subtree */ + odp_queue_enq( + impl->free_slots[CACHE_TYPE_TRIE], + odp_buffer_to_event(buff1[i])); + } + + /* destroy all cache */ + cache_destroy(impl); + + /* free impl */ + odp_shm_free(odp_shm_lookup(impl->name)); + return 0; +} + +/* Insert the prefix into level x + * Return: + * -1 error + * 0 the table is unmodified + * 1 the table is modified + */ +static int +prefix_insert_into_lx( + odph_iplookup_table_impl *tbl, prefix_entry_t *entry, + uint8_t cidr, odp_buffer_t nexthop, uint8_t level) +{ + uint8_t ret = 0; + uint32_t i = 0, limit = (1 << (level - cidr)); + prefix_entry_t *e = entry, *ne = NULL; + + for (i = 0; i < limit; i++, e++) { + if (e->child == 1) { + if (e->cidr > cidr) + continue; + + e->cidr = cidr; + /* push to next level */ + ne = (prefix_entry_t *)e->ptr; + ret = prefix_insert_into_lx( + tbl, ne, cidr, nexthop, cidr + 8); + } else { + if (e->cidr > cidr) + continue; + + e->child = 0; + e->cidr = cidr; + e->nexthop = nexthop; + ret = 1; + } + } + return ret; +} + +static int +prefix_insert_iter( + odph_iplookup_table_impl *tbl, prefix_entry_t *entry, + odp_buffer_t *buff, uint32_t ip, uint8_t cidr, + odp_buffer_t nexthop, uint8_t level, uint8_t depth) +{ + uint8_t state = 0; + prefix_entry_t *ne = NULL; + odp_buffer_t *nbuff = NULL; + + /* If child subtree is existed, get it. */ + if (entry->child) { + ne = (prefix_entry_t *)entry->ptr; + nbuff = ENTRY_BUFF_ARR(ne); + } else { + /* If the child is not existed, create a new subtree. */ + odp_buffer_t buf, push = entry->nexthop; + + buf = cache_get_buffer(tbl, CACHE_TYPE_SUBTREE); + if (buf == ODP_BUFFER_INVALID) { + ODPH_DBG("failed to get subtree buffer from cache.\n"); + return -1; + } + ne = (prefix_entry_t *)odp_buffer_addr(buf); + nbuff = ENTRY_BUFF_ARR(ne); + + entry->child = 1; + entry->ptr = ne; + *buff = buf; + + /* If this entry contains a nexthop and a small cidr, + * push it to the next level. + */ + if (entry->cidr > 0) { + state = prefix_insert_into_lx( + tbl, ne, entry->cidr, + push, entry->cidr + 8); + } + } + + ne += (ip >> 24); + nbuff += (ip >> 24); + if (cidr <= 8) { + state = prefix_insert_into_lx( + tbl, ne, cidr + depth * 8, nexthop, level); + } else { + state = prefix_insert_iter( + tbl, ne, nbuff, ip << 8, cidr - 8, + nexthop, level + 8, depth + 1); + } + + return state; +} + +int +odph_iplookup_table_put_value(odph_table_t tbl, void *key, void *value) +{ + if ((tbl == NULL) || (key == NULL) || (value == NULL)) + return -1; + + odph_iplookup_table_impl *impl = (odph_iplookup_table_impl *)tbl; + odph_iplookup_prefix_t *prefix = (odph_iplookup_prefix_t *)key; + prefix_entry_t *l1e = NULL; + odp_buffer_t nexthop = *((odp_buffer_t *)value); + int ret = 0; + + if (prefix->cidr == 0) + return -1; + prefix->ip = prefix->ip & (0xffffffff << (IP_LENGTH - prefix->cidr)); + + /* insert into trie */ + ret = trie_insert_node( + impl, impl->trie, + prefix->ip, prefix->cidr, nexthop); + + if (ret < 0) { + ODPH_DBG("failed to insert into trie\n"); + return -1; + } + + /* get L1 entry */ + l1e = &impl->l1e[prefix->ip >> 16]; + odp_buffer_t *buff = ENTRY_BUFF_ARR(impl->l1e) + (prefix->ip >> 16); + + if (prefix->cidr <= 16) { + ret = prefix_insert_into_lx( + impl, l1e, prefix->cidr, nexthop, 16); + } else { + ret = prefix_insert_iter( + impl, l1e, buff, + ((prefix->ip) << 16), prefix->cidr - 16, + nexthop, 24, 2); + } + + return ret; +} + +int +odph_iplookup_table_get_value( + odph_table_t tbl, void *key, void *buffer, uint32_t buffer_size) +{ + if ((tbl == NULL) || (key == NULL) || (buffer == NULL)) + return -EINVAL; + + odph_iplookup_table_impl *impl = (odph_iplookup_table_impl *)tbl; + uint32_t ip = *((uint32_t *)key); + prefix_entry_t *entry = &impl->l1e[ip >> 16]; + odp_buffer_t *buff = (odp_buffer_t *)buffer; + + if (entry == NULL) { + ODPH_DBG("failed to get L1 entry.\n"); + return -1; + } + + ip <<= 16; + while (entry->child) { + entry = (prefix_entry_t *)entry->ptr; + entry += ip >> 24; + ip <<= 8; + } + + /* copy data */ + if (entry->nexthop == ODP_BUFFER_INVALID) { + /* ONLY match the default prefix */ + printf("only match the default prefix\n"); + *buff = ODP_BUFFER_INVALID; + } else { + *buff = entry->nexthop; + } + + return 0; +} + +static int +prefix_delete_lx( + odph_iplookup_table_impl *tbl, prefix_entry_t *l1e, + odp_buffer_t *buff, uint8_t cidr, uint8_t over_cidr, + odp_buffer_t over_nexthop, uint8_t level) +{ + uint8_t ret, flag = 1; + prefix_entry_t *e = l1e; + odp_buffer_t *b = buff; + uint32_t i = 0, limit = 1 << (level - cidr); + + for (i = 0; i < limit; i++, e++, b++) { + if (e->child == 1) { + if (e->cidr > cidr) { + flag = 0; + continue; + } + + prefix_entry_t *ne = (prefix_entry_t *)e->ptr; + odp_buffer_t *nbuff = ENTRY_BUFF_ARR(ne); + + e->cidr = over_cidr; + ret = prefix_delete_lx( + tbl, ne, nbuff, cidr, over_cidr, + over_nexthop, cidr + 8); + + /* If ret == 1, the next 2^8 entries equal to + * (over_cidr, over_nexthop). In this case, we + * should not push the (over_cidr, over_nexthop) + * to the next level. In fact, we should recycle + * the next 2^8 entries. + */ + if (ret) { + /* destroy subtree */ + cache_init_buffer( + *b, CACHE_TYPE_SUBTREE, + ENTRY_SIZE * ENTRY_NUM_SUBTREE); + odp_queue_enq( + tbl->free_slots[CACHE_TYPE_SUBTREE], + odp_buffer_to_event(*b)); + e->child = 0; + e->nexthop = over_nexthop; + } else { + flag = 0; + } + } else { + if (e->cidr > cidr) { + flag = 0; + continue; + } else { + e->cidr = over_cidr; + e->nexthop = over_nexthop; + } + } + } + return flag; +} + +/* Check if the entry can be recycled. + * An entry can be recycled duo to two reasons: + * - all children of the entry are the same, + * - all children of the entry have a cidr smaller than the level + * bottom bound. + */ +static uint8_t +can_recycle(prefix_entry_t *e, uint32_t level) +{ + uint8_t recycle = 1; + int i = 1; + prefix_entry_t *ne = (prefix_entry_t *)e->ptr; + + if (ne->child) + return 0; + + uint8_t cidr = ne->cidr; + odp_buffer_t index = ne->nexthop; + + if (cidr > level) + return 0; + + ne++; + for (; i < 256; i++, ne++) { + if ( + ne->child != 0 || ne->cidr != cidr || + ne->nexthop != index) { + recycle = 0; + break; + } + } + return recycle; +} + +static uint8_t +prefix_delete_iter( + odph_iplookup_table_impl *tbl, prefix_entry_t *e, + odp_buffer_t *buff, uint32_t ip, uint8_t cidr, + uint8_t level, uint8_t depth) +{ + uint8_t ret = 0, over_cidr; + odp_buffer_t over_nexthop; + + trie_detect_overlap( + tbl->trie, ip, cidr + 8 * depth, level, + &over_cidr, &over_nexthop); + if (cidr > 8) { + prefix_entry_t *ne = + (prefix_entry_t *)e->ptr; + odp_buffer_t *nbuff = ENTRY_BUFF_ARR(ne); + + ne += ((uint32_t)(ip << level) >> 24); + nbuff += ((uint32_t)(ip << level) >> 24); + ret = prefix_delete_iter( + tbl, ne, nbuff, ip, cidr - 8, + level + 8, depth + 1); + + if (ret && can_recycle(e, level)) { + /* destroy subtree */ + cache_init_buffer( + *buff, CACHE_TYPE_SUBTREE, + ENTRY_SIZE * ENTRY_NUM_SUBTREE); + odp_queue_enq( + tbl->free_slots[CACHE_TYPE_SUBTREE], + odp_buffer_to_event(*buff)); + e->child = 0; + e->nexthop = over_nexthop; + e->cidr = over_cidr; + return 1; + } + return 0; + } + + ret = prefix_delete_lx( + tbl, e, buff, cidr + 8 * depth, + over_cidr, over_nexthop, level); + return ret; +} + +int +odph_iplookup_table_remove_value(odph_table_t tbl, void *key) +{ + if ((tbl == NULL) || (key == NULL)) + return -EINVAL; + + odph_iplookup_table_impl *impl = (odph_iplookup_table_impl *)tbl; + odph_iplookup_prefix_t *prefix = (odph_iplookup_prefix_t *)key; + uint32_t ip = prefix->ip; + uint8_t cidr = prefix->cidr; + + if (prefix->cidr < 0) + return -EINVAL; + + prefix_entry_t *entry = &impl->l1e[ip >> 16]; + odp_buffer_t *buff = ENTRY_BUFF_ARR(impl->l1e) + (ip >> 16); + uint8_t over_cidr, ret; + odp_buffer_t over_nexthop; + + trie_detect_overlap( + impl->trie, ip, cidr, 16, &over_cidr, &over_nexthop); + + if (cidr <= 16) { + prefix_delete_lx( + impl, entry, buff, cidr, over_cidr, over_nexthop, 16); + } else { + prefix_entry_t *ne = (prefix_entry_t *)entry->ptr; + odp_buffer_t *nbuff = ENTRY_BUFF_ARR(ne); + + ne += ((uint32_t)(ip << 16) >> 24); + nbuff += ((uint32_t)(ip << 16) >> 24); + ret = prefix_delete_iter(impl, ne, nbuff, ip, cidr - 16, 24, 2); + + if (ret && can_recycle(entry, 16)) { + /* destroy subtree */ + cache_init_buffer( + *buff, CACHE_TYPE_SUBTREE, + sizeof(prefix_entry_t) * ENTRY_NUM_SUBTREE); + odp_queue_enq( + impl->free_slots[CACHE_TYPE_SUBTREE], + odp_buffer_to_event(*buff)); + entry->child = 0; + entry->cidr = over_cidr; + entry->nexthop = over_nexthop; + } + } + + return trie_delete_node(impl, impl->trie, ip, cidr); +} + +odph_table_ops_t odph_iplookup_table_ops = { + odph_iplookup_table_create, + odph_iplookup_table_lookup, + odph_iplookup_table_destroy, + odph_iplookup_table_put_value, + odph_iplookup_table_get_value, + odph_iplookup_table_remove_value +}; diff --git a/helper/odph_iplookuptable.h b/helper/odph_iplookuptable.h new file mode 100644 index 0000000..0ae6b37 --- /dev/null +++ b/helper/odph_iplookuptable.h @@ -0,0 +1,58 @@ +/* Copyright (c) 2016, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/** + * @file + * + * ODP IP Lookup Table + * + * This is an implementation of the IP lookup table. The key of + * this table is IPv4 address (32 bits), and the value can be + * defined by user. This table uses the 16,8,8 ip lookup (longest + * prefix matching) algorithm. + */ + +#ifndef ODPH_IPLOOKUP_TABLE_H_ +#define ODPH_IPLOOKUP_TABLE_H_ + +#include <odp/helper/table.h> + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct { + uint32_t ip; + uint8_t cidr; +} odph_iplookup_prefix_t; + +odph_table_t odph_iplookup_table_create( + const char *name, + uint32_t ODP_IGNORED_1, + uint32_t ODP_IGNORED_2, + uint32_t value_size); + +odph_table_t odph_iplookup_table_lookup(const char *name); + +int odph_iplookup_table_destroy(odph_table_t table); + +int odph_iplookup_table_put_value( + odph_table_t table, void *key, void *value); + +int odph_iplookup_table_get_value( + odph_table_t table, void *key, + void *buffer, uint32_t buffer_size); + +int odph_iplookup_table_remove_value( + odph_table_t table, void *key); + +extern odph_table_ops_t odph_iplookup_table_ops; + +#ifdef __cplusplus +} +#endif + +#endif /* ODPH_IPLOOKUP_TABLE_H_ */ ----------------------------------------------------------------------- Summary of changes: helper/Makefile.am | 6 +- helper/iplookuptable.c | 937 ++++++++++++++++++++++++++++++++++++++++++++ helper/odph_iplookuptable.h | 58 +++ helper/test/Makefile.am | 4 +- helper/test/iplookuptable.c | 174 ++++++++ 5 files changed, 1176 insertions(+), 3 deletions(-) create mode 100644 helper/iplookuptable.c create mode 100644 helper/odph_iplookuptable.h create mode 100644 helper/test/iplookuptable.c hooks/post-receive --

9 years, 7 months

[COMMIT] branch master updated. v1.10.1.0-35-gc6bf23e

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, master has been updated via c6bf23e2794ec2a54fa1724cd9d833d84aa39270 (commit) from 15f3c174f5a104e9749ed83797acb00660d675ad (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit c6bf23e2794ec2a54fa1724cd9d833d84aa39270 Author: Anders Roxell <anders.roxell(a)linaro.org> Date: Thu Jun 30 22:12:34 2016 +0200 configure: split up libodphelper SO-version from libodp The libodphelper and libopd need to track their evolving ABI independently and so there needs to be two separate version numbers. Signed-off-by: Anders Roxell <anders.roxell(a)linaro.org> Tested-and-Reviewed-by: Mike Holmes <mike.holmes(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/configure.ac b/configure.ac index f3952db..c0eb207 100644 --- a/configure.ac +++ b/configure.ac @@ -15,6 +15,9 @@ AM_SILENT_RULES([yes]) ODP_LIBSO_VERSION=110:0:1 AC_SUBST(ODP_LIBSO_VERSION) +ODPHELPER_LIBSO_VERSION=110:0:1 +AC_SUBST(ODPHELPER_LIBSO_VERSION) + # Checks for programs. AC_PROG_CC AM_PROG_CC_C_O @@ -272,7 +275,8 @@ AC_OUTPUT AC_MSG_RESULT([ $PACKAGE $VERSION - Library version: ${ODP_LIBSO_VERSION} + ODP Library version: ${ODP_LIBSO_VERSION} + Helper Library version: ${ODPHELPER_LIBSO_VERSION} implementation_name: ${IMPLEMENTATION_NAME} ARCH_DIR ${ARCH_DIR} diff --git a/helper/Makefile.am b/helper/Makefile.am index aa58e8c..a82a11a 100644 --- a/helper/Makefile.am +++ b/helper/Makefile.am @@ -8,7 +8,7 @@ AM_CFLAGS = -I$(srcdir)/include AM_CFLAGS += -I$(top_srcdir)/platform/@with_platform@/include AM_CFLAGS += -I$(top_srcdir)/include -AM_LDFLAGS += -version-number '$(ODP_LIBSO_VERSION)' +AM_LDFLAGS += -version-number '$(ODPHELPER_LIBSO_VERSION)' helperincludedir = $(includedir)/odp/helper/ helperinclude_HEADERS = \ ----------------------------------------------------------------------- Summary of changes: configure.ac | 6 +++++- helper/Makefile.am | 2 +- 2 files changed, 6 insertions(+), 2 deletions(-) hooks/post-receive --

9 years, 7 months

[COMMIT] branch api-next updated. v1.10.1.0-34-g1a24b75

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, api-next has been updated via 1a24b758857eef4caf2a1801851315b6c93edd76 (commit) via d1e693d7177d10f382d69b659ab359fddee783b5 (commit) from 449cd8f2c3a694b219fcbb98d7d9948bce583ca1 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 1a24b758857eef4caf2a1801851315b6c93edd76 Author: Ru Jia <jiaru(a)ict.ac.cn> Date: Mon Jun 13 14:42:14 2016 +0800 helper: test: add test of cuckoo hash table This test program consists of basic validation tests and performance tests. Signed-off-by: Ru Jia <jiaru(a)ict.ac.cn> Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/helper/test/.gitignore b/helper/test/.gitignore index 5ce3c3b..482fdb5 100644 --- a/helper/test/.gitignore +++ b/helper/test/.gitignore @@ -1,6 +1,7 @@ *.trs *.log chksum +cuckootable odpthreads parse process diff --git a/helper/test/Makefile.am b/helper/test/Makefile.am index e9e8785..0811d28 100644 --- a/helper/test/Makefile.am +++ b/helper/test/Makefile.am @@ -6,10 +6,11 @@ AM_LDFLAGS += -static TESTS_ENVIRONMENT += TEST_DIR=${builddir} EXECUTABLES = chksum$(EXEEXT) \ + cuckootable$(EXEEXT) \ + table$(EXEEXT) \ thread$(EXEEXT) \ parse$(EXEEXT)\ - process$(EXEEXT)\ - table$(EXEEXT) + process$(EXEEXT) COMPILE_ONLY = odpthreads @@ -27,6 +28,7 @@ bin_PROGRAMS = $(EXECUTABLES) $(COMPILE_ONLY) EXTRA_DIST = odpthreads_as_processes odpthreads_as_pthreads dist_chksum_SOURCES = chksum.c +dist_cuckootable_SOURCES = cuckootable.c dist_odpthreads_SOURCES = odpthreads.c odpthreads_LDADD = $(LIB)/libodphelper-linux.la $(LIB)/libodp-linux.la dist_thread_SOURCES = thread.c diff --git a/helper/test/cuckootable.c b/helper/test/cuckootable.c new file mode 100644 index 0000000..5b4333b --- /dev/null +++ b/helper/test/cuckootable.c @@ -0,0 +1,573 @@ +/* Copyright (c) 2016, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2016 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <stdio.h> +#include <stdint.h> +#include <string.h> +#include <stdlib.h> +#include <stdarg.h> +#include <errno.h> +#include <sys/queue.h> +#include <sys/time.h> +#include <time.h> + +#include <odp_api.h> +#include <test_debug.h> +#include <../odph_cuckootable.h> + +/******************************************************************************* + * Hash function performance test configuration section. + * + * The five arrays below control what tests are performed. Every combination + * from the array entries is tested. + */ +/******************************************************************************/ + +/* 5-tuple key type */ +struct flow_key { + uint32_t ip_src; + uint32_t ip_dst; + uint16_t port_src; + uint16_t port_dst; + uint8_t proto; +} __packed; + +/* + * Print out result of unit test hash operation. + */ +static void print_key_info( + const char *msg, const struct flow_key *key) +{ + const uint8_t *p = (const uint8_t *)key; + unsigned i; + + printf("%s key:0x", msg); + for (i = 0; i < sizeof(struct flow_key); i++) + printf("%02X", p[i]); + printf("\n"); +} + +static double get_time_diff(struct timeval *start, struct timeval *end) +{ + int sec = end->tv_sec - start->tv_sec; + int usec = end->tv_usec - start->tv_usec; + + if (usec < 0) { + sec--; + usec += 1000000; + } + double diff = sec + (double)usec / 1000000; + + return diff; +} + +/** Create IPv4 address */ +#define IPv4(a, b, c, d) ((uint32_t)(((a) & 0xff) << 24) | \ + (((b) & 0xff) << 16) | \ + (((c) & 0xff) << 8) | \ + ((d) & 0xff)) + +/* Keys used by unit test functions */ +static struct flow_key keys[5] = { { + .ip_src = IPv4(0x03, 0x02, 0x01, 0x00), + .ip_dst = IPv4(0x07, 0x06, 0x05, 0x04), + .port_src = 0x0908, + .port_dst = 0x0b0a, + .proto = 0x0c, +}, { + .ip_src = IPv4(0x13, 0x12, 0x11, 0x10), + .ip_dst = IPv4(0x17, 0x16, 0x15, 0x14), + .port_src = 0x1918, + .port_dst = 0x1b1a, + .proto = 0x1c, +}, { + .ip_src = IPv4(0x23, 0x22, 0x21, 0x20), + .ip_dst = IPv4(0x27, 0x26, 0x25, 0x24), + .port_src = 0x2928, + .port_dst = 0x2b2a, + .proto = 0x2c, +}, { + .ip_src = IPv4(0x33, 0x32, 0x31, 0x30), + .ip_dst = IPv4(0x37, 0x36, 0x35, 0x34), + .port_src = 0x3938, + .port_dst = 0x3b3a, + .proto = 0x3c, +}, { + .ip_src = IPv4(0x43, 0x42, 0x41, 0x40), + .ip_dst = IPv4(0x47, 0x46, 0x45, 0x44), + .port_src = 0x4948, + .port_dst = 0x4b4a, + .proto = 0x4c, +} }; + +/* + * Basic sequence of operations for a single key: + * - put + * - get (hit) + * - remove + * - get (miss) + */ +static int test_put_remove(void) +{ + odph_table_t table; + odph_table_ops_t *ops; + + ops = &odph_cuckoo_table_ops; + + /* test with standard put/get/remove functions */ + int ret; + + table = ops->f_create("put_remove", 10, sizeof(struct flow_key), 0); + if (table == NULL) { + printf("cuckoo hash table creation failed\n"); + return -1; + } + + ret = odph_cuckoo_table_put_value(table, &keys[0], NULL); + print_key_info("Add", &keys[0]); + if (ret < 0) { + printf("failed to add key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + ret = odph_cuckoo_table_get_value(table, &keys[0], NULL, 0); + print_key_info("Lkp", &keys[0]); + if (ret < 0) { + printf("failed to find key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + ret = odph_cuckoo_table_remove_value(table, &keys[0]); + print_key_info("Del", &keys[0]); + if (ret < 0) { + printf("failed to delete key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + ret = odph_cuckoo_table_get_value(table, &keys[0], NULL, 0); + print_key_info("Lkp", &keys[0]); + if (ret >= 0) { + printf("error: found key after deleting!\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + odph_cuckoo_table_destroy(table); + return 0; +} + +/* + * Sequence of operations for a single key: + * key type : struct flow_key + * value type: uint8_t + * - remove: miss + * - put + * - get: hit + * - put: update + * - get: hit (updated data) + * - remove: hit + * - remove: miss + */ +static int test_put_update_remove(void) +{ + odph_table_t table; + int ret; + uint8_t val1 = 1, val2 = 2, val = 0; + + table = odph_cuckoo_table_create( + "put_update_remove", + 10, sizeof(struct flow_key), sizeof(uint8_t)); + if (table == NULL) { + printf("failed to create table\n"); + return -1; + } + + ret = odph_cuckoo_table_remove_value(table, &keys[0]); + print_key_info("Del", &keys[0]); + if (ret >= 0) { + printf("error: found non-existent key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + ret = odph_cuckoo_table_put_value(table, &keys[0], &val1); + print_key_info("Add", &keys[0]); + if (ret < 0) { + printf("failed to add key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + ret = odph_cuckoo_table_get_value( + table, &keys[0], &val, sizeof(uint8_t)); + print_key_info("Lkp", &keys[0]); + if (ret < 0) { + printf("failed to find key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + ret = odph_cuckoo_table_put_value(table, &keys[0], &val2); + if (ret < 0) { + printf("failed to re-add key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + ret = odph_cuckoo_table_get_value( + table, &keys[0], &val, sizeof(uint8_t)); + print_key_info("Lkp", &keys[0]); + if (ret < 0) { + printf("failed to find key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + ret = odph_cuckoo_table_remove_value(table, &keys[0]); + print_key_info("Del", &keys[0]); + if (ret < 0) { + printf("failed to delete key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + ret = odph_cuckoo_table_remove_value(table, &keys[0]); + print_key_info("Del", &keys[0]); + if (ret >= 0) { + printf("error: deleted already deleted key\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + odph_cuckoo_table_destroy(table); + return 0; +} + +/* + * Sequence of operations for find existing hash table + * + * - create table + * - find existing table: hit + * - find non-existing table: miss + * + */ +static int test_table_lookup(void) +{ + odph_table_t table, result; + + /* Create cuckoo hash table. */ + table = odph_cuckoo_table_create("table_lookup", 10, 4, 0); + if (table == NULL) { + printf("failed to create table\n"); + return -1; + } + + /* Try to find existing hash table */ + result = odph_cuckoo_table_lookup("table_lookup"); + if (result != table) { + printf("error: could not find existing table\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + /* Try to find non-existing hash table */ + result = odph_cuckoo_table_lookup("non_existing"); + if (result != NULL) { + printf("error: found table that shouldn't exist.\n"); + odph_cuckoo_table_destroy(table); + return -1; + } + + /* Cleanup. */ + odph_cuckoo_table_destroy(table); + return 0; +} + +/* + * Sequence of operations for 5 keys + * - put keys + * - get keys: hit + * - remove keys : hit + * - get keys: miss + */ +static int test_five_keys(void) +{ + odph_table_t table; + unsigned i; + int ret; + + table = odph_cuckoo_table_create( + "five_keys", 10, sizeof(struct flow_key), 0); + if (table == NULL) { + printf("failed to create table\n"); + return -1; + } + + /* put */ + for (i = 0; i < 5; i++) { + ret = odph_cuckoo_table_put_value(table, &keys[i], NULL); + print_key_info("Add", &keys[i]); + if (ret < 0) { + printf("failed to add key %d\n", i); + odph_cuckoo_table_destroy(table); + return -1; + } + } + + /* get */ + for (i = 0; i < 5; i++) { + ret = odph_cuckoo_table_get_value(table, &keys[i], NULL, 0); + print_key_info("Lkp", &keys[i]); + if (ret < 0) { + printf("failed to find key %d\n", i); + odph_cuckoo_table_destroy(table); + return -1; + } + } + + /* remove */ + for (i = 0; i < 5; i++) { + ret = odph_cuckoo_table_remove_value(table, &keys[i]); + print_key_info("Del", &keys[i]); + if (ret < 0) { + printf("failed to delete key %d\n", i); + odph_cuckoo_table_destroy(table); + return -1; + } + } + + /* get */ + for (i = 0; i < 5; i++) { + ret = odph_cuckoo_table_get_value(table, &keys[i], NULL, 0); + print_key_info("Lkp", &keys[i]); + if (ret >= 0) { + printf("found non-existing key %d\n", i); + odph_cuckoo_table_destroy(table); + return -1; + } + } + + odph_cuckoo_table_destroy(table); + return 0; +} + +#define BUCKET_ENTRIES 4 +#define HASH_ENTRIES_MAX 1048576 +/* + * Do tests for cuchoo tabke creation with bad parameters. + */ +static int test_creation_with_bad_parameters(void) +{ + odph_table_t table; + + table = odph_cuckoo_table_create( + "bad_param_0", HASH_ENTRIES_MAX + 1, 4, 0); + if (table != NULL) { + odph_cuckoo_table_destroy(table); + printf("Impossible creating table successfully with entries in parameter exceeded\n"); + return -1; + } + + table = odph_cuckoo_table_create( + "bad_param_1", BUCKET_ENTRIES - 1, 4, 0); + if (table != NULL) { + odph_cuckoo_table_destroy(table); + printf("Impossible creating hash successfully if entries less than bucket_entries in parameter\n"); + return -1; + } + + table = odph_cuckoo_table_create("bad_param_2", 10, 0, 0); + if (table != NULL) { + odph_cuckoo_table_destroy(table); + printf("Impossible creating hash successfully if key_len in parameter is zero\n"); + return -1; + } + + printf("# Test successful. No more errors expected\n"); + + return 0; +} + +#define PERFORMANCE_CAPACITY 1000000 + +/* + * Test the performance of cuckoo hash table. + * table capacity : 1,000,000 + * key size : 4 bytes + * value size : 0 + * Insert at most number random keys into the table. If one + * insertion is failed, the rest insertions will be cancelled. + * The table utilization of the report will show actual number + * of items inserted. + * Then search all inserted items. + */ +static int test_performance(int number) +{ + odph_table_t table; + + /* generate random keys */ + uint8_t *key_space = NULL; + const void **key_ptr = NULL; + unsigned key_len = 4, j; + unsigned elem_num = (number > PERFORMANCE_CAPACITY) ? + PERFORMANCE_CAPACITY : number; + unsigned key_num = key_len * elem_num; + + key_space = (uint8_t *)malloc(key_num); + key_ptr = (const void **)malloc(sizeof(void *) * elem_num); + if (key_space == NULL) + return -ENOENT; + + for (j = 0; j < key_num; j++) { + key_space[j] = rand() % 255; + if (j % key_len == 0) + key_ptr[j / key_len] = &key_space[j]; + } + + unsigned num; + int ret = 0; + struct timeval start, end; + double add_time = 0; + + fflush(stdout); + table = odph_cuckoo_table_create( + "performance_test", PERFORMANCE_CAPACITY, key_len, 0); + if (table == NULL) { + printf("cuckoo table creation failed\n"); + return -ENOENT; + } + + /* insert (put) */ + gettimeofday(&start, 0); + for (j = 0; j < elem_num; j++) { + ret = odph_cuckoo_table_put_value( + table, &key_space[j * key_len], NULL); + if (ret < 0) + break; + } + gettimeofday(&end, 0); + num = j; + add_time = get_time_diff(&start, &end); + printf( + "add %u/%u (%.2f) items, time = %.9lfs\n", + num, PERFORMANCE_CAPACITY, + (double)num / PERFORMANCE_CAPACITY, add_time); + + /* search (get) */ + gettimeofday(&start, 0); + for (j = 0; j < num; j++) { + ret = odph_cuckoo_table_get_value( + table, &key_space[j * key_len], NULL, 0); + + if (ret < 0) + printf("lookup error\n"); + } + gettimeofday(&end, 0); + printf( + "lookup %u items, time = %.9lfs\n", + num, get_time_diff(&start, &end)); + + odph_cuckoo_table_destroy(table); + free(key_ptr); + free(key_space); + return ret; +} + +/* + * Do all unit and performance tests. + */ +static int +test_cuckoo_hash_table(void) +{ + if (test_put_remove() < 0) + return -1; + if (test_table_lookup() < 0) + return -1; + if (test_put_update_remove() < 0) + return -1; + if (test_five_keys() < 0) + return -1; + if (test_creation_with_bad_parameters() < 0) + return -1; + if (test_performance(950000) < 0) + return -1; + + return 0; +} + +int main(int argc TEST_UNUSED, char *argv[] TEST_UNUSED) +{ + odp_instance_t instance; + int ret = 0; + + ret = odp_init_global(&instance, NULL, NULL); + if (ret != 0) { + fprintf(stderr, "Error: ODP global init failed.\n"); + exit(EXIT_FAILURE); + } + + ret = odp_init_local(instance, ODP_THREAD_WORKER); + if (ret != 0) { + fprintf(stderr, "Error: ODP local init failed.\n"); + exit(EXIT_FAILURE); + } + + srand(time(0)); + ret = test_cuckoo_hash_table(); + + if (ret < 0) + printf("cuckoo hash table test fail!!\n"); + else + printf("All Tests pass!!\n"); + + if (odp_term_local()) { + fprintf(stderr, "Error: ODP local term failed.\n"); + exit(EXIT_FAILURE); + } + + if (odp_term_global(instance)) { + fprintf(stderr, "Error: ODP global term failed.\n"); + exit(EXIT_FAILURE); + } + + return ret; +} commit d1e693d7177d10f382d69b659ab359fddee783b5 Author: Ru Jia <jiaru(a)ict.ac.cn> Date: Mon Jun 13 14:42:13 2016 +0800 helper: table: add impl of cuckoo hash table Signed-off-by: Ru Jia <jiaru(a)ict.ac.cn> Reviewed-and-tested-by: Bill Fischofer <bill.fischofer(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/helper/Makefile.am b/helper/Makefile.am index aa58e8c..116a1f0 100644 --- a/helper/Makefile.am +++ b/helper/Makefile.am @@ -27,6 +27,7 @@ noinst_HEADERS = \ $(srcdir)/odph_debug.h \ $(srcdir)/odph_hashtable.h \ $(srcdir)/odph_lineartable.h \ + $(srcdir)/odph_cuckootable.h \ $(srcdir)/odph_list_internal.h __LIB__libodphelper_linux_la_SOURCES = \ @@ -35,6 +36,7 @@ __LIB__libodphelper_linux_la_SOURCES = \ chksum.c \ linux.c \ hashtable.c \ - lineartable.c + lineartable.c \ + cuckootable.c lib_LTLIBRARIES = $(LIB)/libodphelper-linux.la diff --git a/helper/cuckootable.c b/helper/cuckootable.c new file mode 100644 index 0000000..91a73b4 --- /dev/null +++ b/helper/cuckootable.c @@ -0,0 +1,743 @@ +/* Copyright (c) 2016, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2016 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <string.h> +#include <stdint.h> +#include <errno.h> +#include <stdio.h> + +#include "odph_cuckootable.h" +#include "odph_debug.h" +#include <odp_api.h> + +/* More efficient access to a map of single ullong */ +#define ULLONG_FOR_EACH_1(IDX, MAP) \ + for (; MAP && (((IDX) = __builtin_ctzll(MAP)), true); \ + MAP = (MAP & (MAP - 1))) + +/** @magic word, write to the first byte of the memory block + * to indicate this block is used by a cuckoo hash table + */ +#define ODPH_CUCKOO_TABLE_MAGIC_WORD 0xDFDFFDFD + +/** Number of items per bucket. */ +#define HASH_BUCKET_ENTRIES 4 + +#define NULL_SIGNATURE 0 +#define KEY_ALIGNMENT 16 + +/** Maximum size of hash table that can be created. */ +#define HASH_ENTRIES_MAX 1048576 + +/** @internal signature struct + * Structure storing both primary and secondary hashes + */ +struct cuckoo_table_signatures { + union { + struct { + uint32_t current; + uint32_t alt; + }; + uint64_t sig; + }; +}; + +/** @internal kay-value struct + * Structure that stores key-value pair + */ +struct cuckoo_table_key_value { + uint8_t *key; + uint8_t *value; +}; + +/** @internal bucket structure + * Put the elements with defferent keys but a same signature + * into a bucket, and each bucket has at most HASH_BUCKET_ENTRIES + * elements. + */ +struct cuckoo_table_bucket { + struct cuckoo_table_signatures signatures[HASH_BUCKET_ENTRIES]; + /* Includes dummy key index that always contains index 0 */ + odp_buffer_t key_buf[HASH_BUCKET_ENTRIES + 1]; + uint8_t flag[HASH_BUCKET_ENTRIES]; +} ODP_ALIGNED_CACHE; + +/* More efficient access to a map of single ullong */ +#define ULLONG_FOR_EACH_1(IDX, MAP) \ + for (; MAP && (((IDX) = __builtin_ctzll(MAP)), true); \ + MAP = (MAP & (MAP - 1))) + +/** A hash table structure. */ +typedef struct { + /**< for check */ + uint32_t magicword; + /**< Name of the hash. */ + char name[ODPH_TABLE_NAME_LEN]; + /**< Total table entries. */ + uint32_t entries; + /**< Number of buckets in table. */ + uint32_t num_buckets; + /**< Length of hash key. */ + uint32_t key_len; + /**< Length of value. */ + uint32_t value_len; + /**< Bitmask for getting bucket index from hash signature. */ + uint32_t bucket_bitmask; + /**< Queue that stores all free key-value slots*/ + odp_queue_t free_slots; + /** Table with buckets storing all the hash values and key indexes + to the key table*/ + struct cuckoo_table_bucket *buckets; +} odph_cuckoo_table_impl ODP_ALIGNED_CACHE; + +/** + * Aligns input parameter to the next power of 2 + * + * @param x + * The integer value to algin + * + * @return + * Input parameter aligned to the next power of 2 + */ +static inline uint32_t +align32pow2(uint32_t x) +{ + x--; + x |= x >> 1; + x |= x >> 2; + x |= x >> 4; + x |= x >> 8; + x |= x >> 16; + + return x + 1; +} + +/** + * Returns true if n is a power of 2 + * @param n + * Number to check + * @return 1 if true, 0 otherwise + */ +static inline int +is_power_of_2(uint32_t n) +{ + return n && !(n & (n - 1)); +} + +odph_table_t +odph_cuckoo_table_lookup(const char *name) +{ + odph_cuckoo_table_impl *tbl = NULL; + + if (name == NULL || strlen(name) >= ODPH_TABLE_NAME_LEN) + return NULL; + + tbl = (odph_cuckoo_table_impl *)odp_shm_addr(odp_shm_lookup(name)); + + if ( + tbl != NULL && + tbl->magicword == ODPH_CUCKOO_TABLE_MAGIC_WORD && + strcmp(tbl->name, name) == 0) + return (odph_table_t)tbl; +} + +odph_table_t +odph_cuckoo_table_create( + const char *name, uint32_t capacity, uint32_t key_size, + uint32_t value_size) +{ + odph_cuckoo_table_impl *tbl; + odp_shm_t shm_tbl; + + odp_pool_t pool; + odp_pool_param_t param; + + odp_queue_t queue; + odp_queue_param_t qparam; + + char pool_name[ODPH_TABLE_NAME_LEN + 3], + queue_name[ODPH_TABLE_NAME_LEN + 3]; + unsigned i; + uint32_t impl_size, kv_entry_size, + bucket_num, bucket_size; + + /* Check for valid parameters */ + if ( + (capacity > HASH_ENTRIES_MAX) || + (capacity < HASH_BUCKET_ENTRIES) || + (key_size == 0) || + (strlen(name) == 0)) { + ODPH_DBG("invalid parameters\n"); + return NULL; + } + + /* Guarantee there's no existing */ + tbl = (odph_cuckoo_table_impl *)odph_cuckoo_table_lookup(name); + if (tbl != NULL) { + ODPH_DBG("cuckoo hash table %s already exists\n", name); + return NULL; + } + + /* Calculate the sizes of different parts of cuckoo hash table */ + impl_size = sizeof(odph_cuckoo_table_impl); + kv_entry_size = sizeof(struct cuckoo_table_key_value) + + key_size + value_size; + + bucket_num = align32pow2(capacity) / HASH_BUCKET_ENTRIES; + bucket_size = bucket_num * sizeof(struct cuckoo_table_bucket); + + shm_tbl = odp_shm_reserve( + name, impl_size + bucket_size, + ODP_CACHE_LINE_SIZE, ODP_SHM_SW_ONLY); + + if (shm_tbl == ODP_SHM_INVALID) { + ODPH_DBG( + "shm allocation failed for odph_cuckoo_table_impl %s\n", + name); + return NULL; + } + + tbl = (odph_cuckoo_table_impl *)odp_shm_addr(shm_tbl); + memset(tbl, 0, impl_size + bucket_size); + + /* header of this mem block is the table impl struct, + * then the bucket pool. + */ + tbl->buckets = (struct cuckoo_table_bucket *)( + (char *)tbl + impl_size); + + /* initialize key-value buffer pool */ + snprintf(pool_name, sizeof(pool_name), "kv_%s", name); + pool = odp_pool_lookup(pool_name); + + if (pool != ODP_POOL_INVALID) + odp_pool_destroy(pool); + + param.type = ODP_POOL_BUFFER; + param.buf.size = kv_entry_size; + param.buf.align = ODP_CACHE_LINE_SIZE; + param.buf.num = capacity; + + pool = odp_pool_create(pool_name, &param); + + if (pool == ODP_POOL_INVALID) { + ODPH_DBG("failed to create key-value pool\n"); + odp_shm_free(shm_tbl); + return NULL; + } + + /* initialize free_slots queue */ + odp_queue_param_init(&qparam); + qparam.type = ODP_QUEUE_TYPE_PLAIN; + + snprintf(queue_name, sizeof(queue_name), "fs_%s", name); + queue = odp_queue_create(queue_name, &qparam); + if (queue == ODP_QUEUE_INVALID) { + ODPH_DBG("failed to create free_slots queue\n"); + odp_pool_destroy(pool); + odp_shm_free(shm_tbl); + return NULL; + } + + /* Setup hash context */ + snprintf(tbl->name, sizeof(tbl->name), "%s", name); + tbl->magicword = ODPH_CUCKOO_TABLE_MAGIC_WORD; + tbl->entries = capacity; + tbl->key_len = key_size; + tbl->value_len = value_size; + tbl->num_buckets = bucket_num; + tbl->bucket_bitmask = bucket_num - 1; + tbl->free_slots = queue; + + /* generate all free buffers, and put into queue */ + for (i = 0; i < capacity; i++) { + odp_event_t ev = odp_buffer_to_event( + odp_buffer_alloc(pool)); + if (ev == ODP_EVENT_INVALID) { + ODPH_DBG("failed to generate free slots\n"); + odph_cuckoo_table_destroy((odph_table_t)tbl); + return NULL; + } + + if (odp_queue_enq(queue, ev) < 0) { + ODPH_DBG("failed to enqueue free slots\n"); + odph_cuckoo_table_destroy((odph_table_t)tbl); + return NULL; + } + } + + return (odph_table_t)tbl; +} + +int +odph_cuckoo_table_destroy(odph_table_t tbl) +{ + int ret, i, j; + odph_cuckoo_table_impl *impl = NULL; + char pool_name[ODPH_TABLE_NAME_LEN + 3]; + + if (tbl == NULL) + return -1; + + impl = (odph_cuckoo_table_impl *)tbl; + + /* check magic word */ + if (impl->magicword != ODPH_CUCKOO_TABLE_MAGIC_WORD) { + ODPH_DBG("wrong magicword for cuckoo table\n"); + return -1; + } + + /* free all used buffers*/ + for (i = 0; i < impl->num_buckets; i++) { + for (j = 0; j < HASH_BUCKET_ENTRIES; j++) { + if (impl->buckets[i].signatures[j].current + != NULL_SIGNATURE) + odp_buffer_free(impl->buckets[i].key_buf[j]); + } + } + + /* free all free buffers */ + odp_event_t ev; + + while ((ev = odp_queue_deq(impl->free_slots)) + != ODP_EVENT_INVALID) { + odp_buffer_free(odp_buffer_from_event(ev)); + } + + /* destroy free_slots queue */ + ret = odp_queue_destroy(impl->free_slots); + if (ret < 0) + ODPH_DBG("failed to destroy free_slots queue\n"); + + /* destroy key-value pool */ + snprintf(pool_name, sizeof(pool_name), "kv_%s", impl->name); + ret = odp_pool_destroy(odp_pool_lookup(pool_name)); + if (ret != 0) { + ODPH_DBG("failed to destroy key-value buffer pool\n"); + return ret; + } + + /* free impl */ + odp_shm_free(odp_shm_lookup(impl->name)); +} + +static uint32_t hash(const odph_cuckoo_table_impl *h, const void *key) +{ + /* calc hash result by key */ + return odp_hash_crc32c(key, h->key_len, 0); +} + +/* Calc the secondary hash value from the primary hash value of a given key */ +static inline uint32_t +hash_secondary(const uint32_t primary_hash) +{ + static const unsigned all_bits_shift = 12; + static const unsigned alt_bits_xor = 0x5bd1e995; + + uint32_t tag = primary_hash >> all_bits_shift; + + return (primary_hash ^ ((tag + 1) * alt_bits_xor)); +} + +/* Search for an entry that can be pushed to its alternative location */ +static inline int +make_space_bucket( + const odph_cuckoo_table_impl *impl, + struct cuckoo_table_bucket *bkt) +{ + unsigned i, j; + int ret; + uint32_t next_bucket_idx; + struct cuckoo_table_bucket *next_bkt[HASH_BUCKET_ENTRIES]; + + /* + * Push existing item (search for bucket with space in + * alternative locations) to its alternative location + */ + for (i = 0; i < HASH_BUCKET_ENTRIES; i++) { + /* Search for space in alternative locations */ + next_bucket_idx = bkt->signatures[i].alt & impl->bucket_bitmask; + next_bkt[i] = &impl->buckets[next_bucket_idx]; + for (j = 0; j < HASH_BUCKET_ENTRIES; j++) { + if (next_bkt[i]->signatures[j].sig == NULL_SIGNATURE) + break; + } + + if (j != HASH_BUCKET_ENTRIES) + break; + } + + /* Alternative location has spare room (end of recursive function) */ + if (i != HASH_BUCKET_ENTRIES) { + next_bkt[i]->signatures[j].alt = bkt->signatures[i].current; + next_bkt[i]->signatures[j].current = bkt->signatures[i].alt; + next_bkt[i]->key_buf[j] = bkt->key_buf[i]; + return i; + } + + /* Pick entry that has not been pushed yet */ + for (i = 0; i < HASH_BUCKET_ENTRIES; i++) + if (bkt->flag[i] == 0) + break; + + /* All entries have been pushed, so entry cannot be added */ + if (i == HASH_BUCKET_ENTRIES) + return -ENOSPC; + + /* Set flag to indicate that this entry is going to be pushed */ + bkt->flag[i] = 1; + /* Need room in alternative bucket to insert the pushed entry */ + ret = make_space_bucket(impl, next_bkt[i]); + /* + * After recursive function. + * Clear flags and insert the pushed entry + * in its alternative location if successful, + * or return error + */ + bkt->flag[i] = 0; + if (ret >= 0) { + next_bkt[i]->signatures[ret].alt = bkt->signatures[i].current; + next_bkt[i]->signatures[ret].current = bkt->signatures[i].alt; + next_bkt[i]->key_buf[ret] = bkt->key_buf[i]; + return i; + } + + return ret; +} + +static inline int32_t +cuckoo_table_add_key_with_hash( + const odph_cuckoo_table_impl *h, const void *key, + uint32_t sig, void *data) +{ + uint32_t alt_hash; + uint32_t prim_bucket_idx, sec_bucket_idx; + unsigned i; + struct cuckoo_table_bucket *prim_bkt, *sec_bkt; + struct cuckoo_table_key_value *new_kv, *kv; + + odp_buffer_t new_buf; + int ret; + + prim_bucket_idx = sig & h->bucket_bitmask; + prim_bkt = &h->buckets[prim_bucket_idx]; + __builtin_prefetch((const void *)(uintptr_t)prim_bkt, 0, 3); + + alt_hash = hash_secondary(sig); + sec_bucket_idx = alt_hash & h->bucket_bitmask; + sec_bkt = &h->buckets[sec_bucket_idx]; + __builtin_prefetch((const void *)(uintptr_t)sec_bkt, 0, 3); + + /* Get a new slot for storing the new key */ + new_buf = odp_buffer_from_event(odp_queue_deq(h->free_slots)); + if (new_buf == ODP_BUFFER_INVALID) + return -ENOSPC; + + /* Check if key is already inserted in primary location */ + for (i = 0; i < HASH_BUCKET_ENTRIES; i++) { + if ( + prim_bkt->signatures[i].current == sig && + prim_bkt->signatures[i].alt == alt_hash) { + kv = (struct cuckoo_table_key_value *)odp_buffer_addr( + prim_bkt->key_buf[i]); + if (memcmp(key, kv->key, h->key_len) == 0) { + odp_queue_enq( + h->free_slots, + odp_buffer_to_event(new_buf)); + /* Update data */ + if (kv->value != NULL) + memcpy(kv->value, data, h->value_len); + + /* Return bucket index */ + return prim_bucket_idx; + } + } + } + + /* Check if key is already inserted in secondary location */ + for (i = 0; i < HASH_BUCKET_ENTRIES; i++) { + if ( + sec_bkt->signatures[i].alt == sig && + sec_bkt->signatures[i].current == alt_hash) { + kv = (struct cuckoo_table_key_value *)odp_buffer_addr( + sec_bkt->key_buf[i]); + if (memcmp(key, kv->key, h->key_len) == 0) { + odp_queue_enq( + h->free_slots, + odp_buffer_to_event(new_buf)); + /* Update data */ + if (kv->value != NULL) + memcpy(kv->value, data, h->value_len); + + /* Return bucket index */ + return sec_bucket_idx; + } + } + } + + new_kv = (struct cuckoo_table_key_value *)odp_buffer_addr(new_buf); + __builtin_prefetch((const void *)(uintptr_t)new_kv, 0, 3); + + /* Copy key and value. + * key-value mem block : struct cuckoo_table_key_value + * + key (key_len) + value (value_len) + */ + new_kv->key = (uint8_t *)new_kv + + sizeof(struct cuckoo_table_key_value); + memcpy(new_kv->key, key, h->key_len); + + if (h->value_len > 0) { + new_kv->value = new_kv->key + h->key_len; + memcpy(new_kv->value, data, h->value_len); + } else { + new_kv->value = NULL; + } + + /* Insert new entry is there is room in the primary bucket */ + for (i = 0; i < HASH_BUCKET_ENTRIES; i++) { + /* Check if slot is available */ + if (odp_likely(prim_bkt->signatures[i].sig == NULL_SIGNATURE)) { + prim_bkt->signatures[i].current = sig; + prim_bkt->signatures[i].alt = alt_hash; + prim_bkt->key_buf[i] = new_buf; + return prim_bucket_idx; + } + } + + /* Primary bucket is full, so we need to make space for new entry */ + ret = make_space_bucket(h, prim_bkt); + + /* + * After recursive function. + * Insert the new entry in the position of the pushed entry + * if successful or return error and + * store the new slot back in the pool + */ + if (ret >= 0) { + prim_bkt->signatures[ret].current = sig; + prim_bkt->signatures[ret].alt = alt_hash; + prim_bkt->key_buf[ret] = new_buf; + return prim_bucket_idx; + } + + /* Error in addition, store new slot back in the free_slots */ + odp_queue_enq(h->free_slots, odp_buffer_to_event(new_buf)); + return ret; +} + +int +odph_cuckoo_table_put_value(odph_table_t tbl, void *key, void *value) +{ + if ((tbl == NULL) || (key == NULL)) + return -EINVAL; + + odph_cuckoo_table_impl *impl = (odph_cuckoo_table_impl *)tbl; + int ret = cuckoo_table_add_key_with_hash( + impl, key, hash(impl, key), value); + + if (ret < 0) + return -1; + + return 0; +} + +static inline int32_t +cuckoo_table_lookup_with_hash( + const odph_cuckoo_table_impl *h, const void *key, + uint32_t sig, void **data_ptr) +{ + uint32_t bucket_idx; + uint32_t alt_hash; + unsigned i; + struct cuckoo_table_bucket *bkt; + struct cuckoo_table_key_value *kv; + + bucket_idx = sig & h->bucket_bitmask; + bkt = &h->buckets[bucket_idx]; + + /* Check if key is in primary location */ + for (i = 0; i < HASH_BUCKET_ENTRIES; i++) { + if ( + bkt->signatures[i].current == sig && + bkt->signatures[i].sig != NULL_SIGNATURE) { + kv = (struct cuckoo_table_key_value *)odp_buffer_addr( + bkt->key_buf[i]); + if (memcmp(key, kv->key, h->key_len) == 0) { + if (data_ptr != NULL) + *data_ptr = kv->value; + /* + * Return index where key is stored, + * subtracting the first dummy index + */ + return bucket_idx; + } + } + } + + /* Calculate secondary hash */ + alt_hash = hash_secondary(sig); + bucket_idx = alt_hash & h->bucket_bitmask; + bkt = &h->buckets[bucket_idx]; + + /* Check if key is in secondary location */ + for (i = 0; i < HASH_BUCKET_ENTRIES; i++) { + if ( + bkt->signatures[i].current == alt_hash && + bkt->signatures[i].alt == sig) { + kv = (struct cuckoo_table_key_value *)odp_buffer_addr( + bkt->key_buf[i]); + if (memcmp(key, kv->key, h->key_len) == 0) { + if (data_ptr != NULL) + *data_ptr = kv->value; + /* + * Return index where key is stored, + * subtracting the first dummy index + */ + return bucket_idx; + } + } + } + + return -ENOENT; +} + +int +odph_cuckoo_table_get_value( + odph_table_t tbl, void *key, void *buffer, uint32_t buffer_size) +{ + if ((tbl == NULL) || (key == NULL)) + return -EINVAL; + + odph_cuckoo_table_impl *impl = (odph_cuckoo_table_impl *)tbl; + void *tmp = NULL; + int ret; + + ret = cuckoo_table_lookup_with_hash(impl, key, hash(impl, key), &tmp); + + if (ret < 0) + return -1; + + if (impl->value_len > 0) + memcpy(buffer, tmp, impl->value_len); + + return 0; +} + +static inline int32_t +cuckoo_table_del_key_with_hash( + const odph_cuckoo_table_impl *h, + const void *key, uint32_t sig) +{ + uint32_t bucket_idx; + uint32_t alt_hash; + unsigned i; + struct cuckoo_table_bucket *bkt; + struct cuckoo_table_key_value *kv; + + bucket_idx = sig & h->bucket_bitmask; + bkt = &h->buckets[bucket_idx]; + + /* Check if key is in primary location */ + for (i = 0; i < HASH_BUCKET_ENTRIES; i++) { + if ( + bkt->signatures[i].current == sig && + bkt->signatures[i].sig != NULL_SIGNATURE) { + kv = (struct cuckoo_table_key_value *)odp_buffer_addr( + bkt->key_buf[i]); + if (memcmp(key, kv->key, h->key_len) == 0) { + bkt->signatures[i].sig = NULL_SIGNATURE; + odp_queue_enq( + h->free_slots, + odp_buffer_to_event( + bkt->key_buf[i])); + return bucket_idx; + } + } + } + + /* Calculate secondary hash */ + alt_hash = hash_secondary(sig); + bucket_idx = alt_hash & h->bucket_bitmask; + bkt = &h->buckets[bucket_idx]; + + /* Check if key is in secondary location */ + for (i = 0; i < HASH_BUCKET_ENTRIES; i++) { + if ( + bkt->signatures[i].current == alt_hash && + bkt->signatures[i].sig != NULL_SIGNATURE) { + kv = (struct cuckoo_table_key_value *)odp_buffer_addr( + bkt->key_buf[i]); + if (memcmp(key, kv->key, h->key_len) == 0) { + bkt->signatures[i].sig = NULL_SIGNATURE; + odp_queue_enq( + h->free_slots, + odp_buffer_to_event( + bkt->key_buf[i])); + return bucket_idx; + } + } + } + + return -ENOENT; +} + +int +odph_cuckoo_table_remove_value(odph_table_t tbl, void *key) +{ + if ((tbl == NULL) || (key == NULL)) + return -EINVAL; + + odph_cuckoo_table_impl *impl = (odph_cuckoo_table_impl *)tbl; + int ret = cuckoo_table_del_key_with_hash( + impl, key, hash(impl, key)); + + if (ret < 0) + return -1; + + return 0; +} + +odph_table_ops_t odph_cuckoo_table_ops = { + odph_cuckoo_table_create, + odph_cuckoo_table_lookup, + odph_cuckoo_table_destroy, + odph_cuckoo_table_put_value, + odph_cuckoo_table_get_value, + odph_cuckoo_table_remove_value +}; diff --git a/helper/odph_cuckootable.h b/helper/odph_cuckootable.h new file mode 100644 index 0000000..d569980 --- /dev/null +++ b/helper/odph_cuckootable.h @@ -0,0 +1,82 @@ +/* Copyright (c) 2016, Linaro Limited + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +/*- + * BSD LICENSE + * + * Copyright(c) 2010-2016 Intel Corporation. All rights reserved. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Intel Corporation nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef ODPH_CUCKOO_TABLE_H_ +#define ODPH_CUCKOO_TABLE_H_ + +#include <odp/helper/table.h> + +/** + * @file + * + * ODP Cuckoo Hash Table + */ + +#ifdef __cplusplus +extern "C" { +#endif + +odph_table_t odph_cuckoo_table_create( + const char *name, + uint32_t capacity, + uint32_t key_size, + uint32_t value_size); + +odph_table_t odph_cuckoo_table_lookup(const char *name); + +int odph_cuckoo_table_destroy(odph_table_t table); + +int odph_cuckoo_table_put_value( + odph_table_t table, + void *key, void *value); + +int odph_cuckoo_table_get_value( + odph_table_t table, + void *key, void *buffer, + uint32_t buffer_size); + +int odph_cuckoo_table_remove_value(odph_table_t table, void *key); + +extern odph_table_ops_t odph_cuckoo_table_ops; + +#ifdef __cplusplus +} +#endif + +#endif /* ODPH_CUCKOO_TABLE_H_ */ ----------------------------------------------------------------------- Summary of changes: helper/Makefile.am | 4 +- helper/cuckootable.c | 743 ++++++++++++++++++++++++++++++++++++++++++++++ helper/odph_cuckootable.h | 82 +++++ helper/test/.gitignore | 1 + helper/test/Makefile.am | 6 +- helper/test/cuckootable.c | 573 +++++++++++++++++++++++++++++++++++ 6 files changed, 1406 insertions(+), 3 deletions(-) create mode 100644 helper/cuckootable.c create mode 100644 helper/odph_cuckootable.h create mode 100644 helper/test/cuckootable.c hooks/post-receive --

9 years, 7 months

[COMMIT] branch master updated. v1.10.1.0-34-g15f3c17

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, master has been updated via 15f3c174f5a104e9749ed83797acb00660d675ad (commit) via f9baafc4a5644973410ef6c5a1d233671bec1d17 (commit) from 1b1da0fe917cb916232fd9aad615b68941b8f490 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 15f3c174f5a104e9749ed83797acb00660d675ad Author: Bill Fischofer <bill.fischofer(a)linaro.org> Date: Thu Jun 9 07:12:41 2016 -0500 validation: packet: ensure user area is copied correctly As part of resolution of Bug https://bugs.linaro.org/show_bug.cgi?id=2310 make sure that odp_packet_copy() handles user area copies correctly. The copy should fail if the target pool's user area size is not large enough to contain the source user area. Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org> Reviewed-by: Zoltan Kiss <zoltan.kiss(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/test/validation/packet/packet.c b/test/validation/packet/packet.c index 6770339..a4426e2 100644 --- a/test/validation/packet/packet.c +++ b/test/validation/packet/packet.c @@ -14,7 +14,7 @@ /* Reserve some tailroom for tests */ #define PACKET_TAILROOM_RESERVE 4 -static odp_pool_t packet_pool; +static odp_pool_t packet_pool, packet_pool_no_uarea, packet_pool_double_uarea; static uint32_t packet_len; static uint32_t segmented_packet_len; @@ -65,6 +65,24 @@ int packet_suite_init(void) if (packet_pool == ODP_POOL_INVALID) return -1; + params.pkt.uarea_size = 0; + packet_pool_no_uarea = odp_pool_create("packet_pool_no_uarea", + &params); + if (packet_pool_no_uarea == ODP_POOL_INVALID) { + odp_pool_destroy(packet_pool); + return -1; + } + + params.pkt.uarea_size = 2 * sizeof(struct udata_struct); + packet_pool_double_uarea = odp_pool_create("packet_pool_double_uarea", + &params); + + if (packet_pool_double_uarea == ODP_POOL_INVALID) { + odp_pool_destroy(packet_pool_no_uarea); + odp_pool_destroy(packet_pool); + return -1; + } + test_packet = odp_packet_alloc(packet_pool, packet_len); for (i = 0; i < packet_len; i++) { @@ -113,8 +131,12 @@ int packet_suite_term(void) { odp_packet_free(test_packet); odp_packet_free(segmented_test_packet); - if (odp_pool_destroy(packet_pool) != 0) + + if (odp_pool_destroy(packet_pool_double_uarea) != 0 || + odp_pool_destroy(packet_pool_no_uarea) != 0 || + odp_pool_destroy(packet_pool) != 0) return -1; + return 0; } @@ -863,32 +885,41 @@ free_packet: odp_packet_free(pkt); } -#define COMPARE_INFLAG(p1, p2, flag) \ +#define COMPARE_HAS_INFLAG(p1, p2, flag) \ CU_ASSERT(odp_packet_has_##flag(p1) == odp_packet_has_##flag(p2)) +#define COMPARE_INFLAG(p1, p2, flag) \ + CU_ASSERT(odp_packet_##flag(p1) == odp_packet_##flag(p2)) + static void _packet_compare_inflags(odp_packet_t pkt1, odp_packet_t pkt2) { - COMPARE_INFLAG(pkt1, pkt2, l2); - COMPARE_INFLAG(pkt1, pkt2, l3); - COMPARE_INFLAG(pkt1, pkt2, l4); - COMPARE_INFLAG(pkt1, pkt2, eth); - COMPARE_INFLAG(pkt1, pkt2, eth_bcast); - COMPARE_INFLAG(pkt1, pkt2, eth_mcast); - COMPARE_INFLAG(pkt1, pkt2, jumbo); - COMPARE_INFLAG(pkt1, pkt2, vlan); - COMPARE_INFLAG(pkt1, pkt2, vlan_qinq); - COMPARE_INFLAG(pkt1, pkt2, arp); - COMPARE_INFLAG(pkt1, pkt2, ipv4); - COMPARE_INFLAG(pkt1, pkt2, ipv6); - COMPARE_INFLAG(pkt1, pkt2, ip_bcast); - COMPARE_INFLAG(pkt1, pkt2, ip_mcast); - COMPARE_INFLAG(pkt1, pkt2, ipfrag); - COMPARE_INFLAG(pkt1, pkt2, ipopt); - COMPARE_INFLAG(pkt1, pkt2, ipsec); - COMPARE_INFLAG(pkt1, pkt2, udp); - COMPARE_INFLAG(pkt1, pkt2, tcp); - COMPARE_INFLAG(pkt1, pkt2, sctp); - COMPARE_INFLAG(pkt1, pkt2, icmp); + COMPARE_HAS_INFLAG(pkt1, pkt2, l2); + COMPARE_HAS_INFLAG(pkt1, pkt2, l3); + COMPARE_HAS_INFLAG(pkt1, pkt2, l4); + COMPARE_HAS_INFLAG(pkt1, pkt2, eth); + COMPARE_HAS_INFLAG(pkt1, pkt2, eth_bcast); + COMPARE_HAS_INFLAG(pkt1, pkt2, eth_mcast); + COMPARE_HAS_INFLAG(pkt1, pkt2, jumbo); + COMPARE_HAS_INFLAG(pkt1, pkt2, vlan); + COMPARE_HAS_INFLAG(pkt1, pkt2, vlan_qinq); + COMPARE_HAS_INFLAG(pkt1, pkt2, arp); + COMPARE_HAS_INFLAG(pkt1, pkt2, ipv4); + COMPARE_HAS_INFLAG(pkt1, pkt2, ipv6); + COMPARE_HAS_INFLAG(pkt1, pkt2, ip_bcast); + COMPARE_HAS_INFLAG(pkt1, pkt2, ip_mcast); + COMPARE_HAS_INFLAG(pkt1, pkt2, ipfrag); + COMPARE_HAS_INFLAG(pkt1, pkt2, ipopt); + COMPARE_HAS_INFLAG(pkt1, pkt2, ipsec); + COMPARE_HAS_INFLAG(pkt1, pkt2, udp); + COMPARE_HAS_INFLAG(pkt1, pkt2, tcp); + COMPARE_HAS_INFLAG(pkt1, pkt2, sctp); + COMPARE_HAS_INFLAG(pkt1, pkt2, icmp); + COMPARE_HAS_INFLAG(pkt1, pkt2, flow_hash); + COMPARE_HAS_INFLAG(pkt1, pkt2, ts); + + COMPARE_INFLAG(pkt1, pkt2, color); + COMPARE_INFLAG(pkt1, pkt2, drop_eligible); + COMPARE_INFLAG(pkt1, pkt2, shaper_len_adjust); } static void _packet_compare_data(odp_packet_t pkt1, odp_packet_t pkt2) @@ -913,6 +944,20 @@ static void _packet_compare_data(odp_packet_t pkt1, odp_packet_t pkt2) } } +static void _packet_compare_udata(odp_packet_t pkt1, odp_packet_t pkt2) +{ + uint32_t usize1 = odp_packet_user_area_size(pkt1); + uint32_t usize2 = odp_packet_user_area_size(pkt2); + + void *uaddr1 = odp_packet_user_area(pkt1); + void *uaddr2 = odp_packet_user_area(pkt2); + + uint32_t cmplen = usize1 <= usize2 ? usize1 : usize2; + + if (cmplen) + CU_ASSERT(!memcmp(uaddr1, uaddr2, cmplen)); +} + static void _packet_compare_offset(odp_packet_t pkt1, uint32_t off1, odp_packet_t pkt2, uint32_t off2, uint32_t len) @@ -948,6 +993,11 @@ void packet_test_copy(void) uint32_t i, plen, seg_len, src_offset, dst_offset; void *pkt_data; + pkt = odp_packet_copy(test_packet, packet_pool_no_uarea); + CU_ASSERT(pkt == ODP_PACKET_INVALID); + if (pkt != ODP_PACKET_INVALID) + odp_packet_free(pkt); + pkt = odp_packet_copy(test_packet, odp_packet_pool(test_packet)); CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); _packet_compare_data(pkt, test_packet); @@ -962,6 +1012,30 @@ void packet_test_copy(void) _packet_compare_inflags(pkt, pkt_copy); _packet_compare_data(pkt, pkt_copy); + CU_ASSERT(odp_packet_user_area_size(pkt) == + odp_packet_user_area_size(test_packet)); + _packet_compare_udata(pkt, pkt_copy); + odp_packet_free(pkt_copy); + odp_packet_free(pkt); + + pkt = odp_packet_copy(test_packet, packet_pool_double_uarea); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + _packet_compare_data(pkt, test_packet); + pool = odp_packet_pool(pkt); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + pkt_copy = odp_packet_copy(pkt, pool); + CU_ASSERT_FATAL(pkt_copy != ODP_PACKET_INVALID); + + CU_ASSERT(pkt != pkt_copy); + CU_ASSERT(odp_packet_data(pkt) != odp_packet_data(pkt_copy)); + CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(pkt_copy)); + + _packet_compare_inflags(pkt, pkt_copy); + _packet_compare_data(pkt, pkt_copy); + CU_ASSERT(odp_packet_user_area_size(pkt) == + 2 * odp_packet_user_area_size(test_packet)); + _packet_compare_udata(pkt, pkt_copy); + _packet_compare_udata(pkt, test_packet); odp_packet_free(pkt_copy); /* Now test copy_part */ commit f9baafc4a5644973410ef6c5a1d233671bec1d17 Author: Bill Fischofer <bill.fischofer(a)linaro.org> Date: Thu Jun 9 07:12:40 2016 -0500 linux-generic: packet: copy user area as part of odp_packet_copy() Resolve Bug https://bugs.linaro.org/show_bug.cgi?id=2310 by copying the user area as part of odp_packet_copy(). The copy fails if the user area size of the destination pool is not large enough to hold the source packet user area. Reported-by: Zoltan Kiss <zoltan.kiss(a)linaro.org> Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org> Reviewed-by: Zoltan Kiss <zoltan.kiss(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/platform/linux-generic/include/odp_packet_internal.h b/platform/linux-generic/include/odp_packet_internal.h index eedb416..4c4e36c 100644 --- a/platform/linux-generic/include/odp_packet_internal.h +++ b/platform/linux-generic/include/odp_packet_internal.h @@ -199,6 +199,9 @@ static inline void copy_packet_cls_metadata(odp_packet_hdr_t *src_hdr, { dst_hdr->p = src_hdr->p; dst_hdr->dst_queue = src_hdr->dst_queue; + dst_hdr->flow_hash = src_hdr->flow_hash; + dst_hdr->timestamp = src_hdr->timestamp; + dst_hdr->op_result = src_hdr->op_result; } static inline void *packet_map(odp_packet_hdr_t *pkt_hdr, @@ -301,7 +304,7 @@ static inline int packet_parse_not_complete(odp_packet_hdr_t *pkt_hdr) } /* Forward declarations */ -void _odp_packet_copy_md_to_packet(odp_packet_t srcpkt, odp_packet_t dstpkt); +int _odp_packet_copy_md_to_packet(odp_packet_t srcpkt, odp_packet_t dstpkt); odp_packet_t packet_alloc(odp_pool_t pool_hdl, uint32_t len, int parse); diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c index c319833..9f81073 100644 --- a/platform/linux-generic/odp_packet.c +++ b/platform/linux-generic/odp_packet.c @@ -756,22 +756,11 @@ odp_packet_t odp_packet_copy(odp_packet_t pkt, odp_pool_t pool) { odp_packet_hdr_t *srchdr = odp_packet_hdr(pkt); uint32_t pktlen = srchdr->frame_len; - uint32_t meta_offset = ODP_FIELD_SIZEOF(odp_packet_hdr_t, buf_hdr); odp_packet_t newpkt = odp_packet_alloc(pool, pktlen); if (newpkt != ODP_PACKET_INVALID) { - odp_packet_hdr_t *newhdr = odp_packet_hdr(newpkt); - uint8_t *newstart, *srcstart; - - /* Must copy metadata first, followed by packet data */ - newstart = (uint8_t *)newhdr + meta_offset; - srcstart = (uint8_t *)srchdr + meta_offset; - - memcpy(newstart, srcstart, - sizeof(odp_packet_hdr_t) - meta_offset); - - if (odp_packet_copy_from_pkt(newpkt, 0, pkt, 0, - pktlen) != 0) { + if (_odp_packet_copy_md_to_packet(pkt, newpkt) || + odp_packet_copy_from_pkt(newpkt, 0, pkt, 0, pktlen)) { odp_packet_free(newpkt); newpkt = ODP_PACKET_INVALID; } @@ -966,7 +955,7 @@ int odp_packet_is_valid(odp_packet_t pkt) * */ -void _odp_packet_copy_md_to_packet(odp_packet_t srcpkt, odp_packet_t dstpkt) +int _odp_packet_copy_md_to_packet(odp_packet_t srcpkt, odp_packet_t dstpkt) { odp_packet_hdr_t *srchdr = odp_packet_hdr(srcpkt); odp_packet_hdr_t *dsthdr = odp_packet_hdr(dstpkt); @@ -987,6 +976,12 @@ void _odp_packet_copy_md_to_packet(odp_packet_t srcpkt, odp_packet_t dstpkt) odp_atomic_load_u32( &srchdr->buf_hdr.ref_count)); copy_packet_parser_metadata(srchdr, dsthdr); + + /* Metadata copied, but return indication of whether the packet + * user area was truncated in the process. Note this can only + * happen when copying between different pools. + */ + return dsthdr->buf_hdr.uarea_size < srchdr->buf_hdr.uarea_size; } /** ----------------------------------------------------------------------- Summary of changes: .../linux-generic/include/odp_packet_internal.h | 5 +- platform/linux-generic/odp_packet.c | 23 ++-- test/validation/packet/packet.c | 122 +++++++++++++++++---- 3 files changed, 111 insertions(+), 39 deletions(-) hooks/post-receive --

9 years, 7 months

[COMMIT] branch api-next updated. v1.10.1.0-32-g449cd8f

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, api-next has been updated via 449cd8f2c3a694b219fcbb98d7d9948bce583ca1 (commit) from 093fb17ce654532dc1e6c379aa13a3dbab9407d6 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 449cd8f2c3a694b219fcbb98d7d9948bce583ca1 Author: Balasubramanian Manoharan <bala.manoharan(a)linaro.org> Date: Tue Jun 28 17:35:54 2016 +0530 api: traffic_mngr: Add pktio interface to odp_tm_egress_t struct Replaces pktio interface as input to TM system instead of odp_pktout_queue_t.This creates an 1 to 1 mapping between a TM system and pktio interface. Signed-off-by: Balasubramanian Manoharan <bala.manoharan(a)linaro.org> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/include/odp/api/spec/traffic_mngr.h b/include/odp/api/spec/traffic_mngr.h index 83b89e7..c9e6f8f 100644 --- a/include/odp/api/spec/traffic_mngr.h +++ b/include/odp/api/spec/traffic_mngr.h @@ -270,6 +270,12 @@ typedef struct { * have their fan_in only from tm_queues. */ uint8_t max_levels; + /** egress_fcn_supported indicates whether the tm system supports + * egress function. It is an optional feature used to receive the + * packet from the tm system and its performance might be limited. + */ + odp_bool_t egress_fcn_supported; + /** tm_queue_shaper_supported indicates that the tm_queues support * proper TM shaping. Note that TM Shaping is NOT the same thing as * Ingress Metering/Policing as specified by RFC 2697 (A Single Rate @@ -467,7 +473,7 @@ typedef struct { odp_tm_egress_kind_t egress_kind; /**< Union discriminator */ union { - odp_pktout_queue_t pktout; + odp_pktio_t pktio; odp_tm_egress_fcn_t egress_fcn; }; } odp_tm_egress_t; diff --git a/platform/linux-generic/include/odp_traffic_mngr_internal.h b/platform/linux-generic/include/odp_traffic_mngr_internal.h index 3586889..3e13a0a 100644 --- a/platform/linux-generic/include/odp_traffic_mngr_internal.h +++ b/platform/linux-generic/include/odp_traffic_mngr_internal.h @@ -379,7 +379,7 @@ typedef struct { tm_queue_info_t priority_info[ODP_TM_MAX_PRIORITIES]; tm_random_data_t tm_random_data; - + odp_pktout_queue_t pktout; uint64_t current_time; uint8_t tm_idx; uint8_t first_enq; diff --git a/platform/linux-generic/odp_traffic_mngr.c b/platform/linux-generic/odp_traffic_mngr.c index 1fa2d27..54c3517 100644 --- a/platform/linux-generic/odp_traffic_mngr.c +++ b/platform/linux-generic/odp_traffic_mngr.c @@ -2106,7 +2106,7 @@ static void tm_send_pkt(tm_system_t *tm_system, uint32_t max_sends) tm_system->egress_pkt_desc = EMPTY_PKT_DESC; if (tm_system->egress.egress_kind == ODP_TM_EGRESS_PKT_IO) - odp_pktout_send(tm_system->egress.pktout, &odp_pkt, 1); + odp_pktout_send(tm_system->pktout, &odp_pkt, 1); else if (tm_system->egress.egress_kind == ODP_TM_EGRESS_FN) tm_system->egress.egress_fcn(odp_pkt); else @@ -2424,6 +2424,7 @@ int odp_tm_capabilities(odp_tm_capabilities_t capabilities[] ODP_UNUSED, cap_ptr->max_tm_queues = ODP_TM_MAX_TM_QUEUES; cap_ptr->max_levels = ODP_TM_MAX_LEVELS; cap_ptr->tm_queue_shaper_supported = true; + cap_ptr->egress_fcn_supported = true; cap_ptr->tm_queue_wred_supported = true; cap_ptr->tm_queue_dual_slope_supported = true; cap_ptr->vlan_marking_supported = true; @@ -2605,6 +2606,7 @@ odp_tm_t odp_tm_create(const char *name, tm_system_t *tm_system; odp_bool_t create_fail; odp_tm_t odp_tm; + odp_pktout_queue_t pktout; uint32_t malloc_len, max_num_queues, max_queued_pkts, max_timers; uint32_t max_tm_queues, max_sorted_lists; int rc; @@ -2625,6 +2627,10 @@ odp_tm_t odp_tm_create(const char *name, return ODP_TM_INVALID; } + if (odp_pktout_queue(egress->pktio, &pktout, 1) != 1) + return ODP_TM_INVALID; + + tm_system->pktout = pktout; tm_system->name_tbl_id = name_tbl_id; max_tm_queues = requirements->max_tm_queues; memcpy(&tm_system->egress, egress, sizeof(odp_tm_egress_t)); diff --git a/test/validation/traffic_mngr/traffic_mngr.c b/test/validation/traffic_mngr/traffic_mngr.c index 0645370..2fcf2fa 100644 --- a/test/validation/traffic_mngr/traffic_mngr.c +++ b/test/validation/traffic_mngr/traffic_mngr.c @@ -323,7 +323,7 @@ static odp_pktio_t pktios[MAX_NUM_IFACES]; static odp_pktin_queue_t pktins[MAX_NUM_IFACES]; static odp_pktout_queue_t pktouts[MAX_NUM_IFACES]; static odp_pktin_queue_t rcv_pktin; -static odp_pktout_queue_t xmt_pktout; +static odp_pktio_t xmt_pktio; static odph_ethaddr_t src_mac; static odph_ethaddr_t dst_mac; @@ -543,7 +543,7 @@ static int open_pktios(void) } if (2 <= num_ifaces) { - xmt_pktout = pktouts[0]; + xmt_pktio = pktios[0]; rcv_pktin = pktins[1]; ret = odp_pktio_start(pktios[1]); if (ret != 0) { @@ -551,7 +551,7 @@ static int open_pktios(void) return -1; } } else { - xmt_pktout = pktouts[0]; + xmt_pktio = pktios[0]; rcv_pktin = pktins[0]; } @@ -1627,7 +1627,7 @@ static int create_tm_system(void) } egress.egress_kind = ODP_TM_EGRESS_PKT_IO; - egress.pktout = xmt_pktout; + egress.pktio = xmt_pktio; snprintf(tm_name, sizeof(tm_name), "TM_system_%u", num_odp_tm_systems); odp_tm = odp_tm_create(tm_name, &requirements, &egress); ----------------------------------------------------------------------- Summary of changes: include/odp/api/spec/traffic_mngr.h | 8 +++++++- platform/linux-generic/include/odp_traffic_mngr_internal.h | 2 +- platform/linux-generic/odp_traffic_mngr.c | 8 +++++++- test/validation/traffic_mngr/traffic_mngr.c | 8 ++++---- 4 files changed, 19 insertions(+), 7 deletions(-) hooks/post-receive --

9 years, 7 months

[COMMIT] branch master updated. v1.10.1.0-32-g1b1da0f

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, master has been updated via 1b1da0fe917cb916232fd9aad615b68941b8f490 (commit) from e9545afb7d521b7be5b52f7ff599824fdde8113e (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit 1b1da0fe917cb916232fd9aad615b68941b8f490 Author: Rizwan Ansari <rizwan.ansari(a)linaro.org> Date: Tue May 17 21:42:29 2016 +0530 linux-generic: ticketlock: remove odp_sync_stores for octeon Removes odp_sync_stores() call for OCTEON, Octeon build will fail, As this api has been already replaced by odp_mb_full(). Signed-off-by: Rizwan Ansari <rizwan.ansari(a)linaro.org> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-by: Balasubramanian Manoharan <bala.manoharan(a)linaro.org> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/platform/linux-generic/odp_ticketlock.c b/platform/linux-generic/odp_ticketlock.c index 7b4246f..353af9a 100644 --- a/platform/linux-generic/odp_ticketlock.c +++ b/platform/linux-generic/odp_ticketlock.c @@ -69,9 +69,6 @@ void odp_ticketlock_unlock(odp_ticketlock_t *ticketlock) odp_atomic_store_rel_u32(&ticketlock->cur_ticket, cur + 1); -#if defined __OCTEON__ - odp_sync_stores(); /* SYNCW to flush write buffer */ -#endif } int odp_ticketlock_is_locked(odp_ticketlock_t *ticketlock) ----------------------------------------------------------------------- Summary of changes: platform/linux-generic/odp_ticketlock.c | 3 --- 1 file changed, 3 deletions(-) hooks/post-receive --

9 years, 7 months

[COMMIT] branch master updated. v1.10.1.0-31-ge9545af

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, master has been updated via e9545afb7d521b7be5b52f7ff599824fdde8113e (commit) from e9d434fd193e501ef9ca69f530ce4e5f9448594d (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit e9545afb7d521b7be5b52f7ff599824fdde8113e Author: Maxim Uvarov <maxim.uvarov(a)linaro.org> Date: Thu Jun 30 10:39:53 2016 +0300 Revert "validation: queue: use malloc to avoid limits on max_queues" This reverts commit e9d434fd193e501ef9ca69f530ce4e5f9448594d. Some disagreement in ml about this path. Revert on Perti's request. Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/test/validation/queue/queue.c b/test/validation/queue/queue.c index 2c8658e..96941f4 100644 --- a/test/validation/queue/queue.c +++ b/test/validation/queue/queue.c @@ -55,7 +55,7 @@ void queue_test_capa(void) odp_queue_capability_t capa; odp_queue_param_t qparams; char name[ODP_QUEUE_NAME_LEN]; - odp_queue_t *queue; + odp_queue_t queue[MAX_QUEUES]; uint32_t num_queues, i; memset(&capa, 0, sizeof(odp_queue_capability_t)); @@ -71,15 +71,10 @@ void queue_test_capa(void) name[ODP_QUEUE_NAME_LEN - 1] = 0; - num_queues = capa.max_queues; - queue = malloc(num_queues * sizeof(odp_queue_t)); - if (queue == NULL) { - printf("Unable to alloc %d queues, trying with %d\n", - num_queues, MAX_QUEUES); + if (capa.max_queues > MAX_QUEUES) num_queues = MAX_QUEUES; - queue = malloc(num_queues * sizeof(odp_queue_t)); - CU_ASSERT_FATAL(queue != NULL); - } + else + num_queues = capa.max_queues; odp_queue_param_init(&qparams); @@ -98,8 +93,6 @@ void queue_test_capa(void) for (i = 0; i < num_queues; i++) CU_ASSERT(odp_queue_destroy(queue[i]) == 0); - - free(queue); } void queue_test_mode(void) ----------------------------------------------------------------------- Summary of changes: test/validation/queue/queue.c | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-) hooks/post-receive --

9 years, 7 months

[COMMIT] branch master updated. v1.10.1.0-30-ge9d434f

by git＠git-us.linaro.org

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "". The branch, master has been updated via e9d434fd193e501ef9ca69f530ce4e5f9448594d (commit) via 50078445f1a944309fb88946582a2015fd098f6b (commit) from 8e6e5e999ce3d9edb704e18bedf6bc0ebc6ecf79 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- commit e9d434fd193e501ef9ca69f530ce4e5f9448594d Author: Bill Fischofer <bill.fischofer(a)linaro.org> Date: Wed Jun 29 06:59:43 2016 -0500 validation: queue: use malloc to avoid limits on max_queues odp_queue_capability() returns max_queues which may be more than 64K. Use malloc to allocate an array of queue handles to test the ability to create max_queues to avoid limiting the test to 64K queues. If this malloc fails then attempt a reduced test with 64K queues. Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/test/validation/queue/queue.c b/test/validation/queue/queue.c index 96941f4..2c8658e 100644 --- a/test/validation/queue/queue.c +++ b/test/validation/queue/queue.c @@ -55,7 +55,7 @@ void queue_test_capa(void) odp_queue_capability_t capa; odp_queue_param_t qparams; char name[ODP_QUEUE_NAME_LEN]; - odp_queue_t queue[MAX_QUEUES]; + odp_queue_t *queue; uint32_t num_queues, i; memset(&capa, 0, sizeof(odp_queue_capability_t)); @@ -71,10 +71,15 @@ void queue_test_capa(void) name[ODP_QUEUE_NAME_LEN - 1] = 0; - if (capa.max_queues > MAX_QUEUES) + num_queues = capa.max_queues; + queue = malloc(num_queues * sizeof(odp_queue_t)); + if (queue == NULL) { + printf("Unable to alloc %d queues, trying with %d\n", + num_queues, MAX_QUEUES); num_queues = MAX_QUEUES; - else - num_queues = capa.max_queues; + queue = malloc(num_queues * sizeof(odp_queue_t)); + CU_ASSERT_FATAL(queue != NULL); + } odp_queue_param_init(&qparams); @@ -93,6 +98,8 @@ void queue_test_capa(void) for (i = 0; i < num_queues; i++) CU_ASSERT(odp_queue_destroy(queue[i]) == 0); + + free(queue); } void queue_test_mode(void) commit 50078445f1a944309fb88946582a2015fd098f6b Author: Bill Fischofer <bill.fischofer(a)linaro.org> Date: Wed Jun 29 06:59:41 2016 -0500 validation: queue: avoid out of bounds references Resolve Bug https://bugs.linaro.org/show_bug.cgi?id=2377 by correcting loop bounds for error case. Signed-off-by: Bill Fischofer <bill.fischofer(a)linaro.org> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> Signed-off-by: Maxim Uvarov <maxim.uvarov(a)linaro.org> diff --git a/test/validation/queue/queue.c b/test/validation/queue/queue.c index be9c0dc..96941f4 100644 --- a/test/validation/queue/queue.c +++ b/test/validation/queue/queue.c @@ -84,7 +84,7 @@ void queue_test_capa(void) if (queue[i] == ODP_QUEUE_INVALID) { CU_FAIL("Queue create failed"); - num_queues = i - 1; + num_queues = i; break; } ----------------------------------------------------------------------- Summary of changes: test/validation/queue/queue.c | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) hooks/post-receive --

9 years, 7 months

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

git-lng-odp