common/vnf_common/pipeline_actions_common.h

   1 /*
   2 // Copyright (c) 2017 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //      http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16 #ifndef __INCLUDE_PIPELINE_ACTIONS_COMMON_H__
  17 #define __INCLUDE_PIPELINE_ACTIONS_COMMON_H__
  18
  19 #include <stdint.h>
  20
  21 #include <rte_common.h>
  22 #include <rte_cycles.h>
  23 #include <rte_mbuf.h>
  24 #include <rte_pipeline.h>
  25
  26 #define PIPELINE_PORT_IN_AH(f_ah, f_pkt_work, f_pkt4_work)              \
  27 static int                                                              \
  28 f_ah(                                                                   \
  29         __rte_unused struct rte_pipeline *p,                            \
  30         struct rte_mbuf **pkts,                                         \
  31         uint32_t n_pkts,                                                \
  32         void *arg)                                                      \
  33 {                                                                       \
  34         uint32_t i;                                                     \
  35                                                                         \
  36         for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4)                   \
  37                 f_pkt4_work(&pkts[i], arg);                             \
  38                                                                         \
  39         for ( ; i < n_pkts; i++)                                        \
  40                 f_pkt_work(pkts[i], arg);                               \
  41                                                                         \
  42         return 0;                                                       \
  43 }
  44
  45 #define PIPELINE_PORT_IN_AH_HIJACK_ALL(f_ah, f_pkt_work, f_pkt4_work) \
  46 static int                                                              \
  47 f_ah(                                                                   \
  48         struct rte_pipeline *p,                         \
  49         struct rte_mbuf **pkts,                                 \
  50         uint32_t n_pkts,                                                \
  51         void *arg)                                              \
  52 {                                                                       \
  53         uint64_t pkt_mask = RTE_LEN2MASK(n_pkts, uint64_t);     \
  54         uint32_t i;                                                     \
  55                                                                         \
  56         rte_pipeline_ah_packet_hijack(p, pkt_mask);     \
  57                                                                         \
  58         for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4)   \
  59                 f_pkt4_work(&pkts[i], arg);                             \
  60                                                                         \
  61         for ( ; i < n_pkts; i++)                                \
  62                 f_pkt_work(pkts[i], arg);                       \
  63                                                                         \
  64         return 0;                                                       \
  65 }
  66
  67 #define PIPELINE_TABLE_AH_HIT(f_ah, f_pkt_work, f_pkt4_work)            \
  68 static int                                                              \
  69 f_ah(                                                                   \
  70         __rte_unused struct rte_pipeline *p,                            \
  71         struct rte_mbuf **pkts,                                         \
  72         uint64_t pkts_in_mask,                                          \
  73         struct rte_pipeline_table_entry **entries,                      \
  74         void *arg)                                                      \
  75 {                                                                       \
  76         if ((pkts_in_mask & (pkts_in_mask + 1)) == 0) {                 \
  77                 uint64_t n_pkts = __builtin_popcountll(pkts_in_mask);   \
  78                 uint32_t i;                                             \
  79                                                                         \
  80                 for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4)           \
  81                         f_pkt4_work(&pkts[i], &entries[i], arg);        \
  82                                                                         \
  83                 for ( ; i < n_pkts; i++)                                \
  84                         f_pkt_work(pkts[i], entries[i], arg);           \
  85         } else                                                          \
  86                 for ( ; pkts_in_mask; ) {                               \
  87                         uint32_t pos = __builtin_ctzll(pkts_in_mask);   \
  88                         uint64_t pkt_mask = 1LLU << pos;                \
  89                                                                         \
  90                         pkts_in_mask &= ~pkt_mask;                      \
  91                         f_pkt_work(pkts[pos], entries[pos], arg);       \
  92                 }                                                       \
  93                                                                         \
  94         return 0;                                                       \
  95 }
  96
  97 #define PIPELINE_TABLE_AH_MISS(f_ah, f_pkt_work, f_pkt4_work)           \
  98 static int                                                              \
  99 f_ah(                                                                   \
 100         __rte_unused struct rte_pipeline *p,                            \
 101         struct rte_mbuf **pkts,                                         \
 102         uint64_t pkts_in_mask,                                          \
 103         struct rte_pipeline_table_entry *entry,                         \
 104         void *arg)                                                      \
 105 {                                                                       \
 106         if ((pkts_in_mask & (pkts_in_mask + 1)) == 0) {                 \
 107                 uint64_t n_pkts = __builtin_popcountll(pkts_in_mask);   \
 108                 uint32_t i;                                             \
 109                                                                         \
 110                 for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4)           \
 111                         f_pkt4_work(&pkts[i], entry, arg);              \
 112                                                                         \
 113                 for ( ; i < n_pkts; i++)                                \
 114                         f_pkt_work(pkts[i], entry, arg);                \
 115         } else                                                          \
 116                 for ( ; pkts_in_mask; ) {                               \
 117                         uint32_t pos = __builtin_ctzll(pkts_in_mask);   \
 118                         uint64_t pkt_mask = 1LLU << pos;                \
 119                                                                         \
 120                         pkts_in_mask &= ~pkt_mask;                      \
 121                         f_pkt_work(pkts[pos], entry, arg);              \
 122                 }                                                       \
 123                                                                         \
 124         return 0;                                                       \
 125 }
 126
 127 #define PIPELINE_TABLE_AH_HIT_DROP_TIME(f_ah, f_pkt_work, f_pkt4_work)  \
 128 static int                                                              \
 129 f_ah(                                                                   \
 130         struct rte_pipeline *p,                                         \
 131         struct rte_mbuf **pkts,                                         \
 132         uint64_t pkts_mask,                                             \
 133         struct rte_pipeline_table_entry **entries,                      \
 134         void *arg)                                                      \
 135 {                                                                       \
 136         uint64_t pkts_in_mask = pkts_mask;                              \
 137         uint64_t pkts_out_mask = pkts_mask;                             \
 138         uint64_t time = rte_rdtsc();                                    \
 139                                                                         \
 140         if ((pkts_in_mask & (pkts_in_mask + 1)) == 0) {                 \
 141                 uint64_t n_pkts = __builtin_popcountll(pkts_in_mask);   \
 142                 uint32_t i;                                             \
 143                                                                         \
 144                 for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) {         \
 145                         uint64_t mask = f_pkt4_work(&pkts[i],           \
 146                                 &entries[i], arg, time);                \
 147                         pkts_out_mask ^= mask << i;                     \
 148                 }                                                       \
 149                                                                         \
 150                 for ( ; i < n_pkts; i++) {                              \
 151                         uint64_t mask = f_pkt_work(pkts[i],             \
 152                                 entries[i], arg, time);                 \
 153                         pkts_out_mask ^= mask << i;                     \
 154                 }                                                       \
 155         } else                                                          \
 156                 for ( ; pkts_in_mask; ) {                               \
 157                         uint32_t pos = __builtin_ctzll(pkts_in_mask);   \
 158                         uint64_t pkt_mask = 1LLU << pos;                \
 159                         uint64_t mask = f_pkt_work(pkts[pos],           \
 160                                 entries[pos], arg, time);               \
 161                                                                         \
 162                         pkts_in_mask &= ~pkt_mask;                      \
 163                         pkts_out_mask ^= mask << pos;                   \
 164                 }                                                       \
 165                                                                         \
 166         rte_pipeline_ah_packet_drop(p, pkts_out_mask ^ pkts_mask);      \
 167                                                                         \
 168         return 0;                                                       \
 169 }
 170
 171 #define PIPELINE_TABLE_AH_MISS_DROP_TIME(f_ah, f_pkt_work, f_pkt4_work) \
 172 static int                                                              \
 173 f_ah(                                                                   \
 174         struct rte_pipeline *p,                                         \
 175         struct rte_mbuf **pkts,                                         \
 176         uint64_t pkts_mask,                                             \
 177         struct rte_pipeline_table_entry *entry,                         \
 178         void *arg)                                                      \
 179 {                                                                       \
 180         uint64_t pkts_in_mask = pkts_mask;                              \
 181         uint64_t pkts_out_mask = pkts_mask;                             \
 182         uint64_t time = rte_rdtsc();                                    \
 183                                                                         \
 184         if ((pkts_in_mask & (pkts_in_mask + 1)) == 0) {                 \
 185                 uint64_t n_pkts = __builtin_popcountll(pkts_in_mask);   \
 186                 uint32_t i;                                             \
 187                                                                         \
 188                 for (i = 0; i < (n_pkts & (~0x3LLU)); i += 4) {         \
 189                         uint64_t mask = f_pkt4_work(&pkts[i],           \
 190                                 entry, arg, time);                      \
 191                         pkts_out_mask ^= mask << i;                     \
 192                 }                                                       \
 193                                                                         \
 194                 for ( ; i < n_pkts; i++) {                              \
 195                         uint64_t mask = f_pkt_work(pkts[i], entry, arg, time);\
 196                         pkts_out_mask ^= mask << i;                     \
 197                 }                                                       \
 198         } else                                                          \
 199                 for ( ; pkts_in_mask; ) {                               \
 200                         uint32_t pos = __builtin_ctzll(pkts_in_mask);   \
 201                         uint64_t pkt_mask = 1LLU << pos;                \
 202                         uint64_t mask = f_pkt_work(pkts[pos],           \
 203                                 entry, arg, time);              \
 204                                                                         \
 205                         pkts_in_mask &= ~pkt_mask;                      \
 206                         pkts_out_mask ^= mask << pos;                   \
 207                 }                                                       \
 208                                                                         \
 209         rte_pipeline_ah_packet_drop(p, pkts_out_mask ^ pkts_mask);      \
 210                                                                         \
 211         return 0;                                                       \
 212 }
 213
 214 #endif