v3.7.3

algo/skein/skein-4way.c

@@ -0,0 +1,122 @@
+#include "algo-gate-api.h"
+#include "skein-gate.h"
+#include <string.h>
+#include <stdint.h>
+#include <openssl/sha.h>
+#include "skein-hash-4way.h"
+
+#if defined (__AVX2__)
+
+void skeinhash_4way( void *state, const void *input )
+{
+     uint64_t hash0[8] __attribute__ ((aligned (64)));
+     uint64_t hash1[8] __attribute__ ((aligned (64)));
+     uint64_t hash2[8] __attribute__ ((aligned (64)));
+     uint64_t hash3[8] __attribute__ ((aligned (64)));
+     uint64_t vhash[8*4] __attribute__ ((aligned (64)));
+     skein512_4way_context ctx_skein;
+     SHA256_CTX            ctx_sha256;
+
+     skein512_4way_init( &ctx_skein );
+     skein512_4way( &ctx_skein, input, 80 );
+     skein512_4way_close( &ctx_skein, vhash );
+
+     m256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+
+     SHA256_Init( &ctx_sha256 );
+     SHA256_Update( &ctx_sha256, (unsigned char*)hash0, 64 );
+     SHA256_Final( (unsigned char*)hash0, &ctx_sha256 );
+
+     SHA256_Init( &ctx_sha256 );
+     SHA256_Update( &ctx_sha256, (unsigned char*)hash1, 64 );
+     SHA256_Final( (unsigned char*)hash1, &ctx_sha256 );
+
+     SHA256_Init( &ctx_sha256 );
+     SHA256_Update( &ctx_sha256, (unsigned char*)hash2, 64 );
+     SHA256_Final( (unsigned char*)hash2, &ctx_sha256 );
+
+     SHA256_Init( &ctx_sha256 );
+     SHA256_Update( &ctx_sha256, (unsigned char*)hash3, 64 );
+     SHA256_Final( (unsigned char*)hash3, &ctx_sha256 );
+
+     memcpy(  (char*)state,       (char*)hash0, 32 );
+     memcpy( ((char*)state) + 32, (char*)hash1, 32 );
+     memcpy( ((char*)state) + 64, (char*)hash2, 32 );
+     memcpy( ((char*)state) + 96, (char*)hash3, 32 );
+}
+
+int scanhash_skein_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                    uint64_t *hashes_done )
+{
+    uint32_t hash[4*8] __attribute__ ((aligned (64)));
+    uint32_t vdata[20*4] __attribute__ ((aligned (64)));
+    uint32_t endiandata[20] __attribute__ ((aligned (64)));
+    uint32_t *pdata = work->data;
+    uint32_t *ptarget = work->target;
+    uint64_t *edata = (uint64_t*)endiandata;
+    const uint32_t Htarg = ptarget[7];
+    const uint32_t first_nonce = pdata[19];
+    uint32_t n = first_nonce;
+    // hash is returned deinterleaved
+    uint32_t *nonces = work->nonces;
+    bool *found = work->nfound;
+    int num_found;
+
+// data is 80 bytes, 20 u32 or 4 u64.
+	
+    swab32_array( endiandata, pdata, 20 );
+ 
+    m256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+
+    uint32_t *noncep0 = vdata + 73;   // 9*8 + 1
+    uint32_t *noncep1 = vdata + 75;
+    uint32_t *noncep2 = vdata + 77;
+    uint32_t *noncep3 = vdata + 79;
+
+   do
+   {
+       found[0] = found[1] = found[2] = found[3] = false;
+       num_found = 0;      
+       be32enc( noncep0, n   );
+       be32enc( noncep1, n+1 );
+       be32enc( noncep2, n+2 );
+       be32enc( noncep3, n+3 );
+
+       skeinhash_4way( hash, vdata );
+
+       if ( hash[7] < Htarg && fulltest( hash, ptarget ) )
+       {
+           found[0] = true;
+           num_found++;
+           nonces[0] = n;
+           // always put nonce0 in work data for compartibility with 
+           // non vectored algos.
+           pdata[19] = n;
+       }
+       if ( (hash+8)[7] < Htarg && fulltest( hash+8, ptarget ) )
+       {
+           found[1] = true;
+           num_found++;
+           nonces[1] = n+1;           
+       }
+       if ( (hash+16)[7] < Htarg && fulltest( hash+16, ptarget ) )
+       {
+           found[2] = true;
+           num_found++;
+           nonces[2] = n+2;           
+       }
+       if ( (hash+24)[7] < Htarg && fulltest( hash+24, ptarget ) )
+       {
+           found[3] = true;
+           num_found++;
+           nonces[3] = n+3;           
+       }
+       n += 4;
+    } while ( (num_found == 0) && (n < max_nonce)
+               && !work_restart[thr_id].restart );
+
+    *hashes_done = n - first_nonce + 1;
+    return num_found;
+}
+
+#endif

algo/skein/skein-gate.c

