git-lng-odp

git-lng-odp@lists.linaro.org

1 participants
1207 discussions

Legitimate Cryp-to/Bit-coin Reco-very Firm in 2026 ; Visit ZEUS CRYP-TO RECOVE-RY SERVICES

by johnlucas635uw＠gmail.com

I am incredibly grateful to ZEUS CRYP-TO RECOVE-RY SERVICES for their exceptional help. After losing $209,000.56 in Bitcoin last month, I felt hopeless. Their team was professional, transparent, and utilized advanced bloc=kchain forensics to track and successfully reco-ver my assets. They kept me updated throughout the entire process, providing peace of mind during a stressful time. I highly recommend their expertise to anyone facing similar cry-pto losses. Below is their contact information.. Website: zeusrecoveryservices.com Mail-Box: support @ zeusrecoveryservices .c om WhatsApp: +44-7841 9000-82

1 day, 19 hours

Reliable and Professional Crypto Recovery Company – Betafort Recovery

by godfreyleonard474＠gmail.com

I am immensely grateful to Betafort Recovery for their exceptional service and I would highly recommend reaching out to Betafort recovery via Google to anyone who wants to recover scammed bitcoin, stolen cryptocurrency, funds lost to binary options forex, funds lost to fake online investment and any other form of online scam for consultation and assistance. Their professionalism, expertise, and commitment to customer satisfaction truly sets them apart. NO UPFRONT FEES REQUIRED. Email: info(a)betafort.online WhatsApp OR SIGNAL +17126004729 Web portal: https://betafort.online/

3 weeks, 6 days

Hire SAFEGUARD RECOVERY, a Bitcoin recovery specialist, to retrieve stolen or lost coins.

by sophia fourest

I invested $320,000 in Tether (USDT) on a fraudulent website after falling for a romantic scam. I felt completely helpless and in need of assistance after realizing I had been duped. I started looking for a hacker online and found SAFEGUARD RECOVERY. I had optimism because of his professionalism and knowledge. I'm happy to report that SAFEGUARD RECOVERY successfully recovered my stolen money after working relentlessly to do so! I am immensely appreciative of their help and heartily urge anyone in a comparable circumstance to use their services. I'm grateful Email: safeguardbitcoin(a)consultant.com WhatsApp: +44 7426 168300 Website: https://safeguardbitcoin.wixsite.com/safeguard-bitcoin--1

1 month

Hire SAFEGUARD RECOVERY, a Bitcoin recovery specialist, to retrieve stolen or lost coins.

by sophia fourest

1 month

