Revert "[rANS] Fix Compiler Warnings"

shahor02 · shahor02 · commit 05bd24160a4f · 2023-10-05T00:53:33.000+02:00
This reverts commit 354fbb1.
diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/EncodedBlocks.h
@@ -835,7 +835,7 @@ auto EncodedBlocks<H, N, W>::getImage(const void* newHead)
   // we don't modify newHead, but still need to remove constness for relocation interface
   relocate(image.mRegistry.head, const_cast<char*>(reinterpret_cast<const char*>(newHead)), reinterpret_cast<char*>(&image));
 
-  return image;
+  return std::move(image);
 }
 
 ///_____________________________________________________________________________
@@ -945,6 +945,7 @@ CTFIOSize EncodedBlocks<H, N, W>::decodeCompatImpl(dst_IT dstBegin, int slot, co
 {
 
   // get references to the right data
+  const auto& ansVersion = getANSHeader();
   const auto& block = mBlocks[slot];
   const auto& md = mMetadata[slot];
 
@@ -983,6 +984,7 @@ CTFIOSize EncodedBlocks<H, N, W>::decodeRansV1Impl(dst_IT dstBegin, int slot, co
 {
 
   // get references to the right data
+  const auto& ansVersion = getANSHeader();
   const auto& block = mBlocks[slot];
   const auto& md = mMetadata[slot];
 
diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/internal/ExternalEntropyCoder.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/internal/ExternalEntropyCoder.h
@@ -79,7 +79,7 @@ template <typename dst_T>
   constexpr size_t Overhead = 10 * rans::utils::pow2(10); // 10KB overhead safety margin
   const double_t RelativeSafetyFactor = 2.0 * safetyFactor;
   const size_t messageSizeB = nElements * sizeof(source_type);
-  return rans::utils::nBytesTo<dst_T>(std::ceil(RelativeSafetyFactor * messageSizeB) + Overhead);
+  return rans::utils::nBytesTo<dst_T>(std::ceil(safetyFactor * messageSizeB) + Overhead);
 }
 
 template <typename source_T>
diff --git a/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/internal/InplaceEntropyCoder.h b/DataFormats/Detectors/Common/include/DetectorsCommonDataFormats/internal/InplaceEntropyCoder.h
@@ -166,6 +166,7 @@ void InplaceEntropyCoder<source_T>::makeEncoder()
     }
 
     const size_t rangeBits = rans::utils::getRangeBits(*mMetrics.getCoderProperties().min, *mMetrics.getCoderProperties().max);
+    const size_t nSamples = mMetrics.getDatasetProperties().numSamples;
     const size_t nUsedAlphabetSymbols = mMetrics.getDatasetProperties().nUsedAlphabetSymbols;
 
     if (rangeBits <= 18) {
diff --git a/DataFormats/Detectors/Common/test/testCTFEntropyCoder.cxx b/DataFormats/Detectors/Common/test/testCTFEntropyCoder.cxx
@@ -126,7 +126,7 @@ void encodeInplace(source_IT begin, source_IT end)
   std::vector<buffer_type> dictBuffer(sizeEstimate.getCompressedDictionarySize<buffer_type>(), 0);
 
   auto encoderEnd = entropyCoder.encode(begin, end, encodeBuffer.data(), encodeBuffer.data() + encodeBuffer.size());
-  [[maybe_unused]] auto literalsEnd = entropyCoder.writeIncompressible(literalSymbolsBuffer.data(), literalSymbolsBuffer.data() + literalSymbolsBuffer.size());
+  auto literalsEnd = entropyCoder.writeIncompressible(literalSymbolsBuffer.data(), literalSymbolsBuffer.data() + literalSymbolsBuffer.size());
   auto dictEnd = entropyCoder.writeDictionary(dictBuffer.data(), dictBuffer.data() + dictBuffer.size());
   // decode
   const auto& coderProperties = metrics.getCoderProperties();
@@ -303,7 +303,7 @@ void encodeExternal(source_IT begin, source_IT end)
   auto encoderEnd = entropyCoder.encode(begin, end, encodeBuffer.data(), encodeBuffer.data() + encodeBuffer.size());
 
   std::vector<buffer_type> literalSymbolsBuffer(entropyCoder.template computePackedIncompressibleSize<buffer_type>(), 0);
-  [[maybe_unused]] auto literalsEnd = entropyCoder.writeIncompressible(literalSymbolsBuffer.data(), literalSymbolsBuffer.data() + literalSymbolsBuffer.size());
+  auto literalsEnd = entropyCoder.writeIncompressible(literalSymbolsBuffer.data(), literalSymbolsBuffer.data() + literalSymbolsBuffer.size());
 
   // decode
   auto decoder = ExternalEncoders.getDecoder<source_type>();
diff --git a/Utilities/rANS/benchmarks/bench_ransHistogram.cxx b/Utilities/rANS/benchmarks/bench_ransHistogram.cxx
@@ -137,7 +137,7 @@ void ransMakeHistogramBenchmark(benchmark::State& st, Args&&... args)
   histogram_type hist{};
   hist.addSamples(gsl::span<const source_type>(inputData));
 
-  for (std::ptrdiff_t symbol = histogram.getOffset(); symbol != histogram.getOffset() + static_cast<std::ptrdiff_t>(histogram.size()); ++symbol) {
+  for (std::ptrdiff_t symbol = histogram.getOffset(); symbol != histogram.getOffset() + histogram.size(); ++symbol) {
     if (histogram[symbol] > 0) {
       LOG_IF(info, histogram[symbol] != hist[symbol]) << fmt::format("[{}]: {} != {}", symbol, hist[symbol], histogram[symbol]);
       isSame = isSame && (histogram[symbol] == hist[symbol]);
@@ -190,7 +190,7 @@ void ransAccessHistogramBenchmark(benchmark::State& st, Args&&... args)
 #endif
 
   bool isSame = true;
-  for (std::ptrdiff_t symbol = histogram.getOffset(); symbol != histogram.getOffset() + static_cast<std::ptrdiff_t>(histogram.size()); ++symbol) {
+  for (std::ptrdiff_t symbol = histogram.getOffset(); symbol != histogram.getOffset() + histogram.size(); ++symbol) {
     if (histogram[symbol] > 0) {
       LOG_IF(info, histogram[symbol] != hist[symbol]) << fmt::format("[{}]: {} != {}", symbol, hist[symbol], histogram[symbol]);
       isSame = isSame && (histogram[symbol] == hist[symbol]);
diff --git a/Utilities/rANS/include/rANS/internal/containers/DenseHistogram.h b/Utilities/rANS/include/rANS/internal/containers/DenseHistogram.h
@@ -184,7 +184,7 @@ inline bool DenseHistogram<source_T, std::enable_if_t<sizeof(source_T) == 4>>::i
       ret = false;
     }
   }
-  if (max - min > static_cast<difference_type>(this->MaxSize)) {
+  if (max - min > this->MaxSize) {
     LOGP(warning, "DenseHistogram exceeds {} elements threshold", this->MaxSize);
     ret = false;
   }
@@ -233,6 +233,8 @@ inline auto DenseHistogram<source_T, std::enable_if_t<sizeof(source_T) == 4>>::a
   constexpr size_t nUnroll = 4 * ElemsPerQWord;
   auto iter = begin;
 
+  const source_type offset = this->getOffset();
+
   if (getRangeBits(min, max) <= 17) {
     container_type histogram{this->mContainer.size(), this->mContainer.getOffset()};
 
diff --git a/Utilities/rANS/include/rANS/internal/containers/ReverseSymbolLookupTable.h b/Utilities/rANS/include/rANS/internal/containers/ReverseSymbolLookupTable.h
@@ -71,8 +71,8 @@ class ReverseSymbolLookupTable
     return mLut[cumul];
   };
 
-  inline iterator_type begin() const noexcept { return mLut.data(); };
-  inline iterator_type end() const noexcept { return mLut.data() + size(); };
+  inline const iterator_type begin() const noexcept { return mLut.data(); };
+  inline const iterator_type end() const noexcept { return mLut.data() + size(); };
 
   container_type mLut{};
 };
diff --git a/Utilities/rANS/include/rANS/internal/containers/Symbol.h b/Utilities/rANS/include/rANS/internal/containers/Symbol.h
@@ -37,8 +37,11 @@ class Symbol
 
   // TODO(milettri): fix once ROOT cling respects the standard http://wg21.link/p1286r2
   constexpr Symbol() noexcept {}; // NOLINT
-  constexpr Symbol(value_type frequency, value_type cumulative, [[maybe_unused]] size_t symbolTablePrecision = 0)
-    : mSymbol{frequency, cumulative} {};
+  constexpr Symbol(value_type frequency, value_type cumulative, size_t symbolTablePrecision = 0)
+    : mSymbol{frequency, cumulative}
+  {
+    (void)symbolTablePrecision; // silence compiler warnings
+  };
   [[nodiscard]] inline constexpr value_type getFrequency() const noexcept { return mSymbol[0]; };
   [[nodiscard]] inline constexpr value_type getCumulative() const noexcept { return mSymbol[1]; };
   [[nodiscard]] inline constexpr const value_type* data() const noexcept { return mSymbol.data(); };
diff --git a/Utilities/rANS/include/rANS/internal/encode/Encoder.h b/Utilities/rANS/include/rANS/internal/encode/Encoder.h
@@ -143,11 +143,7 @@ decltype(auto) Encoder<encoder_T, symbolTable_T, nStreams_V>::process(source_IT
   EncoderSymbolMapper<symbolTable_type, coder_type, literals_IT> symbolMapper{this->mSymbolTable, literalsBegin};
   typename coder_type::symbol_type encoderSymbols[2]{};
 
-  // one past the end. Will not be dereferenced, thus safe.
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Warray-bounds"
   coder_type* codersREnd = advanceIter(coders.data(), -1);
-#pragma GCC diagnostic pop
   coder_type* activeCoder = codersREnd + nPartialCoderIterations;
 
   // we are encoding backwards!
diff --git a/Utilities/rANS/include/rANS/internal/encode/EncoderSymbolMapper.h b/Utilities/rANS/include/rANS/internal/encode/EncoderSymbolMapper.h
@@ -254,6 +254,8 @@ class EncoderSymbolMapper<symbolTable_T,
   {
     using namespace internal::simd;
 
+    const size_type nStreams = coder_type::getNstreams();
+
     difference_type currentStream = nActiveStreams;
 
     epi32_t<SIMDWidth::SSE, 2> frequencies;
@@ -328,6 +330,8 @@ class EncoderSymbolMapper<symbolTable_T,
   {
     using namespace internal::simd;
 
+    const size_type nStreams = coder_type::getNstreams();
+
     difference_type currentStream = nActiveStreams;
 
     epi32_t<SIMDWidth::SSE, 2> frequencies;
diff --git a/Utilities/rANS/include/rANS/internal/encode/SingleStreamEncoderImpl.h b/Utilities/rANS/include/rANS/internal/encode/SingleStreamEncoderImpl.h
@@ -145,6 +145,8 @@ class SingleStreamEncoderImpl : public SingleStreamEncoderImplBase<lowerBound_V,
   {
     assert(symbol->getFrequency() != 0);
 
+    const state_type old = this->mState;
+
     const auto [newState, streamPosition] = this->renorm(this->mState, outputIter, symbol->getFrequency());
     // coding function
     state_type quotient = static_cast<state_type>((static_cast<uint128_t>(newState) * symbol->getReciprocalFrequency()) >> 64);
diff --git a/Utilities/rANS/include/rANS/internal/pack/DictionaryStreamReader.h b/Utilities/rANS/include/rANS/internal/pack/DictionaryStreamReader.h
@@ -84,7 +84,7 @@ class DictionaryStreamParser
 
 template <typename source_T>
 template <typename buffer_IT>
-DictionaryStreamParser<source_T>::DictionaryStreamParser(buffer_IT begin, buffer_IT end, source_type max) : mPos{end}, mEnd{begin}, mIndex(max)
+DictionaryStreamParser<source_T>::DictionaryStreamParser(buffer_IT begin, buffer_IT end, source_type max) : mEnd{begin}, mPos{end}, mIndex(max)
 {
   static_assert(std::is_pointer_v<buffer_IT>, "can only deserialize from raw pointers");
 
diff --git a/Utilities/rANS/include/rANS/internal/transform/algorithmImpl.h b/Utilities/rANS/include/rANS/internal/transform/algorithmImpl.h
@@ -161,7 +161,7 @@ inline void forEachIndexValue(container_T&& container, IT begin, IT end, F funct
   using container_type = removeCVRef_t<container_T>;
 
   typename container_type::source_type index = container.getOffset() + std::distance(container.begin(), begin);
-  for (std::ptrdiff_t i = 0; i < std::distance(begin, end); ++i) {
+  for (size_t i = 0; i < std::distance(begin, end); ++i) {
     functor(index++, begin[i]);
   }
 }
diff --git a/Utilities/rANS/include/rANS/internal/transform/renorm.h b/Utilities/rANS/include/rANS/internal/transform/renorm.h
@@ -74,6 +74,7 @@ decltype(auto) renorm(histogram_T histogram, Metrics<typename histogram_T::sourc
   using container_type = typename histogram_type::container_type;
   using iterator_type = typename container_type::iterator;
 
+  const source_type offset = histogram.getOffset();
   const double_t nSamples = histogram.getNumSamples();
   const size_t renormingPrecisionBits = *metrics.getCoderProperties().renormingPrecisionBits;
   const size_t nUsedAlphabetSymbols = metrics.getDatasetProperties().nUsedAlphabetSymbols;
diff --git a/Utilities/rANS/run/bin-encode-decode.cxx b/Utilities/rANS/run/bin-encode-decode.cxx
@@ -109,7 +109,7 @@ int main(int argc, char* argv[])
 
   if (renormedHistogram.hasIncompressibleSymbol()) {
     LOG(info) << "With incompressible symbols";
-    [[maybe_unused]] auto res = encoder.process(tokens.begin(), tokens.end(), std::back_inserter(encoderBuffer), std::back_inserter(incompressibleSymbols));
+    auto [encoderEnd, incompressibleEnd] = encoder.process(tokens.begin(), tokens.end(), std::back_inserter(encoderBuffer), std::back_inserter(incompressibleSymbols));
     LOGP(info, "nIncompressible {}", incompressibleSymbols.size());
     decoder.process(encoderBuffer.end(), decodeBuffer.begin(), tokens.size(), NSTREAMS, incompressibleSymbols.end());
   } else {
diff --git a/Utilities/rANS/test/test_ransHistograms.cxx b/Utilities/rANS/test/test_ransHistograms.cxx
@@ -359,6 +359,8 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_addFrequenciesSignChange, histogram_T, histog
     {static_cast<source_type>(5), 5},
   };
 
+  const size_t fixedSizeOffset = std::numeric_limits<source_type>::min();
+
   histogram_T histogram{};
   histogram.addFrequencies(frequencies.begin(), frequencies.end(), 0);
 
@@ -387,6 +389,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_addFrequenciesSignChange, histogram_T, histog
     const std::ptrdiff_t offset = utils::pow2(utils::toBits<source_type>() - 1);
 
     if constexpr (std::is_same_v<histogram_T, DenseHistogram<int32_t>>) {
+      const std::ptrdiff_t largeOffset = utils::toBits<source_type>() - 1;
       BOOST_CHECK_THROW(histogram.addFrequencies(frequencies2.begin(), frequencies2.end(), offset), HistogramError);
       BOOST_CHECK_THROW(histogram2.addFrequencies(gsl::make_span(frequencies2), offset), HistogramError);
     } else {
diff --git a/Utilities/rANS/test/test_ransMetrics.cxx b/Utilities/rANS/test/test_ransMetrics.cxx
@@ -238,6 +238,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_singleElementMetrics, histogram_T, histogram_
   std::vector<uint32_t> frequencies{5};
   histogram_T histogram{frequencies.begin(), frequencies.end(), 2};
   const auto [min, max] = getMinMax(histogram);
+  const float eps = 1e-2;
   const size_t nUsedAlphabetSymbols = countNUsedAlphabetSymbols(histogram);
 
   const Metrics<source_type> metrics{histogram};
diff --git a/Utilities/rANS/test/test_ransPack.cxx b/Utilities/rANS/test/test_ransPack.cxx
@@ -56,6 +56,7 @@ using source_types = boost::mp11::mp_list<uint8_t, uint16_t, uint32_t, uint64_t>
 
 BOOST_AUTO_TEST_CASE_TEMPLATE(test_computePackingBufferSize, buffer_T, buffer_types)
 {
+  size_t nElems{};
   size_t packingWidth = utils::toBits<packing_type>() - 3;
 
   BOOST_CHECK_EQUAL(0, (computePackingBufferSize<buffer_T>(0, packingWidth)));
@@ -131,7 +132,7 @@ BOOST_AUTO_TEST_CASE(test_packUnpackStream)
 
     source_type min = *std::min_element(source.begin(), source.end());
 
-    [[maybe_unused]] auto packingBufferEnd = pack(source.data(), source.size(), packingBuffer.data(), packingWidth, min);
+    auto packingBufferEnd = pack(source.data(), source.size(), packingBuffer.data(), packingWidth, min);
 
     std::vector<source_type> unpackBuffer(source.size(), 0);
     unpack(packingBuffer.data(), source.size(), unpackBuffer.data(), packingWidth, min);
diff --git a/Utilities/rANS/test/test_ransSIMDEncoderKernels.cxx b/Utilities/rANS/test/test_ransSIMDEncoderKernels.cxx
@@ -120,9 +120,7 @@ struct AosToSoaFixture {
     uint32_t counter = 0;
 
     for (size_t i = 0; i < nElems; ++i) {
-      const auto freq = counter++;
-      const auto cumul = counter++;
-      Symbol symbol{freq, cumul, 0};
+      Symbol symbol{counter++, counter++, 0};
       mFrequencies(i) = symbol.getFrequency();
       mCumulative(i) = symbol.getCumulative();
 
@@ -230,10 +228,10 @@ struct SSERenormFixture {
     statesVec[0] = load(states[0]);
     statesVec[1] = load(states[1]);
 
-    [[maybe_unused]] stream_iterator newstreamOutIter = ransRenorm<stream_iterator, LowerBound, StreamBits>(statesVec,
-                                                                                                            frequenciesVec,
-                                                                                                            SymbolTablePrecisionBits,
-                                                                                                            streamOutBuffer.begin(), newStatesVec);
+    stream_iterator newstreamOutIter = ransRenorm<stream_iterator, LowerBound, StreamBits>(statesVec,
+                                                                                           frequenciesVec,
+                                                                                           SymbolTablePrecisionBits,
+                                                                                           streamOutBuffer.begin(), newStatesVec);
 
     epi64_t<SIMDWidth::SSE, 2> newStates(0);
     store(newStatesVec[0], newStates[0]);
diff --git a/Utilities/rANS/test/test_ransSparseVector.cxx b/Utilities/rANS/test/test_ransSparseVector.cxx
@@ -47,6 +47,8 @@ BOOST_AUTO_TEST_CASE(test_write)
 {
   sparseVector_type vec{};
 
+  const size_t fixedSizeOffset = std::numeric_limits<source_type>::min();
+
   std::vector<source_type> samples{-5, -2, 1, 3, 5, 8, -5, 5, 1, 1, 1, 14, 8, 8, 8, 8, 8, 8, 8, 8, utils::pow2(18) + 1};
 
   std::unordered_map<source_type, uint32_t> results{{-5, 2}, {-2, 1}, {-1, 0}, {0, 0}, {1, 4}, {2, 0}, {3, 1}, {4, 0}, {5, 2}, {8, 9}, {14, 1}, {utils::pow2(18) + 1, 1}};
diff --git a/Utilities/rANS/test/test_ransSymbolTables.cxx b/Utilities/rANS/test/test_ransSymbolTables.cxx
@@ -123,7 +123,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(test_symbolTable, histogram_T, histogram_t)
 
   BOOST_CHECK_EQUAL(symbolTable.getPrecision(), scaleBits);
 
-  for (source_type index = 0; index < static_cast<source_type>(rescaledFrequencies.size()); ++index) {
+  for (source_type index = 0; index < rescaledFrequencies.size(); ++index) {
     auto symbol = symbolTable[index + 6];
     BOOST_CHECK_EQUAL(symbol.getFrequency(), rescaledFrequencies[index]);
     BOOST_CHECK_EQUAL(symbol.getCumulative(), cumulativeFrequencies[index]);

Original file line number	Diff line number	Diff line change
`@@ -835,7 +835,7 @@ auto EncodedBlocks<H, N, W>::getImage(const void* newHead)`
`835`	`835`	`// we don't modify newHead, but still need to remove constness for relocation interface`
`836`	`836`	`relocate(image.mRegistry.head, const_cast<char>(reinterpret_cast<const char>(newHead)), reinterpret_cast<char*>(&image));`
`837`	`837`
`838`		`- return image;`
	`838`	`+ return std::move(image);`
`839`	`839`	`}`
`840`	`840`
`841`	`841`	`///_____________________________________________________________________________`
`@@ -945,6 +945,7 @@ CTFIOSize EncodedBlocks<H, N, W>::decodeCompatImpl(dst_IT dstBegin, int slot, co`
`945`	`945`	`{`
`946`	`946`
`947`	`947`	`// get references to the right data`
	`948`	`+ const auto& ansVersion = getANSHeader();`
`948`	`949`	`const auto& block = mBlocks[slot];`
`949`	`950`	`const auto& md = mMetadata[slot];`
`950`	`951`
`@@ -983,6 +984,7 @@ CTFIOSize EncodedBlocks<H, N, W>::decodeRansV1Impl(dst_IT dstBegin, int slot, co`
`983`	`984`	`{`
`984`	`985`
`985`	`986`	`// get references to the right data`
	`987`	`+ const auto& ansVersion = getANSHeader();`
`986`	`988`	`const auto& block = mBlocks[slot];`
`987`	`989`	`const auto& md = mMetadata[slot];`
`988`	`990`
Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ template <typename dst_T>`
`79`	`79`	`constexpr size_t Overhead = 10 * rans::utils::pow2(10); // 10KB overhead safety margin`
`80`	`80`	`const double_t RelativeSafetyFactor = 2.0 * safetyFactor;`
`81`	`81`	`const size_t messageSizeB = nElements * sizeof(source_type);`
`82`		`- return rans::utils::nBytesTo<dst_T>(std::ceil(RelativeSafetyFactor * messageSizeB) + Overhead);`
	`82`	`+ return rans::utils::nBytesTo<dst_T>(std::ceil(safetyFactor * messageSizeB) + Overhead);`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`template <typename source_T>`
Original file line number	Diff line number	Diff line change
`@@ -166,6 +166,7 @@ void InplaceEntropyCoder<source_T>::makeEncoder()`
`166`	`166`	`}`
`167`	`167`
`168`	`168`	`const size_t rangeBits = rans::utils::getRangeBits(mMetrics.getCoderProperties().min, mMetrics.getCoderProperties().max);`
	`169`	`+ const size_t nSamples = mMetrics.getDatasetProperties().numSamples;`
`169`	`170`	`const size_t nUsedAlphabetSymbols = mMetrics.getDatasetProperties().nUsedAlphabetSymbols;`
`170`	`171`
`171`	`172`	`if (rangeBits <= 18) {`
Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ inline bool DenseHistogram<source_T, std::enable_if_t<sizeof(source_T) == 4>>::i`
`184`	`184`	`ret = false;`
`185`	`185`	`}`
`186`	`186`	`}`
`187`		`- if (max - min > static_cast<difference_type>(this->MaxSize)) {`
	`187`	`+ if (max - min > this->MaxSize) {`
`188`	`188`	`LOGP(warning, "DenseHistogram exceeds {} elements threshold", this->MaxSize);`
`189`	`189`	`ret = false;`
`190`	`190`	`}`
`@@ -233,6 +233,8 @@ inline auto DenseHistogram<source_T, std::enable_if_t<sizeof(source_T) == 4>>::a`
`233`	`233`	`constexpr size_t nUnroll = 4 * ElemsPerQWord;`
`234`	`234`	`auto iter = begin;`
`235`	`235`
	`236`	`+ const source_type offset = this->getOffset();`
	`237`	`+`
`236`	`238`	`if (getRangeBits(min, max) <= 17) {`
`237`	`239`	`container_type histogram{this->mContainer.size(), this->mContainer.getOffset()};`
`238`	`240`
Original file line number	Diff line number	Diff line change
`@@ -254,6 +254,8 @@ class EncoderSymbolMapper<symbolTable_T,`
`254`	`254`	`{`
`255`	`255`	`using namespace internal::simd;`
`256`	`256`
	`257`	`+ const size_type nStreams = coder_type::getNstreams();`
	`258`	`+`
`257`	`259`	`difference_type currentStream = nActiveStreams;`
`258`	`260`
`259`	`261`	`epi32_t<SIMDWidth::SSE, 2> frequencies;`
`@@ -328,6 +330,8 @@ class EncoderSymbolMapper<symbolTable_T,`
`328`	`330`	`{`
`329`	`331`	`using namespace internal::simd;`
`330`	`332`
	`333`	`+ const size_type nStreams = coder_type::getNstreams();`
	`334`	`+`
`331`	`335`	`difference_type currentStream = nActiveStreams;`
`332`	`336`
`333`	`337`	`epi32_t<SIMDWidth::SSE, 2> frequencies;`