pit-entry.h

Go to the documentation of this file.

#ifndef NDNDPDK_PCCT_PIT_ENTRY_H
#define NDNDPDK_PCCT_PIT_ENTRY_H

 
#include "../fib/fib.h"
#include "pit-const.h"
#include "pit-dn.h"
#include "pit-struct.h"
#include "pit-up.h"
 
enum {
  PitFibPrefixLenBits_ = 9,
};
static_assert(RTE_BIT32(PitFibPrefixLenBits_) > FibMaxNameLength, "");
 
typedef struct PitEntryExt PitEntryExt;

struct PitEntry {
  Packet* npkt;   
  TscTime expiry; 
  struct PccEntry* pccEntry;
  MinTmr timeout; 
 
  uint64_t fibPrefixHash; 
  struct __rte_packed_begin {
    uint32_t fibSeqNum;                         
    uint8_t nCanBePrefix;                       
    uint16_t fibPrefixL : PitFibPrefixLenBits_; 
    bool mustBeFresh : 1;                       
    bool hasSgTimer : 1;                        
  } __rte_packed_end;
 
  PitEntryExt* ext;
  PitDn dns[PitMaxDns];
  PitUp ups[PitMaxUps];
 
  char sgScratch[PitScratchSize];
};
static_assert(offsetof(PitEntry, dns) <= RTE_CACHE_LINE_SIZE, "");
 
struct PitEntryExt {
  PitDn dns[PitMaxExtDns];
  PitUp ups[PitMaxExtUps];
  PitEntryExt* next;
};
 
__attribute__((nonnull)) static inline void
PitEntry_SetFibEntry_(PitEntry* entry, PInterest* interest, const FibEntry* fibEntry) {
  entry->fibPrefixL = fibEntry->nameL;
  entry->fibSeqNum = fibEntry->seqNum;
  PName* name = &interest->name;
  if (unlikely(interest->activeFwHint >= 0)) {
    name = &interest->fwHint;
  }
  entry->fibPrefixHash = PName_ComputePrefixHash(name, fibEntry->nComps);
  memset(entry->sgScratch, 0, PitScratchSize);
}

__attribute__((nonnull)) static inline void
PitEntry_Init(PitEntry* entry, Packet* npkt, const FibEntry* fibEntry) {
  PInterest* interest = Packet_GetInterestHdr(npkt);
  entry->npkt = npkt;
  MinTmr_Init(&entry->timeout);
  entry->expiry = 0;
 
  entry->nCanBePrefix = (uint8_t)interest->canBePrefix;
  entry->mustBeFresh = interest->mustBeFresh;
 
  entry->dns[0].face = 0;
  entry->ups[0].face = 0;
  entry->ext = NULL;
 
  PitEntry_SetFibEntry_(entry, interest, fibEntry);
}

__attribute__((nonnull)) static inline void
PitEntry_Finalize(PitEntry* entry) {
  if (likely(entry->npkt != NULL)) {
    rte_pktmbuf_free(Packet_ToMbuf(entry->npkt));
  }
  MinTmr_Cancel(&entry->timeout);
  for (PitEntryExt* ext = entry->ext; unlikely(ext != NULL);) {
    PitEntryExt* next = ext->next;
    rte_mempool_put(rte_mempool_from_obj(ext), ext);
    ext = next;
  }
}

__attribute__((nonnull, returns_nonnull)) const char*
PitEntry_ToDebugString(PitEntry* entry);

__attribute__((nonnull)) static inline uint64_t
PitEntry_GetToken(PitEntry* entry);
// Implementation is in pit.h to avoid circular dependency.

__attribute__((nonnull)) static inline void
PitEntry_RefreshFibEntry(PitEntry* entry, Packet* npkt, const FibEntry* fibEntry) {
  if (likely(entry->fibSeqNum == fibEntry->seqNum)) {
    return;
  }
 
  PInterest* interest = Packet_GetInterestHdr(npkt);
  PitEntry_SetFibEntry_(entry, interest, fibEntry);
}

__attribute__((nonnull)) FibEntry*
PitEntry_FindFibEntry(PitEntry* entry, Fib* fib);

__attribute__((nonnull)) void
PitEntry_SetExpiryTimer(PitEntry* entry, Pit* pit);

__attribute__((nonnull)) bool
PitEntry_SetSgTimer(PitEntry* entry, Pit* pit, TscDuration after);
 
__attribute__((nonnull)) void
PitEntry_Timeout_(MinTmr* tmr, uintptr_t pitPtr);

__attribute__((nonnull)) FaceID
PitEntry_FindDuplicateNonce(PitEntry* entry, uint32_t nonce, FaceID rxFace);

__attribute__((nonnull)) PitDn*
PitEntry_InsertDn(PitEntry* entry, Pit* pit, Packet* npkt);

__attribute__((nonnull)) PitUp*
PitEntry_FindUp(PitEntry* entry, FaceID face);

__attribute__((nonnull)) PitUp*
PitEntry_ReserveUp(PitEntry* entry, FaceID face);

__attribute__((nonnull)) void
PitEntry_GetTxInterestIlHl(PitEntry* entry, TscTime now, uint32_t* lifetime, uint8_t* hopLimit);
 
#endif // NDNDPDK_PCCT_PIT_ENTRY_H