DirectCore® Software

/*
   $Header: /root/Signalogic/DirectCore/apps/SigC641x_C667x/boardTest/cardTest.c
 
   Purpose:
 
     Minimum application example showing use of DirectCore APIs
 
   Description:
 
     host test program using DirectCore APIs and SigC66xx multicore CPU accelerator hardware
 
   Copyright (C) Signalogic Inc. 2014-2019
 
   Revision History
 
     Created Nov 2014 AKM
     Modified Jan 2016, JHB.  Simplify for web page presentation (remove declarations, local functions, etc).  Make easier to read
 
*/
 
#include <stdio.h>
#include <sys/socket.h>
#include <limits.h>
#include <unistd.h>
#include <sys/time.h>
 
/* Signalogic header files */
 
#include "hwlib.h"    /* DirectCore API header file */
#include "cimlib.h"   /* CIM lib API header file */
 
/* following header files required depending on application type */
 
#include "test_programs.h"
#include "keybd.h"
 
/* following shared host/target CPU header files required depending on app type */
 
#ifdef APP_SPECIFIC
  #include "streamlib.h"
  #include "video.h"
  #include "ia.h"
#endif
 
/* Global vars */
 
QWORD        nCoreList = 0;   /* bitwise core list, usually given in command line */
bool         fCoresLoaded = false;
 
/* Start of main() */
 
