MCKL
Monte Carlo Kernel Library
threefry_generic_16x64.hpp
Go to the documentation of this file.
1 //============================================================================
2 // MCKL/include/mckl/random/internal/threefry_generic_16x64.hpp
3 //----------------------------------------------------------------------------
4 // MCKL: Monte Carlo Kernel Library
5 //----------------------------------------------------------------------------
6 // Copyright (c) 2013-2018, Yan Zhou
7 // All rights reserved.
8 //
9 // Redistribution and use in source and binary forms, with or without
10 // modification, are permitted provided that the following conditions are met:
11 //
12 // Redistributions of source code must retain the above copyright notice,
13 // this list of conditions and the following disclaimer.
14 //
15 // Redistributions in binary form must reproduce the above copyright notice,
16 // this list of conditions and the following disclaimer in the documentation
17 // and/or other materials provided with the distribution.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS AS IS
20 // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 // ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
23 // LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 // CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 // INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 // CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 // ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 // POSSIBILITY OF SUCH DAMAGE.
30 //============================================================================
31 
32 #ifndef MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_HPP
33 #define MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_HPP
34 
35 #include <mckl/random/internal/common.hpp>
36 #include <mckl/random/internal/threefry_common.hpp>
37 #include <mckl/random/internal/threefry_constants.hpp>
38 #include <mckl/random/increment.hpp>
39 
40 #define MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_KBOX(N) \
41  s0 += ThreefryKBox<T, K, N>::template key<0x0>(par); \
42  s1 += ThreefryKBox<T, K, N>::template key<0x1>(par); \
43  s2 += ThreefryKBox<T, K, N>::template key<0x2>(par); \
44  s3 += ThreefryKBox<T, K, N>::template key<0x3>(par); \
45  s4 += ThreefryKBox<T, K, N>::template key<0x4>(par); \
46  s5 += ThreefryKBox<T, K, N>::template key<0x5>(par); \
47  s6 += ThreefryKBox<T, K, N>::template key<0x6>(par); \
48  s7 += ThreefryKBox<T, K, N>::template key<0x7>(par); \
49  s8 += ThreefryKBox<T, K, N>::template key<0x8>(par); \
50  s9 += ThreefryKBox<T, K, N>::template key<0x9>(par); \
51  sA += ThreefryKBox<T, K, N>::template key<0xA>(par); \
52  sB += ThreefryKBox<T, K, N>::template key<0xB>(par); \
53  sC += ThreefryKBox<T, K, N>::template key<0xC>(par); \
54  sD += ThreefryKBox<T, K, N>::template key<0xD>(par); \
55  sE += ThreefryKBox<T, K, N>::template key<0xE>(par); \
56  sF += ThreefryKBox<T, K, N>::template key<0xF>(par);
57 
58 #define MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N) \
59  { \
60  constexpr int L0 = Constants::rotate::value[0][(N - 1) % 8]; \
61  constexpr int L1 = Constants::rotate::value[1][(N - 1) % 8]; \
62  constexpr int L2 = Constants::rotate::value[2][(N - 1) % 8]; \
63  constexpr int L3 = Constants::rotate::value[3][(N - 1) % 8]; \
64  constexpr int L4 = Constants::rotate::value[4][(N - 1) % 8]; \
65  constexpr int L5 = Constants::rotate::value[5][(N - 1) % 8]; \
66  constexpr int L6 = Constants::rotate::value[6][(N - 1) % 8]; \
67  constexpr int L7 = Constants::rotate::value[7][(N - 1) % 8]; \
68  constexpr int R0 = 64 - L0; \
69  constexpr int R1 = 64 - L1; \
70  constexpr int R2 = 64 - L2; \
71  constexpr int R3 = 64 - L3; \
72  constexpr int R4 = 64 - L4; \
73  constexpr int R5 = 64 - L5; \
74  constexpr int R6 = 64 - L6; \
75  constexpr int R7 = 64 - L7; \
76  t0 = s0 + s1; \
77  t2 = s2 + s3; \
78  t4 = s4 + s5; \
79  t6 = s6 + s7; \
80  t8 = s8 + s9; \
81  tA = sA + sB; \
82  tC = sC + sD; \
83  tE = sE + sF; \
84  t1 = (s1 << L0) | (s1 >> R0); \
85  t3 = (s3 << L1) | (s3 >> R1); \
86  t5 = (s5 << L2) | (s5 >> R2); \
87  t7 = (s7 << L3) | (s7 >> R3); \
88  t9 = (s9 << L4) | (s9 >> R4); \
89  tB = (sB << L5) | (sB >> R5); \
90  tD = (sD << L6) | (sD >> R6); \
91  tF = (sF << L7) | (sF >> R7); \
92  s0 = t0; \
93  s2 = t2; \
94  s4 = t6; \
95  s6 = t4; \
96  s8 = tA; \
97  sA = tC; \
98  sC = tE; \
99  sE = t8; \
100  s1 = t8 ^ t9; \
101  s3 = tC ^ tD; \
102  s5 = tA ^ tB; \
103  s7 = tE ^ tF; \
104  s9 = t6 ^ t7; \
105  sB = t2 ^ t3; \
106  sD = t4 ^ t5; \
107  sF = t0 ^ t1; \
108  }
109 
110 #define MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_4(N) \
111  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 1); \
112  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 2); \
113  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 3); \
114  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 4); \
115  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_KBOX(N * 8 + 4);
116 
117 #define MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(N) \
118  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 1); \
119  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 2); \
120  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 3); \
121  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 4); \
122  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_KBOX(N * 8 + 4); \
123  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 5); \
124  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 6); \
125  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 7); \
126  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_RBOX(N * 8 + 8); \
127  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_KBOX(N * 8 + 8);
128 
129 #define MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND_20 \
130  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_KBOX(0) \
131  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(0) \
132  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(1) \
133  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_4(2)
134 
135 #define MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND_80 \
136  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_KBOX(0) \
137  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(0) \
138  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(1) \
139  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(2) \
140  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(3) \
141  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(4) \
142  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(5) \
143  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(6) \
144  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(7) \
145  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(8) \
146  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_CYCLE_8(9)
147 
148 #define MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND(L) \
149  T s0 = std::get<0x0>(buf.s); \
150  T s1 = std::get<0x1>(buf.s); \
151  T s2 = std::get<0x2>(buf.s); \
152  T s3 = std::get<0x3>(buf.s); \
153  T s4 = std::get<0x4>(buf.s); \
154  T s5 = std::get<0x5>(buf.s); \
155  T s6 = std::get<0x6>(buf.s); \
156  T s7 = std::get<0x7>(buf.s); \
157  T s8 = std::get<0x8>(buf.s); \
158  T s9 = std::get<0x9>(buf.s); \
159  T sA = std::get<0xA>(buf.s); \
160  T sB = std::get<0xB>(buf.s); \
161  T sC = std::get<0xC>(buf.s); \
162  T sD = std::get<0xD>(buf.s); \
163  T sE = std::get<0xE>(buf.s); \
164  T sF = std::get<0xF>(buf.s); \
165  T t0; \
166  T t1; \
167  T t2; \
168  T t3; \
169  T t4; \
170  T t5; \
171  T t6; \
172  T t7; \
173  T t8; \
174  T t9; \
175  T tA; \
176  T tB; \
177  T tC; \
178  T tD; \
179  T tE; \
180  T tF; \
181  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND_##L; \
182  std::get<0x0>(buf.s) = s0; \
183  std::get<0x1>(buf.s) = s1; \
184  std::get<0x2>(buf.s) = s2; \
185  std::get<0x3>(buf.s) = s3; \
186  std::get<0x4>(buf.s) = s4; \
187  std::get<0x5>(buf.s) = s5; \
188  std::get<0x6>(buf.s) = s6; \
189  std::get<0x7>(buf.s) = s7; \
190  std::get<0x8>(buf.s) = s8; \
191  std::get<0x9>(buf.s) = s9; \
192  std::get<0xA>(buf.s) = sA; \
193  std::get<0xB>(buf.s) = sB; \
194  std::get<0xC>(buf.s) = sC; \
195  std::get<0xD>(buf.s) = sD; \
196  std::get<0xE>(buf.s) = sE; \
197  std::get<0xF>(buf.s) = sF;
198 
199 namespace mckl {
200 
201 namespace internal {
202 
203 template <typename T>
204 class Threefry16x64GeneratorGenericImpl
205 {
206  static_assert(std::numeric_limits<T>::digits == 64,
207  "**Threefry16x64GeneratorGenericImpl** used with T other than a "
208  "64-bit unsigned integers");
209 
210  static constexpr std::size_t K = 16;
211  static constexpr std::size_t Rounds = 20;
212  using Constants = ThreefryConstants<T, 16>;
213 
214  public:
215  static void eval(
216  const void *plain, void *cipher, const std::array<T, K + 4> &par)
217  {
218  alignas(MCKL_ALIGNMENT) union {
219  std::array<T, K> s;
220  std::array<char, sizeof(T) * K> r;
221  } buf;
222 
223  std::memcpy(buf.s.data(), plain, sizeof(T) * K);
224  union_le<char>(buf.s);
225  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND(20)
226  union_le<T>(buf.r);
227  std::memcpy(cipher, buf.s.data(), sizeof(T) * K);
228  }
229 
230  template <typename ResultType>
231  static void eval(
232  Counter<T, K> &ctr, ResultType *r, const std::array<T, K + 4> &par)
233  {
234  alignas(MCKL_ALIGNMENT) union {
235  std::array<T, K> s;
236  Counter<T, K> c;
237  std::array<ResultType, sizeof(T) * K / sizeof(ResultType)> r;
238  } buf;
239 
240  MCKL_INLINE_CALL increment(ctr);
241  buf.c = ctr;
242 #if MCKL_REQUIRE_ENDIANNESS_NEUTURAL
243  union_le<typename Counter<T, K>::value_type>(buf.s);
244 #endif
245  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND(20)
246 #if MCKL_REQUIRE_ENDIANNESS_NEUTURAL
247  union_le<T>(buf.r);
248 #endif
249  std::memcpy(r, buf.r.data(), sizeof(T) * K);
250  }
251 
252  template <typename ResultType>
253  static void eval(Counter<T, K> &ctr, std::size_t n, ResultType *r,
254  const std::array<T, K + 4> &par)
255  {
256  constexpr std::size_t R = sizeof(T) * K / sizeof(ResultType);
257 
258  for (std::size_t i = 0; i != n; ++i, r += R) {
259  eval(ctr, r, par);
260  }
261  }
262 }; // class Threefry16x64GeneratorGenericImpl
263 
264 template <typename T>
265 class Threefish1024GeneratorGenericImpl
266 {
267  static_assert(std::numeric_limits<T>::digits == 64,
268  "**Threefish1024GeneratorGenericImpl** used with T other than a "
269  "64-bit unsigned integers");
270 
271  static constexpr std::size_t K = 16;
272  static constexpr std::size_t Rounds = 80;
273  using Constants = ThreefryConstants<T, 16>;
274 
275  public:
276  static void eval(
277  const void *plain, void *cipher, const std::array<T, K + 4> &par)
278  {
279  alignas(MCKL_ALIGNMENT) union {
280  std::array<T, K> s;
281  std::array<char, sizeof(T) * K> r;
282  } buf;
283 
284  std::memcpy(buf.s.data(), plain, sizeof(T) * K);
285  union_le<char>(buf.s);
286  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND(80)
287  union_le<T>(buf.r);
288  std::memcpy(cipher, buf.s.data(), sizeof(T) * K);
289  }
290 
291  template <typename ResultType>
292  static void eval(
293  Counter<T, K> &ctr, ResultType *r, const std::array<T, K + 4> &par)
294  {
295  alignas(MCKL_ALIGNMENT) union {
296  std::array<T, K> s;
297  Counter<T, K> c;
298  std::array<ResultType, sizeof(T) * K / sizeof(ResultType)> r;
299  } buf;
300 
301  MCKL_INLINE_CALL increment(ctr);
302  buf.c = ctr;
303 #if MCKL_REQUIRE_ENDIANNESS_NEUTURAL
304  union_le<typename Counter<T, K>::value_type>(buf.s);
305 #endif
306  MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND(80)
307 #if MCKL_REQUIRE_ENDIANNESS_NEUTURAL
308  union_le<T>(buf.r);
309 #endif
310  std::memcpy(r, buf.r.data(), sizeof(T) * K);
311  }
312 
313  template <typename ResultType>
314  static void eval(Counter<T, K> &ctr, std::size_t n, ResultType *r,
315  const std::array<T, K + 4> &par)
316  {
317  constexpr std::size_t R = sizeof(T) * K / sizeof(ResultType);
318 
319  for (std::size_t i = 0; i != n; ++i, r += R) {
320  eval(ctr, r, par);
321  }
322  }
323 }; // class Threefish1024GeneratorGenericImpl
324 
325 } // namespace internal
326 
327 } // namespace mckl
328 
329 #endif // MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_HPP
MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND
#define MCKL_RANDOM_INTERNAL_THREEFRY_GENERIC_16X64_ROUND(L)
Definition: threefry_generic_16x64.hpp:148
MCKL_INLINE_CALL
#define MCKL_INLINE_CALL
Definition: intel.h:142
mckl::Counter
typename internal::CounterImpl< T, K >::type Counter
A counter type with the same width as std::array<T, K> but with possibly fewer elements.
Definition: increment.hpp:104
mckl::internal::Threefish1024GeneratorGenericImpl::eval
static void eval(const void *plain, void *cipher, const std::array< T, K+4 > &par)
Definition: threefry_generic_16x64.hpp:276
mckl::internal::Threefish1024GeneratorGenericImpl::eval
static void eval(Counter< T, K > &ctr, std::size_t n, ResultType *r, const std::array< T, K+4 > &par)
Definition: threefry_generic_16x64.hpp:314
mckl::ThreefryConstants
Default Threefry constants.
Definition: threefry_constants.hpp:147
mckl::internal::Threefry16x64GeneratorGenericImpl::eval
static void eval(const void *plain, void *cipher, const std::array< T, K+4 > &par)
Definition: threefry_generic_16x64.hpp:215
mckl::increment
void increment(std::array< T, K > &ctr, std::integral_constant< T, NSkip >)
Increment a counter by given steps.
Definition: increment_generic.hpp:196
mckl::internal::Threefish1024GeneratorGenericImpl::eval
static void eval(Counter< T, K > &ctr, ResultType *r, const std::array< T, K+4 > &par)
Definition: threefry_generic_16x64.hpp:292
mckl::internal::Threefry16x64GeneratorGenericImpl::eval
static void eval(Counter< T, K > &ctr, ResultType *r, const std::array< T, K+4 > &par)
Definition: threefry_generic_16x64.hpp:231
threefry_constants.hpp
mckl
Definition: mcmc.hpp:40
mckl::internal::Threefry16x64GeneratorGenericImpl::eval
static void eval(Counter< T, K > &ctr, std::size_t n, ResultType *r, const std::array< T, K+4 > &par)
Definition: threefry_generic_16x64.hpp:253
MCKL_ALIGNMENT
#define MCKL_ALIGNMENT
The default alignment for scalar type.
Definition: config.h:187
threefry_common.hpp
Generated by   doxygen 1.8.13