assertion #3110

behrj · 2022-12-06T20:42:43Z

behrj
Dec 6, 2022

Hey there,

Not sure this is the right place to write this, but I also could not find another one. If you have a forum somewhere that you are using more actively, please let me know.
I started switching to seqan3 recently and I ran into one thing that I cannot easily resolve by myself. Doing a banded alignment on a number of rather small sequences runs into this assertion below deterministically. I looked precisely at the pair of sequences that trigger the assertion, but they look fine and without running the whole batch before, I cannot trigger the issue.
When I remove the config for banded alignment, then everything is smooth.

If you have an idea, how I could reproduce that with a minimal dataset, that I could also share, please let me know.

Best,
Jonas

seqan3/include/seqan3/alignment/decorator/gap_decorator.hpp:683: void seqan3::gap_decorator<inner_type>::basic_iterator< >::jump(seqan3::gap_decorator<inner_type>::size_type) [with bool = true; inner_type = std::span<seqan3::dna5, 18446744073709551615>; seqan3::gap_decorator<inner_type>::size_type = long unsigned int]: Assertion `new_pos <= host->size()' failed.

marehr · 2022-12-07T00:26:12Z

marehr
Dec 7, 2022
Maintainer

Hi @behrj!

If I needed to debug it, I would either print out the sequences to the terminal and re-try the application with just those sequences (i.e. making the set smaller and smaller by commenting them out), or use for example Visual Studio Code and the built-in debugger to see the trace and the state that your application is in, and why it behaves differently with a set vs. two-sequences.

As you get assertion errors, I assume that you build with cmake -DCMAKE_BUILD_TYPE=Debug <..>.
Can you rerun your batch with valgrind ./myapp --param1 --param2, maybe this will give us some hints.
This can take > 10x the normal application runtime, but will give you a complete stack trace with functions that are involved.

Your stated assertion

seqan3/include/seqan3/alignment/decorator/gap_decorator.hpp

Lines 680 to 683 in cdff3dd

    
           //!\brief A helper function that performs the random access into the anchor set, updating all member variables. 
        
           void jump(typename gap_decorator::size_type const new_pos) 
        
           { 
        
               assert(new_pos <= host->size());

does hint that somewhere in the code, a character of an aligned sequence (= sequence + gaps, e.g. "AC-GT-AC-T") that is represented by the gap_decorator will be accessed out-of-range. It would be interesting if your application has faulty logic, or seqan internally messes something up. Maybe we can figure that out if you provide the stack trace.

BTW I think you could also have opened an issue, but I guess here is fine too.

0 replies

behrj · 2022-12-07T08:22:00Z

behrj
Dec 7, 2022
Author

Hi Marcel, thanks for the quick response.
I had checked with valgrind because I was assuming there is an memory error on my side, but that does not seem to be the case. Please find the stack trace below, I hope this is going to tell you something.
And thanks for looking into this.
I will work on trying to reduce the set of sequences to reproduce the problem.

Cheers,
Jonas

detect_fusions_banded: seqan3/include/seqan3/alignment/decorator/gap_decorator.hpp:683: void seqan3::gap_decorator<inner_type>::basic_iterator< >::jump(seqan3::gap_decorator<inner_type>::size_type) [with bool = true; inner_type = std::span<seqan3::dna5, 18446744073709551615>; seqan3::gap_decorator<inner_type>::size_type = long unsigned int]: Assertion `new_pos <= host->size()' failed.
==47==
==47== Process terminating with default action of signal 6 (SIGABRT)
==47== at 0x4DA10C0: __pthread_kill_implementation (pthread_kill.c:44)
==47== by 0x4D5AB2B: raise (raise.c:26)
==47== by 0x4D474BB: abort (abort.c:79)
==47== by 0x4D54433: __assert_fail_base (assert.c:92)
==47== by 0x4D5449B: __assert_fail (assert.c:101)
==47== by 0x178C9B: seqan3::gap_decorator<std::span<seqan3::dna5, 18446744073709551615ul> >::basic_iterator::jump(unsigned long) (gap_decorator.hpp:683)

