@ladybugmem/icebug 0.1.0

package/vendor/include/tlx/meta.hpp

@@ -0,0 +1,55 @@
+/*******************************************************************************
+ * tlx/meta.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_META_HEADER
+#define TLX_META_HEADER
+
+//! \defgroup tlx_meta Meta-Template Programming
+//! Tools for easier meta-template programming
+
+/*[[[perl
+foreach (sort glob("tlx/meta/"."*.hpp")) {
+  print "#include <$_> // NOLINT(misc-include-cleaner)\n"
+}
+]]]*/
+#include <tlx/meta/apply_tuple.hpp>        // NOLINT(misc-include-cleaner)
+#include <tlx/meta/call_for_range.hpp>     // NOLINT(misc-include-cleaner)
+#include <tlx/meta/call_foreach.hpp>       // NOLINT(misc-include-cleaner)
+#include <tlx/meta/call_foreach_tuple.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/meta/call_foreach_tuple_with_index.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/meta/call_foreach_with_index.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/meta/enable_if.hpp>               // NOLINT(misc-include-cleaner)
+#include <tlx/meta/fold_left.hpp>               // NOLINT(misc-include-cleaner)
+#include <tlx/meta/fold_left_tuple.hpp>         // NOLINT(misc-include-cleaner)
+#include <tlx/meta/fold_right.hpp>              // NOLINT(misc-include-cleaner)
+#include <tlx/meta/fold_right_tuple.hpp>        // NOLINT(misc-include-cleaner)
+#include <tlx/meta/function_chain.hpp>          // NOLINT(misc-include-cleaner)
+#include <tlx/meta/function_stack.hpp>          // NOLINT(misc-include-cleaner)
+#include <tlx/meta/has_member.hpp>              // NOLINT(misc-include-cleaner)
+#include <tlx/meta/has_method.hpp>              // NOLINT(misc-include-cleaner)
+#include <tlx/meta/index_sequence.hpp>          // NOLINT(misc-include-cleaner)
+#include <tlx/meta/is_std_array.hpp>            // NOLINT(misc-include-cleaner)
+#include <tlx/meta/is_std_pair.hpp>             // NOLINT(misc-include-cleaner)
+#include <tlx/meta/is_std_tuple.hpp>            // NOLINT(misc-include-cleaner)
+#include <tlx/meta/is_std_vector.hpp>           // NOLINT(misc-include-cleaner)
+#include <tlx/meta/log2.hpp>                    // NOLINT(misc-include-cleaner)
+#include <tlx/meta/no_operation.hpp>            // NOLINT(misc-include-cleaner)
+#include <tlx/meta/static_index.hpp>            // NOLINT(misc-include-cleaner)
+#include <tlx/meta/vexpand.hpp>                 // NOLINT(misc-include-cleaner)
+#include <tlx/meta/vmap_for_range.hpp>          // NOLINT(misc-include-cleaner)
+#include <tlx/meta/vmap_foreach.hpp>            // NOLINT(misc-include-cleaner)
+#include <tlx/meta/vmap_foreach_tuple.hpp>      // NOLINT(misc-include-cleaner)
+#include <tlx/meta/vmap_foreach_tuple_with_index.hpp> // NOLINT(misc-include-cleaner)
+#include <tlx/meta/vmap_foreach_with_index.hpp> // NOLINT(misc-include-cleaner)
+// [[[end]]]
+
+#endif // !TLX_META_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/multi_timer.hpp

