api.h

Go to the documentation of this file.

#ifndef NDNDPDK_STRATEGYAPI_API_H
#define NDNDPDK_STRATEGYAPI_API_H
 
#include "../strategycode/sec.h"
#include "fib.h"
#include "packet.h"
#include "pit.h"
 
typedef struct SgGlobal {
  uint64_t tscHz;
} SgGlobal;
 
typedef enum SgEvent {
  SGEVT_NONE,
  SGEVT_INTEREST, 
  SGEVT_DATA,     
  SGEVT_NACK,     
  SGEVT_TIMER,    
} __rte_packed SgEvent;
 
typedef struct SgCtx {
  const SgGlobal* global;
 
  TscTime now;
 
  SgEvent eventKind;
 
  SgFibNexthopFilter nhFlt;
 
  const SgPacket* pkt;
 
  const SgFibEntry* fibEntry;
 
  SgFibEntryDyn* fibEntryDyn;
 
  SgPitEntry* pitEntry;
} SgCtx;
 
SUBROUTINE TscDuration
SgTscFromMillis(SgCtx* ctx, uint64_t millis) {
  return millis * ctx->global->tscHz / 1000;
}
 
SUBROUTINE void
SgFibNexthopIt_InitCtx(SgFibNexthopIt* it, const SgCtx* ctx) {
  SgFibNexthopIt_Init(it, ctx->fibEntry, ctx->nhFlt);
}
 
#define SgCtx_FibScratchT(ctx, T)                                                                  \
  __extension__({                                                                                  \
    static_assert(sizeof(T) <= FibScratchSize, "");                                                \
    (T*)(ctx)->fibEntryDyn->scratch;                                                               \
  })
 
#define SgCtx_PitScratchT(ctx, T)                                                                  \
  __extension__({                                                                                  \
    static_assert(sizeof(T) <= PitScratchSize, "");                                                \
    (T*)(ctx)->pitEntry->scratch;                                                                  \
  })
 
__attribute__((nonnull)) uint32_t
SgRandInt(SgCtx* ctx, uint32_t max);
 
__attribute__((nonnull)) bool
SgSetTimer(SgCtx* ctx, TscDuration after);
 
typedef enum SgForwardInterestResult {
  SGFWDI_OK,         
  SGFWDI_BADFACE,    
  SGFWDI_ALLOCERR,   
  SGFWDI_NONONCE,    
  SGFWDI_SUPPRESSED, 
  SGFWDI_HOPZERO,    
} __rte_packed SgForwardInterestResult;
 
__attribute__((nonnull)) SgForwardInterestResult
SgForwardInterest(SgCtx* ctx, FaceID nh);
 
__attribute__((nonnull)) void
SgReturnNacks(SgCtx* ctx, NackReason reason);
 
__attribute__((section(SGSEC_MAIN), used, nonnull)) uint64_t
SgMain(SgCtx* ctx);
 
enum {
  SGJSON_SCALAR = -1,
  SGJSON_LEN = -2,
};
 
__attribute__((nonnull)) bool
SgGetJSON(SgCtx* ctx, const char* path, int index, int64_t* dst);
 
#define SgGetJSONScalar(ctx, path, dflt)                                                           \
  __extension__({                                                                                  \
    int64_t value = (dflt);                                                                        \
    char pathA[] = (path);                                                                         \
    SgGetJSON((ctx), pathA, SGJSON_SCALAR, &value);                                                \
    value;                                                                                         \
  })
 
#define SgGetJSONSlice(dst, ctx, path, dflt)                                                       \
  __extension__({                                                                                  \
    int64_t length = (0);                                                                          \
    char pathA[] = (path);                                                                         \
    SgGetJSON((ctx), pathA, SGJSON_LEN, &length);                                                  \
    for (int64_t i = 0; i < RTE_DIM((dst)); ++i) {                                                 \
      int64_t value = (dflt);                                                                      \
      if (i < length) {                                                                            \
        SgGetJSON((ctx), pathA, i, &value);                                                        \
      }                                                                                            \
      (dst)[i] = value;                                                                            \
    }                                                                                              \
    length;                                                                                        \
  })
 
__attribute__((section(SGSEC_INIT), used, nonnull)) uint64_t
SgInit(SgCtx* ctx);
 
#define SGINIT_SCHEMA(...)                                                                         \
  char SgJSONSchema[] __attribute__((section(SGSEC_SCHEMA), used)) = #__VA_ARGS__;
 
#endif // NDNDPDK_STRATEGYAPI_API_H