seqan3/include/seqan3/alignment/decorator/gap_decorator.hpp

Lines 681 to 684 in fe7458e

    
           void jump(typename gap_decorator::size_type const new_pos) 
        
           { 
        
               assert(new_pos <= host->size()); 
        
               pos = new_pos;

==47== by 0x1AD56B: operator+= (gap_decorator.hpp:799)

seqan3/include/seqan3/alignment/decorator/gap_decorator.hpp

Lines 797 to 801 in fe7458e

    
           basic_iterator & operator+=(difference_type const skip) 
        
           { 
        
               this->jump(this->pos + skip); 
        
               return *this; 
        
           }

==47== by 0x1AD56B: fill_aligned_sequence<std::ranges::reverse_view<std::ranges::ref_view<std::vector<std::pair<seqan3::detail::trace_directions, long unsigned int> > > >, seqan3::gap_decorator<std::span<seqan3::dna5, 18446744073709551615> >, seqan3::gap_decorator<std::span<seqan3::dna5, 18446744073709551615> > > (aligned_sequence_builder.hpp:243)

seqan3/include/seqan3/alignment/matrix/detail/aligned_sequence_builder.hpp

Lines 221 to 245 in fe7458e

    
           template <typename reverse_traces_t, typename fst_aligned_t, typename sec_aligned_t> 
        
           void fill_aligned_sequence(reverse_traces_t && rev_traces, 
        
                                      fst_aligned_t & fst_aligned, 
        
                                      sec_aligned_t & sec_aligned) const 
        
           { 
        
               if (std::ranges::empty(rev_traces)) 
        
                   return; 
        
               auto fst_it = std::ranges::begin(fst_aligned); 
        
               auto sec_it = std::ranges::begin(sec_aligned); 
        
               for (auto const & [dir, span] : rev_traces) 
        
               { 
        
                   assert(dir == trace_directions::up || dir == trace_directions::left || dir == trace_directions::diagonal); 
        
                   if (dir == trace_directions::up) 
        
                       fst_it = insert_gap(fst_aligned, fst_it, span); 
        
                   if (dir == trace_directions::left) 
        
                       sec_it = insert_gap(sec_aligned, sec_it, span); 
        
                   fst_it += span; 
        
                   sec_it += span; 
        
               } 
        
           }

==47== by 0x1AD56B: seqan3::detail::aligned_sequence_builder

==47== by 0x1AD56B: seqan3::detail::aligned_sequence_builder&, std::span&>::result_type seqan3::detail::aligned_sequence_builder&, std::span&>::operator(), (seqan3::detail::matrix_major_order)0>::basic_iterator >, std::default_sentinel_t, (std::ranges::subrange_kind)0> >(std::ranges::subrange, (seqan3::detail::matrix_major_order)0>::basic_iterator >, std::default_sentinel_t, (std::ranges::subrange_kind)0>&&) (aligned_sequence_builder.hpp:207)

seqan3/include/seqan3/alignment/matrix/detail/aligned_sequence_builder.hpp

Lines 171 to 212 in fe7458e

    
           template <std::ranges::input_range trace_path_t> 
        
           result_type operator()(trace_path_t && trace_path) 
        
           { 
        
               static_assert(std::same_as<std::ranges::range_value_t<trace_path_t>, trace_directions>, 
        
                             "The value type of the trace path must be seqan3::detail::trace_directions"); 
        
               result_type res{}; 
        
               auto trace_it = std::ranges::begin(trace_path); 
        
               std::tie(res.first_sequence_slice_positions.second, res.second_sequence_slice_positions.second) = 
        
                   std::pair<size_t, size_t>{trace_it.coordinate()}; 
        
               std::vector<std::pair<trace_directions, size_t>> trace_segments; 
        
               while (trace_it != std::ranges::end(trace_path)) 
        
               { 
        
                   trace_directions last_dir = *trace_it; 
        
                   size_t span = 0; 
        
                   for (; trace_it != std::ranges::end(trace_path) && *trace_it == last_dir; ++trace_it, ++span) 
        
                   {} 
        
                   trace_segments.emplace_back(last_dir, span); 
        
               } 
        
               std::tie(res.first_sequence_slice_positions.first, res.second_sequence_slice_positions.first) = 
        
                   std::pair<size_t, size_t>{trace_it.coordinate()}; 
        
               assign_unaligned( 
        
                   std::get<0>(res.alignment), 
        
                   std::views::all(fst_rng) 
        
                       | views::slice(res.first_sequence_slice_positions.first, res.first_sequence_slice_positions.second)); 
        
               assign_unaligned( 
        
                   std::get<1>(res.alignment), 
        
                   std::views::all(sec_rng) 
        
                       | views::slice(res.second_sequence_slice_positions.first, res.second_sequence_slice_positions.second)); 
        
               // Now we need to insert the values. 
        
               fill_aligned_sequence(trace_segments | std::views::reverse, 
        
                                     std::get<0>(res.alignment), 
        
                                     std::get<1>(res.alignment)); 
        
               return res; 
        
           }

==47== by 0x1AD7CF: void seqan3::detail::alignment_algorithm<...>

==47== by 0x1AD7CF: void seqan3::detail::alignment_algorithm >, seqan3::align_cfg::gap_cost_affine, seqan3::align_cfg::output_score, seqan3::align_cfg::output_begin_position, seqan3::align_cfg::output_end_position, seqan3::align_cfg::band_fixed_size, seqan3::align_cfg::detail::result_type, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> > > >, seqan3::detail::deferred_crtp_base, seqan3::detail::alignment_trace_matrix_full_banded >, seqan3::detail::deferred_crtp_base >, seqan3::detail::deferred_crtp_base, seqan3::detail::deferred_crtp_base, seqan3::detail::deferred_crtp_base > >::make_alignment_result, std::span, std::function, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> >)> >(unsigned long, std::span&, std::span&, std::function, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> >)>&) [clone .isra.0] (alignment_algorithm.hpp:636) ==47== by 0x1ADA1F: compute_single_pair&, std::vector&, std::function, seqan3::detail::advanceable_alignment_coordinate<>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> >)> > (alignment_algorithm.hpp:304)

