From patchwork Mon Sep 20 15:01:30 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Dumitrescu X-Patchwork-Id: 99323 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id 6B8BEA0548; Mon, 20 Sep 2021 17:01:40 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id DCD26410E1; Mon, 20 Sep 2021 17:01:39 +0200 (CEST) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by mails.dpdk.org (Postfix) with ESMTP id 878DC40DF5 for ; Mon, 20 Sep 2021 17:01:37 +0200 (CEST) X-IronPort-AV: E=McAfee;i="6200,9189,10113"; a="245557174" X-IronPort-AV: E=Sophos;i="5.85,308,1624345200"; d="scan'208";a="245557174" Received: from orsmga003.jf.intel.com ([10.7.209.27]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Sep 2021 08:01:36 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.85,308,1624345200"; d="scan'208";a="435552153" Received: from silpixa00400573.ir.intel.com (HELO silpixa00400573.ger.corp.intel.com) ([10.237.223.107]) by orsmga003.jf.intel.com with ESMTP; 20 Sep 2021 08:01:34 -0700 From: Cristian Dumitrescu To: dev@dpdk.org Date: Mon, 20 Sep 2021 16:01:30 +0100 Message-Id: <20210920150133.84928-1-cristian.dumitrescu@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20210816122257.84651-1-cristian.dumitrescu@intel.com> References: <20210816122257.84651-1-cristian.dumitrescu@intel.com> Subject: [dpdk-dev] [PATCH V5 1/4] table: add support learner tables X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" A learner table is typically used for learning or connection tracking, where it allows for the implementation of the "add on miss" scenario: whenever the lookup key is not found in the table (lookup miss), the data plane can decide to add this key to the table with a given action with no control plane intervention. Likewise, the table keys expire based on a configurable timeout and are automatically deleted from the table with no control plane intervention. Signed-off-by: Cristian Dumitrescu --- Depends-on: series-18023 ("[V2,1/5] pipeline: prepare for variable size headers") V2: fixed one "line too long" coding style warning. lib/table/meson.build | 2 + lib/table/rte_swx_table_learner.c | 617 ++++++++++++++++++++++++++++++ lib/table/rte_swx_table_learner.h | 206 ++++++++++ lib/table/version.map | 9 + 4 files changed, 834 insertions(+) create mode 100644 lib/table/rte_swx_table_learner.c create mode 100644 lib/table/rte_swx_table_learner.h diff --git a/lib/table/meson.build b/lib/table/meson.build index a1384456a9..ac1f1aac27 100644 --- a/lib/table/meson.build +++ b/lib/table/meson.build @@ -3,6 +3,7 @@ sources = files( 'rte_swx_table_em.c', + 'rte_swx_table_learner.c', 'rte_swx_table_selector.c', 'rte_swx_table_wm.c', 'rte_table_acl.c', @@ -21,6 +22,7 @@ headers = files( 'rte_lru.h', 'rte_swx_table.h', 'rte_swx_table_em.h', + 'rte_swx_table_learner.h', 'rte_swx_table_selector.h', 'rte_swx_table_wm.h', 'rte_table.h', diff --git a/lib/table/rte_swx_table_learner.c b/lib/table/rte_swx_table_learner.c new file mode 100644 index 0000000000..c3c840ff06 --- /dev/null +++ b/lib/table/rte_swx_table_learner.c @@ -0,0 +1,617 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2020 Intel Corporation + */ +#include +#include +#include +#include + +#include +#include +#include + +#include "rte_swx_table_learner.h" + +#ifndef RTE_SWX_TABLE_LEARNER_USE_HUGE_PAGES +#define RTE_SWX_TABLE_LEARNER_USE_HUGE_PAGES 1 +#endif + +#ifndef RTE_SWX_TABLE_SELECTOR_HUGE_PAGES_DISABLE + +#include + +static void * +env_calloc(size_t size, size_t alignment, int numa_node) +{ + return rte_zmalloc_socket(NULL, size, alignment, numa_node); +} + +static void +env_free(void *start, size_t size __rte_unused) +{ + rte_free(start); +} + +#else + +#include + +static void * +env_calloc(size_t size, size_t alignment __rte_unused, int numa_node) +{ + void *start; + + if (numa_available() == -1) + return NULL; + + start = numa_alloc_onnode(size, numa_node); + if (!start) + return NULL; + + memset(start, 0, size); + return start; +} + +static void +env_free(void *start, size_t size) +{ + if ((numa_available() == -1) || !start) + return; + + numa_free(start, size); +} + +#endif + +#if defined(RTE_ARCH_X86_64) + +#include + +#define crc32_u64(crc, v) _mm_crc32_u64(crc, v) + +#else + +static inline uint64_t +crc32_u64_generic(uint64_t crc, uint64_t value) +{ + int i; + + crc = (crc & 0xFFFFFFFFLLU) ^ value; + for (i = 63; i >= 0; i--) { + uint64_t mask; + + mask = -(crc & 1LLU); + crc = (crc >> 1LLU) ^ (0x82F63B78LLU & mask); + } + + return crc; +} + +#define crc32_u64(crc, v) crc32_u64_generic(crc, v) + +#endif + +/* Key size needs to be one of: 8, 16, 32 or 64. */ +static inline uint32_t +hash(void *key, void *key_mask, uint32_t key_size, uint32_t seed) +{ + uint64_t *k = key; + uint64_t *m = key_mask; + uint64_t k0, k2, k5, crc0, crc1, crc2, crc3, crc4, crc5; + + switch (key_size) { + case 8: + crc0 = crc32_u64(seed, k[0] & m[0]); + return crc0; + + case 16: + k0 = k[0] & m[0]; + + crc0 = crc32_u64(k0, seed); + crc1 = crc32_u64(k0 >> 32, k[1] & m[1]); + + crc0 ^= crc1; + + return crc0; + + case 32: + k0 = k[0] & m[0]; + k2 = k[2] & m[2]; + + crc0 = crc32_u64(k0, seed); + crc1 = crc32_u64(k0 >> 32, k[1] & m[1]); + + crc2 = crc32_u64(k2, k[3] & m[3]); + crc3 = k2 >> 32; + + crc0 = crc32_u64(crc0, crc1); + crc1 = crc32_u64(crc2, crc3); + + crc0 ^= crc1; + + return crc0; + + case 64: + k0 = k[0] & m[0]; + k2 = k[2] & m[2]; + k5 = k[5] & m[5]; + + crc0 = crc32_u64(k0, seed); + crc1 = crc32_u64(k0 >> 32, k[1] & m[1]); + + crc2 = crc32_u64(k2, k[3] & m[3]); + crc3 = crc32_u64(k2 >> 32, k[4] & m[4]); + + crc4 = crc32_u64(k5, k[6] & m[6]); + crc5 = crc32_u64(k5 >> 32, k[7] & m[7]); + + crc0 = crc32_u64(crc0, (crc1 << 32) ^ crc2); + crc1 = crc32_u64(crc3, (crc4 << 32) ^ crc5); + + crc0 ^= crc1; + + return crc0; + + default: + crc0 = 0; + return crc0; + } +} + +/* + * Return: 0 = Keys are NOT equal; 1 = Keys are equal. + */ +static inline uint32_t +table_keycmp(void *a, void *b, void *b_mask, uint32_t n_bytes) +{ + uint64_t *a64 = a, *b64 = b, *b_mask64 = b_mask; + + switch (n_bytes) { + case 8: { + uint64_t xor0 = a64[0] ^ (b64[0] & b_mask64[0]); + uint32_t result = 1; + + if (xor0) + result = 0; + return result; + } + + case 16: { + uint64_t xor0 = a64[0] ^ (b64[0] & b_mask64[0]); + uint64_t xor1 = a64[1] ^ (b64[1] & b_mask64[1]); + uint64_t or = xor0 | xor1; + uint32_t result = 1; + + if (or) + result = 0; + return result; + } + + case 32: { + uint64_t xor0 = a64[0] ^ (b64[0] & b_mask64[0]); + uint64_t xor1 = a64[1] ^ (b64[1] & b_mask64[1]); + uint64_t xor2 = a64[2] ^ (b64[2] & b_mask64[2]); + uint64_t xor3 = a64[3] ^ (b64[3] & b_mask64[3]); + uint64_t or = (xor0 | xor1) | (xor2 | xor3); + uint32_t result = 1; + + if (or) + result = 0; + return result; + } + + case 64: { + uint64_t xor0 = a64[0] ^ (b64[0] & b_mask64[0]); + uint64_t xor1 = a64[1] ^ (b64[1] & b_mask64[1]); + uint64_t xor2 = a64[2] ^ (b64[2] & b_mask64[2]); + uint64_t xor3 = a64[3] ^ (b64[3] & b_mask64[3]); + uint64_t xor4 = a64[4] ^ (b64[4] & b_mask64[4]); + uint64_t xor5 = a64[5] ^ (b64[5] & b_mask64[5]); + uint64_t xor6 = a64[6] ^ (b64[6] & b_mask64[6]); + uint64_t xor7 = a64[7] ^ (b64[7] & b_mask64[7]); + uint64_t or = ((xor0 | xor1) | (xor2 | xor3)) | + ((xor4 | xor5) | (xor6 | xor7)); + uint32_t result = 1; + + if (or) + result = 0; + return result; + } + + default: { + uint32_t i; + + for (i = 0; i < n_bytes / sizeof(uint64_t); i++) + if (a64[i] != (b64[i] & b_mask64[i])) + return 0; + return 1; + } + } +} + +#define TABLE_KEYS_PER_BUCKET 4 + +#define TABLE_BUCKET_PAD_SIZE \ + (RTE_CACHE_LINE_SIZE - TABLE_KEYS_PER_BUCKET * (sizeof(uint32_t) + sizeof(uint32_t))) + +struct table_bucket { + uint32_t time[TABLE_KEYS_PER_BUCKET]; + uint32_t sig[TABLE_KEYS_PER_BUCKET]; + uint8_t pad[TABLE_BUCKET_PAD_SIZE]; + uint8_t key[0]; +}; + +struct table_params { + /* The real key size. Must be non-zero. */ + size_t key_size; + + /* They key size upgrated to the next power of 2. This used for hash generation (in + * increments of 8 bytes, from 8 to 64 bytes) and for run-time key comparison. This is why + * key sizes bigger than 64 bytes are not allowed. + */ + size_t key_size_pow2; + + /* log2(key_size_pow2). Purpose: avoid multiplication with non-power-of-2 numbers. */ + size_t key_size_log2; + + /* The key offset within the key buffer. */ + size_t key_offset; + + /* The real action data size. */ + size_t action_data_size; + + /* The data size, i.e. the 8-byte action_id field plus the action data size, upgraded to the + * next power of 2. + */ + size_t data_size_pow2; + + /* log2(data_size_pow2). Purpose: avoid multiplication with non-power of 2 numbers. */ + size_t data_size_log2; + + /* Number of buckets. Must be a power of 2 to avoid modulo with non-power-of-2 numbers. */ + size_t n_buckets; + + /* Bucket mask. Purpose: replace modulo with bitmask and operation. */ + size_t bucket_mask; + + /* Total number of key bytes in the bucket, including the key padding bytes. There are + * (key_size_pow2 - key_size) padding bytes for each key in the bucket. + */ + size_t bucket_key_all_size; + + /* Bucket size. Must be a power of 2 to avoid multiplication with non-power-of-2 number. */ + size_t bucket_size; + + /* log2(bucket_size). Purpose: avoid multiplication with non-power of 2 numbers. */ + size_t bucket_size_log2; + + /* Timeout in CPU clock cycles. */ + uint64_t key_timeout; + + /* Total memory size. */ + size_t total_size; +}; + +struct table { + /* Table parameters. */ + struct table_params params; + + /* Key mask. Array of *key_size* bytes. */ + uint8_t key_mask0[RTE_CACHE_LINE_SIZE]; + + /* Table buckets. */ + uint8_t buckets[0]; +} __rte_cache_aligned; + +static int +table_params_get(struct table_params *p, struct rte_swx_table_learner_params *params) +{ + /* Check input parameters. */ + if (!params || + !params->key_size || + (params->key_size > 64) || + !params->n_keys_max || + (params->n_keys_max > 1U << 31) || + !params->key_timeout) + return -EINVAL; + + /* Key. */ + p->key_size = params->key_size; + + p->key_size_pow2 = rte_align64pow2(p->key_size); + if (p->key_size_pow2 < 8) + p->key_size_pow2 = 8; + + p->key_size_log2 = __builtin_ctzll(p->key_size_pow2); + + p->key_offset = params->key_offset; + + /* Data. */ + p->action_data_size = params->action_data_size; + + p->data_size_pow2 = rte_align64pow2(sizeof(uint64_t) + p->action_data_size); + + p->data_size_log2 = __builtin_ctzll(p->data_size_pow2); + + /* Buckets. */ + p->n_buckets = rte_align32pow2(params->n_keys_max); + + p->bucket_mask = p->n_buckets - 1; + + p->bucket_key_all_size = TABLE_KEYS_PER_BUCKET * p->key_size_pow2; + + p->bucket_size = rte_align64pow2(sizeof(struct table_bucket) + + p->bucket_key_all_size + + TABLE_KEYS_PER_BUCKET * p->data_size_pow2); + + p->bucket_size_log2 = __builtin_ctzll(p->bucket_size); + + /* Timeout. */ + p->key_timeout = params->key_timeout * rte_get_tsc_hz(); + + /* Total size. */ + p->total_size = sizeof(struct table) + p->n_buckets * p->bucket_size; + + return 0; +} + +static inline struct table_bucket * +table_bucket_get(struct table *t, size_t bucket_id) +{ + return (struct table_bucket *)&t->buckets[bucket_id << t->params.bucket_size_log2]; +} + +static inline uint8_t * +table_bucket_key_get(struct table *t, struct table_bucket *b, size_t bucket_key_pos) +{ + return &b->key[bucket_key_pos << t->params.key_size_log2]; +} + +static inline uint64_t * +table_bucket_data_get(struct table *t, struct table_bucket *b, size_t bucket_key_pos) +{ + return (uint64_t *)&b->key[t->params.bucket_key_all_size + + (bucket_key_pos << t->params.data_size_log2)]; +} + +uint64_t +rte_swx_table_learner_footprint_get(struct rte_swx_table_learner_params *params) +{ + struct table_params p; + int status; + + status = table_params_get(&p, params); + + return status ? 0 : p.total_size; +} + +void * +rte_swx_table_learner_create(struct rte_swx_table_learner_params *params, int numa_node) +{ + struct table_params p; + struct table *t; + int status; + + /* Check and process the input parameters. */ + status = table_params_get(&p, params); + if (status) + return NULL; + + /* Memory allocation. */ + t = env_calloc(p.total_size, RTE_CACHE_LINE_SIZE, numa_node); + if (!t) + return NULL; + + /* Memory initialization. */ + memcpy(&t->params, &p, sizeof(struct table_params)); + + if (params->key_mask0) + memcpy(t->key_mask0, params->key_mask0, params->key_size); + else + memset(t->key_mask0, 0xFF, params->key_size); + + return t; +} + +void +rte_swx_table_learner_free(void *table) +{ + struct table *t = table; + + if (!t) + return; + + env_free(t, t->params.total_size); +} + +struct mailbox { + /* Writer: lookup state 0. Reader(s): lookup state 1, add(). */ + struct table_bucket *bucket; + + /* Writer: lookup state 0. Reader(s): lookup state 1, add(). */ + uint32_t input_sig; + + /* Writer: lookup state 1. Reader(s): add(). */ + uint8_t *input_key; + + /* Writer: lookup state 1. Reader(s): add(). Values: 0 = miss; 1 = hit. */ + uint32_t hit; + + /* Writer: lookup state 1. Reader(s): add(). Valid only when hit is non-zero. */ + size_t bucket_key_pos; + + /* State. */ + int state; +}; + +uint64_t +rte_swx_table_learner_mailbox_size_get(void) +{ + return sizeof(struct mailbox); +} + +int +rte_swx_table_learner_lookup(void *table, + void *mailbox, + uint64_t input_time, + uint8_t **key, + uint64_t *action_id, + uint8_t **action_data, + int *hit) +{ + struct table *t = table; + struct mailbox *m = mailbox; + + switch (m->state) { + case 0: { + uint8_t *input_key; + struct table_bucket *b; + size_t bucket_id; + uint32_t input_sig; + + input_key = &(*key)[t->params.key_offset]; + input_sig = hash(input_key, t->key_mask0, t->params.key_size_pow2, 0); + bucket_id = input_sig & t->params.bucket_mask; + b = table_bucket_get(t, bucket_id); + + rte_prefetch0(b); + rte_prefetch0(&b->key[0]); + rte_prefetch0(&b->key[RTE_CACHE_LINE_SIZE]); + + m->bucket = b; + m->input_key = input_key; + m->input_sig = input_sig | 1; + m->state = 1; + return 0; + } + + case 1: { + struct table_bucket *b = m->bucket; + uint32_t i; + + /* Search the input key through the bucket keys. */ + for (i = 0; i < TABLE_KEYS_PER_BUCKET; i++) { + uint64_t time = b->time[i]; + uint32_t sig = b->sig[i]; + uint8_t *key = table_bucket_key_get(t, b, i); + uint32_t key_size_pow2 = t->params.key_size_pow2; + + time <<= 32; + + if ((time > input_time) && + (sig == m->input_sig) && + table_keycmp(key, m->input_key, t->key_mask0, key_size_pow2)) { + uint64_t *data = table_bucket_data_get(t, b, i); + + /* Hit. */ + rte_prefetch0(data); + + b->time[i] = (input_time + t->params.key_timeout) >> 32; + + m->hit = 1; + m->bucket_key_pos = i; + m->state = 0; + + *action_id = data[0]; + *action_data = (uint8_t *)&data[1]; + *hit = 1; + return 1; + } + } + + /* Miss. */ + m->hit = 0; + m->state = 0; + + *hit = 0; + return 1; + } + + default: + /* This state should never be reached. Miss. */ + m->hit = 0; + m->state = 0; + + *hit = 0; + return 1; + } +} + +uint32_t +rte_swx_table_learner_add(void *table, + void *mailbox, + uint64_t input_time, + uint64_t action_id, + uint8_t *action_data) +{ + struct table *t = table; + struct mailbox *m = mailbox; + struct table_bucket *b = m->bucket; + uint32_t i; + + /* Lookup hit: The key, key signature and key time are already properly configured (the key + * time was bumped by lookup), only the key data need to be updated. + */ + if (m->hit) { + uint64_t *data = table_bucket_data_get(t, b, m->bucket_key_pos); + + /* Install the key data. */ + data[0] = action_id; + if (t->params.action_data_size && action_data) + memcpy(&data[1], action_data, t->params.action_data_size); + + return 0; + } + + /* Lookup miss: Search for a free position in the current bucket and install the key. */ + for (i = 0; i < TABLE_KEYS_PER_BUCKET; i++) { + uint64_t time = b->time[i]; + + time <<= 32; + + /* Free position: Either there was never a key installed here, so the key time is + * set to zero (the init value), which is always less than the current time, or this + * position was used before, but the key expired (the key time is in the past). + */ + if (time < input_time) { + uint8_t *key = table_bucket_key_get(t, b, i); + uint64_t *data = table_bucket_data_get(t, b, i); + + /* Install the key. */ + b->time[i] = (input_time + t->params.key_timeout) >> 32; + b->sig[i] = m->input_sig; + memcpy(key, m->input_key, t->params.key_size); + + /* Install the key data. */ + data[0] = action_id; + if (t->params.action_data_size && action_data) + memcpy(&data[1], action_data, t->params.action_data_size); + + /* Mailbox. */ + m->hit = 1; + m->bucket_key_pos = i; + + return 0; + } + } + + /* Bucket full. */ + return 1; +} + +void +rte_swx_table_learner_delete(void *table __rte_unused, + void *mailbox) +{ + struct mailbox *m = mailbox; + + if (m->hit) { + struct table_bucket *b = m->bucket; + + /* Expire the key. */ + b->time[m->bucket_key_pos] = 0; + + /* Mailbox. */ + m->hit = 0; + } +} diff --git a/lib/table/rte_swx_table_learner.h b/lib/table/rte_swx_table_learner.h new file mode 100644 index 0000000000..d6ec733655 --- /dev/null +++ b/lib/table/rte_swx_table_learner.h @@ -0,0 +1,206 @@ +/* SPDX-License-Identifier: BSD-3-Clause + * Copyright(c) 2021 Intel Corporation + */ +#ifndef __INCLUDE_RTE_SWX_TABLE_LEARNER_H__ +#define __INCLUDE_RTE_SWX_TABLE_LEARNER_H__ + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @file + * RTE SWX Learner Table + * + * The learner table API. + * + * This table type is typically used for learning or connection tracking, where it allows for the + * implementation of the "add on miss" scenario: whenever the lookup key is not found in the table + * (lookup miss), the data plane can decide to add this key to the table with a given action with no + * control plane intervention. Likewise, the table keys expire based on a configurable timeout and + * are automatically deleted from the table with no control plane intervention. + */ + +#include +#include + +#include + +/** Learner table creation parameters. */ +struct rte_swx_table_learner_params { + /** Key size in bytes. Must be non-zero. */ + uint32_t key_size; + + /** Offset of the first byte of the key within the key buffer. */ + uint32_t key_offset; + + /** Mask of *key_size* bytes logically laid over the bytes at positions + * *key_offset* .. (*key_offset* + *key_size* - 1) of the key buffer in order to specify + * which bits from the key buffer are part of the key and which ones are not. A bit value of + * 1 in the *key_mask0* means the respective bit in the key buffer is part of the key, while + * a bit value of 0 means the opposite. A NULL value means that all the bits are part of the + * key, i.e. the *key_mask0* is an all-ones mask. + */ + uint8_t *key_mask0; + + /** Maximum size (in bytes) of the action data. The data stored in the table for each entry + * is equal to *action_data_size* plus 8 bytes, which are used to store the action ID. + */ + uint32_t action_data_size; + + /** Maximum number of keys to be stored in the table together with their associated data. */ + uint32_t n_keys_max; + + /** Key timeout in seconds. Must be non-zero. Each table key expires and is automatically + * deleted from the table after this many seconds. + */ + uint32_t key_timeout; +}; + +/** + * Learner table memory footprint get + * + * @param[in] params + * Table create parameters. + * @return + * Table memory footprint in bytes. + */ +__rte_experimental +uint64_t +rte_swx_table_learner_footprint_get(struct rte_swx_table_learner_params *params); + +/** + * Learner table mailbox size get + * + * The mailbox is used to store the context of a lookup operation that is in + * progress and it is passed as a parameter to the lookup operation. This allows + * for multiple concurrent lookup operations into the same table. + * + * @return + * Table mailbox footprint in bytes. + */ +__rte_experimental +uint64_t +rte_swx_table_learner_mailbox_size_get(void); + +/** + * Learner table create + * + * @param[in] params + * Table creation parameters. + * @param[in] numa_node + * Non-Uniform Memory Access (NUMA) node. + * @return + * Table handle, on success, or NULL, on error. + */ +__rte_experimental +void * +rte_swx_table_learner_create(struct rte_swx_table_learner_params *params, int numa_node); + +/** + * Learner table key lookup + * + * The table lookup operation searches a given key in the table and upon its completion it returns + * an indication of whether the key is found in the table (lookup hit) or not (lookup miss). In case + * of lookup hit, the action_id and the action_data associated with the key are also returned. + * + * Multiple invocations of this function may be required in order to complete a single table lookup + * operation for a given table and a given lookup key. The completion of the table lookup operation + * is flagged by a return value of 1; in case of a return value of 0, the function must be invoked + * again with exactly the same arguments. + * + * The mailbox argument is used to store the context of an on-going table key lookup operation, and + * possibly an associated key add operation. The mailbox mechanism allows for multiple concurrent + * table key lookup and add operations into the same table. + * + * @param[in] table + * Table handle. + * @param[in] mailbox + * Mailbox for the current table lookup operation. + * @param[in] time + * Current time measured in CPU clock cycles. + * @param[in] key + * Lookup key. Its size must be equal to the table *key_size*. + * @param[out] action_id + * ID of the action associated with the *key*. Must point to a valid 64-bit variable. Only valid + * when the function returns 1 and *hit* is set to true. + * @param[out] action_data + * Action data for the *action_id* action. Must point to a valid array of table *action_data_size* + * bytes. Only valid when the function returns 1 and *hit* is set to true. + * @param[out] hit + * Only valid when the function returns 1. Set to non-zero (true) on table lookup hit and to zero + * (false) on table lookup miss. + * @return + * 0 when the table lookup operation is not yet completed, and 1 when the table lookup operation + * is completed. No other return values are allowed. + */ +__rte_experimental +int +rte_swx_table_learner_lookup(void *table, + void *mailbox, + uint64_t time, + uint8_t **key, + uint64_t *action_id, + uint8_t **action_data, + int *hit); + +/** + * Learner table key add + * + * This operation takes the latest key that was looked up in the table and adds it to the table with + * the given action ID and action data. Typically, this operation is only invoked when the latest + * lookup operation in the current table resulted in lookup miss. + * + * @param[in] table + * Table handle. + * @param[in] mailbox + * Mailbox for the current operation. + * @param[in] time + * Current time measured in CPU clock cycles. + * @param[out] action_id + * ID of the action associated with the key. + * @param[out] action_data + * Action data for the *action_id* action. + * @return + * 0 on success, 1 or error (table full). + */ +__rte_experimental +uint32_t +rte_swx_table_learner_add(void *table, + void *mailbox, + uint64_t time, + uint64_t action_id, + uint8_t *action_data); + +/** + * Learner table key delete + * + * This operation takes the latest key that was looked up in the table and deletes it from the + * table. Typically, this operation is only invoked to force the deletion of the key before the key + * expires on timeout due to inactivity. + * + * @param[in] table + * Table handle. + * @param[in] mailbox + * Mailbox for the current operation. + */ +__rte_experimental +void +rte_swx_table_learner_delete(void *table, + void *mailbox); + +/** + * Learner table free + * + * @param[in] table + * Table handle. + */ +__rte_experimental +void +rte_swx_table_learner_free(void *table); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/lib/table/version.map b/lib/table/version.map index 65f9645d25..efe5f6e52c 100644 --- a/lib/table/version.map +++ b/lib/table/version.map @@ -36,4 +36,13 @@ EXPERIMENTAL { rte_swx_table_selector_group_set; rte_swx_table_selector_mailbox_size_get; rte_swx_table_selector_select; + + # added in 21.11 + rte_swx_table_learner_add; + rte_swx_table_learner_create; + rte_swx_table_learner_delete; + rte_swx_table_learner_footprint_get; + rte_swx_table_learner_free; + rte_swx_table_learner_lookup; + rte_swx_table_learner_mailbox_size_get; }; From patchwork Mon Sep 20 15:01:31 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Dumitrescu X-Patchwork-Id: 99325 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id BB069A0548; Mon, 20 Sep 2021 17:01:59 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 864A6410FE; Mon, 20 Sep 2021 17:01:42 +0200 (CEST) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by mails.dpdk.org (Postfix) with ESMTP id 8642340DF5 for ; Mon, 20 Sep 2021 17:01:38 +0200 (CEST) X-IronPort-AV: E=McAfee;i="6200,9189,10113"; a="245557180" X-IronPort-AV: E=Sophos;i="5.85,308,1624345200"; d="scan'208";a="245557180" Received: from orsmga003.jf.intel.com ([10.7.209.27]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Sep 2021 08:01:37 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.85,308,1624345200"; d="scan'208";a="435552168" Received: from silpixa00400573.ir.intel.com (HELO silpixa00400573.ger.corp.intel.com) ([10.237.223.107]) by orsmga003.jf.intel.com with ESMTP; 20 Sep 2021 08:01:35 -0700 From: Cristian Dumitrescu To: dev@dpdk.org Date: Mon, 20 Sep 2021 16:01:31 +0100 Message-Id: <20210920150133.84928-2-cristian.dumitrescu@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20210920150133.84928-1-cristian.dumitrescu@intel.com> References: <20210816122257.84651-1-cristian.dumitrescu@intel.com> <20210920150133.84928-1-cristian.dumitrescu@intel.com> Subject: [dpdk-dev] [PATCH V5 2/4] pipeline: add support for learner tables X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Add pipeline level support for learner tables. Signed-off-by: Cristian Dumitrescu --- V2: Added more configuration consistency checks. V3: Fixed one coding style indentation error. V4: Fixed a pointer dereferencing issue in function rte_swx_ctl_pipeline_learner_stats_read(). V5: Added function rte_swx_ctl_pipeline_learner_default_entry_read() to the version.map file. lib/pipeline/rte_swx_ctl.c | 479 +++++++++++- lib/pipeline/rte_swx_ctl.h | 186 +++++ lib/pipeline/rte_swx_pipeline.c | 1041 ++++++++++++++++++++++++-- lib/pipeline/rte_swx_pipeline.h | 77 ++ lib/pipeline/rte_swx_pipeline_spec.c | 470 +++++++++++- lib/pipeline/version.map | 9 + 6 files changed, 2207 insertions(+), 55 deletions(-) diff --git a/lib/pipeline/rte_swx_ctl.c b/lib/pipeline/rte_swx_ctl.c index dc093860de..86b58e21dc 100644 --- a/lib/pipeline/rte_swx_ctl.c +++ b/lib/pipeline/rte_swx_ctl.c @@ -123,12 +123,26 @@ struct selector { struct rte_swx_table_selector_params params; }; +struct learner { + struct rte_swx_ctl_learner_info info; + struct rte_swx_ctl_table_match_field_info *mf; + struct rte_swx_ctl_table_action_info *actions; + uint32_t action_data_size; + + /* The pending default action: this is NOT the current default action; + * this will be the new default action after the next commit, if the + * next commit operation is successful. + */ + struct rte_swx_table_entry *pending_default; +}; + struct rte_swx_ctl_pipeline { struct rte_swx_ctl_pipeline_info info; struct rte_swx_pipeline *p; struct action *actions; struct table *tables; struct selector *selectors; + struct learner *learners; struct rte_swx_table_state *ts; struct rte_swx_table_state *ts_next; int numa_node; @@ -924,6 +938,70 @@ selector_params_get(struct rte_swx_ctl_pipeline *ctl, uint32_t selector_id) return 0; } +static void +learner_pending_default_free(struct learner *l) +{ + if (!l->pending_default) + return; + + free(l->pending_default->action_data); + free(l->pending_default); + l->pending_default = NULL; +} + + +static void +learner_free(struct rte_swx_ctl_pipeline *ctl) +{ + uint32_t i; + + if (!ctl->learners) + return; + + for (i = 0; i < ctl->info.n_learners; i++) { + struct learner *l = &ctl->learners[i]; + + free(l->mf); + free(l->actions); + + learner_pending_default_free(l); + } + + free(ctl->learners); + ctl->learners = NULL; +} + +static struct learner * +learner_find(struct rte_swx_ctl_pipeline *ctl, const char *learner_name) +{ + uint32_t i; + + for (i = 0; i < ctl->info.n_learners; i++) { + struct learner *l = &ctl->learners[i]; + + if (!strcmp(learner_name, l->info.name)) + return l; + } + + return NULL; +} + +static uint32_t +learner_action_data_size_get(struct rte_swx_ctl_pipeline *ctl, struct learner *l) +{ + uint32_t action_data_size = 0, i; + + for (i = 0; i < l->info.n_actions; i++) { + uint32_t action_id = l->actions[i].action_id; + struct action *a = &ctl->actions[action_id]; + + if (a->data_size > action_data_size) + action_data_size = a->data_size; + } + + return action_data_size; +} + static void table_state_free(struct rte_swx_ctl_pipeline *ctl) { @@ -954,6 +1032,14 @@ table_state_free(struct rte_swx_ctl_pipeline *ctl) rte_swx_table_selector_free(ts->obj); } + /* For each learner table, free its table state. */ + for (i = 0; i < ctl->info.n_learners; i++) { + struct rte_swx_table_state *ts = &ctl->ts_next[i]; + + /* Default action data. */ + free(ts->default_action_data); + } + free(ctl->ts_next); ctl->ts_next = NULL; } @@ -1020,6 +1106,29 @@ table_state_create(struct rte_swx_ctl_pipeline *ctl) } } + /* Learner tables. */ + for (i = 0; i < ctl->info.n_learners; i++) { + struct learner *l = &ctl->learners[i]; + struct rte_swx_table_state *ts = &ctl->ts[i]; + struct rte_swx_table_state *ts_next = &ctl->ts_next[i]; + + /* Table object: duplicate from the current table state. */ + ts_next->obj = ts->obj; + + /* Default action data: duplicate from the current table state. */ + ts_next->default_action_data = malloc(l->action_data_size); + if (!ts_next->default_action_data) { + status = -ENOMEM; + goto error; + } + + memcpy(ts_next->default_action_data, + ts->default_action_data, + l->action_data_size); + + ts_next->default_action_id = ts->default_action_id; + } + return 0; error: @@ -1037,6 +1146,8 @@ rte_swx_ctl_pipeline_free(struct rte_swx_ctl_pipeline *ctl) table_state_free(ctl); + learner_free(ctl); + selector_free(ctl); table_free(ctl); @@ -1251,6 +1362,54 @@ rte_swx_ctl_pipeline_create(struct rte_swx_pipeline *p) goto error; } + /* learner tables. */ + ctl->learners = calloc(ctl->info.n_learners, sizeof(struct learner)); + if (!ctl->learners) + goto error; + + for (i = 0; i < ctl->info.n_learners; i++) { + struct learner *l = &ctl->learners[i]; + uint32_t j; + + /* info. */ + status = rte_swx_ctl_learner_info_get(p, i, &l->info); + if (status) + goto error; + + /* mf. */ + l->mf = calloc(l->info.n_match_fields, + sizeof(struct rte_swx_ctl_table_match_field_info)); + if (!l->mf) + goto error; + + for (j = 0; j < l->info.n_match_fields; j++) { + status = rte_swx_ctl_learner_match_field_info_get(p, + i, + j, + &l->mf[j]); + if (status) + goto error; + } + + /* actions. */ + l->actions = calloc(l->info.n_actions, + sizeof(struct rte_swx_ctl_table_action_info)); + if (!l->actions) + goto error; + + for (j = 0; j < l->info.n_actions; j++) { + status = rte_swx_ctl_learner_action_info_get(p, + i, + j, + &l->actions[j]); + if (status || l->actions[j].action_id >= ctl->info.n_actions) + goto error; + } + + /* action_data_size. */ + l->action_data_size = learner_action_data_size_get(ctl, l); + } + /* ts. */ status = rte_swx_pipeline_table_state_get(p, &ctl->ts); if (status) @@ -1685,9 +1844,8 @@ table_rollfwd1(struct rte_swx_ctl_pipeline *ctl, uint32_t table_id) action_data = table->pending_default->action_data; a = &ctl->actions[action_id]; - memcpy(ts_next->default_action_data, - action_data, - a->data_size); + if (a->data_size) + memcpy(ts_next->default_action_data, action_data, a->data_size); ts_next->default_action_id = action_id; } @@ -2099,6 +2257,178 @@ selector_abort(struct rte_swx_ctl_pipeline *ctl, uint32_t selector_id) memset(s->groups_pending_delete, 0, s->info.n_groups_max * sizeof(int)); } +static struct rte_swx_table_entry * +learner_default_entry_alloc(struct learner *l) +{ + struct rte_swx_table_entry *entry; + + entry = calloc(1, sizeof(struct rte_swx_table_entry)); + if (!entry) + goto error; + + /* action_data. */ + if (l->action_data_size) { + entry->action_data = calloc(1, l->action_data_size); + if (!entry->action_data) + goto error; + } + + return entry; + +error: + table_entry_free(entry); + return NULL; +} + +static int +learner_default_entry_check(struct rte_swx_ctl_pipeline *ctl, + uint32_t learner_id, + struct rte_swx_table_entry *entry) +{ + struct learner *l = &ctl->learners[learner_id]; + struct action *a; + uint32_t i; + + CHECK(entry, EINVAL); + + /* action_id. */ + for (i = 0; i < l->info.n_actions; i++) + if (entry->action_id == l->actions[i].action_id) + break; + + CHECK(i < l->info.n_actions, EINVAL); + + /* action_data. */ + a = &ctl->actions[entry->action_id]; + CHECK(!(a->data_size && !entry->action_data), EINVAL); + + return 0; +} + +static struct rte_swx_table_entry * +learner_default_entry_duplicate(struct rte_swx_ctl_pipeline *ctl, + uint32_t learner_id, + struct rte_swx_table_entry *entry) +{ + struct learner *l = &ctl->learners[learner_id]; + struct rte_swx_table_entry *new_entry = NULL; + struct action *a; + uint32_t i; + + if (!entry) + goto error; + + new_entry = calloc(1, sizeof(struct rte_swx_table_entry)); + if (!new_entry) + goto error; + + /* action_id. */ + for (i = 0; i < l->info.n_actions; i++) + if (entry->action_id == l->actions[i].action_id) + break; + + if (i >= l->info.n_actions) + goto error; + + new_entry->action_id = entry->action_id; + + /* action_data. */ + a = &ctl->actions[entry->action_id]; + if (a->data_size && !entry->action_data) + goto error; + + /* The table layer provisions a constant action data size per + * entry, which should be the largest data size for all the + * actions enabled for the current table, and attempts to copy + * this many bytes each time a table entry is added, even if the + * specific action requires less data or even no data at all, + * hence we always have to allocate the max. + */ + new_entry->action_data = calloc(1, l->action_data_size); + if (!new_entry->action_data) + goto error; + + if (a->data_size) + memcpy(new_entry->action_data, entry->action_data, a->data_size); + + return new_entry; + +error: + table_entry_free(new_entry); + return NULL; +} + +int +rte_swx_ctl_pipeline_learner_default_entry_add(struct rte_swx_ctl_pipeline *ctl, + const char *learner_name, + struct rte_swx_table_entry *entry) +{ + struct learner *l; + struct rte_swx_table_entry *new_entry; + uint32_t learner_id; + + CHECK(ctl, EINVAL); + + CHECK(learner_name && learner_name[0], EINVAL); + l = learner_find(ctl, learner_name); + CHECK(l, EINVAL); + learner_id = l - ctl->learners; + CHECK(!l->info.default_action_is_const, EINVAL); + + CHECK(entry, EINVAL); + CHECK(!learner_default_entry_check(ctl, learner_id, entry), EINVAL); + + new_entry = learner_default_entry_duplicate(ctl, learner_id, entry); + CHECK(new_entry, ENOMEM); + + learner_pending_default_free(l); + + l->pending_default = new_entry; + return 0; +} + +static void +learner_rollfwd(struct rte_swx_ctl_pipeline *ctl, uint32_t learner_id) +{ + struct learner *l = &ctl->learners[learner_id]; + struct rte_swx_table_state *ts_next = &ctl->ts_next[ctl->info.n_tables + + ctl->info.n_selectors + learner_id]; + struct action *a; + uint8_t *action_data; + uint64_t action_id; + + /* Copy the pending default entry. */ + if (!l->pending_default) + return; + + action_id = l->pending_default->action_id; + action_data = l->pending_default->action_data; + a = &ctl->actions[action_id]; + + if (a->data_size) + memcpy(ts_next->default_action_data, action_data, a->data_size); + + ts_next->default_action_id = action_id; +} + +static void +learner_rollfwd_finalize(struct rte_swx_ctl_pipeline *ctl, uint32_t learner_id) +{ + struct learner *l = &ctl->learners[learner_id]; + + /* Free up the pending default entry, as it is now part of the table. */ + learner_pending_default_free(l); +} + +static void +learner_abort(struct rte_swx_ctl_pipeline *ctl, uint32_t learner_id) +{ + struct learner *l = &ctl->learners[learner_id]; + + /* Free up the pending default entry, as it is no longer going to be added to the table. */ + learner_pending_default_free(l); +} + int rte_swx_ctl_pipeline_commit(struct rte_swx_ctl_pipeline *ctl, int abort_on_fail) { @@ -2110,6 +2440,7 @@ rte_swx_ctl_pipeline_commit(struct rte_swx_ctl_pipeline *ctl, int abort_on_fail) /* Operate the changes on the current ts_next before it becomes the new ts. First, operate * all the changes that can fail; if no failure, then operate the changes that cannot fail. + * We must be able to fully revert all the changes that can fail as if they never happened. */ for (i = 0; i < ctl->info.n_tables; i++) { status = table_rollfwd0(ctl, i, 0); @@ -2123,9 +2454,15 @@ rte_swx_ctl_pipeline_commit(struct rte_swx_ctl_pipeline *ctl, int abort_on_fail) goto rollback; } + /* Second, operate all the changes that cannot fail. Since nothing can fail from this point + * onwards, the transaction is guaranteed to be successful. + */ for (i = 0; i < ctl->info.n_tables; i++) table_rollfwd1(ctl, i); + for (i = 0; i < ctl->info.n_learners; i++) + learner_rollfwd(ctl, i); + /* Swap the table state for the data plane. The current ts and ts_next * become the new ts_next and ts, respectively. */ @@ -2151,6 +2488,11 @@ rte_swx_ctl_pipeline_commit(struct rte_swx_ctl_pipeline *ctl, int abort_on_fail) selector_rollfwd_finalize(ctl, i); } + for (i = 0; i < ctl->info.n_learners; i++) { + learner_rollfwd(ctl, i); + learner_rollfwd_finalize(ctl, i); + } + return 0; rollback: @@ -2166,6 +2508,10 @@ rte_swx_ctl_pipeline_commit(struct rte_swx_ctl_pipeline *ctl, int abort_on_fail) selector_abort(ctl, i); } + if (abort_on_fail) + for (i = 0; i < ctl->info.n_learners; i++) + learner_abort(ctl, i); + return status; } @@ -2182,6 +2528,9 @@ rte_swx_ctl_pipeline_abort(struct rte_swx_ctl_pipeline *ctl) for (i = 0; i < ctl->info.n_selectors; i++) selector_abort(ctl, i); + + for (i = 0; i < ctl->info.n_learners; i++) + learner_abort(ctl, i); } static int @@ -2460,6 +2809,130 @@ rte_swx_ctl_pipeline_table_entry_read(struct rte_swx_ctl_pipeline *ctl, return NULL; } +struct rte_swx_table_entry * +rte_swx_ctl_pipeline_learner_default_entry_read(struct rte_swx_ctl_pipeline *ctl, + const char *learner_name, + const char *string, + int *is_blank_or_comment) +{ + char *token_array[RTE_SWX_CTL_ENTRY_TOKENS_MAX], **tokens; + struct learner *l; + struct action *action; + struct rte_swx_table_entry *entry = NULL; + char *s0 = NULL, *s; + uint32_t n_tokens = 0, arg_offset = 0, i; + int blank_or_comment = 0; + + /* Check input arguments. */ + if (!ctl) + goto error; + + if (!learner_name || !learner_name[0]) + goto error; + + l = learner_find(ctl, learner_name); + if (!l) + goto error; + + if (!string || !string[0]) + goto error; + + /* Memory allocation. */ + s0 = strdup(string); + if (!s0) + goto error; + + entry = learner_default_entry_alloc(l); + if (!entry) + goto error; + + /* Parse the string into tokens. */ + for (s = s0; ; ) { + char *token; + + token = strtok_r(s, " \f\n\r\t\v", &s); + if (!token || token_is_comment(token)) + break; + + if (n_tokens >= RTE_SWX_CTL_ENTRY_TOKENS_MAX) + goto error; + + token_array[n_tokens] = token; + n_tokens++; + } + + if (!n_tokens) { + blank_or_comment = 1; + goto error; + } + + tokens = token_array; + + /* + * Action. + */ + if (!(n_tokens && !strcmp(tokens[0], "action"))) + goto other; + + if (n_tokens < 2) + goto error; + + action = action_find(ctl, tokens[1]); + if (!action) + goto error; + + if (n_tokens < 2 + action->info.n_args * 2) + goto error; + + /* action_id. */ + entry->action_id = action - ctl->actions; + + /* action_data. */ + for (i = 0; i < action->info.n_args; i++) { + struct rte_swx_ctl_action_arg_info *arg = &action->args[i]; + char *arg_name, *arg_val; + uint64_t val; + + arg_name = tokens[2 + i * 2]; + arg_val = tokens[2 + i * 2 + 1]; + + if (strcmp(arg_name, arg->name)) + goto error; + + val = strtoull(arg_val, &arg_val, 0); + if (arg_val[0]) + goto error; + + /* Endianness conversion. */ + if (arg->is_network_byte_order) + val = field_hton(val, arg->n_bits); + + /* Copy to entry. */ + memcpy(&entry->action_data[arg_offset], + (uint8_t *)&val, + arg->n_bits / 8); + + arg_offset += arg->n_bits / 8; + } + + tokens += 2 + action->info.n_args * 2; + n_tokens -= 2 + action->info.n_args * 2; + +other: + if (n_tokens) + goto error; + + free(s0); + return entry; + +error: + table_entry_free(entry); + free(s0); + if (is_blank_or_comment) + *is_blank_or_comment = blank_or_comment; + return NULL; +} + static void table_entry_printf(FILE *f, struct rte_swx_ctl_pipeline *ctl, diff --git a/lib/pipeline/rte_swx_ctl.h b/lib/pipeline/rte_swx_ctl.h index f37301cf95..807597229d 100644 --- a/lib/pipeline/rte_swx_ctl.h +++ b/lib/pipeline/rte_swx_ctl.h @@ -52,6 +52,9 @@ struct rte_swx_ctl_pipeline_info { /** Number of selector tables. */ uint32_t n_selectors; + /** Number of learner tables. */ + uint32_t n_learners; + /** Number of register arrays. */ uint32_t n_regarrays; @@ -512,6 +515,142 @@ rte_swx_ctl_pipeline_selector_stats_read(struct rte_swx_pipeline *p, const char *selector_name, struct rte_swx_pipeline_selector_stats *stats); +/* + * Learner Table Query API. + */ + +/** Learner table info. */ +struct rte_swx_ctl_learner_info { + /** Learner table name. */ + char name[RTE_SWX_CTL_NAME_SIZE]; + + /** Number of match fields. */ + uint32_t n_match_fields; + + /** Number of actions. */ + uint32_t n_actions; + + /** Non-zero (true) when the default action is constant, therefore it + * cannot be changed; zero (false) when the default action not constant, + * therefore it can be changed. + */ + int default_action_is_const; + + /** Learner table size parameter. */ + uint32_t size; +}; + +/** + * Learner table info get + * + * @param[in] p + * Pipeline handle. + * @param[in] learner_id + * Learner table ID (0 .. *n_learners* - 1). + * @param[out] learner + * Learner table info. + * @return + * 0 on success or the following error codes otherwise: + * -EINVAL: Invalid argument. + */ +__rte_experimental +int +rte_swx_ctl_learner_info_get(struct rte_swx_pipeline *p, + uint32_t learner_id, + struct rte_swx_ctl_learner_info *learner); + +/** + * Learner table match field info get + * + * @param[in] p + * Pipeline handle. + * @param[in] learner_id + * Learner table ID (0 .. *n_learners* - 1). + * @param[in] match_field_id + * Match field ID (0 .. *n_match_fields* - 1). + * @param[out] match_field + * Learner table match field info. + * @return + * 0 on success or the following error codes otherwise: + * -EINVAL: Invalid argument. + */ +__rte_experimental +int +rte_swx_ctl_learner_match_field_info_get(struct rte_swx_pipeline *p, + uint32_t learner_id, + uint32_t match_field_id, + struct rte_swx_ctl_table_match_field_info *match_field); + +/** + * Learner table action info get + * + * @param[in] p + * Pipeline handle. + * @param[in] learner_id + * Learner table ID (0 .. *n_learners* - 1). + * @param[in] learner_action_id + * Action index within the set of learner table actions (0 .. learner table n_actions - 1). Not + * to be confused with the pipeline-leve action ID (0 .. pipeline n_actions - 1), which is + * precisely what this function returns as part of the *learner_action*. + * @param[out] learner_action + * Learner action info. + * @return + * 0 on success or the following error codes otherwise: + * -EINVAL: Invalid argument. + */ +__rte_experimental +int +rte_swx_ctl_learner_action_info_get(struct rte_swx_pipeline *p, + uint32_t learner_id, + uint32_t learner_action_id, + struct rte_swx_ctl_table_action_info *learner_action); + +/** Learner table statistics. */ +struct rte_swx_learner_stats { + /** Number of packets with lookup hit. */ + uint64_t n_pkts_hit; + + /** Number of packets with lookup miss. */ + uint64_t n_pkts_miss; + + /** Number of packets with successful learning. */ + uint64_t n_pkts_learn_ok; + + /** Number of packets with learning error. */ + uint64_t n_pkts_learn_err; + + /** Number of packets with forget event. */ + uint64_t n_pkts_forget; + + /** Number of packets (with either lookup hit or miss) per pipeline action. Array of + * pipeline *n_actions* elements indedex by the pipeline-level *action_id*, therefore this + * array has the same size for all the tables within the same pipeline. + */ + uint64_t *n_pkts_action; +}; + +/** + * Learner table statistics counters read + * + * @param[in] p + * Pipeline handle. + * @param[in] learner_name + * Learner table name. + * @param[out] stats + * Learner table stats. Must point to a pre-allocated structure. The *n_pkts_action* field also + * needs to be pre-allocated as array of pipeline *n_actions* elements. The pipeline actions that + * are not valid for the current learner table have their associated *n_pkts_action* element + * always set to zero. + * @return + * 0 on success or the following error codes otherwise: + * -EINVAL: Invalid argument. + */ +__rte_experimental +int +rte_swx_ctl_pipeline_learner_stats_read(struct rte_swx_pipeline *p, + const char *learner_name, + struct rte_swx_learner_stats *stats); + /* * Table Update API. */ @@ -761,6 +900,27 @@ rte_swx_ctl_pipeline_selector_group_member_delete(struct rte_swx_ctl_pipeline *c uint32_t group_id, uint32_t member_id); +/** + * Pipeline learner table default entry add + * + * Schedule learner table default entry update as part of the next commit operation. + * + * @param[in] ctl + * Pipeline control handle. + * @param[in] learner_name + * Learner table name. + * @param[in] entry + * The new table default entry. The *key* and *key_mask* entry fields are ignored. + * @return + * 0 on success or the following error codes otherwise: + * -EINVAL: Invalid argument. + */ +__rte_experimental +int +rte_swx_ctl_pipeline_learner_default_entry_add(struct rte_swx_ctl_pipeline *ctl, + const char *learner_name, + struct rte_swx_table_entry *entry); + /** * Pipeline commit * @@ -819,6 +979,32 @@ rte_swx_ctl_pipeline_table_entry_read(struct rte_swx_ctl_pipeline *ctl, const char *string, int *is_blank_or_comment); +/** + * Pipeline learner table default entry read + * + * Read learner table default entry from string. + * + * @param[in] ctl + * Pipeline control handle. + * @param[in] learner_name + * Learner table name. + * @param[in] string + * String containing the learner table default entry. + * @param[out] is_blank_or_comment + * On error, this argument provides an indication of whether *string* contains + * an invalid table entry (set to zero) or a blank or comment line that should + * typically be ignored (set to a non-zero value). + * @return + * 0 on success or the following error codes otherwise: + * -EINVAL: Invalid argument. + */ +__rte_experimental +struct rte_swx_table_entry * +rte_swx_ctl_pipeline_learner_default_entry_read(struct rte_swx_ctl_pipeline *ctl, + const char *learner_name, + const char *string, + int *is_blank_or_comment); + /** * Pipeline table print to file * diff --git a/lib/pipeline/rte_swx_pipeline.c b/lib/pipeline/rte_swx_pipeline.c index 96786fb9a0..f89a134a52 100644 --- a/lib/pipeline/rte_swx_pipeline.c +++ b/lib/pipeline/rte_swx_pipeline.c @@ -16,6 +16,7 @@ #include #include +#include #include "rte_swx_pipeline.h" #include "rte_swx_ctl.h" @@ -511,6 +512,13 @@ enum instruction_type { /* table TABLE */ INSTR_TABLE, INSTR_SELECTOR, + INSTR_LEARNER, + + /* learn LEARNER ACTION_NAME */ + INSTR_LEARNER_LEARN, + + /* forget */ + INSTR_LEARNER_FORGET, /* extern e.obj.func */ INSTR_EXTERN_OBJ, @@ -636,6 +644,10 @@ struct instr_table { uint8_t table_id; }; +struct instr_learn { + uint8_t action_id; +}; + struct instr_extern_obj { uint8_t ext_obj_id; uint8_t func_id; @@ -726,6 +738,7 @@ struct instruction { struct instr_dma dma; struct instr_dst_src alu; struct instr_table table; + struct instr_learn learn; struct instr_extern_obj ext_obj; struct instr_extern_func ext_func; struct instr_jmp jmp; @@ -746,7 +759,7 @@ struct action { TAILQ_ENTRY(action) node; char name[RTE_SWX_NAME_SIZE]; struct struct_type *st; - int *args_endianness; /* 0 = Host Byte Order (HBO). */ + int *args_endianness; /* 0 = Host Byte Order (HBO); 1 = Network Byte Order (NBO). */ struct instruction *instructions; uint32_t n_instructions; uint32_t id; @@ -839,6 +852,47 @@ struct selector_statistics { uint64_t n_pkts; }; +/* + * Learner table. + */ +struct learner { + TAILQ_ENTRY(learner) node; + char name[RTE_SWX_NAME_SIZE]; + + /* Match. */ + struct field **fields; + uint32_t n_fields; + struct header *header; + + /* Action. */ + struct action **actions; + struct field **action_arg; + struct action *default_action; + uint8_t *default_action_data; + uint32_t n_actions; + int default_action_is_const; + uint32_t action_data_size_max; + + uint32_t size; + uint32_t timeout; + uint32_t id; +}; + +TAILQ_HEAD(learner_tailq, learner); + +struct learner_runtime { + void *mailbox; + uint8_t **key; + uint8_t **action_data; +}; + +struct learner_statistics { + uint64_t n_pkts_hit[2]; /* 0 = Miss, 1 = Hit. */ + uint64_t n_pkts_learn[2]; /* 0 = Learn OK, 1 = Learn error. */ + uint64_t n_pkts_forget; + uint64_t *n_pkts_action; +}; + /* * Register array. */ @@ -919,9 +973,12 @@ struct thread { /* Tables. */ struct table_runtime *tables; struct selector_runtime *selectors; + struct learner_runtime *learners; struct rte_swx_table_state *table_state; uint64_t action_id; int hit; /* 0 = Miss, 1 = Hit. */ + uint32_t learner_id; + uint64_t time; /* Extern objects and functions. */ struct extern_obj_runtime *extern_objs; @@ -1355,6 +1412,7 @@ struct rte_swx_pipeline { struct table_type_tailq table_types; struct table_tailq tables; struct selector_tailq selectors; + struct learner_tailq learners; struct regarray_tailq regarrays; struct meter_profile_tailq meter_profiles; struct metarray_tailq metarrays; @@ -1365,6 +1423,7 @@ struct rte_swx_pipeline { struct rte_swx_table_state *table_state; struct table_statistics *table_stats; struct selector_statistics *selector_stats; + struct learner_statistics *learner_stats; struct regarray_runtime *regarray_runtime; struct metarray_runtime *metarray_runtime; struct instruction *instructions; @@ -1378,6 +1437,7 @@ struct rte_swx_pipeline { uint32_t n_actions; uint32_t n_tables; uint32_t n_selectors; + uint32_t n_learners; uint32_t n_regarrays; uint32_t n_metarrays; uint32_t n_headers; @@ -3625,6 +3685,9 @@ table_find(struct rte_swx_pipeline *p, const char *name); static struct selector * selector_find(struct rte_swx_pipeline *p, const char *name); +static struct learner * +learner_find(struct rte_swx_pipeline *p, const char *name); + static int instr_table_translate(struct rte_swx_pipeline *p, struct action *action, @@ -3635,6 +3698,7 @@ instr_table_translate(struct rte_swx_pipeline *p, { struct table *t; struct selector *s; + struct learner *l; CHECK(!action, EINVAL); CHECK(n_tokens == 2, EINVAL); @@ -3653,6 +3717,13 @@ instr_table_translate(struct rte_swx_pipeline *p, return 0; } + l = learner_find(p, tokens[1]); + if (l) { + instr->type = INSTR_LEARNER; + instr->table.table_id = l->id; + return 0; + } + CHECK(0, EINVAL); } @@ -3746,6 +3817,168 @@ instr_selector_exec(struct rte_swx_pipeline *p) thread_ip_inc(p); } +static inline void +instr_learner_exec(struct rte_swx_pipeline *p) +{ + struct thread *t = &p->threads[p->thread_id]; + struct instruction *ip = t->ip; + uint32_t learner_id = ip->table.table_id; + struct rte_swx_table_state *ts = &t->table_state[p->n_tables + + p->n_selectors + learner_id]; + struct learner_runtime *l = &t->learners[learner_id]; + struct learner_statistics *stats = &p->learner_stats[learner_id]; + uint64_t action_id, n_pkts_hit, n_pkts_action, time; + uint8_t *action_data; + int done, hit; + + /* Table. */ + time = rte_get_tsc_cycles(); + + done = rte_swx_table_learner_lookup(ts->obj, + l->mailbox, + time, + l->key, + &action_id, + &action_data, + &hit); + if (!done) { + /* Thread. */ + TRACE("[Thread %2u] learner %u (not finalized)\n", + p->thread_id, + learner_id); + + thread_yield(p); + return; + } + + action_id = hit ? action_id : ts->default_action_id; + action_data = hit ? action_data : ts->default_action_data; + n_pkts_hit = stats->n_pkts_hit[hit]; + n_pkts_action = stats->n_pkts_action[action_id]; + + TRACE("[Thread %2u] learner %u (%s, action %u)\n", + p->thread_id, + learner_id, + hit ? "hit" : "miss", + (uint32_t)action_id); + + t->action_id = action_id; + t->structs[0] = action_data; + t->hit = hit; + t->learner_id = learner_id; + t->time = time; + stats->n_pkts_hit[hit] = n_pkts_hit + 1; + stats->n_pkts_action[action_id] = n_pkts_action + 1; + + /* Thread. */ + thread_ip_action_call(p, t, action_id); +} + +/* + * learn. + */ +static struct action * +action_find(struct rte_swx_pipeline *p, const char *name); + +static int +action_has_nbo_args(struct action *a); + +static int +instr_learn_translate(struct rte_swx_pipeline *p, + struct action *action, + char **tokens, + int n_tokens, + struct instruction *instr, + struct instruction_data *data __rte_unused) +{ + struct action *a; + + CHECK(action, EINVAL); + CHECK(n_tokens == 2, EINVAL); + + a = action_find(p, tokens[1]); + CHECK(a, EINVAL); + CHECK(!action_has_nbo_args(a), EINVAL); + + instr->type = INSTR_LEARNER_LEARN; + instr->learn.action_id = a->id; + + return 0; +} + +static inline void +instr_learn_exec(struct rte_swx_pipeline *p) +{ + struct thread *t = &p->threads[p->thread_id]; + struct instruction *ip = t->ip; + uint64_t action_id = ip->learn.action_id; + uint32_t learner_id = t->learner_id; + struct rte_swx_table_state *ts = &t->table_state[p->n_tables + + p->n_selectors + learner_id]; + struct learner_runtime *l = &t->learners[learner_id]; + struct learner_statistics *stats = &p->learner_stats[learner_id]; + uint32_t status; + + /* Table. */ + status = rte_swx_table_learner_add(ts->obj, + l->mailbox, + t->time, + action_id, + l->action_data[action_id]); + + TRACE("[Thread %2u] learner %u learn %s\n", + p->thread_id, + learner_id, + status ? "ok" : "error"); + + stats->n_pkts_learn[status] += 1; + + /* Thread. */ + thread_ip_inc(p); +} + +/* + * forget. + */ +static int +instr_forget_translate(struct rte_swx_pipeline *p __rte_unused, + struct action *action, + char **tokens __rte_unused, + int n_tokens, + struct instruction *instr, + struct instruction_data *data __rte_unused) +{ + CHECK(action, EINVAL); + CHECK(n_tokens == 1, EINVAL); + + instr->type = INSTR_LEARNER_FORGET; + + return 0; +} + +static inline void +instr_forget_exec(struct rte_swx_pipeline *p) +{ + struct thread *t = &p->threads[p->thread_id]; + uint32_t learner_id = t->learner_id; + struct rte_swx_table_state *ts = &t->table_state[p->n_tables + + p->n_selectors + learner_id]; + struct learner_runtime *l = &t->learners[learner_id]; + struct learner_statistics *stats = &p->learner_stats[learner_id]; + + /* Table. */ + rte_swx_table_learner_delete(ts->obj, l->mailbox); + + TRACE("[Thread %2u] learner %u forget\n", + p->thread_id, + learner_id); + + stats->n_pkts_forget += 1; + + /* Thread. */ + thread_ip_inc(p); +} + /* * extern. */ @@ -7159,9 +7392,6 @@ instr_meter_imi_exec(struct rte_swx_pipeline *p) /* * jmp. */ -static struct action * -action_find(struct rte_swx_pipeline *p, const char *name); - static int instr_jmp_translate(struct rte_swx_pipeline *p __rte_unused, struct action *action __rte_unused, @@ -8136,6 +8366,22 @@ instr_translate(struct rte_swx_pipeline *p, instr, data); + if (!strcmp(tokens[tpos], "learn")) + return instr_learn_translate(p, + action, + &tokens[tpos], + n_tokens - tpos, + instr, + data); + + if (!strcmp(tokens[tpos], "forget")) + return instr_forget_translate(p, + action, + &tokens[tpos], + n_tokens - tpos, + instr, + data); + if (!strcmp(tokens[tpos], "extern")) return instr_extern_translate(p, action, @@ -9096,6 +9342,9 @@ static instr_exec_t instruction_table[] = { [INSTR_TABLE] = instr_table_exec, [INSTR_SELECTOR] = instr_selector_exec, + [INSTR_LEARNER] = instr_learner_exec, + [INSTR_LEARNER_LEARN] = instr_learn_exec, + [INSTR_LEARNER_FORGET] = instr_forget_exec, [INSTR_EXTERN_OBJ] = instr_extern_obj_exec, [INSTR_EXTERN_FUNC] = instr_extern_func_exec, @@ -9191,6 +9440,42 @@ action_field_parse(struct action *action, const char *name) return action_field_find(action, &name[2]); } +static int +action_has_nbo_args(struct action *a) +{ + uint32_t i; + + /* Return if the action does not have any args. */ + if (!a->st) + return 0; /* FALSE */ + + for (i = 0; i < a->st->n_fields; i++) + if (a->args_endianness[i]) + return 1; /* TRUE */ + + return 0; /* FALSE */ +} + +static int +action_does_learning(struct action *a) +{ + uint32_t i; + + for (i = 0; i < a->n_instructions; i++) + switch (a->instructions[i].type) { + case INSTR_LEARNER_LEARN: + return 1; /* TRUE */ + + case INSTR_LEARNER_FORGET: + return 1; /* TRUE */ + + default: + continue; + } + + return 0; /* FALSE */ +} + int rte_swx_pipeline_action_config(struct rte_swx_pipeline *p, const char *name, @@ -9546,6 +9831,7 @@ rte_swx_pipeline_table_config(struct rte_swx_pipeline *p, CHECK_NAME(name, EINVAL); CHECK(!table_find(p, name), EEXIST); CHECK(!selector_find(p, name), EEXIST); + CHECK(!learner_find(p, name), EEXIST); CHECK(params, EINVAL); @@ -9566,6 +9852,7 @@ rte_swx_pipeline_table_config(struct rte_swx_pipeline *p, a = action_find(p, action_name); CHECK(a, EINVAL); + CHECK(!action_does_learning(a), EINVAL); action_data_size = a->st ? a->st->n_bits / 8 : 0; if (action_data_size > action_data_size_max) @@ -9964,6 +10251,7 @@ rte_swx_pipeline_selector_config(struct rte_swx_pipeline *p, CHECK_NAME(name, EINVAL); CHECK(!table_find(p, name), EEXIST); CHECK(!selector_find(p, name), EEXIST); + CHECK(!learner_find(p, name), EEXIST); CHECK(params, EINVAL); @@ -10221,73 +10509,604 @@ selector_free(struct rte_swx_pipeline *p) } /* - * Table state. + * Learner table. */ -static int -table_state_build(struct rte_swx_pipeline *p) +static struct learner * +learner_find(struct rte_swx_pipeline *p, const char *name) { - struct table *table; - struct selector *s; - - p->table_state = calloc(p->n_tables + p->n_selectors, - sizeof(struct rte_swx_table_state)); - CHECK(p->table_state, ENOMEM); + struct learner *l; - TAILQ_FOREACH(table, &p->tables, node) { - struct rte_swx_table_state *ts = &p->table_state[table->id]; + TAILQ_FOREACH(l, &p->learners, node) + if (!strcmp(l->name, name)) + return l; - if (table->type) { - struct rte_swx_table_params *params; + return NULL; +} - /* ts->obj. */ - params = table_params_get(table); - CHECK(params, ENOMEM); +static struct learner * +learner_find_by_id(struct rte_swx_pipeline *p, uint32_t id) +{ + struct learner *l = NULL; - ts->obj = table->type->ops.create(params, - NULL, - table->args, - p->numa_node); + TAILQ_FOREACH(l, &p->learners, node) + if (l->id == id) + return l; - table_params_free(params); - CHECK(ts->obj, ENODEV); - } + return NULL; +} - /* ts->default_action_data. */ - if (table->action_data_size_max) { - ts->default_action_data = - malloc(table->action_data_size_max); - CHECK(ts->default_action_data, ENOMEM); +static int +learner_match_fields_check(struct rte_swx_pipeline *p, + struct rte_swx_pipeline_learner_params *params, + struct header **header) +{ + struct header *h0 = NULL; + struct field *hf, *mf; + uint32_t i; - memcpy(ts->default_action_data, - table->default_action_data, - table->action_data_size_max); - } + /* Return if no match fields. */ + if (!params->n_fields || !params->field_names) + return -EINVAL; - /* ts->default_action_id. */ - ts->default_action_id = table->default_action->id; - } + /* Check that all the match fields either belong to the same header + * or are all meta-data fields. + */ + hf = header_field_parse(p, params->field_names[0], &h0); + mf = metadata_field_parse(p, params->field_names[0]); + if (!hf && !mf) + return -EINVAL; - TAILQ_FOREACH(s, &p->selectors, node) { - struct rte_swx_table_state *ts = &p->table_state[p->n_tables + s->id]; - struct rte_swx_table_selector_params *params; + for (i = 1; i < params->n_fields; i++) + if (h0) { + struct header *h; - /* ts->obj. */ - params = selector_table_params_get(s); - CHECK(params, ENOMEM); + hf = header_field_parse(p, params->field_names[i], &h); + if (!hf || (h->id != h0->id)) + return -EINVAL; + } else { + mf = metadata_field_parse(p, params->field_names[i]); + if (!mf) + return -EINVAL; + } - ts->obj = rte_swx_table_selector_create(params, NULL, p->numa_node); + /* Check that there are no duplicated match fields. */ + for (i = 0; i < params->n_fields; i++) { + const char *field_name = params->field_names[i]; + uint32_t j; - selector_params_free(params); - CHECK(ts->obj, ENODEV); + for (j = i + 1; j < params->n_fields; j++) + if (!strcmp(params->field_names[j], field_name)) + return -EINVAL; } + /* Return. */ + if (header) + *header = h0; + return 0; } -static void -table_state_build_free(struct rte_swx_pipeline *p) +static int +learner_action_args_check(struct rte_swx_pipeline *p, struct action *a, const char *mf_name) { - uint32_t i; + struct struct_type *mst = p->metadata_st, *ast = a->st; + struct field *mf, *af; + uint32_t mf_pos, i; + + if (!ast) { + if (mf_name) + return -EINVAL; + + return 0; + } + + /* Check that mf_name is the name of a valid meta-data field. */ + CHECK_NAME(mf_name, EINVAL); + mf = metadata_field_parse(p, mf_name); + CHECK(mf, EINVAL); + + /* Check that there are enough meta-data fields, starting with the mf_name field, to cover + * all the action arguments. + */ + mf_pos = mf - mst->fields; + CHECK(mst->n_fields - mf_pos >= ast->n_fields, EINVAL); + + /* Check that the size of each of the identified meta-data fields matches exactly the size + * of the corresponding action argument. + */ + for (i = 0; i < ast->n_fields; i++) { + mf = &mst->fields[mf_pos + i]; + af = &ast->fields[i]; + + CHECK(mf->n_bits == af->n_bits, EINVAL); + } + + return 0; +} + +static int +learner_action_learning_check(struct rte_swx_pipeline *p, + struct action *action, + const char **action_names, + uint32_t n_actions) +{ + uint32_t i; + + /* For each "learn" instruction of the current action, check that the learned action (i.e. + * the action passed as argument to the "learn" instruction) is also enabled for the + * current learner table. + */ + for (i = 0; i < action->n_instructions; i++) { + struct instruction *instr = &action->instructions[i]; + uint32_t found = 0, j; + + if (instr->type != INSTR_LEARNER_LEARN) + continue; + + for (j = 0; j < n_actions; j++) { + struct action *a; + + a = action_find(p, action_names[j]); + if (!a) + return -EINVAL; + + if (a->id == instr->learn.action_id) + found = 1; + } + + if (!found) + return -EINVAL; + } + + return 0; +} + +int +rte_swx_pipeline_learner_config(struct rte_swx_pipeline *p, + const char *name, + struct rte_swx_pipeline_learner_params *params, + uint32_t size, + uint32_t timeout) +{ + struct learner *l = NULL; + struct action *default_action; + struct header *header = NULL; + uint32_t action_data_size_max = 0, i; + int status = 0; + + CHECK(p, EINVAL); + + CHECK_NAME(name, EINVAL); + CHECK(!table_find(p, name), EEXIST); + CHECK(!selector_find(p, name), EEXIST); + CHECK(!learner_find(p, name), EEXIST); + + CHECK(params, EINVAL); + + /* Match checks. */ + status = learner_match_fields_check(p, params, &header); + if (status) + return status; + + /* Action checks. */ + CHECK(params->n_actions, EINVAL); + + CHECK(params->action_names, EINVAL); + for (i = 0; i < params->n_actions; i++) { + const char *action_name = params->action_names[i]; + const char *action_field_name = params->action_field_names[i]; + struct action *a; + uint32_t action_data_size; + + CHECK_NAME(action_name, EINVAL); + + a = action_find(p, action_name); + CHECK(a, EINVAL); + + status = learner_action_args_check(p, a, action_field_name); + if (status) + return status; + + status = learner_action_learning_check(p, + a, + params->action_names, + params->n_actions); + if (status) + return status; + + action_data_size = a->st ? a->st->n_bits / 8 : 0; + if (action_data_size > action_data_size_max) + action_data_size_max = action_data_size; + } + + CHECK_NAME(params->default_action_name, EINVAL); + for (i = 0; i < p->n_actions; i++) + if (!strcmp(params->action_names[i], + params->default_action_name)) + break; + CHECK(i < params->n_actions, EINVAL); + + default_action = action_find(p, params->default_action_name); + CHECK((default_action->st && params->default_action_data) || + !params->default_action_data, EINVAL); + + /* Any other checks. */ + CHECK(size, EINVAL); + CHECK(timeout, EINVAL); + + /* Memory allocation. */ + l = calloc(1, sizeof(struct learner)); + if (!l) + goto nomem; + + l->fields = calloc(params->n_fields, sizeof(struct field *)); + if (!l->fields) + goto nomem; + + l->actions = calloc(params->n_actions, sizeof(struct action *)); + if (!l->actions) + goto nomem; + + l->action_arg = calloc(params->n_actions, sizeof(struct field *)); + if (!l->action_arg) + goto nomem; + + if (action_data_size_max) { + l->default_action_data = calloc(1, action_data_size_max); + if (!l->default_action_data) + goto nomem; + } + + /* Node initialization. */ + strcpy(l->name, name); + + for (i = 0; i < params->n_fields; i++) { + const char *field_name = params->field_names[i]; + + l->fields[i] = header ? + header_field_parse(p, field_name, NULL) : + metadata_field_parse(p, field_name); + } + + l->n_fields = params->n_fields; + + l->header = header; + + for (i = 0; i < params->n_actions; i++) { + const char *mf_name = params->action_field_names[i]; + + l->actions[i] = action_find(p, params->action_names[i]); + + l->action_arg[i] = mf_name ? metadata_field_parse(p, mf_name) : NULL; + } + + l->default_action = default_action; + + if (default_action->st) + memcpy(l->default_action_data, + params->default_action_data, + default_action->st->n_bits / 8); + + l->n_actions = params->n_actions; + + l->default_action_is_const = params->default_action_is_const; + + l->action_data_size_max = action_data_size_max; + + l->size = size; + + l->timeout = timeout; + + l->id = p->n_learners; + + /* Node add to tailq. */ + TAILQ_INSERT_TAIL(&p->learners, l, node); + p->n_learners++; + + return 0; + +nomem: + if (!l) + return -ENOMEM; + + free(l->action_arg); + free(l->actions); + free(l->fields); + free(l); + + return -ENOMEM; +} + +static void +learner_params_free(struct rte_swx_table_learner_params *params) +{ + if (!params) + return; + + free(params->key_mask0); + + free(params); +} + +static struct rte_swx_table_learner_params * +learner_params_get(struct learner *l) +{ + struct rte_swx_table_learner_params *params = NULL; + struct field *first, *last; + uint32_t i; + + /* Memory allocation. */ + params = calloc(1, sizeof(struct rte_swx_table_learner_params)); + if (!params) + goto error; + + /* Find first (smallest offset) and last (biggest offset) match fields. */ + first = l->fields[0]; + last = l->fields[0]; + + for (i = 0; i < l->n_fields; i++) { + struct field *f = l->fields[i]; + + if (f->offset < first->offset) + first = f; + + if (f->offset > last->offset) + last = f; + } + + /* Key offset and size. */ + params->key_offset = first->offset / 8; + params->key_size = (last->offset + last->n_bits - first->offset) / 8; + + /* Memory allocation. */ + params->key_mask0 = calloc(1, params->key_size); + if (!params->key_mask0) + goto error; + + /* Key mask. */ + for (i = 0; i < l->n_fields; i++) { + struct field *f = l->fields[i]; + uint32_t start = (f->offset - first->offset) / 8; + size_t size = f->n_bits / 8; + + memset(¶ms->key_mask0[start], 0xFF, size); + } + + /* Action data size. */ + params->action_data_size = l->action_data_size_max; + + /* Maximum number of keys. */ + params->n_keys_max = l->size; + + /* Timeout. */ + params->key_timeout = l->timeout; + + return params; + +error: + learner_params_free(params); + return NULL; +} + +static void +learner_build_free(struct rte_swx_pipeline *p) +{ + uint32_t i; + + for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) { + struct thread *t = &p->threads[i]; + uint32_t j; + + if (!t->learners) + continue; + + for (j = 0; j < p->n_learners; j++) { + struct learner_runtime *r = &t->learners[j]; + + free(r->mailbox); + free(r->action_data); + } + + free(t->learners); + t->learners = NULL; + } + + if (p->learner_stats) { + for (i = 0; i < p->n_learners; i++) + free(p->learner_stats[i].n_pkts_action); + + free(p->learner_stats); + } +} + +static int +learner_build(struct rte_swx_pipeline *p) +{ + uint32_t i; + int status = 0; + + /* Per pipeline: learner statistics. */ + p->learner_stats = calloc(p->n_learners, sizeof(struct learner_statistics)); + CHECK(p->learner_stats, ENOMEM); + + for (i = 0; i < p->n_learners; i++) { + p->learner_stats[i].n_pkts_action = calloc(p->n_actions, sizeof(uint64_t)); + CHECK(p->learner_stats[i].n_pkts_action, ENOMEM); + } + + /* Per thread: learner run-time. */ + for (i = 0; i < RTE_SWX_PIPELINE_THREADS_MAX; i++) { + struct thread *t = &p->threads[i]; + struct learner *l; + + t->learners = calloc(p->n_learners, sizeof(struct learner_runtime)); + if (!t->learners) { + status = -ENOMEM; + goto error; + } + + TAILQ_FOREACH(l, &p->learners, node) { + struct learner_runtime *r = &t->learners[l->id]; + uint64_t size; + uint32_t j; + + /* r->mailbox. */ + size = rte_swx_table_learner_mailbox_size_get(); + if (size) { + r->mailbox = calloc(1, size); + if (!r->mailbox) { + status = -ENOMEM; + goto error; + } + } + + /* r->key. */ + r->key = l->header ? + &t->structs[l->header->struct_id] : + &t->structs[p->metadata_struct_id]; + + /* r->action_data. */ + r->action_data = calloc(p->n_actions, sizeof(uint8_t *)); + if (!r->action_data) { + status = -ENOMEM; + goto error; + } + + for (j = 0; j < l->n_actions; j++) { + struct action *a = l->actions[j]; + struct field *mf = l->action_arg[j]; + uint8_t *m = t->structs[p->metadata_struct_id]; + + r->action_data[a->id] = mf ? &m[mf->offset / 8] : NULL; + } + } + } + + return 0; + +error: + learner_build_free(p); + return status; +} + +static void +learner_free(struct rte_swx_pipeline *p) +{ + learner_build_free(p); + + /* Learner tables. */ + for ( ; ; ) { + struct learner *l; + + l = TAILQ_FIRST(&p->learners); + if (!l) + break; + + TAILQ_REMOVE(&p->learners, l, node); + free(l->fields); + free(l->actions); + free(l->action_arg); + free(l->default_action_data); + free(l); + } +} + +/* + * Table state. + */ +static int +table_state_build(struct rte_swx_pipeline *p) +{ + struct table *table; + struct selector *s; + struct learner *l; + + p->table_state = calloc(p->n_tables + p->n_selectors, + sizeof(struct rte_swx_table_state)); + CHECK(p->table_state, ENOMEM); + + TAILQ_FOREACH(table, &p->tables, node) { + struct rte_swx_table_state *ts = &p->table_state[table->id]; + + if (table->type) { + struct rte_swx_table_params *params; + + /* ts->obj. */ + params = table_params_get(table); + CHECK(params, ENOMEM); + + ts->obj = table->type->ops.create(params, + NULL, + table->args, + p->numa_node); + + table_params_free(params); + CHECK(ts->obj, ENODEV); + } + + /* ts->default_action_data. */ + if (table->action_data_size_max) { + ts->default_action_data = + malloc(table->action_data_size_max); + CHECK(ts->default_action_data, ENOMEM); + + memcpy(ts->default_action_data, + table->default_action_data, + table->action_data_size_max); + } + + /* ts->default_action_id. */ + ts->default_action_id = table->default_action->id; + } + + TAILQ_FOREACH(s, &p->selectors, node) { + struct rte_swx_table_state *ts = &p->table_state[p->n_tables + s->id]; + struct rte_swx_table_selector_params *params; + + /* ts->obj. */ + params = selector_table_params_get(s); + CHECK(params, ENOMEM); + + ts->obj = rte_swx_table_selector_create(params, NULL, p->numa_node); + + selector_params_free(params); + CHECK(ts->obj, ENODEV); + } + + TAILQ_FOREACH(l, &p->learners, node) { + struct rte_swx_table_state *ts = &p->table_state[p->n_tables + + p->n_selectors + l->id]; + struct rte_swx_table_learner_params *params; + + /* ts->obj. */ + params = learner_params_get(l); + CHECK(params, ENOMEM); + + ts->obj = rte_swx_table_learner_create(params, p->numa_node); + learner_params_free(params); + CHECK(ts->obj, ENODEV); + + /* ts->default_action_data. */ + if (l->action_data_size_max) { + ts->default_action_data = malloc(l->action_data_size_max); + CHECK(ts->default_action_data, ENOMEM); + + memcpy(ts->default_action_data, + l->default_action_data, + l->action_data_size_max); + } + + /* ts->default_action_id. */ + ts->default_action_id = l->default_action->id; + } + + return 0; +} + +static void +table_state_build_free(struct rte_swx_pipeline *p) +{ + uint32_t i; if (!p->table_state) return; @@ -10312,6 +11131,17 @@ table_state_build_free(struct rte_swx_pipeline *p) rte_swx_table_selector_free(ts->obj); } + for (i = 0; i < p->n_learners; i++) { + struct rte_swx_table_state *ts = &p->table_state[p->n_tables + p->n_selectors + i]; + + /* ts->obj. */ + if (ts->obj) + rte_swx_table_learner_free(ts->obj); + + /* ts->default_action_data. */ + free(ts->default_action_data); + } + free(p->table_state); p->table_state = NULL; } @@ -10653,6 +11483,7 @@ rte_swx_pipeline_config(struct rte_swx_pipeline **p, int numa_node) TAILQ_INIT(&pipeline->table_types); TAILQ_INIT(&pipeline->tables); TAILQ_INIT(&pipeline->selectors); + TAILQ_INIT(&pipeline->learners); TAILQ_INIT(&pipeline->regarrays); TAILQ_INIT(&pipeline->meter_profiles); TAILQ_INIT(&pipeline->metarrays); @@ -10675,6 +11506,7 @@ rte_swx_pipeline_free(struct rte_swx_pipeline *p) metarray_free(p); regarray_free(p); table_state_free(p); + learner_free(p); selector_free(p); table_free(p); action_free(p); @@ -10759,6 +11591,10 @@ rte_swx_pipeline_build(struct rte_swx_pipeline *p) if (status) goto error; + status = learner_build(p); + if (status) + goto error; + status = table_state_build(p); if (status) goto error; @@ -10778,6 +11614,7 @@ rte_swx_pipeline_build(struct rte_swx_pipeline *p) metarray_build_free(p); regarray_build_free(p); table_state_build_free(p); + learner_build_free(p); selector_build_free(p); table_build_free(p); action_build_free(p); @@ -10839,6 +11676,7 @@ rte_swx_ctl_pipeline_info_get(struct rte_swx_pipeline *p, pipeline->n_actions = n_actions; pipeline->n_tables = n_tables; pipeline->n_selectors = p->n_selectors; + pipeline->n_learners = p->n_learners; pipeline->n_regarrays = p->n_regarrays; pipeline->n_metarrays = p->n_metarrays; @@ -11084,6 +11922,75 @@ rte_swx_ctl_selector_member_id_field_info_get(struct rte_swx_pipeline *p, return 0; } +int +rte_swx_ctl_learner_info_get(struct rte_swx_pipeline *p, + uint32_t learner_id, + struct rte_swx_ctl_learner_info *learner) +{ + struct learner *l = NULL; + + if (!p || !learner) + return -EINVAL; + + l = learner_find_by_id(p, learner_id); + if (!l) + return -EINVAL; + + strcpy(learner->name, l->name); + + learner->n_match_fields = l->n_fields; + learner->n_actions = l->n_actions; + learner->default_action_is_const = l->default_action_is_const; + learner->size = l->size; + + return 0; +} + +int +rte_swx_ctl_learner_match_field_info_get(struct rte_swx_pipeline *p, + uint32_t learner_id, + uint32_t match_field_id, + struct rte_swx_ctl_table_match_field_info *match_field) +{ + struct learner *l; + struct field *f; + + if (!p || (learner_id >= p->n_learners) || !match_field) + return -EINVAL; + + l = learner_find_by_id(p, learner_id); + if (!l || (match_field_id >= l->n_fields)) + return -EINVAL; + + f = l->fields[match_field_id]; + match_field->match_type = RTE_SWX_TABLE_MATCH_EXACT; + match_field->is_header = l->header ? 1 : 0; + match_field->n_bits = f->n_bits; + match_field->offset = f->offset; + + return 0; +} + +int +rte_swx_ctl_learner_action_info_get(struct rte_swx_pipeline *p, + uint32_t learner_id, + uint32_t learner_action_id, + struct rte_swx_ctl_table_action_info *learner_action) +{ + struct learner *l; + + if (!p || (learner_id >= p->n_learners) || !learner_action) + return -EINVAL; + + l = learner_find_by_id(p, learner_id); + if (!l || (learner_action_id >= l->n_actions)) + return -EINVAL; + + learner_action->action_id = l->actions[learner_action_id]->id; + + return 0; +} + int rte_swx_pipeline_table_state_get(struct rte_swx_pipeline *p, struct rte_swx_table_state **table_state) @@ -11188,6 +12095,38 @@ rte_swx_ctl_pipeline_selector_stats_read(struct rte_swx_pipeline *p, return 0; } +int +rte_swx_ctl_pipeline_learner_stats_read(struct rte_swx_pipeline *p, + const char *learner_name, + struct rte_swx_learner_stats *stats) +{ + struct learner *l; + struct learner_statistics *learner_stats; + + if (!p || !learner_name || !learner_name[0] || !stats || !stats->n_pkts_action) + return -EINVAL; + + l = learner_find(p, learner_name); + if (!l) + return -EINVAL; + + learner_stats = &p->learner_stats[l->id]; + + memcpy(stats->n_pkts_action, + learner_stats->n_pkts_action, + p->n_actions * sizeof(uint64_t)); + + stats->n_pkts_hit = learner_stats->n_pkts_hit[1]; + stats->n_pkts_miss = learner_stats->n_pkts_hit[0]; + + stats->n_pkts_learn_ok = learner_stats->n_pkts_learn[0]; + stats->n_pkts_learn_err = learner_stats->n_pkts_learn[1]; + + stats->n_pkts_forget = learner_stats->n_pkts_forget; + + return 0; +} + int rte_swx_ctl_regarray_info_get(struct rte_swx_pipeline *p, uint32_t regarray_id, diff --git a/lib/pipeline/rte_swx_pipeline.h b/lib/pipeline/rte_swx_pipeline.h index 5afca2bc20..2f18a820b9 100644 --- a/lib/pipeline/rte_swx_pipeline.h +++ b/lib/pipeline/rte_swx_pipeline.h @@ -676,6 +676,83 @@ rte_swx_pipeline_selector_config(struct rte_swx_pipeline *p, const char *name, struct rte_swx_pipeline_selector_params *params); +/** Pipeline learner table parameters. */ +struct rte_swx_pipeline_learner_params { + /** The set of match fields for the current table. + * Restriction: All the match fields of the current table need to be + * part of the same struct, i.e. either all the match fields are part of + * the same header or all the match fields are part of the meta-data. + */ + const char **field_names; + + /** The number of match fields for the current table. Must be non-zero. + */ + uint32_t n_fields; + + /** The set of actions for the current table. */ + const char **action_names; + + /** The number of actions for the current table. Must be at least one. + */ + uint32_t n_actions; + + /** This table type allows adding the latest lookup key (typically done + * only in the case of lookup miss) to the table with a given action. + * The action arguments are picked up from the packet meta-data: for + * each action, a set of successive meta-data fields (with the name of + * the first such field provided here) is 1:1 mapped to the action + * arguments. These meta-data fields must be set with the actual values + * of the action arguments before the key add operation. + */ + const char **action_field_names; + + /** The default table action that gets executed on lookup miss. Must be + * one of the table actions included in the *action_names*. + */ + const char *default_action_name; + + /** Default action data. The size of this array is the action data size + * of the default action. Must be NULL if the default action data size + * is zero. + */ + uint8_t *default_action_data; + + /** If non-zero (true), then the default action of the current table + * cannot be changed. If zero (false), then the default action can be + * changed in the future with another action from the *action_names* + * list. + */ + int default_action_is_const; +}; + +/** + * Pipeline learner table configure + * + * @param[out] p + * Pipeline handle. + * @param[in] name + * Learner table name. + * @param[in] params + * Learner table parameters. + * @param[in] size + * The maximum number of table entries. Must be non-zero. + * @param[in] timeout + * Table entry timeout in seconds. Must be non-zero. + * @return + * 0 on success or the following error codes otherwise: + * -EINVAL: Invalid argument; + * -ENOMEM: Not enough space/cannot allocate memory; + * -EEXIST: Learner table with this name already exists; + * -ENODEV: Learner table creation error. + */ +__rte_experimental +int +rte_swx_pipeline_learner_config(struct rte_swx_pipeline *p, + const char *name, + struct rte_swx_pipeline_learner_params *params, + uint32_t size, + uint32_t timeout); + /** * Pipeline register array configure * diff --git a/lib/pipeline/rte_swx_pipeline_spec.c b/lib/pipeline/rte_swx_pipeline_spec.c index c57893f18c..d9cd1d0595 100644 --- a/lib/pipeline/rte_swx_pipeline_spec.c +++ b/lib/pipeline/rte_swx_pipeline_spec.c @@ -20,7 +20,10 @@ #define TABLE_ACTIONS_BLOCK 4 #define SELECTOR_BLOCK 5 #define SELECTOR_SELECTOR_BLOCK 6 -#define APPLY_BLOCK 7 +#define LEARNER_BLOCK 7 +#define LEARNER_KEY_BLOCK 8 +#define LEARNER_ACTIONS_BLOCK 9 +#define APPLY_BLOCK 10 /* * extobj. @@ -1281,6 +1284,420 @@ selector_block_parse(struct selector_spec *s, return -EINVAL; } +/* + * learner. + * + * learner { + * key { + * MATCH_FIELD_NAME + * ... + * } + * actions { + * ACTION_NAME args METADATA_FIELD_NAME + * ... + * } + * default_action ACTION_NAME args none | ARGS_BYTE_ARRAY [ const ] + * size SIZE + * timeout TIMEOUT_IN_SECONDS + * } + */ +struct learner_spec { + char *name; + struct rte_swx_pipeline_learner_params params; + uint32_t size; + uint32_t timeout; +}; + +static void +learner_spec_free(struct learner_spec *s) +{ + uintptr_t default_action_name; + uint32_t i; + + if (!s) + return; + + free(s->name); + s->name = NULL; + + for (i = 0; i < s->params.n_fields; i++) { + uintptr_t name = (uintptr_t)s->params.field_names[i]; + + free((void *)name); + } + + free(s->params.field_names); + s->params.field_names = NULL; + + s->params.n_fields = 0; + + for (i = 0; i < s->params.n_actions; i++) { + uintptr_t name = (uintptr_t)s->params.action_names[i]; + + free((void *)name); + } + + free(s->params.action_names); + s->params.action_names = NULL; + + for (i = 0; i < s->params.n_actions; i++) { + uintptr_t name = (uintptr_t)s->params.action_field_names[i]; + + free((void *)name); + } + + free(s->params.action_field_names); + s->params.action_field_names = NULL; + + s->params.n_actions = 0; + + default_action_name = (uintptr_t)s->params.default_action_name; + free((void *)default_action_name); + s->params.default_action_name = NULL; + + free(s->params.default_action_data); + s->params.default_action_data = NULL; + + s->params.default_action_is_const = 0; + + s->size = 0; + + s->timeout = 0; +} + +static int +learner_key_statement_parse(uint32_t *block_mask, + char **tokens, + uint32_t n_tokens, + uint32_t n_lines, + uint32_t *err_line, + const char **err_msg) +{ + /* Check format. */ + if ((n_tokens != 2) || strcmp(tokens[1], "{")) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid key statement."; + return -EINVAL; + } + + /* block_mask. */ + *block_mask |= 1 << LEARNER_KEY_BLOCK; + + return 0; +} + +static int +learner_key_block_parse(struct learner_spec *s, + uint32_t *block_mask, + char **tokens, + uint32_t n_tokens, + uint32_t n_lines, + uint32_t *err_line, + const char **err_msg) +{ + const char **new_field_names = NULL; + char *field_name = NULL; + + /* Handle end of block. */ + if ((n_tokens == 1) && !strcmp(tokens[0], "}")) { + *block_mask &= ~(1 << LEARNER_KEY_BLOCK); + return 0; + } + + /* Check input arguments. */ + if (n_tokens != 1) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid match field statement."; + return -EINVAL; + } + + field_name = strdup(tokens[0]); + new_field_names = realloc(s->params.field_names, (s->params.n_fields + 1) * sizeof(char *)); + if (!field_name || !new_field_names) { + free(field_name); + free(new_field_names); + + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Memory allocation failed."; + return -ENOMEM; + } + + s->params.field_names = new_field_names; + s->params.field_names[s->params.n_fields] = field_name; + s->params.n_fields++; + + return 0; +} + +static int +learner_actions_statement_parse(uint32_t *block_mask, + char **tokens, + uint32_t n_tokens, + uint32_t n_lines, + uint32_t *err_line, + const char **err_msg) +{ + /* Check format. */ + if ((n_tokens != 2) || strcmp(tokens[1], "{")) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid actions statement."; + return -EINVAL; + } + + /* block_mask. */ + *block_mask |= 1 << LEARNER_ACTIONS_BLOCK; + + return 0; +} + +static int +learner_actions_block_parse(struct learner_spec *s, + uint32_t *block_mask, + char **tokens, + uint32_t n_tokens, + uint32_t n_lines, + uint32_t *err_line, + const char **err_msg) +{ + const char **new_action_names = NULL; + const char **new_action_field_names = NULL; + char *action_name = NULL, *action_field_name = NULL; + int has_args = 1; + + /* Handle end of block. */ + if ((n_tokens == 1) && !strcmp(tokens[0], "}")) { + *block_mask &= ~(1 << LEARNER_ACTIONS_BLOCK); + return 0; + } + + /* Check input arguments. */ + if ((n_tokens != 3) || strcmp(tokens[1], "args")) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid action name statement."; + return -EINVAL; + } + + if (!strcmp(tokens[2], "none")) + has_args = 0; + + action_name = strdup(tokens[0]); + + if (has_args) + action_field_name = strdup(tokens[2]); + + new_action_names = realloc(s->params.action_names, + (s->params.n_actions + 1) * sizeof(char *)); + + new_action_field_names = realloc(s->params.action_field_names, + (s->params.n_actions + 1) * sizeof(char *)); + + if (!action_name || + (has_args && !action_field_name) || + !new_action_names || + !new_action_field_names) { + free(action_name); + free(action_field_name); + free(new_action_names); + free(new_action_field_names); + + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Memory allocation failed."; + return -ENOMEM; + } + + s->params.action_names = new_action_names; + s->params.action_names[s->params.n_actions] = action_name; + s->params.action_field_names = new_action_field_names; + s->params.action_field_names[s->params.n_actions] = action_field_name; + s->params.n_actions++; + + return 0; +} + +static int +learner_statement_parse(struct learner_spec *s, + uint32_t *block_mask, + char **tokens, + uint32_t n_tokens, + uint32_t n_lines, + uint32_t *err_line, + const char **err_msg) +{ + /* Check format. */ + if ((n_tokens != 3) || strcmp(tokens[2], "{")) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid learner statement."; + return -EINVAL; + } + + /* spec. */ + s->name = strdup(tokens[1]); + if (!s->name) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Memory allocation failed."; + return -ENOMEM; + } + + /* block_mask. */ + *block_mask |= 1 << LEARNER_BLOCK; + + return 0; +} + +static int +learner_block_parse(struct learner_spec *s, + uint32_t *block_mask, + char **tokens, + uint32_t n_tokens, + uint32_t n_lines, + uint32_t *err_line, + const char **err_msg) +{ + if (*block_mask & (1 << LEARNER_KEY_BLOCK)) + return learner_key_block_parse(s, + block_mask, + tokens, + n_tokens, + n_lines, + err_line, + err_msg); + + if (*block_mask & (1 << LEARNER_ACTIONS_BLOCK)) + return learner_actions_block_parse(s, + block_mask, + tokens, + n_tokens, + n_lines, + err_line, + err_msg); + + /* Handle end of block. */ + if ((n_tokens == 1) && !strcmp(tokens[0], "}")) { + *block_mask &= ~(1 << LEARNER_BLOCK); + return 0; + } + + if (!strcmp(tokens[0], "key")) + return learner_key_statement_parse(block_mask, + tokens, + n_tokens, + n_lines, + err_line, + err_msg); + + if (!strcmp(tokens[0], "actions")) + return learner_actions_statement_parse(block_mask, + tokens, + n_tokens, + n_lines, + err_line, + err_msg); + + if (!strcmp(tokens[0], "default_action")) { + if (((n_tokens != 4) && (n_tokens != 5)) || + strcmp(tokens[2], "args") || + strcmp(tokens[3], "none") || + ((n_tokens == 5) && strcmp(tokens[4], "const"))) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid default_action statement."; + return -EINVAL; + } + + if (s->params.default_action_name) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Duplicate default_action stmt."; + return -EINVAL; + } + + s->params.default_action_name = strdup(tokens[1]); + if (!s->params.default_action_name) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Memory allocation failed."; + return -ENOMEM; + } + + if (n_tokens == 5) + s->params.default_action_is_const = 1; + + return 0; + } + + if (!strcmp(tokens[0], "size")) { + char *p = tokens[1]; + + if (n_tokens != 2) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid size statement."; + return -EINVAL; + } + + s->size = strtoul(p, &p, 0); + if (p[0]) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid size argument."; + return -EINVAL; + } + + return 0; + } + + if (!strcmp(tokens[0], "timeout")) { + char *p = tokens[1]; + + if (n_tokens != 2) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid timeout statement."; + return -EINVAL; + } + + s->timeout = strtoul(p, &p, 0); + if (p[0]) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid timeout argument."; + return -EINVAL; + } + + return 0; + } + + /* Anything else. */ + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Invalid statement."; + return -EINVAL; +} + /* * regarray. * @@ -1545,6 +1962,7 @@ rte_swx_pipeline_build_from_spec(struct rte_swx_pipeline *p, struct action_spec action_spec = {0}; struct table_spec table_spec = {0}; struct selector_spec selector_spec = {0}; + struct learner_spec learner_spec = {0}; struct regarray_spec regarray_spec = {0}; struct metarray_spec metarray_spec = {0}; struct apply_spec apply_spec = {0}; @@ -1761,6 +2179,40 @@ rte_swx_pipeline_build_from_spec(struct rte_swx_pipeline *p, continue; } + /* learner block. */ + if (block_mask & (1 << LEARNER_BLOCK)) { + status = learner_block_parse(&learner_spec, + &block_mask, + tokens, + n_tokens, + n_lines, + err_line, + err_msg); + if (status) + goto error; + + if (block_mask & (1 << LEARNER_BLOCK)) + continue; + + /* End of block. */ + status = rte_swx_pipeline_learner_config(p, + learner_spec.name, + &learner_spec.params, + learner_spec.size, + learner_spec.timeout); + if (status) { + if (err_line) + *err_line = n_lines; + if (err_msg) + *err_msg = "Learner table configuration error."; + goto error; + } + + learner_spec_free(&learner_spec); + + continue; + } + /* apply block. */ if (block_mask & (1 << APPLY_BLOCK)) { status = apply_block_parse(&apply_spec, @@ -1934,6 +2386,21 @@ rte_swx_pipeline_build_from_spec(struct rte_swx_pipeline *p, continue; } + /* learner. */ + if (!strcmp(tokens[0], "learner")) { + status = learner_statement_parse(&learner_spec, + &block_mask, + tokens, + n_tokens, + n_lines, + err_line, + err_msg); + if (status) + goto error; + + continue; + } + /* regarray. */ if (!strcmp(tokens[0], "regarray")) { status = regarray_statement_parse(®array_spec, @@ -2042,6 +2509,7 @@ rte_swx_pipeline_build_from_spec(struct rte_swx_pipeline *p, action_spec_free(&action_spec); table_spec_free(&table_spec); selector_spec_free(&selector_spec); + learner_spec_free(&learner_spec); regarray_spec_free(®array_spec); metarray_spec_free(&metarray_spec); apply_spec_free(&apply_spec); diff --git a/lib/pipeline/version.map b/lib/pipeline/version.map index 2b68f584a4..8bc90e7cd7 100644 --- a/lib/pipeline/version.map +++ b/lib/pipeline/version.map @@ -129,4 +129,13 @@ EXPERIMENTAL { rte_swx_ctl_selector_field_info_get; rte_swx_ctl_selector_group_id_field_info_get; rte_swx_ctl_selector_member_id_field_info_get; + + #added in 21.11 + rte_swx_ctl_pipeline_learner_default_entry_add; + rte_swx_ctl_pipeline_learner_default_entry_read; + rte_swx_ctl_pipeline_learner_stats_read; + rte_swx_ctl_learner_action_info_get; + rte_swx_ctl_learner_info_get; + rte_swx_ctl_learner_match_field_info_get; + rte_swx_pipeline_learner_config; }; From patchwork Mon Sep 20 15:01:32 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Dumitrescu X-Patchwork-Id: 99324 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id D5408A0548; Mon, 20 Sep 2021 17:01:50 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id 41A33410F5; Mon, 20 Sep 2021 17:01:41 +0200 (CEST) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by mails.dpdk.org (Postfix) with ESMTP id CE5EE40DF7 for ; Mon, 20 Sep 2021 17:01:38 +0200 (CEST) X-IronPort-AV: E=McAfee;i="6200,9189,10113"; a="245557187" X-IronPort-AV: E=Sophos;i="5.85,308,1624345200"; d="scan'208";a="245557187" Received: from orsmga003.jf.intel.com ([10.7.209.27]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Sep 2021 08:01:38 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.85,308,1624345200"; d="scan'208";a="435552186" Received: from silpixa00400573.ir.intel.com (HELO silpixa00400573.ger.corp.intel.com) ([10.237.223.107]) by orsmga003.jf.intel.com with ESMTP; 20 Sep 2021 08:01:37 -0700 From: Cristian Dumitrescu To: dev@dpdk.org Date: Mon, 20 Sep 2021 16:01:32 +0100 Message-Id: <20210920150133.84928-3-cristian.dumitrescu@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20210920150133.84928-1-cristian.dumitrescu@intel.com> References: <20210816122257.84651-1-cristian.dumitrescu@intel.com> <20210920150133.84928-1-cristian.dumitrescu@intel.com> Subject: [dpdk-dev] [PATCH V5 3/4] examples/pipeline: add support for learner tables X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Add application-level support for learner tables. Signed-off-by: Cristian Dumitrescu --- examples/pipeline/cli.c | 174 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 174 insertions(+) diff --git a/examples/pipeline/cli.c b/examples/pipeline/cli.c index 1e2dd9d704..39b1e7a41b 100644 --- a/examples/pipeline/cli.c +++ b/examples/pipeline/cli.c @@ -1829,6 +1829,104 @@ cmd_pipeline_selector_show(char **tokens, snprintf(out, out_size, MSG_ARG_INVALID, "selector_name"); } +static int +pipeline_learner_default_entry_add(struct rte_swx_ctl_pipeline *p, + const char *learner_name, + FILE *file, + uint32_t *file_line_number) +{ + char *line = NULL; + uint32_t line_id = 0; + int status = 0; + + /* Buffer allocation. */ + line = malloc(MAX_LINE_SIZE); + if (!line) + return -ENOMEM; + + /* File read. */ + for (line_id = 1; ; line_id++) { + struct rte_swx_table_entry *entry; + int is_blank_or_comment; + + if (fgets(line, MAX_LINE_SIZE, file) == NULL) + break; + + entry = rte_swx_ctl_pipeline_learner_default_entry_read(p, + learner_name, + line, + &is_blank_or_comment); + if (!entry) { + if (is_blank_or_comment) + continue; + + status = -EINVAL; + goto error; + } + + status = rte_swx_ctl_pipeline_learner_default_entry_add(p, + learner_name, + entry); + table_entry_free(entry); + if (status) + goto error; + } + +error: + *file_line_number = line_id; + free(line); + return status; +} + +static const char cmd_pipeline_learner_default_help[] = +"pipeline learner default \n"; + +static void +cmd_pipeline_learner_default(char **tokens, + uint32_t n_tokens, + char *out, + size_t out_size, + void *obj) +{ + struct pipeline *p; + char *pipeline_name, *learner_name, *file_name; + FILE *file = NULL; + uint32_t file_line_number = 0; + int status; + + if (n_tokens != 6) { + snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); + return; + } + + pipeline_name = tokens[1]; + p = pipeline_find(obj, pipeline_name); + if (!p || !p->ctl) { + snprintf(out, out_size, MSG_ARG_INVALID, "pipeline_name"); + return; + } + + learner_name = tokens[3]; + + file_name = tokens[5]; + file = fopen(file_name, "r"); + if (!file) { + snprintf(out, out_size, "Cannot open file %s.\n", file_name); + return; + } + + status = pipeline_learner_default_entry_add(p->ctl, + learner_name, + file, + &file_line_number); + if (status) + snprintf(out, out_size, "Invalid entry in file %s at line %u\n", + file_name, + file_line_number); + + fclose(file); +} + static const char cmd_pipeline_commit_help[] = "pipeline commit\n"; @@ -2503,6 +2601,64 @@ cmd_pipeline_stats(char **tokens, out += strlen(out); } } + + snprintf(out, out_size, "\nLearner tables:\n"); + out_size -= strlen(out); + out += strlen(out); + + for (i = 0; i < info.n_learners; i++) { + struct rte_swx_ctl_learner_info learner_info; + uint64_t n_pkts_action[info.n_actions]; + struct rte_swx_learner_stats stats = { + .n_pkts_hit = 0, + .n_pkts_miss = 0, + .n_pkts_action = n_pkts_action, + }; + uint32_t j; + + status = rte_swx_ctl_learner_info_get(p->p, i, &learner_info); + if (status) { + snprintf(out, out_size, "Learner table info get error."); + return; + } + + status = rte_swx_ctl_pipeline_learner_stats_read(p->p, learner_info.name, &stats); + if (status) { + snprintf(out, out_size, "Learner table stats read error."); + return; + } + + snprintf(out, out_size, "\tLearner table %s:\n" + "\t\tHit (packets): %" PRIu64 "\n" + "\t\tMiss (packets): %" PRIu64 "\n" + "\t\tLearn OK (packets): %" PRIu64 "\n" + "\t\tLearn error (packets): %" PRIu64 "\n" + "\t\tForget (packets): %" PRIu64 "\n", + learner_info.name, + stats.n_pkts_hit, + stats.n_pkts_miss, + stats.n_pkts_learn_ok, + stats.n_pkts_learn_err, + stats.n_pkts_forget); + out_size -= strlen(out); + out += strlen(out); + + for (j = 0; j < info.n_actions; j++) { + struct rte_swx_ctl_action_info action_info; + + status = rte_swx_ctl_action_info_get(p->p, j, &action_info); + if (status) { + snprintf(out, out_size, "Action info get error."); + return; + } + + snprintf(out, out_size, "\t\tAction %s (packets): %" PRIu64 "\n", + action_info.name, + stats.n_pkts_action[j]); + out_size -= strlen(out); + out += strlen(out); + } + } } static const char cmd_thread_pipeline_enable_help[] = @@ -2634,6 +2790,7 @@ cmd_help(char **tokens, "\tpipeline selector group member add\n" "\tpipeline selector group member delete\n" "\tpipeline selector show\n" + "\tpipeline learner default\n" "\tpipeline commit\n" "\tpipeline abort\n" "\tpipeline regrd\n" @@ -2783,6 +2940,15 @@ cmd_help(char **tokens, return; } + if ((strcmp(tokens[0], "pipeline") == 0) && + (n_tokens == 3) && + (strcmp(tokens[1], "learner") == 0) && + (strcmp(tokens[2], "default") == 0)) { + snprintf(out, out_size, "\n%s\n", + cmd_pipeline_learner_default_help); + return; + } + if ((strcmp(tokens[0], "pipeline") == 0) && (n_tokens == 2) && (strcmp(tokens[1], "commit") == 0)) { @@ -3031,6 +3197,14 @@ cli_process(char *in, char *out, size_t out_size, void *obj) return; } + if ((n_tokens >= 5) && + (strcmp(tokens[2], "learner") == 0) && + (strcmp(tokens[4], "default") == 0)) { + cmd_pipeline_learner_default(tokens, n_tokens, out, + out_size, obj); + return; + } + if ((n_tokens >= 3) && (strcmp(tokens[2], "commit") == 0)) { cmd_pipeline_commit(tokens, n_tokens, out, From patchwork Mon Sep 20 15:01:33 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Cristian Dumitrescu X-Patchwork-Id: 99326 X-Patchwork-Delegate: thomas@monjalon.net Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from mails.dpdk.org (mails.dpdk.org [217.70.189.124]) by inbox.dpdk.org (Postfix) with ESMTP id AA812A0548; Mon, 20 Sep 2021 17:02:11 +0200 (CEST) Received: from [217.70.189.124] (localhost [127.0.0.1]) by mails.dpdk.org (Postfix) with ESMTP id C096141101; Mon, 20 Sep 2021 17:01:43 +0200 (CEST) Received: from mga01.intel.com (mga01.intel.com [192.55.52.88]) by mails.dpdk.org (Postfix) with ESMTP id B74F840DF7 for ; Mon, 20 Sep 2021 17:01:39 +0200 (CEST) X-IronPort-AV: E=McAfee;i="6200,9189,10113"; a="245557197" X-IronPort-AV: E=Sophos;i="5.85,308,1624345200"; d="scan'208";a="245557197" Received: from orsmga003.jf.intel.com ([10.7.209.27]) by fmsmga101.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 20 Sep 2021 08:01:39 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.85,308,1624345200"; d="scan'208";a="435552198" Received: from silpixa00400573.ir.intel.com (HELO silpixa00400573.ger.corp.intel.com) ([10.237.223.107]) by orsmga003.jf.intel.com with ESMTP; 20 Sep 2021 08:01:38 -0700 From: Cristian Dumitrescu To: dev@dpdk.org Date: Mon, 20 Sep 2021 16:01:33 +0100 Message-Id: <20210920150133.84928-4-cristian.dumitrescu@intel.com> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20210920150133.84928-1-cristian.dumitrescu@intel.com> References: <20210816122257.84651-1-cristian.dumitrescu@intel.com> <20210920150133.84928-1-cristian.dumitrescu@intel.com> Subject: [dpdk-dev] [PATCH V5 4/4] examples/pipeline: add learner table example X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" Added the files to illustrate the learner table usage. Signed-off-by: Cristian Dumitrescu --- V2: Added description to the .spec file. examples/pipeline/examples/learner.cli | 37 +++++++ examples/pipeline/examples/learner.spec | 127 ++++++++++++++++++++++++ 2 files changed, 164 insertions(+) create mode 100644 examples/pipeline/examples/learner.cli create mode 100644 examples/pipeline/examples/learner.spec diff --git a/examples/pipeline/examples/learner.cli b/examples/pipeline/examples/learner.cli new file mode 100644 index 0000000000..af7792624f --- /dev/null +++ b/examples/pipeline/examples/learner.cli @@ -0,0 +1,37 @@ +; SPDX-License-Identifier: BSD-3-Clause +; Copyright(c) 2020 Intel Corporation + +; +; Customize the LINK parameters to match your setup. +; +mempool MEMPOOL0 buffer 2304 pool 32K cache 256 cpu 0 + +link LINK0 dev 0000:18:00.0 rxq 1 128 MEMPOOL0 txq 1 512 promiscuous on +link LINK1 dev 0000:18:00.1 rxq 1 128 MEMPOOL0 txq 1 512 promiscuous on +link LINK2 dev 0000:3b:00.0 rxq 1 128 MEMPOOL0 txq 1 512 promiscuous on +link LINK3 dev 0000:3b:00.1 rxq 1 128 MEMPOOL0 txq 1 512 promiscuous on + +; +; PIPELINE0 setup. +; +pipeline PIPELINE0 create 0 + +pipeline PIPELINE0 port in 0 link LINK0 rxq 0 bsz 32 +pipeline PIPELINE0 port in 1 link LINK1 rxq 0 bsz 32 +pipeline PIPELINE0 port in 2 link LINK2 rxq 0 bsz 32 +pipeline PIPELINE0 port in 3 link LINK3 rxq 0 bsz 32 + +pipeline PIPELINE0 port out 0 link LINK0 txq 0 bsz 32 +pipeline PIPELINE0 port out 1 link LINK1 txq 0 bsz 32 +pipeline PIPELINE0 port out 2 link LINK2 txq 0 bsz 32 +pipeline PIPELINE0 port out 3 link LINK3 txq 0 bsz 32 +pipeline PIPELINE0 port out 4 sink none + +pipeline PIPELINE0 build ./examples/pipeline/examples/learner.spec + +; +; Pipelines-to-threads mapping. +; +thread 1 pipeline PIPELINE0 enable + +; Once the application has started, the command to get the CLI prompt is: telnet 0.0.0.0 8086 diff --git a/examples/pipeline/examples/learner.spec b/examples/pipeline/examples/learner.spec new file mode 100644 index 0000000000..d635422282 --- /dev/null +++ b/examples/pipeline/examples/learner.spec @@ -0,0 +1,127 @@ +; SPDX-License-Identifier: BSD-3-Clause +; Copyright(c) 2020 Intel Corporation + +; The learner tables are very useful for learning and connection tracking. +; +; As opposed to regular tables, which are read-only for the data plane, the learner tables can be +; updated by the data plane without any control plane intervention. The "learning" process typically +; takes place by having the default action (i.e. the table action which is executed on lookup miss) +; explicitly add to the table with a specific action the key that just missed the lookup operation. +; Each table key expires automatically after a configurable timeout period if not hit during this +; interval. +; +; This example demonstrates a simple connection tracking setup, where the connections are identified +; by the IPv4 destination address. The forwarding action assigned to each new connection gets the +; output port as argument, with the output port of each connection generated by a counter that is +; persistent between packets. On top of the usual table stats, the learner table stats include the +; number of packets with learning related events. + +// +// Headers +// +struct ethernet_h { + bit<48> dst_addr + bit<48> src_addr + bit<16> ethertype +} + +struct ipv4_h { + bit<8> ver_ihl + bit<8> diffserv + bit<16> total_len + bit<16> identification + bit<16> flags_offset + bit<8> ttl + bit<8> protocol + bit<16> hdr_checksum + bit<32> src_addr + bit<32> dst_addr +} + +header ethernet instanceof ethernet_h +header ipv4 instanceof ipv4_h + +// +// Meta-data +// +struct metadata_t { + bit<32> port_in + bit<32> port_out + + // Arguments for the "fwd_action" action. + bit<32> fwd_action_arg_port_out +} + +metadata instanceof metadata_t + +// +// Registers. +// +regarray counter size 1 initval 0 + +// +// Actions +// +struct fwd_action_args_t { + bit<32> port_out +} + +action fwd_action args instanceof fwd_action_args_t { + mov m.port_out t.port_out + return +} + +action learn_action args none { + // Read current counter value into m.fwd_action_arg_port_out. + regrd m.fwd_action_arg_port_out counter 0 + + // Increment the counter. + regadd counter 0 1 + + // Limit the output port values to 0 .. 3. + and m.fwd_action_arg_port_out 3 + + // Add the current lookup key to the table with fwd_action as the key action. The action + // arguments are read from the packet meta-data (the m.fwd_action_arg_port_out field). These + // packet meta-data fields have to be written before the "learn" instruction is invoked. + learn fwd_action + + // Send the current packet to the same output port. + mov m.port_out m.fwd_action_arg_port_out + + return +} + +// +// Tables. +// +learner fwd_table { + key { + h.ipv4.dst_addr + } + + actions { + fwd_action args m.fwd_action_arg_port_out + + learn_action args none + } + + default_action learn_action args none + + size 1048576 + + timeout 120 +} + +// +// Pipeline. +// +apply { + rx m.port_in + extract h.ethernet + extract h.ipv4 + table fwd_table + emit h.ethernet + emit h.ipv4 + tx m.port_out +}