/perf/kseta

To get this branch, use:
bzr branch http://darksoft.org/webbzr/perf/kseta

« back to all changes in this revision

Viewing changes to tutorials/4_pi/random123/ars.h

  • Committer: Suren A. Chilingaryan
  • Date: 2013-10-08 23:53:50 UTC
  • Revision ID: csa@dside.dyndns.org-20131008235350-hsu8oukzkh05gtcm
Add tutorials

Show diffs side-by-side

added added

removed removed

Lines of Context:
tutorials/4_pi/random123/ars.h
 
1
/*
 
2
Copyright 2010-2011, D. E. Shaw Research.
 
3
All rights reserved.
 
4
 
 
5
Redistribution and use in source and binary forms, with or without
 
6
modification, are permitted provided that the following conditions are
 
7
met:
 
8
 
 
9
* Redistributions of source code must retain the above copyright
 
10
  notice, this list of conditions, and the following disclaimer.
 
11
 
 
12
* Redistributions in binary form must reproduce the above copyright
 
13
  notice, this list of conditions, and the following disclaimer in the
 
14
  documentation and/or other materials provided with the distribution.
 
15
 
 
16
* Neither the name of D. E. Shaw Research nor the names of its
 
17
  contributors may be used to endorse or promote products derived from
 
18
  this software without specific prior written permission.
 
19
 
 
20
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
21
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
22
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
23
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
24
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
25
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
26
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
27
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
28
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
29
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
30
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
31
*/
 
32
#ifndef __Random123_ars_dot_hpp__
 
33
#define __Random123_ars_dot_hpp__
 
34
 
 
35
#include "features/compilerfeatures.h"
 
36
#include "array.h"
 
37
 
 
38
#if R123_USE_AES_NI
 
39
 
 
40
#ifndef ARS1xm128i_DEFAULT_ROUNDS
 
41
#define ARS1xm128i_DEFAULT_ROUNDS 7
 
42
#endif
 
43
 
 
44
/** @ingroup AESNI */
 
45
enum r123_enum_ars1xm128i {ars1xm128i_rounds = ARS1xm128i_DEFAULT_ROUNDS};
 
46
 
 
47
/* ARS1xm128i with Weyl keys.  Fast, and Crush-resistant, but NOT CRYPTO. */
 
48
/** @ingroup AESNI */
 
49
typedef struct r123array1xm128i ars1xm128i_ctr_t;
 
50
/** @ingroup AESNI */
 
51
typedef struct r123array1xm128i ars1xm128i_key_t;
 
52
/** @ingroup AESNI */
 
53
typedef struct r123array1xm128i ars1xm128i_ukey_t;
 
54
/** @ingroup AESNI */
 
55
R123_STATIC_INLINE ars1xm128i_key_t ars1xm128ikeyinit(ars1xm128i_ukey_t uk) { return uk; }
 
56
/** @ingroup AESNI */
 
57
R123_STATIC_INLINE ars1xm128i_ctr_t ars1xm128i_R(unsigned int Nrounds, ars1xm128i_ctr_t in, ars1xm128i_key_t k){
 
58
    __m128i kweyl = _mm_set_epi64x(R123_64BIT(0xBB67AE8584CAA73B), /* sqrt(3) - 1.0 */
 
59
                                   R123_64BIT(0x9E3779B97F4A7C15)); /* golden ratio */
 
60
    /* N.B.  the aesenc instructions do the xor *after*
 
61
    // so if we want to follow the AES pattern, we
 
62
    // have to do the initial xor explicitly */
 
63
    __m128i kk = k.v[0].m;
 
64
    __m128i v = _mm_xor_si128(in.v[0].m, kk);
 
65
    ars1xm128i_ctr_t ret;
 
66
    R123_ASSERT(Nrounds<=10);
 
67
    if( Nrounds>1 ){
 
68
        kk = _mm_add_epi64(kk, kweyl);
 
69
        v = _mm_aesenc_si128(v, kk);
 
70
    }
 
71
    if( Nrounds>2 ){
 
72
        kk = _mm_add_epi64(kk, kweyl);
 
73
        v = _mm_aesenc_si128(v, kk);
 
74
    }
 
75
    if( Nrounds>3 ){
 
76
        kk = _mm_add_epi64(kk, kweyl);
 
77
        v = _mm_aesenc_si128(v, kk);
 
78
    }
 
79
    if( Nrounds>4 ){
 
80
        kk = _mm_add_epi64(kk, kweyl);
 
81
        v = _mm_aesenc_si128(v, kk);
 
82
    }
 
83
    if( Nrounds>5 ){
 
84
        kk = _mm_add_epi64(kk, kweyl);
 
85
        v = _mm_aesenc_si128(v, kk);
 
86
    }
 
87
    if( Nrounds>6 ){
 
88
        kk = _mm_add_epi64(kk, kweyl);
 
89
        v = _mm_aesenc_si128(v, kk);
 
90
    }
 
91
    if( Nrounds>7 ){
 
92
        kk = _mm_add_epi64(kk, kweyl);
 
93
        v = _mm_aesenc_si128(v, kk);
 
94
    }
 
95
    if( Nrounds>8 ){
 
96
        kk = _mm_add_epi64(kk, kweyl);
 
97
        v = _mm_aesenc_si128(v, kk);
 
98
    }
 
99
    if( Nrounds>9 ){
 
100
        kk = _mm_add_epi64(kk, kweyl);
 
101
        v = _mm_aesenc_si128(v, kk);
 
102
    }
 
103
    kk = _mm_add_epi64(kk, kweyl);
 
104
    v = _mm_aesenclast_si128(v, kk);
 
105
    ret.v[0].m = v;
 
106
    return ret;
 
107
}
 
