examples/ip_pipeline/pipeline/hash_func.h

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