ars.hpp

Go to the documentation of this file.

//============================================================================
// vSMC/include/vsmc/rng/ars.hpp
//----------------------------------------------------------------------------
//                         vSMC: Scalable Monte Carlo
//----------------------------------------------------------------------------
// Copyright (c) 2013,2014, 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_BLOCKS
#define VSMC_RNG_ARS_BLOCKS 1
#endif

#ifndef VSMC_RNG_ARS_ROUNDS
#define VSMC_RNG_ARS_ROUNDS 7
#endif

namespace vsmc {

namespace traits {

namespace internal {

template <std::size_t> struct ARSWeylConstantValue;

template <> struct ARSWeylConstantValue<0> :
    public cxx11::integral_constant<uint64_t, UINT64_C(0xBB67AE8584CAA73B)> {};

template <> struct ARSWeylConstantValue<1> :
    public cxx11::integral_constant<uint64_t, UINT64_C(0x9E3779B97F4A7C15)> {};

} // namespace vsmc::traits::internal

template <std::size_t I> struct ARSWeylConstantTrait :
    public internal::ARSWeylConstantValue<I> {};

} // namespace vsmc::traits

template <typename ResultType>
class ARSKeySeq
{
    public :

    typedef Array<ResultType, 16 / sizeof(ResultType)> key_type;

    ARSKeySeq () : weyl_(_mm_set_epi64x(
                static_cast<int64_t>(traits::ARSWeylConstantTrait<0>::value),
                static_cast<int64_t>(traits::ARSWeylConstantTrait<1>::value)))
    {}

    template <std::size_t Rp1>
    void generate (const key_type &key, Array<__m128i, Rp1> &key_seq)
    {
        m128i_pack<0>(key, key_seq.front());
        generate_seq<1>(key_seq, cxx11::integral_constant<bool, 1 < Rp1>());
    }

    private :

    const __m128i weyl_;

    template <std::size_t, std::size_t Rp1>
    void generate_seq (Array<__m128i, Rp1> &, cxx11::false_type) {}

    template <std::size_t N, std::size_t Rp1>
    void generate_seq (Array<__m128i, Rp1> &key_seq, cxx11::true_type)
    {
        key_seq[Position<N>()] = _mm_add_epi64(
                key_seq[Position<N - 1>()], weyl_);
        generate_seq<N + 1>(key_seq,
                cxx11::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>
class ARSEngine :
    public AESNIEngine<ResultType, ARSKeySeq<ResultType>,
    false, Rounds, Blocks>
{
    public :

    typedef AESNIEngine<ResultType, ARSKeySeq<ResultType>,
            false, Rounds, Blocks> base_eng_type;

    explicit ARSEngine (ResultType s = 0) : base_eng_type(s) {}

    template <typename SeedSeq>
    explicit ARSEngine (SeedSeq &seq, typename cxx11::enable_if<
            internal::is_seed_seq<SeedSeq,
            typename base_eng_type::result_type,
            typename base_eng_type::key_type,
            ARSEngine<ResultType, Rounds, Blocks>
            >::value>::type * = VSMC_NULLPTR) : base_eng_type(seq) {}

    ARSEngine (const typename base_eng_type::key_type &k) : base_eng_type(k) {}
}; // class ARSEngine

typedef ARSEngine<uint32_t> ARS_32;

typedef ARSEngine<uint32_t, VSMC_RNG_ARS_ROUNDS, 1> ARS_1x32;

typedef ARSEngine<uint32_t, VSMC_RNG_ARS_ROUNDS, 2> ARS_2x32;

typedef ARSEngine<uint32_t, VSMC_RNG_ARS_ROUNDS, 4> ARS_4x32;

typedef ARSEngine<uint32_t, VSMC_RNG_ARS_ROUNDS, 8> ARS_8x32;

typedef ARSEngine<uint64_t> ARS_64;

typedef ARSEngine<uint64_t, VSMC_RNG_ARS_ROUNDS, 1> ARS_1x64;

typedef ARSEngine<uint64_t, VSMC_RNG_ARS_ROUNDS, 2> ARS_2x64;

typedef ARSEngine<uint64_t, VSMC_RNG_ARS_ROUNDS, 4> ARS_4x64;

typedef ARSEngine<uint64_t, VSMC_RNG_ARS_ROUNDS, 8> ARS_8x64;

} // namespace vsmc

#endif // VSMC_RNG_ARS_HPP