Skip to content

Commit

Permalink
Merge pull request #3065 from eseiler/test/benchmark
Browse files Browse the repository at this point in the history 
[TEST] Add more benchmarks
  • Loading branch information
@smehringer
smehringer authored Oct 20, 2022
2 parents 514f260 + d55bcbd commit e723338
Show file tree
Hide file tree
Showing 6 changed files with 345 additions and 21 deletions.
8 changes: 5 additions & 3 deletions include/seqan3/alphabet/container/bitpacked_sequence.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -91,7 +91,7 @@ class bitpacked_sequence
//!\brief Update the sdsl-proxy.
constexpr void on_update() noexcept
{
internal_proxy = static_cast<base_t &>(*this).to_rank();
internal_proxy = base_t::to_rank();
}

public:
Expand All @@ -110,10 +110,12 @@ class bitpacked_sequence
~reference_proxy_type() noexcept = default; //!< Defaulted.

//!\brief Initialise from internal proxy type.
reference_proxy_type(std::ranges::range_reference_t<data_type> const & internal) noexcept :
reference_proxy_type(std::ranges::range_reference_t<data_type> const internal) noexcept :
internal_proxy{internal}
{
static_cast<base_t &>(*this).assign_rank(internal);
// Call alphabet_base's assign_rank to prevent calling on_update() during construction
// which is not necessary, because internal_proxy is already correctly initialised!
base_t::base_t::assign_rank(static_cast<alphabet_rank_t<alphabet_type>>(internal));
}
//!\}
};
Expand Down
75 changes: 71 additions & 4 deletions test/performance/range/container_push_back_benchmark.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,6 +16,7 @@
#include <seqan3/alignment/decorator/gap_decorator.hpp>
#include <seqan3/alphabet/all.hpp>
#include <seqan3/alphabet/container/bitpacked_sequence.hpp>
#include <seqan3/test/seqan2.hpp>
#include <seqan3/utility/container/small_vector.hpp>

template <typename t>
Expand All @@ -31,14 +32,14 @@ using small_vec = seqan3::small_vector<t, 10'000>;
template <template <typename> typename container_t, typename alphabet_t>
void push_back(benchmark::State & state)
{
alphabet_t a{};
alphabet_t letter{};

for (auto _ : state)
{
container_t<alphabet_t> c;
container_t<alphabet_t> container;
for (size_t i = 0; i < 10'000; ++i)
c.push_back(a);
a = c.back();
container.push_back(letter);
benchmark::DoNotOptimize(letter = container.back());
}

state.counters["sizeof"] = sizeof(alphabet_t);
Expand Down Expand Up @@ -88,6 +89,7 @@ BENCHMARK_TEMPLATE(push_back, sdsl_int_vec, uint32_t);
BENCHMARK_TEMPLATE(push_back, sdsl_int_vec, uint64_t);

BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, char);
BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, uint32_t);
BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::gap);
BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::dna4);
BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::gapped<seqan3::dna4>);
Expand All @@ -96,13 +98,78 @@ BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::aa27);
BENCHMARK_TEMPLATE(push_back, seqan3::bitpacked_sequence, seqan3::alphabet_variant<char, seqan3::dna4>);

BENCHMARK_TEMPLATE(push_back, small_vec, char);
BENCHMARK_TEMPLATE(push_back, small_vec, uint32_t);
BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::gap);
BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::dna4);
BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::gapped<seqan3::dna4>);
BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::dna15);
BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::aa27);
BENCHMARK_TEMPLATE(push_back, small_vec, seqan3::alphabet_variant<char, seqan3::dna4>);

// ============================================================================
// push_back SeqAn2
// ============================================================================

#if SEQAN3_HAS_SEQAN2

#include <seqan/sequence.h>

template <template <typename...> typename container_t, typename spec_t, typename alphabet_t>
void push_back2(benchmark::State & state)
{
alphabet_t letter{};

for (auto _ : state)
{
container_t<alphabet_t, spec_t> container;
for (size_t i = 0; i < 10'000; ++i)
seqan::appendValue(container, letter);
benchmark::DoNotOptimize(letter = seqan::back(container));
}

state.counters["sizeof"] = sizeof(alphabet_t);
state.counters["alph_size"] = seqan::ValueSize<alphabet_t>::VALUE;
}

BENCHMARK_TEMPLATE(push_back, std::vector, seqan::Dna);
BENCHMARK_TEMPLATE(push_back, std::vector, seqan::Dna5);
BENCHMARK_TEMPLATE(push_back, std::vector, seqan::Iupac);
BENCHMARK_TEMPLATE(push_back, std::vector, seqan::AminoAcid);
BENCHMARK_TEMPLATE(push_back, std::vector, seqan::Dna5Q);

BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, char);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, uint8_t);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, uint16_t);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, uint32_t);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, uint64_t);

BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::gap);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::dna4);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::gapped<seqan3::dna4>);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::dna15);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::aa27);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan3::alphabet_variant<char, seqan3::dna4>);

BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::Dna);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::Dna5);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::Iupac);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::AminoAcid);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Alloc<>, seqan::Dna5Q);

BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::Dna);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::Dna5);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::Iupac);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::AminoAcid);
// BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Packed<>, seqan::Dna5Q); // broken in SeqAn2

BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::Dna);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::Dna5);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::Iupac);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::AminoAcid);
BENCHMARK_TEMPLATE(push_back2, seqan::String, seqan::Array<10'000>, seqan::Dna5Q);

#endif // SEQAN3_HAS_SEQAN2

// ============================================================================
// run
// ============================================================================
Expand Down
117 changes: 110 additions & 7 deletions test/performance/range/container_seq_read_benchmark.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -17,6 +17,7 @@
#include <seqan3/alphabet/all.hpp>
#include <seqan3/alphabet/container/bitpacked_sequence.hpp>
#include <seqan3/test/performance/sequence_generator.hpp>
#include <seqan3/test/seqan2.hpp>
#include <seqan3/utility/container/small_vector.hpp>

template <typename t>
Expand All @@ -32,18 +33,21 @@ using small_vec = seqan3::small_vector<t, 10'000>;
template <template <typename> typename container_t, typename alphabet_t, bool const_qualified = false>
void sequential_read(benchmark::State & state)
{
auto cont_rando = seqan3::test::generate_sequence<alphabet_t>(10'000, 0, 0);
container_t<alphabet_t> source(cont_rando.begin(), cont_rando.end());
container_t<alphabet_t> container = []()
{
auto container = seqan3::test::generate_sequence<alphabet_t>(10'000, 0, 0);
return container_t<alphabet_t>(container.begin(), container.end());
}();

using source_ref_t =
using container_reference_t =
std::conditional_t<const_qualified, container_t<alphabet_t> const &, container_t<alphabet_t> &>;

source_ref_t source_ref{source};
container_reference_t container_reference{container};

alphabet_t a;
alphabet_t letter{};
for (auto _ : state)
for (auto && c : source_ref)
benchmark::DoNotOptimize(a = c);
for (auto && element : container_reference)
benchmark::DoNotOptimize(letter = element);

state.counters["sizeof"] = sizeof(alphabet_t);
if constexpr (seqan3::alphabet<alphabet_t>)
Expand All @@ -58,9 +62,11 @@ BENCHMARK_TEMPLATE(sequential_read, std::vector, uint32_t);
BENCHMARK_TEMPLATE(sequential_read, std::vector, uint64_t);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::gap);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna4);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna5);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::gapped<seqan3::dna4>);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna15);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::aa27);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::alphabet_variant<char, seqan3::dna4>);

BENCHMARK_TEMPLATE(sequential_read, std::deque, char);
Expand All @@ -70,9 +76,11 @@ BENCHMARK_TEMPLATE(sequential_read, std::deque, uint32_t);
BENCHMARK_TEMPLATE(sequential_read, std::deque, uint64_t);
BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::gap);
BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::dna4);
BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::dna5);
BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::gapped<seqan3::dna4>);
BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::dna15);
BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::aa27);
BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
BENCHMARK_TEMPLATE(sequential_read, std::deque, seqan3::alphabet_variant<char, seqan3::dna4>);

BENCHMARK_TEMPLATE(sequential_read, std::list, char);
Expand All @@ -82,9 +90,11 @@ BENCHMARK_TEMPLATE(sequential_read, std::list, uint32_t);
BENCHMARK_TEMPLATE(sequential_read, std::list, uint64_t);
BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::gap);
BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::dna4);
BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::dna5);
BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::gapped<seqan3::dna4>);
BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::dna15);
BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::aa27);
BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
BENCHMARK_TEMPLATE(sequential_read, std::list, seqan3::alphabet_variant<char, seqan3::dna4>);

BENCHMARK_TEMPLATE(sequential_read, sdsl_int_vec, uint8_t);
Expand All @@ -93,19 +103,25 @@ BENCHMARK_TEMPLATE(sequential_read, sdsl_int_vec, uint32_t);
BENCHMARK_TEMPLATE(sequential_read, sdsl_int_vec, uint64_t);

BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, char);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, uint32_t);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::gap);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna4);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna5);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::gapped<seqan3::dna4>);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna15);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::aa27);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::alphabet_variant<char, seqan3::dna4>);

BENCHMARK_TEMPLATE(sequential_read, small_vec, char);
BENCHMARK_TEMPLATE(sequential_read, small_vec, uint32_t);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::gap);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna4);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna5);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::gapped<seqan3::dna4>);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna15);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::aa27);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::qualified<seqan3::dna4, seqan3::phred42>);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::alphabet_variant<char, seqan3::dna4>);

// ============================================================================
Expand All @@ -119,27 +135,114 @@ BENCHMARK_TEMPLATE(sequential_read, std::vector, uint32_t, true);
BENCHMARK_TEMPLATE(sequential_read, std::vector, uint64_t, true);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::gap, true);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna4, true);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna5, true);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::gapped<seqan3::dna4>, true);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::dna15, true);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::aa27, true);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::qualified<seqan3::dna4, seqan3::phred42>, true);
BENCHMARK_TEMPLATE(sequential_read, std::vector, seqan3::alphabet_variant<char, seqan3::dna4>, true);

BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, char, true);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, uint32_t, true);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::gap, true);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna4, true);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna5, true);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::gapped<seqan3::dna4>, true);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::dna15, true);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::aa27, true);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::qualified<seqan3::dna4, seqan3::phred42>, true);
BENCHMARK_TEMPLATE(sequential_read, seqan3::bitpacked_sequence, seqan3::alphabet_variant<char, seqan3::dna4>, true);

BENCHMARK_TEMPLATE(sequential_read, small_vec, char, true);
BENCHMARK_TEMPLATE(sequential_read, small_vec, uint32_t, true);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::gap, true);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna4, true);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna5, true);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::gapped<seqan3::dna4>, true);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::dna15, true);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::aa27, true);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::qualified<seqan3::dna4, seqan3::phred42>, true);
BENCHMARK_TEMPLATE(sequential_read, small_vec, seqan3::alphabet_variant<char, seqan3::dna4>, true);

// ============================================================================
// SeqAn2: sequential_read
// ============================================================================

#if SEQAN3_HAS_SEQAN2

# include <seqan/sequence.h>

template <template <typename...> typename container_t,
typename spec_t,
typename alphabet_t,
bool const_qualified = false>
void sequential_read2(benchmark::State & state)
{
container_t<alphabet_t, spec_t> container{seqan3::test::generate_sequence_seqan2<alphabet_t>(10'000, 0, 0)};

using container_reference_t =
std::conditional_t<const_qualified, container_t<alphabet_t, spec_t> const &, container_t<alphabet_t, spec_t> &>;

container_reference_t container_reference{container};

alphabet_t letter{};
for (auto _ : state)
for (auto && element : container_reference)
benchmark::DoNotOptimize(letter = element);

state.counters["sizeof"] = sizeof(alphabet_t);
state.counters["alph_size"] = seqan::ValueSize<alphabet_t>::VALUE;
state.counters["const"] = const_qualified;
}

BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, char);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint8_t);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint16_t);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint32_t);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint64_t);

BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna5);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Iupac);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::AminoAcid);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna5Q);

BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna5);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Iupac);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::AminoAcid);
// BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna5Q); // broken in SeqAn2

BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::Dna);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::Dna5);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::Iupac);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::AminoAcid);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Array<10'000>, seqan::Dna5Q);

// ============================================================================
// sequential_read (const)
// ============================================================================

BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, char, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint8_t, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint16_t, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint32_t, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, uint64_t, true);

BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna5, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Iupac, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::AminoAcid, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Alloc<>, seqan::Dna5Q, true);

BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna5, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Iupac, true);
BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::AminoAcid, true);
// BENCHMARK_TEMPLATE(sequential_read2, seqan::String, seqan::Packed<>, seqan::Dna5Q); // broken in SeqAn2

#endif // SEQAN3_HAS_SEQAN2

// ============================================================================
// run
// ============================================================================
Expand Down
Loading

1 comment on commit e723338

@vercel
Copy link

@vercel vercel bot commented on e723338 Oct 20, 2022

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Successfully deployed to the following URLs:

seqan3 – ./

seqan3-git-master-seqan.vercel.app
seqan3-seqan.vercel.app
seqan3.vercel.app

Please sign in to comment.