seqan3/include/seqan3/alignment/pairwise/alignment_algorithm.hpp

Lines 283 to 311 in fe7458e

    
           template <std::ranges::forward_range sequence1_t, std::ranges::forward_range sequence2_t, typename callback_t> 
        
           constexpr void 
        
           compute_single_pair(size_t const idx, sequence1_t && sequence1, sequence2_t && sequence2, callback_t & callback) 
        
           { 
        
               assert(cfg_ptr != nullptr); 
        
               if constexpr (traits_t::is_debug) 
        
                   initialise_debug_matrices(sequence1, sequence2); 
        
               // Reset the alignment state's optimum between executions of the alignment algorithm. 
        
               this->alignment_state.reset_optimum(); 
        
               if constexpr (traits_t::is_banded) 
        
               { 
        
                   using seqan3::get; 
        
                   // Get the band and check if band configuration is valid. 
        
                   auto const & band = get<align_cfg::band_fixed_size>(*cfg_ptr); 
        
                   check_valid_band_parameter(sequence1, sequence2, band); 
        
                   auto && [subsequence1, subsequence2] = this->slice_sequences(sequence1, sequence2, band); 
        
                   // It would be great to use this interface here instead 
        
                   compute_matrix(subsequence1, subsequence2, band); 
        
                   make_alignment_result(idx, subsequence1, subsequence2, callback); 
        
               } 
        
               else 
        
               { 
        
                   compute_matrix(sequence1, sequence2); 
        
                   make_alignment_result(idx, sequence1, sequence2, callback); 
        
               } 
        
           }

