examples/ip_pipeline/hash_func.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2018 Intel Corporation
   3  */
   4
   5 #ifndef __INCLUDE_HASH_FUNC_H__
   6 #define __INCLUDE_HASH_FUNC_H__
   7
   8 static inline uint64_t
   9 hash_xor_key8(void *key, void *mask, __rte_unused uint32_t key_size,
  10         uint64_t seed)
  11 {
  12         uint64_t *k = key;
  13         uint64_t *m = mask;
  14         uint64_t xor0;
  15
  16         xor0 = seed ^ (k[0] & m[0]);
  17
  18         return (xor0 >> 32) ^ xor0;
  19 }
  20
  21 static inline uint64_t
  22 hash_xor_key16(void *key, void *mask, __rte_unused uint32_t key_size,
  23         uint64_t seed)
  24 {
  25         uint64_t *k = key;
  26         uint64_t *m = mask;
  27         uint64_t xor0;
  28
  29         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
  30
  31         return (xor0 >> 32) ^ xor0;
  32 }
  33
  34 static inline uint64_t
  35 hash_xor_key24(void *key, void *mask, __rte_unused uint32_t key_size,
  36         uint64_t seed)
  37 {
  38         uint64_t *k = key;
  39         uint64_t *m = mask;
  40         uint64_t xor0;
  41
  42         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
  43
  44         xor0 ^= k[2] & m[2];
  45
  46         return (xor0 >> 32) ^ xor0;
  47 }
  48
  49 static inline uint64_t
  50 hash_xor_key32(void *key, void *mask, __rte_unused uint32_t key_size,
  51         uint64_t seed)
  52 {
  53         uint64_t *k = key;
  54         uint64_t *m = mask;
  55         uint64_t xor0, xor1;
  56
  57         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
  58         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
  59
  60         xor0 ^= xor1;
  61
  62         return (xor0 >> 32) ^ xor0;
  63 }
  64
  65 static inline uint64_t
  66 hash_xor_key40(void *key, void *mask, __rte_unused uint32_t key_size,
  67         uint64_t seed)
  68 {
  69         uint64_t *k = key;
  70         uint64_t *m = mask;
  71         uint64_t xor0, xor1;
  72
  73         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
  74         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
  75
  76         xor0 ^= xor1;
  77
  78         xor0 ^= k[4] & m[4];
  79
  80         return (xor0 >> 32) ^ xor0;
  81 }
  82
  83 static inline uint64_t
  84 hash_xor_key48(void *key, void *mask, __rte_unused uint32_t key_size,
  85         uint64_t seed)
  86 {
  87         uint64_t *k = key;
  88         uint64_t *m = mask;
  89         uint64_t xor0, xor1, xor2;
  90
  91         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
  92         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
  93         xor2 = (k[4] & m[4]) ^ (k[5] & m[5]);
  94
  95         xor0 ^= xor1;
  96
  97         xor0 ^= xor2;
  98
  99         return (xor0 >> 32) ^ xor0;
 100 }
 101
 102 static inline uint64_t
 103 hash_xor_key56(void *key, void *mask, __rte_unused uint32_t key_size,
 104         uint64_t seed)
 105 {
 106         uint64_t *k = key;
 107         uint64_t *m = mask;
 108         uint64_t xor0, xor1, xor2;
 109
 110         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
 111         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
 112         xor2 = (k[4] & m[4]) ^ (k[5] & m[5]);
 113
 114         xor0 ^= xor1;
 115         xor2 ^= k[6] & m[6];
 116
 117         xor0 ^= xor2;
 118
 119         return (xor0 >> 32) ^ xor0;
 120 }
 121
 122 static inline uint64_t
 123 hash_xor_key64(void *key, void *mask, __rte_unused uint32_t key_size,
 124         uint64_t seed)
 125 {
 126         uint64_t *k = key;
 127         uint64_t *m = mask;
 128         uint64_t xor0, xor1, xor2, xor3;
 129
 130         xor0 = ((k[0] & m[0]) ^ seed) ^ (k[1] & m[1]);
 131         xor1 = (k[2] & m[2]) ^ (k[3] & m[3]);
 132         xor2 = (k[4] & m[4]) ^ (k[5] & m[5]);
 133         xor3 = (k[6] & m[6]) ^ (k[7] & m[7]);
 134
 135         xor0 ^= xor1;
 136         xor2 ^= xor3;
 137
 138         xor0 ^= xor2;
 139
 140         return (xor0 >> 32) ^ xor0;
 141 }
 142
 143 #if defined(RTE_ARCH_X86_64)
 144
 145 #include <x86intrin.h>
 146
 147 static inline uint64_t
 148 hash_crc_key8(void *key, void *mask, __rte_unused uint32_t key_size,
 149         uint64_t seed)
 150 {
 151         uint64_t *k = key;
 152         uint64_t *m = mask;
 153         uint64_t crc0;
 154
 155         crc0 = _mm_crc32_u64(seed, k[0] & m[0]);
 156
 157         return crc0;
 158 }
 159
 160 static inline uint64_t
 161 hash_crc_key16(void *key, void *mask, __rte_unused uint32_t key_size,
 162         uint64_t seed)
 163 {
 164         uint64_t *k = key;
 165         uint64_t *m = mask;
 166         uint64_t k0, crc0, crc1;
 167
 168         k0 = k[0] & m[0];
 169
 170         crc0 = _mm_crc32_u64(k0, seed);
 171         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
 172
 173         crc0 ^= crc1;
 174
 175         return crc0;
 176 }
 177
 178 static inline uint64_t
 179 hash_crc_key24(void *key, void *mask, __rte_unused uint32_t key_size,
 180         uint64_t seed)
 181 {
 182         uint64_t *k = key;
 183         uint64_t *m = mask;
 184         uint64_t k0, k2, crc0, crc1;
 185
 186         k0 = k[0] & m[0];
 187         k2 = k[2] & m[2];
 188
 189         crc0 = _mm_crc32_u64(k0, seed);
 190         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
 191
 192         crc0 = _mm_crc32_u64(crc0, k2);
 193
 194         crc0 ^= crc1;
 195
 196         return crc0;
 197 }
 198
 199 static inline uint64_t
 200 hash_crc_key32(void *key, void *mask, __rte_unused uint32_t key_size,
 201         uint64_t seed)
 202 {
 203         uint64_t *k = key;
 204         uint64_t *m = mask;
 205         uint64_t k0, k2, crc0, crc1, crc2, crc3;
 206
 207         k0 = k[0] & m[0];
 208         k2 = k[2] & m[2];
 209
 210         crc0 = _mm_crc32_u64(k0, seed);
 211         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
 212
 213         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
 214         crc3 = k2 >> 32;
 215
 216         crc0 = _mm_crc32_u64(crc0, crc1);
 217         crc1 = _mm_crc32_u64(crc2, crc3);
 218
 219         crc0 ^= crc1;
 220
 221         return crc0;
 222 }
 223
 224 static inline uint64_t
 225 hash_crc_key40(void *key, void *mask, __rte_unused uint32_t key_size,
 226         uint64_t seed)
 227 {
 228         uint64_t *k = key;
 229         uint64_t *m = mask;
 230         uint64_t k0, k2, crc0, crc1, crc2, crc3;
 231
 232         k0 = k[0] & m[0];
 233         k2 = k[2] & m[2];
 234
 235         crc0 = _mm_crc32_u64(k0, seed);
 236         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
 237
 238         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
 239         crc3 = _mm_crc32_u64(k2 >> 32, k[4] & m[4]);
 240
 241         crc0 = _mm_crc32_u64(crc0, crc1);
 242         crc1 = _mm_crc32_u64(crc2, crc3);
 243
 244         crc0 ^= crc1;
 245
 246         return crc0;
 247 }
 248
 249 static inline uint64_t
 250 hash_crc_key48(void *key, void *mask, __rte_unused uint32_t key_size,
 251         uint64_t seed)
 252 {
 253         uint64_t *k = key;
 254         uint64_t *m = mask;
 255         uint64_t k0, k2, k5, crc0, crc1, crc2, crc3;
 256
 257         k0 = k[0] & m[0];
 258         k2 = k[2] & m[2];
 259         k5 = k[5] & m[5];
 260
 261         crc0 = _mm_crc32_u64(k0, seed);
 262         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
 263
 264         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
 265         crc3 = _mm_crc32_u64(k2 >> 32, k[4] & m[4]);
 266
 267         crc0 = _mm_crc32_u64(crc0, (crc1 << 32) ^ crc2);
 268         crc1 = _mm_crc32_u64(crc3, k5);
 269
 270         crc0 ^= crc1;
 271
 272         return crc0;
 273 }
 274
 275 static inline uint64_t
 276 hash_crc_key56(void *key, void *mask, __rte_unused uint32_t key_size,
 277         uint64_t seed)
 278 {
 279         uint64_t *k = key;
 280         uint64_t *m = mask;
 281         uint64_t k0, k2, k5, crc0, crc1, crc2, crc3, crc4, crc5;
 282
 283         k0 = k[0] & m[0];
 284         k2 = k[2] & m[2];
 285         k5 = k[5] & m[5];
 286
 287         crc0 = _mm_crc32_u64(k0, seed);
 288         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
 289
 290         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
 291         crc3 = _mm_crc32_u64(k2 >> 32, k[4] & m[4]);
 292
 293         crc4 = _mm_crc32_u64(k5, k[6] & m[6]);
 294         crc5 = k5 >> 32;
 295
 296         crc0 = _mm_crc32_u64(crc0, (crc1 << 32) ^ crc2);
 297         crc1 = _mm_crc32_u64(crc3, (crc4 << 32) ^ crc5);
 298
 299         crc0 ^= crc1;
 300
 301         return crc0;
 302 }
 303
 304 static inline uint64_t
 305 hash_crc_key64(void *key, void *mask, __rte_unused uint32_t key_size,
 306         uint64_t seed)
 307 {
 308         uint64_t *k = key;
 309         uint64_t *m = mask;
 310         uint64_t k0, k2, k5, crc0, crc1, crc2, crc3, crc4, crc5;
 311
 312         k0 = k[0] & m[0];
 313         k2 = k[2] & m[2];
 314         k5 = k[5] & m[5];
 315
 316         crc0 = _mm_crc32_u64(k0, seed);
 317         crc1 = _mm_crc32_u64(k0 >> 32, k[1] & m[1]);
 318
 319         crc2 = _mm_crc32_u64(k2, k[3] & m[3]);
 320         crc3 = _mm_crc32_u64(k2 >> 32, k[4] & m[4]);
 321
 322         crc4 = _mm_crc32_u64(k5, k[6] & m[6]);
 323         crc5 = _mm_crc32_u64(k5 >> 32, k[7] & m[7]);
 324
 325         crc0 = _mm_crc32_u64(crc0, (crc1 << 32) ^ crc2);
 326         crc1 = _mm_crc32_u64(crc3, (crc4 << 32) ^ crc5);
 327
 328         crc0 ^= crc1;
 329
 330         return crc0;
 331 }
 332
 333 #define hash_default_key8                       hash_crc_key8
 334 #define hash_default_key16                      hash_crc_key16
 335 #define hash_default_key24                      hash_crc_key24
 336 #define hash_default_key32                      hash_crc_key32
 337 #define hash_default_key40                      hash_crc_key40
 338 #define hash_default_key48                      hash_crc_key48
 339 #define hash_default_key56                      hash_crc_key56
 340 #define hash_default_key64                      hash_crc_key64
 341
 342 #elif defined(RTE_ARCH_ARM64)
 343 #include "hash_func_arm64.h"
 344 #else
 345
 346 #define hash_default_key8                       hash_xor_key8
 347 #define hash_default_key16                      hash_xor_key16
 348 #define hash_default_key24                      hash_xor_key24
 349 #define hash_default_key32                      hash_xor_key32
 350 #define hash_default_key40                      hash_xor_key40
 351 #define hash_default_key48                      hash_xor_key48
 352 #define hash_default_key56                      hash_xor_key56
 353 #define hash_default_key64                      hash_xor_key64
 354
 355 #endif
 356
 357 #endif