BlastQueryInfo* BlastQueryInfoNew(EBlastProgramType program, int num_queries) { const unsigned int kNumContexts = BLAST_GetNumberOfContexts(program); BlastQueryInfo* retval = NULL; if (num_queries <= 0) { return retval; } ASSERT(kNumContexts != 0); retval = (BlastQueryInfo*) calloc(1, sizeof(BlastQueryInfo)); if ( !retval ) { return BlastQueryInfoFree(retval); } retval->num_queries = num_queries; retval->first_context = 0; retval->last_context = retval->num_queries * kNumContexts - 1; retval->contexts = (BlastContextInfo*) calloc(retval->last_context + 1, sizeof(BlastContextInfo)); if ( !retval->contexts ) { return BlastQueryInfoFree(retval); } else { int i; for (i = 0; i < retval->last_context + 1; i++) { retval->contexts[i].query_index = Blast_GetQueryIndexFromContext(i, program); ASSERT(retval->contexts[i].query_index != -1); retval->contexts[i].frame = BLAST_ContextToFrame(program, i); ASSERT(retval->contexts[i].frame != INT1_MAX); retval->contexts[i].is_valid = TRUE; } } return retval; }
SThreadLocalData* SThreadLocalDataFree(SThreadLocalData* tld) { if (tld) { /* Do not destruct score block here, it was just assigned */ if (tld->gap_align != NULL) { tld->gap_align->sbp = NULL; } tld->gap_align = BLAST_GapAlignStructFree(tld->gap_align); tld->score_params = BlastScoringParametersFree(tld->score_params); tld->ext_params = BlastExtensionParametersFree(tld->ext_params); tld->hit_params = BlastHitSavingParametersFree(tld->hit_params); tld->eff_len_params = BlastEffectiveLengthsParametersFree(tld->eff_len_params); tld->query_info = BlastQueryInfoFree(tld->query_info); tld->seqsrc = BlastSeqSrcFree(tld->seqsrc); tld->results = Blast_HSPResultsFree(tld->results); sfree(tld); } return NULL; }
Int2 Blast_RunSearch(SeqLoc* query_seqloc, Blast_PsiCheckpointLoc * psi_checkpoint, const BlastSeqSrc* seq_src, SeqLoc* masking_locs, const SBlastOptions* options, BlastTabularFormatData* tf_data, BlastHSPResults **results, SeqLoc** filter_out, Blast_SummaryReturn* extra_returns) { Int2 status = 0; BLAST_SequenceBlk *query = NULL; BlastQueryInfo* query_info = NULL; double scale_factor = 1.0; BlastSeqLoc* lookup_segments = NULL; BlastScoreBlk* sbp = NULL; LookupTableWrap* lookup_wrap = NULL; BlastMaskLoc* mask_loc = NULL; BlastHSPStream* hsp_stream = NULL; const EBlastProgramType kProgram = options->program; const Boolean kRpsBlast = (kProgram == eBlastTypeRpsBlast || kProgram == eBlastTypeRpsTblastn); BlastRPSInfo* rps_info = NULL; Nlm_MemMapPtr rps_mmap = NULL; Nlm_MemMapPtr rps_pssm_mmap = NULL; const QuerySetUpOptions* query_options = options->query_options; const LookupTableOptions* lookup_options = options->lookup_options; const BlastScoringOptions* score_options = options->score_options; const BlastHitSavingOptions* hit_options = options->hit_options; SBlastOptions* rps_options = NULL; const Boolean kPhiBlast = Blast_ProgramIsPhiBlast(kProgram); const Uint1 kDeallocateMe = 253; Blast_Message *core_msg = NULL; if (!query_seqloc || !seq_src || !options || !extra_returns) return -1; if ((status = BLAST_ValidateOptions(kProgram, options->ext_options, score_options, lookup_options, options->word_options, hit_options, &core_msg)) != 0) { extra_returns->error = Blast_MessageToSBlastMessage(core_msg, NULL, NULL, options->believe_query); core_msg = Blast_MessageFree(core_msg); return status; } if (options->program == eBlastTypeBlastn) { SeqLoc* dust_mask = NULL; /* Dust mask locations */ Blast_FindDustSeqLoc(query_seqloc, options, &dust_mask); /* Combine dust mask with lower case mask The dust mask will be deallocated by the end of this function though as it's copied in BLAST_MainSetUp Not deallocating it will result in a memory leak if masking_locs was NULL at the start of this function */ if (dust_mask) { SeqLoc* dust_mask_var = dust_mask; while (dust_mask_var) { dust_mask_var->choice = kDeallocateMe; dust_mask_var = dust_mask_var->next; } ValNodeLink(&masking_locs, dust_mask); } } if (kRpsBlast) { if ((status = s_RPSExtraStructsSetUp(seq_src, options, &rps_options, &rps_info, &rps_mmap, &rps_pssm_mmap, &scale_factor, extra_returns))) return status; score_options = rps_options->score_options; hit_options = rps_options->hit_options; options = rps_options; /* This will not change the caller's pointer. */ } if ((status = BLAST_SetUpQuery(kProgram, query_seqloc, query_options, masking_locs, &query_info, &query))) { SBlastMessageWrite(&extra_returns->error, SEV_ERROR, "BLAST_SetUpQuery returned non-zero status\n", NULL, FALSE); return status; } status = BLAST_MainSetUp(kProgram, query_options, score_options, query, query_info, scale_factor, &lookup_segments, &mask_loc, &sbp, &core_msg, s_BlastFindMatrixPath); if (core_msg) { extra_returns->error = Blast_MessageToSBlastMessage(core_msg, query_seqloc, query_info, options->believe_query); core_msg = Blast_MessageFree(core_msg); } if (status) return status; if (psi_checkpoint) { core_msg = NULL; status = s_SetupScoreBlkPssmFromChkpt(sbp, query, psi_checkpoint, &core_msg); if (core_msg) { extra_returns->error = Blast_MessageToSBlastMessage(core_msg, query_seqloc, query_info, options->believe_query); core_msg = Blast_MessageFree(core_msg); } if (status) return status; } if (filter_out) { *filter_out = BlastMaskLocToSeqLoc(kProgram, mask_loc, query_seqloc); } /* Mask locations in BlastMaskLoc form are no longer needed. */ BlastMaskLocFree(mask_loc); if (masking_locs) { SeqLocPtr slp_var = masking_locs; SeqLocPtr last = NULL; while (slp_var) { if (slp_var->choice == kDeallocateMe) { if (last == NULL) { masking_locs = slp_var->next; slp_var->next = NULL; Blast_ValNodeMaskListFree(slp_var); slp_var = masking_locs; } else { last->next = slp_var->next; slp_var->next = NULL; Blast_ValNodeMaskListFree(slp_var); slp_var = last->next; } } else { last = slp_var; slp_var = slp_var->next; } } } status = LookupTableWrapInit(query, lookup_options, query_options, lookup_segments, sbp, &lookup_wrap, rps_info, &core_msg); if (core_msg) { extra_returns->error = Blast_MessageToSBlastMessage(core_msg, query_seqloc, query_info, options->believe_query); core_msg = Blast_MessageFree(core_msg); } if (status) return status; /* For PHI BLAST, save information about pattern occurrences in query in the BlastQueryInfo structure. */ if (kPhiBlast) { SPHIPatternSearchBlk* pattern_blk = (SPHIPatternSearchBlk*) lookup_wrap->lut; Blast_SetPHIPatternInfo(kProgram, pattern_blk, query, lookup_segments, query_info, &core_msg); if (core_msg) { extra_returns->error = Blast_MessageToSBlastMessage(core_msg, query_seqloc, query_info, options->believe_query); core_msg = Blast_MessageFree(core_msg); } } /* Only need for the setup of lookup table. */ lookup_segments = BlastSeqLocFree(lookup_segments); if ((status = s_BlastHSPStreamSetUp(query, query_info, seq_src, options, sbp, tf_data, &hsp_stream, extra_returns))) return status; if ((status = s_BlastThreadManager(query, query_info, seq_src, options, lookup_wrap, sbp, hsp_stream, rps_info, tf_data, results, extra_returns))) return status; lookup_wrap = LookupTableWrapFree(lookup_wrap); query = BlastSequenceBlkFree(query); query_info = BlastQueryInfoFree(query_info); BlastScoreBlkFree(sbp); if (kRpsBlast) s_RPSExtraStructsFree(rps_info, rps_mmap, rps_pssm_mmap, rps_options); return status; }