face.h

Go to the documentation of this file.

#ifndef NDNDPDK_IFACE_FACE_H
#define NDNDPDK_IFACE_FACE_H
 
#include "input-demux.h"
#include "reassembler.h"
 
#include "../core/urcu.h"
#include "../pdump/source.h"
#include <urcu/rcuhlist.h>
 
typedef struct FaceRxInputCtx {
  struct rte_mbuf** pkts;  
  Packet** npkts;          
  struct rte_mbuf** frees; 
  uint16_t count;          
  uint16_t nL3;            
  uint16_t nFree;          
} FaceRxInputCtx;
 
typedef void (*Face_RxInputFunc)(Face* face, int rxThread, FaceRxInputCtx* ctx);
 
typedef uint16_t (*Face_TxLoopFunc)(Face* face, int txThread);
 
typedef uint16_t (*Face_TxBurstFunc)(Face* face, struct rte_mbuf** pkts, uint16_t nPkts);
 
enum {
  FaceRxThread_cntNOctets = PktFragment,
};
 
typedef struct FaceRxThread {
  uint64_t nFrames[PktMax]; 
  uint64_t nDecodeErr;      
  Reassembler reass;
} __rte_cache_aligned FaceRxThread;
 
typedef struct FaceTxThread {
  uint64_t nextSeqNum; 
 
  uint64_t nL3Fragmented; 
  uint64_t nL3OverLength; 
  uint64_t nAllocFails;   
 
  uint64_t nFrames[PktMax]; 
  uint64_t nOctets;         
  uint64_t nDroppedFrames;  
  uint64_t nDroppedOctets;  
} __rte_cache_aligned FaceTxThread;
 
typedef struct FaceImpl {
  FaceRxThread rx[MaxFaceRxThreads];
  FaceTxThread tx[MaxFaceTxThreads];
 
  RTE_MARKER rxMarker __rte_cache_aligned;
  Face_RxInputFunc rxInput;
  InputDemuxes* rxDemuxes; 
  PdumpSourceRef rxPdump;
  ParseFor rxParseFor;
 
  RTE_MARKER txMarker __rte_cache_aligned;
  PacketMempools txMempools; 
  Face_TxLoopFunc txLoop;
  Face_TxBurstFunc txBurst;
  PdumpSourceRef txPdump;
 
  uint8_t priv[] __rte_cache_aligned;
} FaceImpl;
 
struct Face {
  FaceImpl* impl;
  struct rte_ring* outputQueue;
  struct cds_hlist_node txlNode;
  PacketTxAlign txAlign;
  FaceID id;
  FaceState state;
};
static_assert(sizeof(Face) <= RTE_CACHE_LINE_SIZE, "");
 
__attribute__((nonnull, returns_nonnull)) static inline void*
Face_GetPriv(Face* face) {
  return face->impl->priv;
}
 
extern Face gFaces[];
 
__attribute__((returns_nonnull)) static inline Face*
Face_Get(FaceID id) {
  return &gFaces[id];
}
 
static inline bool
Face_IsDown(FaceID faceID) {
  Face* face = Face_Get(faceID);
  return face->state != FaceStateUp;
}
 
static inline PacketTxAlign
Face_PacketTxAlign(FaceID faceID) {
  Face* face = Face_Get(faceID);
  return face->txAlign;
}
 
__attribute__((nonnull)) static inline void
Face_TxBurst(FaceID faceID, Packet** npkts, uint16_t count) {
  Face* face = Face_Get(faceID);
  if (likely(face->state == FaceStateUp)) {
    Mbuf_EnqueueVector((struct rte_mbuf**)npkts, count, face->outputQueue, true);
    // TODO count rejects
  } else {
    rte_pktmbuf_free_bulk((struct rte_mbuf**)npkts, count);
  }
}
 
__attribute__((nonnull)) static inline void
Face_Tx(FaceID faceID, Packet* npkt) {
  Face_TxBurst(faceID, &npkt, 1);
}
 
#endif // NDNDPDK_IFACE_FACE_H