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;
}
void
worker_process(ESL_GETOPTS *go)
{
HMMD_COMMAND *cmd = NULL; /* see hmmpgmd.h */
int shutdown = 0;
WORKER_ENV env;
int status;
/* Initializations */
impl_Init();
p7_FLogsumInit(); /* we're going to use table-driven Logsum() approximations at times */
if (esl_opt_IsOn(go, "--cpu")) env.ncpus = esl_opt_GetInteger(go, "--cpu");
else esl_threads_CPUCount(&env.ncpus);
env.hmm_db = NULL;
env.seq_db = NULL;
env.fd = setup_masterside_comm(go);
while (!shutdown)
{
if ((status = read_Command(&cmd, &env)) != eslOK) break;
switch (cmd->hdr.command) {
case HMMD_CMD_INIT: process_InitCmd (cmd, &env); break;
case HMMD_CMD_SCAN: process_SearchCmd(cmd, &env); break;
case HMMD_CMD_SEARCH: process_SearchCmd(cmd, &env); break;
case HMMD_CMD_SHUTDOWN: process_Shutdown (cmd, &env); shutdown = 1; break;
default: p7_syslog(LOG_ERR,"[%s:%d] - unknown command %d (%d)\n", __FILE__, __LINE__, cmd->hdr.command, cmd->hdr.length);
}
free(cmd);
cmd = NULL;
}
if (env.hmm_db) p7_hmmcache_Close(env.hmm_db);
if (env.seq_db) p7_seqcache_Close(env.seq_db);
if (env.fd != -1) close(env.fd);
return;
}
static void
process_InitCmd(HMMD_COMMAND *cmd, WORKER_ENV *env)
{
char *p;
int n;
int status;
if (env->hmm_db != NULL) p7_hmmcache_Close(env->hmm_db);
if (env->seq_db != NULL) p7_seqcache_Close(env->seq_db);
env->hmm_db = NULL;
env->seq_db = NULL;
/* load the sequence database */
if (cmd->init.db_cnt != 0) {
P7_SEQCACHE *sdb = NULL;
p = cmd->init.data + cmd->init.seqdb_off;
status = p7_seqcache_Open(p, &sdb, NULL);
if (status != eslOK) {
p7_syslog(LOG_ERR,"[%s:%d] - p7_seqcache_Open %s error %d\n", __FILE__, __LINE__, p, status);
LOG_FATAL_MSG("cache seqdb error", status);
}
/* validate the sequence database */
cmd->init.sid[MAX_INIT_DESC-1] = 0;
if (strcmp (cmd->init.sid, sdb->id) != 0 || cmd->init.db_cnt != sdb->db_cnt || cmd->init.seq_cnt != sdb->count) {
p7_syslog(LOG_ERR,"[%s:%d] - seq db %s: integrity error %s - %s\n", __FILE__, __LINE__, p, cmd->init.sid, sdb->id);
LOG_FATAL_MSG("database integrity error", 0);
}
env->seq_db = sdb;
}
/* load the hmm database */
if (cmd->init.hmm_cnt != 0) {
P7_HMMCACHE *hcache = NULL;
p = cmd->init.data + cmd->init.hmmdb_off;
status = p7_hmmcache_Open(p, &hcache, NULL);
if (status != eslOK) {
p7_syslog(LOG_ERR,"[%s:%d] - p7_hmmcache_Open %s error %d\n", __FILE__, __LINE__, p, status);
LOG_FATAL_MSG("cache hmmdb error", status);
}
if ( (status = p7_hmmcache_SetNumericNames(hcache)) != eslOK){
p7_syslog(LOG_ERR,"[%s:%d] - p7_hmmcache_SetNumericNames %s error %d\n", __FILE__, __LINE__, p, status);
LOG_FATAL_MSG("cache hmmdb error", status);
}
/* validate the hmm database */
cmd->init.hid[MAX_INIT_DESC-1] = 0;
/* TODO: come up with a new pressed format with an id to compare - strcmp (cmd->init.hid, hdb->id) != 0 */
if (cmd->init.hmm_cnt != 1 || cmd->init.model_cnt != hcache->n) {
p7_syslog(LOG_ERR,"[%s:%d] - hmm db %s: integrity error\n", __FILE__, __LINE__, p);
LOG_FATAL_MSG("database integrity error", 0);
}
env->hmm_db = hcache;
printf("Loaded profile db %s; models: %d memory: %" PRId64 "\n",
p, hcache->n, (uint64_t) p7_hmmcache_Sizeof(hcache));
}
/* if stdout is redirected at the commandline, it causes printf's to be buffered,
* which means status logging isn't printed. This line strongly requests unbuffering,
* which should be ok, given the low stdout load of hmmpgmd
*/
setvbuf (stdout, NULL, _IONBF, BUFSIZ);
printf("Data loaded into memory. Worker is ready.\n");
setvbuf (stdout, NULL, _IOFBF, BUFSIZ);
/* write back to the master that we are on line */
n = MSG_SIZE(cmd);
cmd->hdr.status = eslOK;
if (writen(env->fd, cmd, n) != n) {
LOG_FATAL_MSG("write error", errno);
}
}
/* Function: p7_hmmcache_Open()
* Synopsis: Cache a profile database.
*
* Purpose: Open <hmmfile> and read all of its contents, creating
* a cached profile database in memory. Return a ptr to the
* cached profile database in <*ret_cache>.
*
* Caller may optionally provide an <errbuf> ptr to
* at least <eslERRBUFSIZE> bytes, to capture an
* informative error message on failure.
*
* Args: hmmfile - (base) name of profile file to open
* ret_cache - RETURN: cached profile database
* errbuf - optRETURN: error message for a failure
*
* Returns: <eslOK> on success. <*ret_cache> points to the
* cached db. <errbuf> is unchanged.
*
* Failure codes:
* <eslENOTFOUND> : <hmmfile> couldn't be opened for reading
* <eslEFORMAT> : <hmmfile> isn't in recognized HMMER file format
* <eslEINCOMPAT> : profiles in <hmmfile> have different alphabets
*
* On any failure, <*ret_cache> is <NULL> and <errbuf> contains
* an informative error message for the user.
*
* Throws: <eslEMEM> : memory allocation error.
*/
int
p7_hmmcache_Open(char *hmmfile, P7_HMMCACHE **ret_cache, char *errbuf)
{
P7_HMMCACHE *cache = NULL;
P7_HMMFILE *hfp = NULL;
P7_HMM *hmm = NULL;
P7_BG *bg = NULL;
P7_PROFILE *gm = NULL;
P7_OPROFILE *om = NULL;
int status;
if (errbuf) errbuf[0] = '\0';
ESL_ALLOC(cache, sizeof(P7_HMMCACHE));
cache->name = NULL;
cache->abc = NULL;
cache->omlist = NULL;
cache->gmlist = NULL;
cache->lalloc = 4096; /* allocation chunk size for <list> of ptrs */
cache->n = 0;
if ( ( status = esl_strdup(hmmfile, -1, &cache->name) != eslOK)) goto ERROR;
ESL_ALLOC(cache->omlist, sizeof(P7_OPROFILE *) * cache->lalloc);
ESL_ALLOC(cache->gmlist, sizeof(P7_PROFILE *) * cache->lalloc);
if ( (status = p7_hmmfile_OpenE(hmmfile, NULL, &hfp, errbuf)) != eslOK) goto ERROR; // eslENOTFOUND | eslEFORMAT; <errbuf>
while ((status = p7_hmmfile_Read(hfp, &(cache->abc), &hmm)) != eslEOF) // eslEFORMAT | eslEINCOMPAT; <errbuf>
{
if (status != eslOK) ESL_XFAIL(status, errbuf, "%s", hfp->errbuf);
if (!bg && (bg = p7_bg_Create(cache->abc)) == NULL) { status = eslEMEM; goto ERROR; }
if ( ( gm = p7_profile_Create(hmm->M, cache->abc)) == NULL) { status = eslEMEM; goto ERROR; }
if ( (status = p7_profile_Config(gm, hmm, bg)) != eslOK) goto ERROR;
if ( (status = p7_oprofile_ReadMSV (hfp, &(cache->abc), &om)) != eslOK || /* eslEFORMAT: hfp->errbuf | eslEINCOMPAT | eslEOF */
(status = p7_oprofile_ReadRest(hfp, om)) != eslOK) /* eslEFORMAT: hfp->errbuf */
{
if (status == eslEOF) ESL_XFAIL(eslEFORMAT, errbuf, "Premature EOF in vectorized profile files");
else goto ERROR;
}
ESL_DASSERT1(( strcmp(gm->name, om->name) == 0 ));
if (cache->n >= cache->lalloc) {
ESL_REALLOC(cache->gmlist, sizeof(P7_PROFILE *) * cache->lalloc * 2);
ESL_REALLOC(cache->omlist, sizeof(P7_OPROFILE *) * cache->lalloc * 2);
cache->lalloc *= 2;
}
cache->omlist[cache->n] = om;
cache->gmlist[cache->n] = gm;
cache->n++;
om = NULL;
gm = NULL;
p7_hmm_Destroy(hmm);
}
//printf("\nfinal:: %d memory %" PRId64 "\n", inx, total_mem);
p7_hmmfile_Close(hfp);
p7_bg_Destroy(bg);
*ret_cache = cache;
return eslOK;
ERROR:
if (cache) p7_hmmcache_Close(cache);
if (om) p7_oprofile_Destroy(om);
if (gm) p7_profile_Destroy(gm);
if (hmm) p7_hmm_Destroy(hmm);
if (bg) p7_bg_Destroy(bg);
if (hfp) p7_hmmfile_Close(hfp);
return status;
}