@@ -0,0 +1,24 @@
+#include "skein-gate.h"
+#include "algo-gate-api.h"
+//#include <string.h>
+//#include <stdint.h>
+#include "sph_skein.h"
+#include "skein-hash-4way.h"
+
+int64_t skein_get_max64() { return 0x7ffffLL; }
+
+bool register_skein_algo( algo_gate_t* gate )
+{
+#if defined (FOUR_WAY) &&  defined (__AVX2__)
+    gate->optimizations = SSE2_OPT | AVX2_OPT | SHA_OPT;
+    gate->scanhash  = (void*)&scanhash_skein_4way;
+    gate->hash      = (void*)&skeinhash_4way;
+#else
+    gate->optimizations = SSE2_OPT | SHA_OPT;
+    gate->scanhash  = (void*)&scanhash_skein;
+    gate->hash      = (void*)&skeinhash;
+#endif
+    gate->get_max64 = (void*)&skein_get_max64;
+    return true;
+};
+

algo/skein/skein-gate.h

@@ -0,0 +1,16 @@
+#ifndef __SKEIN_GATE_H__
+#define __SKEIN_GATE_H__
+#include <stdint.h>
+
+#if defined(__AVX2__)
+
+void skeinhash_4way( void *output, const void *input );
+int scanhash_skein_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                         uint64_t *hashes_done );
+#endif
+
+void skeinhash( void *output, const void *input );
+int scanhash_skein( int thr_id, struct work *work, uint32_t max_nonce,
+                    uint64_t *hashes_done );
+
+#endif

algo/skein/skein-hash-4way.c