==47== by 0x1ADA1F: operator()<std::ranges::subrange<seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, (std::ranges::subrange_kind)1>, std::function<void(seqan3::alignment_result<seqan3::detail::alignment_result_value_type<std::nullopt_t*, std::nullopt_t*, int, seqan3::detail::advanceable_alignment_coordinate<>, seqan3::detail::advanceable_alignment_coordinate<>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> >)> > (alignment_algorithm.hpp:200)

seqan3/include/seqan3/alignment/pairwise/alignment_algorithm.hpp

Lines 193 to 201 in fe7458e

    
           template <indexed_sequence_pair_range indexed_sequence_pairs_t, typename callback_t> 
        
               requires (!traits_t::is_vectorised) && std::invocable<callback_t, alignment_result_t> 
        
           void operator()(indexed_sequence_pairs_t && indexed_sequence_pairs, callback_t && callback) 
        
           { 
        
               using std::get; 
        
               for (auto && [sequence_pair, idx] : indexed_sequence_pairs) 
        
                   compute_single_pair(idx, get<0>(sequence_pair), get<1>(sequence_pair), callback); 
        
           }

==47== by 0x1ADA1F: __invoke_impl

==47== by 0x1ADA1F: __invoke_impl<void, seqan3::detail::alignment_algorithm<seqan3::configuration<seqan3::align_cfg::method_global, seqan3::align_cfg::scoring_scheme<seqan3::nucleotide_scoring_scheme >, seqan3::align_cfg::gap_cost_affine, seqan3::align_cfg::output_score, seqan3::align_cfg::output_begin_position, seqan3::align_cfg::output_end_position, seqan3::align_cfg::band_fixed_size, seqan3::align_cfg::detail::result_type<seqan3::alignment_result<seqan3::detail::alignment_result_value_type<std::nullopt_t*, std::nullopt_t*, int, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> > > >, seqan3::detail::deferred_crtp_base<seqan3::detail::alignment_matrix_policy, seqan3::detail::alignment_score_matrix_one_column_banded, seqan3::detail::alignment_trace_matrix_full_banded<seqan3::detail::trace_directions, false> >, seqan3::detail::deferred_crtp_base<seqan3::detail::affine_gap_policy, int, std::integral_constant<bool, false> >, seqan3::detail::deferred_crtp_baseseqan3::detail::find_optimum_policy, seqan3::detail::deferred_crtp_baseseqan3::detail::affine_gap_init_policy, seqan3::detail::deferred_crtp_base<seqan3::detail::scoring_scheme_policy, seqan3::nucleotide_scoring_scheme > >&, std::ranges::subrange<seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, (std::ranges::subrange_kind)1>, std::function<void(seqan3::alignment_result<seqan3::detail::alignment_result_value_type<std::nullopt_t*, std::nullopt_t*, int, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> >)> > (invoke.h:61)
==47== by 0x1ADA1F: __invoke_r<void, seqan3::detail::alignment_algorithm<seqan3::configuration<seqan3::align_cfg::method_global, seqan3::align_cfg::scoring_scheme<seqan3::nucleotide_scoring_scheme >, seqan3::align_cfg::gap_cost_affine, seqan3::align_cfg::output_score, seqan3::align_cfg::output_begin_position, seqan3::align_cfg::output_end_position, seqan3::align_cfg::band_fixed_size, seqan3::align_cfg::detail::result_type<seqan3::alignment_result<seqan3::detail::alignment_result_value_type<std::nullopt_t*, std::nullopt_t*, int, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> > > >, seqan3::detail::deferred_crtp_base<seqan3::detail::alignment_matrix_policy, seqan3::detail::alignment_score_matrix_one_column_banded, seqan3::detail::alignment_trace_matrix_full_banded<seqan3::detail::trace_directions, false> >, seqan3::detail::deferred_crtp_base<seqan3::detail::affine_gap_policy, int, std::integral_constant<bool, false> >, seqan3::detail::deferred_crtp_baseseqan3::detail::find_optimum_policy, seqan3::detail::deferred_crtp_baseseqan3::detail::affine_gap_init_policy, seqan3::detail::deferred_crtp_base<seqan3::detail::scoring_scheme_policy, seqan3::nucleotide_scoring_scheme > >&, std::ranges::subrange<seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, (std::ranges::subrange_kind)1>, std::function<void(seqan3::alignment_result<seqan3::detail::alignment_result_value_type<std::nullopt_t*, std::nullopt_t*, int, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, seqan3::detail::advanceable_alignment_coordinate<(seqan3::detail::advanceable_alignment_coordinate_state)0>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> >)> > (invoke.h:111)
==47== by 0x1ADA1F: ZNSt17_Function_handlerIFvNSt6ranges8subrangeIN6seqan36detail8zip_viewIJNS0_11single_viewISt5tupleIJRSt6vectorINS2_4dna5ESaIS8_EESB_EEEENS0_9iota_viewIiSt22unreachable_sentinel_tEEEE8iteratorILb0EEESJ_LNS0_13subrange_kindE1EEESt8functionIFvNS2_16alignment_resultINS3_27alignment_result_value_typeIPSt9nullopt_tSQ_iNS3_32advanceable_alignment_coordinateILNS3_38advanceable_alignment_coordinate_stateE0EEEST_SQ_SQ_SQ_EEEEEEENS3_19alignment_algorithmINS2_13configurationIJNS2_9align_cfg13method_globalENS11_14scoring_schemeINS2_25nucleotide_scoring_schemeIaEEEENS11_15gap_cost_affineENS11_12output_scoreENS11_21output_begin_positionENS11_19output_end_positionENS11_15band_fixed_sizeENS11_6detail11result_typeISV_EEEEEJNS3_18deferred_crtp_baseINS3_23alignment_matrix_policyEJNS3_40alignment_score_matrix_one_column_bandedIiEENS3_34alignment_trace_matrix_full_bandedINS3_16trace_directionsELb0EEEEEENS1G_INS3_17affine_gap_policyEJiSt17integral_constantIbLb0EEEEENS1G_INS3_19find_optimum_policyEJEEENS1G_INS3_22affine_gap_init_policyEJEEENS1G_INS3_21scoring_scheme_policyEJS15_EEEEEEE9_M_invokeERKSt9_Any_dataOSL_OSX (std_function.h:290)
==47== by 0x16E48F: operator() (std_function.h:590)

