event/octeontx2: improve datapath memory locality
[dpdk.git] / drivers / event / octeontx2 / otx2_worker_dual.c
index 661c78c..946488e 100644 (file)
@@ -79,7 +79,7 @@ otx2_ssogws_dual_forward_event(struct otx2_ssogws_dual *ws,
        }
 }
 
-uint16_t __hot
+uint16_t __rte_hot
 otx2_ssogws_dual_enq(void *port, const struct rte_event *ev)
 {
        struct otx2_ssogws_dual *ws = port;
@@ -102,7 +102,7 @@ otx2_ssogws_dual_enq(void *port, const struct rte_event *ev)
        return 1;
 }
 
-uint16_t __hot
+uint16_t __rte_hot
 otx2_ssogws_dual_enq_burst(void *port, const struct rte_event ev[],
                           uint16_t nb_events)
 {
@@ -110,7 +110,7 @@ otx2_ssogws_dual_enq_burst(void *port, const struct rte_event ev[],
        return otx2_ssogws_dual_enq(port, ev);
 }
 
-uint16_t __hot
+uint16_t __rte_hot
 otx2_ssogws_dual_enq_new_burst(void *port, const struct rte_event ev[],
                               uint16_t nb_events)
 {
@@ -127,7 +127,7 @@ otx2_ssogws_dual_enq_new_burst(void *port, const struct rte_event ev[],
        return nb_events;
 }
 
-uint16_t __hot
+uint16_t __rte_hot
 otx2_ssogws_dual_enq_fwd_burst(void *port, const struct rte_event ev[],
                               uint16_t nb_events)
 {
@@ -139,3 +139,210 @@ otx2_ssogws_dual_enq_fwd_burst(void *port, const struct rte_event ev[],
 
        return 1;
 }
+
+#define R(name, f6, f5, f4, f3, f2, f1, f0, flags)                     \
+uint16_t __rte_hot                                                             \
+otx2_ssogws_dual_deq_ ##name(void *port, struct rte_event *ev,         \
+                            uint64_t timeout_ticks)                    \
+{                                                                      \
+       struct otx2_ssogws_dual *ws = port;                             \
+       uint8_t gw;                                                     \
+                                                                       \
+       rte_prefetch_non_temporal(ws);                                  \
+       RTE_SET_USED(timeout_ticks);                                    \
+       if (ws->swtag_req) {                                            \
+               otx2_ssogws_swtag_wait((struct otx2_ssogws *)           \
+                                      &ws->ws_state[!ws->vws]);        \
+               ws->swtag_req = 0;                                      \
+               return 1;                                               \
+       }                                                               \
+                                                                       \
+       gw = otx2_ssogws_dual_get_work(&ws->ws_state[ws->vws],          \
+                                      &ws->ws_state[!ws->vws], ev,     \
+                                      flags, ws->lookup_mem,           \
+                                      ws->tstamp);                     \
+       ws->vws = !ws->vws;                                             \
+                                                                       \
+       return gw;                                                      \
+}                                                                      \
+                                                                       \
+uint16_t __rte_hot                                                             \
+otx2_ssogws_dual_deq_burst_ ##name(void *port, struct rte_event ev[],  \
+                                  uint16_t nb_events,                  \
+                                  uint64_t timeout_ticks)              \
+{                                                                      \
+       RTE_SET_USED(nb_events);                                        \
+                                                                       \
+       return otx2_ssogws_dual_deq_ ##name(port, ev, timeout_ticks);   \
+}                                                                      \
+                                                                       \
+uint16_t __rte_hot                                                             \
+otx2_ssogws_dual_deq_timeout_ ##name(void *port, struct rte_event *ev, \
+                                    uint64_t timeout_ticks)            \
+{                                                                      \
+       struct otx2_ssogws_dual *ws = port;                             \
+       uint64_t iter;                                                  \
+       uint8_t gw;                                                     \
+                                                                       \
+       if (ws->swtag_req) {                                            \
+               otx2_ssogws_swtag_wait((struct otx2_ssogws *)           \
+                                      &ws->ws_state[!ws->vws]);        \
+               ws->swtag_req = 0;                                      \
+               return 1;                                               \
+       }                                                               \
+                                                                       \
+       gw = otx2_ssogws_dual_get_work(&ws->ws_state[ws->vws],          \
+                                      &ws->ws_state[!ws->vws], ev,     \
+                                      flags, ws->lookup_mem,           \
+                                      ws->tstamp);                     \
+       ws->vws = !ws->vws;                                             \
+       for (iter = 1; iter < timeout_ticks && (gw == 0); iter++) {     \
+               gw = otx2_ssogws_dual_get_work(&ws->ws_state[ws->vws],  \
+                                              &ws->ws_state[!ws->vws], \
+                                              ev, flags,               \
+                                              ws->lookup_mem,          \
+                                              ws->tstamp);             \
+               ws->vws = !ws->vws;                                     \
+       }                                                               \
+                                                                       \
+       return gw;                                                      \
+}                                                                      \
+                                                                       \
+uint16_t __rte_hot                                                             \
+otx2_ssogws_dual_deq_timeout_burst_ ##name(void *port,                 \
+                                          struct rte_event ev[],       \
+                                          uint16_t nb_events,          \
+                                          uint64_t timeout_ticks)      \
+{                                                                      \
+       RTE_SET_USED(nb_events);                                        \
+                                                                       \
+       return otx2_ssogws_dual_deq_timeout_ ##name(port, ev,           \
+                                                   timeout_ticks);     \
+}                                                                      \
+                                                                       \
+uint16_t __rte_hot                                                             \
+otx2_ssogws_dual_deq_seg_ ##name(void *port, struct rte_event *ev,     \
+                                uint64_t timeout_ticks)                \
+{                                                                      \
+       struct otx2_ssogws_dual *ws = port;                             \
+       uint8_t gw;                                                     \
+                                                                       \
+       RTE_SET_USED(timeout_ticks);                                    \
+       if (ws->swtag_req) {                                            \
+               otx2_ssogws_swtag_wait((struct otx2_ssogws *)           \
+                                      &ws->ws_state[!ws->vws]);        \
+               ws->swtag_req = 0;                                      \
+               return 1;                                               \
+       }                                                               \
+                                                                       \
+       gw = otx2_ssogws_dual_get_work(&ws->ws_state[ws->vws],          \
+                                      &ws->ws_state[!ws->vws], ev,     \
+                                      flags | NIX_RX_MULTI_SEG_F,      \
+                                      ws->lookup_mem,                  \
+                                      ws->tstamp);                     \
+       ws->vws = !ws->vws;                                             \
+                                                                       \
+       return gw;                                                      \
+}                                                                      \
+                                                                       \
+uint16_t __rte_hot                                                             \
+otx2_ssogws_dual_deq_seg_burst_ ##name(void *port,                     \
+                                      struct rte_event ev[],           \
+                                      uint16_t nb_events,              \
+                                      uint64_t timeout_ticks)          \
+{                                                                      \
+       RTE_SET_USED(nb_events);                                        \
+                                                                       \
+       return otx2_ssogws_dual_deq_seg_ ##name(port, ev,               \
+                                               timeout_ticks);         \
+}                                                                      \
+                                                                       \
+uint16_t __rte_hot                                                             \
+otx2_ssogws_dual_deq_seg_timeout_ ##name(void *port,                   \
+                                        struct rte_event *ev,          \
+                                        uint64_t timeout_ticks)        \
+{                                                                      \
+       struct otx2_ssogws_dual *ws = port;                             \
+       uint64_t iter;                                                  \
+       uint8_t gw;                                                     \
+                                                                       \
+       if (ws->swtag_req) {                                            \
+               otx2_ssogws_swtag_wait((struct otx2_ssogws *)           \
+                                      &ws->ws_state[!ws->vws]);        \
+               ws->swtag_req = 0;                                      \
+               return 1;                                               \
+       }                                                               \
+                                                                       \
+       gw = otx2_ssogws_dual_get_work(&ws->ws_state[ws->vws],          \
+                                      &ws->ws_state[!ws->vws], ev,     \
+                                      flags | NIX_RX_MULTI_SEG_F,      \
+                                      ws->lookup_mem,                  \
+                                      ws->tstamp);                     \
+       ws->vws = !ws->vws;                                             \
+       for (iter = 1; iter < timeout_ticks && (gw == 0); iter++) {     \
+               gw = otx2_ssogws_dual_get_work(&ws->ws_state[ws->vws],  \
+                                              &ws->ws_state[!ws->vws], \
+                                              ev, flags |              \
+                                              NIX_RX_MULTI_SEG_F,      \
+                                              ws->lookup_mem,          \
+                                              ws->tstamp);             \
+               ws->vws = !ws->vws;                                     \
+       }                                                               \
+                                                                       \
+       return gw;                                                      \
+}                                                                      \
+                                                                       \
+uint16_t __rte_hot                                                             \
+otx2_ssogws_dual_deq_seg_timeout_burst_ ##name(void *port,             \
+                                              struct rte_event ev[],   \
+                                              uint16_t nb_events,      \
+                                              uint64_t timeout_ticks)  \
+{                                                                      \
+       RTE_SET_USED(nb_events);                                        \
+                                                                       \
+       return otx2_ssogws_dual_deq_seg_timeout_ ##name(port, ev,       \
+                                                       timeout_ticks); \
+}
+
+SSO_RX_ADPTR_ENQ_FASTPATH_FUNC
+#undef R
+
+#define T(name, f6, f5, f4, f3, f2, f1, f0, sz, flags)                 \
+uint16_t __rte_hot                                                     \
+otx2_ssogws_dual_tx_adptr_enq_ ## name(void *port,                     \
+                                      struct rte_event ev[],           \
+                                      uint16_t nb_events)              \
+{                                                                      \
+       struct otx2_ssogws_dual *ws = port;                             \
+       struct otx2_ssogws *vws =                                       \
+               (struct otx2_ssogws *)&ws->ws_state[!ws->vws];          \
+       uint64_t cmd[sz];                                               \
+                                                                       \
+       RTE_SET_USED(nb_events);                                        \
+       return otx2_ssogws_event_tx(vws, ev, cmd, (const uint64_t       \
+                                   (*)[RTE_MAX_QUEUES_PER_PORT])       \
+                                   ws->tx_adptr_data,                  \
+                                   flags);                             \
+}
+SSO_TX_ADPTR_ENQ_FASTPATH_FUNC
+#undef T
+
+#define T(name, f6, f5, f4, f3, f2, f1, f0, sz, flags)                 \
+uint16_t __rte_hot                                                     \
+otx2_ssogws_dual_tx_adptr_enq_seg_ ## name(void *port,                 \
+                                          struct rte_event ev[],       \
+                                          uint16_t nb_events)          \
+{                                                                      \
+       struct otx2_ssogws_dual *ws = port;                             \
+       struct otx2_ssogws *vws =                                       \
+               (struct otx2_ssogws *)&ws->ws_state[!ws->vws];          \
+       uint64_t cmd[(sz) + NIX_TX_MSEG_SG_DWORDS - 2];                 \
+                                                                       \
+       RTE_SET_USED(nb_events);                                        \
+       return otx2_ssogws_event_tx(vws, ev, cmd, (const uint64_t       \
+                                   (*)[RTE_MAX_QUEUES_PER_PORT])       \
+                                   ws->tx_adptr_data,                  \
+                                   (flags) | NIX_TX_MULTI_SEG_F);      \
+}
+SSO_TX_ADPTR_ENQ_FASTPATH_FUNC
+#undef T