ars.hpp

Go to the documentation of this file.

//============================================================================
// vSMC/include/vsmc/rng/ars.hpp
//----------------------------------------------------------------------------
//                         vSMC: Scalable Monte Carlo
//----------------------------------------------------------------------------
// Copyright (c) 2013-2016, Yan Zhou
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
//   Redistributions of source code must retain the above copyright notice,
//   this list of conditions and the following disclaimer.
//
//   Redistributions in binary form must reproduce the above copyright notice,
//   this list of conditions and the following disclaimer in the documentation
//   and/or other materials provided with the distribution.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//============================================================================

#ifndef VSMC_RNG_ARS_HPP
#define VSMC_RNG_ARS_HPP

#include <vsmc/rng/internal/common.hpp>
#include <vsmc/rng/aes_ni.hpp>

#ifndef VSMC_RNG_ARS_ROUNDS
#define VSMC_RNG_ARS_ROUNDS 5
#endif

#ifndef VSMC_RNG_ARS_BLOCKS
#define VSMC_RNG_ARS_BLOCKS 4
#endif

namespace vsmc
{

namespace internal
{

template <std::size_t>
class ARSWeylConstant;

template <>
class ARSWeylConstant<0> : public std::integral_constant<std::uint64_t,
                               UINT64_C(0x9E3779B97F4A7C15)>
{
}; // class ARSWeylConstant

template <>
class ARSWeylConstant<1> : public std::integral_constant<std::uint64_t,
                               UINT64_C(0xBB67AE8584CAA73B)>
{
}; // class ARSWeylConstant

} // namespace vsmc::internal

template <std::size_t I>
class ARSWeylConstantTrait : public internal::ARSWeylConstant<I>
{
}; // class ARSWeylConstantTrait

template <typename T>
class ARSKeySeq
{
    public:
    using key_type = std::array<T, M128I<T>::size()>;

    void reset(const key_type &) {}

    template <typename U, std::size_t Rp1>
    void operator()(const key_type &key, std::array<M128I<U>, Rp1> &rk) const
    {
        M128I<std::uint64_t> weyl;
        weyl.set(
            ARSWeylConstantTrait<1>::value, ARSWeylConstantTrait<0>::value);
        std::get<0>(rk).load(key.data());
        generate<1>(rk, weyl, std::integral_constant<bool, 1 < Rp1>());
    }

    private:
    template <std::size_t, typename U, std::size_t Rp1>
    void generate(std::array<M128I<U>, Rp1> &, const M128I<std::uint64_t> &,
        std::false_type) const
    {
    }

    template <std::size_t N, typename U, std::size_t Rp1>
    void generate(std::array<M128I<U>, Rp1> &rk,
        const M128I<std::uint64_t> &weyl, std::true_type) const
    {
        std::get<N>(rk) =
            _mm_add_epi64(std::get<N - 1>(rk).value(), weyl.value());
        generate<N + 1>(rk, weyl, std::integral_constant<bool, N + 1 < Rp1>());
    }
}; // class ARSKeySeq

template <typename ResultType, std::size_t Rounds = VSMC_RNG_ARS_ROUNDS,
    std::size_t Blocks = VSMC_RNG_ARS_BLOCKS>
using ARSEngine =
    AESNIEngine<ResultType, ARSKeySeq<ResultType>, Rounds, Blocks>;

using ARS_1x32 = ARSEngine<std::uint32_t, VSMC_RNG_ARS_ROUNDS, 1>;

using ARS_2x32 = ARSEngine<std::uint32_t, VSMC_RNG_ARS_ROUNDS, 2>;

using ARS_4x32 = ARSEngine<std::uint32_t, VSMC_RNG_ARS_ROUNDS, 4>;

using ARS_8x32 = ARSEngine<std::uint32_t, VSMC_RNG_ARS_ROUNDS, 8>;

using ARS_1x64 = ARSEngine<std::uint64_t, VSMC_RNG_ARS_ROUNDS, 1>;

using ARS_2x64 = ARSEngine<std::uint64_t, VSMC_RNG_ARS_ROUNDS, 2>;

using ARS_4x64 = ARSEngine<std::uint64_t, VSMC_RNG_ARS_ROUNDS, 4>;

using ARS_8x64 = ARSEngine<std::uint64_t, VSMC_RNG_ARS_ROUNDS, 8>;

using ARS = ARSEngine<std::uint32_t>;

using ARS_64 = ARSEngine<std::uint64_t>;

} // namespace vsmc

#endif // VSMC_RNG_ARS_HPP