@@ -0,0 +1,648 @@
+/* $Id: skein.c 254 2011-06-07 19:38:58Z tp $ */
+/*
+ * Skein implementation.
+ *
+ * ==========================(LICENSE BEGIN)============================
+ *
+ * Copyright (c) 2007-2010  Projet RNRT SAPHIR
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * ===========================(LICENSE END)=============================
+ *
+ * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
+ */
+
+#if defined (__AVX2__)
+
+#include <stddef.h>
+#include <string.h>
+#include "skein-hash-4way.h"
+
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (disable: 4146)
+#endif
+
+/*
+ * M9_ ## s ## _ ## i  evaluates to s+i mod 9 (0 <= s <= 18, 0 <= i <= 7).
+ */
+
+#define M9_0_0    0
+#define M9_0_1    1
+#define M9_0_2    2
+#define M9_0_3    3
+#define M9_0_4    4
+#define M9_0_5    5
+#define M9_0_6    6
+#define M9_0_7    7
+
+#define M9_1_0    1
+#define M9_1_1    2
+#define M9_1_2    3
+#define M9_1_3    4
+#define M9_1_4    5
+#define M9_1_5    6
+#define M9_1_6    7
+#define M9_1_7    8
+
+#define M9_2_0    2
+#define M9_2_1    3
+#define M9_2_2    4
+#define M9_2_3    5
+#define M9_2_4    6
+#define M9_2_5    7
+#define M9_2_6    8
+#define M9_2_7    0
+
+#define M9_3_0    3
+#define M9_3_1    4
+#define M9_3_2    5
+#define M9_3_3    6
+#define M9_3_4    7
+#define M9_3_5    8
+#define M9_3_6    0
+#define M9_3_7    1
+
+#define M9_4_0    4
+#define M9_4_1    5
+#define M9_4_2    6
+#define M9_4_3    7
+#define M9_4_4    8
+#define M9_4_5    0
+#define M9_4_6    1
+#define M9_4_7    2
+
+#define M9_5_0    5
+#define M9_5_1    6
+#define M9_5_2    7
+#define M9_5_3    8
+#define M9_5_4    0
+#define M9_5_5    1
+#define M9_5_6    2
+#define M9_5_7    3
+
+#define M9_6_0    6
+#define M9_6_1    7
+#define M9_6_2    8
+#define M9_6_3    0
+#define M9_6_4    1
+#define M9_6_5    2
+#define M9_6_6    3
+#define M9_6_7    4
+
+#define M9_7_0    7
+#define M9_7_1    8
+#define M9_7_2    0
+#define M9_7_3    1
+#define M9_7_4    2
+#define M9_7_5    3
+#define M9_7_6    4
+#define M9_7_7    5
+
+#define M9_8_0    8
+#define M9_8_1    0
+#define M9_8_2    1
+#define M9_8_3    2
+#define M9_8_4    3
+#define M9_8_5    4
+#define M9_8_6    5
+#define M9_8_7    6
+
+#define M9_9_0    0
+#define M9_9_1    1
+#define M9_9_2    2
+#define M9_9_3    3
+#define M9_9_4    4
+#define M9_9_5    5
+#define M9_9_6    6
+#define M9_9_7    7
+
+#define M9_10_0   1
+#define M9_10_1   2
+#define M9_10_2   3
+#define M9_10_3   4
+#define M9_10_4   5
+#define M9_10_5   6
+#define M9_10_6   7
+#define M9_10_7   8
+
+#define M9_11_0   2
+#define M9_11_1   3
+#define M9_11_2   4
+#define M9_11_3   5
+#define M9_11_4   6
+#define M9_11_5   7
+#define M9_11_6   8
+#define M9_11_7   0
+
+#define M9_12_0   3
+#define M9_12_1   4
+#define M9_12_2   5
+#define M9_12_3   6
+#define M9_12_4   7
+#define M9_12_5   8
+#define M9_12_6   0
+#define M9_12_7   1
+
+#define M9_13_0   4
+#define M9_13_1   5
+#define M9_13_2   6
+#define M9_13_3   7
+#define M9_13_4   8
+#define M9_13_5   0
+#define M9_13_6   1
+#define M9_13_7   2
+
+#define M9_14_0   5
+#define M9_14_1   6
+#define M9_14_2   7
+#define M9_14_3   8
+#define M9_14_4   0
+#define M9_14_5   1
+#define M9_14_6   2
+#define M9_14_7   3
+
+#define M9_15_0   6
+#define M9_15_1   7
+#define M9_15_2   8
+#define M9_15_3   0
+#define M9_15_4   1
+#define M9_15_5   2
+#define M9_15_6   3
+#define M9_15_7   4
+
+#define M9_16_0   7
+#define M9_16_1   8
+#define M9_16_2   0
+#define M9_16_3   1
+#define M9_16_4   2
+#define M9_16_5   3
+#define M9_16_6   4
+#define M9_16_7   5
+
+#define M9_17_0   8
+#define M9_17_1   0
+#define M9_17_2   1
+#define M9_17_3   2
+#define M9_17_4   3
+#define M9_17_5   4
+#define M9_17_6   5
+#define M9_17_7   6
+
+#define M9_18_0   0
+#define M9_18_1   1
+#define M9_18_2   2
+#define M9_18_3   3
+#define M9_18_4   4
+#define M9_18_5   5
+#define M9_18_6   6
+#define M9_18_7   7
+
+/*
+ * M3_ ## s ## _ ## i  evaluates to s+i mod 3 (0 <= s <= 18, 0 <= i <= 1).
+ */
+
+#define M3_0_0    0
+#define M3_0_1    1
+#define M3_1_0    1
+#define M3_1_1    2
+#define M3_2_0    2
+#define M3_2_1    0
+#define M3_3_0    0
+#define M3_3_1    1
+#define M3_4_0    1
+#define M3_4_1    2
+#define M3_5_0    2
+#define M3_5_1    0
+#define M3_6_0    0
+#define M3_6_1    1
+#define M3_7_0    1
+#define M3_7_1    2
+#define M3_8_0    2
+#define M3_8_1    0
+#define M3_9_0    0
+#define M3_9_1    1
+#define M3_10_0   1
+#define M3_10_1   2
+#define M3_11_0   2
+#define M3_11_1   0
+#define M3_12_0   0
+#define M3_12_1   1
+#define M3_13_0   1
+#define M3_13_1   2
+#define M3_14_0   2
+#define M3_14_1   0
+#define M3_15_0   0
+#define M3_15_1   1
+#define M3_16_0   1
+#define M3_16_1   2
+#define M3_17_0   2
+#define M3_17_1   0
+#define M3_18_0   0
+#define M3_18_1   1
+
+#define XCAT(x, y)     XCAT_(x, y)
+#define XCAT_(x, y)    x ## y
+
+
+#define SKBI(k, s, i)   XCAT(k, XCAT(XCAT(XCAT(M9_, s), _), i))
+#define SKBT(t, s, v)   XCAT(t, XCAT(XCAT(XCAT(M3_, s), _), v))
+
+// AVX2 all scalar vars are now vectors representing 4 nonces in parallel
+
+#define TFBIG_KINIT_4WAY( k0, k1, k2, k3, k4, k5, k6, k7, k8, t0, t1, t2 ) \
+do { \
+  k8 = _mm256_xor_si256( _mm256_xor_si256( \
+                            _mm256_xor_si256( _mm256_xor_si256( k0, k1 ), \
+                                              _mm256_xor_si256( k2, k3 ) ), \
+                            _mm256_xor_si256( _mm256_xor_si256( k4, k5 ), \
+                                              _mm256_xor_si256( k6, k7 ) ) ), \
+                         _mm256_set_epi64x( SPH_C64(0x1BD11BDAA9FC1A22), \
+                                            SPH_C64(0x1BD11BDAA9FC1A22), \
+                                            SPH_C64(0x1BD11BDAA9FC1A22), \
+                                            SPH_C64(0x1BD11BDAA9FC1A22) ) ); \
+  t2 = t0 ^ t1; \
+} while (0)
+
+#define TFBIG_ADDKEY_4WAY(w0, w1, w2, w3, w4, w5, w6, w7, k, t, s) \
+do { \
+  w0 = _mm256_add_epi64( w0, SKBI(k,s,0) ); \
+  w1 = _mm256_add_epi64( w1, SKBI(k,s,1) ); \
+  w2 = _mm256_add_epi64( w2, SKBI(k,s,2) ); \
+  w3 = _mm256_add_epi64( w3, SKBI(k,s,3) ); \
+  w4 = _mm256_add_epi64( w4, SKBI(k,s,4) ); \
+  w5 = _mm256_add_epi64( w5, _mm256_add_epi64( SKBI(k,s,5), \
+                           _mm256_set_epi64x( SKBT(t,s,0), SKBT(t,s,0), \
+                                              SKBT(t,s,0), SKBT(t,s,0) ) ) ); \
+__m256i skbi6 = SKBI(k,s,6); \
+  w6 = _mm256_add_epi64( w6, _mm256_add_epi64( SKBI(k,s,6), \
+                           _mm256_set_epi64x( SKBT(t,s,1), SKBT(t,s,1), \
+                                              SKBT(t,s,1), SKBT(t,s,1) ) ) ); \
+  w7 = _mm256_add_epi64( w7, _mm256_add_epi64( SKBI(k,s,7), \
+                                      _mm256_set_epi64x( s, s, s, s ) ) ); \
+} while (0)
+
+
+#define TFBIG_MIX_4WAY(x0, x1, rc) \
+do { \
+     x0 = _mm256_add_epi64( x0, x1 ); \
+     x1 = _mm256_xor_si256( mm256_rotl_64( x1, rc ), x0 ); \
+} while (0)
+ 
+
+// typeless
+#define TFBIG_MIX8(w0, w1, w2, w3, w4, w5, w6, w7, rc0, rc1, rc2, rc3)  do { \
+		TFBIG_MIX_4WAY(w0, w1, rc0); \
+		TFBIG_MIX_4WAY(w2, w3, rc1); \
+		TFBIG_MIX_4WAY(w4, w5, rc2); \
+		TFBIG_MIX_4WAY(w6, w7, rc3); \
+	} while (0)
+
+
+#define TFBIG_4e(s)   do { \
+		TFBIG_ADDKEY_4WAY(p0, p1, p2, p3, p4, p5, p6, p7, h, t, s); \
+		TFBIG_MIX8(p0, p1, p2, p3, p4, p5, p6, p7, 46, 36, 19, 37); \
+		TFBIG_MIX8(p2, p1, p4, p7, p6, p5, p0, p3, 33, 27, 14, 42); \
+		TFBIG_MIX8(p4, p1, p6, p3, p0, p5, p2, p7, 17, 49, 36, 39); \
+		TFBIG_MIX8(p6, p1, p0, p7, p2, p5, p4, p3, 44,  9, 54, 56); \
+	} while (0)
+
+#define TFBIG_4o(s)   do { \
+		TFBIG_ADDKEY_4WAY(p0, p1, p2, p3, p4, p5, p6, p7, h, t, s); \
+		TFBIG_MIX8(p0, p1, p2, p3, p4, p5, p6, p7, 39, 30, 34, 24); \
+		TFBIG_MIX8(p2, p1, p4, p7, p6, p5, p0, p3, 13, 50, 10, 17); \
+		TFBIG_MIX8(p4, p1, p6, p3, p0, p5, p2, p7, 25, 29, 39, 43); \
+		TFBIG_MIX8(p6, p1, p0, p7, p2, p5, p4, p3,  8, 35, 56, 22); \
+	} while (0)
+
+
+// scale buf offset by 4
+#define UBI_BIG_4WAY(etype, extra) \
+do { \
+  sph_u64 t0, t1, t2; \
+  __m256i h8; \
+/* can LE be assumed? \
+   dec64le does nothing when SPH_LITTLE endian is set, as it is. \
+  __m256i m0 = _mm256_dec64le( buf ); \
+  __m256i m1 = _mm256_dec64le( buf +  8*4 ); \
+  __m256i m2 = _mm256_dec64le( buf + 16*4 ); \
+  __m256i m3 = _mm256_dec64le( buf + 24*4 ); \
+  __m256i m4 = _mm256_dec64le( buf + 32*4 ); \
+  __m256i m5 = _mm256_dec64le( buf + 40*4 ); \
+  __m256i m6 = _mm256_dec64le( buf + 48*4 ); \
+  __m256i m7 = _mm256_dec64le( buf + 56*4 ); \
+*/ \
+  __m256i m0 =  buf[0]; \
+  __m256i m1 =  buf[1]; \
+  __m256i m2 =  buf[2]; \
+  __m256i m3 =  buf[3]; \
+  __m256i m4 =  buf[4]; \
+  __m256i m5 =  buf[5]; \
+  __m256i m6 =  buf[6]; \
+  __m256i m7 =  buf[7]; \
+\
+  __m256i p0 = m0; \
+  __m256i p1 = m1; \
+  __m256i p2 = m2; \
+  __m256i p3 = m3; \
+  __m256i p4 = m4; \
+  __m256i p5 = m5; \
+  __m256i p6 = m6; \
+  __m256i p7 = m7; \
+  t0 = SPH_T64(bcount << 6) + (sph_u64)(extra); \
+  t1 = (bcount >> 58) + ((sph_u64)(etype) << 55); \
+  TFBIG_KINIT_4WAY(h0, h1, h2, h3, h4, h5, h6, h7, h8, t0, t1, t2); \
+  TFBIG_4e(0); \
+  TFBIG_4o(1); \
+  TFBIG_4e(2); \
+  TFBIG_4o(3); \
+  TFBIG_4e(4); \
+  TFBIG_4o(5); \
+  TFBIG_4e(6); \
+  TFBIG_4o(7); \
+  TFBIG_4e(8); \
+  TFBIG_4o(9); \
+  TFBIG_4e(10); \
+  TFBIG_4o(11); \
+  TFBIG_4e(12); \
+  TFBIG_4o(13); \
+  TFBIG_4e(14); \
+  TFBIG_4o(15); \
+  TFBIG_4e(16); \
+  TFBIG_4o(17); \
+  TFBIG_ADDKEY_4WAY(p0, p1, p2, p3, p4, p5, p6, p7, h, t, 18); \
+  h0 = _mm256_xor_si256( m0, p0 );\
+  h1 = _mm256_xor_si256( m1, p1 );\
+  h2 = _mm256_xor_si256( m2, p2 );\
+  h3 = _mm256_xor_si256( m3, p3 );\
+  h4 = _mm256_xor_si256( m4, p4 );\
+  h5 = _mm256_xor_si256( m5, p5 );\
+  h6 = _mm256_xor_si256( m6, p6 );\
+  h7 = _mm256_xor_si256( m7, p7 );\
+} while (0)
+
+
+#define DECL_STATE_BIG_4WAY \
+  __m256i h0, h1, h2, h3, h4, h5, h6, h7; \
+  sph_u64 bcount;
+
+#define READ_STATE_BIG(sc)   do { \
+		h0 = (sc)->h0; \
+		h1 = (sc)->h1; \
+		h2 = (sc)->h2; \
+		h3 = (sc)->h3; \
+		h4 = (sc)->h4; \
+		h5 = (sc)->h5; \
+		h6 = (sc)->h6; \
+		h7 = (sc)->h7; \
+		bcount = sc->bcount; \
+	} while (0)
+
+#define WRITE_STATE_BIG(sc)   do { \
+		(sc)->h0 = h0; \
+		(sc)->h1 = h1; \
+		(sc)->h2 = h2; \
+		(sc)->h3 = h3; \
+		(sc)->h4 = h4; \
+		(sc)->h5 = h5; \
+		(sc)->h6 = h6; \
+		(sc)->h7 = h7; \
+		sc->bcount = bcount; \
+	} while (0)
+
+
+static void
+skein_big_init_4way( skein512_4way_context *sc, const sph_u64 *iv )
+{
+        sc->h0 = _mm256_set_epi64x( iv[0], iv[0],iv[0],iv[0] );
+        sc->h1 = _mm256_set_epi64x( iv[1], iv[1],iv[1],iv[1] );
+        sc->h2 = _mm256_set_epi64x( iv[2], iv[2],iv[2],iv[2] );
+        sc->h3 = _mm256_set_epi64x( iv[3], iv[3],iv[3],iv[3] );
+        sc->h4 = _mm256_set_epi64x( iv[4], iv[4],iv[4],iv[4] );
+        sc->h5 = _mm256_set_epi64x( iv[5], iv[5],iv[5],iv[5] );
+        sc->h6 = _mm256_set_epi64x( iv[6], iv[6],iv[6],iv[6] );
+        sc->h7 = _mm256_set_epi64x( iv[7], iv[7],iv[7],iv[7] );
+        sc->bcount = 0;
+        sc->ptr = 0;
+}
+
+static void
+skein_big_core_4way( skein512_4way_context *sc, const void *data,
+                     size_t len )
+{
+   __m256i *vdata = (__m256i*)data;
+   __m256i *buf;
+   size_t ptr;
+   unsigned first;
+   DECL_STATE_BIG_4WAY
+
+// len is the array size, of data, ie 64 bytes
+// data points to start of 4 element buf
+// ptr is a len offset in bytes
+// buff is an array of 4 elements
+// buff_size is size of one array element
+// One element is 8 bytes (64 bits) scalar but 32 bytes (256 bits) 4way
+// To index buf using ptr it has to be scaled 8 to 1. the amounrt of
+// data to copy is 32 bytes per element instead of 8, or one m256
+
+   buf = sc->buf;
+   ptr = sc->ptr;
+   const int buf_size = 64;   // 64 * _m256i
+
+// 64 byte len, no part block
+   if ( len <= buf_size - ptr )
+   {
+       memcpy_m256i( buf + (ptr>>3), vdata, len>>3 );
+       sc->ptr = ptr + len;
+       return;
+   }
+
+   READ_STATE_BIG( sc );
+   first = ( bcount == 0 ) << 7;
+// 64 byte len, only one block, no transform here.
+// 80 byte len, transform first 64 bytes.
+   do {
+       size_t clen;
+
+       if ( ptr == buf_size )
+       {
+            bcount ++;
+            UBI_BIG_4WAY( 96 + first, 0 );
+            first = 0;
+            ptr = 0;
+       }
+       clen = buf_size - ptr;
+       if ( clen > len )
+            clen = len;
+       memcpy_m256i( buf + (ptr>>3), vdata, clen>>3 );
+       ptr += clen;
+       vdata += (clen>>3);
+       len -= clen;
+   } while ( len > 0 );
+   WRITE_STATE_BIG( sc );
+   sc->ptr = ptr;
+}
+
+static void
+skein_big_close_4way( skein512_4way_context *sc, unsigned ub, unsigned n,
+                      void *dst, size_t out_len )
+{
+	__m256i *buf;
+	size_t ptr;
+	unsigned et;
+	int i;
+	DECL_STATE_BIG_4WAY
+	/*
+	 * Add bit padding if necessary.
+	 */
+//	if (n != 0) {
+//		unsigned z;
+//		unsigned char x;
+//
+//		z = 0x80 >> n;
+//		x = ((ub & -z) | z) & 0xFF;
+//		skein_big_core(sc, &x, 1);
+//	}
+
+	buf = sc->buf;
+	ptr = sc->ptr;
+        const int buf_size = 64;
+
+	/*
+	 * At that point, if ptr == 0, then the message was empty;
+	 * otherwise, there is between 1 and 64 bytes (inclusive) which
+	 * are yet to be processed. Either way, we complete the buffer
+	 * to a full block with zeros (the Skein specification mandates
+	 * that an empty message is padded so that there is at least
+	 * one block to process).
+	 *
+	 * Once this block has been processed, we do it again, with
+	 * a block full of zeros, for the output (that block contains
+	 * the encoding of "0", over 8 bytes, then padded with zeros).
+	 */
+
+// 64 byte len, process only block
+// 80 byte len, process last part block (16 bytes) padded.
+	READ_STATE_BIG(sc);
+
+        memset_zero_m256i( buf + (ptr>>3), (buf_size - ptr) >> 3 );
+	et = 352 + ((bcount == 0) << 7);
+        UBI_BIG_4WAY( et, ptr );
+
+        memset_zero_m256i( buf, buf_size >> 3 );
+        bcount = 0;
+        UBI_BIG_4WAY( 510, 8 );
+
+//	for ( i = 0; i < 2; i ++ )
+//        {
+//		UBI_BIG_AVX2( et, ptr );
+//		if (i == 0)
+//                {
+//                        memset_zero_m256i( buf, buf_size >> 3 );
+//			bcount = 0;
+//			et = 510;
+//			ptr = 8;
+//		}
+//	}
+
+// Can LE be assumed? Should be ok SPH_LITTLE_ENDIAN is defined
+/*        _mm256_enc64le( buf, h0 );
+        _mm256_enc64le( buf + 32, h1 );
+        _mm256_enc64le( buf + 64, h2 );
+        _mm256_enc64le( buf + 96, h3 );
+        _mm256_enc64le( buf + 128, h4 );
+        _mm256_enc64le( buf + 160, h5 );
+        _mm256_enc64le( buf + 192, h6 );
+        _mm256_enc64le( buf + 224, h7 );
+*/
+        buf[0] = h0;
+        buf[1] = h1;
+        buf[2] = h2;
+        buf[3] = h3;
+        buf[4] = h4;
+        buf[5] = h5;
+        buf[6] = h6;
+        buf[7] = h7;
+
+        memcpy_m256i( dst, buf, out_len >> 3 );
+//	memcpy( dst, buf, out_len * 4 );
+}
+
+static const sph_u64 IV256[] = {
+	SPH_C64(0xCCD044A12FDB3E13), SPH_C64(0xE83590301A79A9EB),
+	SPH_C64(0x55AEA0614F816E6F), SPH_C64(0x2A2767A4AE9B94DB),
+	SPH_C64(0xEC06025E74DD7683), SPH_C64(0xE7A436CDC4746251),
+	SPH_C64(0xC36FBAF9393AD185), SPH_C64(0x3EEDBA1833EDFC13)
+};
+
+static const sph_u64 IV512[] = {
+	SPH_C64(0x4903ADFF749C51CE), SPH_C64(0x0D95DE399746DF03),
+	SPH_C64(0x8FD1934127C79BCE), SPH_C64(0x9A255629FF352CB1),
+	SPH_C64(0x5DB62599DF6CA7B0), SPH_C64(0xEABE394CA9D5C3F4),
+	SPH_C64(0x991112C71A75B523), SPH_C64(0xAE18A40B660FCC33)
+};
+
+
+void
+skein256_4way_init(void *cc)
+{
+	skein_big_init_4way(cc, IV256);
+}
+
+void
+skein256_4way(void *cc, const void *data, size_t len)
+{
+	skein_big_core_4way(cc, data, len);
+}
+
+void
+skein256_4way_close(void *cc, void *dst)
+{
+        skein_big_close_4way(cc, 0, 0, dst, 32);
+}
+
+void
+skein512_4way_init(void *cc)
+{
+	skein_big_init_4way(cc, IV512);
+}
+
+void
+skein512_4way(void *cc, const void *data, size_t len)
+{
+	skein_big_core_4way(cc, data, len);
+}
+
+void
+skein512_4way_close(void *cc, void *dst)
+{
+        skein_big_close_4way(cc, 0, 0, dst, 64);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

algo/skein/skein-hash-4way.h

@@ -0,0 +1,93 @@
+/* $Id: sph_skein.h 253 2011-06-07 18:33:10Z tp $ */
+/**
+ * Skein interface. The Skein specification defines three main
+ * functions, called Skein-256, Skein-512 and Skein-1024, which can be
+ * further parameterized with an output length. For the SHA-3
+ * competition, Skein-512 is used for output sizes of 224, 256, 384 and
+ * 512 bits; this is what this code implements. Thus, we hereafter call
+ * Skein-224, Skein-256, Skein-384 and Skein-512 what the Skein
+ * specification defines as Skein-512-224, Skein-512-256, Skein-512-384
+ * and Skein-512-512, respectively.
+ *
+ * ==========================(LICENSE BEGIN)============================
+ *
+ * Copyright (c) 2007-2010  Projet RNRT SAPHIR
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * "Software"), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * ===========================(LICENSE END)=============================
+ *
+ * @file     sph_skein.h
+ * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
+ */
+
+#ifndef __SKEIN_HASH_4WAY_H__
+#define __SKEIN_HASH_4WAY_H__
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+#include <stddef.h>
+#include "algo/sha/sph_types.h"
+#include "avxdefs.h"
+
+// Output size in bits
+#define SPH_SIZE_skein256   256
+#define SPH_SIZE_skein512   512
+
+#ifdef __AVX2__
+
+typedef struct {
+        __m256i buf[8] __attribute__ ((aligned (32)));
+        __m256i h0, h1, h2, h3, h4, h5, h6, h7;
+        size_t ptr;
+	sph_u64 bcount;
+} skein512_4way_context;
+
+void skein512_4way_init(void *cc);
+void skein512_4way(void *cc, const void *data, size_t len);
+void skein512_4way_close(void *cc, void *dst);
+//void sph_skein512_addbits_and_close(
+//        void *cc, unsigned ub, unsigned n, void *dst);
+
+#endif
+
+#ifdef __AVX__
+
+typedef struct {
+        __m128i buf[8] __attribute__ ((aligned (32)));
+        __m128i h0, h1, h2, h3, h4, h5, h6, h7;
+        size_t ptr;
+        sph_u64 bcount;
+} skein256_4way_context;
+
+void skein256_4way_init(void *cc);
+void skein256_4way(void *cc, const void *data, size_t len);
+void skein256_4way_close(void *cc, void *dst);
+//void sph_skein256_addbits_and_close(
+//	void *cc, unsigned ub, unsigned n, void *dst);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+#endif

algo/skein/skein.c

@@ -5,42 +5,28 @@
 #include <openssl/sha.h>
 #include "algo/sha/sph_sha2.h"
 
-typedef struct {
-   sph_skein512_context skein;
-#ifndef USE_SPH_SHA
-   SHA256_CTX         sha256;
-#else
-   sph_sha256_context sha256;
-#endif
-} skein_ctx_holder;
-
-skein_ctx_holder skein_ctx;
-
-void init_skein_ctx()
-{
-   sph_skein512_init( &skein_ctx.skein );
-#ifndef USE_SPH_SHA
-   SHA256_Init( &skein_ctx.sha256 );
-#else
-   sph_sha256_init( &skein_ctx.sha256 );
-#endif
-}
-
 void skeinhash(void *state, const void *input)
 {
-     skein_ctx_holder ctx __attribute__ ((aligned (64)));
-     memcpy( &ctx, &skein_ctx, sizeof(skein_ctx) );
      uint32_t hash[16] __attribute__ ((aligned (64)));
-	
-     sph_skein512( &ctx.skein, input, 80 );
-     sph_skein512_close( &ctx.skein, hash );
+     sph_skein512_context ctx_skein;
+#ifndef USE_SPH_SHA
+     SHA256_CTX           ctx_sha256;
+#else
+     sph_sha256_context   ctx_sha256;
+#endif
+
+     sph_skein512_init( &ctx_skein );
+     sph_skein512( &ctx_skein, input, 80 );
+     sph_skein512_close( &ctx_skein, hash );
 
 #ifndef USE_SPH_SHA
-     SHA256_Update( &ctx.sha256, hash, 64 );
-     SHA256_Final( (unsigned char*) hash, &ctx.sha256 );
+     SHA256_Init( &ctx_sha256 );
+     SHA256_Update( &ctx_sha256, (unsigned char*)hash, 64 );
+     SHA256_Final( (unsigned char*) hash, &ctx_sha256 );
 #else
-     sph_sha256( &ctx.sha256, hash, 64 );
-     sph_sha256_close( &ctx.sha256, hash );
+     sph_sha256_init( &ctx_sha256 );
+     sph_sha256( &ctx_sha256, hash, 64 );
+     sph_sha256_close( &ctx_sha256, hash );
 #endif
 
      memcpy(state, hash, 32);
@@ -77,15 +63,3 @@ int scanhash_skein(int thr_id, struct work *work,
 	return 0;
 }
 
-int64_t skein_get_max64() { return 0x7ffffLL; }
-
-bool register_skein_algo( algo_gate_t* gate )
-{
-    init_skein_ctx();
-    gate->optimizations = SSE2_OPT | SHA_OPT;
-    gate->scanhash  = (void*)&scanhash_skein;
-    gate->hash      = (void*)&skeinhash;
-    gate->get_max64 = (void*)&skein_get_max64;
-    return true;
-};
-

algo/skein/skein2-4way.c

@@ -0,0 +1,95 @@
+#include "skein-gate.h"
+#include "algo-gate-api.h"
+#include <string.h>
+#include <stdint.h>
+#include "skein-hash-4way.h"
+
+#if defined(__AVX2__)
+
+void skein2hash_4way( void *output, const void *input )
+{
+   skein512_4way_context ctx;
+   uint64_t hash[8*4] __attribute__ ((aligned (64)));
+   uint64_t *out64 = (uint64_t*)output;
+
+   skein512_4way_init( &ctx );
+   skein512_4way( &ctx, input, 80 );
+   skein512_4way_close( &ctx, hash );
+
+   skein512_4way_init( &ctx );
+   skein512_4way( &ctx, hash, 64 );
+   skein512_4way_close( &ctx, hash );
+
+   m256_deinterleave_4x64( out64, out64+4, out64+8, out64+12, hash, 256 );
+}
+
+int scanhash_skein2_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                          uint64_t *hashes_done )
+{
+    uint32_t hash[4*8] __attribute__ ((aligned (64)));
+    uint32_t vdata[20*4] __attribute__ ((aligned (64)));
+    uint32_t endiandata[20] __attribute__ ((aligned (64)));
+    uint64_t *edata = (uint64_t*)endiandata;
+    uint32_t *pdata = work->data;
+    uint32_t *ptarget = work->target;
+    const uint32_t Htarg = ptarget[7];
+    const uint32_t first_nonce = pdata[19];
+    uint32_t n = first_nonce;
+    // hash is returned deinterleaved
+    uint32_t *nonces = work->nonces;
+    bool *found = work->nfound;
+    int num_found;
+
+    swab32_array( endiandata, pdata, 20 );
+
+    m256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+
+    uint32_t *noncep0 = vdata + 73;   // 9*8 + 1
+    uint32_t *noncep1 = vdata + 75;
+    uint32_t *noncep2 = vdata + 77;
+    uint32_t *noncep3 = vdata + 79;
+
+    do 
+    {
+       found[0] = found[1] = found[2] = found[3] = false;
+       num_found = 0;
+       be32enc( noncep0, n   );
+       be32enc( noncep1, n+1 );
+       be32enc( noncep2, n+2 );
+       be32enc( noncep3, n+3 );
+
+       skein2hash( hash, vdata );
+
+       if ( hash[7] < Htarg && fulltest( hash, ptarget ) )
+       {
+           found[0] = true;
+           num_found++;
+           nonces[0] = n;
+       }
+       if ( (hash+8)[7] < Htarg && fulltest( hash+8, ptarget ) )
+       {
+           found[1] = true;
+           num_found++;
+           nonces[1] = n+1;
+       }
+       if ( (hash+16)[7] < Htarg && fulltest( hash+16, ptarget ) )
+       {
+           found[2] = true;
+           num_found++;
+           nonces[2] = n+2;
+       }
+       if ( (hash+24)[7] < Htarg && fulltest( hash+24, ptarget ) )
+       {
+           found[3] = true;
+           num_found++;
+           nonces[3] = n+3;
+       }
+       n += 4;
+    } while ( (num_found == 0) && (n < max_nonce)
+             &&  !work_restart[thr_id].restart );
+
+    *hashes_done = n - first_nonce + 1;
+    return num_found;
+}
+
+#endif

algo/skein/skein2-gate.c

@@ -0,0 +1,27 @@
+#include "skein2-gate.h"
+#include "algo-gate-api.h"
+//#include <string.h>
+#include <stdint.h>
+#include "sph_skein.h"
+//#include "skein-hash-avx2.h"
+
+int64_t skein2_get_max64 ()
+{
+  return 0x7ffffLL;
+}
+
+bool register_skein2_algo( algo_gate_t* gate )
+{
+#if defined (FOUR_WAY) && defined (__AVX2__)
+  gate->optimizations = SSE2_OPT | AVX2_OPT;
+  gate->scanhash  = (void*)&scanhash_skein2_4way;
+  gate->hash      = (void*)&skein2hash_4way;
+#else
+  gate->optimizations = SSE2_OPT;
+  gate->scanhash  = (void*)&scanhash_skein2;
+  gate->hash      = (void*)&skein2hash;
+#endif
+  gate->get_max64 = (void*)&skein2_get_max64;
+  return true;
+};
+

algo/skein/skein2-gate.h

@@ -0,0 +1,15 @@
+#ifndef __SKEIN2GATE_H__
+#define __SKEIN2_GATE_H__
+#include <stdint.h>
+
+#if defined(__AVX2__)
+void skein2hash_4way( void *output, const void *input );
+int scanhash_skein2_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                          uint64_t* hashes_done );
+#endif
+
+void skein2hash( void *output, const void *input );
+int scanhash_skein2( int thr_id, struct work *work, uint32_t max_nonce,
+                     uint64_t *hashes_done );
+#endif
+