[COMMIT] branch master updated. v1.21.0.0-428-g519555018

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 519555018eb8beeaf8bbd704d0d24b60eddf4d20 (commit) via 1d09a45ec333bf237edff731e78fa1c68dc49092 (commit) via 831de57416098df6946d2eb97132fe236d0c7e42 (commit) via 181773542664bddff206fedb62ba94c38118457d (commit) from 324a2a2c7c1a9d35323483b679eedfebcb310827 (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 519555018eb8beeaf8bbd704d0d24b60eddf4d20 Author: Matias Elo <matias.elo(a)nokia.com> Date: Tue Feb 25 16:16:29 2020 +0200 example: don't enable input hashing with only one input queue Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/example/l3fwd/odp_l3fwd.c b/example/l3fwd/odp_l3fwd.c index 79613d672..0f8b8525c 100644 --- a/example/l3fwd/odp_l3fwd.c +++ b/example/l3fwd/odp_l3fwd.c @@ -803,17 +803,18 @@ static void setup_worker_qconf(app_args_t *args) in_queue_param.op_mode = ODP_PKTIO_OP_MT_UNSAFE; out_queue_param.op_mode = ODP_PKTIO_OP_MT_UNSAFE; - in_queue_param.hash_enable = 1; - in_queue_param.hash_proto.proto.ipv4 = 1; - in_queue_param.hash_proto.proto.ipv4_tcp = 1; - in_queue_param.hash_proto.proto.ipv4_udp = 1; - in_queue_param.num_queues = port->rxq_idx; if (port->rxq_idx > port->nb_rxq) { in_queue_param.num_queues = port->nb_rxq; in_queue_param.op_mode = ODP_PKTIO_OP_MT; } + in_queue_param.hash_enable = (in_queue_param.num_queues > 1) ? + 1 : 0; + in_queue_param.hash_proto.proto.ipv4 = 1; + in_queue_param.hash_proto.proto.ipv4_tcp = 1; + in_queue_param.hash_proto.proto.ipv4_udp = 1; + if (odp_pktin_queue_config(port->pktio, &in_queue_param)) ODPH_ABORT("Fail to config input queue for port %s\n", name); diff --git a/example/switch/odp_switch.c b/example/switch/odp_switch.c index ccb975f6c..bcc87680e 100644 --- a/example/switch/odp_switch.c +++ b/example/switch/odp_switch.c @@ -304,7 +304,7 @@ static int create_pktio(const char *dev, int idx, int num_rx, int num_tx, mode_tx = ODP_PKTIO_OP_MT; } - pktin_param.hash_enable = 1; + pktin_param.hash_enable = (num_rx > 1) ? 1 : 0; pktin_param.hash_proto.proto.ipv4_tcp = 1; pktin_param.hash_proto.proto.ipv4_udp = 1; pktin_param.num_queues = num_rx; diff --git a/test/performance/odp_l2fwd.c b/test/performance/odp_l2fwd.c index fc1f04bd1..4bacc5309 100644 --- a/test/performance/odp_l2fwd.c +++ b/test/performance/odp_l2fwd.c @@ -759,7 +759,7 @@ static int create_pktio(const char *dev, int idx, int num_rx, int num_tx, mode_tx = ODP_PKTIO_OP_MT; } - pktin_param.hash_enable = 1; + pktin_param.hash_enable = (num_rx > 1) ? 1 : 0; pktin_param.hash_proto.proto.ipv4_udp = 1; pktin_param.num_queues = num_rx; pktin_param.op_mode = mode_rx; diff --git a/test/performance/odp_pktio_ordered.c b/test/performance/odp_pktio_ordered.c index 4ac6060b7..46e6c1861 100644 --- a/test/performance/odp_pktio_ordered.c +++ b/test/performance/odp_pktio_ordered.c @@ -642,7 +642,7 @@ static int create_pktio(const char *dev, int idx, int num_rx, int num_tx, mode_tx = ODP_PKTIO_OP_MT; } - pktin_param.hash_enable = 1; + pktin_param.hash_enable = (num_rx > 1) ? 1 : 0; pktin_param.hash_proto.proto.ipv4_udp = 1; pktin_param.num_queues = num_rx; pktin_param.op_mode = mode_rx; commit 1d09a45ec333bf237edff731e78fa1c68dc49092 Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Thu Feb 20 16:49:04 2020 +0200 test: packet_gen: test application during make check Packet_gen sends 500 packets through both loopback interfaces. Test lasts 5 sec. In total 1000 packets are sent and the same amount (or minus the last sent burst) should be received. Test passes when at least 800 packets are received. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-and-tested-by: Matias Elo <matias.elo(a)nokia.com> diff --git a/test/performance/Makefile.am b/test/performance/Makefile.am index 36bc7cbd6..4b32573cd 100644 --- a/test/performance/Makefile.am +++ b/test/performance/Makefile.am @@ -20,6 +20,7 @@ COMPILE_ONLY = odp_l2fwd \ odp_scheduling TESTSCRIPTS = odp_l2fwd_run.sh \ + odp_packet_gen_run.sh \ odp_sched_latency_run.sh \ odp_sched_pktio_run.sh \ odp_scheduling_run.sh diff --git a/test/performance/odp_packet_gen_run.sh b/test/performance/odp_packet_gen_run.sh new file mode 100755 index 000000000..579509a07 --- /dev/null +++ b/test/performance/odp_packet_gen_run.sh @@ -0,0 +1,70 @@ +#!/bin/sh +# +# Copyright (c) 2020, Nokia +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +# + +# directory where test binaries have been built +TEST_DIR="${TEST_DIR:-$PWD}" + +# directory where test sources are, including scripts +TEST_SRC_DIR=$(dirname $0) + +PATH=$TEST_DIR:$PATH + +# exit codes expected by automake for skipped tests +TEST_SKIPPED=77 + +VALIDATION_TESTDIR=platform/$ODP_PLATFORM/test/validation +PLATFORM_VALIDATION=${TEST_SRC_DIR}/../../$VALIDATION_TESTDIR + +# Use installed pktio env or for make check take it from platform directory +if [ -f "./pktio_env" ]; then + . ./pktio_env +elif [ "$ODP_PLATFORM" = "" ]; then + echo "$0: error: ODP_PLATFORM must be defined" + # not skipped as this should never happen via "make check" + exit 1 +elif [ -f ${PLATFORM_VALIDATION}/api/pktio/pktio_env ]; then + . ${PLATFORM_VALIDATION}/api/pktio/pktio_env +else + echo "BUG: unable to find pktio_env!" + echo "pktio_env has to be in current directory or " + echo "in platform/\$ODP_PLATFORM/test." + echo "ODP_PLATFORM=\"$ODP_PLATFORM\"" + exit 1 +fi + +run_packet_gen() +{ + setup_pktio_env clean # install trap to call cleanup_pktio_env + + if [ $? -ne 0 ]; then + echo "setup_pktio_env error $?" + exit $TEST_SKIPPED + fi + + # Runs 500 * 10ms = 5 sec + # Sends 500 packets through both interfaces => total 1000 packets + odp_packet_gen${EXEEXT} -i $IF0,$IF1 -b 1 -g 10000000 -q 500 + + ret=$? + + if [ $ret -eq -1 ]; then + echo "FAIL: test failed" + elif [ $ret -eq -2 ]; then + echo "FAIL: too few packets received" + fi + + cleanup_pktio_env + + exit $ret +} + +case "$1" in + setup) setup_pktio_env ;; + cleanup) cleanup_pktio_env ;; + *) run_packet_gen ;; +esac commit 831de57416098df6946d2eb97132fe236d0c7e42 Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Wed Feb 12 15:28:50 2020 +0200 test: packet_gen: new simple packet generator Added new simple and performance optimized packet generator. It may be used e.g. in pair with l2fwd. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-and-tested-by: Matias Elo <matias.elo(a)nokia.com> diff --git a/test/performance/.gitignore b/test/performance/.gitignore index 41e18facc..a4e78b9af 100644 --- a/test/performance/.gitignore +++ b/test/performance/.gitignore @@ -6,6 +6,7 @@ odp_cpu_bench odp_crypto odp_ipsec odp_l2fwd +odp_packet_gen odp_pktio_ordered odp_pktio_perf odp_pool_perf diff --git a/test/performance/Makefile.am b/test/performance/Makefile.am index 29aee55bd..36bc7cbd6 100644 --- a/test/performance/Makefile.am +++ b/test/performance/Makefile.am @@ -13,6 +13,7 @@ EXECUTABLES = odp_bench_packet \ odp_timer_perf COMPILE_ONLY = odp_l2fwd \ + odp_packet_gen \ odp_pktio_ordered \ odp_sched_latency \ odp_sched_pktio \ @@ -39,6 +40,7 @@ odp_bench_packet_SOURCES = odp_bench_packet.c odp_cpu_bench_SOURCES = odp_cpu_bench.c odp_crypto_SOURCES = odp_crypto.c odp_ipsec_SOURCES = odp_ipsec.c +odp_packet_gen_SOURCES = odp_packet_gen.c odp_pktio_ordered_SOURCES = odp_pktio_ordered.c dummy_crc.h odp_sched_latency_SOURCES = odp_sched_latency.c odp_sched_pktio_SOURCES = odp_sched_pktio.c diff --git a/test/performance/odp_packet_gen.c b/test/performance/odp_packet_gen.c new file mode 100644 index 000000000..4c1a1b49a --- /dev/null +++ b/test/performance/odp_packet_gen.c @@ -0,0 +1,1313 @@ +/* Copyright (c) 2020, Nokia + * All rights reserved. + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +#include <stdio.h> +#include <string.h> +#include <stdint.h> +#include <inttypes.h> +#include <signal.h> +#include <stdlib.h> +#include <getopt.h> + +#include <odp_api.h> +#include <odp/helper/odph_api.h> + +#define MAX_PKTIOS 32 +#define MAX_PKTIO_NAME 255 +#define RX_THREAD 1 +#define TX_THREAD 2 + +/* Minimum number of packets to receive in CI test */ +#define MIN_RX_PACKETS_CI 800 + +typedef struct test_options_t { + uint64_t gap_nsec; + uint64_t quit; + uint32_t num_rx; + uint32_t num_tx; + uint32_t num_cpu; + uint32_t num_pktio; + uint32_t num_pkt; + uint32_t pkt_len; + uint32_t burst_size; + uint32_t bursts; + uint32_t ipv4_src; + uint32_t ipv4_dst; + uint16_t udp_src; + uint16_t udp_dst; + + struct { + uint32_t udp_src; + uint32_t udp_dst; + } c_mode; + + char pktio_name[MAX_PKTIOS][MAX_PKTIO_NAME + 1]; + char ipv4_src_s[24]; + char ipv4_dst_s[24]; + +} test_options_t; + +typedef struct thread_arg_t { + void *global; + int tx_thr; + + /* pktout queue per pktio interface (per thread) */ + odp_pktout_queue_t pktout[MAX_PKTIOS]; + +} thread_arg_t; + +typedef struct ODP_ALIGNED_CACHE thread_stat_t { + uint64_t time_nsec; + uint64_t rx_timeouts; + uint64_t rx_packets; + uint64_t rx_bytes; + + uint64_t tx_timeouts; + uint64_t tx_packets; + uint64_t tx_drops; + + int thread_type; + +} thread_stat_t; + +typedef struct test_global_t { + test_options_t test_options; + odp_atomic_u32_t exit_test; + odp_barrier_t barrier; + odp_cpumask_t cpumask; + odp_pool_t pool; + uint64_t drained; + odph_thread_t thread_tbl[ODP_THREAD_COUNT_MAX]; + thread_stat_t stat[ODP_THREAD_COUNT_MAX]; + thread_arg_t thread_arg[ODP_THREAD_COUNT_MAX]; + + struct { + odph_ethaddr_t eth_src; + odph_ethaddr_t eth_dst; + odp_pktio_t pktio; + odp_pktout_queue_t pktout[ODP_THREAD_COUNT_MAX]; + int started; + + } pktio[MAX_PKTIOS]; + +} test_global_t; + +static test_global_t *test_global; + +static void print_usage(void) +{ + printf("\n" + "ODP packet generator\n" + "\n" + "Usage: odp_packet_gen [options]\n" + "\n" + " Mandatory:\n" + " -i, --interface <name> Packet IO interfaces. Comma-separated list of\n" + " interface names (no spaces) e.g. eth0,eth1.\n" + " At least one interface is required.\n" + "\n" + " Optional:\n" + " -e, --eth_dst <mac> Destination MAC address. Comma-separated list of\n" + " addresses (no spaces), one address per packet IO\n" + " interface e.g. AA:BB:CC:DD:EE:FF,11:22:33:44:55:66\n" + " Default per interface: 02:00:00:A0:B0:CX, where X = 0,1,...\n" + " -r, --num_rx Number of receive threads. Default: 1\n" + " -t, --num_tx Number of transmit threads. Default: 1\n" + " -n, --num_pkt Number of packets in the pool. Default: 1000\n" + " -l, --len Packet length. Default: 512\n" + " -b, --burst_size Transmit burst size. Default: 8\n" + " -x, --bursts Number of bursts per one transmit round. Default: 1\n" + " -g, --gap Gap between transmit rounds in nsec. Default: 1000000\n" + " Transmit packet rate per interface:\n" + " num_tx * burst_size * bursts * (10^9 / gap)\n" + " -s, --ipv4_src IPv4 source address. Default: 192.168.0.1\n" + " -d, --ipv4_dst IPv4 destination address. Default: 192.168.0.2\n" + " -o, --udp_src UDP source port. Default: 10000\n" + " -p, --udp_dst UDP destination port. Default: 20000\n" + " -c, --c_mode <counts> Counter mode for incrementing UDP port numbers.\n" + " Specify the number of port numbers used starting from\n" + " udp_src/udp_dst. Comma-serarated (no spaces) list of\n" + " count values: <udp_src count>,<udp_dst count>\n" + " Default value: 0,0\n" + " -q, --quit Quit after this many transmit rounds.\n" + " Default: 0 (don't quit)\n" + " -h, --help This help\n" + "\n"); +} + +static int parse_options(int argc, char *argv[], test_global_t *global) +{ + int opt, i, len, str_len, long_index; + unsigned long int count; + uint32_t min_packets, num_tx_pkt; + char *name, *str, *end; + test_options_t *test_options = &global->test_options; + int ret = 0; + uint8_t default_eth_dst[6] = {0x02, 0x00, 0x00, 0xa0, 0xb0, 0xc0}; + + static const struct option longopts[] = { + {"interface", required_argument, NULL, 'i'}, + {"eth_dst", required_argument, NULL, 'e'}, + {"num_rx", required_argument, NULL, 'r'}, + {"num_tx", required_argument, NULL, 't'}, + {"num_pkt", required_argument, NULL, 'n'}, + {"len", required_argument, NULL, 'l'}, + {"burst_size", required_argument, NULL, 'b'}, + {"bursts", required_argument, NULL, 'x'}, + {"gap", required_argument, NULL, 'g'}, + {"ipv4_src", required_argument, NULL, 's'}, + {"ipv4_dst", required_argument, NULL, 'd'}, + {"udp_src", required_argument, NULL, 'o'}, + {"udp_dst", required_argument, NULL, 'p'}, + {"c_mode", required_argument, NULL, 'c'}, + {"quit", required_argument, NULL, 'q'}, + {"help", no_argument, NULL, 'h'}, + {NULL, 0, NULL, 0} + }; + + static const char *shortopts = "+i:e:r:t:n:l:b:x:g:s:d:o:p:c:q:h"; + + test_options->num_pktio = 0; + test_options->num_rx = 1; + test_options->num_tx = 1; + test_options->num_pkt = 1000; + test_options->pkt_len = 512; + test_options->burst_size = 8; + test_options->bursts = 1; + test_options->gap_nsec = 1000000; + strncpy(test_options->ipv4_src_s, "192.168.0.1", + sizeof(test_options->ipv4_src_s)); + strncpy(test_options->ipv4_dst_s, "192.168.0.2", + sizeof(test_options->ipv4_dst_s)); + odph_ipv4_addr_parse(&test_options->ipv4_src, test_options->ipv4_src_s); + odph_ipv4_addr_parse(&test_options->ipv4_dst, test_options->ipv4_dst_s); + test_options->udp_src = 10000; + test_options->udp_dst = 20000; + test_options->c_mode.udp_src = 0; + test_options->c_mode.udp_dst = 0; + test_options->quit = 0; + + for (i = 0; i < MAX_PKTIOS; i++) { + memcpy(global->pktio[i].eth_dst.addr, default_eth_dst, 6); + global->pktio[i].eth_dst.addr[5] += i; + } + + while (1) { + opt = getopt_long(argc, argv, shortopts, longopts, &long_index); + + if (opt == -1) + break; + + switch (opt) { + case 'i': + i = 0; + str = optarg; + str_len = strlen(str); + + while (str_len > 0) { + len = strcspn(str, ","); + str_len -= len + 1; + + if (i == MAX_PKTIOS) { + printf("Error: Too many interfaces\n"); + ret = -1; + break; + } + + if (len > MAX_PKTIO_NAME) { + printf("Error: Too long interface name %s\n", + str); + ret = -1; + break; + } + + name = test_options->pktio_name[i]; + memcpy(name, str, len); + str += len + 1; + i++; + } + + test_options->num_pktio = i; + + break; + case 'e': + i = 0; + str = optarg; + str_len = strlen(str); + + while (str_len > 0) { + odph_ethaddr_t *dst = &global->pktio[i].eth_dst; + + len = strcspn(str, ","); + str_len -= len + 1; + + if (i == MAX_PKTIOS) { + printf("Error: Too many MAC addresses\n"); + ret = -1; + break; + } + + if (odph_eth_addr_parse(dst, str)) { + printf("Error: Bad MAC address: %s\n", + str); + ret = -1; + break; + } + + str += len + 1; + i++; + } + break; + case 'r': + test_options->num_rx = atoi(optarg); + break; + case 't': + test_options->num_tx = atoi(optarg); + break; + case 'n': + test_options->num_pkt = atoi(optarg); + break; + case 'l': + test_options->pkt_len = atoi(optarg); + break; + case 'b': + test_options->burst_size = atoi(optarg); + break; + case 'x': + test_options->bursts = atoi(optarg); + break; + case 'g': + test_options->gap_nsec = atoll(optarg); + break; + case 's': + if (odph_ipv4_addr_parse(&test_options->ipv4_src, + optarg)) { + printf("Error: Bad IPv4 source address: %s\n", + optarg); + ret = -1; + } + strncpy(test_options->ipv4_src_s, optarg, + sizeof(test_options->ipv4_src_s)); + break; + case 'd': + if (odph_ipv4_addr_parse(&test_options->ipv4_dst, + optarg)) { + printf("Error: Bad IPv4 destination address: %s\n", + optarg); + ret = -1; + } + strncpy(test_options->ipv4_dst_s, optarg, + sizeof(test_options->ipv4_dst_s)); + break; + case 'c': + count = strtoul(optarg, &end, 0); + test_options->c_mode.udp_src = count; + + end++; + count = strtoul(end, NULL, 0); + test_options->c_mode.udp_dst = count; + break; + case 'q': + test_options->quit = atoll(optarg); + break; + case 'h': + /* fall through */ + default: + print_usage(); + ret = -1; + break; + } + } + + if (test_options->num_pktio == 0) { + printf("Error: At least one packet IO interface is needed.\n"); + printf(" Use -i <name> to specify interfaces.\n"); + ret = -1; + } + + if (test_options->num_rx < 1 || test_options->num_tx < 1) { + printf("Error: At least one rx and tx thread needed.\n"); + ret = -1; + } + + test_options->num_cpu = test_options->num_rx + test_options->num_tx; + + /* Pool needs to have enough packets for all tx side bursts and + * one rx side burst */ + num_tx_pkt = test_options->burst_size * test_options->bursts; + min_packets = (test_options->num_pktio * test_options->num_tx * + num_tx_pkt) + + (test_options->num_pktio * test_options->num_rx * + test_options->burst_size); + + if (test_options->num_pkt < min_packets) { + printf("Error: Pool needs to have at least %u packets\n", + min_packets); + ret = -1; + } + + if (test_options->gap_nsec) { + double gap_hz = 1000000000.0 / test_options->gap_nsec; + + if (gap_hz > (double)odp_time_local_res()) { + printf("\nWARNING: Burst gap exceeds time counter resolution " + "%" PRIu64 "\n\n", odp_time_local_res()); + } + } + + if (test_options->c_mode.udp_dst && + num_tx_pkt % test_options->c_mode.udp_dst) + printf("\nWARNING: Transmit packet count is not evenly divisible by UDP destination port count.\n\n"); + + if (test_options->c_mode.udp_src && + num_tx_pkt % test_options->c_mode.udp_src) + printf("\nWARNING: Transmit packet count is not evenly divisible by UDP source port count.\n\n"); + + return ret; +} + +static int set_num_cpu(test_global_t *global) +{ + int ret; + test_options_t *test_options = &global->test_options; + int num_cpu = test_options->num_cpu; + + /* One thread used for the main thread */ + if (num_cpu > ODP_THREAD_COUNT_MAX - 1) { + printf("Error: Too many threads. API supports max %i.\n", + ODP_THREAD_COUNT_MAX - 1); + return -1; + } + + ret = odp_cpumask_default_worker(&global->cpumask, num_cpu); + + if (ret != num_cpu) { + int cpu; + + /* Normally we want to use only worker threads */ + if (ret > 1) { + printf("Error: Too many workers. Maximum supported %i.\n", + ret); + return -1; + } + + /* When number of workers is very limited (e.g. ODP project CI), + * we try to use any CPUs available. */ + ret = odp_cpumask_all_available(&global->cpumask); + if (ret < num_cpu) { + printf("Error: Not enough CPUs. Maximum supported %i.\n", + ret); + return -1; + } + + /* Remove extra CPUs from the mask */ + cpu = odp_cpumask_first(&global->cpumask); + while (ret > num_cpu) { + odp_cpumask_clr(&global->cpumask, cpu); + cpu = odp_cpumask_first(&global->cpumask); + ret--; + } + } + + odp_barrier_init(&global->barrier, num_cpu + 1); + + return 0; +} + +static int open_pktios(test_global_t *global) +{ + odp_pool_capability_t pool_capa; + odp_pktio_capability_t pktio_capa; + odp_pool_param_t pool_param; + odp_pool_t pool; + odp_pktio_param_t pktio_param; + odp_pktio_t pktio; + odp_pktio_config_t pktio_config; + odp_pktin_queue_param_t pktin_param; + odp_pktout_queue_param_t pktout_param; + char *name; + uint32_t i, seg_len; + int j; + test_options_t *test_options = &global->test_options; + uint32_t num_rx = test_options->num_rx; + int num_tx = test_options->num_tx; + uint32_t num_pktio = test_options->num_pktio; + uint32_t num_pkt = test_options->num_pkt; + uint32_t pkt_len = test_options->pkt_len; + odp_pktout_queue_t pktout[num_tx]; + + printf("\nODP packet generator\n"); + printf(" quit test after %" PRIu64 " rounds\n", + test_options->quit); + printf(" num rx threads %u\n", num_rx); + printf(" num tx threads %i\n", num_tx); + printf(" num packets %u\n", num_pkt); + printf(" packet length %u bytes\n", pkt_len); + printf(" tx burst size %u\n", test_options->burst_size); + printf(" tx bursts %u\n", test_options->bursts); + printf(" tx burst gap %" PRIu64 " nsec\n", + test_options->gap_nsec); + printf(" clock resolution %" PRIu64 " Hz\n", odp_time_local_res()); + printf(" IPv4 source %s\n", test_options->ipv4_src_s); + printf(" IPv4 destination %s\n", test_options->ipv4_dst_s); + printf(" UDP source %u\n", test_options->udp_src); + printf(" UDP destination %u\n", test_options->udp_dst); + printf(" UDP src count %u\n", test_options->c_mode.udp_src); + printf(" UDP dst count %u\n", test_options->c_mode.udp_dst); + printf(" num pktio %u\n", num_pktio); + + printf(" interfaces names: "); + for (i = 0; i < num_pktio; i++) { + if (i > 0) + printf(" "); + printf("%s\n", test_options->pktio_name[i]); + } + + printf(" destination MACs: "); + for (i = 0; i < num_pktio; i++) { + uint8_t *eth_dst = global->pktio[i].eth_dst.addr; + + if (i > 0) + printf(" "); + printf("%02x:%02x:%02x:%02x:%02x:%02x\n", + eth_dst[0], eth_dst[1], eth_dst[2], + eth_dst[3], eth_dst[4], eth_dst[5]); + } + printf("\n"); + + global->pool = ODP_POOL_INVALID; + + if (odp_pool_capability(&pool_capa)) { + printf("Error: Pool capability failed.\n"); + return -1; + } + + if (pool_capa.pkt.max_num && + num_pkt > pool_capa.pkt.max_num) { + printf("Error: Too many packets. Max %u supported.\n", + pool_capa.pkt.max_num); + return -1; + } + + if (pool_capa.pkt.max_len && + pkt_len > pool_capa.pkt.max_len) { + printf("Error: Too large packets. Max %u supported length.\n", + pool_capa.pkt.max_len); + return -1; + } + + seg_len = ODPH_ETHHDR_LEN + ODPH_IPV4HDR_LEN + ODPH_UDPHDR_LEN; + if (pool_capa.pkt.max_seg_len && + seg_len > pool_capa.pkt.max_seg_len) { + printf("Error: Max segment length is too small %u\n", + pool_capa.pkt.max_seg_len); + return -1; + } + + /* Create pool */ + odp_pool_param_init(&pool_param); + pool_param.type = ODP_POOL_PACKET; + pool_param.pkt.num = num_pkt; + pool_param.pkt.len = pkt_len; + pool_param.pkt.seg_len = seg_len; + + pool = odp_pool_create("packet gen pool", &pool_param); + + if (pool == ODP_POOL_INVALID) { + printf("Error: Pool create failed.\n"); + return -1; + } + + global->pool = pool; + + odp_pktio_param_init(&pktio_param); + pktio_param.in_mode = ODP_PKTIN_MODE_SCHED; + pktio_param.out_mode = ODP_PKTOUT_MODE_DIRECT; + + for (i = 0; i < num_pktio; i++) + global->pktio[i].pktio = ODP_PKTIO_INVALID; + + /* Open and configure interfaces */ + for (i = 0; i < num_pktio; i++) { + name = test_options->pktio_name[i]; + pktio = odp_pktio_open(name, pool, &pktio_param); + + if (pktio == ODP_PKTIO_INVALID) { + printf("Error (%s): Pktio open failed.\n", name); + return -1; + } + + global->pktio[i].pktio = pktio; + + odp_pktio_print(pktio); + + if (odp_pktio_capability(pktio, &pktio_capa)) { + printf("Error (%s): Pktio capability failed.\n", name); + return -1; + } + + if (num_rx > pktio_capa.max_input_queues) { + printf("Error (%s): Too many RX threads. Interface supports max %u input queues.\n", + name, pktio_capa.max_input_queues); + return -1; + } + + if (num_tx > (int)pktio_capa.max_output_queues) { + printf("Error (%s): Too many TX threads. Interface supports max %u output queues.\n", + name, pktio_capa.max_output_queues); + return -1; + } + + if (odp_pktio_mac_addr(pktio, + &global->pktio[i].eth_src.addr, + ODPH_ETHADDR_LEN) != ODPH_ETHADDR_LEN) { + printf("Error (%s): MAC address read failed.\n", name); + return -1; + } + + odp_pktio_config_init(&pktio_config); + pktio_config.parser.layer = ODP_PROTO_LAYER_ALL; + + odp_pktio_config(pktio, &pktio_config); + + odp_pktin_queue_param_init(&pktin_param); + + pktin_param.queue_param.sched.prio = ODP_SCHED_PRIO_DEFAULT; + pktin_param.queue_param.sched.sync = ODP_SCHED_SYNC_PARALLEL; + pktin_param.queue_param.sched.group = ODP_SCHED_GROUP_ALL; + pktin_param.hash_enable = 1; + pktin_param.hash_proto.proto.ipv4_udp = 1; + pktin_param.num_queues = num_rx; + + if (odp_pktin_queue_config(pktio, &pktin_param)) { + printf("Error (%s): Pktin config failed.\n", name); + return -1; + } + + odp_pktout_queue_param_init(&pktout_param); + pktout_param.op_mode = ODP_PKTIO_OP_MT_UNSAFE; + pktout_param.num_queues = num_tx; + + if (odp_pktout_queue_config(pktio, &pktout_param)) { + printf("Error (%s): Pktout config failed.\n", name); + return -1; + } + + if (odp_pktout_queue(pktio, pktout, num_tx) != num_tx) { + printf("Error (%s): Pktout queue request failed.\n", + name); + return -1; + } + + for (j = 0; j < num_tx; j++) + global->pktio[i].pktout[j] = pktout[j]; + } + + return 0; +} + +static int start_pktios(test_global_t *global) +{ + uint32_t i; + test_options_t *test_options = &global->test_options; + uint32_t num_pktio = test_options->num_pktio; + + for (i = 0; i < num_pktio; i++) { + if (odp_pktio_start(global->pktio[i].pktio)) { + printf("Error (%s): Pktio start failed.\n", + test_options->pktio_name[i]); + + return -1; + } + + global->pktio[i].started = 1; + } + + return 0; +} + +static int stop_pktios(test_global_t *global) +{ + uint32_t i; + odp_pktio_t pktio; + int ret = 0; + test_options_t *test_options = &global->test_options; + uint32_t num_pktio = test_options->num_pktio; + + for (i = 0; i < num_pktio; i++) { + pktio = global->pktio[i].pktio; + + if (pktio == ODP_PKTIO_INVALID || global->pktio[i].started == 0) + continue; + + if (odp_pktio_stop(pktio)) { + printf("Error (%s): Pktio stop failed.\n", + test_options->pktio_name[i]); + ret = -1; + } + } + + return ret; +} + +static int close_pktios(test_global_t *global) +{ + uint32_t i; + odp_pktio_t pktio; + test_options_t *test_options = &global->test_options; + uint32_t num_pktio = test_options->num_pktio; + int ret = 0; + + for (i = 0; i < num_pktio; i++) { + pktio = global->pktio[i].pktio; + + if (pktio == ODP_PKTIO_INVALID) + continue; + + if (odp_pktio_close(pktio)) { + printf("Error (%s): Pktio close failed.\n", + test_options->pktio_name[i]); + ret = -1; + } + } + + if (global->pool != ODP_POOL_INVALID && + odp_pool_destroy(global->pool)) { + printf("Error: Pool destroy failed.\n"); + ret = -1; + } + + return ret; +} + +static int rx_thread(void *arg) +{ + int i, thr, num; + uint32_t exit_test; + odp_time_t t1, t2; + thread_arg_t *thread_arg = arg; + test_global_t *global = thread_arg->global; + uint64_t rx_timeouts = 0; + uint64_t rx_packets = 0; + uint64_t rx_bytes = 0; + uint64_t nsec = 0; + int ret = 0; + int clock_started = 0; + int paused = 0; + int max_num = 32; + odp_event_t ev[max_num]; + + thr = odp_thread_id(); + global->stat[thr].thread_type = RX_THREAD; + + /* Start all workers at the same time */ + odp_barrier_wait(&global->barrier); + + while (1) { + num = odp_schedule_multi_no_wait(NULL, ev, max_num); + + exit_test = odp_atomic_load_u32(&global->exit_test); + if (num == 0 && exit_test) { + if (paused == 0) { + odp_schedule_pause(); + paused = 1; + } else { + /* Exit schedule loop after schedule paused and + * no more packets received */ + break; + } + } + + if (num == 0) { + rx_timeouts++; + continue; + } + + if (!clock_started) { + t1 = odp_time_local(); + clock_started = 1; + } + + for (i = 0; i < num; i++) { + odp_packet_t pkt; + + pkt = odp_packet_from_event(ev[i]); + rx_bytes += odp_packet_len(pkt); + } + + odp_event_free_multi(ev, num); + rx_packets += num; + } + + t2 = odp_time_local(); + + if (clock_started) + nsec = odp_time_diff_ns(t2, t1); + + /* Update stats*/ + global->stat[thr].time_nsec = nsec; + global->stat[thr].rx_timeouts = rx_timeouts; + global->stat[thr].rx_packets = rx_packets; + global->stat[thr].rx_bytes = rx_bytes; + + return ret; +} + +static void drain_queues(test_global_t *global) +{ + odp_event_t ev; + uint64_t wait_time = odp_schedule_wait_time(100 * ODP_TIME_MSEC_IN_NS); + + while ((ev = odp_schedule(NULL, wait_time)) != ODP_EVENT_INVALID) { + global->drained++; + odp_event_free(ev); + } +} + +static int init_packets(test_global_t *global, int pktio, + odp_packet_t packet[], uint32_t num, uint16_t seq) +{ + odp_packet_t pkt; + uint32_t i, j, pkt_len, seg_len, payload_len; + void *data; + uint8_t *u8; + odph_ethhdr_t *eth; + odph_ipv4hdr_t *ip; + odph_udphdr_t *udp; + test_options_t *test_options = &global->test_options; + uint32_t hdr_len = ODPH_ETHHDR_LEN + ODPH_IPV4HDR_LEN + ODPH_UDPHDR_LEN; + uint16_t udp_src = test_options->udp_src; + uint16_t udp_dst = test_options->udp_dst; + uint32_t udp_src_cnt = 0; + uint32_t udp_dst_cnt = 0; + + for (i = 0; i < num; i++) { + pkt = packet[i]; + pkt_len = odp_packet_len(pkt); + seg_len = odp_packet_seg_len(pkt); + data = odp_packet_data(pkt); + payload_len = pkt_len - hdr_len; + + if (seg_len < hdr_len) { + printf("Error: First segment too short %u\n", seg_len); + return -1; + } + + /* Ethernet */ + eth = data; + memcpy(eth->dst.addr, global->pktio[pktio].eth_dst.addr, 6); + memcpy(eth->src.addr, global->pktio[pktio].eth_src.addr, 6); + eth->type = odp_cpu_to_be_16(ODPH_ETHTYPE_IPV4); + + /* IPv4 */ + ip = (odph_ipv4hdr_t *)((uint8_t *)data + ODPH_ETHHDR_LEN); + memset(ip, 0, ODPH_IPV4HDR_LEN); + ip->ver_ihl = ODPH_IPV4 << 4 | ODPH_IPV4HDR_IHL_MIN; + ip->tot_len = odp_cpu_to_be_16(pkt_len - ODPH_ETHHDR_LEN); + ip->id = odp_cpu_to_be_16(seq + i); + ip->ttl = 64; + ip->proto = ODPH_IPPROTO_UDP; + ip->src_addr = odp_cpu_to_be_32(test_options->ipv4_src); + ip->dst_addr = odp_cpu_to_be_32(test_options->ipv4_dst); + ip->chksum = ~odp_chksum_ones_comp16(ip, ODPH_IPV4HDR_LEN); + + /* UDP */ + udp = (odph_udphdr_t *)((uint8_t *)data + ODPH_ETHHDR_LEN + + ODPH_IPV4HDR_LEN); + memset(udp, 0, ODPH_UDPHDR_LEN); + udp->src_port = odp_cpu_to_be_16(udp_src); + udp->dst_port = odp_cpu_to_be_16(udp_dst); + udp->length = odp_cpu_to_be_16(payload_len + ODPH_UDPHDR_LEN); + udp->chksum = 0; + + /* Init UDP payload until the end of the first segment */ + u8 = data; + u8 += hdr_len; + for (j = 0; j < seg_len - hdr_len; j++) + u8[j] = j; + + /* Insert UDP checksum */ + odp_packet_l3_offset_set(pkt, ODPH_ETHHDR_LEN); + odp_packet_l4_offset_set(pkt, + ODPH_ETHHDR_LEN + ODPH_IPV4HDR_LEN); + odp_packet_has_eth_set(pkt, 1); + odp_packet_has_ipv4_set(pkt, 1); + odp_packet_has_udp_set(pkt, 1); + udp->chksum = odph_ipv4_udp_chksum(pkt); + + /* Increment port numbers */ + if (test_options->c_mode.udp_src) { + udp_src_cnt++; + if (udp_src_cnt < test_options->c_mode.udp_src) { + udp_src++; + } else { + udp_src = test_options->udp_src; + udp_src_cnt = 0; + } + } + if (test_options->c_mode.udp_dst) { + udp_dst_cnt++; + if (udp_dst_cnt < test_options->c_mode.udp_dst) { + udp_dst++; + } else { + udp_dst = test_options->udp_dst; + udp_dst_cnt = 0; + } + } + } + + return 0; +} + +static inline int send_burst(odp_pktout_queue_t pktout, odp_packet_t pkt[], + int burst_size) { + int i, sent; + int num = burst_size; + odp_packet_t pkt_ref[burst_size]; + + for (i = 0; i < burst_size; i++) { + pkt_ref[i] = odp_packet_ref_static(pkt[i]); + + if (pkt_ref[i] == ODP_PACKET_INVALID) { + num = i; + break; + } + } + + if (odp_unlikely(num == 0)) + return 0; + + sent = odp_pktout_send(pktout, pkt_ref, num); + + if (odp_unlikely(sent < 0)) + sent = 0; + + if (odp_unlikely(sent != num)) { + uint32_t num_drop = num - sent; + + odp_packet_free_multi(&pkt_ref[sent], num_drop); + } + + return sent; +} + +static int tx_thread(void *arg) +{ + int i, thr, tx_thr, num_alloc; + uint32_t exit_test; + odp_time_t t1, t2, next_tmo; + uint64_t diff_ns, t1_nsec; + thread_arg_t *thread_arg = arg; + test_global_t *global = thread_arg->global; + test_options_t *test_options = &global->test_options; + odp_pool_t pool = global->pool; + uint64_t gap_nsec = test_options->gap_nsec; + uint64_t quit = test_options->quit; + uint64_t tx_timeouts = 0; + uint64_t tx_packets = 0; + uint64_t tx_drops = 0; + int ret = 0; + int burst_size = test_options->burst_size; + int bursts = test_options->bursts; + uint32_t num_tx = test_options->num_tx; + uint32_t pkt_len = test_options->pkt_len; + int num_pktio = test_options->num_pktio; + int num_pkt = num_pktio * bursts * burst_size; + odp_pktout_queue_t pktout[num_pktio]; + odp_packet_t pkt[num_pkt]; + + thr = odp_thread_id(); + tx_thr = thread_arg->tx_thr; + global->stat[thr].thread_type = TX_THREAD; + + num_alloc = odp_packet_alloc_multi(pool, pkt_len, pkt, num_pkt); + + if (num_alloc != num_pkt) { + printf("Error: alloc of %u packets failed (%i)\n", + num_pkt, thr); + ret = -1; + } + + /* Initialize packets per pktio interface */ + for (i = 0; ret == 0 && i < num_pktio; i++) { + int f = i * bursts * burst_size; + + pktout[i] = thread_arg->pktout[i]; + if (init_packets(global, i, &pkt[f], bursts * burst_size, f)) { + ret = -1; + break; + } + } + + /* Start all workers at the same time */ + odp_barrier_wait(&global->barrier); + + t1 = odp_time_local(); + + /* Start TX burst at different per thread offset */ + t1_nsec = odp_time_to_ns(t1) + gap_nsec + (tx_thr * gap_nsec / num_tx); + + while (ret == 0) { + exit_test = odp_atomic_load_u32(&global->exit_test); + if (exit_test) + break; + + if (quit && tx_timeouts >= quit) { + odp_atomic_inc_u32(&global->exit_test); + break; + } + + if (gap_nsec) { + uint64_t nsec = t1_nsec + tx_timeouts * gap_nsec; + + next_tmo = odp_time_local_from_ns(nsec); + odp_time_wait_until(next_tmo); + } + tx_timeouts++; + + /* Send bursts to each pktio */ + for (i = 0; i < num_pktio; i++) { + int sent, j; + int first = i * bursts * burst_size; + + for (j = 0; j < bursts; j++) { + sent = send_burst(pktout[i], + &pkt[first + j * burst_size], + burst_size); + + if (odp_unlikely(sent < 0)) { + ret = -1; + tx_drops += burst_size; + break; + } + + tx_packets += sent; + if (odp_unlikely(sent < burst_size)) + tx_drops += burst_size - sent; + } + } + } + + t2 = odp_time_local(); + diff_ns = odp_time_diff_ns(t2, t1); + + if (num_alloc > 0) + odp_packet_free_multi(pkt, num_alloc); + + /* Update stats */ + global->stat[thr].time_nsec = diff_ns; + global->stat[thr].tx_timeouts = tx_timeouts; + global->stat[thr].tx_packets = tx_packets; + global->stat[thr].tx_drops = tx_drops; + + return ret; +} + +static int start_workers(test_global_t *global, odp_instance_t instance) +{ + odph_thread_common_param_t thr_common; + int i, j, ret, tx_thr; + test_options_t *test_options = &global->test_options; + int num_pktio = test_options->num_pktio; + int num_rx = test_options->num_rx; + int num_cpu = test_options->num_cpu; + odph_thread_param_t thr_param[num_cpu]; + + memset(global->thread_tbl, 0, sizeof(global->thread_tbl)); + memset(thr_param, 0, sizeof(thr_param)); + memset(&thr_common, 0, sizeof(thr_common)); + + thr_common.instance = instance; + thr_common.cpumask = &global->cpumask; + + /* Receive threads */ + for (i = 0; i < num_rx; i++) { + thr_param[i].start = rx_thread; + thr_param[i].arg = &global->thread_arg[i]; + thr_param[i].thr_type = ODP_THREAD_WORKER; + } + + /* Transmit threads */ + tx_thr = 0; + for (i = num_rx; i < num_cpu; i++) { + for (j = 0; j < num_pktio; j++) { + odp_pktout_queue_t pktout; + + global->thread_arg[i].tx_thr = tx_thr; + + /* Dedicate a pktout queue per pktio interface + * (per TX thread) */ + pktout = global->pktio[j].pktout[tx_thr]; + global->thread_arg[i].pktout[j] = pktout; + } + + thr_param[i].start = tx_thread; + thr_param[i].arg = &global->thread_arg[i]; + thr_param[i].thr_type = ODP_THREAD_WORKER; + tx_thr++; + } + + ret = odph_thread_create(global->thread_tbl, &thr_common, thr_param, + num_cpu); + + if (ret != num_cpu) { + printf("Error: thread create failed %i\n", ret); + return -1; + } + + return 0; +} + +static int print_stat(test_global_t *global) +{ + int i, num_thr; + double rx_pkt_ave, rx_mbit_per_sec, tx_mbit_per_sec; + test_options_t *test_options = &global->test_options; + int num_rx = test_options->num_rx; + int num_tx = test_options->num_tx; + uint32_t pkt_len = test_options->pkt_len; + uint64_t rx_nsec_sum = 0; + uint64_t rx_pkt_sum = 0; + uint64_t rx_byte_sum = 0; + uint64_t rx_tmo_sum = 0; + uint64_t tx_nsec_sum = 0; + uint64_t tx_pkt_sum = 0; + uint64_t tx_drop_sum = 0; + uint64_t tx_tmo_sum = 0; + double rx_pkt_per_sec = 0.0; + double rx_byte_per_sec = 0.0; + double rx_pkt_len = 0.0; + double rx_sec = 0.0; + double tx_pkt_per_sec = 0.0; + double tx_sec = 0.0; + + printf("\nRESULTS PER THREAD\n"); + printf(" rx thread:\n"); + printf(" 1 2 3 4 5 6 7 8\n"); + printf(" ---------------------------------------------------------------------------------------\n"); + printf(" "); + + num_thr = 0; + for (i = 0; i < ODP_THREAD_COUNT_MAX; i++) { + if (global->stat[i].thread_type != RX_THREAD) + continue; + + if (num_thr && (num_thr % 8) == 0) + printf("\n "); + + printf("%10" PRIu64 " ", global->stat[i].rx_packets); + num_thr++; + } + + printf("\n\n"); + + printf(" tx thread:\n"); + printf(" 1 2 3 4 5 6 7 8\n"); + printf(" ---------------------------------------------------------------------------------------\n"); + printf(" "); + + num_thr = 0; + for (i = 0; i < ODP_THREAD_COUNT_MAX; i++) { + if (global->stat[i].thread_type != TX_THREAD) + continue; + + if (num_thr && (num_thr % 8) == 0) + printf("\n "); + + printf("%10" PRIu64 " ", global->stat[i].tx_packets); + num_thr++; + } + + printf("\n\n"); + + for (i = 0; i < ODP_THREAD_COUNT_MAX; i++) { + if (global->stat[i].thread_type == RX_THREAD) { + rx_tmo_sum += global->stat[i].rx_timeouts; + rx_pkt_sum += global->stat[i].rx_packets; + rx_byte_sum += global->stat[i].rx_bytes; + rx_nsec_sum += global->stat[i].time_nsec; + + } else if (global->stat[i].thread_type == TX_THREAD) { + tx_tmo_sum += global->stat[i].tx_timeouts; + tx_pkt_sum += global->stat[i].tx_packets; + tx_drop_sum += global->stat[i].tx_drops; + tx_nsec_sum += global->stat[i].time_nsec; + } + } + + rx_pkt_ave = (double)rx_pkt_sum / num_rx; + rx_sec = rx_nsec_sum / 1000000000.0; + tx_sec = tx_nsec_sum / 1000000000.0; + + /* Packets and bytes per thread per sec */ + if (rx_nsec_sum) { + rx_pkt_per_sec = (1000000000.0 * (double)rx_pkt_sum) / + (double)rx_nsec_sum; + + rx_byte_per_sec = 1000000000.0; + rx_byte_per_sec *= (rx_byte_sum + 24 * rx_pkt_sum); + rx_byte_per_sec /= (double)rx_nsec_sum; + } + + if (tx_nsec_sum) { + tx_pkt_per_sec = (1000000000.0 * (double)tx_pkt_sum) / + (double)tx_nsec_sum; + } + + /* Total Mbit/s */ + rx_mbit_per_sec = (num_rx * 8 * rx_byte_per_sec) / 1000000.0; + tx_mbit_per_sec = (num_tx * 8 * tx_pkt_per_sec * (pkt_len + 24)) + / 1000000.0; + + if (rx_pkt_sum) + rx_pkt_len = (double)rx_byte_sum / rx_pkt_sum; + + printf("TOTAL (%i rx and %i tx threads)\n", num_rx, num_tx); + printf(" rx timeouts: %" PRIu64 "\n", rx_tmo_sum); + printf(" rx time spent (sec): %.3f\n", rx_sec); + printf(" rx packets: %" PRIu64 "\n", rx_pkt_sum); + printf(" rx packets drained: %" PRIu64 "\n", global->drained); + printf(" rx packets per thr: %.1f\n", rx_pkt_ave); + printf(" rx packets per thr per sec: %.1f\n", rx_pkt_per_sec); + printf(" rx packets per sec: %.1f\n", num_rx * rx_pkt_per_sec); + printf(" rx ave packet len: %.1f\n", rx_pkt_len); + printf(" rx Mbit/s: %.1f\n", rx_mbit_per_sec); + printf("\n"); + printf(" tx timeouts: %" PRIu64 "\n", tx_tmo_sum); + printf(" tx time spent (sec): %.3f\n", tx_sec); + printf(" tx packets: %" PRIu64 "\n", tx_pkt_sum); + printf(" tx dropped packets: %" PRIu64 "\n", tx_drop_sum); + printf(" tx packets per thr per sec: %.1f\n", tx_pkt_per_sec); + printf(" tx packets per sec: %.1f\n", num_tx * tx_pkt_per_sec); + printf(" tx Mbit/s: %.1f\n", tx_mbit_per_sec); + printf("\n"); + + if (rx_pkt_sum < MIN_RX_PACKETS_CI) + return -1; + + return 0; +} + +static void sig_handler(int signo) +{ + (void)signo; + + if (test_global == NULL) + return; + + odp_atomic_add_u32(&test_global->exit_test, 1); +} + +int main(int argc, char **argv) +{ + odp_instance_t instance; + odp_init_t init; + test_global_t *global; + odp_shm_t shm; + int i; + int ret = 0; + + signal(SIGINT, sig_handler); + + /* List features not to be used */ + odp_init_param_init(&init); + init.not_used.feat.cls = 1; + init.not_used.feat.compress = 1; + init.not_used.feat.crypto = 1; + init.not_used.feat.ipsec = 1; + init.not_used.feat.timer = 1; + init.not_used.feat.tm = 1; + + /* Init ODP before calling anything else */ + if (odp_init_global(&instance, &init, NULL)) { + printf("Error: Global init failed.\n"); + return -1; + } + + /* Init this thread */ + if (odp_init_local(instance, ODP_THREAD_CONTROL)) { + printf("Error: Local init failed.\n"); + return -1; + } + + shm = odp_shm_reserve("packet_gen_global", sizeof(test_global_t), + ODP_CACHE_LINE_SIZE, 0); + + if (shm == ODP_SHM_INVALID) { + printf("Error: SHM reserve failed.\n"); + return -1; + } + + global = odp_shm_addr(shm); + test_global = global; + + memset(global, 0, sizeof(test_global_t)); + odp_atomic_init_u32(&global->exit_test, 0); + + for (i = 0; i < ODP_THREAD_COUNT_MAX; i++) + global->thread_arg[i].global = global; + + if (parse_options(argc, argv, global)) { + ret = -1; + goto term; + } + + odp_schedule_config(NULL); + + if (set_num_cpu(global)) { + ret = -1; + goto term; + } + + if (open_pktios(global)) { + ret = -1; + goto term; + } + + if (start_pktios(global)) { + ret = -1; + goto term; + } + + /* Start worker threads */ + start_workers(global, instance); + + /* Wait until workers have started. */ + odp_barrier_wait(&global->barrier); + + /* Wait workers to exit */ + odph_thread_join(global->thread_tbl, + global->test_options.num_cpu); + + if (stop_pktios(global)) + ret = -1; + + drain_queues(global); + + if (close_pktios(global)) + ret = -1; + + if (print_stat(global)) + ret = -2; + +term: + if (odp_shm_free(shm)) { + printf("Error: SHM free failed.\n"); + return -1; + } + + if (odp_term_local()) { + printf("Error: term local failed.\n"); + return -1; + } + + if (odp_term_global(instance)) { + printf("Error: term global failed.\n"); + return -1; + } + + return ret; +} commit 181773542664bddff206fedb62ba94c38118457d Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Wed Feb 12 15:31:28 2020 +0200 test: timer_perf: fix help text Fixed copy-paste error from help text. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-and-tested-by: Matias Elo <matias.elo(a)nokia.com> diff --git a/test/performance/odp_timer_perf.c b/test/performance/odp_timer_perf.c index 5a2317aab..7834d4e56 100644 --- a/test/performance/odp_timer_perf.c +++ b/test/performance/odp_timer_perf.c @@ -79,9 +79,9 @@ test_global_t test_global; static void print_usage(void) { printf("\n" - "Scheduler performance test\n" + "Timer performance test\n" "\n" - "Usage: odp_sched_perf [options]\n" + "Usage: odp_timer_perf [options]\n" "\n" " -c, --num_cpu Number of CPUs (worker threads). 0: all available CPUs. Default: 1\n" " -n, --num_tp Number of timer pools. Default: 1\n" ----------------------------------------------------------------------- Summary of changes: example/l3fwd/odp_l3fwd.c | 11 +- example/switch/odp_switch.c | 2 +- test/performance/.gitignore | 1 + test/performance/Makefile.am | 3 + test/performance/odp_l2fwd.c | 2 +- test/performance/odp_packet_gen.c | 1313 ++++++++++++++++++++ ...dp_sched_pktio_run.sh => odp_packet_gen_run.sh} | 55 +- test/performance/odp_pktio_ordered.c | 2 +- test/performance/odp_timer_perf.c | 4 +- 9 files changed, 1340 insertions(+), 53 deletions(-) create mode 100644 test/performance/odp_packet_gen.c copy test/performance/{odp_sched_pktio_run.sh => odp_packet_gen_run.sh} (58%) hooks/post-receive --