@@ -0,0 +1,148 @@
+/*******************************************************************************
+ * tlx/multi_timer.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018-2019 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_MULTI_TIMER_HEADER
+#define TLX_MULTI_TIMER_HEADER
+
+#include <chrono>
+#include <cstdint>
+#include <ostream>
+#include <vector>
+
+namespace tlx {
+
+/*!
+ * MultiTimer can be used to measure time usage of different phases in a program
+ * or algorithm. It contains multiple named "timers", which can be activated
+ * without prior definition. At most one timer is start at any time, which
+ * means `start()` will stop any current timer and start a new one.
+ *
+ * Timers are identified by strings, which are passed as const char*, which MUST
+ * remain valid for the lifetime of the MultiTimer. Dynamic strings will not
+ * work, the standard way is to use plain string literals. The strings are hash
+ * for faster searches.
+ *
+ * MultiTimer can also be used for multi-threading parallel programs. Each
+ * thread must create and keep its own MultiTimer instance, which can then be
+ * added together into a global MultiTimer object. The add() method of the
+ * global object is internally thread-safe using a global mutex.
+ */
+class MultiTimer
+{
+public:
+    //! constructor
+    MultiTimer();
+
+    //! default copy-constructor
+    MultiTimer(const MultiTimer&);
+    //! default assignment operator
+    MultiTimer& operator=(const MultiTimer&);
+    //! move-constructor: default
+    MultiTimer(MultiTimer&&) noexcept;
+    //! move-assignment operator: default
+    MultiTimer& operator=(MultiTimer&&) noexcept;
+
+    //! destructor
+    ~MultiTimer();
+
+    //! start new timer phase, stop the currently running one.
+    void start(const char* timer);
+
+    //! stop the currently running timer.
+    void stop();
+
+    //! zero timers.
+    void reset();
+
+    //! return name of currently running timer.
+    const char* running() const;
+
+    //! return timer duration in seconds of timer.
+    double get(const char* timer);
+    //! return total duration of all timers.
+    double total() const;
+
+    //! print all timers as a TIMER line to os
+    void print(const char* info, std::ostream& os) const;
+    //! print all timers as a TIMER line to stderr
+    void print(const char* info) const;
+
+    //! add all timers from another, internally holds a global mutex lock,
+    //! because this is used to add thread values
+    MultiTimer& add(const MultiTimer& b);
+
+    //! add all timers from another, internally holds a global mutex lock,
+    //! because this is used to add thread values
+    MultiTimer& operator+=(const MultiTimer& b);
+
+private:
+    //! timer entry
+    struct Entry;
+
+    //! array of timers
+    std::vector<Entry> timers_;
+
+    //! total duration
+    std::chrono::duration<double> total_duration_;
+
+    //! currently running timer name
+    const char* running_ = nullptr;
+    //! hash of running_
+    std::uint32_t running_hash_ = 0;
+    //! start of currently running timer name
+    std::chrono::time_point<std::chrono::high_resolution_clock> time_point_;
+
+    //! internal methods to find or create new timer entries
+    Entry& find_or_create(const char* name);
+};
+
+//! RAII Scoped MultiTimer switcher: switches the timer of a MultiTimer on
+//! construction and back to old one on destruction.
+class ScopedMultiTimerSwitch
+{
+public:
+    //! construct and timer to switch to
+    ScopedMultiTimerSwitch(MultiTimer& timer, const char* new_timer);
+
+    //! change back timer to previous timer.
+    ~ScopedMultiTimerSwitch();
+
+private:
+    //! reference to MultiTimer
+    MultiTimer& timer_;
+
+    //! previous timer, used to switch back to on destruction
+    const char* previous_;
+};
+
+//! Independent RAII Scoped MultiTimer: contains a MultiTimer which is started
+//! with the given timer, and added to the base MultiTimer on destruction.
+class ScopedMultiTimer
+{
+public:
+    //! construct and change timer to tm
+    ScopedMultiTimer(MultiTimer& base, const char* timer);
+
+    //! change back timer to previous timer.
+    ~ScopedMultiTimer();
+
+private:
+    //! reference to base timer
+    MultiTimer& base_;
+
+    //! contained independent timer
+    MultiTimer timer_;
+};
+
+} // namespace tlx
+
+#endif // !TLX_MULTI_TIMER_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/port/setenv.hpp

