Int Task_execute (Task_TransferInfo * info)
{
int sum;
//wait for semaphore
SEM_pend (&(info->notifySemObj), SYS_FOREVER);
//invalidate cache
BCACHE_inv ((Ptr)buf, length, TRUE) ;
//call the functionality to be performed by dsp
sum = sum_dsp();
//notify that we are done
NOTIFY_notify(ID_GPP,MPCSXFER_IPS_ID,MPCSXFER_IPS_EVENTNO,(Uint32)0);
//notify the result
NOTIFY_notify(ID_GPP,MPCSXFER_IPS_ID,MPCSXFER_IPS_EVENTNO,(Uint32)sum);
return SYS_OK;
}
Void LogCallback (Uint32 event, Pvoid arg, Pvoid info)
{
static char PrintBuffer[512];
// get data from DSP:
int status = PROC_read(0, (int)info, 512, PrintBuffer);
if (status == DSP_SOK)
printf ("DSP-LOG: %s", PrintBuffer);
else
printf ("DEBUG: Unable to read dsp-mem %p\n", info);
// notify the DSP-side:
NOTIFY_notify (0, 0, 6, 0);
}
void dprintf (const char * format, ...)
{
int n;
va_list args;
va_start (args, format);
n = vsprintf (printf_buffer,format, args);
va_end (args);
if (n<=0) return;
// writeback cache:
BCACHE_wb (printf_buffer, n, 1);
// notify GPP:
NOTIFY_notify (ID_GPP, 0, 6, (Uint32)printf_buffer);
// wait for GPP acknowledge
SEM_pendBinary (dprint_sema, SYS_FOREVER);
}
Int Task_create (Task_TransferInfo ** infoPtr)
{
Int status = SYS_OK ;
Task_TransferInfo * info = NULL ;
/* Allocate Task_TransferInfo structure that will be initialized
* and passed to other phases of the application */
if (status == SYS_OK)
{
*infoPtr = MEM_calloc (DSPLINK_SEGID,
sizeof (Task_TransferInfo),
0) ; /* No alignment restriction */
if (*infoPtr == NULL)
{
status = SYS_EALLOC ;
}
else
{
info = *infoPtr ;
}
}
/* Fill up the transfer info structure */
if (status == SYS_OK)
{
info->dataBuf = NULL ; /* Set through notification callback. */
info->bufferSize = MPCSXFER_BufferSize ;
SEM_new (&(info->notifySemObj), 0) ;
}
/*
* Register notification for the event callback to get control and data
* buffer pointers from the GPP-side.
*/
if (status == SYS_OK)
{
status = NOTIFY_register (ID_GPP,
MPCSXFER_IPS_ID,
MPCSXFER_IPS_EVENTNO,
(FnNotifyCbck) Task_notify,
info) ;
if (status != SYS_OK)
{
return status;
}
}
/*
* Send notification to the GPP-side that the application has completed its
* setup and is ready for further execution.
*/
if (status == SYS_OK)
{
status = NOTIFY_notify (ID_GPP,
MPCSXFER_IPS_ID,
MPCSXFER_IPS_EVENTNO,
(Uint32) 0) ; /* No payload to be sent. */
if (status != SYS_OK)
{
return status;
}
}
/*
* Wait for the event callback from the GPP-side to post the semaphore
* indicating receipt of the data buffer pointer and image width and height.
*/
SEM_pend (&(info->notifySemObj), SYS_FOREVER) ;
SEM_pend (&(info->notifySemObj), SYS_FOREVER) ;
return status ;
}
/** ============================================================================
* @func pool_notify_Execute
*
* @desc This function implements the execute phase for this application.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
pool_notify_Execute (IN Uint32 numIterations, Uint8 processorId, IN Char8 * strFeatures, IN Char8 * strFrames)
{
DSP_STATUS status = DSP_SOK ;
long long start;
// Variables for klt
unsigned char *img1, *img2;
char fnamein[100], fnameout[100];
KLT_TrackingContext tc;
KLT_FeatureList fl;
KLT_FeatureTable ft;
int ncols, nrows;
int i;
int nFeatures;
int nFrames;
#if defined(DSP)
unsigned char *buf_dsp;
#endif
#ifdef DEBUG
printf ("Entered pool_notify_Execute ()\n") ;
#endif
nFeatures = atoi(strFeatures);
nFrames = atoi(strFrames);
unit_init();
start = get_usec();
tc = KLTCreateTrackingContext();
fl = KLTCreateFeatureList(nFeatures);
ft = KLTCreateFeatureTable(nFrames, nFeatures);
tc->sequentialMode = TRUE;
tc->writeInternalImages = FALSE;
tc->affineConsistencyCheck = -1; /* set this to 2 to turn on affine consistency check */
//startTimer(&appTimer);
img1 = pgmReadFile("img0.pgm", NULL, &ncols, &nrows);
img2 = (unsigned char *) malloc(ncols*nrows*sizeof(unsigned char));
KLTSelectGoodFeatures(tc, img1, ncols, nrows, fl);
KLTStoreFeatureList(fl, ft, 0);
KLTWriteFeatureListToPPM(fl, img1, ncols, nrows, "feat0.ppm");
for (i = 1 ; i < nFrames ; i++)
{
sprintf(fnamein, "img%d.pgm", i);
pgmReadFile(fnamein, img2, &ncols, &nrows);
KLTTrackFeatures(tc, img1, img2, ncols, nrows, fl);
#ifdef REPLACE
KLTReplaceLostFeatures(tc, img2, ncols, nrows, fl);
#endif
KLTStoreFeatureList(fl, ft, i);
sprintf(fnameout, "feat%d.ppm", i);
KLTWriteFeatureListToPPM(fl, img2, ncols, nrows, fnameout);
}
//stopTimer(&appTimer);
//printTime(appTimer);
//printf("Frames per second = %4.2f\n", nFrames / getTime(appTimer) *1000 );
KLTWriteFeatureTable(ft, "features.txt", "%5.1f");
KLTWriteFeatureTable(ft, "features.ft", NULL);
KLTFreeFeatureTable(ft);
KLTFreeFeatureList(fl);
KLTFreeTrackingContext(tc);
free(img1);
free(img2);
#if !defined(DSP)
printf(" Result is %d \n", sum_dsp(pool_notify_DataBuf,pool_notify_BufferSize));
#endif
#if defined(DSP)
POOL_writeback (POOL_makePoolId(processorId, SAMPLE_POOL_ID),
pool_notify_DataBuf,
pool_notify_BufferSize);
POOL_translateAddr ( POOL_makePoolId(processorId, SAMPLE_POOL_ID),
(void*)&buf_dsp,
AddrType_Dsp,
(Void *) pool_notify_DataBuf,
AddrType_Usr) ;
NOTIFY_notify (processorId,pool_notify_IPS_ID,pool_notify_IPS_EVENTNO,1);
sem_wait(&sem);
#endif
printf("Sum execution time %lld us.\n", get_usec()-start);
return status ;
}
/** ============================================================================
* @func pool_notify_Create
*
* @desc This function allocates and initializes resources used by
* this application.
*
* @modif None
* ============================================================================
*/
NORMAL_API
DSP_STATUS
pool_notify_Create (IN Char8 * dspExecutable,
IN Char8 * strBufferSize,
IN Uint8 processorId)
{
DSP_STATUS status = DSP_SOK ;
Uint32 numArgs = NUM_ARGS ;
Void * dspDataBuf = NULL ;
Uint32 numBufs [NUM_BUF_SIZES] = {NUM_BUF_POOL0,
} ;
Uint32 size [NUM_BUF_SIZES] ;
SMAPOOL_Attrs poolAttrs ;
Char8 * args [NUM_ARGS] ;
#ifdef DEBUG
printf ("Entered pool_notify_Create ()\n") ;
#endif
sem_init(&sem,0,0);
/*
* Create and initialize the proc object.
*/
status = PROC_setup (NULL) ;
/*
* Attach the Dsp with which the transfers have to be done.
*/
if (DSP_SUCCEEDED (status)) {
status = PROC_attach (processorId, NULL) ;
if (DSP_FAILED (status)) {
printf ("PROC_attach () failed. Status = [0x%x]\n",
(int)status) ;
}
}
else {
printf ("PROC_setup () failed. Status = [0x%x]\n", (int)status) ;
}
/*
* Open the pool.
*/
if (DSP_SUCCEEDED (status)) {
size [0] = pool_notify_BufferSize ;
poolAttrs.bufSizes = (Uint32 *) &size ;
poolAttrs.numBuffers = (Uint32 *) &numBufs ;
poolAttrs.numBufPools = NUM_BUF_SIZES ;
poolAttrs.exactMatchReq = TRUE ;
status = POOL_open (POOL_makePoolId(processorId, SAMPLE_POOL_ID),
&poolAttrs) ;
if (DSP_FAILED (status)) {
printf ("POOL_open () failed. Status = [0x%x]\n",
(int)status) ;
}
}
/*
* Allocate the data buffer to be used for the application.
*/
if (DSP_SUCCEEDED (status)) {
status = POOL_alloc (POOL_makePoolId(processorId, SAMPLE_POOL_ID),
(Void **) &pool_notify_DataBuf,
pool_notify_BufferSize) ;
/* Get the translated DSP address to be sent to the DSP. */
if (DSP_SUCCEEDED (status)) {
status = POOL_translateAddr (
POOL_makePoolId(processorId, SAMPLE_POOL_ID),
&dspDataBuf,
AddrType_Dsp,
(Void *) pool_notify_DataBuf,
AddrType_Usr) ;
if (DSP_FAILED (status)) {
printf ("POOL_translateAddr () DataBuf failed."
" Status = [0x%x]\n",
(int)status) ;
}
}
else {
printf ("POOL_alloc () DataBuf failed. Status = [0x%x]\n",
(int)status) ;
}
}
/*
* Register for notification that the DSP-side application setup is
* complete.
*/
if (DSP_SUCCEEDED (status)) {
status = NOTIFY_register (processorId,
pool_notify_IPS_ID,
pool_notify_IPS_EVENTNO,
(FnNotifyCbck) pool_notify_Notify,
0/* vladms XFER_SemPtr*/) ;
if (DSP_FAILED (status)) {
printf ("NOTIFY_register () failed Status = [0x%x]\n",
(int)status) ;
}
}
/*
* Load the executable on the DSP.
*/
if (DSP_SUCCEEDED (status)) {
args [0] = strBufferSize ;
{
status = PROC_load (processorId, dspExecutable, numArgs, args) ;
}
if (DSP_FAILED (status)) {
printf ("PROC_load () failed. Status = [0x%x]\n", (int)status) ;
}
}
/*
* Start execution on DSP.
*/
if (DSP_SUCCEEDED (status)) {
status = PROC_start (processorId) ;
if (DSP_FAILED (status)) {
printf ("PROC_start () failed. Status = [0x%x]\n",
(int)status) ;
}
}
/*
* Wait for the DSP-side application to indicate that it has completed its
* setup. The DSP-side application sends notification of the IPS event
* when it is ready to proceed with further execution of the application.
*/
if (DSP_SUCCEEDED (status)) {
// wait for initialization
sem_wait(&sem);
}
/*
* Send notifications to the DSP with information about the address of the
* control structure and data buffer to be used by the application.
*
*/
status = NOTIFY_notify (processorId,
pool_notify_IPS_ID,
pool_notify_IPS_EVENTNO,
(Uint32) dspDataBuf);
if (DSP_FAILED (status)) {
printf ("NOTIFY_notify () DataBuf failed."
" Status = [0x%x]\n",
(int)status) ;
}
status = NOTIFY_notify (processorId,
pool_notify_IPS_ID,
pool_notify_IPS_EVENTNO,
(Uint32) pool_notify_BufferSize);
if (DSP_FAILED (status)) {
printf ("NOTIFY_notify () DataBuf failed."
" Status = [0x%x]\n",
(int)status) ;
}
#ifdef DEBUG
printf ("Leaving pool_notify_Create ()\n") ;
#endif
return status ;
}
