static int serial_loop(WORKER_INFO *info, struct cfg_s *cfg) { P7_BUILDER *bld = NULL; ESL_MSA *msa = NULL; ESL_MSA *postmsa = NULL; ESL_MSA **postmsa_ptr = (cfg->postmsafile != NULL) ? &postmsa : NULL; P7_HMM *hmm = NULL; char errmsg[eslERRBUFSIZE]; int status; double entropy; cfg->nali = 0; while ((status = esl_msa_Read(cfg->afp, &msa)) == eslOK) { cfg->nali++; if ((status = set_msa_name(cfg, errmsg, msa)) != eslOK) p7_Fail("%s\n", errmsg); /* cfg->nnamed gets incremented in this call */ /* bg new-HMM trarr gm om */ if ((status = p7_Builder(info->bld, msa, info->bg, &hmm, NULL, NULL, NULL, postmsa_ptr)) != eslOK) p7_Fail("build failed: %s", bld->errbuf); entropy = p7_MeanMatchRelativeEntropy(hmm, info->bg); if ((status = output_result(cfg, errmsg, cfg->nali, msa, hmm, postmsa, entropy)) != eslOK) p7_Fail(errmsg); p7_hmm_Destroy(hmm); esl_msa_Destroy(msa); esl_msa_Destroy(postmsa); } return status; }
static void pipeline_thread(void *arg) { int workeridx; int status; WORK_ITEM *item; void *newItem; WORKER_INFO *info; ESL_THREADS *obj; obj = (ESL_THREADS *) arg; esl_threads_Started(obj, &workeridx); info = (WORKER_INFO *) esl_threads_GetData(obj, workeridx); status = esl_workqueue_WorkerUpdate(info->queue, NULL, &newItem); if (status != eslOK) esl_fatal("Work queue worker failed"); /* loop until all blocks have been processed */ item = (WORK_ITEM *) newItem; while (item->msa != NULL) { status = p7_Builder(info->bld, item->msa, info->bg, &item->hmm, NULL, NULL, NULL, &item->postmsa); if (status != eslOK) p7_Fail("build failed: %s", info->bld->errbuf); item->entropy = p7_MeanMatchRelativeEntropy(item->hmm, info->bg); item->processed = TRUE; status = esl_workqueue_WorkerUpdate(info->queue, item, &newItem); if (status != eslOK) esl_fatal("Work queue worker failed"); item = (WORK_ITEM *) newItem; } status = esl_workqueue_WorkerUpdate(info->queue, item, NULL); if (status != eslOK) esl_fatal("Work queue worker failed"); esl_threads_Finished(obj, workeridx); return; }
/* if error occurs we return hmms that are already created, so caller should delete them anyway Note, that we do not destroy hmm->abc here, caller should delete it too. Don't worry, on exception we'll catch it here */ P7_HMM * UHMM3Build::build( const MAlignment & malignment, const UHMM3BuildSettings & settings ,TaskStateInfo & ti ) { ESL_ALPHABET* abc = NULL; P7_BG* bg = NULL; P7_BUILDER* bld = NULL; ESL_MSA* msa = NULL; P7_HMM* hmm = NULL; QByteArray errStr; ti.progress = 0; try { int alType = UHMM3Utilities::convertAlphabetType( malignment.getAlphabet() ); if( UHMM3Utilities::BAD_ALPHABET == alType ) { errStr = tr( "UGENE cannot determine alphabet of alignment" ).toLatin1(); throwUHMMER3Exception( errStr.data() ); } ESL_ALPHABET* abc = esl_alphabet_Create( alType ); if( NULL == abc ) { errStr = tr( "Run out of memory (creating alphabet failed)" ).toLatin1(); throwUHMMER3Exception( errStr.data() ); } P7_BG* bg = p7_bg_Create( abc ); if( NULL == bg ) { errStr = tr( "Run out of memory (creating null model failed)" ).toLatin1(); throwUHMMER3Exception( errStr.data() ); } P7_BUILDER* bld = p7_builder_Create( &settings, abc ); if( NULL == bld ) { errStr = tr( "Run out of memory (creating builder failed)" ).toLatin1(); throwUHMMER3Exception( errStr.data() ); } ESL_MSA* msa = UHMM3Utilities::convertMSA( malignment ); if( NULL == msa ) { errStr = tr( "Run out of memory (creating multiple alignment failed)" ).toLatin1(); throwUHMMER3Exception( errStr.data() ); } int ret = esl_msa_Digitize( abc, msa, NULL ); if( eslOK != ret ) { errStr = tr( "Run out of memory (digitizing of alignment failed)" ).toLatin1(); throwUHMMER3Exception( errStr.data() ); } ret = p7_Builder( bld, msa, bg, &hmm, NULL, NULL, NULL, NULL, ti ); if ( eslOK != ret ) { if( eslCANCELED == ret ) { errStr = tr( HMMER3_CANCELED_ERROR ).toLatin1(); } else { errStr = tr( "Model building failed" ).toLatin1(); } assert( !errStr.isEmpty() ); throwUHMMER3Exception( errStr.data() ); } destoryAllIfYouCan( abc, bg, bld, msa, NULL ); } catch( const UHMMER3Exception& ex ) { ti.setError( ex.msg ); destoryAllIfYouCan( abc, bg, bld, msa, hmm ); return NULL; } catch(...) { ti.setError( tr( HMMER3_UNKNOWN_ERROR ) ); destoryAllIfYouCan( abc, bg, bld, msa, hmm ); return NULL; } return hmm; }
static void mpi_worker(const ESL_GETOPTS *go, struct cfg_s *cfg) { int xstatus = eslOK; int status; int type; P7_BUILDER *bld = NULL; ESL_MSA *msa = NULL; ESL_MSA *postmsa = NULL; ESL_MSA **postmsa_ptr = (cfg->postmsafile != NULL) ? &postmsa : NULL; P7_HMM *hmm = NULL; P7_BG *bg = NULL; char *wbuf = NULL; /* packed send/recv buffer */ void *tmp; /* for reallocation of wbuf */ int wn = 0; /* allocation size for wbuf */ int sz, n; /* size of a packed message */ int pos; char errmsg[eslERRBUFSIZE]; /* After master initialization: master broadcasts its status. */ MPI_Bcast(&xstatus, 1, MPI_INT, 0, MPI_COMM_WORLD); if (xstatus != eslOK) return; /* master saw an error code; workers do an immediate normal shutdown. */ ESL_DPRINTF2(("worker %d: sees that master has initialized\n", cfg->my_rank)); /* Master now broadcasts worker initialization information (alphabet type) * Workers returns their status post-initialization. * Initial allocation of wbuf must be large enough to guarantee that * we can pack an error result into it, because after initialization, * errors will be returned as packed (code, errmsg) messages. */ MPI_Bcast(&type, 1, MPI_INT, 0, MPI_COMM_WORLD); if (xstatus == eslOK) { if ((cfg->abc = esl_alphabet_Create(type)) == NULL) xstatus = eslEMEM; } if (xstatus == eslOK) { wn = 4096; if ((wbuf = malloc(wn * sizeof(char))) == NULL) xstatus = eslEMEM; } if (xstatus == eslOK) { if ((bld = p7_builder_Create(go, cfg->abc)) == NULL) xstatus = eslEMEM; } MPI_Reduce(&xstatus, &status, 1, MPI_INT, MPI_MAX, 0, MPI_COMM_WORLD); /* everyone sends xstatus back to master */ if (xstatus != eslOK) { if (wbuf != NULL) free(wbuf); if (bld != NULL) p7_builder_Destroy(bld); return; /* shutdown; we passed the error back for the master to deal with. */ } bg = p7_bg_Create(cfg->abc); ESL_DPRINTF2(("worker %d: initialized\n", cfg->my_rank)); /* source = 0 (master); tag = 0 */ while (esl_msa_MPIRecv(0, 0, MPI_COMM_WORLD, cfg->abc, &wbuf, &wn, &msa) == eslOK) { /* Build the HMM */ ESL_DPRINTF2(("worker %d: has received MSA %s (%d columns, %d seqs)\n", cfg->my_rank, msa->name, msa->alen, msa->nseq)); if ((status = p7_Builder(bld, msa, bg, &hmm, NULL, NULL, NULL, postmsa_ptr)) != eslOK) { strcpy(errmsg, bld->errbuf); goto ERROR; } ESL_DPRINTF2(("worker %d: has produced an HMM %s\n", cfg->my_rank, hmm->name)); /* Calculate upper bound on size of sending status, HMM, and optional postmsa; make sure wbuf can hold it. */ n = 0; if (MPI_Pack_size(1, MPI_INT, MPI_COMM_WORLD, &sz) != 0) goto ERROR; n += sz; if (p7_hmm_MPIPackSize( hmm, MPI_COMM_WORLD, &sz) != eslOK) goto ERROR; n += sz; if (esl_msa_MPIPackSize(postmsa, MPI_COMM_WORLD, &sz) != eslOK) goto ERROR; n += sz; if (n > wn) { ESL_RALLOC(wbuf, tmp, sizeof(char) * n); wn = n; } ESL_DPRINTF2(("worker %d: has calculated that HMM will pack into %d bytes\n", cfg->my_rank, n)); /* Send status, HMM, and optional postmsa back to the master */ pos = 0; if (MPI_Pack (&status, 1, MPI_INT, wbuf, wn, &pos, MPI_COMM_WORLD) != 0) goto ERROR; if (p7_hmm_MPIPack (hmm, wbuf, wn, &pos, MPI_COMM_WORLD) != eslOK) goto ERROR; if (esl_msa_MPIPack(postmsa, wbuf, wn, &pos, MPI_COMM_WORLD) != eslOK) goto ERROR; MPI_Send(wbuf, pos, MPI_PACKED, 0, 0, MPI_COMM_WORLD); ESL_DPRINTF2(("worker %d: has sent HMM to master in message of %d bytes\n", cfg->my_rank, pos)); esl_msa_Destroy(msa); msa = NULL; esl_msa_Destroy(postmsa); postmsa = NULL; p7_hmm_Destroy(hmm); hmm = NULL; } if (wbuf != NULL) free(wbuf); p7_builder_Destroy(bld); return; ERROR: ESL_DPRINTF2(("worker %d: fails, is sending an error message, as follows:\n%s\n", cfg->my_rank, errmsg)); pos = 0; MPI_Pack(&status, 1, MPI_INT, wbuf, wn, &pos, MPI_COMM_WORLD); MPI_Pack(errmsg, eslERRBUFSIZE, MPI_CHAR, wbuf, wn, &pos, MPI_COMM_WORLD); MPI_Send(wbuf, pos, MPI_PACKED, 0, 0, MPI_COMM_WORLD); if (wbuf != NULL) free(wbuf); if (msa != NULL) esl_msa_Destroy(msa); if (hmm != NULL) p7_hmm_Destroy(hmm); if (bld != NULL) p7_builder_Destroy(bld); return; }
P7_HMM * constructHMM(ESL_MSA *msa, ESL_ALPHABET *abc, int ali_hmm, int frag, P7_HMM **ret_hmm, char *errbuf){ int status; ESL_GETOPTS *go = esl_getopts_Create(options); P7_BUILDER *bld = NULL; P7_BG *bg = NULL; char *args = NULL; esl_strcat(&args, -1, "X ", -1); status = esl_msa_SetName(msa, "Query", -1); /* Now take this alignment and make an HMM from it */ if(status != eslOK){ ESL_XFAIL(status, errbuf, "Easel MSA SetNAME returned an error %d\n", status); } bg = p7_bg_Create(abc); if(bg == NULL){ ESL_XFAIL(status, errbuf, "Error generating bg\n"); } if (frag == 1) { // add --fragthresh 0 esl_strcat(&args, -1, "--fragthresh 0 ", -1); } // if these flags are set, then we want a non standard hmm out. Used by the logo server. if (ali_hmm == 1) { // observed counts // arguments "X --pnone --wnone --enone" esl_strcat(&args, -1, "--pnone --wnone --enone --symfrac 0 ", -1); } else if (ali_hmm == 2) { // weighted counts // arguments "X --pnone"); esl_strcat(&args, -1, "--pnone --symfrac 0 ", -1); } else if (ali_hmm == 3) { // Create HMM - keep all columns esl_strcat(&args, -1, "--symfrac 0 ", -1); } else { // no arguments ? } // pass in arguments to hmm builder esl_opt_ProcessSpoof(go, args); if (args != NULL) free(args); bld = p7_builder_Create(go, abc); if(bld == NULL){ ESL_XFAIL(eslEMEM, errbuf, "Error creating builder\n"); } status = p7_Builder(bld, msa, bg, ret_hmm, NULL, NULL, NULL, NULL); if (status != eslOK) { strcpy( errbuf, bld->errbuf ); goto ERROR; } p7_bg_Destroy(bg); p7_builder_Destroy(bld); esl_getopts_Destroy(go); return status; ERROR: if (bg != NULL) p7_bg_Destroy(bg); if (bld != NULL) p7_builder_Destroy(bld); if (go != NULL) esl_getopts_Destroy(go); return status; }