int main(int argc, char *argv[]) {
 
HCARD       hCard = (HCARD)NULL;  /* handle to card.  Note that multiple card handles can be opened */
CARDPARAMS  CardParams;
int         nDisplayCore, timer_count;
DWORD       data[120];
 
/* Display program header */
 
   printf("DirectCore minimum API example for C66x host and VM accelerators, Rev 2.1, Copyright (C) Signalogic 2015-2016\n");
 
/* Process command line for basic target CPU items:  card type, clock rate, executable file */
 
   if (!cimGetCmdLine(argc, argv, NULL, CIM_GCL_DEBUGPRINT, &CardParams, NULL)) exit(EXIT_FAILURE);
 
/* Display card info */
 
   printf("Accelerator card info: %s-%2.1fGHz, target executable file %s\n", CardParams.szCardDescription, CardParams.nClockRate/1e9, CardParams.szTargetExecutableFile);
 
/* Assign card handle, init cores, reset cores */
 
   if (!(hCard = cimInitHardware(CIM_IH_DEBUGPRINT, &CardParams))) {  /* use CIM_IH_DEBUGPRINT flag so cimInitHardware will print error messages, if any */
 
      printf("cimInitHardware failed\n");
      exit(EXIT_FAILURE);
   }
 
   nCoreList = CardParams.nCoreList;
 
/*
   If application specific items are being used, process the command line again using flags and
   structs as listed below (note -- this example gives NULL for the application specific struct)
 
   App                 Flag          Struct Argument (prefix with &)
   ---                 ----          -------------------------------
 
   VDI                 CIM_GCL_VDI   VDIParams
   Image Analytics     CIM_GCL_IA    IAParams
   Media Transcoding   CIM_GCL_MED   MediaParams
   Video               CIM_GCL_VID   VideoParams
   FFT                 CIM_GCL_FFT   FFTParams
*/
 
   if (!cimGetCmdLine(argc, argv, NULL, CIM_GCL_DEBUGPRINT, &CardParams, NULL)) goto cleanup;
 
/* Load executable file(s) to target CPU(s) */
 
   printf("Loading executable file %s to target CPU corelist 0x%lx\n", CardParams.szTargetExecutableFile, nCoreList);
 
   if (!(fCoresLoaded = DSLoadFileCores(hCard, CardParams.szTargetExecutableFile, nCoreList))) {
 
      printf("DSLoadFileCores failed\n");
      goto cleanup;
   }
 
/* Run target CPU hardware.  If required, give application type flag and pointer to application property struct, as noted in comments above */
 
   if (!cimRunHardware(hCard, CIM_RH_DEBUGPRINT | (CardParams.enableNetIO ? CIM_RH_ENABLENETIO : 0), &CardParams, NULL)) {
 
      printf("cimRunHardware failed\n");  /* use CIM_RH_DEBUGPRINT flag so cimRunHardware will print any error messages */
      goto cleanup;
   }
 
   nDisplayCore = GetDisplayCore(nCoreList);
   DSSetCoreList(hCard, (QWORD)1 << nDisplayCore);
 
   printf("Core list used for results display = 0x%llx\n", (unsigned long long)((QWORD)1 << nDisplayCore));
 
 
/* Start data acquisition and display using RTAF components */
 
   setTimerInterval((time_t)0, (time_t)1000);
   printf("Timer running...\n");
 
   while (1) {  /* we poll with IsTimerEventReady(), and use timer events to wake up and check target CPU buffer ready status */
 
      ch = getkey();  /* look for interactive keyboard commands */
 
      if (ch >= '0' && ch <= '9') {
 
         nDisplayCore = ch - '0';
 
         DSSetCoreList(hCard, (QWORD)1 << nDisplayCore);
      }
      else if (ch == 'Q' || ch == 'q' || ch == ESC) goto cleanup;
 
      if (IsTimerEventReady()) {
 
      /* check to see if next data buffer is available */
 
         if ((new_targetbufnum[nDisplayCore] = DSGetProperty(hCard, DSPROP_BUFNUM)) != targetbufnum[nDisplayCore]) {
 
            targetbufnum[nDisplayCore] = new_targetbufnum[nDisplayCore];  /* update local copy of target buffer number */
 
            printf("Got data for core %d... count[%d] = %d\n", nDisplayCore, nDisplayCore, count[nDisplayCore]++);
 
            if (dwCode_count_addr != 0) {
 
               DSReadMem(hCard, DS_RM_LINEAR_PROGRAM | DS_RM_MASTERMODE, dwCode_count_addr, DS_GM_SIZE32, &timer_count, 1);
               printf("Timer count value = %d\n", timer_count);
            }
 
         /* read data from target CPUs, display */
 
            if (DSReadMem(hCard, DS_RM_LINEAR_DATA | DS_RM_MASTERMODE, dwBufferBaseAddr + nBufLen * 4 * hostbufnum[nDisplayCore], DS_GM_SIZE32, (DWORD*)&data, sizeof(data)/sizeof(DWORD))) {
 
               hostbufnum[nDisplayCore] ^= 1;  /* toggle buffer number, let host know */
 
               DSSetProperty(hCard, DSPROP_HOSTBUFNUM, hostbufnum[nDisplayCore]);
 
               for (int i=0; i<120; i+=12) {
 
                  for (int j=0; j<12; j++) printf("0x%08x ", data[i+j]); printf("\n");
               }
            }
         }
      }
   }
 
cleanup:
 
   if (fCoresLoaded) SaveC66xLog(hCard);
 
   printf("Program and hardware cleanup, hCard = %d\n", hCard);
 
/* Hardware cleanup */
 
   if (hCard) cimCloseHardware(hCard, CIM_CH_DEBUGPRINT, nCoreList, NULL);
}
 
 
/* Local functions */
 
int GetDisplayCore(QWORD nCoreList) {
 
int nDisplayCore = 0;
 
   do {
 
      if (nCoreList & 1) break;
      nDisplayCore++;
 
   } while (nCoreList >>= 1);
 
   return nDisplayCore;
}

/* Allocate send mailbox handle (send = transmit, or tx) */
 
   if (tx_mailbox_handle[node] == NULL) {
 
      tx_mailbox_handle[node] = malloc(sizeof(mailBoxInst_t));
 
      if (tx_mailbox_handle[node] == NULL) {
         printf("Failed to allocate Tx mailbox memory for node = %d\n", node);
         return -1;
      }
   }
 