==47== by 0x16E48F: execute<std::function<void(std::ranges::subrange<seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, (std::ranges::subrange_kind)1>, std::function<void(seqan3::alignment_result<seqan3::detail::alignment_result_value_type<std::nullopt_t*, std::nullopt_t*, int, seqan3::detail::advanceable_alignment_coordinate<>, seqan3::detail::advanceable_alignment_coordinate<>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> >)>)>&, std::ranges::subrange<seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, (std::ranges::subrange_kind)1>, seqan3::detail::algorithm_executor_blocking<seqan3::detail::chunk_view<seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> > >, std::function<void(std::ranges::subrange<seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, seqan3::detail::zip_view<std::ranges::single_view<std::tuple<std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&, std::vector<seqan3::dna5, std::allocatorseqan3::dna5 >&> >, std::ranges::iota_view<int, std::unreachable_sentinel_t> >::iterator, (std::ranges::subrange_kind)1>, std::function<void(seqan3::alignment_result<seqan3::detail::alignment_result_value_type<std::nullopt_t*, std::nullopt_t*, int, seqan3::detail::advanceable_alignment_coordinate<>, seqan3::detail::advanceable_alignment_coordinate<>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> >)>)>, seqan3::alignment_result<seqan3::detail::alignment_result_value_type<std::nullopt_t*, std::nullopt_t*, int, seqan3::detail::advanceable_alignment_coordinate<>, seqan3::detail::advanceable_alignment_coordinate<>, std::nullopt_t*, std::nullopt_t*, std::nullopt_t*> >, seqan3::detail::execution_handler_sequential>::fill_buffer()::<lambda(auto:78&&)> > (execution_handler_sequential.hpp:49)

