int wl_timer_initialize(){
int status = 0;
XTmrCtr *TmrCtrInstancePtr = &TimerCounter;
XTmrCtr_Config *TmrCtrConfigPtr;
//Initialize the timer counter
status = XTmrCtr_Initialize(TmrCtrInstancePtr, TMRCTR_DEVICE_ID);
if (status == XST_DEVICE_IS_STARTED) {
xil_printf("Timer was already running; clear/init manually\n");
TmrCtrConfigPtr = XTmrCtr_LookupConfig(TMRCTR_DEVICE_ID);
TmrCtrInstancePtr->BaseAddress = TmrCtrConfigPtr->BaseAddress;
TmrCtrInstancePtr->IsReady = XIL_COMPONENT_IS_READY;
XTmrCtr_Stop(TmrCtrInstancePtr, 0);
XTmrCtr_Reset(TmrCtrInstancePtr, 0);
status = XTmrCtr_Initialize(TmrCtrInstancePtr, TMRCTR_DEVICE_ID);
}
if (status != XST_SUCCESS) {
xil_printf("w3_node_init: Error in XtmrCtr_Initialize (%d)\n", status);
}
// Set timer 0 to into a "count down" mode
XTmrCtr_SetOptions(TmrCtrInstancePtr, 0, (XTC_DOWN_COUNT_OPTION));
///Timer Setup///
XTmrCtr_SetResetValue(TmrCtrInstancePtr,1,0); //Sets it so issuing a "start" command begins at counter=0
/////////////////
return status;
}
void timer_start() {
if (!initialized) return;
started = true;
XTmrCtr_Reset(&TmrCtrInstancePtr, 0);
startTime = XTmrCtr_GetValue(&TmrCtrInstancePtr, 0);
XTmrCtr_Start(&TmrCtrInstancePtr, 0);
}
void usleep(unsigned int duration){
XTmrCtr *TmrCtrInstancePtr = &TimerCounter;
XTmrCtr_SetResetValue(TmrCtrInstancePtr,0,duration*(TIMER_FREQ/1000000));
XTmrCtr_Start(TmrCtrInstancePtr,0);
volatile u8 isExpired = 0;
while(isExpired!=1){
isExpired = XTmrCtr_IsExpired(TmrCtrInstancePtr,0);
}
XTmrCtr_Reset(TmrCtrInstancePtr,0);
return;
}
void Timer_InterruptHandler(void *data, u8 TmrCtrNumber)
{
print("\r\n");
print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\r\n");
print(" Inside Timer ISR \n \r ");
XTmrCtr_Stop(&TimerInstancePtr,TmrCtrNumber);
XGpioPs_WritePin(&psGpioInstancePtr,iPinNumber,0);
XGpioPs_WritePin(&psGpioInstancePtr,55,0);
XTmrCtr_Reset(&TimerInstancePtr,TmrCtrNumber);
print(" Timer ISR Exit\n \n \r");
print("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\r\n");
}
/* This is an application defined callback function used to install the tick
interrupt handler. It is provided as an application callback because the kernel
will run on lots of different MicroBlaze and FPGA configurations - not all of
which will have the same timer peripherals defined or available. This example
uses the AXI Timer 0. If that is available on your hardware platform then this
example callback implementation should not require modification. The name of
the interrupt handler that should be installed is vPortTickISR(), which the
function below declares as an extern. */
void vApplicationSetupTimerInterrupt( void )
{
portBASE_TYPE xStatus;
const unsigned char ucTimerCounterNumber = ( unsigned char ) 0U;
const unsigned long ulCounterValue = ( ( TIMER_CLOCK_FREQ / configTICK_RATE_HZ ) - 1UL );
extern void vPortTickISR( void *pvUnused );
/* Initialise the timer/counter. */
xStatus = XTmrCtr_Initialize( &xTimer0Instance, TIMER_DEVICE_ID );
if (xStatus == XST_DEVICE_IS_STARTED)
{
xTimer0Instance.IsReady = XIL_COMPONENT_IS_READY;
XTmrCtr_Stop( &xTimer0Instance, TIMER_DEVICE_ID );
XTmrCtr_Reset( &xTimer0Instance, TIMER_DEVICE_ID );
xStatus = XTmrCtr_Initialize( &xTimer0Instance, TIMER_DEVICE_ID );
xStatus = XST_SUCCESS;
}
if( xStatus == XST_SUCCESS )
{
/* Install the tick interrupt handler as the timer ISR.
*NOTE* The xPortInstallInterruptHandler() API function must be used for
this purpose. */
xStatus = xPortInstallInterruptHandler(TIMER_INTR_ID, vPortTickISR, NULL );
}
if( xStatus == pdPASS )
{
/* Enable the timer interrupt in the interrupt controller.
*NOTE* The vPortEnableInterrupt() API function must be used for this
purpose. */
vPortEnableInterrupt(TIMER_INTR_ID);
/* Configure the timer interrupt handler. */
XTmrCtr_SetHandler( &xTimer0Instance, ( void * ) vPortTickISR, NULL );
/* Set the correct period for the timer. */
XTmrCtr_SetResetValue( &xTimer0Instance, ucTimerCounterNumber, ulCounterValue );
/* Enable the interrupts. Auto-reload mode is used to generate a
periodic tick. Note that interrupts are disabled when this function is
called, so interrupts will not start to be processed until the first
task has started to run. */
XTmrCtr_SetOptions( &xTimer0Instance, ucTimerCounterNumber, ( XTC_INT_MODE_OPTION | XTC_AUTO_RELOAD_OPTION | XTC_DOWN_COUNT_OPTION ) );
/* Start the timer. */
XTmrCtr_Start( &xTimer0Instance, ucTimerCounterNumber );
}
/* Sanity check that the function executed as expected. */
configASSERT( ( xStatus == pdPASS ) );
}
/*
* Timer Interrupt Handler
*/
void tmrIntrHandler(void *InstancePtr) {
if (XTmrCtr_IsExpired(&tmrCtr, 0)) {
//Stop Timer Controller
XTmrCtr_Stop(&tmrCtr, 0);
//Set flag
tmrExpired = BOOL_TRUE;
//Reset Timer Controller
XTmrCtr_Reset(&tmrCtr, 0);
//Start Timer
XTmrCtr_Start(&tmrCtr, 0);
}
}
/**
*
* This function sets up a custom timer which the driver will use for MicroBlaze
* systems.
*
* @param None.
*
* @return
* - XST_SUCCESS if a timer controller exists for use.
* - XST_FAILURE otherwise.
*
* @note A timer controller must be present in the system.
*
******************************************************************************/
u32 DpRxSs_SetupTimerHandler(void)
{
u32 Status;
Status = XTmrCtr_Initialize(&TmrCtrInst, XTMR_CTRL_DEVICE_ID);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/* Set a custom timer handler for improved delay accuracy on MicroBlaze
* systems since the driver does not assume/have a dependency on the
* system having a timer in the FPGA.
* Note: This only has an affect for MicroBlaze systems since the Zynq
* ARM SoC contains a timer, which is used when the driver calls the
* delay function. */
XDpRxSs_SetUserTimerHandler(&DpRxSsInst, &DpRxSs_CustomWaitUs,
&TmrCtrInst);
XTmrCtr_SetResetValue(DpRxSsInst.DpPtr->UserTimerPtr, 0, 0);
XTmrCtr_Reset(DpRxSsInst.DpPtr->UserTimerPtr, 0);
return XST_SUCCESS;
}
/**
* This function sets up a custom timer which the driver will use for MicroBlaze
* systems.
*
* @param InstancePtr is a pointer to the XDp instance.
* @param TimerCounterPtr is a pointer to the timer instance.
* @param TimerId is the ID of the timer controller to use for delays.
*
* @return
* - XST_SUCCESS if a timer controller exists for use.
* - XST_FAILURE otherwise.
*
* @note A timer controller must be present in the system.
*
*******************************************************************************/
static u32 Dprx_SetupTimerHandler(XDp *InstancePtr, XTmrCtr *TimerCounterPtr,
u16 TimerId)
{
u32 Status;
Status = XTmrCtr_Initialize(TimerCounterPtr, TimerId);
if (Status != XST_SUCCESS) {
return XST_FAILURE;
}
/* Set a custom timer handler for improved delay accuracy on MicroBlaze
* systems since the driver does not assume/have a dependency on the
* system having a timer in the FPGA.
* Note: This only has an affect for MicroBlaze systems since the Zynq
* ARM SoC contains a timer, which is used when the driver calls the
* delay function. */
XDp_SetUserTimerHandler(InstancePtr, &Dprx_CustomWaitUs,
TimerCounterPtr);
XTmrCtr_SetResetValue(InstancePtr->UserTimerPtr, 0, 0);
XTmrCtr_Reset(InstancePtr->UserTimerPtr, 0);
return XST_SUCCESS;
}
int main (void)
{
float u[n*n], v[n*n], u0[n*n], v0[n*n];
float x, y, x0, y_0, f, r, U[2], V[2], s, t;
int i, j, i0, j_0, i1, j_1,m;
int k;
float visc=1.25;
float dt=2.36;
int start,end;
xil_printf("----------------------- START ------------------------ ! \n\r");
int MASK_LENGTH= 10;//(int) ceil((log(BUFFER_SIZE))/log(2));
int MASK = ((1 << MASK_LENGTH)-1);
//-- Flag Initializations
for (i=0; i<BUFFER_SIZE; i++)
{
flag1[i]=0;
flag2[i]=0;
flag3[i]=0;
}
XTmrCtr timer;
XTmrCtr_Initialize(&timer, XPAR_XPS_TIMER_0_DEVICE_ID);
XTmrCtr_Reset(&timer, TIMER_COUNTER_0);
start = XTmrCtr_GetValue(&timer, TIMER_COUNTER_0);
// Start timer
XTmrCtr_Start(&timer, TIMER_COUNTER_0);
//------- LOOP FOR IMAGES -------
for (k=0; k < Number_of_Images; k++) // loop for Images
{
consumer_index = ci; // for nested loop can be i*n+j
while (consumer_index<SIZE_floid)
{
if (read_from_fifo ==1)
{
getfsl(fifo_index,0);
if (fifo_index!=999999999)
{
getfsl(fifo_data,0);
getfsl(fifo_data2,0);
xil_printf("READ %d FROM FIFO \t",fifo_index);
if (consumer_index == fifo_index && fifo_index!=999999999)
{
// consume the data directly
consumer_data = fifo_data;
consumer_data2 = fifo_data2;
xil_printf("»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»» %d DIRECTLY CONSUMED !\n\r",consumer_index);
consumer_index=consumer_index+1;//ci;
consumer_done=1;
read_from_fifo=1;
//-- The rest of consumer's computing stage here : output: consumer_index
u0[i+(n+2)*j] = consumer_data; // u[i+n*j]
v0[i+(n+2)*j] = consumer_data2; // v[i+n*j]
y = j<=n/2 ? j : j-n;
r = x*x+y*y;
if ( r==0.0 ) continue;
f = exp(-r*dt*visc);
U[0] = u0[i +(n+2)*j];
V[0] = v0[i +(n+2)*j];
U[1] = u0[i+1+(n+2)*j];
V[1] = v0[i+1+(n+2)*j];
u0[i +(n+2)*j] = f*( (1-x*x/r)*U[0] -x*y/r *V[0] );
u0[i+1+(n+2)*j] = f*( (1-x*x/r)*U[1] -x*y/r *V[1] );
v0[i+ (n+2)*j] = f*( -y*x/r *U[0] + (1-y*y/r)*V[0] );
v0[i+1+(n+2)*j] = f*( -y*x/r *U[1] + (1-y*y/r)*V[1] );
}
}
else if (fifo_index==999999999)
{
xil_printf("==PRODUCER STOPPED AND consumer_index IS %d!\n\r",consumer_index);
read_from_fifo=0;
//consumer_index++;
}
}
// compute the hash
consumer_hash_index = consumer_index & MASK; // here index is not refreshing
fifo_hash_index = fifo_index & MASK;
// Load from memory
if (flag1[consumer_hash_index]==1 && index1[consumer_hash_index]==consumer_index)
{
flag1[consumer_hash_index]=0;
consumer_data= data1[consumer_hash_index];
xil_printf("========== LOAD consumer_index %d from T1 ================!\n\r",consumer_index);
consumer_index++;
consumer_done=1;
//-- The rest of consumer's computing stage here : output: consumer_index
u0[i+(n+2)*j] = consumer_data; // u[i+n*j]
v0[i+(n+2)*j] = consumer_data2; // v[i+n*j]
y = j<=n/2 ? j : j-n;
r = x*x+y*y;
if ( r==0.0 ) continue;
f = exp(-r*dt*visc);
U[0] = u0[i +(n+2)*j];
V[0] = v0[i +(n+2)*j];
U[1] = u0[i+1+(n+2)*j];
V[1] = v0[i+1+(n+2)*j];
u0[i +(n+2)*j] = f*( (1-x*x/r)*U[0] -x*y/r *V[0] );
u0[i+1+(n+2)*j] = f*( (1-x*x/r)*U[1] -x*y/r *V[1] );
v0[i+ (n+2)*j] = f*( -y*x/r *U[0] + (1-y*y/r)*V[0] );
v0[i+1+(n+2)*j] = f*( -y*x/r *U[1] + (1-y*y/r)*V[1] );
if (fifo_index!=999999999)
read_from_fifo=1;
}
else if (flag2[consumer_hash_index]==1 && index2[consumer_hash_index]==consumer_index)
{
flag2[consumer_hash_index]=0;
consumer_data= data2[consumer_hash_index];
consumer_index++;
read_from_fifo=1;
consumer_done=1;
xil_printf("=================== LOAD consumer_index %d from T2 ================!\n\r",consumer_index);
//-- The rest of consumer's computing stage here : output: consumer_index
u0[i+(n+2)*j] = consumer_data; // u[i+n*j]
v0[i+(n+2)*j] = consumer_data2; // v[i+n*j]
y = j<=n/2 ? j : j-n;
r = x*x+y*y;
if ( r==0.0 ) continue;
f = exp(-r*dt*visc);
U[0] = u0[i +(n+2)*j];
V[0] = v0[i +(n+2)*j];
U[1] = u0[i+1+(n+2)*j];
V[1] = v0[i+1+(n+2)*j];
u0[i +(n+2)*j] = f*( (1-x*x/r)*U[0] -x*y/r *V[0] );
u0[i+1+(n+2)*j] = f*( (1-x*x/r)*U[1] -x*y/r *V[1] );
v0[i+ (n+2)*j] = f*( -y*x/r *U[0] + (1-y*y/r)*V[0] );
v0[i+1+(n+2)*j] = f*( -y*x/r *U[1] + (1-y*y/r)*V[1] );
}
else if (flag3[consumer_hash_index]==1 && index3[consumer_hash_index]==consumer_index)
{
flag3[consumer_hash_index]=0;
consumer_data= data3[consumer_hash_index];
consumer_index++;
read_from_fifo=1;
consumer_done=1;
consumer_done=1;
xil_printf("=================== LOAD consumer_index %d from T3 ================!\n\r",consumer_index);
//-- The rest of consumer's computing stage here : output: consumer_index
u0[i+(n+2)*j] = consumer_data; // u[i+n*j]
v0[i+(n+2)*j] = consumer_data2; // v[i+n*j]
y = j<=n/2 ? j : j-n;
r = x*x+y*y;
if ( r==0.0 ) continue;
f = exp(-r*dt*visc);
U[0] = u0[i +(n+2)*j];
V[0] = v0[i +(n+2)*j];
U[1] = u0[i+1+(n+2)*j];
V[1] = v0[i+1+(n+2)*j];
u0[i +(n+2)*j] = f*( (1-x*x/r)*U[0] -x*y/r *V[0] );
u0[i+1+(n+2)*j] = f*( (1-x*x/r)*U[1] -x*y/r *V[1] );
v0[i+ (n+2)*j] = f*( -y*x/r *U[0] + (1-y*y/r)*V[0] );
v0[i+1+(n+2)*j] = f*( -y*x/r *U[1] + (1-y*y/r)*V[1] );
}
// Store in memory
else if (read_from_fifo ==1 && consumer_done==0)
{
if (flag1[fifo_hash_index]==0 && fifo_index!=999999999)
{
data1[fifo_hash_index] =fifo_data;
index1[fifo_hash_index] =fifo_index;
flag1[fifo_hash_index]=1;
read_from_fifo=1;
xil_printf("»»»»»»»»»»»»»»»»»%d STORED in T1 \n\r",fifo_index);
}
else if (flag2[fifo_hash_index]==0 && fifo_index!=999999999)
{
data2[fifo_hash_index] =fifo_data;
index2[fifo_hash_index] =fifo_index;
flag2[fifo_hash_index]=1;
read_from_fifo=1;
xil_printf("»»»»»»»»»»»»»»»»»%d STORED in T2 \n\r",fifo_index);
}
else if (flag3[fifo_hash_index]==0 && fifo_index!=999999999)
{
data3[fifo_hash_index] =fifo_data;
index3[fifo_hash_index] =fifo_index;
flag3[fifo_hash_index]=1;
read_from_fifo=1;
xil_printf("»»»»»»»»»»»»»»»»»%d STORED in T3 \n\r",fifo_index);
}
else
read_from_fifo=0;
} // Store in memory
else
{
xil_printf("ERROR ! Index %d cannot be found !!!!\n\r",consumer_index);
consumer_done=0;
consumer_index++;
}
}
}
xil_printf ("consumer_index =%d \t ci=%d \n\r",consumer_index,ci);
end = XTmrCtr_GetValue(&timer, TIMER_COUNTER_0);
XTmrCtr_Stop(&timer, TIMER_COUNTER_0);
xil_printf("Timer Start value = %d Timer end value = %d \r\n", start, end-start);
return 0;
}
void resetTimer(u8 TmrCtrNumber) {
XTmrCtr_Reset(&timer, TmrCtrNumber);
}
void * foo_thread(void * arg)
{
data * package = (data *) arg;
Hint * dataA = package->dataA;
Hint * dataB = package->dataB;
Hint * dataC = package->dataC;
Hint * brama = (Hint *) BRAMA;
Hint * bramb = (Hint *) BRAMB;
Hint * bramc = (Hint *) BRAMC;
int e,Status;
int time = package->time;
XTmrCtr * mytimer =package->timer;
XAxiCdma mydma;
#ifndef HETERO_COMPILATION
Status= XAxiCdma_Initialize(&mydma, XPAR_PERIPHERALS_CENTRAL_DMA_DEVICE_ID);
#else
Status= XAxiCdma_Initialize(&mydma,XPAR_GROUP_0_SLAVE_0_LOCAL_DMA_DEVICE_ID);
#endif
if (Status != XST_SUCCESS) {
putnum(0xdeadbeef);
return XST_FAILURE;
}
XAxiCdma_IntrDisable(&mydma, XAXICDMA_XR_IRQ_ALL_MASK);
XTmrCtr_Reset(mytimer,1);
//sending the data **********************************************
/*for (e = 0; e < package->vector_size; e++) {
brama[e] = dataA[e];
bramb[e] = dataB[e]; }
*/
Status = XAxiCdma_Transfer(&mydma, (u32) package->dataA , (u32) BRAMA, package->vector_size *4, NULL, NULL);
Status = XAxiCdma_Transfer(&mydma, (u32) package->dataB , (u32) BRAMB, package->vector_size *4, NULL, NULL);
//computation
// for (e = 0; e < package->vector_size; e++) bramc[e] = brama[e] + bramb[e];
/*
int cmd =1; //1=> means add, 2=> means subtraction
int start =0;
int end = package->vector_size ;
putfslx( cmd, 0, FSL_DEFAULT);
putfslx( end, 0, FSL_DEFAULT);
putfslx( start, 0, FSL_DEFAULT);
getfslx(cmd, 0, FSL_DEFAULT);
*/
putfslx((0 << 30) | (SIZE << 15) | 0, 0, FSL_DEFAULT);
getfslx(e, 0, FSL_DEFAULT);
//sending the data back to dram **********************************************
Status = XAxiCdma_Transfer(&mydma, (u32) BRAMC , (u32) package->dataC, package->vector_size *4, NULL, NULL);
// for (e = 0; e < package->vector_size; e++) dataC[e] = bramc[e];
package->time= XTmrCtr_GetValue(mytimer,1);
return (void *) 0;
}
int main(int argc, char *argv[])
{
xil_printf("\r\n-----Begin Program-----\r\n");
//===============================================================================
//Initilizing Data
//===============================================================================
data package;
package.vector_size = SIZE;
package.dataA = (int *) malloc(sizeof(int) * package.vector_size);
package.dataB = (int *) malloc(sizeof(int) * package.vector_size);
package.dataC = (int *) malloc(sizeof(int) * package.vector_size);
// xil_printf (" %08x , %08x , %08x , \r\n", package.dataA,package.dataB,package.dataC);
assert(package.dataA != NULL);
assert(package.dataB != NULL);
assert(package.dataC != NULL);
int e;
Hint * dataA = package.dataA;
Hint * dataB = package.dataB;
Hint * dataC = package.dataC;
// for (e = 0; e < package.vector_size; e++) xil_printf("%d %d %d\r\n", dataA[e], dataB[e], dataC[e]);
//===============================================================================
//Peripherals instantiation
//===============================================================================
XTmrCtr mytimer;
int Status= XTmrCtr_Initialize(&mytimer, XPAR_PERIPHERALS_AXI_TIMER_0_DEVICE_ID);
if (Status != XST_SUCCESS) {
xil_printf("Timer initialization failed \r\n");
return XST_FAILURE;
}
XTmrCtr_SetResetValue(&mytimer, 0, 0);
XTmrCtr_Start(&mytimer,0);
XTmrCtr_SetResetValue(&mytimer, 1, 0);
XTmrCtr_Start(&mytimer,1);
package.timer= &mytimer;
//===============================================================================
//Creating and joining on thread
//===============================================================================
hthread_t tid;
hthread_attr_t attr;
hthread_attr_init(&attr);
int i;
for ( i=0; i <NUM_AVAILABLE_HETERO_CPUS ; i++)
{
for (e = 0; e < package.vector_size; e++)
{
dataA[e] = rand() %1000;
dataB[e] = rand()%1000;
dataC[e] = 10;
}
XTmrCtr_Reset(&mytimer,0);
thread_create ( &tid, &attr , foo_thread_FUNC_ID , (void * )&package, i+2, 0);
int ret;
if( hthread_join(tid, (void *) &ret))
{
xil_printf("Error joining child thread\r\n");
while(1);
}
if (ret !=XST_SUCCESS){
xil_printf("Thread returned XST_FAILURE\r\n");
while(1);
}
int time= XTmrCtr_GetValue(&mytimer,0);
xil_printf("Total exe_time on Slave %d : %d us\r\n", i, (time)/100 );
xil_printf("Net exe_time of the body of the thread: %d us\r\n", (package.time)/100 );
//===============================================================================
//Check to see if the result were right?
//===============================================================================
for (e = 0; e < 5; e++) xil_printf("%d %d %d\r\n", dataA[e], dataB[e], dataC[e]);
for (e = 0; e < package.vector_size; e++)
{
if (dataC[e]!= dataA[e]+ dataB[e])
{
xil_printf("Error at location %d \r\n", e);
while (1);
}
}
}
xil_printf("FINISH\r\n");
return 0;
}
