void RTCC_IRQHandler(void) #endif { uint32_t flags, timeElapsed, cnt, timeToNextTimerCompletion; INT_Disable(); // CNT will normally be COMP0+1 at this point, // unless IRQ latency exceeded one tick period. flags = RTC_INTGET(); if ( flags & RTC_COMP_INT ) { // Stop timer system by disabling the compare IRQ. // Update all timers with the time elapsed, call callbacks if needed, // then find the timer with the shortest timeout (if any at all) and // reenable the compare IRQ if needed. inTimerIRQ = true; cnt = RTC_COUNTERGET(); // This loop is repeated if CNT is incremented while processing. do { RTC_INTDISABLE( RTC_COMP_INT ); timeElapsed = TIMEDIFF( cnt, lastStart ); // Update all timers with elapsed time. checkAllTimers( timeElapsed ); // Execute timer callbacks. executeTimerCallbacks(); // Restart RTC according to next timeout. rescheduleRtc( cnt ); cnt = RTC_COUNTERGET(); timeElapsed = TIMEDIFF( cnt, lastStart ); timeToNextTimerCompletion = TIMEDIFF( RTC_COMPAREGET(), lastStart ); /* If the counter has passed the COMP(ARE) register value since we checked the timers, then we should recheck the timers and reschedule again. */ } while ( rtcRunning && (timeElapsed > timeToNextTimerCompletion)); inTimerIRQ = false; } #if defined( EMDRV_RTCDRV_WALLCLOCK_CONFIG ) if ( flags & RTC_OF_INT ) { RTC_INTCLEAR( RTC_OF_INT ); wallClockOverflowCnt++; } #endif INT_Enable(); }
void bpress(XEvent *e) { struct timespec now; MouseShortcut *ms; if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) { mousereport(e); return; } for (ms = mshortcuts; ms < mshortcuts + mshortcutslen; ms++) { if (e->xbutton.button == ms->b && match(ms->mask, e->xbutton.state)) { ttysend(ms->s, strlen(ms->s)); return; } } if (e->xbutton.button == Button1) { clock_gettime(CLOCK_MONOTONIC, &now); /* Clear previous selection, logically and visually. */ selclear_(NULL); sel.mode = SEL_EMPTY; sel.type = SEL_REGULAR; sel.oe.x = sel.ob.x = x2col(e->xbutton.x); sel.oe.y = sel.ob.y = y2row(e->xbutton.y); /* * If the user clicks below predefined timeouts specific * snapping behaviour is exposed. */ if (TIMEDIFF(now, sel.tclick2) <= tripleclicktimeout) { sel.snap = SNAP_LINE; } else if (TIMEDIFF(now, sel.tclick1) <= doubleclicktimeout) { sel.snap = SNAP_WORD; } else { sel.snap = 0; } selnormalize(); if (sel.snap != 0) sel.mode = SEL_READY; tsetdirt(sel.nb.y, sel.ne.y); sel.tclick2 = sel.tclick1; sel.tclick1 = now; } }
int main(int argc, char **argv) { int i; double tbaseline; x = 25.0; xsq = x * x; /* Reference: a loop that just does an assignment */ clock_gettime(CLOCK_REALTIME, &before); clock_gettime(CLOCK_REALTIME, &ts1); for (i = 0; i < N; i++) { y = x; } clock_gettime(CLOCK_REALTIME, &ts2); tbaseline = ELAPSED_NANOSECONDS(); /* Floating-point comparisons take 1.8 nsecs */ clock_gettime(CLOCK_REALTIME, &ts1); for (i = 0; i < N; i++) { if (x > M_PI) y = 0.0; else y = 1.0; } clock_gettime(CLOCK_REALTIME, &ts2); printf("%f nanoseconds for float comparison\n", ELAPSED_NANOSECONDS() - tbaseline); /* The library sqrt() function takes 14 nsecs */ clock_gettime(CLOCK_REALTIME, &ts1); for (i = 0; i < N; i++) { y = sqrt(x); } clock_gettime(CLOCK_REALTIME, &ts2); printf("%f nanoseconds for library sqrt\n", ELAPSED_NANOSECONDS() - tbaseline); printf("sqrt(%f) = %f\n", x, y); /* Tinker with the lookup-table sqrt until it's fast */ clock_gettime(CLOCK_REALTIME, &ts1); for (i = 0; i < N; i++) { //y = extendSqrt(xsq); y = interpolator_sqrt(xsq); } clock_gettime(CLOCK_REALTIME, &ts2); printf("%f nanoseconds for lookup-table sqrt\n", ELAPSED_NANOSECONDS() - tbaseline); clock_gettime(CLOCK_REALTIME, &after); printf("sqrtlut(%f) = %f\n", x, y); printf("%f seconds for the whole thing\n", TIMEDIFF(after, before)); return 0; }
static void delayTicks( uint32_t ticks ) { uint32_t startTime; volatile uint32_t now; if ( ticks ) { startTime = RTC_COUNTERGET(); do { now = RTC_COUNTERGET(); } while ( TIMEDIFF( now, startTime ) < ticks ); } }
void bpress(XEvent *e) { struct timespec now; MouseShortcut *ms; int snap; if (IS_SET(MODE_MOUSE) && !(e->xbutton.state & forceselmod)) { mousereport(e); return; } for (ms = mshortcuts; ms < mshortcuts + LEN(mshortcuts); ms++) { if (e->xbutton.button == ms->b && match(ms->mask, e->xbutton.state)) { ttywrite(ms->s, strlen(ms->s), 1); return; } } if (e->xbutton.button == Button1) { /* * If the user clicks below predefined timeouts specific * snapping behaviour is exposed. */ clock_gettime(CLOCK_MONOTONIC, &now); if (TIMEDIFF(now, xsel.tclick2) <= tripleclicktimeout) { snap = SNAP_LINE; } else if (TIMEDIFF(now, xsel.tclick1) <= doubleclicktimeout) { snap = SNAP_WORD; } else { snap = 0; } xsel.tclick2 = xsel.tclick1; xsel.tclick1 = now; selstart(evcol(e), evrow(e), snap); } }
/***************************************************************************//** * @brief * Get time left before a given timer expires. * * @param[in] id The id of the timer to query. * * @param[out] timeRemaining Time left expressed in milliseconds. * Only valid if return status is ECODE_EMDRV_RTCDRV_OK. * @return * @ref ECODE_EMDRV_RTCDRV_OK on success.@n * @ref ECODE_EMDRV_RTCDRV_ILLEGAL_TIMER_ID if id has an illegal value. @n * @ref ECODE_EMDRV_RTCDRV_TIMER_NOT_ALLOCATED if the timer is not reserved.@n * @ref ECODE_EMDRV_RTCDRV_TIMER_NOT_RUNNING if the timer is not running.@n * @ref ECODE_EMDRV_RTCDRV_PARAM_ERROR if an invalid timeRemaining pointer * was supplied. ******************************************************************************/ Ecode_t RTCDRV_TimeRemaining( RTCDRV_TimerID_t id, uint32_t *timeRemaining ) { uint64_t tmp; uint32_t timeLeft, currentCnt, lastRtcStart; // Check if valid timer ID. if ( id >= EMDRV_RTCDRV_NUM_TIMERS ) { return ECODE_EMDRV_RTCDRV_ILLEGAL_TIMER_ID; } // Check pointer validity. if ( timeRemaining == NULL ) { return ECODE_EMDRV_RTCDRV_PARAM_ERROR; } INT_Disable(); // Check if timer is reserved. if ( ! timer[ id ].allocated ) { INT_Enable(); return ECODE_EMDRV_RTCDRV_TIMER_NOT_ALLOCATED; } // Check if timer is running. if ( ! timer[ id ].running ) { INT_Enable(); return ECODE_EMDRV_RTCDRV_TIMER_NOT_RUNNING; } timeLeft = timer[ id ].remaining; currentCnt = RTC_COUNTERGET(); lastRtcStart = lastStart; INT_Enable(); // Get number of RTC clock ticks elapsed since last RTC reschedule. currentCnt = TIMEDIFF( currentCnt, lastRtcStart ); if ( currentCnt > timeLeft ) { timeLeft = 0; } else { timeLeft -= currentCnt; } tmp = TICKS_TO_MSEC( timeLeft ); *timeRemaining = tmp; return ECODE_EMDRV_RTCDRV_OK; }
int get_reply(mc_socket_t sock) #endif { fd_set readfds; FD_ZERO(&readfds); FD_SET(sock, &readfds); #ifdef NOMULTISOCK int s_rc = select(sock+1, &readfds, NULL, NULL, NULL); #else /* XXX: make sure this is working properly. */ int s_rc = cmm_select(sock+1, &readfds, NULL, NULL, NULL); //int s_rc = 1; #endif if (s_rc < 0) { return s_rc; } struct chunk ch = {""}; struct timeval begin, end, diff; TIME(begin); printf("[%lu.%06lu][testapp] Receiving reply\n", begin.tv_sec, begin.tv_usec); #ifdef NOMULTISOCK int rc = read(sock, &ch, sizeof(ch)); #else int rc = cmm_read(sock, &ch, sizeof(ch), NULL); #endif TIME(end); if (rc != sizeof(ch)) { perror("cmm_read"); return rc; } TIMEDIFF(begin, end, diff); printf("[%lu.%06lu][testapp] Received msg in %lu.%06lu seconds\n", end.tv_sec, end.tv_usec, diff.tv_sec, diff.tv_usec); ch.data[sizeof(ch)-1] = '\0'; printf("Echo: %*s\n", (int)(sizeof(ch) - 1), ch.data); return rc; }
int main(int argc, char **argv) { ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 2, argc, argv, banner, usage); char *hmmfile = esl_opt_GetArg(go, 1); char *seqfile = esl_opt_GetArg(go, 2); ESL_STOPWATCH *w = esl_stopwatch_Create(); ESL_RANDOMNESS*r = esl_randomness_Create(esl_opt_GetInteger(go, "-s")); ESL_ALPHABET*abc = NULL; P7_HMMFILE *hfp = NULL; P7_HMM *hmm = NULL; P7_BG *bg = NULL; P7_PROFILE *gm1, *gm2; int L = 2000; // esl_opt_GetInteger(go, "-L"); int N = esl_opt_GetInteger(go, "-N"); int MaxPart = esl_opt_GetInteger(go, "-M"); __m128 resdata[10]; float *sc1 = (float*) (resdata+0); // uses 1 __m128s ESL_DSQ *dsq = NULL; int i, j; ESL_SQFILE *sqfp = NULL; DATA_STREAM *dstream; struct timeb tbstart, tbend; int sumlengths = 0; if (p7_hmmfile_Open(hmmfile, NULL, &hfp)!= eslOK) p7_Fail("Failed to open HMM file %s", hmmfile); if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("Failed to read HMM"); bg = p7_bg_Create(abc); p7_bg_SetLength(bg, L); gm1 = p7_profile_Create(hmm->M, abc); gm2 = p7_profile_Create(hmm->M, abc); p7_ProfileConfig(hmm, bg, gm1, L, p7_UNILOCAL); p7_ProfileConfig(hmm, bg, gm2, L, p7_UNILOCAL); dstream = p7_ViterbiStream_Create(gm1); p7_ViterbiStream_Setup(dstream, L+100, MaxPart); // use max L dstream->L = L; // No. of partitions computed without full parallelism ( == no. of threads active while some are idle) int Niters_part = dstream->Npartitions % NTHREADS; // No. of Model lines that could be computed but are wasted by idle threads waiting on the end int Nwasted_threads = dstream->partition * ((NTHREADS-Niters_part) % NTHREADS); // No. of lines in the last partition that go beyond M. It's wasted comp time by a single thread int Nwasted_leftover= (dstream->partition - gm1->M % dstream->partition) % dstream->partition; // Total number of wasted lines int wastedcomp = Nwasted_threads + Nwasted_leftover; // Total number of lines computed and waited for int totalcomp = wastedcomp + gm1->M; // same as: roundtop(gm1->M, dstream->partition * NTHREADS); printf("Viterbi Stream Word with %d Threads, model %s: Modelsize %d, #Segms: %d, SeqL: %d, Nseqs %d, Part %d, #Parts %d\n", NTHREADS, hmmfile, gm1->M, (int) ceil(gm1->M/8.0), L, 8*N, dstream->partition, dstream->Npartitions); printf("Total Comp Lines: %d | Wasted Comp Lines: %d\n", totalcomp, wastedcomp); // for ViterbiFilter P7_OPROFILE *om = p7_oprofile_Create(hmm->M, gm1->abc); p7_oprofile_Convert(gm1, om); P7_OMX *ox = p7_omx_Create(hmm->M, 0, 0); dsq_cmp_t **seqsdb= calloc(8*N+64, sizeof(dsq_cmp_t*)); if(0) { ESL_SQ* sq = esl_sq_CreateDigital(abc); if (esl_sqfile_OpenDigital(abc, seqfile, eslSQFILE_FASTA, NULL, &sqfp) != eslOK) { p7_Fail("Failed to open sequence file\n"); return -1; } for (j = 0; j < 8*N; j++) { int res = esl_sqio_Read(sqfp, sq); if (res != eslOK) { printf("ATENCAO: faltam sequencias\n"); break; } int len = sq->n; dsq = sq->dsq; seqsdb[j] = malloc(sizeof(dsq_cmp_t)); seqsdb[j]->length = len; seqsdb[j]->seq = malloc((len+4)*sizeof(ESL_DSQ)); memcpy(seqsdb[j]->seq, dsq, len+2); sumlengths += len; esl_sq_Reuse(sq); } ftime(&tbstart); N = j/8; printf("N = %d\n", N); // Sort sequences by length qsort(seqsdb, N*8, sizeof(dsq_cmp_t*), compare_seqs); } else if(0) for (i = 0; i < N; i++) { for (j = 0; j < 8; j++) { int len = L - rand()%1000; seqsdb[i*8+j] = malloc(sizeof(dsq_cmp_t)); seqsdb[i*8+j]->seq = malloc(len+4); seqsdb[i*8+j]->length = len; esl_rsq_xfIID(r, bg->f, abc->K, len, seqsdb[i*8+j]->seq); sumlengths += len; } } // double sumerrors = 0; float* results = (float*) alloc_m128_aligned64(N*2+2); ftime(&tbstart); for (j = 0; j < N; j++) for (i = 0; i < N; i++) { // if (i % 10000 == 0) printf("START %d\n", i); p7_ViterbiStream(dstream, seqsdb+i*8, sc1); // memcpy(results+i*8, sc1, 32); } ftime(&tbend); double secs = TIMEDIFF(tbstart,tbend); // printf("Qsort time: %6.3f | Viterbi time: %6.3f\n", TIMEDIFF(tbqsort,tbstart), secs); w->elapsed = w->user = secs; esl_stopwatch_Display(stdout, w, "# Opt CPU time: "); printf("# %.0fM cells in %.1f Mc/s\n", (sumlengths * (double) gm1->M) / 1e6, (sumlengths * (double) gm1->M * 1e-6) / secs); if(0) // compare results against base version for (i = 0; i < 1000 && i < N; i++) { int maxll = 0; float sc2; for (j = 0; j < 8; j++) if (maxll < seqsdb[i*8+j]->length) maxll = seqsdb[i*8+j]->length; // for (j = 0; j < 8; j++) printf("%d ", seqsdb[i*8+j]->length); printf("\n"); // if (i % 10 == 0) printf("i %d\n", i); p7_oprofile_ReconfigRestLength(om, maxll); p7_ReconfigLength(gm2, maxll); // fazer Reconfig aqui para emular compl o VitStream for (j = 0; j < 8; j++) { // p7_ReconfigLength(gm2, seqsdb[i*8+j]->length); // p7_Viterbi_unilocal(seqsdb[i*8+j]->seq, seqsdb[i*8+j]->length, gm2, &sc3); // p7_Viterbi_unilocal_word(seqsdb[i*8+j]->seq, seqsdb[i*8+j]->length, gm2, &sc2); // p7_oprofile_ReconfigLength(om, seqsdb[i*8+j]->length); p7_ViterbiFilter(seqsdb[i*8+j]->seq, seqsdb[i*8+j]->length, om, ox, &sc2); //sumerrors += fabs(sc1[j]- sc2); if (fabs(results[i*8+j] - sc2) > 0.00001) { printf("%3d-%d L %4d: VS %f d %f\t| Base SerI %f\n", i, j, seqsdb[i*8+j]->length, results[i*8+j], fabs(results[i*8+j] - sc2), sc2); getc(stdin); } } } return 0; }
/***************************************************************************//** * @brief * Start a timer. * * @note * It is legal to start an already running timer. * * @param[in] id The id of the timer to start. * @param[in] type Timer type, oneshot or periodic. See @ref RTCDRV_TimerType_t. * @param[in] timeout Timeout expressed in milliseconds. If the timeout value * is 0, the callback function will be called immediately and * the timer will not be started. * @param[in] callback Function to call on timer expiry. See @ref * RTCDRV_Callback_t. NULL is a legal value. * @param[in] user Extra callback function parameter for user application. * * @return * @ref ECODE_EMDRV_RTCDRV_OK on success.@n * @ref ECODE_EMDRV_RTCDRV_ILLEGAL_TIMER_ID if id has an illegal value.@n * @ref ECODE_EMDRV_RTCDRV_TIMER_NOT_ALLOCATED if the timer is not reserved. ******************************************************************************/ Ecode_t RTCDRV_StartTimer( RTCDRV_TimerID_t id, RTCDRV_TimerType_t type, uint32_t timeout, RTCDRV_Callback_t callback, void *user ) { uint32_t timeElapsed, cnt, compVal, loopCnt = 0; uint32_t timeToNextTimerCompletion; // Check if valid timer ID. if ( id >= EMDRV_RTCDRV_NUM_TIMERS ) { return ECODE_EMDRV_RTCDRV_ILLEGAL_TIMER_ID; } INT_Disable(); if ( ! timer[ id ].allocated ) { INT_Enable(); return ECODE_EMDRV_RTCDRV_TIMER_NOT_ALLOCATED; } if ( timeout == 0 ) { if ( callback != NULL ) { callback( id, user ); } INT_Enable(); return ECODE_EMDRV_RTCDRV_OK; } cnt = RTC_COUNTERGET(); timer[ id ].callback = callback; timer[ id ].ticks = MSEC_TO_TICKS( timeout ); if (rtcdrvTimerTypePeriodic == type) { // Calculate compensation value for periodic timers. timer[ id ].periodicCompensationUsec = 1000 * timeout - (timer[ id ].ticks * TICK_TIME_USEC); timer[ id ].periodicDriftUsec = TICK_TIME_USEC/2; } else { // Compensate for the fact that CNT is normally COMP0+1 after a // compare match event on some devices. timer[ id ].ticks -= RTC_ONESHOT_TICK_ADJUST; } // Add one tick in order to compensate if RTC is close to an increment event. timer[ id ].remaining = timer[ id ].ticks + 1; timer[ id ].running = true; timer[ id ].timerType = type; timer[ id ].user = user; if ( inTimerIRQ == true ) { // Exit now, remaining processing will be done in IRQ handler. INT_Enable(); return ECODE_EMDRV_RTCDRV_OK; } // StartTimer() may recurse, keep track of recursion level. if ( startTimerNestingLevel < UINT32_MAX ) { startTimerNestingLevel++; } if ( rtcRunning == false ) { #if defined( RTCDRV_USE_RTC ) lastStart = ( cnt ) & RTC_COUNTER_MASK; #elif defined( RTCDRV_USE_RTCC ) lastStart = cnt; #endif RTC_INTCLEAR( RTC_COMP_INT ); compVal = SL_MIN( timer[ id ].remaining, RTC_CLOSE_TO_MAX_VALUE ); RTC_COMPARESET( cnt + compVal ); // Start the timer system by enabling the compare interrupt. RTC_INTENABLE( RTC_COMP_INT ); #if defined( EMODE_DYNAMIC ) // When RTC is running, we can not allow EM3 or EM4. if ( sleepBlocked == false ) { sleepBlocked = true; SLEEP_SleepBlockBegin( sleepEM3 ); } #endif rtcRunning = true; } else { // The timer system is running. We must stop, update timers with the time // elapsed so far, find the timer with the shortest timeout and then restart. // As StartTimer() may be called from the callbacks we only do this // processing at the first nesting level. if ( startTimerNestingLevel == 1 ) { timer[ id ].running = false; // This loop is repeated if CNT is incremented while processing. do { RTC_INTDISABLE( RTC_COMP_INT ); timeElapsed = TIMEDIFF( cnt, lastStart ); #if defined( RTCDRV_USE_RTC ) // Compensate for the fact that CNT is normally COMP0+1 after a // compare match event. if ( timeElapsed == RTC_MAX_VALUE ) { timeElapsed = 0; } #endif // Update all timers with elapsed time. checkAllTimers( timeElapsed ); // Execute timer callbacks. executeTimerCallbacks(); // Set timer to running only after checkAllTimers() is called once. if ( loopCnt == 0 ) { timer[ id ].running = true; } loopCnt++; // Restart RTC according to next timeout. rescheduleRtc( cnt ); cnt = RTC_COUNTERGET(); timeElapsed = TIMEDIFF( cnt, lastStart ); timeToNextTimerCompletion = TIMEDIFF( RTC_COMPAREGET(), lastStart ); /* If the counter has passed the COMP(ARE) register value since we checked the timers, then we should recheck the timers and reschedule again. */ } while ( rtcRunning && (timeElapsed > timeToNextTimerCompletion)); } } if ( startTimerNestingLevel > 0 ) { startTimerNestingLevel--; } INT_Enable(); return ECODE_EMDRV_RTCDRV_OK; }
int main(int argc, char **argv) { ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 2, argc, argv, banner, usage); char *hmmfile = esl_opt_GetArg(go, 1); char *seqfile = esl_opt_GetArg(go, 2); ESL_STOPWATCH *w = esl_stopwatch_Create(); ESL_RANDOMNESS*r = esl_randomness_Create(esl_opt_GetInteger(go, "-s")); ESL_ALPHABET*abc = NULL; P7_HMMFILE *hfp = NULL; P7_HMM *hmm = NULL; P7_BG *bg = NULL; P7_PROFILE *gm1, *gm2; int L = esl_opt_GetInteger(go, "-L"); int N = esl_opt_GetInteger(go, "-N") / SSE16_NVALS; int MaxPart = esl_opt_GetInteger(go, "-M"); int NROUNDS = esl_opt_GetInteger(go, "-R"); int check = esl_opt_GetBoolean(go, "-c"); __m128 resdata[10]; int i, j; float *sc1 = (float*) resdata; ESL_SQFILE *sqfp = NULL; DATA_COPS16 *dcops; struct timeb tbstart, tbend; int sumlengths = 0; float* results = NULL; srand(time(NULL)); if (p7_hmmfile_Open(hmmfile, NULL, &hfp) != eslOK) p7_Fail("Failed to open HMM file %s", hmmfile); if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("Failed to read HMM"); bg = p7_bg_Create(abc); p7_bg_SetLength(bg, L); gm1 = p7_profile_Create(hmm->M, abc); gm2 = p7_profile_Create(hmm->M, abc); p7_ProfileConfig(hmm, bg, gm1, L, p7_UNILOCAL); p7_ProfileConfig(hmm, bg, gm2, L, p7_UNILOCAL); dcops = p7_ViterbiCOPSw_Create(gm1); p7_ViterbiCOPSW_Setup(dcops, L+100, MaxPart); // use max L dcops->L = L; int dbsize = SSE16_NVALS*N; SEQ **seqsdb= calloc(dbsize+1, sizeof(SEQ*)); int equallength = 1; if (esl_sqfile_OpenDigital(abc, seqfile, eslSQFILE_FASTA, NULL, &sqfp) == eslOK) { // Use Sequence file ESL_SQ* sq = esl_sq_CreateDigital(abc); int maxseqs, len=0; if (esl_opt_IsDefault(go, "-N")) // N not specified in cmdline maxseqs = INT_MAX; // no limit else maxseqs = SSE16_NVALS*N; // use cmdline limit for (j = 0; j < maxseqs && esl_sqio_Read(sqfp, sq) == eslOK; j++) { if (equallength && sq->n != len && j > 0) equallength = 0; len = sq->n; if (j > dbsize) { seqsdb = realloc(seqsdb, 2*(dbsize+1)*sizeof(SEQ*)); dbsize *= 2; } ESL_DSQ* dsq = sq->dsq; seqsdb[j] = malloc(sizeof(SEQ)); seqsdb[j]->length = len; seqsdb[j]->seq = malloc((len+4)*sizeof(ESL_DSQ)); memcpy(seqsdb[j]->seq, dsq, len+2); sumlengths += len; esl_sq_Reuse(sq); } N = j/SSE16_NVALS; } else // Not found database. Generate random sequences for (i = 0; i < N; i++) for (j = 0; j < SSE16_NVALS; j++) { int len = L; // - rand()%1000; seqsdb[i*SSE16_NVALS+j] = malloc(sizeof(SEQ)); seqsdb[i*SSE16_NVALS+j]->seq = malloc(len+4); seqsdb[i*SSE16_NVALS+j]->length = len; esl_rsq_xfIID(r, bg->f, abc->K, len, seqsdb[i*SSE16_NVALS+j]->seq); sumlengths += len; } printf("Viterbi COPS Word with %d threads, model %s. ModelLen: %d, #Segms: %d, SeqL.: %d, #seqs: %d, Partition: %d, #parts: %d\n", NTHREADS, hmmfile, gm1->M, (int) ceil(gm1->M/SSE16_NVALS), L, SSE16_NVALS*N*NROUNDS, dcops->partition, dcops->Npartitions); /* // No. of partitions computed without full parallelism ( == no. of threads active while some are idle) int Niters_part = dcops->Npartitions % NTHREADS; // No. of Model lines that could be computed but are wasted by idle threads waiting on the end int Nwasted_threads = dcops->partition * ((NTHREADS-Niters_part) % NTHREADS); // No. of lines in the last partition that go beyond M. It's wasted comp time by a single thread int Nwasted_leftover= (dcops->partition - gm1->M % dcops->partition) % dcops->partition; // Total number of wasted lines int wastedcomp = Nwasted_threads + Nwasted_leftover; // Total number of lines computed and waited for int totalcomp = wastedcomp + gm1->M; // same as: roundtop(gm1->M, dcops->partition * NTHREADS); printf("Total Comp Lines: %d | Wasted Comp Lines: %d\n", totalcomp, wastedcomp); */ if (check) results = (float*) alloc_m128_aligned64((N+1)*2); ftime(&tbstart); if (!equallength) { // Sort sequences by length qsort(seqsdb, N*SSE16_NVALS, sizeof(SEQ*), compare_seqs); } for (j = 0; j < NROUNDS; j++) for (i = 0; i < N; i++) { // if (i % 1000 == 0) printf("Seq %d\n", i); p7_ViterbiCOPSw_run(dcops, seqsdb+i*SSE16_NVALS, sc1); if (check) memcpy(results+i*SSE16_NVALS, sc1, 32); // 32 bytes indeed! SSE16_NVALS floats } ftime(&tbend); double secs = TIMEDIFF(tbstart,tbend); w->elapsed = w->user = secs; esl_stopwatch_Display(stdout, w, "# Opt CPU time: "); double compmillioncells = NROUNDS * (double) sumlengths * (double) hmm->M * 1e-6; printf("# %.0fM cells in %.1f Mc/s\n", compmillioncells, compmillioncells / secs); if (check) { P7_OPROFILE *om = p7_oprofile_Create(hmm->M, gm1->abc); p7_oprofile_Convert(gm1, om); P7_OMX *ox = p7_omx_Create(hmm->M, 0, 0); printf("Compare results against base version\n"); for (i = 0; i < N; i++) { int maxll = 0; float sc2; for (j = 0; j < SSE16_NVALS; j++) if (maxll < seqsdb[i*SSE16_NVALS+j]->length) maxll = seqsdb[i*SSE16_NVALS+j]->length; p7_oprofile_ReconfigRestLength(om, maxll); // p7_ReconfigLength(gm2, maxll); // emulate the lock-step inter-sequence reconfigs for (j = 0; j < SSE16_NVALS; j++) { // p7_ReconfigLength(gm2, seqsdb[i*SSE16_NVALS+j]->length); // p7_Viterbi_unilocal(seqsdb[i*SSE16_NVALS+j]->seq, seqsdb[i*SSE16_NVALS+j]->length, gm2, &sc3); // p7_Viterbi_unilocal_word(seqsdb[i*SSE16_NVALS+j]->seq, seqsdb[i*SSE16_NVALS+j]->length, gm2, &sc2); // p7_oprofile_ReconfigLength(om, seqsdb[i*SSE16_NVALS+j]->length); p7_ViterbiFilter(seqsdb[i*SSE16_NVALS+j]->seq, seqsdb[i*SSE16_NVALS+j]->length, om, ox, &sc2); sc2 += 1.0; // -2.0nat optimization, Local to Unilocal mode if (fabs(results[i*SSE16_NVALS+j] - sc2) > 0.0001) { printf("Seq %d Len %4d: %f - %f\tdiff: %f\n", i*SSE16_NVALS+j, seqsdb[i*SSE16_NVALS+j]->length, results[i*SSE16_NVALS+j], sc2, fabs(results[i*SSE16_NVALS+j] - sc2)); } } } } return 0; }
void GCTimer::finish(bool lastGC) { end = PRMJ_Now(); if (startMark > 0) { if (JS_WANT_GC_SUITE_PRINT) { fprintf(stderr, "%f %f %f\n", TIMEDIFF(enter, end), TIMEDIFF(startMark, startSweep), TIMEDIFF(startSweep, sweepDestroyEnd)); } else { static FILE *gcFile; if (!gcFile) { gcFile = fopen("gcTimer.dat", "a"); fprintf(gcFile, " AppTime, Total, Wait, Mark, Sweep, FinObj,"); fprintf(gcFile, " FinStr, SwShapes, Destroy, End, +Chu, -Chu\n"); } JS_ASSERT(gcFile); /* App , Tot , Wai , Mar , Swe , FiO , FiS , SwS , Des , End */ fprintf(gcFile, "%12.0f, %6.1f, %6.1f, %6.1f, %6.1f, %6.1f, %6.1f, %8.1f, %6.1f, %6.1f, ", TIMEDIFF(getFirstEnter(), enter), TIMEDIFF(enter, end), TIMEDIFF(enter, startMark), TIMEDIFF(startMark, startSweep), TIMEDIFF(startSweep, sweepDestroyEnd), TIMEDIFF(startSweep, sweepObjectEnd), TIMEDIFF(sweepObjectEnd, sweepStringEnd), TIMEDIFF(sweepStringEnd, sweepShapeEnd), TIMEDIFF(sweepShapeEnd, sweepDestroyEnd), TIMEDIFF(sweepDestroyEnd, end)); fprintf(gcFile, "%4d, %4d\n", newChunkCount, destroyChunkCount); fflush(gcFile); if (lastGC) { fclose(gcFile); gcFile = NULL; } } } newChunkCount = 0; destroyChunkCount = 0; }
int main(int argc, char *argv[]) { int rc; srv_addr.sin_family = AF_INET; srv_addr.sin_port = htons(LISTEN_PORT); const char *hostname = (argc > 1) ? argv[1] : HOST; struct hostent *hp = gethostbyname(hostname); if (hp == NULL) { printf("Failed to lookup hostname %s\n", HOST); exit(-1); } memcpy(&srv_addr.sin_addr, hp->h_addr, hp->h_length); struct th_arg args; #ifdef NOMULTISOCK shared_sock = socket(PF_INET, SOCK_STREAM, 0); #else shared_sock = cmm_socket(PF_INET, SOCK_STREAM, 0); #endif if (shared_sock < 0) { perror("socket"); exit(-1); } rc = srv_connect(hostname, CMM_LABEL_ONDEMAND); if (rc < 0) { #ifndef NOMULTISOCK if (rc == CMM_DEFERRED) { printf("Initial connection deferred\n"); } else #endif { printf("Initial connection failed!\n"); #ifdef NOMULTISOCK close(shared_sock); #else cmm_close(shared_sock); #endif exit(-1); } } running = true; signal(SIGINT, handle_term); signal(SIGPIPE, SIG_IGN); pthread_t tid; rc = pthread_create(&tid, NULL, (void *(*)(void*)) BackgroundPing, &args); if (rc < 0) { printf("Failed to start background thread\n"); } while (running) { struct th_arg *new_args = args.clone(); if (!fgets(new_args->ch.data, sizeof(new_args->ch) - 1, stdin)) { if (errno == EINTR) { //printf("interrupted; trying again\n"); continue; } else { printf("fgets failed!\n"); running = false; break; } } PthreadScopedLock lock(&socket_lock); printf("Attempting to send message\n"); struct timeval begin, end, diff; TIME(begin); #ifdef NOMULTISOCK rc = send(shared_sock, new_args->ch.data, sizeof(new_args->ch), 0); #else rc = cmm_send(shared_sock, new_args->ch.data, sizeof(new_args->ch), 0, CMM_LABEL_ONDEMAND, (resume_handler_t)resume_ondemand, new_args); if (rc == CMM_DEFERRED) { printf("Deferred\n"); } else #endif if (rc < 0) { perror("send"); break; } else { delete new_args; TIME(end); TIMEDIFF(begin, end, diff); printf("[%lu.%06lu][testapp] ...message sent, took %lu.%06lu seconds\n", end.tv_sec, end.tv_usec, diff.tv_sec, diff.tv_usec); rc = get_reply(shared_sock); if (rc < 0) { break; } struct timeval reply_end; TIME(reply_end); TIMEDIFF(begin, reply_end, diff); printf("Send-and-receive time: %lu.%06lu seconds\n", diff.tv_sec, diff.tv_usec); } } #ifdef NOMULTISOCK shutdown(shared_sock, SHUT_RDWR); #else cmm_shutdown(shared_sock, SHUT_RDWR); #endif pthread_join(tid, NULL); #ifdef NOMULTISOCK close(shared_sock); #else cmm_close(shared_sock); #endif return 0; }