From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga02.intel.com (mga02.intel.com [134.134.136.20]) by dpdk.org (Postfix) with ESMTP id 274AD95BE for ; Wed, 21 Oct 2015 14:51:55 +0200 (CEST) Received: from orsmga001.jf.intel.com ([10.7.209.18]) by orsmga101.jf.intel.com with ESMTP; 21 Oct 2015 05:51:54 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.17,712,1437462000"; d="scan'208";a="799083753" Received: from irvmail001.ir.intel.com ([163.33.26.43]) by orsmga001.jf.intel.com with ESMTP; 21 Oct 2015 05:51:37 -0700 Received: from sivswdev02.ir.intel.com (sivswdev02.ir.intel.com [10.237.217.46]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id t9LCI6FH021606; Wed, 21 Oct 2015 13:18:06 +0100 Received: from sivswdev02.ir.intel.com (localhost [127.0.0.1]) by sivswdev02.ir.intel.com with ESMTP id t9LCI66Y000767; Wed, 21 Oct 2015 13:18:06 +0100 Received: (from jasvinde@localhost) by sivswdev02.ir.intel.com with id t9LCI691000763; Wed, 21 Oct 2015 13:18:06 +0100 From: Jasvinder Singh To: dev@dpdk.org Date: Wed, 21 Oct 2015 13:18:01 +0100 Message-Id: <1445429886-599-2-git-send-email-jasvinder.singh@intel.com> X-Mailer: git-send-email 1.7.4.1 In-Reply-To: <1445429886-599-1-git-send-email-jasvinder.singh@intel.com> References: <1444744652-573-1-git-send-email-jasvinder.singh@intel.com> <1445429886-599-1-git-send-email-jasvinder.singh@intel.com> Subject: [dpdk-dev] [PATCH v3 1/6] librte_table: add key_mask parameter to 8- and 16-bytes key hash parameters X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Wed, 21 Oct 2015 12:51:56 -0000 From: Fan Zhang This patch relates to ABI change proposed for librte_table. The key_mask parameter is added for 8-byte and 16-byte key extendible bucket and LRU tables.The release notes is updated and the deprecation notice is removed. Signed-off-by: Fan Zhang Signed-off-by: Jasvinder Singh --- doc/guides/rel_notes/deprecation.rst | 4 --- doc/guides/rel_notes/release_2_2.rst | 4 +++ lib/librte_table/rte_table_hash.h | 12 ++++++++ lib/librte_table/rte_table_hash_key16.c | 52 ++++++++++++++++++++++++++----- lib/librte_table/rte_table_hash_key8.c | 54 +++++++++++++++++++++++++++------ lib/librte_table/rte_table_version.map | 7 +++++ 6 files changed, 112 insertions(+), 21 deletions(-) diff --git a/doc/guides/rel_notes/deprecation.rst b/doc/guides/rel_notes/deprecation.rst index 018a119..f8b8ca9 100644 --- a/doc/guides/rel_notes/deprecation.rst +++ b/doc/guides/rel_notes/deprecation.rst @@ -48,10 +48,6 @@ Deprecation Notices * librte_table: New functions for table entry bulk add/delete will be added to the table operations structure. -* librte_table hash: Key mask parameter will be added to the hash table - parameter structure for 8-byte key and 16-byte key extendible bucket and - LRU tables. - * librte_pipeline: The prototype for the pipeline input port, output port and table action handlers will be updated: the pipeline parameter will be added, the packets mask parameter will be diff --git a/doc/guides/rel_notes/release_2_2.rst b/doc/guides/rel_notes/release_2_2.rst index 4f75cff..deb36c7 100644 --- a/doc/guides/rel_notes/release_2_2.rst +++ b/doc/guides/rel_notes/release_2_2.rst @@ -117,6 +117,10 @@ ABI Changes * librte_port: Macros to access the packet meta-data stored within the packet buffer has been adjusted to cover the packet mbuf structure. +* librte_table hash: The key mask parameter is added to the hash table + parameter structure for 8-byte key and 16-byte key extendible bucket + and LRU tables. + Shared Library Versions ----------------------- diff --git a/lib/librte_table/rte_table_hash.h b/lib/librte_table/rte_table_hash.h index 9181942..e2c60e1 100644 --- a/lib/librte_table/rte_table_hash.h +++ b/lib/librte_table/rte_table_hash.h @@ -196,6 +196,9 @@ struct rte_table_hash_key8_lru_params { /** Byte offset within packet meta-data where the key is located */ uint32_t key_offset; + + /** Bit-mask to be AND-ed to the key on lookup */ + uint8_t *key_mask; }; /** LRU hash table operations for pre-computed key signature */ @@ -226,6 +229,9 @@ struct rte_table_hash_key8_ext_params { /** Byte offset within packet meta-data where the key is located */ uint32_t key_offset; + + /** Bit-mask to be AND-ed to the key on lookup */ + uint8_t *key_mask; }; /** Extendible bucket hash table operations for pre-computed key signature */ @@ -257,6 +263,9 @@ struct rte_table_hash_key16_lru_params { /** Byte offset within packet meta-data where the key is located */ uint32_t key_offset; + + /** Bit-mask to be AND-ed to the key on lookup */ + uint8_t *key_mask; }; /** LRU hash table operations for pre-computed key signature */ @@ -284,6 +293,9 @@ struct rte_table_hash_key16_ext_params { /** Byte offset within packet meta-data where the key is located */ uint32_t key_offset; + + /** Bit-mask to be AND-ed to the key on lookup */ + uint8_t *key_mask; }; /** Extendible bucket operations for pre-computed key signature */ diff --git a/lib/librte_table/rte_table_hash_key16.c b/lib/librte_table/rte_table_hash_key16.c index f6a3306..0d6cc55 100644 --- a/lib/librte_table/rte_table_hash_key16.c +++ b/lib/librte_table/rte_table_hash_key16.c @@ -85,6 +85,7 @@ struct rte_table_hash { uint32_t bucket_size; uint32_t signature_offset; uint32_t key_offset; + uint64_t key_mask[2]; rte_table_hash_op_hash f_hash; uint64_t seed; @@ -164,6 +165,14 @@ rte_table_hash_create_key16_lru(void *params, f->f_hash = p->f_hash; f->seed = p->seed; + if (p->key_mask != NULL) { + f->key_mask[0] = ((uint64_t *)p->key_mask)[0]; + f->key_mask[1] = ((uint64_t *)p->key_mask)[1]; + } else { + f->key_mask[0] = 0xFFFFFFFFFFFFFFFFLLU; + f->key_mask[1] = 0xFFFFFFFFFFFFFFFFLLU; + } + for (i = 0; i < n_buckets; i++) { struct rte_bucket_4_16 *bucket; @@ -384,6 +393,14 @@ rte_table_hash_create_key16_ext(void *params, for (i = 0; i < n_buckets_ext; i++) f->stack[i] = i; + if (p->key_mask != NULL) { + f->key_mask[0] = (((uint64_t *)p->key_mask)[0]); + f->key_mask[1] = (((uint64_t *)p->key_mask)[1]); + } else { + f->key_mask[0] = 0xFFFFFFFFFFFFFFFFLLU; + f->key_mask[1] = 0xFFFFFFFFFFFFFFFFLLU; + } + return f; } @@ -609,11 +626,14 @@ rte_table_hash_entry_delete_key16_ext( void *a; \ uint64_t pkt_mask; \ uint64_t *key; \ + uint64_t hash_key_buffer[2]; \ uint32_t pos; \ \ key = RTE_MBUF_METADATA_UINT64_PTR(mbuf2, f->key_offset);\ + hash_key_buffer[0] = key[0] & f->key_mask[0]; \ + hash_key_buffer[1] = key[1] & f->key_mask[1]; \ \ - lookup_key16_cmp(key, bucket2, pos); \ + lookup_key16_cmp(hash_key_buffer, bucket2, pos); \ \ pkt_mask = (bucket2->signature[pos] & 1LLU) << pkt2_index;\ pkts_mask_out |= pkt_mask; \ @@ -631,11 +651,14 @@ rte_table_hash_entry_delete_key16_ext( void *a; \ uint64_t pkt_mask, bucket_mask; \ uint64_t *key; \ + uint64_t hash_key_buffer[2]; \ uint32_t pos; \ \ key = RTE_MBUF_METADATA_UINT64_PTR(mbuf2, f->key_offset);\ + hash_key_buffer[0] = key[0] & f->key_mask[0]; \ + hash_key_buffer[1] = key[1] & f->key_mask[1]; \ \ - lookup_key16_cmp(key, bucket2, pos); \ + lookup_key16_cmp(hash_key_buffer, bucket2, pos); \ \ pkt_mask = (bucket2->signature[pos] & 1LLU) << pkt2_index;\ pkts_mask_out |= pkt_mask; \ @@ -658,12 +681,15 @@ rte_table_hash_entry_delete_key16_ext( void *a; \ uint64_t pkt_mask, bucket_mask; \ uint64_t *key; \ + uint64_t hash_key_buffer[2]; \ uint32_t pos; \ \ bucket = buckets[pkt_index]; \ key = keys[pkt_index]; \ + hash_key_buffer[0] = key[0] & f->key_mask[0]; \ + hash_key_buffer[1] = key[1] & f->key_mask[1]; \ \ - lookup_key16_cmp(key, bucket, pos); \ + lookup_key16_cmp(hash_key_buffer, bucket, pos); \ \ pkt_mask = (bucket->signature[pos] & 1LLU) << pkt_index;\ pkts_mask_out |= pkt_mask; \ @@ -749,13 +775,19 @@ rte_table_hash_entry_delete_key16_ext( void *a20, *a21; \ uint64_t pkt20_mask, pkt21_mask; \ uint64_t *key20, *key21; \ + uint64_t hash_key_buffer20[2]; \ + uint64_t hash_key_buffer21[2]; \ uint32_t pos20, pos21; \ \ key20 = RTE_MBUF_METADATA_UINT64_PTR(mbuf20, f->key_offset);\ key21 = RTE_MBUF_METADATA_UINT64_PTR(mbuf21, f->key_offset);\ + hash_key_buffer20[0] = key20[0] & f->key_mask[0]; \ + hash_key_buffer20[1] = key20[1] & f->key_mask[1]; \ + hash_key_buffer21[0] = key21[0] & f->key_mask[0]; \ + hash_key_buffer21[1] = key21[1] & f->key_mask[1]; \ \ - lookup_key16_cmp(key20, bucket20, pos20); \ - lookup_key16_cmp(key21, bucket21, pos21); \ + lookup_key16_cmp(hash_key_buffer20, bucket20, pos20); \ + lookup_key16_cmp(hash_key_buffer21, bucket21, pos21); \ \ pkt20_mask = (bucket20->signature[pos20] & 1LLU) << pkt20_index;\ pkt21_mask = (bucket21->signature[pos21] & 1LLU) << pkt21_index;\ @@ -778,13 +810,19 @@ rte_table_hash_entry_delete_key16_ext( void *a20, *a21; \ uint64_t pkt20_mask, pkt21_mask, bucket20_mask, bucket21_mask;\ uint64_t *key20, *key21; \ + uint64_t hash_key_buffer20[2]; \ + uint64_t hash_key_buffer21[2]; \ uint32_t pos20, pos21; \ \ key20 = RTE_MBUF_METADATA_UINT64_PTR(mbuf20, f->key_offset);\ key21 = RTE_MBUF_METADATA_UINT64_PTR(mbuf21, f->key_offset);\ + hash_key_buffer20[0] = key20[0] & f->key_mask[0]; \ + hash_key_buffer20[1] = key20[1] & f->key_mask[1]; \ + hash_key_buffer21[0] = key21[0] & f->key_mask[0]; \ + hash_key_buffer21[1] = key21[1] & f->key_mask[1]; \ \ - lookup_key16_cmp(key20, bucket20, pos20); \ - lookup_key16_cmp(key21, bucket21, pos21); \ + lookup_key16_cmp(hash_key_buffer20, bucket20, pos20); \ + lookup_key16_cmp(hash_key_buffer21, bucket21, pos21); \ \ pkt20_mask = (bucket20->signature[pos20] & 1LLU) << pkt20_index;\ pkt21_mask = (bucket21->signature[pos21] & 1LLU) << pkt21_index;\ diff --git a/lib/librte_table/rte_table_hash_key8.c b/lib/librte_table/rte_table_hash_key8.c index b351a49..ccb20cf 100644 --- a/lib/librte_table/rte_table_hash_key8.c +++ b/lib/librte_table/rte_table_hash_key8.c @@ -82,6 +82,7 @@ struct rte_table_hash { uint32_t bucket_size; uint32_t signature_offset; uint32_t key_offset; + uint64_t key_mask; rte_table_hash_op_hash f_hash; uint64_t seed; @@ -160,6 +161,11 @@ rte_table_hash_create_key8_lru(void *params, int socket_id, uint32_t entry_size) f->f_hash = p->f_hash; f->seed = p->seed; + if (p->key_mask != NULL) + f->key_mask = ((uint64_t *)p->key_mask)[0]; + else + f->key_mask = 0xFFFFFFFFFFFFFFFFLLU; + for (i = 0; i < n_buckets; i++) { struct rte_bucket_4_8 *bucket; @@ -372,6 +378,11 @@ rte_table_hash_create_key8_ext(void *params, int socket_id, uint32_t entry_size) f->stack = (uint32_t *) &f->memory[(n_buckets + n_buckets_ext) * f->bucket_size]; + if (p->key_mask != NULL) + f->key_mask = ((uint64_t *)p->key_mask)[0]; + else + f->key_mask = 0xFFFFFFFFFFFFFFFFLLU; + for (i = 0; i < n_buckets_ext; i++) f->stack[i] = i; @@ -586,9 +597,12 @@ rte_table_hash_entry_delete_key8_ext( uint64_t *key; \ uint64_t signature; \ uint32_t bucket_index; \ + uint64_t hash_key_buffer; \ \ key = RTE_MBUF_METADATA_UINT64_PTR(mbuf1, f->key_offset);\ - signature = f->f_hash(key, RTE_TABLE_HASH_KEY_SIZE, f->seed);\ + hash_key_buffer = *key & f->key_mask; \ + signature = f->f_hash(&hash_key_buffer, \ + RTE_TABLE_HASH_KEY_SIZE, f->seed); \ bucket_index = signature & (f->n_buckets - 1); \ bucket1 = (struct rte_bucket_4_8 *) \ &f->memory[bucket_index * f->bucket_size]; \ @@ -602,10 +616,12 @@ rte_table_hash_entry_delete_key8_ext( uint64_t pkt_mask; \ uint64_t *key; \ uint32_t pos; \ + uint64_t hash_key_buffer; \ \ key = RTE_MBUF_METADATA_UINT64_PTR(mbuf2, f->key_offset);\ + hash_key_buffer = key[0] & f->key_mask; \ \ - lookup_key8_cmp(key, bucket2, pos); \ + lookup_key8_cmp((&hash_key_buffer), bucket2, pos); \ \ pkt_mask = ((bucket2->signature >> pos) & 1LLU) << pkt2_index;\ pkts_mask_out |= pkt_mask; \ @@ -624,10 +640,12 @@ rte_table_hash_entry_delete_key8_ext( uint64_t pkt_mask, bucket_mask; \ uint64_t *key; \ uint32_t pos; \ + uint64_t hash_key_buffer; \ \ key = RTE_MBUF_METADATA_UINT64_PTR(mbuf2, f->key_offset);\ + hash_key_buffer = *key & f->key_mask; \ \ - lookup_key8_cmp(key, bucket2, pos); \ + lookup_key8_cmp((&hash_key_buffer), bucket2, pos); \ \ pkt_mask = ((bucket2->signature >> pos) & 1LLU) << pkt2_index;\ pkts_mask_out |= pkt_mask; \ @@ -651,11 +669,13 @@ rte_table_hash_entry_delete_key8_ext( uint64_t pkt_mask, bucket_mask; \ uint64_t *key; \ uint32_t pos; \ + uint64_t hash_key_buffer; \ \ bucket = buckets[pkt_index]; \ key = keys[pkt_index]; \ + hash_key_buffer = (*key) & f->key_mask; \ \ - lookup_key8_cmp(key, bucket, pos); \ + lookup_key8_cmp((&hash_key_buffer), bucket, pos); \ \ pkt_mask = ((bucket->signature >> pos) & 1LLU) << pkt_index;\ pkts_mask_out |= pkt_mask; \ @@ -736,6 +756,8 @@ rte_table_hash_entry_delete_key8_ext( #define lookup2_stage1_dosig(mbuf10, mbuf11, bucket10, bucket11, f)\ { \ uint64_t *key10, *key11; \ + uint64_t hash_offset_buffer10; \ + uint64_t hash_offset_buffer11; \ uint64_t signature10, signature11; \ uint32_t bucket10_index, bucket11_index; \ rte_table_hash_op_hash f_hash = f->f_hash; \ @@ -744,14 +766,18 @@ rte_table_hash_entry_delete_key8_ext( \ key10 = RTE_MBUF_METADATA_UINT64_PTR(mbuf10, key_offset);\ key11 = RTE_MBUF_METADATA_UINT64_PTR(mbuf11, key_offset);\ + hash_offset_buffer10 = *key10 & f->key_mask; \ + hash_offset_buffer11 = *key11 & f->key_mask; \ \ - signature10 = f_hash(key10, RTE_TABLE_HASH_KEY_SIZE, seed);\ + signature10 = f_hash(&hash_offset_buffer10, \ + RTE_TABLE_HASH_KEY_SIZE, seed); \ bucket10_index = signature10 & (f->n_buckets - 1); \ bucket10 = (struct rte_bucket_4_8 *) \ &f->memory[bucket10_index * f->bucket_size]; \ rte_prefetch0(bucket10); \ \ - signature11 = f_hash(key11, RTE_TABLE_HASH_KEY_SIZE, seed);\ + signature11 = f_hash(&hash_offset_buffer11, \ + RTE_TABLE_HASH_KEY_SIZE, seed); \ bucket11_index = signature11 & (f->n_buckets - 1); \ bucket11 = (struct rte_bucket_4_8 *) \ &f->memory[bucket11_index * f->bucket_size]; \ @@ -764,13 +790,17 @@ rte_table_hash_entry_delete_key8_ext( void *a20, *a21; \ uint64_t pkt20_mask, pkt21_mask; \ uint64_t *key20, *key21; \ + uint64_t hash_offset_buffer20; \ + uint64_t hash_offset_buffer21; \ uint32_t pos20, pos21; \ \ key20 = RTE_MBUF_METADATA_UINT64_PTR(mbuf20, f->key_offset);\ key21 = RTE_MBUF_METADATA_UINT64_PTR(mbuf21, f->key_offset);\ + hash_offset_buffer20 = *key20 & f->key_mask; \ + hash_offset_buffer21 = *key21 & f->key_mask; \ \ - lookup_key8_cmp(key20, bucket20, pos20); \ - lookup_key8_cmp(key21, bucket21, pos21); \ + lookup_key8_cmp((&hash_offset_buffer20), bucket20, pos20);\ + lookup_key8_cmp((&hash_offset_buffer21), bucket21, pos21);\ \ pkt20_mask = ((bucket20->signature >> pos20) & 1LLU) << pkt20_index;\ pkt21_mask = ((bucket21->signature >> pos21) & 1LLU) << pkt21_index;\ @@ -793,13 +823,17 @@ rte_table_hash_entry_delete_key8_ext( void *a20, *a21; \ uint64_t pkt20_mask, pkt21_mask, bucket20_mask, bucket21_mask;\ uint64_t *key20, *key21; \ + uint64_t hash_offset_buffer20; \ + uint64_t hash_offset_buffer21; \ uint32_t pos20, pos21; \ \ key20 = RTE_MBUF_METADATA_UINT64_PTR(mbuf20, f->key_offset);\ key21 = RTE_MBUF_METADATA_UINT64_PTR(mbuf21, f->key_offset);\ + hash_offset_buffer20 = *key20 & f->key_mask; \ + hash_offset_buffer21 = *key21 & f->key_mask; \ \ - lookup_key8_cmp(key20, bucket20, pos20); \ - lookup_key8_cmp(key21, bucket21, pos21); \ + lookup_key8_cmp((&hash_offset_buffer20), bucket20, pos20);\ + lookup_key8_cmp((&hash_offset_buffer21), bucket21, pos21);\ \ pkt20_mask = ((bucket20->signature >> pos20) & 1LLU) << pkt20_index;\ pkt21_mask = ((bucket21->signature >> pos21) & 1LLU) << pkt21_index;\ diff --git a/lib/librte_table/rte_table_version.map b/lib/librte_table/rte_table_version.map index d33f926..f767a50 100644 --- a/lib/librte_table/rte_table_version.map +++ b/lib/librte_table/rte_table_version.map @@ -19,3 +19,10 @@ DPDK_2.0 { local: *; }; + +DPDK_2.2 { + global: + + rte_table_hash_key16_ext_dosig_ops; + +} DPDK_2.0; \ No newline at end of file -- 2.1.0