108
 
 
109
/** @def ars1xm128i
 
110
@ingroup AESNI
 
111
The ars1mx128i macro provides a C API interface to the @ref AESNI "ARS" CBRNG with the default number of rounds i.e. \c ars1xm128i_rounds **/
 
112
#define ars1xm128i(c,k) ars1xm128i_R(ars1xm128i_rounds, c, k)
 
113
 
 
114
/** @ingroup AESNI */
 
115
typedef struct r123array4x32 ars4x32_ctr_t;
 
116
/** @ingroup AESNI */
 
117
typedef struct r123array4x32 ars4x32_key_t;
 
118
/** @ingroup AESNI */
 
119
typedef struct r123array4x32 ars4x32_ukey_t;
 
120
/** @ingroup AESNI */
 
121
enum r123_enum_ars4x32 {ars4x32_rounds = ARS1xm128i_DEFAULT_ROUNDS};
 
122
/** @ingroup AESNI */
 
123
R123_STATIC_INLINE ars4x32_key_t ars4x32keyinit(ars4x32_ukey_t uk) { return uk; }
 
124
/** @ingroup AESNI */
 
125
R123_STATIC_INLINE ars4x32_ctr_t ars4x32_R(unsigned int Nrounds, ars4x32_ctr_t c, ars4x32_key_t k){
 
126
    ars1xm128i_ctr_t c128;
 
127
    ars1xm128i_key_t k128;
 
128
    c128.v[0].m = _mm_set_epi32(c.v[3], c.v[2], c.v[1], c.v[0]);
 
129
    k128.v[0].m = _mm_set_epi32(k.v[3], k.v[2], k.v[1], k.v[0]);
 
130
    c128 = ars1xm128i_R(Nrounds, c128, k128);
 
131
    _mm_storeu_si128((__m128i*)&c.v[0], c128.v[0].m);
 
132
    return c;
 
133
}
 
134
 
 
135
/** @def ars4x32
 
136
@ingroup AESNI
 
137
The ars4x32 macro provides a C API interface to the @ref AESNI "ARS" CBRNG with the default number of rounds i.e. \c ars4x32_rounds **/
 
138
#define ars4x32(c,k) ars4x32_R(ars4x32_rounds, c, k)
 
139
 
 
140
#ifdef __cplusplus
 
141
namespace r123{
 
142
/** 
 
143
@ingroup AESNI
 
144
 
 
145
ARS1xm128i_R exports the member functions, typedefs and operator overloads required by a @ref CBRNG class.
 
146
 
 
147
ARS1xm128i uses the crypotgraphic AES round function, but a @b non-cryptographc key schedule
 
148
to save time and space.
 
149
 
 
150
ARS1xm128i is only available when the feature-test macro R123_USE_AES_NI is true, which
 
151
should occur only when the compiler is configured to generate AES-NI instructions (or
 
152
when defaults are overridden by compile-time, compiler-command-line options).
 
153
 
 
154
The template argument, ROUNDS, is the number of times the ARS round
 
155
functions will be applied.
 
156
 
 
157
As of September 2011, the authors know of no statistical flaws with
 
158
ROUNDS=5 or more.
 
159
 
 
160
@class ARS1xm128i_R
 
161
 
 
162
*/
 
163
template<unsigned int ROUNDS>
 
164
struct ARS1xm128i_R{
 
165
    typedef ars1xm128i_ctr_t ctr_type;
 
166
    typedef ars1xm128i_key_t key_type;
 
167
    typedef ars1xm128i_key_t ukey_type;
 
168
    static const unsigned int rounds=ROUNDS;
 
169
    R123_FORCE_INLINE(ctr_type operator()(ctr_type ctr, key_type key) const){
 
170
        return ars1xm128i_R(ROUNDS, ctr, key);
 
171
    }
 
172
};
 
173
 
 
174
/** @class ARS4x32_R
 
175
    @ingroup AESNI
 
176
*/
 
177
 
 
178
template<unsigned int ROUNDS>
 
179
struct ARS4x32_R{
 
180
    typedef ars4x32_ctr_t ctr_type;
 
181
    typedef ars4x32_key_t key_type;
 
182
    typedef ars4x32_key_t ukey_type;
 
183
    static const unsigned int rounds=ROUNDS;
 
184
    R123_FORCE_INLINE(ctr_type operator()(ctr_type ctr, key_type key) const){
 
185
        return ars4x32_R(ROUNDS, ctr, key);
 
186
    }
 
187
};
 
188
/**
 
189
@ingroup AESNI
 
190
 
 
191
@class ARS1xm128i_R
 
192
  ARS1xm128i is equivalent to ARS1xm128i_R<7>.    With 7 rounds,
 
193
  the ARS1xm128i CBRNG  has a considerable safety margin over the minimum number
 
194
  of rounds with no known statistical flaws, but still has excellent
 
195
  performance. */
 
196
typedef ARS1xm128i_R<ars1xm128i_rounds> ARS1xm128i;
 
197
typedef ARS4x32_R<ars4x32_rounds> ARS4x32;
 
198
} // namespace r123
 
199
 
 
200
#endif /* __cplusplus */
 
201
 
 
202
#endif /* R123_USE_AES_NI */
 
203
 
 
204
#endif