seqan3/include/seqan3/core/algorithm/detail/execution_handler_sequential.hpp

Lines 45 to 50 in fe7458e

    
           template <typename algorithm_t, typename algorithm_input_t, typename callback_t> 
        
               requires std::invocable<algorithm_t, algorithm_input_t, callback_t> 
        
           void execute(algorithm_t && algorithm, algorithm_input_t && input, callback_t && callback) 
        
           { 
        
               algorithm(std::forward<algorithm_input_t>(input), std::forward<callback_t>(callback)); 
        
           }

==47== by 0x16E48F: fill_buffer (algorithm_executor_blocking.hpp:262)

seqan3/include/seqan3/core/algorithm/detail/algorithm_executor_blocking.hpp

Lines 248 to 279 in fe7458e

    
           fill_status fill_buffer() 
        
           { 
        
               if (!is_buffer_empty()) // Not everything consumed yet. 
        
                   return fill_status::non_empty_buffer; 
        
               if (is_eof()) // Case: reached end of resource. 
        
                   return fill_status::end_of_resource; 
        
               // Reset the buckets and the buffer iterator. 
        
               reset_buffer(); 
        
               // Execute the algorithm (possibly asynchronous) and fill the buckets in this pre-assigned order. 
        
               for (buffer_end_it = buffer_it; buffer_end_it != buffer.end() && !is_eof(); ++buffer_end_it, ++resource_it) 
        
               { 
        
                   exec_handler.execute(algorithm, 
        
                                        *resource_it, 
        
                                        [target_buffer_it = buffer_end_it](auto && algorithm_result) 
        
                                        { 
        
                                            target_buffer_it->push_back(std::move(algorithm_result)); 
        
                                        }); 
        
               } 
        
               exec_handler.wait(); 
        
               // Move the results iterator to the next available result. (This skips empty results of the algorithm) 
        
               find_next_non_empty_bucket(); 
        
               if (is_buffer_empty()) 
        
                   return fill_status::empty_buffer; 
        
               return fill_status::non_empty_buffer; 
        
           }

==47== by 0x16E48F: next_result (algorithm_executor_blocking.hpp:199)

seqan3/include/seqan3/core/algorithm/detail/algorithm_executor_blocking.hpp

Lines 192 to 212 in fe7458e

    
           std::optional<algorithm_result_t> next_result() 
        
           { 
        
               fill_status status; 
        
               // Each invocation of the algorithm might produce zero results (e.g. a search might not find a query) 
        
               // this repeats the algorithm until it produces the first result or the input resource was consumed. 
        
               do 
        
               { 
        
                   status = fill_buffer(); 
        
               } 
        
               while (status == fill_status::empty_buffer); 
        
               if (status == fill_status::end_of_resource) 
        
                   return {std::nullopt}; 
        
               assert(status == fill_status::non_empty_buffer); 
        
               assert(bucket_it != buffer_it->end()); 
        
               std::optional<algorithm_result_t> result = std::ranges::iter_move(bucket_it); 
        
               go_to_next_result(); // Go to next buffered result. 
        
               return result; 
        
           }

==47== by 0x16E48F: next (algorithm_result_generator_range.hpp:139)

seqan3/include/seqan3/core/algorithm/algorithm_result_generator_range.hpp

Lines 134 to 146 in fe7458e

    
           bool next() 
        
           { 
        
               if (!algorithm_executor_ptr) 
        
                   throw std::runtime_error{"No algorithm execution buffer available."}; 
        
               if (auto opt = algorithm_executor_ptr->next_result(); opt.has_value()) 
        
               { 
        
                   cache = std::move(*opt); 
        
                   return true; 
        
               } 
        
               return false; 
        
           }

==47== by 0x16E48F: operator++ (algorithm_result_generator_range.hpp:234)

