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;
}