@@ -0,0 +1,31 @@
+/*******************************************************************************
+ * tlx/port/setenv.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2016-2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_PORT_SETENV_HEADER
+#define TLX_PORT_SETENV_HEADER
+
+namespace tlx {
+
+//! \addtogroup tlx_port
+//! \{
+
+/*!
+ * setenv - change or add an environment variable.
+ * Windows porting madness because setenv() is apparently dangerous.
+ */
+int setenv(const char* name, const char* value, int overwrite);
+
+//! \}
+
+} // namespace tlx
+
+#endif // !TLX_PORT_SETENV_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/port.hpp

@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * tlx/port.hpp
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2017 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_PORT_HEADER
+#define TLX_PORT_HEADER
+
+//! \defgroup tlx_port Helpers for Portable Code
+//! Tools to enable easier writing of portable code.
+
+/*[[[perl
+foreach (sort glob("tlx/port/"."*.hpp")) {
+  print "#include <$_> // NOLINT(misc-include-cleaner)\n";
+}
+]]]*/
+#include <tlx/port/setenv.hpp> // NOLINT(misc-include-cleaner)
+// [[[end]]]
+
+#endif // !TLX_PORT_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/semaphore.hpp

@@ -0,0 +1,119 @@
+/*******************************************************************************
+ * tlx/semaphore.hpp
+ *
+ * A simple semaphore implementation using C++11 synchronization methods.
+ *
+ * Copied and modified from STXXL https://github.com/stxxl/stxxl, which is
+ * distributed under the Boost Software License, Version 1.0.
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2002 Roman Dementiev <dementiev@mpi-sb.mpg.de>
+ * Copyright (C) 2013-2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_SEMAPHORE_HEADER
+#define TLX_SEMAPHORE_HEADER
+
+#include <condition_variable>
+#include <cstddef>
+#include <mutex>
+
+namespace tlx {
+
+//! A simple semaphore implementation using C++11 synchronization methods.
+class Semaphore
+{
+public:
+    //! construct semaphore
+    explicit Semaphore(size_t initial_value = 0) : value_(initial_value)
+    {
+    }
+
+    //! non-copyable: delete copy-constructor
+    Semaphore(const Semaphore&) = delete;
+    //! non-copyable: delete assignment operator
+    Semaphore& operator=(const Semaphore&) = delete;
+
+    //! move-constructor: just move the value
+    Semaphore(Semaphore&& s) noexcept : value_(s.value_)
+    {
+    }
+
+    //! move-assignment: just move the value
+    Semaphore& operator=(Semaphore&& s) noexcept
+    {
+        value_ = s.value_;
+        return *this;
+    }
+
+    //! function increments the semaphore and signals any threads that are
+    //! blocked waiting a change in the semaphore
+    size_t signal()
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        size_t res = ++value_;
+        cv_.notify_one();
+        return res;
+    }
+
+    //! function increments the semaphore and signals any threads that are
+    //! blocked waiting a change in the semaphore
+    size_t signal(size_t delta)
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        size_t res = (value_ += delta);
+        cv_.notify_all();
+        return res;
+    }
+
+    //! function decrements the semaphore by delta and blocks if the semaphore
+    //! is < (delta + slack) until another thread signals a change
+    size_t wait(size_t delta = 1, size_t slack = 0)
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        while (value_ < delta + slack)
+            cv_.wait(lock);
+        value_ -= delta;
+        return value_;
+    }
+
+    //! function decrements the semaphore by delta if (delta + slack) tokens are
+    //! available as a batch. the function will not block and returns true if
+    //! delta was acquired otherwise false.
+    bool try_acquire(size_t delta = 1, size_t slack = 0)
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        if (value_ < delta + slack)
+            return false;
+        value_ -= delta;
+        return true;
+    }
+
+    //! return the current value -- should only be used for debugging.
+    size_t value() const
+    {
+        return value_;
+    }
+
+private:
+    //! value of the semaphore
+    size_t value_;
+
+    //! mutex for condition variable
+    std::mutex mutex_;
+
+    //! condition variable
+    std::condition_variable cv_;
+};
+
+//! alias for STL-like code style
+using semaphore = Semaphore;
+
+} // namespace tlx
+
+#endif // !TLX_SEMAPHORE_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/simple_vector.hpp

@@ -0,0 +1,20 @@
+/*******************************************************************************
+ * tlx/simple_vector.hpp
+ *
+ * Alias for <tlx/container/simple_vector.hpp>
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2018 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_SIMPLE_VECTOR_HEADER
+#define TLX_SIMPLE_VECTOR_HEADER
+
+#include <tlx/container/simple_vector.hpp> // NOLINT(misc-include-cleaner)
+
+#endif // !TLX_SIMPLE_VECTOR_HEADER
+
+/******************************************************************************/