algo/skein/skein2.c

@@ -65,16 +65,4 @@ int scanhash_skein2(int thr_id, struct work *work,
 	return 0;
 }
 
-int64_t skein2_get_max64 ()
-{
-  return 0x7ffffLL;
-}
-
-bool register_skein2_algo( algo_gate_t* gate )
-{
-  gate->scanhash  = (void*)&scanhash_skein2;
-  gate->hash      = (void*)&skein2hash;
-  gate->get_max64 = (void*)&skein2_get_max64;
-  return true;
-};
 

algo/skein/sph_skein.c

@@ -39,6 +39,24 @@
 extern "C"{
 #endif
 
+void dump_sph_context( sph_u64 ptr, sph_u64 bcount, uint64_t* buf, 
+  sph_u64 h0, sph_u64 h1, sph_u64 h2, sph_u64 h3, sph_u64 h4, sph_u64 h5,
+  sph_u64 h6, sph_u64 h7 )
+{
+//scalar
+printf("sptr= %llu, bcount= %llu\n", ptr, bcount );
+
+printf("sbuf: %016llx %016llx %016llx %016llx\n", *((uint64_t*)buf),
+       *((uint64_t*)buf+1), *((uint64_t*)buf+2), *((uint64_t*)buf+3) );
+
+printf("      %016llx %016llx %016llx %016llx\n", *((uint64_t*)buf+4),
+       *((uint64_t*)buf+5), *((uint64_t*)buf+6), *((uint64_t*)buf+7) );
+
+printf("sh:%016llx %016llx %016llx %016llx\n", h0, h1, h2, h3 );
+
+printf("   %016llx %016llx %016llx %016llx\n", h4, h5, h6, h7 );
+
+}
 
 #if SPH_SMALL_FOOTPRINT && !defined SPH_SMALL_FOOTPRINT_SKEIN
 #define SPH_SMALL_FOOTPRINT_SKEIN   1
@@ -883,6 +901,7 @@ skein_big_core(sph_skein_big_context *sc, const void *data, size_t len)
 	}
 
 	READ_STATE_BIG(sc);
+
 	first = (bcount == 0) << 7;
 	do {
 		size_t clen;