lib/librte_hash/rte_cmp_arm64.h

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2015 Cavium, Inc. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Cavium, Inc nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34 /* Functions to compare multiple of 16 byte keys (up to 128 bytes) */
  35 static int
  36 rte_hash_k16_cmp_eq(const void *key1, const void *key2,
  37                     size_t key_len __rte_unused)
  38 {
  39         uint64_t x0, x1, y0, y1;
  40
  41         asm volatile(
  42                 "ldp %x[x1], %x[x0], [%x[p1]]"
  43                 : [x1]"=r"(x1), [x0]"=r"(x0)
  44                 : [p1]"r"(key1)
  45                 );
  46         asm volatile(
  47                 "ldp %x[y1], %x[y0], [%x[p2]]"
  48                 : [y1]"=r"(y1), [y0]"=r"(y0)
  49                 : [p2]"r"(key2)
  50                 );
  51         x0 ^= y0;
  52         x1 ^= y1;
  53         return !(x0 == 0 && x1 == 0);
  54 }
  55
  56 static int
  57 rte_hash_k32_cmp_eq(const void *key1, const void *key2, size_t key_len)
  58 {
  59         return rte_hash_k16_cmp_eq(key1, key2, key_len) ||
  60                 rte_hash_k16_cmp_eq((const char *) key1 + 16,
  61                                 (const char *) key2 + 16, key_len);
  62 }
  63
  64 static int
  65 rte_hash_k48_cmp_eq(const void *key1, const void *key2, size_t key_len)
  66 {
  67         return rte_hash_k16_cmp_eq(key1, key2, key_len) ||
  68                 rte_hash_k16_cmp_eq((const char *) key1 + 16,
  69                                 (const char *) key2 + 16, key_len) ||
  70                 rte_hash_k16_cmp_eq((const char *) key1 + 32,
  71                                 (const char *) key2 + 32, key_len);
  72 }
  73
  74 static int
  75 rte_hash_k64_cmp_eq(const void *key1, const void *key2, size_t key_len)
  76 {
  77         return rte_hash_k32_cmp_eq(key1, key2, key_len) ||
  78                 rte_hash_k32_cmp_eq((const char *) key1 + 32,
  79                                 (const char *) key2 + 32, key_len);
  80 }
  81
  82 static int
  83 rte_hash_k80_cmp_eq(const void *key1, const void *key2, size_t key_len)
  84 {
  85         return rte_hash_k64_cmp_eq(key1, key2, key_len) ||
  86                 rte_hash_k16_cmp_eq((const char *) key1 + 64,
  87                                 (const char *) key2 + 64, key_len);
  88 }
  89
  90 static int
  91 rte_hash_k96_cmp_eq(const void *key1, const void *key2, size_t key_len)
  92 {
  93         return rte_hash_k64_cmp_eq(key1, key2, key_len) ||
  94                 rte_hash_k32_cmp_eq((const char *) key1 + 64,
  95                                 (const char *) key2 + 64, key_len);
  96 }
  97
  98 static int
  99 rte_hash_k112_cmp_eq(const void *key1, const void *key2, size_t key_len)
 100 {
 101         return rte_hash_k64_cmp_eq(key1, key2, key_len) ||
 102                 rte_hash_k32_cmp_eq((const char *) key1 + 64,
 103                                 (const char *) key2 + 64, key_len) ||
 104                 rte_hash_k16_cmp_eq((const char *) key1 + 96,
 105                                 (const char *) key2 + 96, key_len);
 106 }
 107
 108 static int
 109 rte_hash_k128_cmp_eq(const void *key1, const void *key2, size_t key_len)
 110 {
 111         return rte_hash_k64_cmp_eq(key1, key2, key_len) ||
 112                 rte_hash_k64_cmp_eq((const char *) key1 + 64,
 113                                 (const char *) key2 + 64, key_len);
 114 }