void main(){ // Configure the timers e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); // Start the timer (countdown from 0xFFFFFFFF) e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); init(); int i = 0; // wait for the go (which means actors are connected) while(Mailbox.pGo[me.corenum] == 0); timerValue = e_ctimer_get(E_CTIMER_0); Mailbox.pTimer0[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_0); e_ctimer_set(E_CTIMER_1, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); while(i < IN_BUFFER_SIZE) { // action a0 int D0, D1; D0 = port_read(&X); D1 = port_read(&X); // end of a0 // action a1 int d2, d3; d2 = port_read(&X); d3 = port_read(&X); #if 1 port_write(&Y, D0 + d2); i++; port_write(&Y, D0 - d2); i++; port_write(&Y, D1 + d3); i++; port_write(&Y, D1 - d3); i++; // end of a1 #endif #if 0 Mailbox.pOutputBuffer[i] = D0 + d2; i++; Mailbox.pOutputBuffer[i] = D0 - d2; i++; Mailbox.pOutputBuffer[i] = D1 + d3; i++; Mailbox.pOutputBuffer[i] = D1 - d3; i++; #endif } #if 0 *Mailbox.pOutputReady = 10; #endif // Get timer value, find the elapsed time and stop timerValue = e_ctimer_get(E_CTIMER_1); Mailbox.pTimer1[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_1); }
int main(int argc, char** args) { (void) argc; (void) args; e_irq_global_mask(E_TRUE); const u32 w = *(u32*) 0x40; const u32 h = *(u32*) 0x44; f32* b_kh = b; f32* c_jh; // if (a != (const f32*) 0x2000 || b != (const f32*) 0x4000 || c != (const f32*) 0x6000) { // *(UserInterrupt*) 0x24 = UserInterrupt::Error; // return 0; // } e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_set(E_CTIMER_1, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_FPU_INST); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); for (u32 k = 0; k < w; k += 1) { c_jh = c; for (u32 j = 0; j < h; j += 1) { f32 a_jw_k = a[j*w + k]; for (u32 i = 0; i < h;) { if (i + 1 < h) { c_jh[i ] += a_jw_k * b_kh[i ]; c_jh[i + 1] += a_jw_k * b_kh[i + 1]; i += 2; } else { c_jh[i ] += a_jw_k * b_kh[i ]; i += 1; } } c_jh += h; } b_kh += h; } // for (u32 k = 0; k < w; k += 1) { // this order of loops is faster than the others on epiphany // for (u32 j = 0; j < h; j += 1) { // for (u32 i = 0; i < h; i += 1) { // c[j*h + i] += a[j*w + k] * b[k*h + i]; // } // } // } u32 cycles = (u32) e_ctimer_get(E_CTIMER_1); u32 fpops = (u32) e_ctimer_get(E_CTIMER_0); *(u32*) 0x48 = E_CTIMER_MAX - cycles; *(u32*) 0x4c = E_CTIMER_MAX - fpops; *(UserInterrupt*) 0x24 = UserInterrupt::Done; return 0; }
void main(){ // Configure the timers e_ctimer_set(E_CTIMER_0, E_CTIMER_CLK, E_CTIMER_MAX); // Start the timer (countdown from 0xFFFFFFFF) e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); init(); int i = 0; // wait for the go (which means actors are connected) while(Mailbox.pGo[me.corenum] == 0); timerValue = e_ctimer_get(E_CTIMER_0); Mailbox.pTimer0[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_0); e_ctimer_set(E_CTIMER_1, E_CTIMER_CLK, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); while(i < IN_BUFFER_SIZE) { // action a0 int a, b, c, d; a = port_read(&X); b = port_read(&X); c = port_read(&X); d = port_read(&X); #if 1 port_write(&Y, (a + c) >> 8); i++; port_write(&Y, (a - c) >> 8); i++; port_write(&Y, (b + d) >> 8); i++; port_write(&Y, (b - d) >> 8); i++; // end of action a0 #endif #if 0 Mailbox.pOutputBuffer[i] = (a + c) >> 8; i++; Mailbox.pOutputBuffer[i] = (a - c) >> 8; i++; Mailbox.pOutputBuffer[i] = (b + d) >> 8; i++; Mailbox.pOutputBuffer[i] = (b - d) >> 8; i++; #endif } #if 0 *Mailbox.pOutputReady = 12; #endif // Get timer value, find the elapsed time and stop timerValue = e_ctimer_get(E_CTIMER_1); Mailbox.pTimer1[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_1); }
void main() { // Configure the timers e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); // Start the timer (countdown from 0xFFFFFFFF) e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); init(); int i = 0; int a, b; int w0, w1; // Wait until we get the go message from the host while(Mailbox.pGo[me.corenum] == 0); timerValue = e_ctimer_get(E_CTIMER_0); Mailbox.pTimer0[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_0); e_ctimer_set(E_CTIMER_1, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); // Run continuously while(i < (IN_BUFFER_SIZE * 2))//temporary value 128 { w0 = ww0; w1 = ww1; index0 = (index0 + 1) & 3; ww0 = W0[index0]; ww1 = W1[index0]; a = port_read(&X); b = port_read(&X); // For full version we need to change the following line to #ifdef FULL #if 1 port_write(&Y, a * w0); i++; port_write(&Y, a * w1); i++; port_write(&Y, b * w0); i++; port_write(&Y, b * w1); i++; #endif #if 0 // Send the outputs to the host Mailbox.pOutputBuffer[i] = a * w0; i++; Mailbox.pOutputBuffer[i] = a * w1; i++; Mailbox.pOutputBuffer[i] = b * w0; i++; Mailbox.pOutputBuffer[i] = b * w1; i++; #endif } // Get timer value, find the elapsed time and stop timerValue = e_ctimer_get(E_CTIMER_1); Mailbox.pTimer1[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_1); }
/** * Timer1 ISR * This routine is installed with the interrupt Attach function * There will be no signal number attached when invoked * @param signum: not used */ void __attribute__((interrupt)) timer1_trace_isr(int signum) { (void)signum; e_ctimer_set(E_CTIMER_1, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); return; }
/** * Start trace, but wait until all processors on this chip are ready and waiting to start */ int trace_start_wait_all() { e_irq_attach(E_WAND_INT, wand_trace_isr); e_irq_mask(E_WAND_INT, 0); __asm__ __volatile__("wand"); // Set our WAND bit __asm__ __volatile__("idle"); // Idle and wait for an interrupt e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); // Start counting return 0; }
int main(void){ test_t *me = (void *) 0x7000; void *pmem, *src, *dst; pmem = (void *) (e_emem_config.base + 0x01000000); me->eot = 0; me->sram_clocks_read = me->sram_clocks_write = 11223344; me->eram_clocks_read = me->eram_clocks_write = 55667788; me->eot = 1; // Initialize timer e_irq_mask(E_TIMER0_INT, E_TRUE); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); // Measure time for local -> SRAM src = (void *) (Abuf); dst = (void *) e_get_global_address(0, 1, (void *) 0x2000); me->sram_clocks_write = e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_memcopy(dst, src, _BUF_SZ); me->sram_clocks_write -= e_ctimer_get(E_CTIMER_0); me->eot = 2; // Measure time for SRAM -> local src = (void *) e_get_global_address(0, 1, (void *) 0x4000); dst = (void *) (Bbuf); me->sram_clocks_read = e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_memcopy(dst, src, _BUF_SZ); me->sram_clocks_read -= e_ctimer_get(E_CTIMER_0); me->eot = 3; // Measure time for local -> ERAM src = (void *) (Abuf); dst = (void *) (pmem+0x0000); me->eram_clocks_write = e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_memcopy(dst, src, _BUF_SZ); me->eram_clocks_write -= e_ctimer_get(E_CTIMER_0); me->eot = 4; // Measure time for ERAM -> local src = (void *) (pmem+0x0000); dst = (void *) (Bbuf); me->eram_clocks_read = e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_memcopy(dst, src, _BUF_SZ); me->eram_clocks_read -= e_ctimer_get(E_CTIMER_0); me->eot = 5; return EXIT_SUCCESS; }
int main(void) { e_mutex_t *mutex; volatile unsigned *po; unsigned time_p; unsigned time_c; int i; unsigned *box; unsigned *box1; // Define the address of mutex mutex = (int *)0x00004000; // Define the address of counter po = (int *)0x00006000; // Define the mailbox box = (int *)0x00006200; box1 = (int *)0x00006300; // Initialize the counter to 0 *po = 0; // Initialize the mutex in core (0,0) e_mutex_init(0, 0, mutex, MUTEXATTR_NULL); // Start counting e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; time_p = e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); // Wait to get the key e_mutex_lock(0, 0, mutex); // Add 1 to counter po[0] = po[0] + 1; // Release the key e_mutex_unlock(0, 0, mutex); while(po[0] != 16) {}; // Return the value of counter time_c = e_ctimer_get(E_CTIMER_0); *box = time_p - time_c; *box1 = po[0]; return 0; }
int main(void) { e_mutex_t *mutex; volatile unsigned *po; unsigned time_p; unsigned time_c; unsigned clk_hardcode; int i; unsigned *box; unsigned *box1; clk_hardcode = 19118172; mutex = (int *)0x00004000; po = (int *)0x00006000; box = (int *)0x00006200; box1 = (int *)0x00006300; *po = 0; //for (i=0; i<16; i++) // ((unsigned *) 0x6200)[i] = 0xdeadbeef; // Initialize the mutex in core (0,0) e_mutex_init(0, 0, mutex, MUTEXATTR_NULL); // Start counting e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); // Wait to get the key e_mutex_lock(0, 0, mutex); // Add 1 to counter po[0] = po[0] + 1; // Release the key e_mutex_unlock(0, 0, mutex); while(po[0] != 16) {}; // Return the value of counter time_c = e_ctimer_get(E_CTIMER_0); *box = time_p - time_c; *box1 = po[0]; return 0; }
int main () { e_coreid_t coreid; unsigned int row, col, core, trow, tcol, *ec; volatile msg_block_t *msg = (msg_block_t *) BUF_ADDRESS; e_ctimer_set(E_CTIMER_0, 0xffffffff); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); ec = (unsigned int *) 0x4000; *ec = 0; coreid = e_get_coreid(); e_coords_from_coreid(coreid, &row, &col); core = row*e_group_config.group_cols + col; srand(msg->shared_msg[core].seed); msg->shared_msg[core].seed = msg->shared_msg[core].seed + 10; trow = ((core + 1) % E_GROUP_CORES) / e_group_config.group_rows; tcol = (core + 1) % e_group_config.group_cols; ec = e_get_global_address(trow, tcol, ec); e_write(&e_group_config, &coreid, 0, 0, ec, sizeof(e_coreid_t)); /**ec = coreid;*/ msg->shared_msg[core].msg = e_coreid_from_coords(trow, tcol); msg->shared_msg[core].external = *(unsigned int *) 0x4000; /* Sync */ e_wait(E_CTIMER_1, 2000); msg->shared_msg[core].timer = 0xffffffff - e_ctimer_get(E_CTIMER_0); msg->shared_msg[core].coreid = coreid; e_ctimer_stop(E_CTIMER_0); return 0; }
int main(void) { unsigned mesh_reg; unsigned mesh_reg_modify; unsigned time_c, time_p; unsigned time; unsigned tran,k,i,j,h,m,n,q; unsigned *mailbox, *mode; unsigned *commander; unsigned *counter; unsigned *master, *slave, *p; unsigned *row, *col; unsigned *n_row, *n_col; unsigned *neighbour0, *neighbour1, *neighbour2, *neighbour3; row = (unsigned *)0x5000; col = (unsigned *)0x5004; n_row = (unsigned *)0x5008; n_col = (unsigned *)0x500c; master = (unsigned *)0x2000; p =(unsigned *) 0x2000; slave = (unsigned *) e_get_global_address(*row, *col, p); commander = (unsigned *)0x5100; p = (unsigned *) 0x5300; counter = (unsigned *) e_get_global_address(*row, *col, p); mailbox = (unsigned *)0x6000; mode = (unsigned *)0x5400; tran = 2048; // Core number k = (e_group_config.core_row)*e_group_config.group_cols + (e_group_config.core_col); // Broadcast to all the other neighbours p = (unsigned *)0x5100; e_neighbor_id(E_PREV_CORE, E_ROW_WRAP, n_row, n_col); neighbour0 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_NEXT_CORE, E_ROW_WRAP, n_row, n_col); neighbour1 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_PREV_CORE, E_COL_WRAP, n_row, n_col); neighbour2 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_NEXT_CORE, E_COL_WRAP, n_row, n_col); neighbour3 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; // Initialize master and slave for(i=0; i<tran; i++) { master[i] = 0xdeadbee9; slave[i] = 0x00000000; } while(1) { //Clear the mode box mode[0] = 0xdeadbeef; // Clear the start commander commander[0] = 0x00000000; // Wait for the mesh event while(mode[0] == 0xdeadbeef) {}; q = mode[0]; mesh_reg = e_reg_read(E_REG_MESH_CONFIG); mesh_reg_modify = mesh_reg & 0xffffff0f; mesh_reg_modify = mesh_reg_modify |mesh_type[1][q]; e_reg_write(E_REG_MESH_CONFIG, mesh_reg_modify); // Set the ctimer e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; // Waiting for the signal to start transfering while(commander[0] != 0xdeadbeef) {}; // Start the ctimer and select the time type time_p = e_ctimer_start(E_CTIMER_0, E_CTIMER_MESH_0); // Broadcast to all the other neighbours neighbour0[0] = 0xdeadbeef; neighbour1[0] = 0xdeadbeef; neighbour2[0] = 0xdeadbeef; neighbour3[0] = 0xdeadbeef; e_dma_copy(slave, master, 0x2000); // Wait for transfer finishing while(slave[2047] != 0xdeadbee9 ) {}; counter[k] = 1; // Get the time now time_c = e_ctimer_get(E_CTIMER_0); time = time_p - time_c; // Output the result mailbox[q] = time; // Load the original value of E_REG_MESH_CONFIG e_reg_write(E_REG_MESH_CONFIG, mesh_reg); // Check if all the mesh events have been through if(q == 12) { break; } } return 0; }
int main(void) { unsigned time_c, time_p; unsigned time; unsigned i,j,q,h,m,n,k; unsigned *commander; unsigned *counter; unsigned *mailbox; unsigned *n_row, *n_col; unsigned *neighbour0, *neighbour1, *neighbour2, *neighbour3, *p; commander = (unsigned *)0x6100; counter = (unsigned *)0x6300; mailbox = (unsigned *)0x5000; n_row = (unsigned *)0x5100; n_col = (unsigned *)0x5200; p = (unsigned *)0x6100; // Broadcast to all neighbours e_neighbor_id(E_PREV_CORE, E_ROW_WRAP, n_row, n_col); neighbour0 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_NEXT_CORE, E_ROW_WRAP, n_row, n_col); neighbour1 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_PREV_CORE, E_COL_WRAP, n_row, n_col); neighbour2 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_NEXT_CORE, E_COL_WRAP, n_row, n_col); neighbour3 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; // Get core information k = e_group_config.core_row * e_group_config.group_cols + e_group_config.core_col; // Clear the counter of finishing transfering for(i=0; i<(e_group_config.group_rows*e_group_config.group_cols); i++) { counter[i] = 0; } // Initialize the commander and counter for the specific core counter[k] = 1; commander[0] = 0x00000000; // Set the ctimer e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; // Waiting for the signal of starting transfering while(commander[0] != (unsigned)0xdeadbeef) {}; // Broadcast the signal to neighbours neighbour0[0] = 0xdeadbeef; neighbour1[0] = 0xdeadbeef; neighbour2[0] = 0xdeadbeef; neighbour3[0] = 0xdeadbeef; // Start the ctimer and select the time type time_p = e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); while(1) { if((counter[0]&counter[1]&counter[2]&counter[3]&counter[4]&counter[5] &counter[6]&counter[7]&counter[8]&counter[9]&counter[10]&counter[11] &counter[12]&counter[13]&counter[14]&counter[15]) != 0) { time_c = e_ctimer_get(E_CTIMER_0); break; } } time = time_p - time_c; mailbox[0] = time; return 0; }
void main() { // Configure the timers e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); // Start the timer (countdown from 0xFFFFFFFF) e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); int x0, x1, x2, x3, x5; int i = 0; #if 0 int j = 0; #endif // Initialize data structures - mainly target pointers init(); // Wait for the connect actors signal while(*Mailbox.pConnectActors == 0); connect_actors(); // Reset the connect actors signal to inform the host that actors are connected *Mailbox.pConnectActors = 0; // Wait for the trigger from the host while(Mailbox.pGo[me.corenum] == 0); timerValue = e_ctimer_get(E_CTIMER_0); Mailbox.pTimer0[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_0); e_ctimer_set(E_CTIMER_1, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); while(i < IN_BUFFER_SIZE) { // Read x0, x1, x2, x3 x0 = Mailbox.pInBuffer[i]; i++; x1 = Mailbox.pInBuffer[i]; i++; x2 = Mailbox.pInBuffer[i]; i++; x3 = Mailbox.pInBuffer[i]; i++; // Write x0 and read an input and write it directly to the output port_write(&Y, x0); port_write(&Y, Mailbox.pInBuffer[i]); i++; #if 0 Mailbox.pOutputBuffer[j] = x0; j++; Mailbox.pOutputBuffer[j] = Mailbox.pInBuffer[i - 1]; j++; #endif // Read x5 x5 = Mailbox.pInBuffer[i]; i++; // Write x2 and read an input and write it directly to the output port_write(&Y, x2); port_write(&Y, Mailbox.pInBuffer[i]); i++; #if 0 Mailbox.pOutputBuffer[j] = x2; j++; Mailbox.pOutputBuffer[j] = Mailbox.pInBuffer[i - 1]; j++; #endif // write x1 and read an input and write it directly to the output port_write(&Y, x1); port_write(&Y, Mailbox.pInBuffer[i]); i++; #if 0 Mailbox.pOutputBuffer[j] = x1; j++; Mailbox.pOutputBuffer[j] = Mailbox.pInBuffer[i - 1]; j++; #endif // Write x5 and x3 port_write(&Y, x5); port_write(&Y, x3); #if 0 Mailbox.pOutputBuffer[j] = x5; j++; Mailbox.pOutputBuffer[j] = x3; j++; #endif } // Get timer value, find the elapsed time and stop timerValue = e_ctimer_get(E_CTIMER_1); Mailbox.pTimer1[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_1); }
int main(void) { //initialize unsigned time_s, time_e, time; unsigned expect; int *p0, *p1; unsigned ctimer; int i, j; int a; int fault; int row, col; sprintf(outbuf,"\t"); row = e_group_config.core_row; col = e_group_config.core_col; ctimer = (unsigned)e_get_global_address(row,col,(void *)0xf0438); fault = 0x0; //ctimer = 0x849f0438; p0 = (int *)0x5200; *p0 = 0x0; //*p0 = 0x10; //p1 = (int *)0x80a05200; for(i=0;i<4;i++) { for(j=0;j<4;j++) { p1 = e_get_global_address(i,j,(void *)0x5100); //p1 = e_get_global_address(0,0,(void *)0x5200); *p1 = 0x210; a = 0x0; e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); //record the ctimer __asm__ __volatile__("ldr %0, [%1]":"=r"(time_s):"r"(ctimer):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(a):"r"(p1):); __asm__ __volatile__("ldr %0, [%1]":"=r"(time_e):"r"(ctimer):); //time_e = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); time = time_s - time_e; //if(time = (i+j)*) expect = ((abs(row - i) + abs(col - j)) * 3 + 17)*10 + 17; if(time != expect) *p0++; //sprintf(outbuf,"time = %d cycles!", fault); } } /* if(fault == 0) sprintf(outbuf+strlen(outbuf),"test20 emesh_read_latency Passed!"); else sprintf(outbuf+strlen(outbuf),"test20 emesh_read_latency failed!\t\t\tWarnning, failed!"); */ return EXIT_SUCCESS; }
void main(){ e_ctimer_set(E_CTIMER_0, E_CTIMER_CLK, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); init(); // wait for the go (which means actors are connected) while(Mailbox.pGo[me.corenum] == 0); timerValue = e_ctimer_get(E_CTIMER_0); Mailbox.pTimer0[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_0); // Timer functions 1 e_ctimer_set(E_CTIMER_1, E_CTIMER_CLK, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); int j = 0; int signed_counter = 0; // Run until there is no input left while(j < IN_BUFFER_SIZE) { //action read_signed if(clip.count < 0){ //clip.sflag = port_read(&SIGNED); clip.sflag = Mailbox.pSignedBuffer[signed_counter++]; clip.count = 63; } // end of action read_signed else { // action limit int i = port_read(&I); if(i > 255){ #if 0 port_write(&O, 255); j++; #endif #if 1 Mailbox.pOutputBuffer[j] = 255; j++; #endif // j++; } else if(clip.sflag == 0 && i < 0){ #if 0 port_write(&O, 0); j++; #endif #if 1 Mailbox.pOutputBuffer[j] = 0; j++; #endif //j++; } else if(i < -255){ #if 0 port_write(&O, -255); j++; #endif #if 1 Mailbox.pOutputBuffer[j] = -255; j++; #endif //j++; } else{ #if 0 port_write(&O, i); j++; #endif #if 1 Mailbox.pOutputBuffer[j] = i; j++; #endif //j++; } clip.count = clip.count - 1; } } timerValue = e_ctimer_get(E_CTIMER_1); Mailbox.pTimer1[me.corenum] = E_CTIMER_MAX - timerValue; #if 1 *Mailbox.pOutputReady = 1; #endif e_ctimer_stop(E_CTIMER_1); }
int main(void) { unsigned time_c, time_p; unsigned time; unsigned tran,k,i,j,q,h,m,n; unsigned *box; unsigned *n_row, *n_col, *p; unsigned *neighbour_n; unsigned *neighbour_s; unsigned *neighbour_w; unsigned *neighbour_e; unsigned *master; // Define the mailbox master = (unsigned *)0x2000; box = (unsigned *) 0x5000; n_row = (unsigned *)0x6000; n_col = (unsigned *)0x6004; tran = 2048; p =(unsigned *) 0x2000; // Get the neighbour global address e_neighbor_id(E_NEXT_CORE, E_ROW_WRAP, n_row, n_col); neighbour_e = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_PREV_CORE, E_ROW_WRAP, n_row, n_col); neighbour_w = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_NEXT_CORE, E_COL_WRAP, n_row, n_col); neighbour_s = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_PREV_CORE, E_COL_WRAP, n_row, n_col); neighbour_n = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; // Test the writing bandwidth // Initialize master and slave for(i=0; i<tran; i++) { master[i] = 0xdeadbeef; neighbour_e[i] = 0x00000000; neighbour_w[i] = 0x00000000; neighbour_s[i] = 0x00000000; neighbour_n[i] = 0x00000000; } // Set the ctimer e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; // Start the ctimer and select the time type time_p = e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); // Write to all neighbour cores e_dma_copy(neighbour_e, master, 0x2000); e_dma_copy(neighbour_w, master, 0x2000); e_dma_copy(neighbour_s, master, 0x2000); e_dma_copy(neighbour_n, master, 0x2000); // Get the time now time_c = e_ctimer_get(E_CTIMER_0); time = time_p - time_c; // Output the result box[0] = time; // Test the reading bandwidth // Initialize master and slave for(i=0; i<tran; i++) { master[i] = 0x00000000; neighbour_e[i] = 0xdeadbee1; neighbour_w[i] = 0xdeadbee2; neighbour_s[i] = 0xdeadbee3; neighbour_n[i] = 0xdeadbee4; } // Set the ctimer e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; // Start the ctimer and select the time type time_p = e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); // Read from all neighbour cores e_dma_copy(master, neighbour_e, 0x2000); e_dma_copy(master, neighbour_w, 0x2000); e_dma_copy(master, neighbour_s, 0x2000); e_dma_copy(master, neighbour_n, 0x2000); // Get the time now time_c = e_ctimer_get(E_CTIMER_0); time = time_p - time_c; // Output the result box[1] = time; return 0; }
int main(void) { unsigned mesh_reg; unsigned mesh_reg_modify; unsigned time_c, time_p; unsigned time; unsigned time_c1, time_p1; unsigned time1; unsigned i,j,q,m,n,k; unsigned *commander; unsigned *counter; unsigned *mailbox,*mode; unsigned *n_row, *n_col; unsigned *neighbour0, *neighbour1, *neighbour2, *neighbour3, *p; commander = (unsigned *)0x5100; counter = (unsigned *)0x5300; mailbox = (unsigned *)0x6000; mode = (unsigned *)0x5400; n_row = (unsigned *)0x5008; n_col = (unsigned *)0x500c; p = (unsigned *)0x5100; // Broadcast to neighbours e_neighbor_id(E_PREV_CORE, E_ROW_WRAP, n_row, n_col); neighbour0 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_NEXT_CORE, E_ROW_WRAP, n_row, n_col); neighbour1 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_PREV_CORE, E_COL_WRAP, n_row, n_col); neighbour2 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; e_neighbor_id(E_NEXT_CORE, E_COL_WRAP, n_row, n_col); neighbour3 = (unsigned *) e_get_global_address(*n_row, *n_col, p) ; // Get core information k = e_group_config.core_row * e_group_config.group_cols + e_group_config.core_col; while(1) { // Clear the counter of finishing transfering for(m=0; m<(e_group_config.group_rows*e_group_config.group_cols); m++) { counter[m] = 0; } // Initialize the commander and counter counter[k] = 1; //Clear the mode box mode[0] = 0xdeadbeef; // Clear the start commander commander[0] = 0x00000000; // Wait for the mesh event while(mode[0] == 0xdeadbeef) {}; q = mode[0]; mesh_reg = e_reg_read(E_REG_MESH_CONFIG); mesh_reg_modify = mesh_reg & 0xffffff0f; mesh_reg_modify = mesh_reg_modify |mesh_type[1][q]; e_reg_write(E_REG_MESH_CONFIG, mesh_reg_modify); // Set the ctimer e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; // Waiting for the signal to start transfering while(commander[0] != 0xdeadbeef) {}; // Start the ctimer and select the time type time_p = e_ctimer_start(E_CTIMER_0, E_CTIMER_MESH_0); // Broadcast to all the other neighbours neighbour0[0] = 0xdeadbeef; neighbour1[0] = 0xdeadbeef; neighbour2[0] = 0xdeadbeef; neighbour3[0] = 0xdeadbeef; while((counter[0]&counter[1]&counter[2]&counter[3]&counter[4]&counter[5]&counter[6] &counter[7]&counter[8]&counter[9]&counter[10]&counter[11]&counter[12]&counter[13] &counter[14]&counter[15]) == 0) {}; time_c = e_ctimer_get(E_CTIMER_0); time = time_p - time_c; mailbox[(*mode)] = time; // Load the original value to E_REG_MESH_CONFIG system register e_reg_write(E_REG_MESH_CONFIG, mesh_reg); if(mode[0] == 12) { break; } } return 0; }
void main(){ // Configure the timers e_ctimer_set(E_CTIMER_0, E_CTIMER_CLK, E_CTIMER_MAX); // Start the timer (countdown from 0xFFFFFFFF) e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); init(); int j = 0; int consumed_elements = 0; // wait for the go (which means actors are connected) while(Mailbox.pGo[me.corenum] == 0); timerValue = e_ctimer_get(E_CTIMER_0); Mailbox.pTimer0[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_0); e_ctimer_set(E_CTIMER_1, E_CTIMER_CLK, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); while(j < IN_BUFFER_SIZE) { // action #1 if(transpose.rcount < 64){ int row = (transpose.rcount >> 3); int quad = (transpose.rcount >> 2) & 1; int i; if(quad == 0){ for(i = 0; i < 4; i++){ if(input_available(&X)){ switch(consumed_elements){ case 0: transpose.mem[transpose.select][row][0] = port_read(&X); break; case 1: transpose.mem[transpose.select][row][7] = port_read(&X); break; case 2: transpose.mem[transpose.select][row][3] = port_read(&X); break; case 3: transpose.mem[transpose.select][row][4] = port_read(&X); transpose.rcount = transpose.rcount + 4; break; default: break; } // if we consumed 4 elements, get out of for loop if(consumed_elements == 3) i = 4; consumed_elements = (consumed_elements + 1) % 4; } } } else{ for(i = 0; i < 4; i++){ if(input_available(&X)){ switch(consumed_elements){ case 0: transpose.mem[transpose.select][row][1] = port_read(&X); break; case 1: transpose.mem[transpose.select][row][6] = port_read(&X); break; case 2: transpose.mem[transpose.select][row][2] = port_read(&X); break; case 3: transpose.mem[transpose.select][row][5] = port_read(&X); transpose.rcount = transpose.rcount + 4; break; default: break; } // if we consumed 4 elements, get out of for loop if(consumed_elements == 3) i = 4; consumed_elements = (consumed_elements + 1) % 4; } } } } // end of action #1 // action #2 if(transpose.ccount > 0){ int a, b; int col = (64 - transpose.ccount) >> 3; int pair = ((64 - transpose.ccount) >> 1) & 3; int k = transpose.select ^ 1; if(pair == 0){ a = 0; b = 4; } else if(pair == 1){ a = 2; b = 6; } else if(pair == 2){ a = 1; b = 7; } else{ a = 5; b = 3; } #if 1 port_write(&Y, transpose.mem[k][a][col]); j++; port_write(&Y, transpose.mem[k][b][col]); j++; #endif #if 0 // DEBUG Mailbox.pOutputBuffer[j] = transpose.mem[k][a][col]; j++; Mailbox.pOutputBuffer[j] = transpose.mem[k][b][col]; j++; #endif transpose.ccount = transpose.ccount - 2; }
int main(void) { e_coreid_t coreid; unsigned int i; unsigned int num; unsigned int time_p; unsigned int time_c; unsigned int time_compare; unsigned int list[14] = {4, 3, 3, 144953, 68892, 24971, 52908, 96970, 19531, 17676, 10459, 10458, 357432, 36235}; unsigned int index = 0; unsigned *mailbox; float volatile af; float volatile bf; float volatile cf; float volatile df; float volatile ref; unsigned int temp; float volatile in_sin; float volatile in_cos; float volatile in_sqt; float volatile in_ceil; float volatile in_log; float re_f0, re_f1, re_f2, re_f3, re_f4, re_f5; af = 3.5f; bf = 2.8f; cf = 8.0f; df = 3.0f; in_sin = (float) pi; in_sin = in_sin / 6 ; in_cos = (float) pi; in_cos = in_cos / 3 ; in_sqt = 0.25f; in_ceil = 2.5f; in_log = 100.0f; mailbox = (unsigned *)0x6000; mailbox[0] = 0; // Who am I? Query the CoreID from hardware. coreid = e_get_coreid(); sprintf(outbuf, ""); // Get time waste on functions e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; time_p = e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); time_compare = time_p - time_c ; // Addition // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = bf + af ; time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if (!((ref > 6.299f)&&(ref < 6.301f)) ) { sprintf(outbuf, "\n Addition is wrong!\n"); } else { if ( (temp >=(list[0] - 2)) && (temp <=(list[0] + 2)) ) { index++;//sprintf(outbuf , "\nPASS for addition!\n"); } else { sprintf(outbuf , "\nThe clock cycle for addition is %d instead of %d.\n", temp, list[0]); } } // Subtraction // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = af - bf; time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( !((ref > 0.699f)&&(ref < 0.701f))) { sprintf(outbuf+strlen(outbuf), "\n Subtraction is wrong!\n"); } else { if ((temp >= (list[1] - 2)) && (temp <= (list[1] + 2)) ) { index++;//sprintf(outbuf +strlen(outbuf) , "\nPASS for substraction!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for subtraction is %d instead of %d.\n", temp, list[1]); } } // Mul //E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = af * bf; time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if (!((ref > 9.799f)&&(ref < 9.801f))) { sprintf(outbuf+strlen(outbuf), "\n Multiplication is wrong!\n"); } else { if ((temp >=(unsigned) (list[2] -2)) && (temp <=(unsigned) (list[2]+2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for multiplication!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for multiplication is %d instead of %d.\n", temp, list[2]); } } // Div //E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = ( af / bf); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if (!((ref > 1.2499f)&&(ref < 1.2501f))) { sprintf(outbuf+strlen(outbuf), "\n Division is wrong!\n"); } else { if ( (temp > (unsigned) (list[3] * 0.8)) && (temp < (unsigned) (list[3] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for division!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for division is %d instead of %d.\n", temp, list[3]); } } // Mod // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = fmodf(cf,df); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if (!((ref > 1.99f)&&(ref < 2.01f))) { sprintf(outbuf+strlen(outbuf), "\n Mod is wrong!\n"); } else { if ( (temp > (unsigned)(list[4] * 0.8)) && (temp < (unsigned)(list[4] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for mod!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for mod is %d instead of %d.\n", temp, list[4]); } } // Sin // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f0 = sinf(in_sin); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( !((re_f0 > 0.499) && (re_f0 < 0.501)) ) { sprintf(outbuf+strlen(outbuf), "\n Sin is wrong!\n"); } else { if ( (temp > (unsigned)(list[5] * 0.8)) && (temp < (unsigned)(list[5] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for sin!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for sin is %d instead of %d.\n", temp, list[5]); } } // Cos // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f1 = cosf(in_cos); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( !((re_f1 > 0.499) && (re_f1 < 0.501))) { sprintf(outbuf+strlen(outbuf), "\n Cos is wrong!\n"); } else { if ( (temp > (unsigned)(list[6] * 0.8)) && (temp < (unsigned)(list[6] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for cos!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for cos is %d instead of %d.\n", temp, list[6]); } } // Sqrt e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f2 = sqrtf(in_sqt); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( !((re_f2 > 0.499) && (re_f2 < 0.501)) ) { sprintf(outbuf+strlen(outbuf), "\n Sqrt is wrong!\n"); } else { if ( (temp > (list[7] * 0.8)) && (temp < (list[7] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for square root!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for sqrt is %d instead of %d.\n", temp, list[7]); } } // Ceil e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f3 = ceilf(in_ceil); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( !((re_f3 > 2.99) && (re_f3 < 3.01)) ) { sprintf(outbuf+strlen(outbuf), "\n Ceil is wrong!\n"); } else { if ( (temp > (list[8] * 0.8)) && (temp < (list[8] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for ceil!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for ceil is %d instead of %d.\n", temp, list[8]); } } // Floor e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f5 = floorf(in_ceil); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( !((re_f5 > 1.99f) && (re_f5 < 2.01f)) ) { sprintf(outbuf+strlen(outbuf), "\n Floor is wrong!\n"); } else { if ( (temp > (list[9] * 0.8)) && (temp < (list[9] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for floor!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for floor is %d instead of %d.\n", temp, list[9]); } } // Log10 e_ctimer_set(E_CTIMER_1, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_1); re_f4 = log10f(df); time_c = e_ctimer_get(E_CTIMER_1); e_ctimer_stop(E_CTIMER_1); temp = time_p - time_c - time_compare; if ( !((re_f4 > 0.477f) && (re_f4 < 0.478f)) ) { sprintf(outbuf+strlen(outbuf), "\n Log10 is wrong!\n"); } else { if ( (temp > (list[11] * 0.8)) && (temp < (list[11] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for log10!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for log10 is %d instead of %d.\n", temp, list[10]); } } // Ln e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f4 = logf(in_log); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if (!((re_f4 > 4.6f) && (re_f4 < 4.61f)) ) { sprintf(outbuf+strlen(outbuf), "\n Ln is wrong!\n"); } else { if ( (temp > (list[11] * 0.8)) && (temp < (list[11] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for ln!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for ln is %d instead of %d.\n", temp, list[11]); } } // Power e_ctimer_set(E_CTIMER_1, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_1); re_f4 = powf(cf,df); time_c = e_ctimer_get(E_CTIMER_1); e_ctimer_stop(E_CTIMER_1); temp = time_p - time_c - time_compare; if (!( (re_f4 > 511.99f) && (re_f4 < 512.01f) )) { sprintf(outbuf+strlen(outbuf), "\n Power is wrong!\n"); } else { if ( (temp > (list[12] * 0.8)) && (temp < (list[12] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for power!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for power is %d instead of %d.\n", temp, list[12]); } } // Ldexp e_ctimer_set(E_CTIMER_1, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_1); re_f4 = ldexpf(cf,df); time_c = e_ctimer_get(E_CTIMER_1); e_ctimer_stop(E_CTIMER_1); temp = time_p - time_c - time_compare; if ( !((re_f4 > 63.99f) && (re_f4 < 64.01f)) ) { sprintf(outbuf+strlen(outbuf), "\n Ldexp is wrong!\n"); } else { if ( (temp > (list[13] * 0.8)) && (temp < (list[13] * 1.2)) ) { index++;//sprintf(outbuf +strlen(outbuf), "\nPASS for ldexp!\n"); } else { sprintf(outbuf +strlen(outbuf), "\nThe clock cycle for ldexp is %d instead of %d.\n", temp, list[13]); } } mailbox[0] = index; return EXIT_SUCCESS; }
static uint64_t platform_clock(void) { static mach_timebase_info_data_t tb_info = { .numer = 0, .denom = 0, }; uint64_t abs_time, nanosec; abs_time = mach_absolute_time(); if (tb_info.denom == 0) { (void) mach_timebase_info(&tb_info); } nanosec = abs_time; nanosec /= tb_info.denom; nanosec *= tb_info.numer; return nanosec; } #elif defined(HAVE_E_LIB_H) static uint64_t platform_clock(void) { // Assuming 600MHz clock 10^9 / (600 * 10^6) const float factor = 1.6666666666666666666f; static uint64_t clock = 0; uint64_t diff, nanosec; static bool initialized = false; if (!initialized) { e_ctimer_stop(E_CTIMER_0); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); initialized = true; return 0; } /* Clock will drift here */ diff = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); clock += diff; nanosec = (uint64_t) ((float) clock * factor); return nanosec; } #else #error "No timing function" #endif static void platform_print_duration(uint64_t start, uint64_t end) { if (end < start) bench_printf("%" PRIu64, 0xffffffffffffffffUL); else bench_printf("%" PRIu64, end - start); } /* end of platform specific section */ struct item_data { uint64_t start; uint64_t end; };
/** * Starts the clock. */ static int8_t start_clock(void) { e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); return 0; }
void main() { // Configure the timers e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); // Start the timer (countdown from 0xFFFFFFFF) e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); init(); int i = 0; int a, b; int w0, w1; // Wait until we get the go message from the host while(Mailbox.pGo[me.corenum] == 0); timerValue = e_ctimer_get(E_CTIMER_0); Mailbox.pTimer0[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_0); e_ctimer_set(E_CTIMER_1, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); while(i < (IN_BUFFER_SIZE * 2)) { w0 = ww0; w1 = ww1; index0 = (index0 + 1) & 3; ww0 = W0[index0]; ww1 = W1[index0]; a = port_read(&X); b = port_read(&X); #if 1 port_write(&Y, a * w0); i++; port_write(&Y, a * w1); i++; port_write(&Y, b * w0); i++; port_write(&Y, b * w1); i++; #endif #if 0 Mailbox.pOutputBuffer[i] = a * w0; i++; Mailbox.pOutputBuffer[i] = a * w1; i++; Mailbox.pOutputBuffer[i] = b * w0; i++; Mailbox.pOutputBuffer[i] = b * w1; i++; #endif } #if 0 *Mailbox.pOutputReady = 8; #endif // Get timer value, find the elapsed time and stop timerValue = e_ctimer_get(E_CTIMER_1); Mailbox.pTimer1[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_1); }
/** * This function starts the clock counter, tracing can be used after this call */ int trace_start() { e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); return 0; }
int main() { msg_t *m = (msg_t *) 0x4000; uint64_t d64; uint32_t d32; uint16_t d16; uint8_t d8; unsigned int dt; void *da, *dua, *dc; for (unsigned int row = 0; row < E_ROWS; row++) { for (unsigned int col = 0; col < E_COLS; col++) { if (row == 0 && col == 0) continue; unsigned int tcore = row * E_COLS + col; da = e_get_global_address(row, col, (void *) MEM_ALINEADA); dua = e_get_global_address(row, col, (void *) MEM_NO_ALINEADA); dc = e_get_global_address(row, col, (void *) MEM_A_CABALLO); e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d64, da, sizeof(d64)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].t64 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d32, da, sizeof(d32)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].t32 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d16, da, sizeof(d16)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].t16 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d8, da, sizeof(d8)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].t8 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d64, dua, sizeof(d64)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].ua64 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d32, dua, sizeof(d32)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].ua32 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d16, dua, sizeof(d16)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].ua16 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d8, dua, sizeof(d8)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].ua8 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d64, dua, sizeof(d64)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].c64 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d32, dc, sizeof(d32)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].c32 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d16, dc, sizeof(d16)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].c16 = (dt - DUMMY_WAIT) / (double) VECES; e_dma_wait(E_DMA_1); e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); for (int i = 0; i < VECES; i++) e_dma_copy(&d8, dc, sizeof(d8)); e_dma_wait(E_DMA_1); e_wait(E_CTIMER_1, DUMMY_WAIT); e_ctimer_stop(E_CTIMER_0); dt = E_CTIMER_MAX - e_ctimer_get(E_CTIMER_0); m->ticks[tcore].c8 = (dt - DUMMY_WAIT) / (double) VECES; } } m->finalizado = E_TRUE; return 0; }
int main(void) { e_coreid_t coreid; unsigned int i; unsigned int num; unsigned int time_p; unsigned int time_c; unsigned int time_compare; float volatile af; float volatile bf; float volatile cf; float volatile df; float ref; unsigned int temp; float volatile in_sin; float volatile in_cos; float volatile in_sqt; float volatile in_ceil; float volatile in_log; float re_f0, re_f1, re_f2, re_f3, re_f4, re_f5; af = 3.5f; bf = 2.8f; cf = 8.0f; df = 3.0f; in_sin = (float) pi; in_sin = in_sin / 6 ; in_cos = (float) pi; in_cos = in_cos / 3 ; in_sqt = 0.25f; in_ceil = 2.5f; in_log = 100.0f; // Who am I? Query the CoreID from hardware. coreid = e_get_coreid(); sprintf(outbuf, ""); // Get time waste on functions e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); time_compare = time_p - time_c ; // Addition // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = bf + af ; time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if (!((ref > 6.299f)&&(ref < 6.301f))) { sprintf(outbuf, "\n Addition is wrong!\n"); }else { sprintf(outbuf , "\nE_CTIMER0: The clock cycle of addition is %d.\n", temp); } // Subtraction // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = af - bf; time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( !((ref > 0.699f)&&(ref < 0.701f))) { sprintf(outbuf+strlen(outbuf), "\n Subtraction is wrong!\n"); }else { sprintf(outbuf+strlen(outbuf) , "\n E_CTIMER0: The clock cycle of subtraction is %d.\n", temp); } // Mul //E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = af * bf; time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if (!((ref > 9.799f)&&(ref < 9.801f))) { sprintf(outbuf+strlen(outbuf), "\n Multiplication is wrong!\n"); }else { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of multiplication is %d.\n", temp); } // Div //E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = ( af / bf); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if (!((ref > 1.2499f)&&(ref < 1.2501f))) { sprintf(outbuf+strlen(outbuf), "\n Division is wrong!\n"); }else { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of division is %d.\n", temp); } // Mod // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); ref = fmodf(cf,df); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if (!((ref > 1.99f)&&(ref < 2.01f))) { sprintf(outbuf+strlen(outbuf), "\n Mod is wrong!\n"); }else { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of mod is %d.\n", temp); } // Sin // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f0 = sinf(in_sin); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( (re_f0 > 0.499) && (re_f0 < 0.501) ) { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of sin is %d.\n", temp); }else { sprintf(outbuf+strlen(outbuf), "\n Sin is wrong!\n"); } // Cos // E_CTIMER0 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f1 = cosf(in_cos); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( (re_f1 > 0.499) && (re_f1 < 0.501)) { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of cos is %d.\n", temp); }else { sprintf(outbuf+strlen(outbuf), "\n Cos is wrong!\n"); } // Sqrt e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f2 = sqrtf(in_sqt); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( (re_f2 > 0.499) && (re_f2 < 0.501) ) { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of sqrt is %d.\n", temp); }else { sprintf(outbuf+strlen(outbuf), "\n Sqrt is wrong!\n"); } // Ceil e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f3 = ceilf(in_ceil); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( (re_f3 > 2.99) && (re_f3 < 3.01) ) { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of ceil is %d.\n", temp); }else { sprintf(outbuf+strlen(outbuf), "\n Ceil is wrong!\n"); } // Floor e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f5 = floorf(in_ceil); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( (re_f5 > 1.99f) && (re_f5 < 2.01f) ) { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of floor is %d.\n", temp); }else { sprintf(outbuf+strlen(outbuf), "\n Floor is wrong!\n"); } // Log10 e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f4 = log10f(df); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( (re_f4 > 0.477f) && (re_f4 < 0.478f) ) { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of log10 is %d.\n", temp); }else { sprintf(outbuf+strlen(outbuf), "\n Log10 is wrong!\n"); } // Ln e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f4 = logf(in_log); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( (re_f4 > 4.6f) && (re_f4 < 4.61f) ) { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of ln is %d.\n", temp); }else { sprintf(outbuf+strlen(outbuf), "\n Ln is wrong!\n"); } // Power e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f4 = powf(cf,df); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( (re_f4 > 511.99f) && (re_f4 < 512.01f) ) { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of power is %d.\n", temp); }else { sprintf(outbuf+strlen(outbuf), "\n Power is wrong!\n"); } // Ldexp e_ctimer_set(E_CTIMER_0, E_CTIMER_MAX) ; e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); time_p = e_ctimer_get(E_CTIMER_0); re_f4 = ldexpf(cf,df); time_c = e_ctimer_get(E_CTIMER_0); e_ctimer_stop(E_CTIMER_0); temp = time_p - time_c - time_compare; if ( (re_f4 > 63.99f) && (re_f4 < 64.01f) ) { sprintf(outbuf+strlen(outbuf) , "\nE_CTIMER0: The clock cycle of ldexp is %d.\n", temp); }else { sprintf(outbuf+strlen(outbuf), "\n Ldexp is wrong!\n"); } return EXIT_SUCCESS; }
void main(){ // Configure the timers e_ctimer_set(E_CTIMER_0, E_CTIMER_CLK, E_CTIMER_MAX); // Start the timer (countdown from 0xFFFFFFFF) e_ctimer_start(E_CTIMER_0, E_CTIMER_CLK); init(); int i = 0; // wait for the go (which means actors are connected) while(Mailbox.pGo[me.corenum] == 0); timerValue = e_ctimer_get(E_CTIMER_0); Mailbox.pTimer0[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_0); e_ctimer_set(E_CTIMER_1, E_CTIMER_CLK, E_CTIMER_MAX); e_ctimer_start(E_CTIMER_1, E_CTIMER_CLK); while(i < IN_BUFFER_SIZE) { int a, b, c, d, x2, x3, x4, x5, x6h, x6l, x7h, x7l; // action a0 a = port_read(&X); b = port_read(&X); c = port_read(&X); d = port_read(&X); x4 = c; x5 = d; #if 1 port_write(&Y, a); i++; port_write(&Y, b); i++; // end of action a0 #endif #if 0 //DEBUG Mailbox.pOutputBuffer[i] = a; i++; Mailbox.pOutputBuffer[i] = b; i++; #endif // action a1 x2 = port_read(&X); a = port_read(&X); x3 = port_read(&X); b = port_read(&X); int ah = a >> 8; int bh = b >> 8; int al = a & 255; int bl = b & 255; x6h = 181 * (ah + bh); x7h = 181 * (ah - bh); x6l = 181 * (al + bl) + 128; x7l = 181 * (al - bl) + 128; #if 1 port_write(&Y, x2); i++; port_write(&Y, x3); i++; // end of action a1 #endif #if 0 //DEBUG Mailbox.pOutputBuffer[i] = x2; i++; Mailbox.pOutputBuffer[i] = x3; i++; #endif #if 1 // action a2 port_write(&Y, x4); i++; port_write(&Y, x5); i++; port_write(&Y, x6h + (x6l >> 8)); i++; port_write(&Y, x7h + (x7l >> 8)); i++; // end of action a2 #endif #if 0 //DEBUG Mailbox.pOutputBuffer[i] = x4; i++; Mailbox.pOutputBuffer[i] = x5; i++; Mailbox.pOutputBuffer[i] = x6h + (x6l >> 8); i++; Mailbox.pOutputBuffer[i] = x7h + (x7l >> 8); i++; #endif } // Get timer value, find the elapsed time and stop timerValue = e_ctimer_get(E_CTIMER_1); Mailbox.pTimer1[me.corenum] = E_CTIMER_MAX - timerValue; e_ctimer_stop(E_CTIMER_1); }