package/vendor/include/tlx/siphash.hpp

@@ -0,0 +1,282 @@
+/*******************************************************************************
+ * tlx/siphash.hpp
+ *
+ * SipHash Implementations borrowed under Public Domain license from
+ * https://github.com/floodyberry/siphash
+ *
+ * Part of tlx - http://panthema.net/tlx
+ *
+ * Copyright (C) 2017-2024 Timo Bingmann <tb@panthema.net>
+ *
+ * All rights reserved. Published under the Boost Software License, Version 1.0
+ ******************************************************************************/
+
+#ifndef TLX_SIPHASH_HEADER
+#define TLX_SIPHASH_HEADER
+
+#include <tlx/container/string_view.hpp>
+#include <tlx/define/attribute_fallthrough.hpp>
+#include <tlx/math/bswap_le.hpp>
+#include <tlx/math/rol.hpp>
+#include <cstdint>
+#include <cstdlib>
+
+#if defined(_MSC_VER)
+
+#include <intrin.h>
+
+#if (_MSC_VER > 1200) || defined(_mm_free)
+#define __SSE2__
+#endif
+
+#endif // !defined(_MSC_VER)
+
+#if defined(__SSE2__)
+#include <emmintrin.h>
+#include <xmmintrin.h>
+#endif
+
+namespace tlx {
+
+static inline std::uint64_t siphash_plain(const std::uint8_t key[16],
+                                          const std::uint8_t* m, size_t len)
+{
+    std::uint64_t v0, v1, v2, v3;
+    std::uint64_t mi, k0, k1;
+    std::uint64_t last7;
+    size_t i, blocks;
+
+    k0 = bswap64_le(*reinterpret_cast<const std::uint64_t*>(key + 0));
+    k1 = bswap64_le(*reinterpret_cast<const std::uint64_t*>(key + 8));
+    v0 = k0 ^ 0x736f6d6570736575ULL;
+    v1 = k1 ^ 0x646f72616e646f6dULL;
+    v2 = k0 ^ 0x6c7967656e657261ULL;
+    v3 = k1 ^ 0x7465646279746573ULL;
+
+    last7 = static_cast<std::uint64_t>(len & 0xff) << 56;
+
+#define TLX_SIPCOMPRESS()                                                      \
+    v0 += v1;                                                                  \
+    v2 += v3;                                                                  \
+    v1 = rol64(v1, 13);                                                        \
+    v3 = rol64(v3, 16);                                                        \
+    v1 ^= v0;                                                                  \
+    v3 ^= v2;                                                                  \
+    v0 = rol64(v0, 32);                                                        \
+    v2 += v1;                                                                  \
+    v0 += v3;                                                                  \
+    v1 = rol64(v1, 17);                                                        \
+    v3 = rol64(v3, 21);                                                        \
+    v1 ^= v2;                                                                  \
+    v3 ^= v0;                                                                  \
+    v2 = rol64(v2, 32);
+
+    for (i = 0, blocks = (len & ~7); i < blocks; i += 8)
+    {
+        mi = bswap64_le(*reinterpret_cast<const std::uint64_t*>(m + i));
+        v3 ^= mi;
+        TLX_SIPCOMPRESS();
+        TLX_SIPCOMPRESS();
+        v0 ^= mi;
+    }
+
+    switch (len - blocks)
+    {
+    case 7:
+        last7 |= static_cast<std::uint64_t>(m[i + 6]) << 48;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 6:
+        last7 |= static_cast<std::uint64_t>(m[i + 5]) << 40;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 5:
+        last7 |= static_cast<std::uint64_t>(m[i + 4]) << 32;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 4:
+        last7 |= static_cast<std::uint64_t>(m[i + 3]) << 24;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 3:
+        last7 |= static_cast<std::uint64_t>(m[i + 2]) << 16;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 2:
+        last7 |= static_cast<std::uint64_t>(m[i + 1]) << 8;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 1:
+        last7 |= static_cast<std::uint64_t>(m[i + 0]);
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 0:
+    default:;
+    }
+
+    v3 ^= last7;
+    TLX_SIPCOMPRESS();
+    TLX_SIPCOMPRESS();
+    v0 ^= last7;
+    v2 ^= 0xff;
+    TLX_SIPCOMPRESS();
+    TLX_SIPCOMPRESS();
+    TLX_SIPCOMPRESS();
+    TLX_SIPCOMPRESS();
+
+#undef TLX_SIPCOMPRESS
+
+    return v0 ^ v1 ^ v2 ^ v3;
+}
+
+/******************************************************************************/
+// SSE2 vectorization
+
+#if defined(__SSE2__)
+
+union siphash_packedelem64
+{
+    std::uint64_t u[2];
+    __m128i v;
+};
+
+/* 0,2,1,3 */
+static const siphash_packedelem64 siphash_init[2] = {
+    {{0x736f6d6570736575ULL, 0x6c7967656e657261ULL}},
+    {{0x646f72616e646f6dULL, 0x7465646279746573ULL}}};
+
+static const siphash_packedelem64 siphash_final = {
+    {0x0000000000000000ULL, 0x00000000000000ffULL}};
+
+static inline std::uint64_t siphash_sse2(const std::uint8_t key[16],
+                                         const std::uint8_t* m, size_t len)
+{
+    __m128i k, v02, v20, v13, v11, v33, mi;
+    std::uint64_t last7;
+    std::uint32_t lo, hi;
+    size_t i, blocks;
+
+    k = _mm_loadu_si128(reinterpret_cast<const __m128i*>(key + 0));
+    v02 = siphash_init[0].v;
+    v13 = siphash_init[1].v;
+    v02 = _mm_xor_si128(v02, _mm_unpacklo_epi64(k, k));
+    v13 = _mm_xor_si128(v13, _mm_unpackhi_epi64(k, k));
+
+    last7 = static_cast<std::uint64_t>(len & 0xff) << 56;
+
+#define TLX_SIPCOMPRESS()                                                      \
+    v11 = v13;                                                                 \
+    v33 = _mm_shuffle_epi32(v13, _MM_SHUFFLE(1, 0, 3, 2));                     \
+    v11 = _mm_or_si128(_mm_slli_epi64(v11, 13), _mm_srli_epi64(v11, 64 - 13)); \
+    v02 = _mm_add_epi64(v02, v13);                                             \
+    v33 = _mm_shufflelo_epi16(v33, _MM_SHUFFLE(2, 1, 0, 3));                   \
+    v13 = _mm_unpacklo_epi64(v11, v33);                                        \
+    v13 = _mm_xor_si128(v13, v02);                                             \
+    v20 = _mm_shuffle_epi32(v02, _MM_SHUFFLE(0, 1, 3, 2));                     \
+    v11 = v13;                                                                 \
+    v33 = _mm_shuffle_epi32(v13, _MM_SHUFFLE(1, 0, 3, 2));                     \
+    v11 = _mm_or_si128(_mm_slli_epi64(v11, 17), _mm_srli_epi64(v11, 64 - 17)); \
+    v20 = _mm_add_epi64(v20, v13);                                             \
+    v33 = _mm_or_si128(_mm_slli_epi64(v33, 21), _mm_srli_epi64(v33, 64 - 21)); \
+    v13 = _mm_unpacklo_epi64(v11, v33);                                        \
+    v02 = _mm_shuffle_epi32(v20, _MM_SHUFFLE(0, 1, 3, 2));                     \
+    v13 = _mm_xor_si128(v13, v20);
+
+    for (i = 0, blocks = (len & ~7); i < blocks; i += 8)
+    {
+        mi = _mm_loadl_epi64(reinterpret_cast<const __m128i*>(m + i));
+        v13 = _mm_xor_si128(v13, _mm_slli_si128(mi, 8));
+        TLX_SIPCOMPRESS();
+        TLX_SIPCOMPRESS();
+        v02 = _mm_xor_si128(v02, mi);
+    }
+
+    switch (len - blocks)
+    {
+    case 7:
+        last7 |= static_cast<std::uint64_t>(m[i + 6]) << 48;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 6:
+        last7 |= static_cast<std::uint64_t>(m[i + 5]) << 40;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 5:
+        last7 |= static_cast<std::uint64_t>(m[i + 4]) << 32;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 4:
+        last7 |= static_cast<std::uint64_t>(m[i + 3]) << 24;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 3:
+        last7 |= static_cast<std::uint64_t>(m[i + 2]) << 16;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 2:
+        last7 |= static_cast<std::uint64_t>(m[i + 1]) << 8;
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 1:
+        last7 |= static_cast<std::uint64_t>(m[i + 0]);
+        TLX_ATTRIBUTE_FALLTHROUGH;
+    case 0:
+    default:;
+    }
+
+    mi = _mm_unpacklo_epi32(
+        _mm_cvtsi32_si128(static_cast<std::uint32_t>(last7)),
+        _mm_cvtsi32_si128(static_cast<std::uint32_t>(last7 >> 32)));
+    v13 = _mm_xor_si128(v13, _mm_slli_si128(mi, 8));
+    TLX_SIPCOMPRESS();
+    TLX_SIPCOMPRESS();
+    v02 = _mm_xor_si128(v02, mi);
+    v02 = _mm_xor_si128(v02, siphash_final.v);
+    TLX_SIPCOMPRESS();
+    TLX_SIPCOMPRESS();
+    TLX_SIPCOMPRESS();
+    TLX_SIPCOMPRESS();
+
+    v02 = _mm_xor_si128(v02, v13);
+    v02 = _mm_xor_si128(v02, _mm_shuffle_epi32(v02, _MM_SHUFFLE(1, 0, 3, 2)));
+    lo = _mm_cvtsi128_si32(v02);
+    hi = _mm_cvtsi128_si32(_mm_srli_si128(v02, 4));
+
+#undef TLX_SIPCOMPRESS
+
+    return (static_cast<std::uint64_t>(hi) << 32) | lo;
+}
+
+#endif // defined(__SSE2__)
+
+/******************************************************************************/
+// Switch between available implementations
+
+static inline std::uint64_t siphash(const std::uint8_t key[16],
+                                    const std::uint8_t* msg, size_t size)
+{
+#if defined(__SSE2__)
+    return siphash_sse2(key, msg, size);
+#else
+    return siphash_plain(key, msg, size);
+#endif
+}
+
+static inline std::uint64_t siphash(const std::uint8_t* msg, size_t size)
+{
+    const unsigned char key[16] = {0, 1, 2,  3,  4,  5,  6,  7,
+                                   8, 9, 10, 11, 12, 13, 14, 15};
+    return siphash(key, msg, size);
+}
+
+static inline std::uint64_t siphash(const char* msg, size_t size)
+{
+    return siphash(reinterpret_cast<const std::uint8_t*>(msg), size);
+}
+
+static inline std::uint64_t siphash(tlx::string_view str)
+{
+    return siphash(str.data(), str.size());
+}
+
+template <typename Type>
+static inline std::uint64_t siphash(const Type& value)
+{
+    return siphash(reinterpret_cast<const std::uint8_t*>(&value),
+                   sizeof(value));
+}
+
+#undef rol64
+
+} // namespace tlx
+
+#endif // !TLX_SIPHASH_HEADER
+
+/******************************************************************************/