int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_STOPWATCH *w = esl_stopwatch_Create();
int N = esl_opt_GetInteger(go, "-N");
float origx = 2.0;
float x = origx;
__m128 xv = _mm_set1_ps(x);
int i;
/* First, serial time. */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++) { x = logf(x); x = expf(x); }
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# serial CPU time: ");
/* Vector time */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++) { xv = esl_sse_logf(xv); xv = esl_sse_expf(xv); }
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# vector CPU time: ");
/* If you don't do something with x and xv, the compiler may optimize them away */
printf("%g => many scalar logf,expf cycles => %g\n", origx, x);
printf("%g => many vector logf,expf cycles => ", origx);
esl_sse_dump_ps(stdout, xv); printf("\n");
esl_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_GMX *gx1 = NULL;
P7_GMX *gx2 = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
float null2[p7_MAXCODE];
int i;
float fsc, bsc;
double Mcs;
if (p7_hmmfile_OpenE(hmmfile, NULL, &hfp, NULL) != 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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
gx1 = p7_gmx_Create(gm->M, L);
gx2 = p7_gmx_Create(gm->M, L);
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_GForward (dsq, L, gm, gx1, &fsc);
p7_GBackward(dsq, L, gm, gx2, &bsc);
p7_GDecoding(gm, gx1, gx2, gx2);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
p7_GNull2_ByExpectation(gm, gx2, null2);
esl_stopwatch_Stop(w);
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / w->user;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_gmx_Destroy(gx1);
p7_gmx_Destroy(gx2);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
ESL_STOPWATCH *w = esl_stopwatch_Create();
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
int i;
/* Read one HMM from <hmmfile> */
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");
p7_hmmfile_Close(hfp);
bg = p7_bg_Create(abc);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
p7_bg_SetFilterByHMM(bg, hmm);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
int N = esl_opt_GetInteger(go, "-N");
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
if (p7_hmmfile_OpenE(hmmfile, NULL, &hfp, NULL) != eslOK) p7_Fail("Failed to open HMM file %s", hmmfile);
if (p7_hmmfile_Read(hfp, &abc, &hmm) != eslOK) p7_Fail("Failed to read HMM");
p7_hmmfile_Close(hfp);
esl_stopwatch_Start(w);
while (N--)
{ /* cfg rng bg gm om */
p7_Calibrate(hmm, NULL, NULL, NULL, NULL, NULL);
}
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
ESL_STOPWATCH *w = esl_stopwatch_Create();
char *hmmfile = esl_opt_GetArg(go, 1);
P7_HMMCACHE *hcache = NULL;
char errbuf[eslERRBUFSIZE];
size_t tot_mem;
int status;
esl_stopwatch_Start(w);
status = p7_hmmcache_Open(hmmfile, &hcache, errbuf);
if (status == eslENOTFOUND) p7_Fail("Failed to read %s\n %s\n", hmmfile, errbuf);
else if (status == eslEFORMAT) p7_Fail("Failed to parse %s\n %s\n", hmmfile, errbuf);
else if (status == eslEINCOMPAT) p7_Fail("Mixed profile types in %s\n %s\n", hmmfile, errbuf);
else if (status != eslOK) p7_Fail("Failed to cache %s: error code %d\n", hmmfile, status);
p7_hmmcache_SetNumericNames(hcache);
tot_mem = p7_hmmcache_Sizeof(hcache);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("models = %d\n", hcache->n);
printf("tot memory = %" PRIu64 "\n", (uint64_t) tot_mem);
p7_hmmcache_Close(hcache);
esl_getopts_Destroy(go);
esl_stopwatch_Destroy(w);
return 0;
}
int
main(void)
{
ESL_STOPWATCH *w = NULL;
ESL_DMATRIX *Q = NULL;
ESL_DMATRIX *P = NULL;
double t = 5.0;
int esl_iterations = 100;
int i;
#ifdef HAVE_LIBGSL
gsl_matrix *Qg = NULL;
gsl_matrix *Pg = NULL;
int gsl_iterations = 100;
#endif
w = esl_stopwatch_Create();
Q = esl_dmatrix_Create(20, 20);
P = esl_dmatrix_Create(20, 20);
esl_rmx_SetWAG(Q, NULL);
esl_stopwatch_Start(w);
for (i = 0; i < esl_iterations; i++)
esl_dmx_Exp(Q, t, P);
esl_stopwatch_Stop(w);
printf("Easel takes: %g sec\n", w->user / (double) esl_iterations);
#ifdef HAVE_LIBGSL
if (esl_dmx_MorphGSL(Q, &Qg) != eslOK) esl_fatal("morph to gsl_matrix failed");
if ((Pg = gsl_matrix_alloc(20, 20)) == NULL) esl_fatal("gsl alloc failed");
gsl_matrix_scale(Qg, t);
esl_stopwatch_Start(w);
for (i = 0; i < gsl_iterations; i++)
gsl_linalg_exponential_ss(Qg, Pg, GSL_PREC_DOUBLE);
esl_stopwatch_Stop(w);
printf(" GSL takes: %g sec\n", w->user / (double) gsl_iterations);
gsl_matrix_free(Qg);
gsl_matrix_free(Pg);
#endif /*HAVE_LIBGSL*/
esl_dmatrix_Destroy(Q);
esl_dmatrix_Destroy(P);
esl_stopwatch_Destroy(w);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_STOPWATCH *w = esl_stopwatch_Create();
int N = esl_opt_GetInteger(go, "-N");
int i;
float *A, *B, *C;
p7_FLogsumInit();
/* Create the problem: sample N values A,B on interval -1000,1000: about the range of H3 scores */
A = malloc(sizeof(float) * N);
B = malloc(sizeof(float) * N);
C = malloc(sizeof(float) * N);
for (i = 0; i < N; i++)
{
A[i] = esl_random(r) * 2000. - 1000.;
B[i] = esl_random(r) * 2000. - 1000.;
}
/* Run */
esl_stopwatch_Start(w);
if (esl_opt_GetBoolean(go, "-n"))
{
for (i = 0; i < N; i++)
C[i] = naive2(A[i], B[i]);
}
else if (esl_opt_GetBoolean(go, "-r"))
{
for (i = 0; i < N; i++)
C[i] = naive1(A[i], B[i]);
}
else
{
for (i = 0; i < N; i++)
C[i] = p7_FLogsum(A[i], B[i]);
}
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(void)
{
ESL_STOPWATCH *w;
w = esl_stopwatch_Create();
esl_stopwatch_Start(w);
sleep(5);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "CPU Time: ");
esl_stopwatch_Destroy(w);
return 0;
}
/* The LogGamma() function is rate-limiting in hmmbuild, because it is
* used so heavily in mixture Dirichlet calculations.
* ./configure --with-gsl; [compile test driver]
* ./stats_utest -v
* runs a comparison of time/precision against GSL.
* SRE, Sat May 23 10:04:41 2009, on home Mac:
* LogGamma = 1.29u / N=1e8 = 13 nsec/call
* gsl_sf_lngamma = 1.43u / N=1e8 = 14 nsec/call
*/
static void
utest_LogGamma(ESL_RANDOMNESS *r, int N, int be_verbose)
{
char *msg = "esl_stats_LogGamma() unit test failed";
ESL_STOPWATCH *w = esl_stopwatch_Create();
double *x = malloc(sizeof(double) * N);
double *lg = malloc(sizeof(double) * N);
double *lg2 = malloc(sizeof(double) * N);
int i;
for (i = 0; i < N; i++)
x[i] = esl_random(r) * 100.;
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
if (esl_stats_LogGamma(x[i], &(lg[i])) != eslOK) esl_fatal(msg);
esl_stopwatch_Stop(w);
if (be_verbose) esl_stopwatch_Display(stdout, w, "esl_stats_LogGamma() timing: ");
#ifdef HAVE_LIBGSL
esl_stopwatch_Start(w);
for (i = 0; i < N; i++) lg2[i] = gsl_sf_lngamma(x[i]);
esl_stopwatch_Stop(w);
if (be_verbose) esl_stopwatch_Display(stdout, w, "gsl_sf_lngamma() timing: ");
for (i = 0; i < N; i++)
if (esl_DCompare(lg[i], lg2[i], 1e-2) != eslOK) esl_fatal(msg);
#endif
free(lg2);
free(lg);
free(x);
esl_stopwatch_Destroy(w);
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RECORDER *rc = NULL;
char *filename = esl_opt_GetArg(go, 1);
int N = esl_opt_GetInteger(go, "-N");
FILE *fp = NULL;
char *buf = NULL;
int balloc = 0;
int status;
if ((fp = fopen(filename, "r")) == NULL) esl_fatal("no such file %s\n", filename);
rc = esl_recorder_Create(fp, N);
esl_stopwatch_Start(w);
while ((status = esl_recorder_Read(rc, &buf)) == eslOK);
esl_recorder_Destroy(rc);
fclose(fp);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "recorder time: ");
if ((fp = fopen(filename, "r")) == NULL) esl_fatal("no such file %s\n", filename);
esl_stopwatch_Start(w);
while ((status = esl_fgets(&buf, &balloc, fp)) == eslOK);
free(buf);
fclose(fp);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "esl_fgets() time: ");
esl_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_ALPHABET *abc = NULL;
char *hmmfile = esl_opt_GetArg(go, 1);
P7_HMMFILE *hfp = NULL;
P7_OPROFILE *om = NULL;
int nmodel = 0;
uint64_t totM = 0;
int status;
char errbuf[eslERRBUFSIZE];
esl_stopwatch_Start(w);
status = p7_hmmfile_OpenE(hmmfile, NULL, &hfp, errbuf);
if (status == eslENOTFOUND) p7_Fail("File existence/permissions problem in trying to open HMM file %s.\n%s\n", hmmfile, errbuf);
else if (status == eslEFORMAT) p7_Fail("File format problem in trying to open HMM file %s.\n%s\n", hmmfile, errbuf);
else if (status != eslOK) p7_Fail("Unexpected error %d in opening HMM file %s.\n%s\n", status, hmmfile, errbuf);
while ((status = p7_oprofile_ReadMSV(hfp, &abc, &om)) == eslOK)
{
nmodel++;
totM += om->M;
p7_oprofile_Destroy(om);
}
if (status == eslEFORMAT) p7_Fail("bad file format in profile file %s", hmmfile);
else if (status == eslEINCOMPAT) p7_Fail("profile file %s contains different alphabets", hmmfile);
else if (status != eslEOF) p7_Fail("Unexpected error in reading profiles from %s", hmmfile);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# number of models: %d\n", nmodel);
printf("# total M: %" PRId64 "\n", totM);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
int i;
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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
p7_oprofile_Convert(gm, om);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_ALPHABET *abc = NULL;
char *msvfile = esl_opt_GetArg(go, 1);
FILE *msvfp = NULL;
P7_OPROFILE *om = NULL;
int nmodel = 0;
uint64_t totM = 0;
int status;
esl_stopwatch_Start(w);
if ((msvfp = fopen(msvfile, "r")) == NULL) p7_Fail("Failed to open MSV file %s for reading.\n", msvfile);
while ((status = p7_oprofile_ReadMSV(msvfp, &abc, NULL, &om)) == eslOK)
{
nmodel++;
totM += om->M;
p7_oprofile_Destroy(om);
}
if (status == eslEFORMAT) p7_Fail("bad file format in profile file %s", msvfile);
else if (status == eslEINCOMPAT) p7_Fail("profile file %s contains different alphabets", msvfile);
else if (status != eslEOF) p7_Fail("Unexpected error in reading profiles from %s", msvfile);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# number of models: %d\n", nmodel);
printf("# total M: %" PRId64 "\n", totM);
fclose(msvfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_ALPHABET *abc = esl_alphabet_Create(eslAMINO);
P7_BG *bg = p7_bg_Create(abc);
int my_rank;
int nproc;
char *buf = NULL;
int nbuf = 0;
int subtotalM = 0;
int allM = 0;
int stalling = esl_opt_GetBoolean(go, "--stall");
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
MPI_Comm_size(MPI_COMM_WORLD, &nproc);
while (stalling);
/* Master MPI process: */
if (my_rank == 0)
{
ESL_STOPWATCH *w = esl_stopwatch_Create();
P7_HMMFILE *hfp = NULL;
P7_OPROFILE *om = NULL;
P7_HMM *hmm = NULL;
/* Read HMMs from a file. */
if (p7_hmmfile_OpenE(hmmfile, NULL, &hfp, NULL) != eslOK) p7_Fail("Failed to open HMM file %s", hmmfile);
esl_stopwatch_Start(w);
while (p7_oprofile_ReadMSV(hfp, &abc, &om) == eslOK &&
p7_oprofile_ReadRest(hfp, om) == eslOK)
{
if (!esl_opt_GetBoolean(go, "-b"))
p7_oprofile_MPISend(om, 1, 0, MPI_COMM_WORLD, &buf, &nbuf); /* 1 = dest; 0 = tag */
p7_hmm_Destroy(hmm);
p7_oprofile_Destroy(om);
}
p7_oprofile_MPISend(NULL, 1, 0, MPI_COMM_WORLD, &buf, &nbuf); /* send the "no more HMMs" sign */
MPI_Reduce(&subtotalM, &allM, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
printf("total: %d\n", allM);
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "CPU Time: ");
esl_stopwatch_Destroy(w);
}
/* Worker MPI process: */
else
{
P7_OPROFILE *om_recd = NULL;
while (p7_oprofile_MPIRecv(0, 0, MPI_COMM_WORLD, &buf, &nbuf, &abc, &om_recd) == eslOK)
{
subtotalM += om_recd->M;
p7_oprofile_Destroy(om_recd);
}
MPI_Reduce(&subtotalM, &allM, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD);
}
free(buf);
p7_bg_Destroy(bg);
esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
MPI_Finalize();
exit(0);
}
int
main(int argc, char **argv)
{
int i,j;
ESL_GETOPTS *go = NULL; /* command line processing */
ESL_STOPWATCH *w = esl_stopwatch_Create();
int status;
ESL_MSA *msa = NULL;
FILE *ofp = NULL; /* output file (default is stdout) */
ESL_ALPHABET *abc = NULL; /* digital alphabet */
char *alifile; /* name of the alignment file we're building HMMs from */
ESLX_MSAFILE *afp = NULL; /* open alifile */
int infmt = eslMSAFILE_UNKNOWN; /* autodetect alignment format by default. */
int outfmt = eslMSAFILE_STOCKHOLM;
char *postmsafile; /* optional file to resave annotated, modified MSAs to */
FILE *postmsafp = NULL; /* open <postmsafile>, or NULL */
int mask_range_cnt = 0;
uint32_t mask_starts[100]; // over-the-top allocation.
uint32_t mask_ends[100];
char *rangestr;
char *range;
int *map = NULL; /* map[i]=j, means model position i comes from column j of the alignment; 1..alen */
int keep_mm;
/* Set processor specific flags */
impl_Init();
alifile = NULL;
postmsafile = NULL;
/* Parse the command line
*/
process_commandline(argc, argv, &go, &alifile, &postmsafile);
keep_mm = esl_opt_IsUsed(go, "--apendmask");
/* Initialize what we can in the config structure (without knowing the alphabet yet).
* Fields controlled by masters are set up in usual_master() or mpi_master()
* Fields used by workers are set up in mpi_worker()
*/
ofp = NULL;
infmt = eslMSAFILE_UNKNOWN;
afp = NULL;
abc = NULL;
if (esl_opt_IsOn(go, "--informat")) {
infmt = eslx_msafile_EncodeFormat(esl_opt_GetString(go, "--informat"));
if (infmt == eslMSAFILE_UNKNOWN) p7_Fail("%s is not a recognized input sequence file format\n", esl_opt_GetString(go, "--informat"));
}
/* Determine output alignment file format */
outfmt = eslx_msafile_EncodeFormat(esl_opt_GetString(go, "--outformat"));
if (outfmt == eslMSAFILE_UNKNOWN) p7_Fail(argv[0], "%s is not a recognized output MSA file format\n", esl_opt_GetString(go, "--outformat"));
/* Parse the ranges */
if (esl_opt_IsUsed(go, "--alirange")) {
esl_strdup(esl_opt_GetString(go, "--alirange"), -1, &rangestr) ;
} else if (esl_opt_IsUsed(go, "--modelrange")) {
esl_strdup(esl_opt_GetString(go, "--modelrange"), -1, &rangestr) ;
} else if (esl_opt_IsUsed(go, "--model2ali")) {
esl_strdup(esl_opt_GetString(go, "--model2ali"), -1, &rangestr) ;
} else if (esl_opt_IsUsed(go, "--ali2model")) {
esl_strdup(esl_opt_GetString(go, "--ali2model"), -1, &rangestr) ;
} else {
if (puts("Must specify mask range with --modelrange, --alirange, --model2ali, or --ali2model\n") < 0) ESL_XEXCEPTION_SYS(eslEWRITE, "write failed"); goto ERROR;
}
while ( (status = esl_strtok(&rangestr, ",", &range) ) == eslOK) {
status = esl_regexp_ParseCoordString(range, mask_starts + mask_range_cnt, mask_ends + mask_range_cnt );
if (status == eslESYNTAX) esl_fatal("range flags take coords <from>..<to>; %s not recognized", range);
if (status == eslFAIL) esl_fatal("Failed to find <from> or <to> coord in %s", range);
mask_range_cnt++;
}
/* Start timing. */
esl_stopwatch_Start(w);
/* Open files, set alphabet.
* afp - open alignment file for input
* abc - alphabet expected or guessed in ali file
* postmsafp - open MSA output file
* ofp - optional open output file, or stdout
*/
if (esl_opt_GetBoolean(go, "--amino")) abc = esl_alphabet_Create(eslAMINO);
else if (esl_opt_GetBoolean(go, "--dna")) abc = esl_alphabet_Create(eslDNA);
else if (esl_opt_GetBoolean(go, "--rna")) abc = esl_alphabet_Create(eslRNA);
else abc = NULL;
status = eslx_msafile_Open(&abc, alifile, NULL, infmt, NULL, &afp);
if (status != eslOK) eslx_msafile_OpenFailure(afp, status);
if (esl_opt_IsUsed(go, "--alirange") || esl_opt_IsUsed(go, "--modelrange") ) {
postmsafp = fopen(postmsafile, "w");
if (postmsafp == NULL) p7_Fail("Failed to MSA output file %s for writing", postmsafile);
}
if (esl_opt_IsUsed(go, "-o"))
{
ofp = fopen(esl_opt_GetString(go, "-o"), "w");
if (ofp == NULL) p7_Fail("Failed to open -o output file %s\n", esl_opt_GetString(go, "-o"));
}
else ofp = stdout;
/* Looks like the i/o is set up successfully...
* Initial output to the user
*/
output_header(go, ofp, alifile, postmsafile); /* cheery output header */
/* read the alignment */
if ((status = eslx_msafile_Read(afp, &msa)) != eslOK) eslx_msafile_ReadFailure(afp, status);
if (esl_opt_IsUsed(go, "--alirange") || esl_opt_IsUsed(go, "--modelrange") ) {
/* add/modify mmline for the mask */
if (msa->mm == NULL) {
ESL_ALLOC(msa->mm, msa->alen);
keep_mm = FALSE;
}
if (!keep_mm)
for (i=0; i<msa->alen; i++) msa->mm[i] = '.';
}
// convert model coordinates to alignment coordinates, if necessary
if (esl_opt_IsUsed(go, "--modelrange") || esl_opt_IsUsed(go, "--model2ali") || esl_opt_IsUsed(go, "--ali2model") ) {
float symfrac = esl_opt_GetReal(go, "--symfrac");
int do_hand = esl_opt_IsOn(go, "--hand");
int L;
//same as p7_builder relative_weights
if (esl_opt_IsOn(go, "--wnone") ) { esl_vec_DSet(msa->wgt, msa->nseq, 1.); }
else if (esl_opt_IsOn(go, "--wgiven") ) ;
else if (esl_opt_IsOn(go, "--wpb") ) status = esl_msaweight_PB(msa);
else if (esl_opt_IsOn(go, "--wgsc") ) status = esl_msaweight_GSC(msa);
else if (esl_opt_IsOn(go, "--wblosum")) status = esl_msaweight_BLOSUM(msa, esl_opt_GetReal(go, "--wid"));
if ((status = esl_msa_MarkFragments(msa, esl_opt_GetReal(go, "--fragthresh"))) != eslOK) goto ERROR;
//build a map of model mask coordinates to alignment coords
ESL_ALLOC(map, sizeof(int) * (msa->alen+1));
L = p7_Alimask_MakeModel2AliMap(msa, do_hand, symfrac, map );
if ( esl_opt_IsUsed(go, "--model2ali") ) {
//print mapping
printf ("model coordinates alignment coordinates\n");
for (i=0; i<mask_range_cnt; i++)
printf ("%8d..%-8d -> %8d..%-8d\n", mask_starts[i], mask_ends[i], map[mask_starts[i]-1], map[mask_ends[i]-1]);
/* If I wanted to, I could print all the map values independently:
printf("\n\n-----------\n");
printf("Map\n");
printf("---\n");
for (i=0; i<L; i++)
printf("%d -> %d\n", i+1, map[i]);
*/
} else if ( esl_opt_IsUsed(go, "--ali2model") ) {
//print mapping (requires scanning the inverted map
int alistart = 0;
int aliend = 0;
printf ("alignment coordinates model coordinates\n");
for (i=0; i<mask_range_cnt; i++) {
//find j for ali positions
while (map[alistart] < mask_starts[i] )
alistart++;
aliend = alistart;
while (map[aliend] < mask_ends[i] )
aliend++;
printf (" %8d..%-8d -> %8d..%-8d\n", map[alistart], map[aliend], alistart+1, aliend+1);
}
} else {
//convert the mask coords based on map
for (i=0; i<mask_range_cnt; i++) {
mask_starts[i] = map[mask_starts[i]-1]; //-1 because mmline is offset by one relative to the 1-base alignment
mask_ends[i] = map[mask_ends[i]-1];
}
}
}
if (esl_opt_IsUsed(go, "--alirange") || esl_opt_IsUsed(go, "--modelrange") ) {
//overwrite '.' with 'm' everywhere the range says to do it
for (i=0; i<mask_range_cnt; i++)
for (j=mask_starts[i]; j<=mask_ends[i]; j++)
msa->mm[j-1] = 'm';
if ((status = eslx_msafile_Write(postmsafp, msa, outfmt)) != eslOK) ESL_XEXCEPTION_SYS(eslEWRITE, "write failed");
}
esl_stopwatch_Stop(w);
if (esl_opt_IsOn(go, "-o")) fclose(ofp);
if (postmsafp) fclose(postmsafp);
if (afp) eslx_msafile_Close(afp);
if (abc) esl_alphabet_Destroy(abc);
esl_getopts_Destroy(go);
esl_stopwatch_Destroy(w);
return 0;
ERROR:
return eslFAIL;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_OMX *ox = NULL;
P7_GMX *gx = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float sc1, sc2;
double base_time, bench_time, Mcs;
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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc);
p7_oprofile_Convert(gm, om);
p7_oprofile_ReconfigLength(om, L);
if (esl_opt_GetBoolean(go, "-x")) p7_profile_SameAsVF(om, gm);
ox = p7_omx_Create(gm->M, 0, 0);
gx = p7_gmx_Create(gm->M, L);
/* Get a baseline time: how long it takes just to generate the sequences */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
esl_stopwatch_Stop(w);
base_time = w->user;
/* Run the benchmark */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_ViterbiFilter(dsq, L, om, ox, &sc1);
if (esl_opt_GetBoolean(go, "-c"))
{
p7_GViterbi(dsq, L, gm, gx, &sc2);
printf("%.4f %.4f\n", sc1, sc2);
}
if (esl_opt_GetBoolean(go, "-x"))
{
p7_GViterbi(dsq, L, gm, gx, &sc2);
sc2 /= om->scale_w;
if (om->mode == p7_UNILOCAL) sc2 -= 2.0; /* that's ~ L \log \frac{L}{L+2}, for our NN,CC,JJ */
else if (om->mode == p7_LOCAL) sc2 -= 3.0; /* that's ~ L \log \frac{L}{L+3}, for our NN,CC,JJ */
printf("%.4f %.4f\n", sc1, sc2);
}
}
esl_stopwatch_Stop(w);
bench_time = w->user - base_time;
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) bench_time;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_omx_Destroy(ox);
p7_gmx_Destroy(gx);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
/* Function: DispatchSqAlignment()
* Date: EPN, Thu Jan 12 14:47:26 2012
*
* Purpose: Given a CM and a sequence, align the sequence(s) using
* the appropriate alignment function and return relevant
* data for eventual output in <ret_data>.
*
* This function can be called from either an alignment
* pipeline (i.e. cmalign) or a search/scan pipeline
* (i.e. cmsearch or cmscan). <idx> is the (overloaded) flag
* for determining which, if -1, we're a search/scan
* pipeline. This is only relevant because in a search/scan
* pipeline we don't care about determining spos/epos so we
* don't call ParsetreeToCMBounds().
*
* If (cm->flags & CM_ALIGN_XTAU) we'll potentially tighten
* HMM bands until the required DP matrices are below out
* limit (<mxsize>). cm->maxtau is the max allowed tau value
* during this iterative band tightening, and cm->xtau is
* the factor by which we multiply cm->tau at each iteration
* during band tightening.
*
* Args: cm - the covariance model
* errbuf - char buffer for reporting errors
* sq - sequence to align
* idx - index of sequence (may be used to reorder data later)
* mxsize - max size in Mb of allowable DP mx
* mode - preset mode of alignment (TRMODE_UNKNOWN if unknown)
* pass_idx - pipeline pass index, determines trunc penalty
* cp9b_valid - TRUE if cm->cp9b are valid, don't compute HMM bands
* w - stopwatch for timing individual stages, can be NULL
* w_tot - stopwatch for timing total time per seq, can be NULL
* r - RNG, req'd if CM_ALIGN_SAMPLE, can be NULL otherwise
* ret_data - RETURN: newly created CM_ALNDATA object
*
* Returns: eslOK on success;
* eslEINCOMPAT on contract violation, errbuf is filled;
* eslEMEM if we run out of memory;
* <ret_data> is alloc'ed and filled.
*/
int
DispatchSqAlignment(CM_t *cm, char *errbuf, ESL_SQ *sq, int64_t idx, float mxsize, char mode, int pass_idx,
int cp9b_valid, ESL_STOPWATCH *w, ESL_STOPWATCH *w_tot, ESL_RANDOMNESS *r, CM_ALNDATA **ret_data)
{
int status; /* easel status */
CM_ALNDATA *data = NULL; /* CM_ALNDATA we'll create and fill */
float sc = 0.; /* score from alignment function */
float pp = 0.; /* average PP from alignment function */
Parsetree_t *tr = NULL; /* ptr to a parsetree */
char *ppstr = NULL; /* ptr to a PP string */
float secs_bands = 0.; /* seconds elapsed for band calculation */
float secs_aln = 0.; /* seconds elapsed for alignment calculation */
float mb_tot = 0.; /* size of all DP matrices used for alignment */
double tau = -1.; /* tau used for calculating bands */
float thresh1 = -1.; /* cp9b->thresh1 used for calculating bands */
float thresh2 = -1.; /* cp9b->thresh2 used for calculating bands */
int spos = -1; /* start posn: first non-gap CM consensus position */
int epos = -1; /* end posn: final non-gap CM consensus position */
double save_tau = cm->tau; /* cm->tau upon entrance, we restore before leaving */
float save_thresh1 = (cm->cp9b == NULL) ? -1. : cm->cp9b->thresh1;
float save_thresh2 = (cm->cp9b == NULL) ? -1. : cm->cp9b->thresh2;
/* alignment options */
int do_nonbanded = (cm->align_opts & CM_ALIGN_NONBANDED) ? TRUE : FALSE;
int do_qdb = (cm->align_opts & CM_ALIGN_QDB) ? TRUE : FALSE;
int do_hbanded = (do_nonbanded || do_qdb) ? FALSE : TRUE;
int do_optacc = (cm->align_opts & CM_ALIGN_OPTACC) ? TRUE : FALSE;
int do_sample = (cm->align_opts & CM_ALIGN_SAMPLE) ? TRUE : FALSE;
int do_post = (cm->align_opts & CM_ALIGN_POST) ? TRUE : FALSE;
int do_sub = (cm->align_opts & CM_ALIGN_SUB) ? TRUE : FALSE;
int do_small = (cm->align_opts & CM_ALIGN_SMALL) ? TRUE : FALSE;
int do_trunc = (cm->align_opts & CM_ALIGN_TRUNC) ? TRUE : FALSE;
int do_xtau = (cm->align_opts & CM_ALIGN_XTAU) ? TRUE : FALSE;
int doing_search = FALSE;
#if eslDEBUGLEVEL >= 1
printf("in DispatchSqAlignment() %s\n", sq->name);
printf("\tdo_nonbanded: %d\n", do_nonbanded);
printf("\tdo_optacc: %d\n", do_optacc);
printf("\tdo_sample: %d\n", do_sample);
printf("\tdo_post: %d\n", do_post);
printf("\tdo_sub: %d\n", do_sub);
printf("\tdo_small: %d\n", do_small);
printf("\tdo_trunc: %d\n", do_trunc);
printf("\tdo_qdb: %d\n", do_qdb);
printf("\tdoing_search: %d\n", doing_search);
#endif
/* sub-mode specific variables (wouldn't be needed if sub mode were not supported) */
CM_t *orig_cm = cm; /* pointer to the original CM */
CM_t *sub_cm = NULL; /* the sub CM */
CMSubMap_t *submap = NULL; /* map from mother CM to sub CM, and vice versa */
Parsetree_t *full_tr = NULL; /* converted parsetree to full CM */
/* contract check */
if(do_small && do_hbanded) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to do small and HMM banded alignment");
if(do_small && do_optacc) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to do small and opt acc alignment");
if(do_post && do_small) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to do PP and small alignment");
if(do_optacc && do_sample) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to sample and do optacc alignment");
if(do_sub && do_small) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to do sub and small alignment");
if(do_sub && do_trunc) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to do sub and truncated alignment");
if(do_sample && r == NULL) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to sample but RNG r == NULL");
if(do_xtau && ! do_hbanded) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to multiply tau without HMM banded alignment");
if(do_xtau && cp9b_valid) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to multiply tau but HMM bands already valid");
if(do_qdb && do_nonbanded) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to do qdb and nonbanded alignment");
if(do_qdb && do_trunc) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to use qdbs and truncated alignment");
/* qdb + trunc combo disallowed only b/c no function exists for it yet */
if(do_qdb && (! do_small)) ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to use qdbs but not divide and conquer");
/* qdb + small combo disallowed b/c only non-HMM banded non-small alignment functions are not set up to use QDBs */
if(do_qdb && cm->qdbinfo == NULL) {
ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to use qdbs but cm->qdbinfo is NULL");
}
if(do_qdb && (cm->qdbinfo->dmin2 == NULL || cm->qdbinfo->dmax2 == NULL)) {
ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to use qdbs but cm->qdbinfo is NULL");
}
if(do_trunc && (! cm_pli_PassAllowsTruncation(pass_idx))) {
ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() trying to do truncated alignment, but pass_idx doesn't allow truncation (PLI_PASS_STD_ANY)");
}
if(pass_idx == PLI_PASS_STD_ANY && (mode == TRMODE_L || mode == TRMODE_R || mode == TRMODE_T)) {
ESL_XFAIL(eslEINCOMPAT, errbuf, "DispatchSqAlignment() mode is L, R, or T, but pass_idx is PLI_PASS_STD_ANY");
}
if(w_tot != NULL) esl_stopwatch_Start(w_tot);
/* do sub-mode specific pre-alignment steps, if nec */
if(do_sub) {
if((status = sub_alignment_prep(cm, errbuf, sq, &submap, &sub_cm)) != eslOK) goto ERROR;
cm = sub_cm;
}
if(w != NULL) esl_stopwatch_Start(w);
/* do small D&C alignment, if nec */
if(do_small) {
if(do_trunc) {
sc = TrCYK_DnC(cm, sq->dsq, sq->L, 0, 1, sq->L, pass_idx, FALSE, &tr); /* FALSE: don't reproduce 1.0 behavior */
mb_tot = 4. * CYKNonQDBSmallMbNeeded(cm, sq->L); /* not sure how accurate this is */
}
else {
/* with QDB, always use dmin2/dmax2, the looser of the two sets of QDBs in cm->qdbinfo */
sc = CYKDivideAndConquer(cm, sq->dsq, sq->L, 0, 1, sq->L, &tr,
(do_qdb) ? cm->qdbinfo->dmin2 : NULL,
(do_qdb) ? cm->qdbinfo->dmax2 : NULL);
mb_tot = CYKNonQDBSmallMbNeeded(cm, sq->L);
}
}
else { /* do_small is FALSE */
if(do_nonbanded || do_qdb) { /* do not use HMM bands */
if(do_trunc) {
if((status = cm_TrAlignSizeNeeded(cm, errbuf, sq->L, mxsize, do_sample, do_post,
NULL, NULL, NULL, &mb_tot)) != eslOK) goto ERROR;
if((status = cm_TrAlign(cm, errbuf, sq->dsq, sq->L, mxsize, mode, pass_idx,
do_optacc, do_sample, cm->trnb_mx, cm->trnb_shmx, cm->trnb_omx,
cm->trnb_emx, r, do_post ? &ppstr : NULL, &tr, NULL, &pp, &sc)) != eslOK) goto ERROR;
}
else {
if((status = cm_AlignSizeNeeded(cm, errbuf, sq->L, mxsize, do_sample, do_post,
NULL, NULL, NULL, &mb_tot)) != eslOK) goto ERROR;
if((status = cm_Align(cm, errbuf, sq->dsq, sq->L, mxsize, do_optacc, do_sample, cm->nb_mx, cm->nb_shmx,
cm->nb_omx, cm->nb_emx, r, do_post ? &ppstr : NULL, &tr, &pp, &sc)) != eslOK) goto ERROR;
}
}
else { /* use HMM bands */
if(! cp9b_valid) {
if(do_xtau) { /* multiply tau (if nec) until required mx is below Mb limit (mxsize) */
if((status = cp9_IterateSeq2Bands(cm, errbuf, sq->dsq, 1, sq->L, pass_idx, mxsize, doing_search, do_sample, do_post,
cm->maxtau, NULL)) != eslOK) goto ERROR;
}
else {
if((status = cp9_Seq2Bands(cm, errbuf, cm->cp9_mx, cm->cp9_bmx, cm->cp9_bmx, sq->dsq,
1, sq->L, cm->cp9b, doing_search, pass_idx, 0)) != eslOK) goto ERROR;
}
if(w != NULL) esl_stopwatch_Stop(w);
secs_bands = (w == NULL) ? 0. : w->elapsed;
tau = cm->tau;
thresh1 = cm->cp9b->thresh1;
thresh2 = cm->cp9b->thresh2;
/* note: we don't set these three if cp9b_valid is TRUE */
}
if(w != NULL) esl_stopwatch_Start(w);
if(do_trunc) {
if((status = cm_TrAlignSizeNeededHB(cm, errbuf, sq->L, mxsize, do_sample, do_post,
NULL, NULL, NULL, &mb_tot)) != eslOK) goto ERROR;
if((status = cm_TrAlignHB(cm, errbuf, sq->dsq, sq->L, mxsize, mode, pass_idx,
do_optacc, do_sample, cm->trhb_mx, cm->trhb_shmx, cm->trhb_omx,
cm->trhb_emx, r, do_post ? &ppstr : NULL, &tr, NULL, &pp, &sc)) != eslOK) goto ERROR;
}
else {
if((status = cm_AlignSizeNeededHB(cm, errbuf, sq->L, mxsize, do_sample, do_post,
NULL, NULL, NULL, &mb_tot)) != eslOK) goto ERROR;
if((status = cm_AlignHB(cm, errbuf, sq->dsq, sq->L, mxsize, do_optacc, do_sample, cm->hb_mx, cm->hb_shmx,
cm->hb_omx, cm->hb_emx, r, do_post ? &ppstr : NULL, &tr, &pp, &sc)) != eslOK) goto ERROR;
}
/* add size of CP9 matrices used for calculating bands */
mb_tot += ((float) cm->cp9_mx->ncells_valid * sizeof(int)) / 1000000.;
mb_tot += ((float) cm->cp9_bmx->ncells_valid * sizeof(int)) / 1000000.;
if(do_sub) { /* add size of original CM's CP9 matrices used for calculating start/end position */
mb_tot += ((float) orig_cm->cp9_mx->ncells_valid * sizeof(int)) / 1000000.;
mb_tot += ((float) orig_cm->cp9_bmx->ncells_valid * sizeof(int)) / 1000000.;
}
}
}
if(w != NULL) esl_stopwatch_Stop(w);
secs_aln = (w == NULL) ? 0. : w->elapsed;
if(do_sub) {
/* convert sub cm parsetree to a full CM parsetree */
if((status = sub_cm2cm_parsetree(orig_cm, cm, &full_tr, tr, submap, 0)) != eslOK) ESL_XFAIL(status, errbuf, "out of memory, converting sub parsetree to full parsetree");
/* free sub data structures, we're done with them */
FreeParsetree(tr); tr = full_tr;
FreeCM(cm); cm = orig_cm;
FreeSubMap(submap); submap = NULL;
}
/* determine start and end points of the parsetree,
* but only if we're not in a search/scan pipeline
*/
if(idx != -1) { /* we're not in a search/scan pipeline */
if((status = ParsetreeToCMBounds(cm, tr, TRUE, TRUE, errbuf, NULL, NULL, NULL, NULL, &spos, &epos)) != eslOK) goto ERROR;
}
/* create and fill data */
ESL_ALLOC(data, sizeof(CM_ALNDATA));
data->sq = sq;
data->idx = idx;
data->tr = tr;
data->sc = sc;
data->pp = (do_post) ? pp : 0.;
data->ppstr = (do_post) ? ppstr : NULL;
data->spos = spos;
data->epos = epos;
data->secs_bands = (do_nonbanded) ? 0. : secs_bands;
data->secs_aln = secs_aln;
data->mb_tot = mb_tot;
data->tau = tau;
data->thresh1 = thresh1;
data->thresh2 = thresh2;
if(w_tot != NULL) esl_stopwatch_Stop(w_tot);
data->secs_tot = (w_tot == NULL) ? 0. : w_tot->elapsed;
*ret_data = data;
cm->tau = save_tau;
if(cm->cp9b != NULL) {
cm->cp9b->thresh1 = save_thresh1;
cm->cp9b->thresh2 = save_thresh2;
}
return eslOK;
ERROR:
cm->tau = save_tau;
if(cm->cp9b != NULL) {
cm->cp9b->thresh1 = save_thresh1;
cm->cp9b->thresh2 = save_thresh2;
}
if(data != NULL) cm_alndata_Destroy(data, FALSE);
*ret_data = NULL;
if(status == eslEMEM) ESL_FAIL(status, errbuf, "DispatchSqAlignment(), out of memory");
return status;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_OMX *ox1 = NULL;
P7_OMX *ox2 = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
float null2[p7_MAXCODE];
int i,j,d,pos;
int nsamples = 200;
float fsc, bsc;
double Mcs;
if (p7_hmmfile_OpenE(hmmfile, NULL, &hfp, NULL) != 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);
gm = p7_profile_Create(hmm->M, abc); p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc); p7_oprofile_Convert(gm, om);
p7_oprofile_ReconfigLength(om, L);
ox1 = p7_omx_Create(gm->M, L, L);
ox2 = p7_omx_Create(gm->M, L, L);
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_Forward (dsq, L, om, ox1, &fsc);
if (esl_opt_GetBoolean(go, "-t"))
{
P7_TRACE *tr = p7_trace_Create();
float *n2sc = malloc(sizeof(float) * (L+1));
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{ /* This is approximately what p7_domaindef.c::region_trace_ensemble() is doing: */
for (j = 0; j < nsamples; j++)
{
p7_StochasticTrace(r, dsq, L, om, ox1, tr);
p7_trace_Index(tr);
pos = 1;
for (d = 0; d < tr->ndom; d++)
{
p7_Null2_ByTrace(om, tr, tr->tfrom[d], tr->tto[d], ox2, null2);
for (; pos <= tr->sqfrom[d]; pos++) n2sc[pos] += 1.0;
for (; pos < tr->sqto[d]; pos++) n2sc[pos] += null2[dsq[pos]];
}
for (; pos <= L; pos++) n2sc[pos] += 1.0;
p7_trace_Reuse(tr);
}
for (pos = 1; pos <= L; pos++)
n2sc[pos] = logf(n2sc[pos] / nsamples);
}
esl_stopwatch_Stop(w);
free(n2sc);
p7_trace_Destroy(tr);
}
else
{
p7_Backward(dsq, L, om, ox1, ox2, &bsc);
p7_Decoding(om, ox1, ox2, ox2);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
p7_Null2_ByExpectation(om, ox2, null2);
esl_stopwatch_Stop(w);
}
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) w->user;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_omx_Destroy(ox1);
p7_omx_Destroy(ox2);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 0, argc, argv, banner, usage);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
int N = esl_opt_GetInteger(go, "-N");
int M = esl_opt_GetInteger(go, "-M");
P7_TOPHITS **h = NULL;
P7_HIT *hit = NULL;
double *sortkeys = NULL;
char name[] = "not_unique_name";
char acc[] = "not_unique_acc";
char desc[] = "Test description for the purposes of making the benchmark allocate space";
int i,j;
int status;
/* prep work: generate our sort keys before starting to time anything */
ESL_ALLOC(h, sizeof(P7_TOPHITS *) * M); /* allocate pointers for M lists */
ESL_ALLOC(sortkeys, sizeof(double) * N * M);
for (i = 0; i < N*M; i++) sortkeys[i] = esl_random(r);
esl_stopwatch_Start(w);
/* generate M "random" lists and sort them */
for (j = 0; j < M; j++)
{
h[j] = p7_tophits_Create(p7_TOPHITS_DEFAULT_INIT_ALLOC);
for (i = 0; i < N; i++)
{
p7_tophits_CreateNextHit(h[j], &hit);
esl_strdup(name, -1, &(hit->name));
esl_strdup(acc, -1, &(hit->acc));
esl_strdup(desc, -1, &(hit->desc));
hit->sortkey = sortkeys[j*N + i];
hit->score = (float) sortkeys[j*N+i];
hit->pre_score = 0.0;
hit->sum_score = 0.0;
hit->lnP = sortkeys[j*N+i];
hit->pre_lnP = 0.0;
hit->sum_lnP = 0.0;
hit->ndom = N;
hit->noverlaps = 0;
hit->nexpected = 0;
hit->flags = 0;
hit->nreported = 0;
hit->nincluded = 0;
hit->best_domain = 0;
hit->dcl = NULL;
}
p7_tophits_SortBySortkey(h[j]);
}
/* then merge them into one big list in h[0] */
for (j = 1; j < M; j++)
{
p7_tophits_Merge(h[0], h[j]);
p7_tophits_Destroy(h[j]);
}
esl_stopwatch_Stop(w);
p7_tophits_Destroy(h[0]);
status = eslOK;
ERROR:
esl_getopts_Destroy(go);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
if (sortkeys != NULL) free(sortkeys);
if (h != NULL) free(h);
return status;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_GMX *gx1 = NULL;
P7_GMX *gx2 = NULL;
P7_TRACE *tr = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float fsc, bsc, accscore;
double Mcs;
p7_FLogsumInit();
if (p7_hmmfile_OpenE(hmmfile, NULL, &hfp, NULL) != 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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_UNILOCAL);
gx1 = p7_gmx_Create(gm->M, L);
gx2 = p7_gmx_Create(gm->M, L);
tr = p7_trace_CreateWithPP();
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_GForward (dsq, L, gm, gx1, &fsc);
p7_GBackward(dsq, L, gm, gx2, &bsc);
p7_GDecoding(gm, gx1, gx2, gx2); /* <gx2> is now the posterior decoding matrix */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
p7_GOptimalAccuracy(gm, gx2, gx1, &accscore); /* <gx1> is now the OA matrix */
if (! esl_opt_GetBoolean(go, "--notrace"))
{
p7_GOATrace(gm, gx2, gx1, tr);
p7_trace_Reuse(tr);
}
}
esl_stopwatch_Stop(w);
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / w->user;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_trace_Destroy(tr);
p7_gmx_Destroy(gx1);
p7_gmx_Destroy(gx2);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
static void
scan_thread(void *arg)
{
int i;
int count;
int workeridx;
WORKER_INFO *info;
ESL_THREADS *obj;
ESL_STOPWATCH *w;
P7_BG *bg = NULL; /* null model */
P7_PIPELINE *pli = NULL; /* work pipeline */
P7_TOPHITS *th = NULL; /* top hit results */
obj = (ESL_THREADS *) arg;
esl_threads_Started(obj, &workeridx);
info = (WORKER_INFO *) esl_threads_GetData(obj, workeridx);
w = esl_stopwatch_Create();
esl_stopwatch_Start(w);
/* Convert to an optimized model */
bg = p7_bg_Create(info->abc);
/* Create processing pipeline and hit list */
th = p7_tophits_Create();
pli = p7_pipeline_Create(info->opts, 100, 100, FALSE, p7_SCAN_MODELS);
p7_pli_NewSeq(pli, info->seq);
/* loop until all sequences have been processed */
count = 1;
while (count > 0) {
int inx;
int blksz;
P7_OPROFILE **om;
/* grab the next block of sequences */
if (pthread_mutex_lock(info->inx_mutex) != 0) p7_Fail("mutex lock failed");
inx = *info->inx;
blksz = *info->blk_size;
if (inx > *info->limit) {
blksz /= 5;
if (blksz < 1000) {
*info->limit = info->om_cnt * 2;
} else {
*info->limit = inx + (info->om_cnt - inx) * 2 / 3;
}
}
*info->blk_size = blksz;
*info->inx += blksz;
if (pthread_mutex_unlock(info->inx_mutex) != 0) p7_Fail("mutex unlock failed");
om = info->om_list + inx;
count = info->om_cnt - inx;
if (count > blksz) count = blksz;
/* Main loop: */
for (i = 0; i < count; ++i, ++om) {
p7_pli_NewModel(pli, *om, bg);
p7_bg_SetLength(bg, info->seq->n);
p7_oprofile_ReconfigLength(*om, info->seq->n);
p7_Pipeline(pli, *om, bg, info->seq, th);
p7_pipeline_Reuse(pli);
}
}
/* make available the pipeline objects to the main thread */
info->th = th;
info->pli = pli;
/* clean up */
p7_bg_Destroy(bg);
esl_stopwatch_Stop(w);
info->elapsed = w->elapsed;
esl_stopwatch_Destroy(w);
esl_threads_Finished(obj, workeridx);
pthread_exit(NULL);
return;
}
static void
search_thread(void *arg)
{
int i;
int count;
int seed;
int status;
int workeridx;
WORKER_INFO *info;
ESL_THREADS *obj;
ESL_SQ dbsq;
ESL_STOPWATCH *w = NULL; /* timing stopwatch */
P7_BUILDER *bld = NULL; /* HMM construction configuration */
P7_BG *bg = NULL; /* null model */
P7_PIPELINE *pli = NULL; /* work pipeline */
P7_TOPHITS *th = NULL; /* top hit results */
P7_PROFILE *gm = NULL; /* generic model */
P7_OPROFILE *om = NULL; /* optimized query profile */
obj = (ESL_THREADS *) arg;
esl_threads_Started(obj, &workeridx);
info = (WORKER_INFO *) esl_threads_GetData(obj, workeridx);
w = esl_stopwatch_Create();
bg = p7_bg_Create(info->abc);
esl_stopwatch_Start(w);
/* set up the dummy description and accession fields */
dbsq.desc = "";
dbsq.acc = "";
/* process a query sequence or hmm */
if (info->seq != NULL) {
bld = p7_builder_Create(NULL, info->abc);
if ((seed = esl_opt_GetInteger(info->opts, "--seed")) > 0) {
esl_randomness_Init(bld->r, seed);
bld->do_reseeding = TRUE;
}
bld->EmL = esl_opt_GetInteger(info->opts, "--EmL");
bld->EmN = esl_opt_GetInteger(info->opts, "--EmN");
bld->EvL = esl_opt_GetInteger(info->opts, "--EvL");
bld->EvN = esl_opt_GetInteger(info->opts, "--EvN");
bld->EfL = esl_opt_GetInteger(info->opts, "--EfL");
bld->EfN = esl_opt_GetInteger(info->opts, "--EfN");
bld->Eft = esl_opt_GetReal (info->opts, "--Eft");
if (esl_opt_IsOn(info->opts, "--mxfile")) status = p7_builder_SetScoreSystem (bld, esl_opt_GetString(info->opts, "--mxfile"), NULL, esl_opt_GetReal(info->opts, "--popen"), esl_opt_GetReal(info->opts, "--pextend"), bg);
else status = p7_builder_LoadScoreSystem(bld, esl_opt_GetString(info->opts, "--mx"), esl_opt_GetReal(info->opts, "--popen"), esl_opt_GetReal(info->opts, "--pextend"), bg);
if (status != eslOK) {
//client_error(info->sock, status, "hmmgpmd: failed to set single query sequence score system: %s", bld->errbuf);
fprintf(stderr, "hmmpgmd: failed to set single query sequence score system: %s", bld->errbuf);
pthread_exit(NULL);
return;
}
p7_SingleBuilder(bld, info->seq, bg, NULL, NULL, NULL, &om); /* bypass HMM - only need model */
p7_builder_Destroy(bld);
} else {
gm = p7_profile_Create (info->hmm->M, info->abc);
om = p7_oprofile_Create(info->hmm->M, info->abc);
p7_ProfileConfig(info->hmm, bg, gm, 100, p7_LOCAL);
p7_oprofile_Convert(gm, om);
}
/* Create processing pipeline and hit list */
th = p7_tophits_Create();
pli = p7_pipeline_Create(info->opts, om->M, 100, FALSE, p7_SEARCH_SEQS);
p7_pli_NewModel(pli, om, bg);
if (pli->Z_setby == p7_ZSETBY_NTARGETS) pli->Z = info->db_Z;
/* loop until all sequences have been processed */
count = 1;
while (count > 0) {
int inx;
int blksz;
HMMER_SEQ **sq;
/* grab the next block of sequences */
if (pthread_mutex_lock(info->inx_mutex) != 0) p7_Fail("mutex lock failed");
inx = *info->inx;
blksz = *info->blk_size;
if (inx > *info->limit) {
blksz /= 5;
if (blksz < 1000) {
*info->limit = info->sq_cnt * 2;
} else {
*info->limit = inx + (info->sq_cnt - inx) * 2 / 3;
}
}
*info->blk_size = blksz;
*info->inx += blksz;
if (pthread_mutex_unlock(info->inx_mutex) != 0) p7_Fail("mutex unlock failed");
sq = info->sq_list + inx;
count = info->sq_cnt - inx;
if (count > blksz) count = blksz;
/* Main loop: */
for (i = 0; i < count; ++i, ++sq) {
if ( !(info->range_list) || hmmpgmd_IsWithinRanges ((*sq)->idx, info->range_list)) {
dbsq.name = (*sq)->name;
dbsq.dsq = (*sq)->dsq;
dbsq.n = (*sq)->n;
dbsq.idx = (*sq)->idx;
if((*sq)->desc != NULL) dbsq.desc = (*sq)->desc;
p7_bg_SetLength(bg, dbsq.n);
p7_oprofile_ReconfigLength(om, dbsq.n);
p7_Pipeline(pli, om, bg, &dbsq, th);
p7_pipeline_Reuse(pli);
}
}
}
/* make available the pipeline objects to the main thread */
info->th = th;
info->pli = pli;
/* clean up */
p7_bg_Destroy(bg);
p7_oprofile_Destroy(om);
if (gm != NULL) p7_profile_Destroy(gm);
esl_stopwatch_Stop(w);
info->elapsed = w->elapsed;
esl_stopwatch_Destroy(w);
esl_threads_Finished(obj, workeridx);
pthread_exit(NULL);
return;
}
static void
process_SearchCmd(HMMD_COMMAND *cmd, WORKER_ENV *env)
{
int i;
int cnt;
int limit;
int status;
int blk_size;
WORKER_INFO *info = NULL;
ESL_ALPHABET *abc;
ESL_STOPWATCH *w;
ESL_THREADS *threadObj = NULL;
pthread_mutex_t inx_mutex;
int current_index;
QUEUE_DATA *query = NULL;
time_t date;
char timestamp[32];
w = esl_stopwatch_Create();
abc = esl_alphabet_Create(eslAMINO);
if (pthread_mutex_init(&inx_mutex, NULL) != 0) p7_Fail("mutex init failed");
ESL_ALLOC(info, sizeof(*info) * env->ncpus);
/* Log the current time (at search start) */
date = time(NULL);
ctime_r(&date, timestamp);
printf("\n%s", timestamp); /* note that ctime_r() leaves \n on end of timestamp */
/* initialize thread data */
query = process_QueryCmd(cmd, env);
esl_stopwatch_Start(w);
info->range_list = NULL;
if (esl_opt_IsUsed(query->opts, "--seqdb_ranges")) {
ESL_ALLOC(info->range_list, sizeof(RANGE_LIST));
hmmpgmd_GetRanges(info->range_list, esl_opt_GetString(query->opts, "--seqdb_ranges"));
}
if (query->cmd_type == HMMD_CMD_SEARCH) threadObj = esl_threads_Create(&search_thread);
else threadObj = esl_threads_Create(&scan_thread);
if (query->query_type == HMMD_SEQUENCE) {
fprintf(stdout, "Search seq %s [L=%ld]", query->seq->name, (long) query->seq->n);
} else {
fprintf(stdout, "Search hmm %s [M=%d]", query->hmm->name, query->hmm->M);
}
fprintf(stdout, " vs %s DB %d [%d - %d]",
(query->cmd_type == HMMD_CMD_SEARCH) ? "SEQ" : "HMM",
query->dbx, query->inx, query->inx + query->cnt - 1);
if (info->range_list)
fprintf(stdout, " in range(s) %s", esl_opt_GetString(query->opts, "--seqdb_ranges"));
fprintf(stdout, "\n");
/* Create processing pipeline and hit list */
for (i = 0; i < env->ncpus; ++i) {
info[i].abc = query->abc;
info[i].hmm = query->hmm;
info[i].seq = query->seq;
info[i].opts = query->opts;
info[i].range_list = info[0].range_list;
info[i].th = NULL;
info[i].pli = NULL;
info[i].inx_mutex = &inx_mutex;
info[i].inx = ¤t_index;/* this is confusing trickery - to share a single variable across all threads */
info[i].blk_size = &blk_size; /* ditto */
info[i].limit = &limit; /* ditto. TODO: come back and clean this up. */
if (query->cmd_type == HMMD_CMD_SEARCH) {
HMMER_SEQ **list = env->seq_db->db[query->dbx].list;
info[i].sq_list = &list[query->inx];
info[i].sq_cnt = query->cnt;
info[i].db_Z = env->seq_db->db[query->dbx].K;
info[i].om_list = NULL;
info[i].om_cnt = 0;
} else {
info[i].sq_list = NULL;
info[i].sq_cnt = 0;
info[i].db_Z = 0;
info[i].om_list = &env->hmm_db->list[query->inx];
info[i].om_cnt = query->cnt;
}
esl_threads_AddThread(threadObj, &info[i]);
}
/* try block size of 5000. we will need enough sequences for four
* blocks per thread or better.
*/
blk_size = 5000;
cnt = query->cnt / env->ncpus / blk_size;
limit = query->cnt * 2 / 3;
if (cnt < 4) {
/* try block size of 1000 */
blk_size /= 5;
cnt = query->cnt / env->ncpus / blk_size;
if (cnt < 4) {
/* still not enough. just divide it up into one block per thread */
blk_size = query->cnt / env->ncpus + 1;
limit = query->cnt * 2;
}
}
current_index = 0;
esl_threads_WaitForStart(threadObj);
esl_threads_WaitForFinish(threadObj);
esl_stopwatch_Stop(w);
#if 1
fprintf (stdout, " Sequences Residues Elapsed\n");
for (i = 0; i < env->ncpus; ++i) {
print_timings(i, info[i].elapsed, info[i].pli);
}
#endif
/* merge the results of the search results */
for (i = 1; i < env->ncpus; ++i) {
p7_tophits_Merge(info[0].th, info[i].th);
p7_pipeline_Merge(info[0].pli, info[i].pli);
p7_pipeline_Destroy(info[i].pli);
p7_tophits_Destroy(info[i].th);
}
print_timings(99, w->elapsed, info[0].pli);
send_results(env->fd, w, info);
/* free the last of the pipeline data */
p7_pipeline_Destroy(info->pli);
p7_tophits_Destroy(info->th);
free_QueueData(query);
esl_threads_Destroy(threadObj);
pthread_mutex_destroy(&inx_mutex);
if (info->range_list) {
if (info->range_list->starts) free(info->range_list->starts);
if (info->range_list->ends) free(info->range_list->ends);
free (info->range_list);
}
free(info);
esl_stopwatch_Destroy(w);
esl_alphabet_Destroy(abc);
return;
ERROR:
LOG_FATAL_MSG("malloc", errno);
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = NULL; /* command line processing */
ESL_STOPWATCH *w = esl_stopwatch_Create();
struct cfg_s cfg;
/* Set processor specific flags */
impl_Init();
cfg.alifile = NULL;
cfg.hmmfile = NULL;
/* Parse the command line
*/
process_commandline(argc, argv, &go, &cfg.hmmfile, &cfg.alifile);
/* Initialize what we can in the config structure (without knowing the alphabet yet)
*/
cfg.ofp = NULL; /* opened in init_master_cfg() */
cfg.fmt = eslMSAFILE_UNKNOWN; /* autodetect alignment format by default. */
cfg.afp = NULL; /* created in init_master_cfg() */
cfg.abc = NULL; /* created in init_master_cfg() in masters, or in mpi_worker() in workers */
cfg.hmmfp = NULL; /* opened in init_master_cfg() */
cfg.postmsafile = esl_opt_GetString(go, "-O"); /* NULL by default */
cfg.postmsafp = NULL; /* opened in init_master_cfg() */
cfg.nali = 0; /* this counter is incremented in masters */
cfg.nnamed = 0; /* 0 or 1 if a single MSA; == nali if multiple MSAs */
cfg.do_mpi = FALSE; /* this gets reset below, if we init MPI */
cfg.nproc = 0; /* this gets reset below, if we init MPI */
cfg.my_rank = 0; /* this gets reset below, if we init MPI */
cfg.do_stall = esl_opt_GetBoolean(go, "--stall");
cfg.hmmName = esl_opt_GetString(go, "-n"); /* NULL by default */
if (esl_opt_IsOn(go, "--informat")) {
cfg.fmt = esl_msa_EncodeFormat(esl_opt_GetString(go, "--informat"));
if (cfg.fmt == eslMSAFILE_UNKNOWN) p7_Fail("%s is not a recognized input sequence file format\n", esl_opt_GetString(go, "--informat"));
}
/* This is our stall point, if we need to wait until we get a
* debugger attached to this process for debugging (especially
* useful for MPI):
*/
while (cfg.do_stall);
/* Start timing. */
esl_stopwatch_Start(w);
/* Figure out who we are, and send control there:
* we might be an MPI master, an MPI worker, or a serial program.
*/
#ifdef HAVE_MPI
if (esl_opt_GetBoolean(go, "--mpi"))
{
cfg.do_mpi = TRUE;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &(cfg.my_rank));
MPI_Comm_size(MPI_COMM_WORLD, &(cfg.nproc));
if (cfg.my_rank > 0) mpi_worker(go, &cfg);
else mpi_master(go, &cfg);
esl_stopwatch_Stop(w);
esl_stopwatch_MPIReduce(w, 0, MPI_COMM_WORLD);
MPI_Finalize();
}
else
#endif /*HAVE_MPI*/
{
serial_master(go, &cfg);
esl_stopwatch_Stop(w);
}
if (cfg.my_rank == 0) {
fputc('\n', cfg.ofp);
esl_stopwatch_Display(cfg.ofp, w, "# CPU time: ");
}
/* Clean up the shared cfg.
*/
if (cfg.my_rank == 0) {
if (esl_opt_IsOn(go, "-o")) { fclose(cfg.ofp); }
if (cfg.afp != NULL) esl_msafile_Close(cfg.afp);
if (cfg.abc != NULL) esl_alphabet_Destroy(cfg.abc);
if (cfg.hmmfp != NULL) fclose(cfg.hmmfp);
}
esl_getopts_Destroy(go);
esl_stopwatch_Destroy(w);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = p7_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_GMX *gx1 = NULL;
P7_GMX *gx2 = NULL;
P7_OMX *ox1 = NULL;
P7_OMX *ox2 = NULL;
P7_TRACE *tr = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float fsc, bsc, accscore;
float fsc_g, bsc_g, accscore_g;
double Mcs;
p7_FLogsumInit();
if (p7_hmmfile_OpenE(hmmfile, NULL, &hfp, NULL) != 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);
gm = p7_profile_Create(hmm->M, abc); p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc); p7_oprofile_Convert(gm, om);
p7_oprofile_ReconfigLength(om, L);
if (esl_opt_GetBoolean(go, "-x") && p7_FLogsumError(-0.4, -0.5) > 0.0001)
p7_Fail("-x here requires p7_Logsum() recompiled in slow exact mode");
ox1 = p7_omx_Create(gm->M, L, L);
ox2 = p7_omx_Create(gm->M, L, L);
tr = p7_trace_CreateWithPP();
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_Forward (dsq, L, om, ox1, &fsc);
p7_Backward(dsq, L, om, ox1, ox2, &bsc);
p7_Decoding(om, ox1, ox2, ox2);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
p7_OptimalAccuracy(om, ox2, ox1, &accscore);
if (! esl_opt_GetBoolean(go, "--notrace"))
{
p7_OATrace(om, ox2, ox1, tr);
p7_trace_Reuse(tr);
}
}
esl_stopwatch_Stop(w);
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) w->user;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
if (esl_opt_GetBoolean(go, "-c") || esl_opt_GetBoolean(go, "-x") )
{
gx1 = p7_gmx_Create(gm->M, L);
gx2 = p7_gmx_Create(gm->M, L);
p7_GForward (dsq, L, gm, gx1, &fsc_g);
p7_GBackward(dsq, L, gm, gx2, &bsc_g);
p7_GDecoding(gm, gx1, gx2, gx2);
p7_GOptimalAccuracy(gm, gx2, gx1, &accscore_g);
printf("generic: fwd=%8.4f bck=%8.4f acc=%8.4f\n", fsc_g, bsc_g, accscore_g);
printf("VMX: fwd=%8.4f bck=%8.4f acc=%8.4f\n", fsc, bsc, accscore);
p7_gmx_Destroy(gx1);
p7_gmx_Destroy(gx2);
}
free(dsq);
p7_omx_Destroy(ox1);
p7_omx_Destroy(ox2);
p7_trace_Destroy(tr);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_GMX *gx = NULL;
P7_OMX *fwd = NULL;
P7_TRACE *tr = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float sc, fsc, vsc;
float bestsc = -eslINFINITY;
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);
gm = p7_profile_Create(hmm->M, abc); p7_ProfileConfig(hmm, bg, gm, L, p7_UNILOCAL);
om = p7_oprofile_Create(gm->M, abc); p7_oprofile_Convert(gm, om);
fwd = p7_omx_Create(gm->M, L, L);
gx = p7_gmx_Create(gm->M, L);
tr = p7_trace_Create();
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_GViterbi(dsq, L, gm, gx, &vsc);
p7_Forward (dsq, L, om, fwd, &fsc);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
p7_StochasticTrace(r, dsq, L, om, fwd, tr);
p7_trace_Score(tr, dsq, gm, &sc);
bestsc = ESL_MAX(bestsc, sc);
p7_trace_Reuse(tr);
}
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("forward sc = %.4f nats\n", fsc);
printf("viterbi sc = %.4f nats\n", vsc);
printf("max trace sc = %.4f nats\n", bestsc);
free(dsq);
p7_trace_Destroy(tr);
p7_gmx_Destroy(gx);
p7_omx_Destroy(fwd);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
/* serial_master()
* The serial version of hmmsearch.
* For each query HMM in <hmmdb> search the database for hits.
*
* A master can only return if it's successful. All errors are handled
* immediately and fatally with p7_Fail().
*/
static int
serial_master(ESL_GETOPTS *go, struct cfg_s *cfg)
{
FILE *ofp = stdout; /* output file for results (default stdout) */
FILE *tblfp = NULL; /* output stream for tabular per-seq (--tblout) */
FILE *dfamtblfp = NULL; /* output stream for tabular Dfam format (--dfamtblout) */
FILE *aliscoresfp = NULL; /* output stream for alignment scores (--aliscoresout) */
// P7_HMM *hmm = NULL; /* one HMM query */
// P7_SCOREDATA *scoredata = NULL;
int seqfmt = eslSQFILE_UNKNOWN; /* format of seqfile */
ESL_SQFILE *sqfp = NULL; /* open seqfile */
P7_HMMFILE *hfp = NULL; /* open HMM database file */
ESL_ALPHABET *abc = NULL; /* sequence alphabet */
P7_OPROFILE *om = NULL; /* target profile */
ESL_STOPWATCH *w = NULL; /* timing */
ESL_SQ *qsq = NULL; /* query sequence */
int nquery = 0;
int textw;
int status = eslOK;
int hstatus = eslOK;
int sstatus = eslOK;
int i;
int ncpus = 0;
int infocnt = 0;
WORKER_INFO *info = NULL;
#ifdef HMMER_THREADS
P7_OM_BLOCK *block = NULL;
ESL_THREADS *threadObj= NULL;
ESL_WORK_QUEUE *queue = NULL;
#endif
char errbuf[eslERRBUFSIZE];
double window_beta = -1.0 ;
int window_length = -1;
if (esl_opt_IsUsed(go, "--w_beta")) { if ( ( window_beta = esl_opt_GetReal(go, "--w_beta") ) < 0 || window_beta > 1 ) esl_fatal("Invalid window-length beta value\n"); }
if (esl_opt_IsUsed(go, "--w_length")) { if (( window_length = esl_opt_GetInteger(go, "--w_length")) < 4 ) esl_fatal("Invalid window length value\n"); }
w = esl_stopwatch_Create();
if (esl_opt_GetBoolean(go, "--notextw")) textw = 0;
else textw = esl_opt_GetInteger(go, "--textw");
/* If caller declared an input format, decode it */
if (esl_opt_IsOn(go, "--qformat")) {
seqfmt = esl_sqio_EncodeFormat(esl_opt_GetString(go, "--qformat"));
if (seqfmt == eslSQFILE_UNKNOWN) p7_Fail("%s is not a recognized input sequence file format\n", esl_opt_GetString(go, "--qformat"));
}
/* validate options if running as a daemon */
// if (esl_opt_IsOn(go, "--daemon")) {
/* running as a daemon, the input format must be type daemon */
// if (seqfmt != eslSQFILE_UNKNOWN && seqfmt != eslSQFILE_DAEMON)
// esl_fatal("Input format %s not supported. Must be daemon\n", esl_opt_GetString(go, "--qformat"));
// seqfmt = eslSQFILE_DAEMON;
// if (strcmp(cfg->seqfile, "-") != 0) esl_fatal("Query sequence file must be '-'\n");
// }
/* Open the target profile database to get the sequence alphabet */
status = p7_hmmfile_OpenE(cfg->hmmfile, p7_HMMDBENV, &hfp, errbuf);
if (status == eslENOTFOUND) p7_Fail("File existence/permissions problem in trying to open HMM file %s.\n%s\n", cfg->hmmfile, errbuf);
else if (status == eslEFORMAT) p7_Fail("File format problem, trying to open HMM file %s.\n%s\n", cfg->hmmfile, errbuf);
else if (status != eslOK) p7_Fail("Unexpected error %d in opening HMM file %s.\n%s\n", status, cfg->hmmfile, errbuf);
if (! hfp->is_pressed) p7_Fail("Failed to open binary auxfiles for %s: use hmmpress first\n", hfp->fname);
hstatus = p7_oprofile_ReadMSV(hfp, &abc, &om);
if (hstatus == eslEFORMAT) p7_Fail("bad format, binary auxfiles, %s:\n%s", cfg->hmmfile, hfp->errbuf);
else if (hstatus == eslEINCOMPAT) p7_Fail("HMM file %s contains different alphabets", cfg->hmmfile);
else if (hstatus != eslOK) p7_Fail("Unexpected error in reading HMMs from %s", cfg->hmmfile);
p7_oprofile_Destroy(om);
p7_hmmfile_Close(hfp);
/* Open the query sequence database */
status = esl_sqfile_OpenDigital(abc, cfg->seqfile, seqfmt, NULL, &sqfp);
if (status == eslENOTFOUND) p7_Fail("Failed to open sequence file %s for reading\n", cfg->seqfile);
else if (status == eslEFORMAT) p7_Fail("Sequence file %s is empty or misformatted\n", cfg->seqfile);
else if (status == eslEINVAL) p7_Fail("Can't autodetect format of a stdin or .gz seqfile");
else if (status != eslOK) p7_Fail("Unexpected error %d opening sequence file %s\n", status, cfg->seqfile);
if (sqfp->format > 100) // breaking the law! That range is reserved for msa, for aligned formats
p7_Fail("%s contains a multiple sequence alignment; expect unaligned sequences, like FASTA\n", cfg->seqfile);
qsq = esl_sq_CreateDigital(abc);
/* Open the results output files */
if (esl_opt_IsOn(go, "-o")) { if ((ofp = fopen(esl_opt_GetString(go, "-o"), "w")) == NULL) esl_fatal("Failed to open output file %s for writing\n", esl_opt_GetString(go, "-o")); }
if (esl_opt_IsOn(go, "--tblout")) { if ((tblfp = fopen(esl_opt_GetString(go, "--tblout"), "w")) == NULL) esl_fatal("Failed to open tabular per-seq output file %s for writing\n", esl_opt_GetString(go, "--tblfp")); }
if (esl_opt_IsOn(go, "--dfamtblout")) { if ((dfamtblfp = fopen(esl_opt_GetString(go, "--dfamtblout"),"w")) == NULL) esl_fatal("Failed to open tabular dfam output file %s for writing\n", esl_opt_GetString(go, "--dfamtblout")); }
if (esl_opt_IsOn(go, "--aliscoresout")) { if ((aliscoresfp = fopen(esl_opt_GetString(go, "--aliscoresout"),"w")) == NULL) esl_fatal("Failed to open alignment scores output file %s for writing\n", esl_opt_GetString(go, "--aliscoresout")); }
output_header(ofp, go, cfg->hmmfile, cfg->seqfile);
#ifdef HMMER_THREADS
/* initialize thread data */
if (esl_opt_IsOn(go, "--cpu")) ncpus = esl_opt_GetInteger(go, "--cpu");
else esl_threads_CPUCount(&ncpus);
if (ncpus > 0)
{
threadObj = esl_threads_Create(&pipeline_thread);
queue = esl_workqueue_Create(ncpus * 2);
}
#endif
infocnt = (ncpus == 0) ? 1 : ncpus;
ESL_ALLOC(info, sizeof(*info) * infocnt);
for (i = 0; i < infocnt; ++i)
{
info[i].bg = p7_bg_Create(abc);
#ifdef HMMER_THREADS
info[i].queue = queue;
#endif
}
#ifdef HMMER_THREADS
for (i = 0; i < ncpus * 2; ++i)
{
block = p7_oprofile_CreateBlock(BLOCK_SIZE);
if (block == NULL) esl_fatal("Failed to allocate sequence block");
status = esl_workqueue_Init(queue, block);
if (status != eslOK) esl_fatal("Failed to add block to work queue");
}
#endif
/* Outside loop: over each query sequence in <seqfile>. */
while ((sstatus = esl_sqio_Read(sqfp, qsq)) == eslOK)
{
if (sstatus == eslEMEM) p7_Fail("Memory allocation error reading sequence file\n", status);
if (sstatus == eslEINCONCEIVABLE) p7_Fail("Unexpected error %d reading sequence file\n", status);
// if (qsq->L > NHMMER_MAX_RESIDUE_COUNT) p7_Fail("Input sequence %s in file %s exceeds maximum length of %d bases.\n", qsq->name, cfg->seqfile, NHMMER_MAX_RESIDUE_COUNT);
nquery++;
esl_stopwatch_Start(w);
/* Open the target profile database */
status = p7_hmmfile_OpenE(cfg->hmmfile, p7_HMMDBENV, &hfp, NULL);
if (status != eslOK) p7_Fail("Unexpected error %d in opening hmm file %s.\n", status, cfg->hmmfile);
#ifdef HMMER_THREADS
/* if we are threaded, create a lock to prevent multiple readers */
if (ncpus > 0)
{
status = p7_hmmfile_CreateLock(hfp);
if (status != eslOK) p7_Fail("Unexpected error %d creating lock\n", status);
}
#endif
if (fprintf(ofp, "Query: %s [L=%ld]\n", qsq->name, (long) qsq->n) < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
if (qsq->acc[0] != 0 && fprintf(ofp, "Accession: %s\n", qsq->acc) < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
if (qsq->desc[0] != 0 && fprintf(ofp, "Description: %s\n", qsq->desc) < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
for (i = 0; i < infocnt; ++i)
{
/* Create processing pipeline and hit list */
info[i].th = p7_tophits_Create();
info[i].pli = p7_pipeline_Create(go, 100, 100, TRUE, p7_SCAN_MODELS); /* M_hint = 100, L_hint = 100 are just dummies for now */
info[i].pli->hfp = hfp; /* for two-stage input, pipeline needs <hfp> */
p7_pli_NewSeq(info[i].pli, qsq);
info[i].qsq = qsq;
if ( esl_opt_IsUsed(go, "--toponly") )
info[i].pli->strand = p7_STRAND_TOPONLY;
else if ( esl_opt_IsUsed(go, "--bottomonly") )
info[i].pli->strand = p7_STRAND_BOTTOMONLY;
else
info[i].pli->strand = p7_STRAND_BOTH;
#ifdef HMMER_THREADS
if (ncpus > 0) esl_threads_AddThread(threadObj, &info[i]);
#endif
}
#ifdef HMMER_THREADS
if (ncpus > 0) hstatus = thread_loop(threadObj, queue, hfp);
else hstatus = serial_loop(info, hfp);
#else
hstatus = serial_loop(info, hfp);
#endif
switch(hstatus)
{
case eslEFORMAT: p7_Fail("bad file format in HMM file %s", cfg->hmmfile); break;
case eslEINCOMPAT: p7_Fail("HMM file %s contains different alphabets", cfg->hmmfile); break;
case eslEOF:
case eslOK: /* do nothing */
break;
default: p7_Fail("Unexpected error in reading HMMs from %s", cfg->hmmfile);
}
/* merge the results of the search results */
for (i = 1; i < infocnt; ++i)
{
p7_tophits_Merge(info[0].th, info[i].th);
p7_pipeline_Merge(info[0].pli, info[i].pli);
p7_pipeline_Destroy(info[i].pli);
p7_tophits_Destroy(info[i].th);
}
/* modify e-value to account for number of models */
for (i = 0; i < info->th->N ; i++)
{
info->th->unsrt[i].lnP += log((float)info->pli->nmodels);
info->th->unsrt[i].dcl[0].lnP = info->th->unsrt[i].lnP;
info->th->unsrt[i].sortkey = -1.0 * info->th->unsrt[i].lnP;
}
/* it's possible to have duplicates based on how viterbi ranges can overlap */
p7_tophits_SortByModelnameAndAlipos(info->th);
p7_tophits_RemoveDuplicates(info->th, info->pli->use_bit_cutoffs);
/* Print results */
p7_tophits_SortBySortkey(info->th);
p7_tophits_Threshold(info->th, info->pli);
//tally up total number of hits and target coverage
info->pli->n_output = info->pli->pos_output = 0;
for (i = 0; i < info->th->N; i++) {
if ( (info->th->hit[i]->flags & p7_IS_REPORTED) || info->th->hit[i]->flags & p7_IS_INCLUDED) {
info->pli->n_output++;
info->pli->pos_output += abs(info->th->hit[i]->dcl[0].jali - info->th->hit[i]->dcl[0].iali) + 1;
}
}
p7_tophits_Targets(ofp, info->th, info->pli, textw); if (fprintf(ofp, "\n\n") < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
p7_tophits_Domains(ofp, info->th, info->pli, textw); if (fprintf(ofp, "\n\n") < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
if (tblfp) p7_tophits_TabularTargets(tblfp, qsq->name, qsq->acc, info->th, info->pli, (nquery == 1));
if (dfamtblfp) p7_tophits_TabularXfam(dfamtblfp, qsq->name, NULL, info->th, info->pli);
if (aliscoresfp) p7_tophits_AliScores(aliscoresfp, qsq->name, info->th );
esl_stopwatch_Stop(w);
info->pli->nseqs = 1;
p7_pli_Statistics(ofp, info->pli, w);
if (fprintf(ofp, "//\n") < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed");
fflush(ofp);
p7_hmmfile_Close(hfp);
p7_pipeline_Destroy(info->pli);
p7_tophits_Destroy(info->th);
esl_sq_Reuse(qsq);
}
if (sstatus == eslEFORMAT) esl_fatal("Parse failed (sequence file %s):\n%s\n",
sqfp->filename, esl_sqfile_GetErrorBuf(sqfp));
else if (sstatus != eslEOF) esl_fatal("Unexpected error %d reading sequence file %s",
sstatus, sqfp->filename);
/* Terminate outputs - any last words?
*/
if (tblfp) p7_tophits_TabularTail(tblfp, "hmmscan", p7_SCAN_MODELS, cfg->seqfile, cfg->hmmfile, go);
if (ofp) { if (fprintf(ofp, "[ok]\n") < 0) ESL_EXCEPTION_SYS(eslEWRITE, "write failed"); }
/* Cleanup - prepare for successful exit
*/
for (i = 0; i < infocnt; ++i)
p7_bg_Destroy(info[i].bg);
#ifdef HMMER_THREADS
if (ncpus > 0)
{
esl_workqueue_Reset(queue);
while (esl_workqueue_Remove(queue, (void **) &block) == eslOK)
p7_oprofile_DestroyBlock(block);
esl_workqueue_Destroy(queue);
esl_threads_Destroy(threadObj);
}
#endif
free(info);
esl_sq_Destroy(qsq);
esl_stopwatch_Destroy(w);
esl_alphabet_Destroy(abc);
esl_sqfile_Close(sqfp);
if (ofp != stdout) fclose(ofp);
if (tblfp) fclose(tblfp);
if (dfamtblfp) fclose(dfamtblfp);
if (aliscoresfp) fclose(aliscoresfp);
return eslOK;
ERROR:
if (ofp != stdout) fclose(ofp);
if (tblfp) fclose(tblfp);
if (dfamtblfp) fclose(dfamtblfp);
if (aliscoresfp) fclose(aliscoresfp);
return status;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
int N = esl_opt_GetInteger(go, "-N");
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_TRACE *tr = NULL;
ESL_SQ *sq = NULL;
P7_ALIDISPLAY *ad = NULL;
int i,z;
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");
p7_hmmfile_Close(hfp);
bg = p7_bg_Create(abc);
p7_bg_SetLength(bg, 0);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, 0, p7_UNIGLOCAL); /* that sets N,C,J to generate nothing */
om = p7_oprofile_Create(gm->M, abc);
p7_oprofile_Convert(gm, om);
if (esl_opt_GetBoolean(go, "-p")) tr = p7_trace_CreateWithPP();
else tr = p7_trace_Create();
sq = esl_sq_CreateDigital(abc);
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
p7_ProfileEmit(r, hmm, gm, bg, sq, tr);
esl_sq_SetName(sq, "random");
if (! esl_opt_GetBoolean(go, "-b"))
{
if (esl_opt_GetBoolean(go, "-p"))
for (z = 0; z < tr->N; z++)
if (tr->i[z] > 0) tr->pp[z] = esl_random(r);
ad = p7_alidisplay_Create(tr, 0, om, sq);
p7_alidisplay_Print(stdout, ad, 40, 80, FALSE);
p7_alidisplay_Destroy(ad);
}
p7_trace_Reuse(tr);
esl_sq_Reuse(sq);
}
esl_stopwatch_Stop(w);
esl_stopwatch_Display(stdout, w, "# CPU time: ");
esl_sq_Destroy(sq);
p7_trace_Destroy(tr);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
esl_alphabet_Destroy(abc);
esl_randomness_Destroy(r);
esl_stopwatch_Destroy(w);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_GMX *gx = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float sc;
double base_time, bench_time, Mcs;
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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_UNILOCAL);
gx = p7_gmx_Create(gm->M, L);
/* Baseline time. */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++) esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
esl_stopwatch_Stop(w);
base_time = w->user;
/* Benchmark time. */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
p7_GViterbi (dsq, L, gm, gx, &sc);
}
esl_stopwatch_Stop(w);
bench_time = w->user - base_time;
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) bench_time;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_gmx_Destroy(gx);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
int
main(int argc, char **argv)
{
ESL_GETOPTS *go = esl_getopts_CreateDefaultApp(options, 1, argc, argv, banner, usage);
char *hmmfile = esl_opt_GetArg(go, 1);
ESL_STOPWATCH *w = esl_stopwatch_Create();
ESL_RANDOMNESS *r = esl_randomness_CreateFast(esl_opt_GetInteger(go, "-s"));
ESL_ALPHABET *abc = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
P7_GMX *gx = NULL;
P7_OMX *fwd = NULL;
P7_OMX *bck = NULL;
int L = esl_opt_GetInteger(go, "-L");
int N = esl_opt_GetInteger(go, "-N");
ESL_DSQ *dsq = malloc(sizeof(ESL_DSQ) * (L+2));
int i;
float fsc, bsc;
float fsc2, bsc2;
double base_time, bench_time, Mcs;
p7_FLogsumInit();
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);
gm = p7_profile_Create(hmm->M, abc);
p7_ProfileConfig(hmm, bg, gm, L, p7_LOCAL);
om = p7_oprofile_Create(gm->M, abc);
p7_oprofile_Convert(gm, om);
p7_oprofile_ReconfigLength(om, L);
if (esl_opt_GetBoolean(go, "-x") && p7_FLogsumError(-0.4, -0.5) > 0.0001)
p7_Fail("-x here requires p7_Logsum() recompiled in slow exact mode");
if (esl_opt_GetBoolean(go, "-P")) {
fwd = p7_omx_Create(gm->M, 0, L);
bck = p7_omx_Create(gm->M, 0, L);
} else {
fwd = p7_omx_Create(gm->M, L, L);
bck = p7_omx_Create(gm->M, L, L);
}
gx = p7_gmx_Create(gm->M, L);
/* Get a baseline time: how long it takes just to generate the sequences */
esl_stopwatch_Start(w);
for (i = 0; i < N; i++) esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
esl_stopwatch_Stop(w);
base_time = w->user;
esl_stopwatch_Start(w);
for (i = 0; i < N; i++)
{
esl_rsq_xfIID(r, bg->f, abc->K, L, dsq);
if (esl_opt_GetBoolean(go, "-P")) {
if (! esl_opt_GetBoolean(go, "-B")) p7_ForwardParser (dsq, L, om, fwd, &fsc);
if (! esl_opt_GetBoolean(go, "-F")) p7_BackwardParser(dsq, L, om, fwd, bck, &bsc);
} else {
if (! esl_opt_GetBoolean(go, "-B")) p7_Forward (dsq, L, om, fwd, &fsc);
if (! esl_opt_GetBoolean(go, "-F")) p7_Backward(dsq, L, om, fwd, bck, &bsc);
}
if (esl_opt_GetBoolean(go, "-c") || esl_opt_GetBoolean(go, "-x"))
{
p7_GForward (dsq, L, gm, gx, &fsc2);
p7_GBackward(dsq, L, gm, gx, &bsc2);
printf("%.4f %.4f %.4f %.4f\n", fsc, bsc, fsc2, bsc2);
}
}
esl_stopwatch_Stop(w);
bench_time = w->user - base_time;
Mcs = (double) N * (double) L * (double) gm->M * 1e-6 / (double) bench_time;
esl_stopwatch_Display(stdout, w, "# CPU time: ");
printf("# M = %d\n", gm->M);
printf("# %.1f Mc/s\n", Mcs);
free(dsq);
p7_omx_Destroy(bck);
p7_omx_Destroy(fwd);
p7_gmx_Destroy(gx);
p7_oprofile_Destroy(om);
p7_profile_Destroy(gm);
p7_bg_Destroy(bg);
p7_hmm_Destroy(hmm);
p7_hmmfile_Close(hfp);
esl_alphabet_Destroy(abc);
esl_stopwatch_Destroy(w);
esl_randomness_Destroy(r);
esl_getopts_Destroy(go);
return 0;
}
