/* * Prints reports conditionally */ int reporter_condprintstats( ReporterData *stats, MultiHeader *multireport, int force ) { if ( force != 0 ) { stats->info.cntOutofOrder = stats->cntOutofOrder; // assume most of the time out-of-order packets are not // duplicate packets, so conditionally subtract them from the lost packets. stats->info.cntError = stats->cntError; if ( stats->info.cntError > stats->info.cntOutofOrder ) { stats->info.cntError -= stats->info.cntOutofOrder; } stats->info.cntDatagrams = (isUDP(stats) ? stats->PacketID : stats->cntDatagrams); stats->info.TotalLen = stats->TotalLen; stats->info.startTime = 0; stats->info.endTime = TimeDifference( stats->packetTime, stats->startTime ); stats->info.free = 1; reporter_print( stats, TRANSFER_REPORT, force ); if ( isMultipleReport(stats) ) { reporter_handle_multiple_reports( multireport, &stats->info, force ); } } else while ((stats->intervalTime.tv_sec != 0 || stats->intervalTime.tv_usec != 0) && TimeDifference( stats->nextTime, stats->packetTime ) < 0 ) { stats->info.cntOutofOrder = stats->cntOutofOrder - stats->lastOutofOrder; stats->lastOutofOrder = stats->cntOutofOrder; // assume most of the time out-of-order packets are not // duplicate packets, so conditionally subtract them from the lost packets. stats->info.cntError = stats->cntError - stats->lastError; if ( stats->info.cntError > stats->info.cntOutofOrder ) { stats->info.cntError -= stats->info.cntOutofOrder; } stats->lastError = stats->cntError; stats->info.cntDatagrams = (isUDP( stats ) ? stats->PacketID - stats->lastDatagrams : stats->cntDatagrams - stats->lastDatagrams); stats->lastDatagrams = (isUDP( stats ) ? stats->PacketID : stats->cntDatagrams); stats->info.TotalLen = stats->TotalLen - stats->lastTotal; stats->lastTotal = stats->TotalLen; stats->info.startTime = stats->info.endTime; stats->info.endTime = TimeDifference( stats->nextTime, stats->startTime ); TimeAdd( stats->nextTime, stats->intervalTime ); stats->info.free = 0; reporter_print( stats, TRANSFER_REPORT, force ); if ( isMultipleReport(stats) ) { reporter_handle_multiple_reports( multireport, &stats->info, force ); } } return force; }
/* * Pauses a timer. Any further call to GetElapsedTime will * return the total time measured since it was started. The * timer can be further resumed by calling StartTimer. * */ void PauseTimer (Timer* t) { Clock timeNow; GetTimeFunction(timeNow); t->elapsedTime += TimeDifference(timeNow, t->beginTime); t->status = PAUSED; }
/* * Stops a timer. This function is similar to PauseTimer, * with the diference that the timer cannot be resumed. * */ void StopTimer (Timer* t) { Clock timeNow; GetTimeFunction(timeNow); t->elapsedTime += TimeDifference(timeNow, t->beginTime); t->status = STOPPED; }
const TimeDifference RealTimeDifference::operator*( const TimePassageSpeed& passage) const { auto duration_in_nanoseconds = ( std::chrono::duration_cast<std::chrono::nanoseconds>( this->duration_).count()); return TimeDifference(duration_in_nanoseconds * passage); }
void ProtocolTest1() { #if defined(IS_ROUTER) #if PROFILE_TEST_SERVICE == true double executionTime; Uint32 startTime; #endif struct Packet newPacket; Uint16 x[100], i, j; for(i = 0; i < 100; i++) x[i] = i; TSK_sleep(3000); if(gpioDataRegisters.GPBDAT.bit.SWITCH1) { for(i = 0; i < 100; i++) { for(j = 0; j < 50; j++) { InitializePacket(&newPacket, PACKET_ID_UNDEFINED); // Create the data transfer packet newPacket.a.communicationType = COMM_TYPE_UNICAST; newPacket.transmissionInfo.destination = ROOT_ADDRESS; newPacket.b.command = COMMAND_DATA_TRANSFER; newPacket.b.packetSequenceStep = SEQUENCE_DATA_TRANSFER_REQUEST_TRANSFER; // Set the data newPacket.dataBuffer = x; newPacket.dataBufferInfo.dataBufferLength = 100; #if PROFILE_TEST_SERVICE == true startTime = timer0Registers.TIM.all; #endif SendDataPacket(&newPacket); while(globals.statistics.packet.numDataTransfersSucceeded + globals.statistics.packet.numDataTransfersExpired + globals.statistics.packet.numDataTransfersFailed < globals.statistics.packet.numDataTransfersSetup); #if PROFILE_TEST_SERVICE == true executionTime = TimeDifference(startTime, timer0Registers.TIM.all); globals.statistics.profiling.avgTestServiceTime = (globals.statistics.profiling.avgTestServiceTime * globals.statistics.profiling.numTestServiceSamples) + executionTime; globals.statistics.profiling.numTestServiceSamples++; globals.statistics.profiling.avgTestServiceTime /= globals.statistics.profiling.numTestServiceSamples; if(executionTime < globals.statistics.profiling.minTestServiceTime) globals.statistics.profiling.minTestServiceTime = executionTime; else if(executionTime > globals.statistics.profiling.maxTestServiceTime) globals.statistics.profiling.maxTestServiceTime = executionTime; #endif } SetSevenSegmentDisplay(i); } } #endif }
/* * Gets the elapsed time. This function works in any status * of the timer but notice that this function requires some * time and, if the timer is running, the final measure will * include it. * */ double GetElapsedTime(Timer *t) { if (t->status == TIMER_RUNNING) { Clock timeNow; GetTimeFunction(timeNow); return (t->elapsedTime + TimeDifference(timeNow, t->beginTime)); } return t->elapsedTime; }
/*********************************************************************** * * FUNCTION: AdjustTimes * * DESCRIPTION: This routine adjusts the start or end times. It's * called when ever the start or end time are changed. If * the start time has been changed then the end time is adjust * such that the elasped time is maintained. If the end * time has been changed then the start time is adjusted so * that it will not be before the end time. * * PARAMETERS: startTime - pointer to TimeType * endTime - pointer to TimeType * startTimeText - buffer that holds start time string * emdTimeText - buffer that holds end time string * timeFormat - time format * untimed - true if there isn't a time. * * RETURNED: nothing * * REVISION HISTORY: * Name Date Description * ---- ---- ----------- * art 4/4/96 Initial Revision * ***********************************************************************/ static Boolean AdjustTimes (TimePtr startTime, TimePtr endTime, TimePtr timeDiff, ChangingTimeType changingTime) { Boolean changed = false; if (changingTime == changingStartTime) { // The start time has changed so update the end time. endTime->minutes = startTime->minutes + timeDiff->minutes; endTime->hours = startTime->hours + timeDiff->hours; // If there are 60 or more minutes wrap to the next hour if (endTime->minutes >= hoursInMinutes) { endTime->minutes -= hoursInMinutes; endTime->hours++; } // Don't allow the end time past 11:55 PM. //if (endTime->hours >= 24) // { // endTime->minutes = 55; // endTime->hours = 23; // } changed = true; } else if (changingTime == changingEndTime) { // The end time has changed so make sure it's valid // and calculate the new difference. TimeDifference (endTime, startTime, timeDiff); if (endTime->hours < startTime->hours || (endTime->hours == startTime->hours && endTime->minutes < startTime->minutes)) { timeDiff->hours = 0; timeDiff->minutes = 0; endTime->hours = startTime->hours; endTime->minutes = startTime->minutes; changed = true; } } // Don't allow the end time past 11:55 PM. if (endTime->hours >= 24) { endTime->minutes = 55; endTime->hours = 23; changed = true; } return (changed); }
unsigned SystemMicroSecondWait(void *time0,unsigned us) { unsigned start,t1=0,t2,end; Time *time = time0; // system wait if (us >= 10000) { struct timeval start,end; gettimeofday(&start,0); usleep(us - us % 10000); gettimeofday(&end,0); t1 = TimeDifference(start,end); if (t1 > us) return t1; us -= t1; } start = time->Tick(time); end = time->usFuture(time,start,us); while (!time->TimeoutQ(time,start,end)); //while ((t2=time->usElapsed(time,start)) < us); t2=time->usElapsed(time,start); return t1+t2; }
void TimeOneNE10RFFT(int count, int fft_log_size, float signal_value, int signal_type) { OMX_F32* x; /* Source */ OMX_FC32* y; /* Transform */ OMX_F32* z; /* Inverse transform */ OMX_F32* temp; OMX_F32* y_true; /* True FFT */ struct AlignedPtr* x_aligned; struct AlignedPtr* y_aligned; struct AlignedPtr* z_aligned; int n; ne10_result_t status; ne10_fft_r2c_cfg_float32_t fft_fwd_spec; int fft_size; struct timeval start_time; struct timeval end_time; double elapsed_time; struct SnrResult snr_forward; struct SnrResult snr_inverse; fft_size = 1 << fft_log_size; x_aligned = AllocAlignedPointer(32, sizeof(*x) * 4 * fft_size); /* The transformed value is in CCS format and is has fft_size + 2 values */ y_aligned = AllocAlignedPointer(32, sizeof(*y) * (4 * fft_size + 2)); z_aligned = AllocAlignedPointer(32, sizeof(*z) * 4 * fft_size); x = x_aligned->aligned_pointer_; y = y_aligned->aligned_pointer_; z = z_aligned->aligned_pointer_; y_true = (OMX_F32*) malloc(sizeof(*y_true) * (fft_size + 2)); GenerateRealFloatSignal(x, (struct ComplexFloat*) y_true, fft_size, signal_type, signal_value); fft_fwd_spec = ne10_fft_alloc_r2c_float32(fft_size); if (!fft_fwd_spec) { fprintf(stderr, "NE10 RFFT: Cannot initialize FFT structure for order %d\n", fft_log_size); return; } if (do_forward_test) { GetUserTime(&start_time); for (n = 0; n < count; ++n) { ne10_fft_r2c_1d_float32_neon((ne10_fft_cpx_float32_t *) y, x, fft_fwd_spec); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareComplexFloat(&snr_forward, (OMX_FC32*) y, (OMX_FC32*) y_true, fft_size / 2 + 1); PrintResult("Forward NE10 RFFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_); if (verbose >= 255) { printf("FFT Actual:\n"); DumpArrayComplexFloat("y", fft_size / 2 + 1, y); printf("FFT Expected:\n"); DumpArrayComplexFloat("true", fft_size / 2 + 1, (OMX_FC32*) y_true); } } if (do_inverse_test) { // Ne10 FFTs destroy the input. GetUserTime(&start_time); for (n = 0; n < count; ++n) { //memcpy(y, y_true, (fft_size >> 1) * sizeof(*y)); // The inverse appears not to be working. ne10_fft_c2r_1d_float32_neon(z, (ne10_fft_cpx_float32_t *) y_true, fft_fwd_spec); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareFloat(&snr_inverse, (OMX_F32*) z, (OMX_F32*) x, fft_size); PrintResult("Inverse NE10 RFFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_); if (verbose >= 255) { printf("IFFT Actual:\n"); DumpArrayFloat("z", fft_size, z); printf("IFFT Expected:\n"); DumpArrayFloat("x", fft_size, x); } } ne10_fft_destroy_r2c_float32(fft_fwd_spec); FreeAlignedPointer(x_aligned); FreeAlignedPointer(y_aligned); FreeAlignedPointer(z_aligned); }
/* * Prints reports conditionally */ int reporter_condprintstats( ReporterData *stats, MultiHeader *multireport, int force ) { if ( force ) { #ifdef HAVE_STRUCT_TCP_INFO_TCPI_TOTAL_RETRANS gettcpistats(stats); #endif stats->info.cntOutofOrder = stats->cntOutofOrder; // assume most of the time out-of-order packets are not // duplicate packets, so conditionally subtract them from the lost packets. stats->info.cntError = stats->cntError; if ( stats->info.cntError > stats->info.cntOutofOrder ) { stats->info.cntError -= stats->info.cntOutofOrder; } stats->info.cntDatagrams = ((stats->info.mUDP == kMode_Server) ? stats->PacketID : stats->cntDatagrams); stats->info.TotalLen = stats->TotalLen; stats->info.startTime = 0; stats->info.endTime = TimeDifference( stats->packetTime, stats->startTime ); stats->info.transit.minTransit = stats->info.transit.totminTransit; stats->info.transit.maxTransit = stats->info.transit.totmaxTransit; stats->info.transit.cntTransit = stats->info.transit.totcntTransit; stats->info.transit.sumTransit = stats->info.transit.totsumTransit; stats->info.transit.meanTransit = stats->info.transit.totmeanTransit; stats->info.transit.m2Transit = stats->info.transit.totm2Transit; stats->info.transit.vdTransit = stats->info.transit.totvdTransit; if (stats->info.mTCP == kMode_Client) { stats->info.tcp.write.WriteErr = stats->info.tcp.write.totWriteErr; stats->info.tcp.write.WriteCnt = stats->info.tcp.write.totWriteCnt; stats->info.tcp.write.TCPretry = stats->info.tcp.write.totTCPretry; } if (stats->info.mTCP == kMode_Server) { int ix; stats->info.tcp.read.cntRead = stats->info.tcp.read.totcntRead; for (ix = 0; ix < 8; ix++) { stats->info.tcp.read.bins[ix] = stats->info.tcp.read.totbins[ix]; } } if (stats->info.endTime > 0) { stats->info.IPGcnt = (int) (stats->cntDatagrams / stats->info.endTime); } else { stats->info.IPGcnt = 0; } stats->info.IPGsum = 1; stats->info.free = 1; reporter_print( stats, TRANSFER_REPORT, force ); if ( isMultipleReport(stats) ) { reporter_handle_multiple_reports( multireport, &stats->info, force ); } } else while ((stats->intervalTime.tv_sec != 0 || stats->intervalTime.tv_usec != 0) && TimeDifference( stats->nextTime, stats->packetTime ) < 0 ) { #ifdef HAVE_STRUCT_TCP_INFO_TCPI_TOTAL_RETRANS gettcpistats(stats); #endif stats->info.cntOutofOrder = stats->cntOutofOrder - stats->lastOutofOrder; stats->lastOutofOrder = stats->cntOutofOrder; // assume most of the time out-of-order packets are not // duplicate packets, so conditionally subtract them from the lost packets. stats->info.cntError = stats->cntError - stats->lastError; if ( stats->info.cntError > stats->info.cntOutofOrder ) { stats->info.cntError -= stats->info.cntOutofOrder; } stats->lastError = stats->cntError; stats->info.cntDatagrams = ((stats->info.mUDP == kMode_Server) ? stats->PacketID - stats->lastDatagrams : stats->cntDatagrams - stats->lastDatagrams); stats->lastDatagrams = ((stats->info.mUDP == kMode_Server) ? stats->PacketID : stats->cntDatagrams); stats->info.TotalLen = stats->TotalLen - stats->lastTotal; stats->lastTotal = stats->TotalLen; stats->info.startTime = stats->info.endTime; stats->info.endTime = TimeDifference( stats->nextTime, stats->startTime ); TimeAdd( stats->nextTime, stats->intervalTime ); stats->info.free = 0; reporter_print( stats, TRANSFER_REPORT, force ); if ( isMultipleReport(stats) ) { reporter_handle_multiple_reports( multireport, &stats->info, force ); } // Reset stats used by SUM now that the SUM has been reported if (stats->info.mEnhanced) { if (stats->info.mUDP) { stats->info.IPGcnt = 0; stats->info.IPGsum = 0; } else if (stats->info.mTCP == (char)kMode_Client) { stats->info.tcp.write.WriteCnt = 0; stats->info.tcp.write.WriteErr = 0; } else if (stats->info.mTCP == (char)kMode_Server) { int ix; stats->info.tcp.read.cntRead = 0; for (ix = 0; ix < 8; ix++) { stats->info.tcp.read.bins[ix] = 0; } } } } return force; }
/* * Updates connection stats */ int reporter_handle_packet( ReportHeader *reporthdr ) { ReportStruct *packet = &reporthdr->data[reporthdr->reporterindex]; ReporterData *data = &reporthdr->report; Transfer_Info *stats = &reporthdr->report.info; int finished = 0; double usec_transit; data->packetTime = packet->packetTime; stats->socket = packet->socket; if ( packet->packetID < 0 ) { finished = 1; if ( reporthdr->report.mThreadMode != kMode_Client ) { data->TotalLen += packet->packetLen; } } else { if (!packet->emptyreport) { // update fields common to TCP and UDP, client and server data->TotalLen += packet->packetLen; // update fields common to UDP client and server if ( isUDP( data ) ) { data->cntDatagrams++; stats->IPGsum += TimeDifference(data->packetTime, data->IPGstart ); stats->IPGcnt++; data->IPGstart = data->packetTime; // Finally, update UDP server fields if (stats->mUDP == kMode_Server) { //subsequent packets double transit; double deltaTransit; transit = TimeDifference( packet->packetTime, packet->sentTime ); // packet loss occured if the datagram numbers aren't sequential if ( packet->packetID != data->PacketID + 1 ) { if (packet->packetID < data->PacketID + 1 ) { data->cntOutofOrder++; } else { data->cntError += packet->packetID - data->PacketID - 1; } } // never decrease datagramID (e.g. if we get an out-of-order packet) if ( packet->packetID > data->PacketID ) { data->PacketID = packet->packetID; } if (stats->transit.totcntTransit == 0) { // Very first packet stats->transit.minTransit = transit; stats->transit.maxTransit = transit; stats->transit.sumTransit = transit; stats->transit.cntTransit = 1; stats->transit.totminTransit = transit; stats->transit.totmaxTransit = transit; stats->transit.totsumTransit = transit; stats->transit.totcntTransit = 1; // For variance, working units is microseconds usec_transit = transit * 1e6; stats->transit.vdTransit = usec_transit; stats->transit.meanTransit = usec_transit; stats->transit.m2Transit = usec_transit * usec_transit; stats->transit.totvdTransit = usec_transit; stats->transit.totmeanTransit = usec_transit; stats->transit.totm2Transit = usec_transit * usec_transit; } else { // from RFC 1889, Real Time Protocol (RTP) // J = J + ( | D(i-1,i) | - J ) / // Compute jitter deltaTransit = transit - stats->transit.lastTransit; if ( deltaTransit < 0.0 ) { deltaTransit = -deltaTransit; } stats->jitter += (deltaTransit - stats->jitter) / (16.0); // Compute end/end delay stats stats->transit.sumTransit += transit; stats->transit.cntTransit++; stats->transit.totsumTransit += transit; stats->transit.totcntTransit++; // mean min max tests if (transit < stats->transit.minTransit) { stats->transit.minTransit=transit; } if (transit < stats->transit.totminTransit) { stats->transit.totminTransit=transit; } if (transit > stats->transit.maxTransit) { stats->transit.maxTransit=transit; } if (transit > stats->transit.totmaxTransit) { stats->transit.totmaxTransit=transit; } // For variance, working units is microseconds // variance interval usec_transit = transit * 1e6; stats->transit.vdTransit = usec_transit - stats->transit.meanTransit; stats->transit.meanTransit = stats->transit.meanTransit + (stats->transit.vdTransit / stats->transit.cntTransit); stats->transit.m2Transit = stats->transit.m2Transit + (stats->transit.vdTransit * (usec_transit - stats->transit.meanTransit)); // variance total stats->transit.totvdTransit = usec_transit - stats->transit.totmeanTransit; stats->transit.totmeanTransit = stats->transit.totmeanTransit + (stats->transit.totvdTransit / stats->transit.totcntTransit); stats->transit.totm2Transit = stats->transit.totm2Transit + (stats->transit.totvdTransit * (usec_transit - stats->transit.totmeanTransit)); } stats->transit.lastTransit = transit; } } else if (reporthdr->report.mThreadMode == kMode_Server && (packet->packetLen > 0)) { int bin; // mean min max tests stats->tcp.read.cntRead++; stats->tcp.read.totcntRead++; bin = (int)floor((packet->packetLen -1)/stats->tcp.read.binsize); stats->tcp.read.bins[bin]++; stats->tcp.read.totbins[bin]++; } else if (reporthdr->report.mThreadMode == kMode_Client) { if (packet->errwrite) { stats->tcp.write.WriteErr++; stats->tcp.write.totWriteErr++; } else { stats->tcp.write.WriteCnt++; stats->tcp.write.totWriteCnt++; } } } else if ((stats->mUDP == kMode_Server) && \ (stats->transit.cntTransit == 0)) { // This is the case when empty reports // cross the report interval boundary // Hence, set the per interval min to infinity // and the per interval max and sum to zero stats->transit.minTransit = FLT_MAX; stats->transit.maxTransit = FLT_MIN; stats->transit.sumTransit = 0; stats->transit.vdTransit = 0; stats->transit.meanTransit = 0; stats->transit.m2Transit = 0; } } // Print a report if appropriate return reporter_condprintstats( &reporthdr->report, reporthdr->multireport, finished ); }
void TimeOnePfRFFT(int count, int fft_log_size, float signal_value, int signal_type) { struct AlignedPtr* x_aligned; struct AlignedPtr* y_aligned; struct AlignedPtr* z_aligned; struct AlignedPtr* y_tmp_aligned; float* x; struct ComplexFloat* y; OMX_F32* z; float* y_true; float* y_tmp; int n; int fft_size; struct timeval start_time; struct timeval end_time; double elapsed_time; PFFFT_Setup *s; struct SnrResult snr_forward; struct SnrResult snr_inverse; fft_size = 1 << fft_log_size; x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size); y_aligned = AllocAlignedPointer(32, sizeof(*y) * (fft_size + 2)); z_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size); y_tmp_aligned = AllocAlignedPointer(32, sizeof(*y_tmp) * (fft_size + 2)); y_true = (float*) malloc(sizeof(*y_true) * 2 * fft_size); x = x_aligned->aligned_pointer_; y = y_aligned->aligned_pointer_; z = z_aligned->aligned_pointer_; y_tmp = y_tmp_aligned->aligned_pointer_; s = pffft_new_setup(fft_size, PFFFT_REAL); if (!s) { fprintf(stderr, "TimeOnePfRFFT: Could not initialize structure for order %d\n", fft_log_size); } GenerateRealFloatSignal(x, (struct ComplexFloat*) y_true, fft_size, signal_type, signal_value); if (do_forward_test) { GetUserTime(&start_time); for (n = 0; n < count; ++n) { pffft_transform_ordered(s, (float*)x, (float*)y, NULL, PFFFT_FORWARD); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); /* * Arrange the output of the FFT to match the expected output. */ y[fft_size / 2].Re = y[0].Im; y[fft_size / 2].Im = 0; y[0].Im = 0; CompareComplexFloat(&snr_forward, (OMX_FC32*) y, (OMX_FC32*) y_true, fft_size / 2 + 1); PrintResult("Forward PFFFT RFFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_); if (verbose >= 255) { printf("FFT Actual:\n"); DumpArrayComplexFloat("y", fft_size / 2 + 1, (OMX_FC32*) y); printf("FFT Expected:\n"); DumpArrayComplexFloat("true", fft_size / 2 + 1, (OMX_FC32*) y_true); } } if (do_inverse_test) { float scale = 1.0 / fft_size; /* Copy y_true to true, but arrange the values according to what rdft wants. */ memcpy(y_tmp, y_true, sizeof(y_tmp[0]) * fft_size); y_tmp[1] = y_true[fft_size / 2]; GetUserTime(&start_time); for (n = 0; n < count; ++n) { int m; pffft_transform_ordered(s, (float*)y_tmp, (float*)z, NULL, PFFFT_BACKWARD); /* * Need to include cost of scaling the inverse */ ScaleVector(z, fft_size, fft_size); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareFloat(&snr_inverse, (OMX_F32*) z, (OMX_F32*) x, fft_size); PrintResult("Inverse PFFFT RFFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_); if (verbose >= 255) { printf("IFFT Actual:\n"); DumpArrayFloat("z", fft_size, z); printf("IFFT Expected:\n"); DumpArrayFloat("x", fft_size, x); } } FreeAlignedPointer(x_aligned); FreeAlignedPointer(y_aligned); FreeAlignedPointer(z_aligned); FreeAlignedPointer(y_tmp_aligned); pffft_destroy_setup(s); free(y_true); }
void MPITest() { int rank, numNodes; Uint16 sendBuf[1], *receiveBuf; Uint16 i, j; MPI_Status status; Uint32 startTime; double elapsedTime; SEM_pend(&TestServiceSem,SYS_FOREVER); // Generate the x data for(i = 0; i < 14; i++) { for(j = 0; j < 25; j++) xglobal[i * 50 + j] = (j / 4); for(j = 0; j < 25; j++) xglobal[i * 50 + j + 25] = 6 - (j / 4); } // Generate the y data for(i = 0; i < 28; i++) { for(j = 0; j < 25; j++) yglobal[i * 25 + j] = j / 2; } // Initialize MPI MPI_Init(NULL,NULL); MPI_Comm_rank(MPI_COMM_WORLD,&rank); globals.processing.sevenSegmentUpperDigit = SEVENSEG_1DASH; // Distribute the number of nodes to use if(rank == 0) { numNodes = (gpioDataRegisters.GPBDAT.bit.SWITCH1 << 3) + (gpioDataRegisters.GPBDAT.bit.SWITCH2 << 2) + (gpioDataRegisters.GPADAT.bit.SWITCH3 << 1) + (gpioDataRegisters.GPADAT.bit.SWITCH4); sendBuf[0] = numNodes; for(i = 1; i <= 6; i++) MPI_Send(sendBuf,1,MPI_SHORT,i,0,MPI_COMM_WORLD); } else { MPI_Recv((void**)(&receiveBuf),1,MPI_SHORT,0,0,MPI_COMM_WORLD,&status); numNodes = receiveBuf[0]; MemFree(receiveBuf); } MPI_Barrier(MPI_COMM_WORLD); // If this node is participating in the convolution if(rank < numNodes) { globals.processing.sevenSegmentUpperDigit = SEVENSEG_2DASH; startTime = timer0Registers.TIM.all; Convolution(xglobal,yglobal,100,100,resultglobal,numNodes); elapsedTime = TimeDifference(startTime, timer0Registers.TIM.all); // Finalize MPI if(rank == 0) { globals.processing.sevenSegmentLowerDigit = SEVENSEG_FINAL; globals.processing.sevenSegmentUpperDigit = SEVENSEG_FINAL; } else globals.processing.sevenSegmentUpperDigit = SEVENSEG_3DASH; } else { globals.processing.sevenSegmentUpperDigit = SEVENSEG_FINAL; } SEM_pend(&TestServiceSem,SYS_FOREVER); }
void ProtocolTest3() { #if PROFILE_TEST_SERVICE == true double executionTime; Uint32 startTime; #endif struct Packet newPacket; Uns interruptStatus; Uint16 x[100], i, j, destination; double executionTime = 0; double avgTime[9] = {0,0,0,0,0,0,0,0,0}; double minTime[9] = {DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX}; double maxTime[9] = {DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN}; Uint32 startTime = 0; Uint32 numSamples; SEM_pend(&TestServiceSem,SYS_FOREVER); for(i = 0; i < 100; i++) x[i] = i; if(globals.protocol.address == 1) { globals.processing.sevenSegmentUpperDigit = SEVENSEG_1DASH; destination = (gpioDataRegisters.GPBDAT.bit.SWITCH1 << 3) + (gpioDataRegisters.GPBDAT.bit.SWITCH2 << 2) + (gpioDataRegisters.GPADAT.bit.SWITCH3 << 1) + (gpioDataRegisters.GPADAT.bit.SWITCH4); interruptStatus = HWI_disable(); numSamples = 0; for(j = 0; j < 100; j++) { startTime = timer0Registers.TIM.all; GenerateRoutingPath(globals.protocol.address, 1, &newPacket); executionTime = TimeDifference(startTime, timer0Registers.TIM.all); avgTime[1] = (avgTime[1] * numSamples) + executionTime; numSamples++; avgTime[1] /= numSamples; if(executionTime < minTime[1]) minTime[1] = executionTime; else if(executionTime > maxTime[1]) maxTime[1] = executionTime; } for(i = 3; i <= 8; i++) { numSamples = 0; for(j = 0; j < 100; j++) { startTime = timer0Registers.TIM.all; GenerateRoutingPath(globals.protocol.address, i, &newPacket); executionTime = TimeDifference(startTime, timer0Registers.TIM.all); avgTime[i] = (avgTime[i] * numSamples) + executionTime; numSamples++; avgTime[i] /= numSamples; if(executionTime < minTime[i]) minTime[i] = executionTime; else if(executionTime > maxTime[i]) maxTime[i] = executionTime; } } HWI_restore(interruptStatus); asm(" NOP"); for(i = 0; i < 100; i++) { for(j = 0; j < 50; j++) { InitializePacket(&newPacket, PACKET_ID_UNDEFINED); // Create the data transfer packet newPacket.a.communicationType = COMM_TYPE_UNICAST; newPacket.transmissionInfo.destination = 7; newPacket.b.command = COMMAND_DATA_TRANSFER; newPacket.b.packetSequenceStep = SEQUENCE_DATA_TRANSFER_REQUEST_TRANSFER; // Set the data newPacket.dataBuffer = x; newPacket.dataBufferInfo.dataBufferLength = 10; SendDataPacket(&newPacket); InitializePacket(&newPacket, PACKET_ID_UNDEFINED); // Create the data transfer packet newPacket.a.communicationType = COMM_TYPE_UNICAST; newPacket.transmissionInfo.destination = 8; newPacket.b.command = COMMAND_DATA_TRANSFER; newPacket.b.packetSequenceStep = SEQUENCE_DATA_TRANSFER_REQUEST_TRANSFER; // Set the data newPacket.dataBuffer = x; newPacket.dataBufferInfo.dataBufferLength = 10; SendDataPacket(&newPacket); while(globals.statistics.packet.numDataTransfersSucceeded + globals.statistics.packet.numDataTransfersExpired + globals.statistics.packet.numDataTransfersFailed < globals.statistics.packet.numDataTransfersSetup); } if(globals.processing.sevenSegmentUpperDigit == SEVENSEG_2DASH) globals.processing.sevenSegmentUpperDigit = SEVENSEG_1DASH; else globals.processing.sevenSegmentUpperDigit = SEVENSEG_2DASH; } globals.processing.sevenSegmentUpperDigit = SEVENSEG_3DASH; } }
void TimeOnePfFFT(int count, int fft_log_size, float signal_value, int signal_type) { struct AlignedPtr* x_aligned; struct AlignedPtr* y_aligned; struct AlignedPtr* z_aligned; struct AlignedPtr* y_true_aligned; struct ComplexFloat* x; struct ComplexFloat* y; OMX_FC32* z; struct ComplexFloat* y_true; int n; int fft_size; struct timeval start_time; struct timeval end_time; double elapsed_time; PFFFT_Setup *s; struct SnrResult snr_forward; struct SnrResult snr_inverse; fft_size = 1 << fft_log_size; x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size); y_aligned = AllocAlignedPointer(32, sizeof(*y) * (fft_size + 2)); z_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size); y_true_aligned = AllocAlignedPointer(32, sizeof(*y_true) * fft_size); x = x_aligned->aligned_pointer_; y = y_aligned->aligned_pointer_; z = z_aligned->aligned_pointer_; y_true = y_true_aligned->aligned_pointer_; s = pffft_new_setup(fft_size, PFFFT_COMPLEX); if (!s) { fprintf(stderr, "TimeOnePfFFT: Could not initialize structure for order %d\n", fft_log_size); } GenerateTestSignalAndFFT(x, y_true, fft_size, signal_type, signal_value, 0); if (do_forward_test) { GetUserTime(&start_time); for (n = 0; n < count; ++n) { pffft_transform_ordered(s, (float*)x, (float*)y, NULL, PFFFT_FORWARD); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareComplexFloat(&snr_forward, (OMX_FC32*) y, (OMX_FC32*) y_true, fft_size); PrintResult("Forward PFFFT FFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_); if (verbose >= 255) { printf("FFT Actual:\n"); DumpArrayComplexFloat("y", fft_size, (OMX_FC32*) y); printf("FFT Expected:\n"); DumpArrayComplexFloat("true", fft_size, (OMX_FC32*) y_true); } } if (do_inverse_test) { float scale = 1.0 / fft_size; memcpy(y, y_true, sizeof(*y) * (fft_size + 2)); GetUserTime(&start_time); for (n = 0; n < count; ++n) { int m; pffft_transform_ordered(s, (float*)y_true, (float*)z, NULL, PFFFT_BACKWARD); /* * Need to include cost of scaling the inverse */ ScaleVector((OMX_F32*) z, 2 * fft_size, fft_size); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareComplexFloat(&snr_inverse, (OMX_FC32*) z, (OMX_FC32*) x, fft_size); PrintResult("Inverse PFFFT FFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_); if (verbose >= 255) { printf("IFFT Actual:\n"); DumpArrayComplexFloat("z", fft_size, z); printf("IFFT Expected:\n"); DumpArrayComplexFloat("x", fft_size, (OMX_FC32*) x); } } FreeAlignedPointer(x_aligned); FreeAlignedPointer(y_aligned); FreeAlignedPointer(z_aligned); FreeAlignedPointer(y_true_aligned); pffft_destroy_setup(s); }
/* * Updates connection stats */ int reporter_handle_packet( ReportHeader *reporthdr ) { ReportStruct *packet = &reporthdr->data[reporthdr->reporterindex]; ReporterData *data = &reporthdr->report; Transfer_Info *stats = &reporthdr->report.info; int finished = 0; data->cntDatagrams++; // If this is the last packet set the endTime if ( packet->packetID < 0 ) { data->packetTime = packet->packetTime; finished = 1; if ( reporthdr->report.mThreadMode != kMode_Client ) { data->TotalLen += packet->packetLen; } } else { // update recieved amount and time data->packetTime = packet->packetTime; reporter_condprintstats( &reporthdr->report, reporthdr->multireport, finished ); data->TotalLen += packet->packetLen; if ( packet->packetID != 0 ) { // UDP packet double transit = 0.0; double deltaTransit; // from RFC 1889, Real Time Protocol (RTP) // J = J + ( | D(i-1,i) | - J ) / 16 transit = TimeDifference( packet->packetTime, packet->sentTime ); if ( data->lastTransit != 0.0 ) { deltaTransit = transit - data->lastTransit; if ( deltaTransit < 0.0 ) { deltaTransit = -deltaTransit; } stats->jitter += (deltaTransit - stats->jitter) / (16.0); stats->delay += transit*1000; stats->delay_total += transit*1000; } data->lastTransit = transit; // packet loss occured if the datagram numbers aren't sequential if ( packet->packetID != data->PacketID + 1 ) { if ( packet->packetID < data->PacketID + 1 ) { data->cntOutofOrder++; if (reporthdr->report.mThreadMode != kMode_Client) { struct out_of_order_packet *oop; if (!(oop = (struct out_of_order_packet *) malloc(sizeof(struct out_of_order_packet)))) { fprintf(stderr, "Out of memory"); exit(1); } oop->packetID = packet->packetID; #ifndef WIN32 //printf("Packet %d out of order\n", packet->packetID); LIST_INSERT_HEAD(&(data->out_of_order_packets), oop, list); #endif } } else { data->cntError += packet->packetID - data->PacketID - 1; if (reporthdr->report.mThreadMode != kMode_Client) { struct lost_packet_interval *lpi; if (!(lpi = (struct lost_packet_interval *) malloc(sizeof(struct lost_packet_interval)))) { fprintf(stderr, "Out of memory"); exit(1); } lpi->from = (data->PacketID + 1); lpi->to = (packet->packetID - 1); #ifndef WIN32 LIST_INSERT_HEAD(&data->lost_packets, lpi, list); /* printf("Packet %d revealed a loss gap from %d, " "total loss %d\n", packet->packetID, data->PacketID, data->cntError); */ #endif } } } // never decrease datagramID (e.g. if we get an out-of-order packet) if ( packet->packetID > data->PacketID ) { data->PacketID = packet->packetID; } } } // Print a report if appropriate return reporter_condprintstats( &reporthdr->report, reporthdr->multireport, finished ); }
void TimeOneFloatRFFT(int count, int fft_log_size, float signal_value, int signal_type) { OMX_F32* x; /* Source */ OMX_F32* y; /* Transform */ OMX_F32* z; /* Inverse transform */ OMX_F32* y_true; /* True FFT */ struct AlignedPtr* x_aligned; struct AlignedPtr* y_aligned; struct AlignedPtr* z_aligned; struct AlignedPtr* y_true_aligned; OMX_INT n, fft_spec_buffer_size; OMXResult status; OMXFFTSpec_R_F32 * fft_fwd_spec = NULL; OMXFFTSpec_R_F32 * fft_inv_spec = NULL; int fft_size; struct timeval start_time; struct timeval end_time; double elapsed_time; struct SnrResult snr_forward; struct SnrResult snr_inverse; fft_size = 1 << fft_log_size; x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size); /* The transformed value is in CCS format and is has fft_size + 2 values */ y_aligned = AllocAlignedPointer(32, sizeof(*y) * (fft_size + 2)); z_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size); y_true_aligned = AllocAlignedPointer(32, sizeof(*z) * (fft_size + 2)); x = x_aligned->aligned_pointer_; y = y_aligned->aligned_pointer_; z = z_aligned->aligned_pointer_; y_true = y_true_aligned->aligned_pointer_; GenerateRealFloatSignal(x, (OMX_FC32*) y_true, fft_size, signal_type, signal_value); status = omxSP_FFTGetBufSize_R_F32(fft_log_size, &fft_spec_buffer_size); fft_fwd_spec = (OMXFFTSpec_R_F32*) malloc(fft_spec_buffer_size); fft_inv_spec = (OMXFFTSpec_R_F32*) malloc(fft_spec_buffer_size); status = omxSP_FFTInit_R_F32(fft_fwd_spec, fft_log_size); status = omxSP_FFTInit_R_F32(fft_inv_spec, fft_log_size); if (do_forward_test) { GetUserTime(&start_time); for (n = 0; n < count; ++n) { FORWARD_FLOAT_RFFT(x, y, fft_fwd_spec); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareComplexFloat(&snr_forward, (OMX_FC32*) y, (OMX_FC32*) y_true, fft_size / 2 + 1); PrintResult("Forward Float RFFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_); } if (do_inverse_test) { GetUserTime(&start_time); for (n = 0; n < count; ++n) { INVERSE_FLOAT_RFFT(y_true, z, fft_inv_spec); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareFloat(&snr_inverse, (OMX_F32*) z, (OMX_F32*) x, fft_size); PrintResult("Inverse Float RFFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_); } FreeAlignedPointer(x_aligned); FreeAlignedPointer(y_aligned); FreeAlignedPointer(z_aligned); free(fft_fwd_spec); free(fft_inv_spec); }
void InitializeSystem(void* parameter, Uint16 followUpItemIndex) { Uns interruptStatus; Uint16 i, j; double executionTime = 0; double genAvgTime = 0; double genMinTime = DBL_MAX; double genMaxTime = DBL_MIN; double avgTime[9] = {0,0,0,0,0,0,0,0,0}; double minTime[9] = {DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX,DBL_MAX}; double maxTime[9] = {DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN,DBL_MIN}; Uint32 startTime = 0; Uint32 numSamples; struct Packet newPacket; // Allow the system to write to the system registers EALLOW; // Set up the heartbeat gpioCtrlRegisters.GPBDIR.bit.HEARTBEAT = 1; gpioDataRegisters.GPBDAT.bit.HEARTBEAT = 1; // Set up the seven segment display gpioCtrlRegisters.GPADIR.bit.SEVENSEG_A = 1; gpioDataRegisters.GPADAT.bit.SEVENSEG_A = 0; gpioCtrlRegisters.GPADIR.bit.SEVENSEG_B = 1; gpioDataRegisters.GPADAT.bit.SEVENSEG_B = 0; gpioCtrlRegisters.GPADIR.bit.SEVENSEG_C = 1; gpioDataRegisters.GPADAT.bit.SEVENSEG_C = 0; gpioCtrlRegisters.GPADIR.bit.SEVENSEG_D = 1; gpioDataRegisters.GPADAT.bit.SEVENSEG_D = 0; gpioCtrlRegisters.GPADIR.bit.SEVENSEG_E = 1; gpioDataRegisters.GPADAT.bit.SEVENSEG_E = 0; gpioCtrlRegisters.GPADIR.bit.SEVENSEG_F = 1; gpioDataRegisters.GPADAT.bit.SEVENSEG_F = 0; gpioCtrlRegisters.GPADIR.bit.SEVENSEG_G = 1; gpioDataRegisters.GPADAT.bit.SEVENSEG_G = 0; gpioCtrlRegisters.GPADIR.bit.SEVENSEG_DIGIT = 1; gpioDataRegisters.GPADAT.bit.SEVENSEG_DIGIT = 1; // Set up timer 0 for use with SPI related timings sysCtrlRegisters.HISPCP.all = 0; // Set the HSPCLK to run at SYSCLK sysCtrlRegisters.LOSPCP.bit.LSPCLK = 0; // Set the LSPCLK to run at SYSCLK timer0Registers.TCR.bit.TSS = 1; // Stop the timer timer0Registers.TPR.bit.TDDR = 0; // Do not prescale the timer timer0Registers.PRD.all = 0xFFFFFFFF; // Set the period register to it's largest possible value timer0Registers.TCR.bit.TIE = false; // Disable timer interrupts timer0Registers.TCR.bit.FREE = 0; // Set the timer to stop when a breakpoint occrs timer0Registers.TCR.bit.SOFT = 0; timer0Registers.TCR.bit.TRB = 1; // Load the period register timer0Registers.TCR.bit.TSS = 0; // Start the timer // Set up the global SPI-related settings IER |= 0x20; // Enable CPU INT6 // Disallow the system to write to the system registers EDIS; interruptStatus = HWI_disable(); numSamples = 0; for(j = 0; j < 1000; j++) { InitializeGlobalVariables(); globals.root.availableAddresses[0].address = 1; globals.root.availableAddresses[0].addressTaken = true; globals.root.availableAddresses[1].address = 2; globals.root.availableAddresses[1].addressTaken = true; globals.root.availableAddresses[2].address = 3; globals.root.availableAddresses[2].addressTaken = true; globals.root.availableAddresses[3].address = 4; globals.root.availableAddresses[3].addressTaken = true; globals.root.availableAddresses[4].address = 5; globals.root.availableAddresses[4].addressTaken = true; globals.root.availableAddresses[5].address = 6; globals.root.availableAddresses[5].addressTaken = true; globals.root.availableAddresses[6].address = 7; globals.root.availableAddresses[6].addressTaken = true; globals.root.availableAddresses[7].address = 8; globals.root.availableAddresses[7].addressTaken = true; globals.protocol.globalNeighborInfo[1][PORTA].nodeAddress = 2; globals.protocol.globalNeighborInfo[1][PORTB].nodeAddress = 3; globals.protocol.globalNeighborInfo[2][PORTA].nodeAddress = 1; globals.protocol.globalNeighborInfo[2][PORTB].nodeAddress = 4; globals.protocol.globalNeighborInfo[3][PORTA].nodeAddress = 1; globals.protocol.globalNeighborInfo[3][PORTB].nodeAddress = 4; globals.protocol.globalNeighborInfo[3][PORTC].nodeAddress = 5; globals.protocol.globalNeighborInfo[4][PORTA].nodeAddress = 2; globals.protocol.globalNeighborInfo[4][PORTB].nodeAddress = 3; globals.protocol.globalNeighborInfo[4][PORTC].nodeAddress = 6; globals.protocol.globalNeighborInfo[5][PORTA].nodeAddress = 3; globals.protocol.globalNeighborInfo[5][PORTB].nodeAddress = 6; globals.protocol.globalNeighborInfo[5][PORTC].nodeAddress = 7; globals.protocol.globalNeighborInfo[6][PORTA].nodeAddress = 4; globals.protocol.globalNeighborInfo[6][PORTB].nodeAddress = 5; globals.protocol.globalNeighborInfo[6][PORTC].nodeAddress = 8; globals.protocol.globalNeighborInfo[7][PORTA].nodeAddress = 5; globals.protocol.globalNeighborInfo[7][PORTB].nodeAddress = 8; globals.protocol.globalNeighborInfo[8][PORTA].nodeAddress = 6; globals.protocol.globalNeighborInfo[8][PORTB].nodeAddress = 7; startTime = timer0Registers.TIM.all; GenerateRoutingTree(); executionTime = TimeDifference(startTime, timer0Registers.TIM.all); genAvgTime = (genAvgTime * numSamples) + executionTime; numSamples++; genAvgTime /= numSamples; if(executionTime < genMinTime) genMinTime = executionTime; else if(executionTime > genMaxTime) genMaxTime = executionTime; } for(i = 2; i <= 8; i++) { numSamples = 0; for(j = 0; j < 1000; j++) { startTime = timer0Registers.TIM.all; GenerateRoutingPath(1, i, &newPacket); executionTime = TimeDifference(startTime, timer0Registers.TIM.all); avgTime[i] = (avgTime[i] * numSamples) + executionTime; numSamples++; avgTime[i] /= numSamples; if(executionTime < minTime[i]) minTime[i] = executionTime; else if(executionTime > maxTime[i]) maxTime[i] = executionTime; } } HWI_restore(interruptStatus); asm(" NOP"); // Set the seed for the random number generator SetRandomSeed(0x175E); // Set up each individual port SetupPort(PORTA); SetupPort(PORTB); SetupPort(PORTC); SetupPort(PORTD); // Create the direct data cleanup follow-up item AddFollowUpItem(&CleanupDirectData,NULL,DIRECT_DATA_CLEANUP_RATE,true); // Create the neighbor check follow-up item #if defined(IS_ROOT) #if TEST != TEST_SPI globals.followUpMonitor.neighborFollowUpIndex = AddFollowUpItem(&NeighborFollowUp,NULL,NEIGHBOR_FOLLOW_UP_RATE,true); #endif SetSevenSegmentDisplay(SEVENSEG_BLANK); globals.processing.sevenSegmentLowerDigit = globals.protocol.address; #elif defined (IS_ROUTER) #if TEST != TEST_SPI globals.followUpMonitor.neighborFollowUpIndex = AddFollowUpItem(&NeighborFollowUp,NULL,NEIGHBOR_FOLLOW_UP_RATE_WITHOUT_ADDRESS,true); #endif SetSevenSegmentDisplay(SEVENSEG_BLANK); // Register the test service RegisterServiceProvider(TEST_SERVICE_TAG,TEST_SERVICE_TASK_PRIORITY,&TestServiceTask,&TestServiceSem); #endif // Let the other threads know that initialization is finished SEM_post(&ProcessInboundFlitsSem); SEM_post(&TestServiceSem); }
void TimeOneRFFT32(int count, int fft_log_size, float signal_value, int signal_type) { OMX_S32* x; OMX_S32* y; OMX_S32* z; OMX_S32* y_true; OMX_F32* xr; OMX_F32* yrTrue; struct AlignedPtr* x_aligned; struct AlignedPtr* y_aligned; struct AlignedPtr* z_aligned; struct AlignedPtr* y_true_aligned; OMX_S32* temp1; OMX_S32* temp2; OMX_INT n, fft_spec_buffer_size; OMXResult status; OMXFFTSpec_R_S16S32 * fft_fwd_spec = NULL; OMXFFTSpec_R_S16S32 * fft_inv_spec = NULL; int fft_size; struct timeval start_time; struct timeval end_time; double elapsed_time; int scaleFactor = 0; struct SnrResult snr_forward; struct SnrResult snr_inverse; fft_size = 1 << fft_log_size; x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size); y_aligned = AllocAlignedPointer(32, sizeof(*y) * (fft_size + 2)); z_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size); y_true_aligned = AllocAlignedPointer(32, sizeof(*y_true) * (fft_size + 2)); x = x_aligned->aligned_pointer_; y = y_aligned->aligned_pointer_; z = z_aligned->aligned_pointer_; y_true = y_true_aligned->aligned_pointer_; if (verbose > 3) { printf("x = %p\n", (void*)x); printf("y = %p\n", (void*)y); printf("z = %p\n", (void*)z); } xr = (OMX_F32*) malloc(sizeof(*x) * fft_size); yrTrue = (OMX_F32*) malloc(sizeof(*y) * (fft_size + 2)); temp1 = (OMX_S32*) malloc(sizeof(*temp1) * fft_size); temp2 = (OMX_S32*) malloc(sizeof(*temp2) * (fft_size + 2)); GenerateRFFT32Signal(x, (OMX_SC32*) y_true, fft_size, signal_type, signal_value); if (verbose > 63) { printf("Signal\n"); printf("n\tx[n]\n"); for (n = 0; n < fft_size; ++n) { printf("%4d\t%d\n", n, x[n]); } } status = omxSP_FFTGetBufSize_R_S32(fft_log_size, &fft_spec_buffer_size); if (verbose > 3) { printf("fft_spec_buffer_size = %d\n", fft_spec_buffer_size); } fft_fwd_spec = (OMXFFTSpec_R_S32*) malloc(fft_spec_buffer_size); fft_inv_spec = (OMXFFTSpec_R_S32*) malloc(fft_spec_buffer_size); status = omxSP_FFTInit_R_S32(fft_fwd_spec, fft_log_size); if (status) { printf("Failed to init forward FFT: status = %d\n", status); } status = omxSP_FFTInit_R_S32(fft_inv_spec, fft_log_size); if (status) { printf("Failed to init backward FFT: status = %d\n", status); } if (do_forward_test) { if (include_conversion) { int k; float factor = -1; GetUserTime(&start_time); for (k = 0; k < count; ++k) { /* * Spend some time computing the max of the signal, and then scaling it. */ for (n = 0; n < fft_size; ++n) { if (abs(xr[n]) > factor) { factor = abs(xr[n]); } } factor = (1 << 20) / factor; for (n = 0; n < fft_size; ++n) { temp1[n] = factor * xr[n]; } status = omxSP_FFTFwd_RToCCS_S32_Sfs(x, y, fft_fwd_spec, (OMX_INT) scaleFactor); /* * Now spend some time converting the fixed-point FFT back to float. */ factor = 1 / factor; for (n = 0; n < fft_size + 2; ++n) { xr[n] = y[n] * factor; } } GetUserTime(&end_time); } else { float factor = -1; GetUserTime(&start_time); for (n = 0; n < count; ++n) { status = omxSP_FFTFwd_RToCCS_S32_Sfs(x, y, fft_fwd_spec, (OMX_INT) scaleFactor); } GetUserTime(&end_time); } elapsed_time = TimeDifference(&start_time, &end_time); CompareComplex32(&snr_forward, (OMX_SC32*) y, (OMX_SC32*) y_true, fft_size / 2 + 1); PrintResult("Forward RFFT32", fft_log_size, elapsed_time, count, snr_forward.complex_snr_); } if (do_inverse_test) { if (include_conversion) { int k; float factor = -1; GetUserTime(&start_time); for (k = 0; k < count; ++k) { /* * Spend some time scaling the FFT signal to fixed point. */ for (n = 0; n < fft_size + 2; ++n) { if (abs(yrTrue[n]) > factor) { factor = abs(yrTrue[n]); } } for (n = 0; n < fft_size + 2; ++n) { temp2[n] = factor * yrTrue[n]; } status = omxSP_FFTInv_CCSToR_S32_Sfs(y_true, z, fft_inv_spec, 0); /* * Spend some time converting the result back to float */ factor = 1 / factor; for (n = 0; n < fft_size; ++n) { xr[n] = factor * z[n]; } } GetUserTime(&end_time); } else { GetUserTime(&start_time); for (n = 0; n < count; ++n) { status = omxSP_FFTInv_CCSToR_S32_Sfs(y_true, z, fft_inv_spec, 0); } GetUserTime(&end_time); } elapsed_time = TimeDifference(&start_time, &end_time); CompareReal32(&snr_inverse, z, x, fft_size); PrintResult("Inverse RFFT32", fft_log_size, elapsed_time, count, snr_inverse.real_snr_); } FreeAlignedPointer(x_aligned); FreeAlignedPointer(y_aligned); FreeAlignedPointer(z_aligned); FreeAlignedPointer(y_true_aligned); free(fft_fwd_spec); free(fft_inv_spec); }
/* Argument s16s32: * S32: Calculate RFFT16 with 32 bit complex FFT; * otherwise: Calculate RFFT16 with 16 bit complex FFT. */ void TimeOneRFFT16(int count, int fft_log_size, float signal_value, int signal_type, s16_s32 s16s32) { OMX_S16* x; OMX_S32* y; OMX_S16* z; OMX_S32* y_true; OMX_F32* xr; OMX_F32* yrTrue; struct AlignedPtr* x_aligned; struct AlignedPtr* y_aligned; struct AlignedPtr* z_aligned; struct AlignedPtr* y_trueAligned; struct AlignedPtr* xr_aligned; struct AlignedPtr* yr_true_aligned; OMX_S16* temp16; OMX_S32* temp32; OMX_INT n, fft_spec_buffer_size; OMXResult status; OMXFFTSpec_R_S16 * fft_fwd_spec = NULL; OMXFFTSpec_R_S16 * fft_inv_spec = NULL; int fft_size; struct timeval start_time; struct timeval end_time; double elapsed_time; int scaleFactor; fft_size = 1 << fft_log_size; scaleFactor = fft_log_size; x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size); y_aligned = AllocAlignedPointer(32, sizeof(*y) * (fft_size + 2)); z_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size); y_trueAligned = AllocAlignedPointer(32, sizeof(*y_true) * (fft_size + 2)); xr_aligned = AllocAlignedPointer(32, sizeof(*xr) * fft_size); yr_true_aligned = AllocAlignedPointer(32, sizeof(*yrTrue) * (fft_size + 2)); x = x_aligned->aligned_pointer_; y = y_aligned->aligned_pointer_; z = z_aligned->aligned_pointer_; y_true = y_trueAligned->aligned_pointer_; xr = xr_aligned->aligned_pointer_; yrTrue = yr_true_aligned->aligned_pointer_; temp16 = (OMX_S16*) malloc(sizeof(*temp16) * fft_size); temp32 = (OMX_S32*) malloc(sizeof(*temp32) * fft_size); GenerateRFFT16Signal(x, (OMX_SC32*) y_true, fft_size, signal_type, signal_value); /* * Generate a real version so we can measure scaling costs */ GenerateRealFloatSignal(xr, (OMX_FC32*) yrTrue, fft_size, signal_type, signal_value); if(s16s32 == S32) { status = omxSP_FFTGetBufSize_R_S16S32(fft_log_size, &fft_spec_buffer_size); fft_fwd_spec = malloc(fft_spec_buffer_size); fft_inv_spec = malloc(fft_spec_buffer_size); status = omxSP_FFTInit_R_S16S32(fft_fwd_spec, fft_log_size); status = omxSP_FFTInit_R_S16S32(fft_inv_spec, fft_log_size); } else { status = omxSP_FFTGetBufSize_R_S16(fft_log_size, &fft_spec_buffer_size); fft_fwd_spec = malloc(fft_spec_buffer_size); fft_inv_spec = malloc(fft_spec_buffer_size); status = omxSP_FFTInit_R_S16(fft_fwd_spec, fft_log_size); status = omxSP_FFTInit_R_S16(fft_inv_spec, fft_log_size); } if (do_forward_test) { if (include_conversion) { int k; float factor = -1; GetUserTime(&start_time); for (k = 0; k < count; ++k) { /* * Spend some time computing the max of the signal, and then scaling it. */ for (n = 0; n < fft_size; ++n) { if (abs(xr[n]) > factor) { factor = abs(xr[n]); } } factor = 32767 / factor; for (n = 0; n < fft_size; ++n) { temp16[n] = factor * xr[n]; } if(s16s32 == S32) { status = omxSP_FFTFwd_RToCCS_S16S32_Sfs(x, y, (OMXFFTSpec_R_S16S32*)fft_fwd_spec, (OMX_INT) scaleFactor); } else { status = omxSP_FFTFwd_RToCCS_S16_Sfs(x, (OMX_S16*)y, (OMXFFTSpec_R_S16*)fft_fwd_spec, (OMX_INT) scaleFactor); } /* * Now spend some time converting the fixed-point FFT back to float. */ factor = 1 / factor; for (n = 0; n < fft_size + 2; ++n) { xr[n] = y[n] * factor; } } GetUserTime(&end_time); } else { float factor = -1; GetUserTime(&start_time); for (n = 0; n < count; ++n) { if(s16s32 == S32) { status = omxSP_FFTFwd_RToCCS_S16S32_Sfs(x, y, (OMXFFTSpec_R_S16S32*)fft_fwd_spec, (OMX_INT) scaleFactor); } else { status = omxSP_FFTFwd_RToCCS_S16_Sfs(x, (OMX_S16*)y, (OMXFFTSpec_R_S16*)fft_fwd_spec, (OMX_INT) scaleFactor); } } GetUserTime(&end_time); } elapsed_time = TimeDifference(&start_time, &end_time); if(s16s32 == S32) { PrintResultNoSNR("Forward RFFT16 (with S32)", fft_log_size, elapsed_time, count); } else { PrintResultNoSNR("Forward RFFT16 (with S16)", fft_log_size, elapsed_time, count); } } if (do_inverse_test) { if (include_conversion) { int k; float factor = -1; GetUserTime(&start_time); for (k = 0; k < count; ++k) { /* * Spend some time scaling the FFT signal to fixed point. */ for (n = 0; n < fft_size; ++n) { if (abs(yrTrue[n]) > factor) { factor = abs(yrTrue[n]); } } for (n = 0; n < fft_size; ++n) { temp32[n] = factor * yrTrue[n]; } if(s16s32 == S32) { status = omxSP_FFTInv_CCSToR_S32S16_Sfs(y, z, (OMXFFTSpec_R_S16S32*)fft_inv_spec, 0); } else { status = omxSP_FFTInv_CCSToR_S16_Sfs((OMX_S16*)y, z, (OMXFFTSpec_R_S16*)fft_inv_spec, 0); } /* * Spend some time converting the result back to float */ factor = 1 / factor; for (n = 0; n < fft_size; ++n) { xr[n] = factor * z[n]; } } GetUserTime(&end_time); } else { GetUserTime(&start_time); for (n = 0; n < count; ++n) { if(s16s32 == S32) { status = omxSP_FFTInv_CCSToR_S32S16_Sfs(y, z, (OMXFFTSpec_R_S16S32*)fft_inv_spec, 0); } else { status = omxSP_FFTInv_CCSToR_S16_Sfs((OMX_S16*)y, z, (OMXFFTSpec_R_S16*)fft_inv_spec, 0); } } GetUserTime(&end_time); } elapsed_time = TimeDifference(&start_time, &end_time); if(s16s32 == S32) { PrintResultNoSNR("Inverse RFFT16 (with S32)", fft_log_size, elapsed_time, count); } else { PrintResultNoSNR("Inverse RFFT16 (with S16)", fft_log_size, elapsed_time, count); } } FreeAlignedPointer(x_aligned); FreeAlignedPointer(y_aligned); FreeAlignedPointer(z_aligned); FreeAlignedPointer(y_trueAligned); FreeAlignedPointer(xr_aligned); FreeAlignedPointer(yr_true_aligned); free(fft_fwd_spec); free(fft_inv_spec); }
void TimeOneSC16FFT(int count, int fft_log_size, float signal_value, int signal_type) { OMX_SC16* x; OMX_SC16* y; OMX_SC16* z; struct AlignedPtr* x_aligned; struct AlignedPtr* y_aligned; struct AlignedPtr* z_aligned; OMX_SC16* y_true; OMX_SC16* temp16a; OMX_SC16* temp16b; OMX_INT n, fft_spec_buffer_size; OMXResult status; OMXFFTSpec_C_SC16 * fft_fwd_spec = NULL; OMXFFTSpec_C_SC16 * fft_inv_spec = NULL; int fft_size; struct timeval start_time; struct timeval end_time; double elapsed_time; struct SnrResult snr_forward; struct SnrResult snr_inverse; fft_size = 1 << fft_log_size; x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size); y_aligned = AllocAlignedPointer(32, sizeof(*y) * fft_size); z_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size); y_true = (OMX_SC16*) malloc(sizeof(*y_true) * fft_size); temp16a = (OMX_SC16*) malloc(sizeof(*temp16a) * fft_size); temp16b = (OMX_SC16*) malloc(sizeof(*temp16b) * fft_size); x = x_aligned->aligned_pointer_; y = y_aligned->aligned_pointer_; z = z_aligned->aligned_pointer_; generateSC16Signal(x, y_true, fft_size, signal_type, signal_value); status = omxSP_FFTGetBufSize_C_SC16(fft_log_size, &fft_spec_buffer_size); fft_fwd_spec = (OMXFFTSpec_C_SC16*) malloc(fft_spec_buffer_size); fft_inv_spec = (OMXFFTSpec_C_SC16*) malloc(fft_spec_buffer_size); status = omxSP_FFTInit_C_SC16(fft_fwd_spec, fft_log_size); status = omxSP_FFTInit_C_SC16(fft_inv_spec, fft_log_size); if (do_forward_test) { if (include_conversion) { int k; float factor = -1; GetUserTime(&start_time); for (k = 0; k < count; ++k) { for (n = 0; n < fft_size; ++n) { if (abs(x[n].Re) > factor) { factor = abs(x[n].Re); } if (abs(x[n].Im) > factor) { factor = abs(x[n].Im); } } factor = ((1 << 15) - 1) / factor; for (n = 0; n < fft_size; ++n) { temp16a[n].Re = factor * x[n].Re; temp16a[n].Im = factor * x[n].Im; } omxSP_FFTFwd_CToC_SC16_Sfs(x, y, fft_fwd_spec, 0); factor = 1 / factor; for (n = 0; n < fft_size; ++n) { temp16b[n].Re = y[n].Re * factor; temp16b[n].Im = y[n].Im * factor; } } GetUserTime(&end_time); } else { GetUserTime(&start_time); for (n = 0; n < count; ++n) { omxSP_FFTFwd_CToC_SC16_Sfs(x, y, fft_fwd_spec, 0); } GetUserTime(&end_time); } elapsed_time = TimeDifference(&start_time, &end_time); CompareComplex16(&snr_forward, y, y_true, fft_size); PrintResult("Forward SC16 FFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_); } if (do_inverse_test) { if (include_conversion) { int k; float factor = -1; GetUserTime(&start_time); for (k = 0; k < count; ++k) { for (n = 0; n < fft_size; ++n) { if (abs(x[n].Re) > factor) { factor = abs(x[n].Re); } if (abs(x[n].Im) > factor) { factor = abs(x[n].Im); } } factor = ((1 << 15) - 1) / factor; for (n = 0; n < fft_size; ++n) { temp16a[n].Re = factor * x[n].Re; temp16a[n].Im = factor * x[n].Im; } status = omxSP_FFTInv_CToC_SC16_Sfs(y, z, fft_inv_spec, 0); factor = 1 / factor; for (n = 0; n < fft_size; ++n) { temp16b[n].Re = y[n].Re * factor; temp16b[n].Im = y[n].Im * factor; } } GetUserTime(&end_time); } else { GetUserTime(&start_time); for (n = 0; n < count; ++n) { status = omxSP_FFTInv_CToC_SC16_Sfs(y, z, fft_inv_spec, 0); } GetUserTime(&end_time); } elapsed_time = TimeDifference(&start_time, &end_time); CompareComplex16(&snr_inverse, z, x, fft_size); PrintResult("Inverse SC16 FFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_); } FreeAlignedPointer(x_aligned); FreeAlignedPointer(y_aligned); FreeAlignedPointer(z_aligned); free(temp16a); free(temp16b); free(fft_fwd_spec); free(fft_inv_spec); }
void TimeOneFloatFFT(int count, int fft_log_size, float signal_value, int signal_type) { struct AlignedPtr* x_aligned; struct AlignedPtr* y_aligned; struct AlignedPtr* z_aligned; struct AlignedPtr* y_true_aligned; struct ComplexFloat* x; struct ComplexFloat* y; OMX_FC32* z; struct ComplexFloat* y_true; OMX_INT n, fft_spec_buffer_size; OMXFFTSpec_C_FC32 * fft_fwd_spec = NULL; OMXFFTSpec_C_FC32 * fft_inv_spec = NULL; int fft_size; struct timeval start_time; struct timeval end_time; double elapsed_time; struct SnrResult snr_forward; struct SnrResult snr_inverse; fft_size = 1 << fft_log_size; x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size); y_aligned = AllocAlignedPointer(32, sizeof(*y) * (fft_size + 2)); z_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size); y_true_aligned = AllocAlignedPointer(32, sizeof(*z) * fft_size); x = x_aligned->aligned_pointer_; y = y_aligned->aligned_pointer_; z = z_aligned->aligned_pointer_; y_true = y_true_aligned->aligned_pointer_; GenerateTestSignalAndFFT(x, y_true, fft_size, signal_type, signal_value, 0); omxSP_FFTGetBufSize_C_FC32(fft_log_size, &fft_spec_buffer_size); fft_fwd_spec = (OMXFFTSpec_C_FC32*) malloc(fft_spec_buffer_size); fft_inv_spec = (OMXFFTSpec_C_FC32*) malloc(fft_spec_buffer_size); omxSP_FFTInit_C_FC32(fft_fwd_spec, fft_log_size); omxSP_FFTInit_C_FC32(fft_inv_spec, fft_log_size); if (do_forward_test) { GetUserTime(&start_time); for (n = 0; n < count; ++n) { FORWARD_FLOAT_FFT((OMX_FC32*) x, (OMX_FC32*) y, fft_fwd_spec); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareComplexFloat(&snr_forward, (OMX_FC32*) y, (OMX_FC32*) y_true, fft_size); PrintResult("Forward Float FFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_); } if (do_inverse_test) { GetUserTime(&start_time); for (n = 0; n < count; ++n) { INVERSE_FLOAT_FFT((OMX_FC32*) y_true, z, fft_inv_spec); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareComplexFloat(&snr_inverse, (OMX_FC32*) z, (OMX_FC32*) x, fft_size); PrintResult("Inverse Float FFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_); } FreeAlignedPointer(x_aligned); FreeAlignedPointer(y_aligned); FreeAlignedPointer(z_aligned); FreeAlignedPointer(y_true_aligned); free(fft_fwd_spec); free(fft_inv_spec); }
/*********************************************************************** * * FUNCTION: SelectTime * * DESCRIPTION: Display a form showing a start and end time. * Allow the user to change the time and then * return them. * pTimeDiff. * * PARAMETERS: pStartTime - pointer to TimeType * pEndTime - pointer to TimeType * untimed - true if there isn't a time. * title - string containing the title * startOfDay - used when "All Day" button selected. * endOfDay - our used when "All Day" button selected. * startOfDisplay - first hour initially visible * * RETURNED: True if the time was changed by the user. * The first three parameters may change. * * REVISION HISTORY: * Name Date Description * ---- ---- ----------- * roger 12/2/94 Initial Revision * trev 08/12/97 made non modified passed variables constant * css 06/08/99 added new parameter & "All Day" button for gromit change. * ***********************************************************************/ Boolean SelectTime (TimeType * startTimeP, TimeType * endTimeP, Boolean untimed, const Char * titleP, Int16 startOfDay, Int16 endOfDay, Int16 startOfDisplay) { Int16 firstHour; Char startTimeText [timeStringLength]; Char endTimeText [timeStringLength]; Char timeChars [timeStringLength]; TimePtr timeP; FormType *originalForm, *frm; ListPtr hoursLst, minutesLst; ControlPtr startTimeCtl, endTimeCtl; EventType event; Boolean confirmed = false; MemHandle hoursItems; TimeType startTime, endTime, timeDiff; TimeFormatType timeFormat; ChangingTimeType changingTime; // Get the time format from the system preerances; timeFormat = (TimeFormatType)PrefGetPreference(prefTimeFormat); // Because this routine only deals with minutes in five minute // intervals we convert the proposed times from those passed. startTime.hours = startTimeP->hours; startTime.minutes = startTimeP->minutes; endTime.hours = endTimeP->hours; endTime.minutes = endTimeP->minutes; TimeDifference (&endTime, &startTime, &timeDiff); // Make sure the end time is displayable (clips at 11:55 pm) AdjustTimes (&startTime, &endTime, &timeDiff, changingStartTime); // Clear the buffer that holds written characters. *timeChars = 0; startOfDisplay = min (startOfDisplay, 12); originalForm = FrmGetActiveForm(); frm = (FormType *) FrmInitForm (TimeSelectorForm); FrmSetActiveForm (frm); hoursLst = FrmGetObjectPtr (frm, FrmGetObjectIndex (frm, TimeSelectorHourList)); minutesLst = FrmGetObjectPtr (frm, FrmGetObjectIndex (frm, TimeSelectorMinuteList)); startTimeCtl = FrmGetObjectPtr (frm, FrmGetObjectIndex (frm, TimeSelectorStartTimeButton)); endTimeCtl = FrmGetObjectPtr (frm, FrmGetObjectIndex (frm, TimeSelectorEndTimeButton)); // Set list to use either 12 or 24 hour time hoursItems = SysFormPointerArrayToStrings ( ((timeFormat == tfColon24h) || (timeFormat == tfDot24h)) ? (Char *) Hours24Array() : (Char *) Hours12Array(), 24); LstSetListChoices (hoursLst, MemHandleLock(hoursItems), 24); LstSetTopItem (hoursLst, startOfDisplay); // Used to do LstMakeItemVisible (hoursLst, startTime.hours); no longer. if (! untimed) { LstSetSelection (hoursLst, startTime.hours); LstSetSelection (minutesLst, startTime.minutes / 5); CtlSetValue (startTimeCtl, true); changingTime = changingStartTime; } else { // The hour list is dynamically created and doesn't have a selection LstSetSelection (minutesLst, noListSelection); changingTime = changingNoTime; } // Set the start and end time buttons to the current times or blank them // if No Time is selected. SetTimeTriggers (startTime, endTime, startTimeText, endTimeText, timeFormat, untimed); // This needs to be taken out when SelectTimeV33 goes away. It allows for backward // compatibility for this change of adding the end of day variable as a parameter. if (endOfDay != noDisplayOfAllDay) { FrmShowObject (frm, FrmGetObjectIndex (frm, TimeSelectorAllDayButton)); } FrmSetTitle (frm, (Char *) titleP); FrmDrawForm (frm); while (true) { EvtGetEvent (&event, evtWaitForever); if (SysHandleEvent ((EventType *)&event)) continue; if (event.eType == appStopEvent) { // Cancel the dialog and repost this event for the app EvtAddEventToQueue(&event); confirmed = false; break; } // Handle these before the form does to overide the default behavior if (changingTime == changingNoTime && event.eType == lstEnterEvent && event.data.lstEnter.listID == TimeSelectorMinuteList) { SndPlaySystemSound(sndError); continue; } FrmHandleEvent (frm, &event); // If the start or end time buttons are pressed then change // the time displayed in the lists. if (event.eType == ctlSelectEvent) { // "Ok" button pressed? if (event.data.ctlSelect.controlID == TimeSelectorOKButton) { confirmed = true; } // "Cancel" button pressed? else if (event.data.ctlSelect.controlID == TimeSelectorCancelButton) { break; } // Start time button pressed? else if (event.data.ctlSelect.controlID == TimeSelectorStartTimeButton) { if (changingTime != changingStartTime) { if (changingTime == changingNoTime) { SetTimeTriggers (startTime, endTime, startTimeText, endTimeText, timeFormat, false); } CtlSetValue (endTimeCtl, false); LstSetSelection (hoursLst, startTime.hours); LstSetSelection (minutesLst, startTime.minutes / 5); changingTime = changingStartTime; } else CtlSetValue(startTimeCtl, true); } // End time button pressed? else if (event.data.ctlSelect.controlID == TimeSelectorEndTimeButton) { if (changingTime != changingEndTime) { if (changingTime == changingNoTime) { SetTimeTriggers (startTime, endTime, startTimeText, endTimeText, timeFormat, false); } CtlSetValue(startTimeCtl, false); LstSetSelection (hoursLst, endTime.hours); LstSetSelection (minutesLst, endTime.minutes / 5); changingTime = changingEndTime; } else CtlSetValue(endTimeCtl, true); } // No time button pressed? else if (event.data.ctlSelect.controlID == TimeSelectorNoTimeButton) { if (changingTime != changingNoTime) { if (changingTime == changingStartTime) CtlSetValue(startTimeCtl, false); else CtlSetValue(endTimeCtl, false); SetTimeTriggers (startTime, endTime, startTimeText, endTimeText, timeFormat, true); LstSetSelection (hoursLst, noListSelection); LstSetSelection (minutesLst, noListSelection); changingTime = changingNoTime; } // Get us out of this form display now. confirmed = true; } // All day button pressed? else if (event.data.ctlSelect.controlID == TimeSelectorAllDayButton) { if (changingTime != changingNoTime) { if (changingTime == changingStartTime) CtlSetValue(startTimeCtl, false); else CtlSetValue(endTimeCtl, false); LstSetSelection (hoursLst, noListSelection); LstSetSelection (minutesLst, noListSelection); changingTime = changingNoTime; } // No matter what, the minutes are 0 for both because only the hour is registered for start/end // times. startTime.minutes = 0; endTime.minutes = 0; startTime.hours = startOfDay; endTime.hours = endOfDay; // Set the times to the new times. SetTimeTriggers (startTime, endTime, startTimeText, endTimeText, timeFormat, true); // Get us out of this form display now. First set the changing time to anything but the changingNoTime value // so that the pointers at the end of this function get set correctly. changingTime = changingStartTime; confirmed = true; } // Clear the buffer that holds written characters. *timeChars = 0; } // If either list is changed then get the new time. If the // start time is changed then change the end time so that the // the time difference remains the same. If the end time is // changed then make sure the end time isn't before the start // time. Also calculate a new time difference. else if (event.eType == lstSelectEvent) { // First, get the info from the list which has changed. if (event.data.lstSelect.listID == TimeSelectorHourList) { if (changingTime == changingStartTime) startTime.hours = (UInt8) LstGetSelection (hoursLst); else if (changingTime == changingEndTime) endTime.hours = (UInt8) LstGetSelection (hoursLst); else if (changingTime == changingNoTime) { startTime.hours = (UInt8) LstGetSelection (hoursLst); SetTimeTriggers (startTime, endTime, startTimeText, endTimeText, timeFormat, false); CtlSetValue (endTimeCtl, false); LstSetSelection (minutesLst, startTime.minutes / 5); changingTime = changingStartTime; } } else if (event.data.lstSelect.listID == TimeSelectorMinuteList) { if (changingTime == changingStartTime) startTime.minutes = (UInt8) LstGetSelection (minutesLst) * 5; else if (changingTime == changingEndTime) endTime.minutes = (UInt8) LstGetSelection (minutesLst) * 5; else if (changingTime == changingNoTime) { ErrNonFatalDisplay("lstEnterEvent not being filtered."); } } if (AdjustTimes (&startTime, &endTime, &timeDiff, changingTime)) { if (changingTime == changingStartTime) { TimeToAscii (startTime.hours, startTime.minutes, timeFormat, startTimeText); CtlSetLabel (startTimeCtl, startTimeText); } else if (changingTime == changingEndTime) { LstSetSelection (hoursLst, startTime.hours); LstSetSelection (minutesLst, startTime.minutes / 5); } } TimeToAscii(endTime.hours, endTime.minutes, timeFormat, endTimeText); CtlSetLabel(endTimeCtl, endTimeText); // Clear the buffer that holds written characters. *timeChars = 0; } // Handle character written in the time picker. else if (event.eType == keyDownEvent) { if (changingTime == changingEndTime) { timeP = &endTime; firstHour = startTime.hours; } else { timeP = &startTime; firstHour = startOfDisplay; } // If a backspace character was written, change the time picker's // current setting to "no-time". if (event.data.keyDown.chr == backspaceChr) { *timeChars = 0; if (changingTime != changingNoTime) { if (changingTime == changingStartTime) CtlSetValue (startTimeCtl, false); else CtlSetValue (endTimeCtl, false); SetTimeTriggers (startTime, endTime, startTimeText, endTimeText, timeFormat, true); LstSetSelection (hoursLst, noListSelection); LstSetSelection (minutesLst, noListSelection); changingTime = changingNoTime; } } // A linefeed character confirms the dialog box. else if (event.data.keyDown.chr == linefeedChr) { confirmed = true; } // If next-field character toggle between start time in end // time. else if (event.data.keyDown.chr == nextFieldChr) { *timeChars = 0; if (changingTime == changingStartTime) { CtlSetValue (startTimeCtl, false); CtlSetValue (endTimeCtl, true); changingTime = changingEndTime; } else { CtlSetValue (endTimeCtl, false); CtlSetValue (startTimeCtl, true); changingTime = changingStartTime; } } // If a valid time character was written, translate the written // character into a time and update the time picker's UI. else if (TranslateTime (timeFormat, event.data.keyDown.chr, firstHour, timeChars, timeP)) { if (changingTime == changingNoTime) { changingTime = changingStartTime; CtlSetValue (startTimeCtl, true); } AdjustTimes (&startTime, &endTime, &timeDiff, changingTime); SetTimeTriggers (startTime, endTime, startTimeText, endTimeText, timeFormat, false); LstSetSelection (hoursLst, timeP->hours); LstSetSelection (minutesLst, timeP->minutes / 5); } } // Has the dialog been confirmed. if (confirmed) { if (changingTime != changingNoTime) { *startTimeP = startTime; *endTimeP = endTime; } else { TimeToInt(*startTimeP) = noTime; TimeToInt(*endTimeP) = noTime; } break; } } FrmEraseForm (frm); FrmDeleteForm (frm); MemHandleFree (hoursItems); FrmSetActiveForm(originalForm); return (confirmed); }
void TimeOneNE10FFT(int count, int fft_log_size, float signal_value, int signal_type) { struct AlignedPtr* x_aligned; struct AlignedPtr* y_aligned; struct AlignedPtr* z_aligned; struct ComplexFloat* x; struct ComplexFloat* y; OMX_FC32* z; struct ComplexFloat* y_true; int n; ne10_result_t status; ne10_fft_cfg_float32_t fft_fwd_spec; int fft_size; struct timeval start_time; struct timeval end_time; double elapsed_time; struct SnrResult snr_forward; struct SnrResult snr_inverse; fft_size = 1 << fft_log_size; x_aligned = AllocAlignedPointer(32, sizeof(*x) * fft_size); y_aligned = AllocAlignedPointer(32, sizeof(*y) * 2 * fft_size); z_aligned = AllocAlignedPointer(32, sizeof(*z) * 2 * fft_size); y_true = (struct ComplexFloat*) malloc(sizeof(*y_true) * fft_size); x = x_aligned->aligned_pointer_; y = y_aligned->aligned_pointer_; z = z_aligned->aligned_pointer_; GenerateTestSignalAndFFT(x, y_true, fft_size, signal_type, signal_value, 0); fft_fwd_spec = ne10_fft_alloc_c2c_float32(fft_size); if (!fft_fwd_spec) { fprintf(stderr, "NE10 FFT: Cannot initialize FFT structure for order %d\n", fft_log_size); return; } if (do_forward_test) { GetUserTime(&start_time); for (n = 0; n < count; ++n) { ne10_fft_c2c_1d_float32_neon((ne10_fft_cpx_float32_t *) y, (ne10_fft_cpx_float32_t *) x, fft_fwd_spec, 0); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareComplexFloat(&snr_forward, (OMX_FC32*) y, (OMX_FC32*) y_true, fft_size); PrintResult("Forward NE10 FFT", fft_log_size, elapsed_time, count, snr_forward.complex_snr_); if (verbose >= 255) { printf("Input data:\n"); DumpArrayComplexFloat("x", fft_size, (OMX_FC32*) x); printf("FFT Actual:\n"); DumpArrayComplexFloat("y", fft_size, (OMX_FC32*) y); printf("FFT Expected:\n"); DumpArrayComplexFloat("true", fft_size, (OMX_FC32*) y_true); } } if (do_inverse_test) { GetUserTime(&start_time); for (n = 0; n < count; ++n) { ne10_fft_c2c_1d_float32_neon((ne10_fft_cpx_float32_t *) z, (ne10_fft_cpx_float32_t *) y_true, fft_fwd_spec, 1); } GetUserTime(&end_time); elapsed_time = TimeDifference(&start_time, &end_time); CompareComplexFloat(&snr_inverse, (OMX_FC32*) z, (OMX_FC32*) x, fft_size); PrintResult("Inverse NE10 FFT", fft_log_size, elapsed_time, count, snr_inverse.complex_snr_); if (verbose >= 255) { printf("Input data:\n"); DumpArrayComplexFloat("y", fft_size, (OMX_FC32*) y_true); printf("IFFT Actual:\n"); DumpArrayComplexFloat("z", fft_size, z); printf("IFFT Expected:\n"); DumpArrayComplexFloat("x", fft_size, (OMX_FC32*) x); } } ne10_fft_destroy_c2c_float32(fft_fwd_spec); FreeAlignedPointer(x_aligned); FreeAlignedPointer(y_aligned); FreeAlignedPointer(z_aligned); free(y_true); }