/* Create send mailbox */
 
   mailBox_config.mem_start_addr = host2dspmailbox + (nCore * TRANS_PER_MAILBOX_MEM_SIZE);
   mailBox_config.mem_size = TRANS_PER_MAILBOX_MEM_SIZE;
   mailBox_config.max_payload_size = TRANS_MAILBOX_MAX_PAYLOAD_SIZE;
 
   if (DSMailBoxCreate(hCard, tx_mailbox_handle[node], MAILBOX_MEMORY_LOCATION_REMOTE, MAILBOX_DIRECTION_SEND, &mailBox_config, (QWORD)1 << nCore) != 0) {
 
      printf("Tx DSMailboxCreate() failed for node: %d\n", node);
      return -1;
   }
 
/* Allocate receive mailbox handle (receive = rx) */
 
   if (rx_mailbox_handle[node] == NULL) {
 
      rx_mailbox_handle[node] = malloc(sizeof(mailBoxInst_t));
 
      if (rx_mailbox_handle[node] == NULL) {
         printf("Failed to allocate Tx mailbox memory for node = %d\n", node);
         return -1;
      }
   }
 
/* Create receive mailbox */
 
   mailBox_config.mem_start_addr = dsp2hostmailbox + (nCore * TRANS_PER_MAILBOX_MEM_SIZE);
 
   if (DSMailboxCreate(hCard, rx_mailbox_handle[node], MAILBOX_MEMORY_LOCATION_REMOTE, MAILBOX_DIRECTION_RECEIVE, &mailBox_config, (QWORD)1 << nCore) != 0) {
 
      printf("Rx DSMailboxCreate() failed for node: %d\n", node);
      return -1;
   }

/* query and read mailboxes on all active cores */
 
   nCore = 0;
 
   do {
 
      if (nCoreList & ((QWORD)1 << nCore)) {
 
         ret_val = DSQueryMailbox(hCard, (QWORD)1 << nCore);
 
         if (ret_val < 0) {
 
            fprintf(mailbox_out, "mailBox_query error: %d\n", ret_val);
            continue;
         }
 
         while(ret_val-- > 0) {
 
            ret_val = DSReadMailbox(hCard, rx_buffer, &size, &trans_id, (QWORD)1 << nCore);
 
            if (ret_val < 0) {
 
               fprintf(mailbox_out, "mailBox_read error: %d\n", ret_val);
               continue;
            }
 
            memcpy(&header_in, rx_buffer, sizeof(struct cmd_hdr));
 
            if (header_in.type == DS_CMD_CREATE_SESSION_ACK) {
               :
               :
            }
            else if (header_in.type == DS_CMD_DELETE_SESSION_ACK) {
               :
               :
            }
            else if (header_in.type == DS_CMD_EVENT_INDICATION) {
               :
               :
            }
         }
      }
 
      nCore++;
 
   } while (nCoreList >> 1);

typedef struct {
 
/* from command line */
 
  char          szCardDesignator[CMDOPT_MAX_INPUT_LEN];
  char          szTargetExecutableFile[CMDOPT_MAX_INPUT_LEN];
  unsigned int  nClockRate;
  QWORD         nCoreList;
 
/* derived from command line entries */
 
  char          szCardDescription[CMDOPT_MAX_INPUT_LEN];
  unsigned int  maxCoresPerCPU;
  unsigned int  maxCPUsPerCard;
  unsigned int  maxActiveCoresPerCard;
 
  unsigned int  numActiveCPUs;   /* total number of currently active CPUs (note: not max CPUs, but CPUs currently in use) */
  unsigned int  numActiveCores;  /* total number of currently active cores (note: not max cores, but cores currently in use) */
 
  bool          enableNetIO;     /* set if command line params indicate that network I/O is needed.  Various application-specific params are checked */
 
  WORD          wCardClass;
  unsigned int  uTestMode;
  bool          enableTalker;    /* not used for c66x hardware */
 
  CIMINFO       cimInfo[MAXCPUSPERCARD];
 
} CARDPARAMS;  /* common target CPU and card params */
 
typedef CARDPARAMS* PCARDPARAMS;