seqan3/include/seqan3/core/algorithm/algorithm_result_generator_range.hpp

Lines 230 to 236 in fe7458e

    
           algorithm_range_iterator & operator++(/*pre*/) 
        
           { 
        
               assert(range_ptr != nullptr); 
        
               at_end = !range_ptr->next(); 
        
               return *this; 
        
           }

==47== by 0x16E48F: algorithm_range_iterator (algorithm_result_generator_range.hpp:202)

seqan3/include/seqan3/core/algorithm/algorithm_result_generator_range.hpp

Lines 199 to 203 in fe7458e

    
           explicit constexpr algorithm_range_iterator(algorithm_result_generator_range & range) : 
        
               range_ptr(std::addressof(range)) 
        
           { 
        
               ++(*this); // Fetch the next element. 
        
           }

==47== by 0x16E48F: begin (algorithm_result_generator_range.hpp:102)

seqan3/include/seqan3/core/algorithm/algorithm_result_generator_range.hpp

Lines 100 to 103 in fe7458e

    
           constexpr algorithm_range_iterator begin() 
        
           { 
        
               return algorithm_range_iterator{*this}; 
        
           }

==47== by 0x16E48F: Alignment::bandedAlignment(std::__cxx11::basic_string<char, std::char_traits, std::allocator >, std::__cxx11::basic_string<char, std::char_traits, std::allocator >, int) (pairwiseAlignment.cpp:105)

0 replies

marehr · 2022-12-07T13:56:48Z

marehr
Dec 7, 2022
Maintainer

Okay, this definitely looks like some internal issue. (I annotated all the referenced code locations in your reply)

It would be awesome if you could provide pairwiseAlignment.cpp:105 and your used sequences, if possible reduced, but you could also send them privately via https://gitter.im/seqan/Lobby or e-mail. The best form would be just the alignment code + all the sequences in a single cpp file. If it is huge then so be it, you can compress it :). If it is standalone, we can reduce it to a manageable size.
Are the sources available?

Some notes:

alignment has been computed, and it aborts when constructing the final aligned sequence
begin (algorithm_result_generator_range.hpp:102) suggests that it is the first alignment computation that fails.
```
auto range = align_pairwise(...);
range.begin(); // computes first alignment
```

seqan3/include/seqan3/alignment/matrix/detail/aligned_sequence_builder.hpp

Lines 232 to 244 in fe7458e

    
           for (auto const & [dir, span] : rev_traces) 
        
           { 
        
               assert(dir == trace_directions::up || dir == trace_directions::left || dir == trace_directions::diagonal); 
        
               if (dir == trace_directions::up) 
        
                   fst_it = insert_gap(fst_aligned, fst_it, span); 
        
               if (dir == trace_directions::left) 
        
                   sec_it = insert_gap(sec_aligned, sec_it, span); 
        
               fst_it += span; 
        
               sec_it += span; 
        
           }

(aligned_sequence_builder.hpp:243) suggests that the trace-back somehow thinks that the (gapped) sequence is longer than the aligned sequence (gap_decorator) allows. This might be an off-by-one error, or worse a completely wrong span size. ~~It seems that it is in the "match" phase, as n added gaps would allow the iterator to go n places further~~ (this only holds true, if both sequences hold their invariants, but the traceback could mess that assumption up).

0 replies

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

assertion #3110

{{title}}

Replies: 3 comments

{{title}}

{{title}}

{{editor}}'s edit

{{editor}}'s edit

{{title}}

{{editor}}'s edit

{{editor}}'s edit

Select a reply

assertion #3110

behrj Dec 6, 2022

Replies: 3 comments

marehr Dec 7, 2022 Maintainer

behrj Dec 7, 2022 Author

marehr Dec 7, 2022 Maintainer

behrj
Dec 6, 2022

marehr
Dec 7, 2022
Maintainer

behrj
Dec 7, 2022
Author

marehr
Dec 7, 2022
Maintainer