6 years

[COMMIT] branch master updated. v1.21.0.0-424-g324a2a2c7

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 324a2a2c7c1a9d35323483b679eedfebcb310827 (commit) via 9dc2dcff30a5bf8963b9947343cf79fe63013932 (commit) via f974cb930ffb6bc1f0084b23f8d2e877b75e44db (commit) via f1798c854568c4e521cf71842bb71e81a0904251 (commit) from 64b4c275b39373678eaad8294816e9937805de47 (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 324a2a2c7c1a9d35323483b679eedfebcb310827 Author: Matias Elo <matias.elo(a)nokia.com> Date: Thu Feb 13 10:39:56 2020 +0200 build: check if libatomic is needed for __atomic_compare_exchange_n Double wide __atomic_compare_exchange_n() is required by ipfragreass example. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/example/Makefile.am b/example/Makefile.am index 28362f2c1..26723a9e4 100644 --- a/example/Makefile.am +++ b/example/Makefile.am @@ -3,7 +3,6 @@ SUBDIRS = classifier \ hello \ ipsec \ ipsec_api \ - ipfragreass \ ipsec_offload \ l2fwd_simple \ l3fwd \ @@ -15,3 +14,7 @@ SUBDIRS = classifier \ time \ timer \ traffic_mgmt + +if HAVE_DW_ATOMIC_CMP_EXC +SUBDIRS += ipfragreass +endif diff --git a/example/ipfragreass/Makefile.am b/example/ipfragreass/Makefile.am index b98e066f8..2cd61a39e 100644 --- a/example/ipfragreass/Makefile.am +++ b/example/ipfragreass/Makefile.am @@ -1,6 +1,6 @@ include $(top_srcdir)/example/Makefile.inc -LDADD += $(ATOMIC_LIBS) +LDADD += $(ATOMIC_LIBS) $(ATOMIC_LIBS_OPT) bin_PROGRAMS = odp_ipfragreass diff --git a/m4/odp_atomic.m4 b/m4/odp_atomic.m4 index 413dcbda9..c0068b5e4 100644 --- a/m4/odp_atomic.m4 +++ b/m4/odp_atomic.m4 @@ -14,6 +14,30 @@ if test "x$use_libatomic" = "xyes"; then ATOMIC_LIBS="-latomic" fi AC_SUBST([ATOMIC_LIBS]) + +# Double wide __atomic_compare_exchange_n is required by ipfragreass example +use_libatomic_opt=no; +have_atomic_cmp_exc=yes; + +AC_CHECK_SIZEOF([void *]) +AC_PREPROC_IFELSE( + [AC_LANG_SOURCE([ + #if SIZEOF_VOID_P == 8 + #error + #endif + ])], [plat64=no], [plat64=yes]) + +if test "x$plat64" = "xyes"; then + ODP_ATOMIC_NEEDED_128BIT_CMP_EXC([use_libatomic_opt=yes], [have_atomic_cmp_exc=no]) +else + ODP_ATOMIC_NEEDED_64BIT_CMP_EXC([use_libatomic_opt=yes], [have_atomic_cmp_exc=no]) +fi + +if test "x$use_libatomic_opt" = "xyes"; then + ATOMIC_LIBS_OPT="-latomic" +fi +AC_SUBST([ATOMIC_LIBS_OPT]) +AM_CONDITIONAL([HAVE_DW_ATOMIC_CMP_EXC], [test x$have_atomic_cmp_exc = xyes]) ]) # ODP_ATOMIC # ODP_ATOMIC_BUILTINS @@ -93,3 +117,64 @@ if test "x$odp_cv_atomic_needed_128bit" = "xyes" ; then [AC_MSG_FAILURE([__atomic_exchange_16 is not available])]) fi ]) # ODP_ATOMIC_NEEDED_128BIT + +# ODP_ATOMIC_NEEDED_64BIT_CMP_EXC([ACTION_IF_NEEDED], [ACTION_IF_NOT_AVAILABLE]) +# ------------------------------------------------------------------------------ +# +AC_DEFUN([ODP_ATOMIC_NEEDED_64BIT_CMP_EXC], [dnl +AC_CACHE_CHECK([whether -latomic is needed for 64-bit atomic compare exchange], + [odp_cv_atomic_needed_64bit_cmp_exc], [dnl +AC_LINK_IFELSE( + [AC_LANG_SOURCE([[ + #include <stdint.h> + static uint64_t loc; + int main(void) + { + uint64_t exp = 0; + uint64_t = __atomic_compare_exchange_n(&loc, &exp, 1, 1, + __ATOMIC_ACQUIRE, + __ATOMIC_RELAXED); + return 0; + } + ]])], + [odp_cv_atomic_needed_64bit_cmp_exc=no], + [odp_cv_atomic_needed_64bit_cmp_exc=yes])]) + +if test "x$odp_cv_atomic_needed_64bit_cmp_exc" = "xyes" ; then + AC_CHECK_LIB( + [atomic], [__atomic_compare_exchange_8], + [m4_default([$1], [:])], + [m4_default([$2], [:])]) +fi + +]) # ODP_ATOMIC_NEEDED_64BIT_CMP_EXC + +# ODP_ATOMIC_NEEDED_128BIT_CMP_EXC([ACTION_IF_NEEDED], [ACTION_IF_NOT_AVAILABLE]) +# ------------------------------------------------------------------------------- +# +AC_DEFUN([ODP_ATOMIC_NEEDED_128BIT_CMP_EXC], [dnl +AC_CACHE_CHECK([whether -latomic is needed for 128-bit atomic compare exchange], + [odp_cv_atomic_needed_128bit_cmp_exc], [dnl +AC_LINK_IFELSE( + [AC_LANG_SOURCE([[ + #include <stdint.h> + static __int128 loc; + int main(void) + { + __int128 exp = 0; + __int128 = __atomic_compare_exchange_n(&loc, &exp, 1, 1, + __ATOMIC_ACQUIRE, + __ATOMIC_RELAXED); + return 0; + } + ]])], + [odp_cv_atomic_needed_128bit_cmp_exc=no], + [odp_cv_atomic_needed_128bit_cmp_exc=yes])]) + +if test "x$odp_cv_atomic_needed_128bit_cmp_exc" = "xyes" ; then + AC_CHECK_LIB( + [atomic], [__atomic_compare_exchange_16], + [m4_default([$1], [:])], + [m4_default([$2], [:])]) +fi +]) # ODP_ATOMIC_NEEDED_128BIT_CMP_EXC commit 9dc2dcff30a5bf8963b9947343cf79fe63013932 Author: Matias Elo <matias.elo(a)nokia.com> Date: Wed Feb 12 16:24:45 2020 +0200 ci: use correct paths for pkg-config when cross compiling Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/scripts/ci/build_arm64.sh b/scripts/ci/build_arm64.sh index 647dd29cf..abdc5acb8 100755 --- a/scripts/ci/build_arm64.sh +++ b/scripts/ci/build_arm64.sh @@ -11,4 +11,8 @@ else fi export CPPFLAGS="-I/usr/include/${TARGET_ARCH}/dpdk" +# Use target libraries +export PKG_CONFIG_PATH= +export PKG_CONFIG_LIBDIR=/usr/lib/${TARGET_ARCH}/pkgconfig + exec "$(dirname "$0")"/build.sh diff --git a/scripts/ci/build_armhf.sh b/scripts/ci/build_armhf.sh index c13acaa08..4ae0f19b1 100755 --- a/scripts/ci/build_armhf.sh +++ b/scripts/ci/build_armhf.sh @@ -15,4 +15,8 @@ export CXXFLAGS="-march=armv7-a" # No DPDK on ARMv7 export CONF="${CONF} --disable-dpdk" +# Use target libraries +export PKG_CONFIG_PATH= +export PKG_CONFIG_LIBDIR=/usr/lib/${TARGET_ARCH}/pkgconfig + exec "$(dirname "$0")"/build.sh diff --git a/scripts/ci/build_i386.sh b/scripts/ci/build_i386.sh index 17b6bf668..797dd454d 100755 --- a/scripts/ci/build_i386.sh +++ b/scripts/ci/build_i386.sh @@ -12,4 +12,8 @@ else fi export CPPFLAGS="-I/usr/include/i386-linux-gnu/dpdk" +# Use target libraries +export PKG_CONFIG_PATH= +export PKG_CONFIG_LIBDIR=/usr/lib/i386-linux-gnu/pkgconfig + exec "$(dirname "$0")"/build.sh diff --git a/scripts/ci/build_ppc64el.sh b/scripts/ci/build_ppc64el.sh index ca094c901..984481bb5 100755 --- a/scripts/ci/build_ppc64el.sh +++ b/scripts/ci/build_ppc64el.sh @@ -13,4 +13,8 @@ else fi export CPPFLAGS="-I/usr/include/${TARGET_ARCH}/dpdk" +# Use target libraries +export PKG_CONFIG_PATH= +export PKG_CONFIG_LIBDIR=/usr/lib/${TARGET_ARCH}/pkgconfig + exec "$(dirname "$0")"/build.sh commit f974cb930ffb6bc1f0084b23f8d2e877b75e44db Author: Matias Elo <matias.elo(a)nokia.com> Date: Tue Feb 11 15:37:45 2020 +0200 travis: change default ubuntu container version to 18.04 Separate DPDK v18.11 test has been removed. DPDK v18.11 is used now by default in Ubuntu 18.04 x86 builds. DPDK v17.11 is still used in Ubuntu 16.04 builds. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/.travis.yml b/.travis.yml index e75ec5dc6..d3fafcb0c 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,26 +49,22 @@ env: # you need to generate a new one at https://codecov.io specific for your # repo. - CODECOV_TOKEN=a733c34c-5f5c-4ff1-af4b-e9f5edb1ab5e - - OS=ubuntu_16.04 + - OS=ubuntu_18.04 - ARCH=x86_64 - CHECK=1 - NETMAP=0 matrix: - CHECK=0 CONF="CFLAGS=-O3" - CHECK=0 CONF="CFLAGS=-O0 --enable-debug --enable-debug-print" - - CHECK=0 OS=ubuntu_18.04 CONF="CFLAGS=-O3" - - CHECK=0 OS=ubuntu_18.04 CONF="CFLAGS=-O0 --enable-debug --enable-debug-print" - CHECK=0 CONF="--enable-lto" - CHECK=0 CONF="--enable-lto --disable-abi-compat" - - CHECK=0 OS=ubuntu_18.04 CONF="--enable-lto" - - CHECK=0 OS=ubuntu_18.04 CONF="--enable-lto --disable-abi-compat" - CHECK=0 ARCH=arm64 - CHECK=0 ARCH=armhf - - CHECK=0 ARCH=powerpc + - CHECK=0 ARCH=ppc64el - CHECK=0 ARCH=i386 - CHECK=0 ARCH=arm64 CONF="--disable-abi-compat" - CHECK=0 ARCH=armhf CONF="--disable-abi-compat" - - CHECK=0 ARCH=powerpc CONF="--disable-abi-compat" + - CHECK=0 ARCH=ppc64el CONF="--disable-abi-compat" - CHECK=0 ARCH=i386 CONF="--disable-abi-compat" - CONF="" - CONF="--disable-abi-compat" @@ -81,7 +77,7 @@ env: - CHECK=0 CONF="--enable-pcapng-support" - CHECK=0 OS=centos_7 - CONF="--without-openssl --without-pcap" - - OS=ubuntu_18.04 + - OS=ubuntu_16.04 matrix: exclude: @@ -93,10 +89,6 @@ matrix: env: CHECK=0 CONF="--enable-lto" - compiler: clang env: CHECK=0 CONF="--enable-lto --disable-abi-compat" - - compiler: clang - env: CHECK=0 OS=ubuntu_18.04 CONF="--enable-lto" - - compiler: clang - env: CHECK=0 OS=ubuntu_18.04 CONF="--enable-lto --disable-abi-compat" install: - if [ ${NETMAP} -eq 1 ] ; then @@ -117,14 +109,14 @@ script: docker run -i -t -v `pwd`:/odp --shm-size 8g -e CC="${CC}" -e CONF="${CONF}" - ${DOCKER_NAMESPACE}/travis-odp-lng-${OS} /odp/scripts/ci/build_${ARCH}.sh ; + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/build_${ARCH}.sh ; else echo "Running test" ; docker run --privileged -i -t -v `pwd`:/odp --shm-size 8g -e CC="${CC}" -e CONF="${CONF}" - ${DOCKER_NAMESPACE}/travis-odp-lng-${OS} /odp/scripts/ci/check.sh ; + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/check.sh ; fi jobs: include: @@ -137,7 +129,7 @@ jobs: -v `pwd`:/odp --shm-size 8g -e CODECOV_TOKEN="${CODECOV_TOKEN}" -e CC="${CC}" - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/coverage.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/coverage.sh - stage: test env: TEST=scheduler_sp compiler: gcc @@ -148,7 +140,7 @@ jobs: -e CC="${CC}" -e CONF="" -e ODP_SCHEDULER=sp - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/check.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/check.sh - stage: test env: TEST=scheduler_scalable compiler: gcc @@ -159,7 +151,7 @@ jobs: -e CC="${CC}" -e CONF="" -e ODP_SCHEDULER=scalable - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/check.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/check.sh - stage: test env: TEST=process_mode install: @@ -173,19 +165,7 @@ jobs: -e CONF="" -e ODP_CONFIG_FILE=/odp/platform/linux-generic/test/process-mode.conf -e ODPH_PROC_MODE=1 - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/check.sh - - stage: test - env: TEST=dpdk_18.11 - install: - - true - compiler: gcc - script: - - if [ -z "${DOCKER_NAMESPACE}" ] ; then export DOCKER_NAMESPACE="opendataplane"; fi - - docker run --privileged -i -t - -v `pwd`:/odp --shm-size 8g - -e CC="${CC}" - -e CONF="" - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04-dpdk_18.11 /odp/scripts/ci/check.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/check.sh - stage: test env: TEST=inline_timer install: @@ -198,7 +178,7 @@ jobs: -e CC="${CC}" -e CONF="" -e ODP_CONFIG_FILE=/odp/platform/linux-generic/test/inline-timer.conf - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/check_inline_timer.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/check_inline_timer.sh - stage: test env: TEST=packet_align install: @@ -211,7 +191,7 @@ jobs: -e CC="${CC}" -e CONF="" -e ODP_CONFIG_FILE=/odp/platform/linux-generic/test/packet_align.conf - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/check_pktio.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/check_pktio.sh - stage: test env: TEST=distcheck compiler: gcc @@ -221,7 +201,7 @@ jobs: -v `pwd`:/odp --shm-size 8g -e CC="${CC}" -e CONF="--enable-user-guides" - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/distcheck.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/distcheck.sh - stage: test env: TEST=distcheck_nonabi compiler: gcc @@ -231,7 +211,7 @@ jobs: -v `pwd`:/odp --shm-size 8g -e CC="${CC}" -e CONF="--enable-user-guides --disable-abi-compat" - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/distcheck.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/distcheck.sh - stage: test env: TEST=out_of_tree compiler: gcc @@ -241,7 +221,7 @@ jobs: -v `pwd`:/odp --shm-size 8g -e CC="${CC}" -e CONF="" - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/out_of_tree.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/out_of_tree.sh - stage: "build only" env: TEST=documentation compiler: gcc @@ -314,7 +294,7 @@ jobs: - if [ -z "${DOCKER_NAMESPACE}" ] ; then export DOCKER_NAMESPACE="opendataplane"; fi - docker run -i -t -v `pwd`:/odp --shm-size 8g -e CC="${CC}" - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/build_${ARCH}.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/build_${ARCH}.sh - stage: "build only" env: ARCH=x86_64 compiler: clang @@ -324,7 +304,7 @@ jobs: - if [ -z "${DOCKER_NAMESPACE}" ] ; then export DOCKER_NAMESPACE="opendataplane"; fi - docker run -i -t -v `pwd`:/odp --shm-size 8g -e CC="${CC}" - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/build_${ARCH}.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/build_${ARCH}.sh - stage: "build only" env: ARCH=arm64 install: @@ -333,7 +313,7 @@ jobs: - if [ -z "${DOCKER_NAMESPACE}" ] ; then export DOCKER_NAMESPACE="opendataplane"; fi - docker run -i -t -v `pwd`:/odp -e CC="${CC}" - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/build_${ARCH}.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/build_${ARCH}.sh - stage: "build only" env: ARCH=i386 install: @@ -342,7 +322,7 @@ jobs: - if [ -z "${DOCKER_NAMESPACE}" ] ; then export DOCKER_NAMESPACE="opendataplane"; fi - docker run -i -t -v `pwd`:/odp --shm-size 8g -e CC="${CC}" - ${DOCKER_NAMESPACE}/travis-odp-lng-ubuntu_16.04 /odp/scripts/ci/build_${ARCH}.sh + ${DOCKER_NAMESPACE}/travis-odp-${OS}-${ARCH} /odp/scripts/ci/build_${ARCH}.sh - stage: test canfail: yes env: TEST=checkpatch diff --git a/scripts/ci/build_armhf.sh b/scripts/ci/build_armhf.sh index 837561f83..c13acaa08 100755 --- a/scripts/ci/build_armhf.sh +++ b/scripts/ci/build_armhf.sh @@ -9,8 +9,10 @@ else export CC="${TARGET_ARCH}-gcc" export CXX="${TARGET_ARCH}-g++" fi -export CPPFLAGS="-I/usr/include/${TARGET_ARCH}/dpdk" export CFLAGS="-march=armv7-a" export CXXFLAGS="-march=armv7-a" +# No DPDK on ARMv7 +export CONF="${CONF} --disable-dpdk" + exec "$(dirname "$0")"/build.sh diff --git a/scripts/ci/build_powerpc.sh b/scripts/ci/build_ppc64el.sh similarity index 61% rename from scripts/ci/build_powerpc.sh rename to scripts/ci/build_ppc64el.sh index a213ee1d3..ca094c901 100755 --- a/scripts/ci/build_powerpc.sh +++ b/scripts/ci/build_ppc64el.sh @@ -1,15 +1,16 @@ #!/bin/bash set -e -export TARGET_ARCH=powerpc-linux-gnu +export TARGET_ARCH=powerpc64le-linux-gnu if [ "${CC#clang}" != "${CC}" ] ; then export CC="clang --target=${TARGET_ARCH}" export CXX="clang++ --target=${TARGET_ARCH}" + # DPDK clang build broken + export CONF="${CONF} --disable-dpdk" else export CC="${TARGET_ARCH}-gcc" export CXX="${TARGET_ARCH}-g++" fi -# No DPDK on PowerPC -export CONF="${CONF} --disable-dpdk" +export CPPFLAGS="-I/usr/include/${TARGET_ARCH}/dpdk" exec "$(dirname "$0")"/build.sh commit f1798c854568c4e521cf71842bb71e81a0904251 Author: Matias Elo <matias.elo(a)nokia.com> Date: Thu Feb 13 21:15:24 2020 +0200 linux-gen: pcap: disable loop support in process mode Reopening pcap interface, which is needed to implemement loop support, causes pcap internal failure in process mode. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/platform/linux-generic/pktio/pcap.c b/platform/linux-generic/pktio/pcap.c index 4332348b6..6ef998717 100644 --- a/platform/linux-generic/pktio/pcap.c +++ b/platform/linux-generic/pktio/pcap.c @@ -29,7 +29,8 @@ * doesn't exist it will be created, if it does exist it will * be overwritten. * loops the number of times to iterate through the input file, set - * to 0 to loop indefinitely. The default value is 1. + * to 0 to loop indefinitely. The default value is 1. Looping is + * only supported in thread mode (ODP_MEM_MODEL_THREAD). * * The total length of the string is limited by PKTIO_NAME_LEN. */ @@ -38,6 +39,7 @@ #include <odp_api.h> #include <odp/api/plat/packet_inlines.h> +#include <odp_global_data.h> #include <odp_packet_internal.h> #include <odp_packet_io_internal.h> @@ -199,6 +201,10 @@ static int _pcapif_reopen(pkt_pcap_t *pcap) { char errbuf[PCAP_ERRBUF_SIZE]; + /* Reopen causes pcap internal failure in process mode */ + if (odp_global_ro.init_param.mem_model == ODP_MEM_MODEL_PROCESS) + return 1; + if (pcap->loops != 0 && ++pcap->loop_cnt >= pcap->loops) return 1; diff --git a/test/performance/odp_pktio_ordered_run.sh b/test/performance/odp_pktio_ordered_run.sh index 09dd2ab98..d695be289 100755 --- a/test/performance/odp_pktio_ordered_run.sh +++ b/test/performance/odp_pktio_ordered_run.sh @@ -11,7 +11,7 @@ TEST_DIR="${TEST_DIR:-$(dirname $0)}" DURATION=5 LOG=odp_pktio_ordered.log LOOPS=100000000 -PASS_PPS=5000 +PASS_PPS=100 PCAP_IN=`find . ${TEST_SRC_DIR} $(dirname $0) -name udp64.pcap -print -quit` PCAP_OUT=/dev/null ----------------------------------------------------------------------- Summary of changes: .travis.yml | 58 ++++++----------- example/Makefile.am | 5 +- example/ipfragreass/Makefile.am | 2 +- m4/odp_atomic.m4 | 85 +++++++++++++++++++++++++ platform/linux-generic/pktio/pcap.c | 8 ++- scripts/ci/build_arm64.sh | 4 ++ scripts/ci/build_armhf.sh | 8 ++- scripts/ci/build_i386.sh | 4 ++ scripts/ci/build_powerpc.sh | 15 ----- scripts/ci/{build_armhf.sh => build_ppc64el.sh} | 10 ++- test/performance/odp_pktio_ordered_run.sh | 2 +- 11 files changed, 139 insertions(+), 62 deletions(-) delete mode 100755 scripts/ci/build_powerpc.sh copy scripts/ci/{build_armhf.sh => build_ppc64el.sh} (59%) hooks/post-receive --

6 years

[COMMIT] branch master updated. v1.21.0.0-420-g64b4c275

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 64b4c275b39373678eaad8294816e9937805de47 (commit) from 2356affd7f5b0c96b66e9b6c3174175bbfa00bd1 (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 64b4c275b39373678eaad8294816e9937805de47 Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Wed Feb 19 11:13:50 2020 +0200 linux-gen: timer: fix timer pool create sync with inline timer scan Set highest_tp_idx only after timer pool has been fully initialized. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-by: Matias Elo <matias.elo(a)nokia.com> diff --git a/platform/linux-generic/odp_timer.c b/platform/linux-generic/odp_timer.c index 3a82ee84..5fa02011 100644 --- a/platform/linux-generic/odp_timer.c +++ b/platform/linux-generic/odp_timer.c @@ -307,9 +307,6 @@ static odp_timer_pool_t timer_pool_new(const char *name, tp_idx = i; timer_global->num_timer_pools++; - if (tp_idx > timer_global->highest_tp_idx) - timer_global->highest_tp_idx = tp_idx; - odp_ticketlock_unlock(&timer_global->lock); sz0 = ROUNDUP_CACHE_LINE(sizeof(timer_pool_t)); @@ -377,7 +374,10 @@ static odp_timer_pool_t timer_pool_new(const char *name, } tp->tp_idx = tp_idx; odp_spinlock_init(&tp->lock); + tp->start_time = odp_time_global(); + odp_ticketlock_lock(&timer_global->lock); + /* Inline timer scan may find the timer pool after this */ timer_global->timer_pool[tp_idx] = tp; if (timer_global->num_timer_pools == 1) @@ -391,13 +391,18 @@ static odp_timer_pool_t timer_pool_new(const char *name, } odp_ticketlock_unlock(&timer_global->lock); + if (!odp_global_rw->inline_timers) { if (tp->param.clk_src == ODP_CLOCK_CPU) itimer_init(tp); + } else { + /* Update the highest index for inline timer scan */ + odp_ticketlock_lock(&timer_global->lock); + if (tp_idx > timer_global->highest_tp_idx) + timer_global->highest_tp_idx = tp_idx; + odp_ticketlock_unlock(&timer_global->lock); } - tp->start_time = odp_time_global(); - return timer_pool_to_hdl(tp); } ----------------------------------------------------------------------- Summary of changes: platform/linux-generic/odp_timer.c | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) hooks/post-receive --

6 years

[COMMIT] branch master updated. v1.21.0.0-419-g2356affd7

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 2356affd7f5b0c96b66e9b6c3174175bbfa00bd1 (commit) from 180f1403b12beab32715f10839d3248e7fecb46d (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 2356affd7f5b0c96b66e9b6c3174175bbfa00bd1 Author: Matias Elo <matias.elo(a)nokia.com> Date: Thu Feb 6 09:27:47 2020 +0200 linux-gen: pool: increase max segment length Enable creating larger single segment packets. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> Suggested-by: Jussi Kerttula <jussi.kerttula(a)nokia.com> diff --git a/platform/linux-generic/include/odp_config_internal.h b/platform/linux-generic/include/odp_config_internal.h index 67011b0d4..8c0285ff0 100644 --- a/platform/linux-generic/include/odp_config_internal.h +++ b/platform/linux-generic/include/odp_config_internal.h @@ -97,7 +97,7 @@ extern "C" { /* * Maximum packet segment size including head- and tailrooms */ -#define CONFIG_PACKET_SEG_SIZE (8 * 1024) +#define CONFIG_PACKET_SEG_SIZE (60 * 1024) /* Maximum data length in a segment * ----------------------------------------------------------------------- Summary of changes: platform/linux-generic/include/odp_config_internal.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) hooks/post-receive --

6 years

[COMMIT] branch master updated. v1.21.0.0-418-g180f1403b

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 180f1403b12beab32715f10839d3248e7fecb46d (commit) via cf51a0805a265b74128cb1dd30acfa292240a28f (commit) via bd1207ff72490a5000ab66281e0d10f566e0877d (commit) via 42c37a8506151debd9be885d055b2c4dc8a93c1c (commit) via 8c6880ee093af5ed6bf2af54a1acadc7b2ba895f (commit) via 321e53c0405ab300585ad66693a24942eefef62b (commit) via 90103b8a5dd627b8680e2fd7ff8380e6a4707ced (commit) from c9f7b34c7f0a4cadfabbd6733e3420a8adb8c322 (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 180f1403b12beab32715f10839d3248e7fecb46d Author: Matias Elo <matias.elo(a)nokia.com> Date: Mon Feb 3 10:52:56 2020 +0200 validation: packet: prevent test trying to allocate zero length packets Test packet_test_free_sp() would end up trying to allocate invalid zero length packets if pool_capa.pkt.max_len was zero. The following packet_alloc_multi() call would then loop indefinitely since error return value was not checked. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index 6f020d820..b7dfb59f3 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -341,7 +341,7 @@ static int packet_alloc_multi(odp_pool_t pool, uint32_t pkt_len, CU_ASSERT(ret >= 0); CU_ASSERT(ret <= num - total); total += ret; - } while (total < num && ret); + } while (total < num && ret > 0); return total; } @@ -430,7 +430,7 @@ static void packet_test_free_sp(void) odp_pool_param_t params; uint32_t len = packet_len; - if (pool_capa.pkt.max_len < len) + if (pool_capa.pkt.max_len && pool_capa.pkt.max_len < len) len = pool_capa.pkt.max_len; odp_pool_param_init(&params); commit cf51a0805a265b74128cb1dd30acfa292240a28f Author: Matias Elo <matias.elo(a)nokia.com> Date: Wed Jan 29 10:16:46 2020 +0200 example: switch: add signal handler for SIGINT Add signal handler to perform clean exit. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/example/switch/odp_switch.c b/example/switch/odp_switch.c index d21ed61d2..ccb975f6c 100644 --- a/example/switch/odp_switch.c +++ b/example/switch/odp_switch.c @@ -10,6 +10,7 @@ #include <unistd.h> #include <stdlib.h> #include <inttypes.h> +#include <signal.h> #include <odp_api.h> #include <odp/helper/odph_api.h> @@ -149,6 +150,13 @@ typedef struct { /** Global pointer to args */ static args_t *gbl_args; +static void sig_handler(int signo ODP_UNUSED) +{ + if (gbl_args == NULL) + return; + gbl_args->exit_threads = 1; +} + /** * Calculate MAC table index using Ethernet address hash * @@ -416,7 +424,8 @@ static int print_speed_stats(int num_workers, stats_t (*thr_stats)[MAX_PKTIOS], PRIu64 " rx drops, %" PRIu64 " tx drops\n", rx_pkts_tot, tx_pkts_tot, rx_drops_tot, tx_drops_tot); - } while (loop_forever || (elapsed < duration)); + } while (!gbl_args->exit_threads && + (loop_forever || (elapsed < duration))); return rx_pkts_tot >= 100 ? 0 : -1; } @@ -976,6 +985,8 @@ int main(int argc, char **argv) odp_init_t init_param; odph_odpthread_params_t thr_params; + signal(SIGINT, sig_handler); + /* Let helper collect its own arguments (e.g. --odph_proc) */ argc = odph_parse_options(argc, argv); if (odph_options(&helper_options)) { @@ -1160,6 +1171,5 @@ int main(int argc, char **argv) exit(EXIT_FAILURE); } - printf("Exit: %d\n\n", ret); return ret; } commit bd1207ff72490a5000ab66281e0d10f566e0877d Author: Matias Elo <matias.elo(a)nokia.com> Date: Tue Jan 28 16:40:17 2020 +0200 example: switch: detect invalid and broadcast ethernet addresses Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/example/switch/odp_switch.c b/example/switch/odp_switch.c index a31a19cd8..d21ed61d2 100644 --- a/example/switch/odp_switch.c +++ b/example/switch/odp_switch.c @@ -66,6 +66,12 @@ typedef struct { char *if_str; /**< Storage for interface names */ } appl_args_t; +typedef enum frame_type_t { + FRAME_UNICAST, + FRAME_BROADCAST, + FRAME_INVALID +} frame_type_t; + /** * Statistics */ @@ -497,6 +503,34 @@ static inline void broadcast_packet(odp_packet_t pkt, thread_args_t *thr_arg, } } +/** + * Check Ethernet frame for broadcast/invalid addresses + * + * @param eth Pointer to an Ethernet header + * + * @retval Ethernet frame_type_t + */ +static frame_type_t check_frame(odph_ethhdr_t *eth) +{ + static uint8_t broadcast_addr[ODPH_ETHADDR_LEN] = {0xff, 0xff, 0xff, + 0xff, 0xff, 0xff}; + static uint8_t null_addr[ODPH_ETHADDR_LEN] = {0, 0, 0, 0, 0, 0}; + + /* Drop invalid frames */ + if (odp_unlikely(!memcmp(eth->src.addr, broadcast_addr, + ODPH_ETHADDR_LEN) || + !memcmp(eth->dst.addr, null_addr, + ODPH_ETHADDR_LEN) || + !memcmp(eth->src.addr, null_addr, + ODPH_ETHADDR_LEN))) { + return FRAME_INVALID; + } + if (!memcmp(eth->dst.addr, broadcast_addr, ODPH_ETHADDR_LEN)) + return FRAME_BROADCAST; + + return FRAME_UNICAST; +} + /** * Forward packets to correct output buffers * @@ -520,23 +554,33 @@ static inline void forward_packets(odp_packet_t pkt_tbl[], unsigned int num, unsigned int i; unsigned int buf_id; uint8_t port_out = 0; + int frame_type; for (i = 0; i < num; i++) { pkt = pkt_tbl[i]; if (!odp_packet_has_eth(pkt)) { + thr_arg->stats[port_in]->s.rx_drops++; odp_packet_free(pkt); continue; } eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL); + /* Check Ethernet frame type */ + frame_type = check_frame(eth); + if (odp_unlikely(frame_type == FRAME_INVALID)) { + thr_arg->stats[port_in]->s.rx_drops++; + odp_packet_free(pkt); + continue; + } + /* Update source address MAC table entry */ mac_table_update(&eth->src, port_in, cur_tick); - /* Lookup destination MAC address */ - if (!mac_table_get(&eth->dst, &port_out, cur_tick)) { - /* If address was not found, broadcast packet */ + /* Broadcast frame is necessary */ + if (frame_type == FRAME_BROADCAST || + !mac_table_get(&eth->dst, &port_out, cur_tick)) { broadcast_packet(pkt, thr_arg, port_in); continue; } commit 42c37a8506151debd9be885d055b2c4dc8a93c1c Author: Matias Elo <matias.elo(a)nokia.com> Date: Tue Jan 28 16:22:53 2020 +0200 example: switch: print packet drop statistics Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/example/switch/odp_switch.c b/example/switch/odp_switch.c index 07fd9eb77..a31a19cd8 100644 --- a/example/switch/odp_switch.c +++ b/example/switch/odp_switch.c @@ -346,6 +346,8 @@ static int print_speed_stats(int num_workers, stats_t (*thr_stats)[MAX_PKTIOS], uint64_t tx_pkts_prev[MAX_PKTIOS] = {0}; uint64_t rx_pkts_tot; uint64_t tx_pkts_tot; + uint64_t rx_drops_tot; + uint64_t tx_drops_tot; uint64_t rx_pps; uint64_t tx_pps; int i, j; @@ -364,11 +366,13 @@ static int print_speed_stats(int num_workers, stats_t (*thr_stats)[MAX_PKTIOS], do { uint64_t rx_pkts[MAX_PKTIOS] = {0}; uint64_t tx_pkts[MAX_PKTIOS] = {0}; - uint64_t rx_drops = 0; - uint64_t tx_drops = 0; + uint64_t rx_drops[MAX_PKTIOS] = {0}; + uint64_t tx_drops[MAX_PKTIOS] = {0}; rx_pkts_tot = 0; tx_pkts_tot = 0; + rx_drops_tot = 0; + tx_drops_tot = 0; sleep(timeout); elapsed += timeout; @@ -377,8 +381,8 @@ static int print_speed_stats(int num_workers, stats_t (*thr_stats)[MAX_PKTIOS], for (j = 0; j < num_ifaces; j++) { rx_pkts[j] += thr_stats[i][j].s.rx_packets; tx_pkts[j] += thr_stats[i][j].s.tx_packets; - rx_drops += thr_stats[i][j].s.rx_drops; - tx_drops += thr_stats[i][j].s.tx_drops; + rx_drops[j] += thr_stats[i][j].s.rx_drops; + tx_drops[j] += thr_stats[i][j].s.tx_drops; } } @@ -390,18 +394,21 @@ static int print_speed_stats(int num_workers, stats_t (*thr_stats)[MAX_PKTIOS], tx_pps = (tx_pkts[j] - tx_pkts_prev[j]) / timeout; printf(" Port %d: %" PRIu64 " rx pps, %" PRIu64 " tx pps, %" PRIu64 " rx pkts, %" PRIu64 - " tx pkts\n", j, rx_pps, tx_pps, rx_pkts[j], - tx_pkts[j]); + " tx pkts, %" PRIu64 " rx drops, %" PRIu64 + " tx drops\n", j, rx_pps, tx_pps, rx_pkts[j], + tx_pkts[j], rx_drops[j], tx_drops[j]); rx_pkts_prev[j] = rx_pkts[j]; tx_pkts_prev[j] = tx_pkts[j]; rx_pkts_tot += rx_pkts[j]; tx_pkts_tot += tx_pkts[j]; + rx_drops_tot += rx_drops[j]; + tx_drops_tot += tx_drops[j]; } printf("Total: %" PRIu64 " rx pkts, %" PRIu64 " tx pkts, %" PRIu64 " rx drops, %" PRIu64 " tx drops\n", rx_pkts_tot, - tx_pkts_tot, rx_drops, tx_drops); + tx_pkts_tot, rx_drops_tot, tx_drops_tot); } while (loop_forever || (elapsed < duration)); commit 8c6880ee093af5ed6bf2af54a1acadc7b2ba895f Author: Matias Elo <matias.elo(a)nokia.com> Date: Mon Jan 27 17:10:14 2020 +0200 example: switch: add 5 minute aging time to mac table entries Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/example/switch/odp_switch.c b/example/switch/odp_switch.c index b73d8a50c..07fd9eb77 100644 --- a/example/switch/odp_switch.c +++ b/example/switch/odp_switch.c @@ -1,4 +1,5 @@ /* Copyright (c) 2016-2018, Linaro Limited + * Copyright (c) 2020, Nokia * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -34,6 +35,9 @@ /** Number of MAC table entries. Must match to hash length. */ #define MAC_TBL_SIZE UINT16_MAX +/** Aging time for MAC table entries in minutes. Must be <= UINT8_MAX. */ +#define AGING_TIME 5 + /** Get rid of path in filename - only for unix-type paths using '/' */ #define NO_PATH(file_name) (strrchr((file_name), '/') ? \ strrchr((file_name), '/') + 1 : (file_name)) @@ -43,6 +47,7 @@ typedef union { struct { odph_ethaddr_t mac; /**< Ethernet MAC address */ uint8_t port; /**< Port index */ + uint8_t tick; /**< Tick of the latest received packet */ } s; uint64_t u64; @@ -154,16 +159,30 @@ static inline uint16_t calc_mac_tbl_idx(odph_ethaddr_t *mac) return (uint16_t)(hash & 0xFFFF); } +/** + * Calculate diff between ticks and take care of value wrap + */ +static inline uint8_t diff_ticks(uint8_t t2, uint8_t t1) +{ + if (t1 < t2) + return t2 - t1; + else if (t1 > t2) + return UINT8_MAX + t2 - t1; + return 0; +} + /** * Get Ethernet address port index from MAC table * * @param mac Pointer to Ethernet address * @param port[out] Pointer to port index for output + * @param cur_tick Current tick * - * @retval 0 on success - * @retval -1 on failure + * @retval 1 on entry found + * @retval 0 on entry not found or expired */ -static inline int mac_table_get(odph_ethaddr_t *mac, uint8_t *port) +static inline int mac_table_get(odph_ethaddr_t *mac, uint8_t *port, + uint8_t cur_tick) { mac_tbl_entry_t entry; uint16_t idx; @@ -173,10 +192,13 @@ static inline int mac_table_get(odph_ethaddr_t *mac, uint8_t *port) entry.u64 = odp_atomic_load_u64(&gbl_args->mac_tbl[idx]); if (memcmp(mac->addr, entry.s.mac.addr, ODPH_ETHADDR_LEN)) - return -1; + return 0; + + if (odp_unlikely(diff_ticks(cur_tick, entry.s.tick) > AGING_TIME)) + return 0; *port = entry.s.port; - return 0; + return 1; } /** @@ -184,18 +206,24 @@ static inline int mac_table_get(odph_ethaddr_t *mac, uint8_t *port) * * @param mac Pointer to Ethernet address * @param port Pointer to port index + * @param cur_tick Current tick */ -static inline void mac_table_put(odph_ethaddr_t *mac, uint8_t port) +static inline void mac_table_update(odph_ethaddr_t *mac, uint8_t port, + uint8_t cur_tick) { mac_tbl_entry_t entry; uint16_t idx; idx = calc_mac_tbl_idx(mac); + entry.u64 = odp_atomic_load_u64(&gbl_args->mac_tbl[idx]); - entry.s.mac = *mac; - entry.s.port = port; - - odp_atomic_store_u64(&gbl_args->mac_tbl[idx], entry.u64); + if (memcmp(entry.s.mac.addr, mac->addr, ODPH_ETHADDR_LEN) || + entry.s.port != port || entry.s.tick != cur_tick) { + entry.s.mac = *mac; + entry.s.port = port; + entry.s.tick = cur_tick; + odp_atomic_store_u64(&gbl_args->mac_tbl[idx], entry.u64); + } } /** @@ -474,15 +502,16 @@ static inline void broadcast_packet(odp_packet_t pkt, thread_args_t *thr_arg, * @param num Number of packets in the array * @param thr_arg Thread arguments * @param port_in Input port index + * @param cur_tick Current tick */ static inline void forward_packets(odp_packet_t pkt_tbl[], unsigned int num, - thread_args_t *thr_arg, uint8_t port_in) + thread_args_t *thr_arg, uint8_t port_in, + uint8_t cur_tick) { odp_packet_t pkt; odph_ethhdr_t *eth; unsigned int i; unsigned int buf_id; - int ret; uint8_t port_out = 0; for (i = 0; i < num; i++) { @@ -495,16 +524,11 @@ static inline void forward_packets(odp_packet_t pkt_tbl[], unsigned int num, eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL); - /* Lookup source MAC address */ - ret = mac_table_get(&eth->src, &port_out); - - /* Update for address table if necessary */ - if (ret < 0 || port_out != port_in) - mac_table_put(&eth->src, port_in); + /* Update source address MAC table entry */ + mac_table_update(&eth->src, port_in, cur_tick); /* Lookup destination MAC address */ - ret = mac_table_get(&eth->dst, &port_out); - if (ret < 0) { + if (!mac_table_get(&eth->dst, &port_out, cur_tick)) { /* If address was not found, broadcast packet */ broadcast_packet(pkt, thr_arg, port_in); continue; @@ -583,6 +607,9 @@ static int run_worker(void *arg) odp_packet_t pkt_tbl[MAX_PKT_BURST]; odp_pktin_queue_t pktin; odp_pktout_queue_t pktout; + odp_time_t time_prev; + odp_time_t minute; + uint8_t cur_tick; unsigned int num_pktio; unsigned int pktio = 0; uint8_t port_in; @@ -595,7 +622,13 @@ static int run_worker(void *arg) odp_barrier_wait(&gbl_args->barrier); + minute = odp_time_local_from_ns(ODP_TIME_MIN_IN_NS); + time_prev = odp_time_local(); + cur_tick = (odp_time_to_ns(time_prev) / ODP_TIME_MIN_IN_NS) % UINT8_MAX; + while (!gbl_args->exit_threads) { + odp_time_t time_cur; + odp_time_t time_diff; int sent; unsigned int drops; @@ -611,10 +644,20 @@ static int run_worker(void *arg) if (odp_unlikely(pkts <= 0)) continue; + time_cur = odp_time_local(); + time_diff = odp_time_diff(time_cur, time_prev); + + if (odp_unlikely(odp_time_cmp(time_diff, minute))) { + /* Tick stored as 8 bit value */ + cur_tick = (odp_time_to_ns(time_cur) / + ODP_TIME_MIN_IN_NS) % UINT8_MAX; + time_prev = time_cur; + } + thr_args->stats[port_in]->s.rx_packets += pkts; /* Sort packets to thread local tx buffers */ - forward_packets(pkt_tbl, pkts, thr_args, port_in); + forward_packets(pkt_tbl, pkts, thr_args, port_in, cur_tick); /* Empty all thread local tx buffers */ for (port_out = 0; port_out < gbl_args->appl.if_count; commit 321e53c0405ab300585ad66693a24942eefef62b Author: Matias Elo <matias.elo(a)nokia.com> Date: Tue Jan 28 13:25:18 2020 +0200 test: sched_latency: increase number of scheduling rounds Increase the default number of scheduling rounds to 100M. The number of scheduling rounds can now be configured with '-d' command line option. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/test/performance/odp_sched_latency.c b/test/performance/odp_sched_latency.c index 7bb31e77c..c726074c5 100644 --- a/test/performance/odp_sched_latency.c +++ b/test/performance/odp_sched_latency.c @@ -26,8 +26,8 @@ #define MAX_QUEUES 4096 /**< Maximum number of queues */ #define EVENT_POOL_SIZE (1024 * 1024) /**< Event pool size */ -#define TEST_ROUNDS (4 * 1024 * 1024) /**< Test rounds for each thread */ -#define MAIN_THREAD 1 /**< Thread ID performing maintenance tasks */ +#define TEST_ROUNDS 10 /**< Test rounds for each thread (millions) */ +#define MAIN_THREAD 1 /**< Thread ID performing maintenance tasks */ /* Default values for command line arguments */ #define SAMPLE_EVENT_PER_PRIO 0 /**< Allocate a separate sample event for @@ -75,6 +75,7 @@ typedef struct { typedef struct { unsigned int cpu_count; /**< CPU count */ odp_schedule_sync_t sync_type; /**< Scheduler sync type */ + int test_rounds; /**< Number of test rounds (millions) */ int warm_up_rounds; /**< Number of warm-up rounds */ struct { int queues; /**< Number of scheduling queues */ @@ -334,7 +335,7 @@ static void print_results(test_globals_t *globals) /** * Measure latency of scheduled ODP events * - * Schedule and enqueue events until 'TEST_ROUNDS' events have been processed. + * Schedule and enqueue events until 'test_rounds' events have been processed. * Scheduling latency is measured only from type 'SAMPLE' events. Other events * are simply enqueued back to the scheduling queues. * @@ -360,12 +361,13 @@ static int test_schedule(int thr, test_globals_t *globals) test_stat_t *stats; int dst_idx; int warm_up_rounds = globals->args.warm_up_rounds; + uint64_t test_rounds = globals->args.test_rounds * 1000000; memset(&globals->core_stat[thr], 0, sizeof(core_stat_t)); globals->core_stat[thr].prio[HI_PRIO].min = UINT64_MAX; globals->core_stat[thr].prio[LO_PRIO].min = UINT64_MAX; - for (i = 0; i < TEST_ROUNDS; i++) { + for (i = 0; i < test_rounds; i++) { ev = odp_schedule(&src_queue, ODP_SCHED_WAIT); buf = odp_buffer_from_event(ev); @@ -505,6 +507,7 @@ static void usage(void) "Usage: ./odp_sched_latency [options]\n" "Optional OPTIONS:\n" " -c, --count <number> CPU count, 0=all available, default=1\n" + " -d, --duration <number> Test duration in scheduling rounds (millions), default=%d, min=1\n" " -l, --lo-prio-queues <number> Number of low priority scheduled queues\n" " -t, --hi-prio-queues <number> Number of high priority scheduled queues\n" " -m, --lo-prio-events-per-queue <number> Number of events per low priority queue\n" @@ -522,7 +525,7 @@ static void usage(void) " 2: ODP_SCHED_SYNC_ORDERED\n" " -w, --warm-up <number> Number of warm-up rounds, default=%d, min=1\n" " -h, --help Display help and exit.\n\n" - , WARM_UP_ROUNDS); + , TEST_ROUNDS, WARM_UP_ROUNDS); } /** @@ -553,9 +556,10 @@ static void parse_args(int argc, char *argv[], test_args_t *args) {NULL, 0, NULL, 0} }; - static const char *shortopts = "+c:s:l:t:m:n:o:p:rw:h"; + static const char *shortopts = "+c:d:s:l:t:m:n:o:p:rw:h"; args->cpu_count = 1; + args->test_rounds = TEST_ROUNDS; args->warm_up_rounds = WARM_UP_ROUNDS; args->sync_type = ODP_SCHED_SYNC_PARALLEL; args->sample_per_prio = SAMPLE_EVENT_PER_PRIO; @@ -576,6 +580,9 @@ static void parse_args(int argc, char *argv[], test_args_t *args) case 'c': args->cpu_count = atoi(optarg); break; + case 'd': + args->test_rounds = atoi(optarg); + break; case 'l': args->prio[LO_PRIO].queues = atoi(optarg); break; @@ -631,6 +638,8 @@ static void parse_args(int argc, char *argv[], test_args_t *args) args->prio[LO_PRIO].queues = MAX_QUEUES; if (args->prio[HI_PRIO].queues > MAX_QUEUES) args->prio[HI_PRIO].queues = MAX_QUEUES; + if (args->test_rounds < 1) + args->test_rounds = 1; if (!args->prio[HI_PRIO].queues && !args->prio[LO_PRIO].queues) { printf("No queues configured\n"); usage(); commit 90103b8a5dd627b8680e2fd7ff8380e6a4707ced Author: Matias Elo <matias.elo(a)nokia.com> Date: Tue Jan 28 11:30:14 2020 +0200 test: sched_latency: increase number of warm-up rounds Increase the default number of warm-up rounds to 100 to avoid possible extra latency caused by scheduler startup. The number of warm-up rounds can now be configured with '-w' command line option. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> diff --git a/test/performance/odp_sched_latency.c b/test/performance/odp_sched_latency.c index 2bdc4b356..7bb31e77c 100644 --- a/test/performance/odp_sched_latency.c +++ b/test/performance/odp_sched_latency.c @@ -1,4 +1,5 @@ /* Copyright (c) 2016-2018, Linaro Limited + * Copyright (c) 2020, Nokia * All rights reserved. * * SPDX-License-Identifier: BSD-3-Clause @@ -35,6 +36,7 @@ #define LO_PRIO_EVENTS 32 /**< Number of low priority events */ #define HI_PRIO_QUEUES 16 /**< Number of high priority queues */ #define LO_PRIO_QUEUES 64 /**< Number of low priority queues */ +#define WARM_UP_ROUNDS 100 /**< Number of warm-up rounds */ #define EVENTS_PER_HI_PRIO_QUEUE 0 /**< Alloc HI_PRIO_QUEUES x HI_PRIO_EVENTS events */ @@ -54,7 +56,7 @@ ODP_STATIC_ASSERT(LO_PRIO_QUEUES <= MAX_QUEUES, "Too many LO priority queues"); /** Test event types */ typedef enum { - WARM_UP, /**< Warm up event */ + WARM_UP, /**< Warm-up event */ COOL_DOWN,/**< Last event on queue */ TRAFFIC, /**< Event used only as traffic load */ SAMPLE /**< Event used to measure latency */ @@ -66,12 +68,14 @@ typedef struct { event_type_t type; /**< Message type */ int src_idx[NUM_PRIOS]; /**< Source ODP queue */ int prio; /**< Source queue priority */ + int warm_up_rounds; /**< Number of completed warm-up rounds */ } test_event_t; /** Test arguments */ typedef struct { unsigned int cpu_count; /**< CPU count */ odp_schedule_sync_t sync_type; /**< Scheduler sync type */ + int warm_up_rounds; /**< Number of warm-up rounds */ struct { int queues; /**< Number of scheduling queues */ int events; /**< Number of events */ @@ -218,9 +222,10 @@ static int enqueue_events(int prio, int num_queues, int num_events, memset(event, 0, sizeof(test_event_t)); /* Latency isn't measured from the first processing - * round. */ + * rounds. */ if (num_samples > 0) { event->type = WARM_UP; + event->warm_up_rounds = 0; num_samples--; } else { event->type = TRAFFIC; @@ -354,6 +359,7 @@ static int test_schedule(int thr, test_globals_t *globals) test_event_t *event; test_stat_t *stats; int dst_idx; + int warm_up_rounds = globals->args.warm_up_rounds; memset(&globals->core_stat[thr], 0, sizeof(core_stat_t)); globals->core_stat[thr].prio[HI_PRIO].min = UINT64_MAX; @@ -383,10 +389,13 @@ static int test_schedule(int thr, test_globals_t *globals) event->prio = !event->prio; } - if (odp_unlikely(event->type == WARM_UP)) - event->type = SAMPLE; - else + if (odp_unlikely(event->type == WARM_UP)) { + event->warm_up_rounds++; + if (event->warm_up_rounds >= warm_up_rounds) + event->type = SAMPLE; + } else { stats->events++; + } /* Move event to next queue */ dst_idx = event->src_idx[event->prio] + 1; @@ -511,8 +520,9 @@ static void usage(void) " 0: ODP_SCHED_SYNC_PARALLEL (default)\n" " 1: ODP_SCHED_SYNC_ATOMIC\n" " 2: ODP_SCHED_SYNC_ORDERED\n" + " -w, --warm-up <number> Number of warm-up rounds, default=%d, min=1\n" " -h, --help Display help and exit.\n\n" - ); + , WARM_UP_ROUNDS); } /** @@ -538,13 +548,15 @@ static void parse_args(int argc, char *argv[], test_args_t *args) {"hi-prio-events", required_argument, NULL, 'p'}, {"sample-per-prio", no_argument, NULL, 'r'}, {"sync", required_argument, NULL, 's'}, + {"warm-up", required_argument, NULL, 'w'}, {"help", no_argument, NULL, 'h'}, {NULL, 0, NULL, 0} }; - static const char *shortopts = "+c:s:l:t:m:n:o:p:rh"; + static const char *shortopts = "+c:s:l:t:m:n:o:p:rw:h"; args->cpu_count = 1; + args->warm_up_rounds = WARM_UP_ROUNDS; args->sync_type = ODP_SCHED_SYNC_PARALLEL; args->sample_per_prio = SAMPLE_EVENT_PER_PRIO; args->prio[LO_PRIO].queues = LO_PRIO_QUEUES; @@ -598,6 +610,9 @@ static void parse_args(int argc, char *argv[], test_args_t *args) case 'r': args->sample_per_prio = 1; break; + case 'w': + args->warm_up_rounds = atoi(optarg); + break; case 'h': usage(); exit(EXIT_SUCCESS); ----------------------------------------------------------------------- Summary of changes: example/switch/odp_switch.c | 166 ++++++++++++++++++++++++++++------- test/performance/odp_sched_latency.c | 46 +++++++--- test/validation/api/packet/packet.c | 4 +- 3 files changed, 172 insertions(+), 44 deletions(-) hooks/post-receive --

6 years

[COMMIT] branch master updated. v1.21.0.0-411-gc9f7b34c7

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 c9f7b34c7f0a4cadfabbd6733e3420a8adb8c322 (commit) via 3125f0621c170b5bd3b5f4e48d2c90c7d3d438b2 (commit) via a072a42095fdd2d7b85343007e34bc424bcf5032 (commit) via f6cb2b6f9cd9c0218ec564f75a0cda543a4477ba (commit) via 4de501a5867b93394215b44d3df0e5488c256199 (commit) via b3812d61817aadb18f989fa864481dec53d4570e (commit) via 2e19fc517ec1c1c72d995d1a9c8abc56335e45c2 (commit) from 29c9a342c4cbc4cc92686e6f324fe258afae6b9a (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 c9f7b34c7f0a4cadfabbd6733e3420a8adb8c322 Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Mon Jan 20 15:30:38 2020 +0200 api: increase version number to 1.23.3 Incremented minor version number to reflect packet length clarifications and addition of packet pool align parameter. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-by: Stanislaw Kardach <skardach(a)marvell.com> diff --git a/configure.ac b/configure.ac index c715e4358..82e197956 100644 --- a/configure.ac +++ b/configure.ac @@ -4,7 +4,7 @@ AC_PREREQ([2.5]) ########################################################################## m4_define([odpapi_generation_version], [1]) m4_define([odpapi_major_version], [23]) -m4_define([odpapi_minor_version], [2]) +m4_define([odpapi_minor_version], [3]) m4_define([odpapi_point_version], [0]) m4_define([odpapi_version], [odpapi_generation_version.odpapi_major_version.odpapi_minor_version.odpapi_point_version]) commit 3125f0621c170b5bd3b5f4e48d2c90c7d3d438b2 Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Fri Jan 10 14:06:35 2020 +0200 validation: packet: add packet alloc align test Added test case for the new packet align parameter. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-by: Stanislaw Kardach <skardach(a)marvell.com> diff --git a/test/validation/api/packet/packet.c b/test/validation/api/packet/packet.c index 90226819c..6f020d820 100644 --- a/test/validation/api/packet/packet.c +++ b/test/validation/api/packet/packet.c @@ -544,6 +544,57 @@ static void packet_test_alloc_segmented(void) CU_ASSERT(odp_pool_destroy(pool) == 0); } +static void packet_test_alloc_align(void) +{ + odp_pool_t pool; + odp_pool_param_t params; + uintptr_t data, mask; + uint32_t i; + uint32_t error_print = 10; + uint32_t len = packet_len; + uint32_t align = 256; + uint32_t num = 100; + odp_packet_t pkt[num]; + + CU_ASSERT(pool_capa.pkt.max_align >= 2); + + if (align > pool_capa.pkt.max_align) + align = pool_capa.pkt.max_align; + + mask = align - 1; + + odp_pool_param_init(&params); + + params.type = ODP_POOL_PACKET; + params.pkt.len = len; + params.pkt.num = num; + params.pkt.align = align; + + pool = odp_pool_create("packet_pool_align", &params); + CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); + + /* Allocate the only buffer from the pool */ + for (i = 0; i < num; i++) { + pkt[i] = odp_packet_alloc(pool, len); + CU_ASSERT_FATAL(pkt[i] != ODP_PACKET_INVALID); + CU_ASSERT(odp_packet_len(pkt[i]) == len); + data = (uintptr_t)odp_packet_data(pkt[i]); + + if (data & mask) { + /* Print only first couple of failures to the log */ + if (error_print > 0) { + CU_ASSERT((data & mask) == 0); + printf("\nError: Bad data align. Pointer %p, requested align %u\n", + (void *)data, align); + error_print--; + } + } + } + + odp_packet_free_multi(pkt, num); + CU_ASSERT(odp_pool_destroy(pool) == 0); +} + static void packet_test_event_conversion(void) { odp_packet_t pkt0 = test_packet; @@ -3530,6 +3581,7 @@ odp_testinfo_t packet_suite[] = { ODP_TEST_INFO(packet_test_alloc_free_multi), ODP_TEST_INFO(packet_test_free_sp), ODP_TEST_INFO(packet_test_alloc_segmented), + ODP_TEST_INFO(packet_test_alloc_align), ODP_TEST_INFO(packet_test_basic_metadata), ODP_TEST_INFO(packet_test_debug), ODP_TEST_INFO(packet_test_segments), commit a072a42095fdd2d7b85343007e34bc424bcf5032 Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Fri Jan 10 13:39:38 2020 +0200 linux-gen: pool: set packet pool max align capa Implement the new packet align pool parameter with minimal changes. Packet pools are aligned always to the base align, so all application requests up to that value are supported. Base align can be changed through the config file. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-by: Stanislaw Kardach <skardach(a)marvell.com> diff --git a/config/odp-linux-generic.conf b/config/odp-linux-generic.conf index 5a3ca72ff..b1f0e9009 100644 --- a/config/odp-linux-generic.conf +++ b/config/odp-linux-generic.conf @@ -62,7 +62,8 @@ pool: { max_num = 262143 # Base alignment for segment data. When set to zero, - # cache line size is used. Use power of two values. + # cache line size is used. Use power of two values. This is + # also the maximum value for the packet pool alignment param. base_align = 0 } diff --git a/platform/linux-generic/odp_pool.c b/platform/linux-generic/odp_pool.c index 5d5217aaf..e1964f840 100644 --- a/platform/linux-generic/odp_pool.c +++ b/platform/linux-generic/odp_pool.c @@ -503,6 +503,15 @@ static odp_pool_t pool_create(const char *name, odp_pool_param_t *params, align = 0; if (params->type == ODP_POOL_PACKET) { + uint32_t align_req = params->pkt.align; + + if (align_req && + (!CHECK_IS_POWER2(align_req) || + align_req > _odp_pool_glb->config.pkt_base_align)) { + ODP_ERR("Bad align requirement\n"); + return ODP_POOL_INVALID; + } + align = _odp_pool_glb->config.pkt_base_align; } else { if (params->type == ODP_POOL_BUFFER) @@ -1106,6 +1115,7 @@ int odp_pool_capability(odp_pool_capability_t *capa) capa->pkt.max_pools = max_pools; capa->pkt.max_len = CONFIG_PACKET_MAX_LEN; capa->pkt.max_num = _odp_pool_glb->config.pkt_max_num; + capa->pkt.max_align = _odp_pool_glb->config.pkt_base_align; capa->pkt.min_headroom = CONFIG_PACKET_HEADROOM; capa->pkt.max_headroom = CONFIG_PACKET_HEADROOM; capa->pkt.min_tailroom = CONFIG_PACKET_TAILROOM; commit f6cb2b6f9cd9c0218ec564f75a0cda543a4477ba Author: Petri Savolainen <petri.savolainen(a)nokia.com> Date: Fri Jan 10 10:56:22 2020 +0200 api: pool: add packet data align parameter Added packet pool parameter to request minimum data alignment for user allocated packets. When user allocates a new packet and fills in protocol headers, it's convenient that data alignment does not need to be checked (and tuned) on each allocated packet. Signed-off-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-by: Stanislaw Kardach <skardach(a)marvell.com> diff --git a/include/odp/api/spec/pool.h b/include/odp/api/spec/pool.h index 69e99605c..754e2cc04 100644 --- a/include/odp/api/spec/pool.h +++ b/include/odp/api/spec/pool.h @@ -92,6 +92,12 @@ typedef struct odp_pool_capability_t { * memory size for the pool. */ uint32_t max_num; + /** Maximum packet data alignment in bytes + * + * This is the maximum value of packet pool alignment + * (pkt.align) parameter. */ + uint32_t max_align; + /** Minimum packet level headroom length in bytes * * The minimum number of headroom bytes that newly created @@ -248,6 +254,19 @@ typedef struct odp_pool_param_t { */ uint32_t max_len; + /** Minimum packet data alignment in bytes. + * + * Valid values are powers of two. User allocated packets have + * start of data (@see odp_packet_data()) aligned to this or + * a higher alignment (power of two value). This parameter + * does not apply to packets that ODP allocates internally + * (e.g. packets from packet input). + * + * The maximum value is defined by pool capability + * pkt.max_align. Use 0 for default alignment. + */ + uint32_t align; + /** Minimum number of packet data bytes that are stored in the * first segment of a packet. The maximum value is defined by * pool capability pkt.max_seg_len. Use 0 for default. commit 4de501a5867b93394215b44d3df0e5488c256199 Author: Matias Elo <matias.elo(a)nokia.com> Date: Tue Jan 14 17:00:56 2020 +0200 linux-gen: packet: don't allow creating zero length packets Packet API forbids creating zero length packets. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reported-by: Carl Wallen <carl.wallen(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-by: Stanislaw Kardach <skardach(a)marvell.com> diff --git a/platform/linux-generic/odp_packet.c b/platform/linux-generic/odp_packet.c index 9e3f3a2b8..430839be6 100644 --- a/platform/linux-generic/odp_packet.c +++ b/platform/linux-generic/odp_packet.c @@ -686,7 +686,7 @@ odp_packet_t odp_packet_alloc(odp_pool_t pool_hdl, uint32_t len) return ODP_PACKET_INVALID; } - if (odp_unlikely(len > pool->max_len)) + if (odp_unlikely(len > pool->max_len || len == 0)) return ODP_PACKET_INVALID; num_seg = num_segments(len, pool->seg_len); @@ -709,7 +709,7 @@ int odp_packet_alloc_multi(odp_pool_t pool_hdl, uint32_t len, return -1; } - if (odp_unlikely(len > pool->max_len)) + if (odp_unlikely(len > pool->max_len || len == 0)) return -1; num_seg = num_segments(len, pool->seg_len); @@ -771,7 +771,7 @@ int odp_packet_reset(odp_packet_t pkt, uint32_t len) int num = pkt_hdr->seg_count; int num_req; - if (odp_unlikely(len > (pool->seg_len * num))) + if (odp_unlikely(len > (pool->seg_len * num)) || len == 0) return -1; /* Free possible extra segments */ @@ -887,7 +887,7 @@ void *odp_packet_pull_head(odp_packet_t pkt, uint32_t len) { odp_packet_hdr_t *pkt_hdr = packet_hdr(pkt); - if (len > pkt_hdr->frame_len) + if (len >= pkt_hdr->seg_len) return NULL; pull_head(pkt_hdr, len); @@ -900,7 +900,7 @@ int odp_packet_trunc_head(odp_packet_t *pkt, uint32_t len, odp_packet_hdr_t *pkt_hdr = packet_hdr(*pkt); uint32_t seg_len = packet_first_seg_len(pkt_hdr); - if (len > pkt_hdr->frame_len) + if (len >= pkt_hdr->frame_len) return -1; if (len < seg_len) { @@ -993,7 +993,7 @@ void *odp_packet_pull_tail(odp_packet_t pkt, uint32_t len) ODP_ASSERT(odp_packet_has_ref(pkt) == 0); - if (len > last_seg->seg_len) + if (len >= last_seg->seg_len) return NULL; pull_tail(pkt_hdr, len); @@ -1009,7 +1009,7 @@ int odp_packet_trunc_tail(odp_packet_t *pkt, uint32_t len, odp_packet_hdr_t *last_seg; odp_packet_hdr_t *pkt_hdr = packet_hdr(*pkt); - if (len > pkt_hdr->frame_len) + if (len >= pkt_hdr->frame_len) return -1; ODP_ASSERT(odp_packet_has_ref(*pkt) == 0); @@ -1234,7 +1234,7 @@ int odp_packet_rem_data(odp_packet_t *pkt_ptr, uint32_t offset, uint32_t len) pool_t *pool = pkt_hdr->buf_hdr.pool_ptr; odp_packet_t newpkt; - if (offset > pktlen || offset + len > pktlen) + if (offset + len >= pktlen) return -1; newpkt = odp_packet_alloc(pool->pool_hdl, pktlen - len); commit b3812d61817aadb18f989fa864481dec53d4570e Author: Matias Elo <matias.elo(a)nokia.com> Date: Wed Jan 15 16:52:07 2020 +0200 validation: ipsec: don't allocate zero length test packet Allocating packets of length zero is not allowed by the packet API. Also, fix some typos and abort tests after a failed test packet allocation to prevent a seg fault. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-by: Stanislaw Kardach <skardach(a)marvell.com> diff --git a/test/validation/api/ipsec/ipsec.c b/test/validation/api/ipsec/ipsec.c index 705fbbabf..5b60fd888 100644 --- a/test/validation/api/ipsec/ipsec.c +++ b/test/validation/api/ipsec/ipsec.c @@ -429,7 +429,7 @@ odp_packet_t ipsec_packet(const ipsec_test_packet *itp) { odp_packet_t pkt = odp_packet_alloc(suite_context.pool, itp->len); - CU_ASSERT_NOT_EQUAL(ODP_PACKET_INVALID, pkt); + CU_ASSERT_NOT_EQUAL_FATAL(ODP_PACKET_INVALID, pkt); if (ODP_PACKET_INVALID == pkt) return pkt; diff --git a/test/validation/api/ipsec/ipsec_test_out.c b/test/validation/api/ipsec/ipsec_test_out.c index 0bfb9cff8..6cdbb72f4 100644 --- a/test/validation/api/ipsec/ipsec_test_out.c +++ b/test/validation/api/ipsec/ipsec_test_out.c @@ -1036,7 +1036,7 @@ static void test_out_dummy_esp_null_sha256_tun_ipv4(void) test.out[0].l3_type = ODP_PROTO_L3_TYPE_IPV4; test.out[0].l4_type = ODP_PROTO_L4_TYPE_NO_NEXT; - test_empty.pkt_in = &pkt_test_emtpy; + test_empty.pkt_in = &pkt_test_empty; test_empty.num_opt = 1; test_empty.opt.flag.tfc_dummy = 1; test_empty.opt.tfc_pad_len = 16; @@ -1110,7 +1110,7 @@ static void test_out_dummy_esp_null_sha256_tun_ipv6(void) test.out[0].l3_type = ODP_PROTO_L3_TYPE_IPV4; test.out[0].l4_type = ODP_PROTO_L4_TYPE_NO_NEXT; - test_empty.pkt_in = &pkt_test_emtpy; + test_empty.pkt_in = &pkt_test_empty; test_empty.num_opt = 1; test_empty.opt.flag.tfc_dummy = 1; test_empty.opt.tfc_pad_len = 16; diff --git a/test/validation/api/ipsec/test_vectors.h b/test/validation/api/ipsec/test_vectors.h index 289b8008c..e9b8634f2 100644 --- a/test/validation/api/ipsec/test_vectors.h +++ b/test/validation/api/ipsec/test_vectors.h @@ -1865,8 +1865,8 @@ static const ODP_UNUSED ipsec_test_packet }, }; -static const ipsec_test_packet pkt_test_emtpy = { - .len = 0, +static const ipsec_test_packet pkt_test_empty = { + .len = 1, .l2_offset = ODP_PACKET_OFFSET_INVALID, .l3_offset = ODP_PACKET_OFFSET_INVALID, .l4_offset = ODP_PACKET_OFFSET_INVALID, commit 2e19fc517ec1c1c72d995d1a9c8abc56335e45c2 Author: Matias Elo <matias.elo(a)nokia.com> Date: Wed Jan 15 12:16:12 2020 +0200 api: packet: clarify packet length function argument definitions Modify documentations of functions, which decrease packet length, to clearly state what are the allowed values for length argument. This is done to avoid creating zero length packets which are not allowed by the packet API. Signed-off-by: Matias Elo <matias.elo(a)nokia.com> Reviewed-by: Petri Savolainen <petri.savolainen(a)nokia.com> Reviewed-by: Stanislaw Kardach <skardach(a)marvell.com> diff --git a/include/odp/api/spec/packet.h b/include/odp/api/spec/packet.h index cbc3c2cbd..ec20371b2 100644 --- a/include/odp/api/spec/packet.h +++ b/include/odp/api/spec/packet.h @@ -318,11 +318,10 @@ void odp_packet_free_sp(const odp_packet_t pkt[], int num); * * Resets all packet metadata to their default values. Packet length is used * to initialize pointers and lengths. It must be less than the total buffer - * length of the packet minus the default headroom length. Packet is not - * modified on failure. + * length of the packet. Packet is not modified on failure. * * @param pkt Packet handle - * @param len Packet data length + * @param len Packet data length (1 ... odp_packet_buf_len()) * * @retval 0 on success * @retval <0 on failure @@ -724,7 +723,8 @@ int odp_packet_extend_head(odp_packet_t *pkt, uint32_t len, void **data_ptr, * * @param[in, out] pkt Pointer to packet handle. A successful operation outputs * the new packet handle. - * @param len Number of bytes to truncate the head (0 ... packet_len) + * @param len Number of bytes to truncate the head + * (0 ... packet_len - 1) * @param[out] data_ptr Pointer to output the new data pointer. * Ignored when NULL. * @param[out] seg_len Pointer to output segment length at 'data_ptr' above. @@ -797,7 +797,8 @@ int odp_packet_extend_tail(odp_packet_t *pkt, uint32_t len, void **data_ptr, * * @param[in, out] pkt Pointer to packet handle. A successful operation outputs * the new packet handle. - * @param len Number of bytes to truncate the tail (0 ... packet_len) + * @param len Number of bytes to truncate the tail + * (0 ... packet_len - 1) * @param[out] tail_ptr Pointer to output the new tail pointer. * Ignored when NULL. * @param[out] tailroom Pointer to output the new tailroom. Ignored when NULL. @@ -861,7 +862,9 @@ int odp_packet_add_data(odp_packet_t *pkt, uint32_t offset, uint32_t len); * @param[in, out] pkt Pointer to packet handle. A successful operation outputs * the new packet handle. * @param offset Byte offset into the packet - * @param len Number of bytes to remove from the offset + * @param len Number of bytes to remove from the offset. When offset + * is zero: 0 ... packet_len - 1 bytes, otherwise + * 0 ... packet_len - offset bytes. * * @retval 0 Operation successful, old pointers remain valid * @retval >0 Operation successful, old pointers need to be updated @@ -1064,6 +1067,7 @@ int odp_packet_concat(odp_packet_t *dst, odp_packet_t src); * @param[in, out] pkt Pointer to packet handle. A successful operation * outputs a new packet handle for the head packet. * @param len Data length remaining in the head packet + * (1 ... packet_len - 1) * @param tail Pointer to output the tail packet handle * * @retval 0 Operation successful, old pointers remain valid ----------------------------------------------------------------------- Summary of changes: config/odp-linux-generic.conf | 3 +- configure.ac | 2 +- include/odp/api/spec/packet.h | 16 +++++---- include/odp/api/spec/pool.h | 19 +++++++++++ platform/linux-generic/odp_packet.c | 16 ++++----- platform/linux-generic/odp_pool.c | 10 ++++++ test/validation/api/ipsec/ipsec.c | 2 +- test/validation/api/ipsec/ipsec_test_out.c | 4 +-- test/validation/api/ipsec/test_vectors.h | 4 +-- test/validation/api/packet/packet.c | 52 ++++++++++++++++++++++++++++++ 10 files changed, 107 insertions(+), 21 deletions(-) hooks/post-receive --

6 years, 1 month

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

git-lng-odp