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 __rte_packed_begin SgEvent {
  SGEVT_NONE,
  SGEVT_INTEREST, 
  SGEVT_DATA,     
  SGEVT_NACK,     
  SGEVT_TIMER,    
} __rte_packed_end 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 __rte_packed_begin SgForwardInterestResult {
  SGFWDI_OK,         
  SGFWDI_BADFACE,    
  SGFWDI_ALLOCERR,   
  SGFWDI_NONONCE,    
  SGFWDI_SUPPRESSED, 
  SGFWDI_HOPZERO,    
} __rte_packed_end 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