v3.9.4

INSTALL_LINUX

@@ -42,9 +42,6 @@ openssl 1.1.0e or higher. Add one of the following, depending on the
 compiler version, to CFLAGS:
 "-march=native" or "-march=znver1" or "-msha".
 
-Due to poor AVX2 performance on Ryzen users should add -DRYZEN_ to CFLAGS
-to override multiway AVX2 on algos with sha256, and use SHA instead.
-
 Additional instructions for static compilalation can be found here:
 https://lxadm.com/Static_compilation_of_cpuminer
 Static builds should only considered in a homogeneous HW and SW environment.

Makefile.am

@@ -68,7 +68,8 @@ cpuminer_SOURCES = \
   algo/blake/pentablake-4way.c \
   algo/blake/pentablake.c \
   algo/bmw/sph_bmw.c \
-  algo/bmw/bmw-hash-4way.c \
+  algo/bmw/bmw256-hash-4way.c \
+  algo/bmw/bmw512-hash-4way.c \
   algo/bmw/bmw256.c \
   algo/cryptonight/cryptolight.c \
   algo/cryptonight/cryptonight-common.c\
@@ -130,6 +131,7 @@ cpuminer_SOURCES = \
   algo/lyra2/lyra2h-4way.c \
   algo/lyra2/allium-4way.c \
   algo/lyra2/allium.c \
+  algo/lyra2/phi2-4way.c \
   algo/lyra2/phi2.c \
   algo/m7m.c \
   algo/neoscrypt/neoscrypt.c \
@@ -146,6 +148,9 @@ cpuminer_SOURCES = \
   algo/quark/anime-gate.c \
   algo/quark/anime.c \
   algo/quark/anime-4way.c \
+  algo/quark/hmq1725-gate.c \
+  algo/quark/hmq1725-4way.c \
+  algo/quark/hmq1725.c \
   algo/qubit/qubit-gate.c \
   algo/qubit/qubit.c \
   algo/qubit/qubit-2way.c \
@@ -162,10 +167,13 @@ cpuminer_SOURCES = \
   algo/sha/sph_sha2.c \
   algo/sha/sph_sha2big.c \
   algo/sha/sha2-hash-4way.c \
+  algo/sha/sha256_hash_11way.c \
   algo/sha/sha2.c \
   algo/sha/sha256t-gate.c \
   algo/sha/sha256t-4way.c \
   algo/sha/sha256t.c \
+  algo/sha/sha256q-4way.c \
+  algo/sha/sha256q.c \
   algo/shabal/sph_shabal.c \
   algo/shabal/shabal-hash-4way.c \
   algo/shavite/sph_shavite.c \
@@ -253,7 +261,6 @@ cpuminer_SOURCES = \
   algo/x17/xevan-gate.c \
   algo/x17/xevan.c \
   algo/x17/xevan-4way.c \
-  algo/x17/hmq1725.c \
   algo/x17/sonoa-gate.c \
   algo/x17/sonoa-4way.c \
   algo/x17/sonoa.c \
@@ -262,7 +269,7 @@ cpuminer_SOURCES = \
   algo/yescrypt/sha256_Y.c \
   algo/yescrypt/yescrypt-best.c \
   algo/yespower/yespower.c \
-  algo/yespower/sha256.c \
+  algo/yespower/sha256_p.c \
   algo/yespower/yespower-opt.c
 
 disable_flags =

README.txt

@@ -12,7 +12,7 @@ the software, don't use it.
 Choose the exe that best matches you CPU's features or use trial and
 error to find the fastest one that doesn't crash. Pay attention to
 the features listed at cpuminer startup to ensure you are mining at
-optimum speed using all the available features.
+optimum speed using the best available features.
 
 Architecture names and compile options used are only provided for Intel
 Core series. Even the newest Pentium and Celeron CPUs are often missing
@@ -22,8 +22,6 @@ AMD CPUs older than Piledriver, including Athlon x2 and Phenom II x4, are not
 supported by cpuminer-opt due to an incompatible implementation of SSE2 on
 these CPUs. Some algos may crash the miner with an invalid instruction.
 Users are recommended to use an unoptimized miner such as cpuminer-multi.
-Changes in v3.8.4 may have improved compatibility with some of these CPUs.
-
 
 Exe name                Compile flags            Arch name
 
@@ -31,7 +29,7 @@ cpuminer-sse2.exe      "-msse2"                  Core2, Nehalem
 cpuminer-aes-sse42.exe "-march=westmere"         Westmere
 cpuminer-avx.exe       "-march=corei7-avx"       Sandy-Ivybridge
 cpuminer-avx2.exe      "-march=core-avx2"        Haswell, Sky-Kaby-Coffeelake
-cpuminer-zen           "-march=znver1 -DRYZEN_"  Ryzen
+cpuminer-zen           "-march=znver1"           AMD Ryzen, Threadripper
 
 If you like this software feel free to donate:
 

RELEASE_NOTES

@@ -33,11 +33,63 @@ Requirements
 Intel Core2 or newer, or AMD Steamroller or newer CPU. ARM CPUs are not
 supported.
 
-64 bit Linux or Windows operating system. Apple is not supported.
+64 bit Linux or Windows operating system. Apple and Android are not supported.
 
 Change Log
 ----------
 
+v3.9.4
+
+Faster AVX2 for lyra2v3, quark, anime.
+Fixed skein AVX2 regression (invalid shares since v3.9.0) and faster.
+Faster skein2 with 4way AVX2 enabled.
+Automatic SHA override on Ryzen CPUs, no need for -DRYZEN compile flag.
+Ongoing restructuring.
+
+v3.9.3.1
+
+Skipped v3.9.3 due to misidentification of v3.9.2.5 as v3.9.3.
+Fixed x16r algo 25% invalid share reject rate. The bug may have also
+affected other algos.
+
+v3.9.2.5
+
+Fixed 2 regressions: hodl AES detection, x16r invalid shares with AVX2.
+More restructuring.
+
+v3.9.2.4
+
+Yet another affinity fix. Hopefully the last one.
+
+v3.9.2.3
+
+Another cpu-affinity fix.
+Disabled test code that fails to compile on some CPUs with limited
+AVX512 capabilities.
+
+v3.9.2.2
+
+Fixed some day one cpu-affinity issues.
+
+v3.9.2
+
+Added sha256q algo.
+Yespower now uses openssl SHA256, but no observable hash rate increase
+on Ryzen.
+Ongoing rearchitecting.
+Lyra2z now hashes 8-way on CPUs with AVX2.
+Lyra2 (all including phi2) now runs optimized code with SSE2.
+
+v3.9.1.1
+
+Fixed lyra2v3 AVX and below.
+
+Compiling on Windows using Cygwin now works. Simply use "./build.sh"
+just like on Linux. It isn't portable therefore the binaries package will
+continue to use the existing procedure.
+The Cygwin procedure will be documented in more detail later and will
+include a list of packages that need to be installed.
+
 v3.9.1
 
 Fixed AVX2 version of anime algo.

algo-gate-api.c

@@ -210,6 +210,7 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
      case ALGO_SCRYPTJANE:   register_scryptjane_algo   ( gate ); break;
      case ALGO_SHA256D:      register_sha256d_algo      ( gate ); break;
      case ALGO_SHA256T:      register_sha256t_algo      ( gate ); break;
+     case ALGO_SHA256Q:      register_sha256q_algo      ( gate ); break;
      case ALGO_SHAVITE3:     register_shavite_algo      ( gate ); break;
      case ALGO_SKEIN:        register_skein_algo        ( gate ); break;
      case ALGO_SKEIN2:       register_skein2_algo       ( gate ); break;
@@ -344,9 +345,9 @@ const char* const algo_alias_map[][2] =
   { NULL,                NULL           }   
 };
 
-// if arg is a valid alias for a known algo it is updated with the proper name.
-// No validation of the algo or alias is done, It is the responsinility of the
-// calling function to validate the algo after return.
+// if arg is a valid alias for a known algo it is updated with the proper
+// name. No validation of the algo or alias is done, It is the responsinility
+// of the calling function to validate the algo after return.
 void get_algo_alias( char** algo_or_alias )
 {
   int i;
@@ -361,3 +362,22 @@ void get_algo_alias( char** algo_or_alias )
 
 #undef ALIAS
 #undef PROPER
+
+// only for parallel when there are lanes.
+bool submit_solution( struct work *work, void *hash,
+                      struct thr_info *thr, int lane )
+{
+     work_set_target_ratio( work, hash );
+     if ( submit_work( thr, work ) )
+     {
+         applog( LOG_NOTICE, "Share %d submitted by thread %d, lane %d.",
+                 accepted_share_count + rejected_share_count + 1,
+                 thr->id, lane );
+         return true;
+     }
+     else
+          applog( LOG_WARNING, "Failed to submit share." );
+     return false;
+}
+
+

algo-gate-api.h

@@ -2,8 +2,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include "miner.h"
-#include "avxdefs.h"
-#include "interleave.h"
+#include "simd-utils.h"
 
 /////////////////////////////
 ////
@@ -196,8 +195,9 @@ void four_way_not_tested();
 int null_scanhash();
 
 // The one and only, a callback for scanhash.
-
-
+bool submit_solution( struct work *work, void *hash,
+                      struct thr_info *thr, int lane );
+ 
 bool submit_work( struct thr_info *thr, const struct work *work_in );
 
 // displays warning

algo/argon2/argon2d/argon2d/core.c

@@ -112,7 +112,7 @@ int allocate_memory(const argon2_context *context, uint8_t **memory,
 void free_memory(const argon2_context *context, uint8_t *memory,
                  size_t num, size_t size) {
     size_t memory_size = num*size;
-    clear_internal_memory(memory, memory_size);
+//    clear_internal_memory(memory, memory_size);
     if (context->free_cbk) {
         (context->free_cbk)(memory, memory_size);
     } else {
@@ -137,7 +137,7 @@ void NOT_OPTIMIZED secure_wipe_memory(void *v, size_t n) {
 int FLAG_clear_internal_memory = 0;
 void clear_internal_memory(void *v, size_t n) {
   if (FLAG_clear_internal_memory && v) {
-    secure_wipe_memory(v, n);
+//    secure_wipe_memory(v, n);
   }
 }
 
@@ -559,7 +559,7 @@ void initial_hash(uint8_t *blockhash, argon2_context *context,
                        context->pwdlen);
 
         if (context->flags & ARGON2_FLAG_CLEAR_PASSWORD) {
-            secure_wipe_memory(context->pwd, context->pwdlen);
+//            secure_wipe_memory(context->pwd, context->pwdlen);
             context->pwdlen = 0;
         }
     }
@@ -580,7 +580,7 @@ void initial_hash(uint8_t *blockhash, argon2_context *context,
                        context->secretlen);
 
         if (context->flags & ARGON2_FLAG_CLEAR_SECRET) {
-            secure_wipe_memory(context->secret, context->secretlen);
+//            secure_wipe_memory(context->secret, context->secretlen);
             context->secretlen = 0;
         }
     }

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

@@ -45,7 +45,7 @@ extern "C"{
 
 #include <stddef.h>
 #include "algo/sha/sph_types.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #define SPH_SIZE_blake256   256
 

algo/blake/blake2s-hash-4way.h

@@ -16,7 +16,7 @@
 
 #if defined(__SSE4_2__)
 
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #include <stddef.h>
 #include <stdint.h>

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

@@ -41,15 +41,18 @@ extern "C"{
 #endif
 
 #include <stddef.h>
-#ifdef __AVX2__
 
 #include "algo/sha/sph_types.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #define SPH_SIZE_bmw256   256
 
 #define SPH_SIZE_bmw512   512
 
+#if defined(__SSE2__)
+
+// BMW-256 4 way 32
+
 typedef struct {
    __m128i buf[64];
    __m128i H[16];
@@ -59,6 +62,60 @@ typedef struct {
 
 typedef bmw_4way_small_context bmw256_4way_context;
 
+void bmw256_4way_init(void *cc);
+
+void bmw256_4way(void *cc, const void *data, size_t len);
+
+void bmw256_4way_close(void *cc, void *dst);
+
+void bmw256_4way_addbits_and_close(
+        void *cc, unsigned ub, unsigned n, void *dst);
+
+#endif  // __SSE2__
+
+#if defined(__AVX2__)
+
+// BMW-256 8 way 32
+
+typedef struct {
+   __m256i buf[64];
+   __m256i H[16];
+   size_t ptr;
+   uint32_t bit_count;  // assume bit_count fits in 32 bits
+} bmw_8way_small_context __attribute__ ((aligned (64)));
+
+typedef bmw_8way_small_context bmw256_8way_context;
+
+void bmw256_8way_init( bmw256_8way_context *ctx );
+void bmw256_8way( bmw256_8way_context *ctx, const void *data, size_t len );
+void bmw256_8way_close( bmw256_8way_context *ctx, void *dst );
+
+#endif
+
+
+#if defined(__SSE2__)
+
+// BMW-512 2 way 64
+
+typedef struct {
+   __m128i buf[16];
+   __m128i H[16];
+   size_t ptr;
+   uint64_t bit_count; 
+} bmw_2way_big_context __attribute__ ((aligned (64)));
+
+typedef bmw_2way_big_context bmw512_2way_context;
+
+void bmw512_2way_init( bmw512_2way_context *ctx );
+void bmw512_2way( bmw512_2way_context *ctx, const void *data, size_t len );
+void bmw512_2way_close( bmw512_2way_context *ctx, void *dst );
+
+#endif // __SSE2__
+
+#if defined(__AVX2__)
+
+// BMW-512 4 way 64
+
 typedef struct {
    __m256i buf[16];
    __m256i H[16];
@@ -68,14 +125,6 @@ typedef struct {
 
 typedef bmw_4way_big_context bmw512_4way_context;
 
-void bmw256_4way_init(void *cc);
-
-void bmw256_4way(void *cc, const void *data, size_t len);
-
-void bmw256_4way_close(void *cc, void *dst);
-
-void bmw256_4way_addbits_and_close(
-	void *cc, unsigned ub, unsigned n, void *dst);
 
 void bmw512_4way_init(void *cc);
 
@@ -86,10 +135,10 @@ void bmw512_4way_close(void *cc, void *dst);
 void bmw512_4way_addbits_and_close(
 	void *cc, unsigned ub, unsigned n, void *dst);
 
-#endif
+#endif  // __AVX2__
 
 #ifdef __cplusplus
 }
 #endif
 
-#endif
+#endif // BMW_HASH_H__

algo/cubehash/cube-hash-2way.h

@@ -4,7 +4,7 @@
 #if defined(__AVX2__)
 
 #include <stdint.h>
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 // 2x128, 2 way parallel SSE2
 

algo/cubehash/cubehash_sse2.c

@@ -13,7 +13,7 @@
 #include <stdbool.h>
 #include <unistd.h>
 #include <memory.h>
-#include "avxdefs.h"
+#include "simd-utils.h"
 #include <stdio.h>
 
 // The result of hashing 10 rounds of initial data which is params and 

algo/fugue/sph_fugue.c

@@ -11,6 +11,8 @@ extern "C"{
 #pragma warning (disable: 4146)
 #endif
 
+#define SPH_FUGUE_NOCOPY 1
+
 static const sph_u32 IV224[] = {
 	SPH_C32(0xf4c9120d), SPH_C32(0x6286f757), SPH_C32(0xee39e01c),
 	SPH_C32(0xe074e3cb), SPH_C32(0xa1127c62), SPH_C32(0x9a43d215),

algo/groestl/aes_ni/hash-groestl.c

@@ -12,7 +12,7 @@
 #include <memory.h>
 #include "hash-groestl.h"
 #include "miner.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #ifndef NO_AES_NI
 

algo/groestl/aes_ni/hash-groestl256.c

@@ -9,7 +9,7 @@
 #include <memory.h>
 #include "hash-groestl256.h"
 #include "miner.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #ifndef NO_AES_NI
 

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

@@ -40,7 +40,7 @@
 
 #if defined (__AVX2__)
 
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #ifdef __cplusplus
 extern "C"{

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

@@ -69,7 +69,7 @@ extern "C"{
 
 #include <stddef.h>
 #include "algo/sha/sph_types.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #define SPH_SIZE_haval256_5   256
 

algo/hodl/hodl-gate.c

@@ -156,7 +156,7 @@ int hodl_scanhash( int thr_id, struct work* work, uint32_t max_nonce,
 
 bool register_hodl_algo( algo_gate_t* gate )
 {
-#if defined(__AES__)
+#if !defined(__AES__)
   applog( LOG_ERR, "Only CPUs with AES are supported, use legacy version.");
   return false;
 #endif

algo/hodl/sha512_avx.c

@@ -11,6 +11,10 @@
 #include <sys/endian.h>
 #endif 
 
+#if defined(__CYGWIN__)
+#include <endian.h>
+#endif
+
 #include "tmmintrin.h"
 #include "smmintrin.h"
 

algo/hodl/sha512_avx2.c

@@ -8,6 +8,10 @@
 #include <sys/endian.h>
 #endif 
 
+#if defined(__CYGWIN__)
+#include <endian.h>
+#endif
+
 #include "tmmintrin.h"
 #include "smmintrin.h"
 #include "immintrin.h"

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

@@ -44,7 +44,7 @@ extern "C"{
 
 #include <stddef.h>
 #include "algo/sha/sph_types.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #define SPH_SIZE_jh256   256
 

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

@@ -44,7 +44,7 @@ extern "C"{
 
 #include <stddef.h>
 #include "algo/sha/sph_types.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #define SPH_SIZE_keccak256   256
 

algo/keccak/sse2/keccak.c

@@ -91,7 +91,7 @@ extern "C"{
 #pragma warning (disable: 4146)
 #endif
 
-
+/*
 static const sph_u64 RC[] = {
 	SPH_C64(0x0000000000000001), SPH_C64(0x0000000000008082),
 	SPH_C64(0x800000000000808A), SPH_C64(0x8000000080008000),
@@ -106,7 +106,7 @@ static const sph_u64 RC[] = {
 	SPH_C64(0x8000000080008081), SPH_C64(0x8000000000008080),
 	SPH_C64(0x0000000080000001), SPH_C64(0x8000000080008008)
 };
-
+*/
 #define kekDECL_STATE \
 	sph_u64 keca00, keca01, keca02, keca03, keca04; \
 	sph_u64 keca10, keca11, keca12, keca13, keca14; \
@@ -756,6 +756,20 @@ static const sph_u64 RC[] = {
  * tested faster saving space
 */
 #define KECCAK_F_1600_   do { \
+static const sph_u64 RC[] = { \
+        SPH_C64(0x0000000000000001), SPH_C64(0x0000000000008082), \
+        SPH_C64(0x800000000000808A), SPH_C64(0x8000000080008000), \
+        SPH_C64(0x000000000000808B), SPH_C64(0x0000000080000001), \
+        SPH_C64(0x8000000080008081), SPH_C64(0x8000000000008009), \
+        SPH_C64(0x000000000000008A), SPH_C64(0x0000000000000088), \
+        SPH_C64(0x0000000080008009), SPH_C64(0x000000008000000A), \
+        SPH_C64(0x000000008000808B), SPH_C64(0x800000000000008B), \
+        SPH_C64(0x8000000000008089), SPH_C64(0x8000000000008003), \
+        SPH_C64(0x8000000000008002), SPH_C64(0x8000000000000080), \
+        SPH_C64(0x000000000000800A), SPH_C64(0x800000008000000A), \
+        SPH_C64(0x8000000080008081), SPH_C64(0x8000000000008080), \
+        SPH_C64(0x0000000080000001), SPH_C64(0x8000000080008008) \
+}; \
 		int j; \
 		for (j = 0; j < 24; j += 4) { \
 			KF_ELT( 0,  1, RC[j + 0]); \
@@ -791,7 +805,7 @@ static const sph_u64 RC[] = {
 /* load initial constants */
 #define KEC_I 
 
-static unsigned char keczword[8] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }; 
+//static unsigned char keczword[8] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }; 
 /*
  unsigned char keczword[8] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }; \
 */
@@ -799,6 +813,7 @@ static unsigned char keczword[8] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0
 /* load hash for loop */
 #define KEC_U \
 do { \
+static unsigned char keczword[8] = { 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80 }; \
     /*memcpy(hashbuf, hash, 64); */ \
     memcpy(hash + 64, keczword, 8); \
 } while (0); 

algo/luffa/luffa-hash-2way.c

@@ -24,7 +24,7 @@
 
 #if defined(__AVX2__)
 
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #define MASK _mm256_set_epi32( 0UL, 0UL, 0UL, 0xffffffffUL, \
                                0UL, 0UL, 0UL, 0xffffffffUL )

algo/luffa/luffa-hash-2way.h

@@ -24,7 +24,7 @@
 
 #include <immintrin.h>
 #include "algo/sha/sha3-defs.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 /* The length of digests*/
 #define DIGEST_BIT_LEN_224 224

algo/luffa/luffa_for_sse2.c

@@ -20,7 +20,7 @@
 
 #include <string.h>
 #include <emmintrin.h>
-#include "avxdefs.h"
+#include "simd-utils.h"
 #include "luffa_for_sse2.h"
 
 #define MULT2(a0,a1) do \

algo/lyra2/allium-4way.c

@@ -44,10 +44,11 @@ void allium_4way_hash( void *state, const void *input )
    blake256_4way( &ctx.blake, input + (64<<2), 16 );
    blake256_4way_close( &ctx.blake, vhash32 );
 
-   mm256_reinterleave_4x64( vhash64, vhash32, 256 );
+   mm256_rintrlv_4x32_4x64( vhash64, vhash32, 256 );
    keccak256_4way( &ctx.keccak, vhash64, 32 );
    keccak256_4way_close( &ctx.keccak, vhash64 );
-   mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
+
+   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
 
    LYRA2RE( hash0, 32, hash0, 32, hash0, 32, 1, 8, 8 );
    LYRA2RE( hash1, 32, hash1, 32, hash1, 32, 1, 8, 8 );
@@ -67,73 +68,64 @@ void allium_4way_hash( void *state, const void *input )
    LYRA2RE( hash2, 32, hash2, 32, hash2, 32, 1, 8, 8 );
    LYRA2RE( hash3, 32, hash3, 32, hash3, 32, 1, 8, 8 );
 
-   mm256_interleave_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );
+   mm256_intrlv_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );
+
    skein256_4way( &ctx.skein, vhash64, 32 );
    skein256_4way_close( &ctx.skein, vhash64 );
-   mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
 
-   update_and_final_groestl256( &ctx.groestl, hash0, hash0, 256 );
-   memcpy( &ctx.groestl, &allium_4way_ctx.groestl,
-           sizeof(hashState_groestl256) );
-   update_and_final_groestl256( &ctx.groestl, hash1, hash1, 256 );
-   memcpy( &ctx.groestl, &allium_4way_ctx.groestl,
-           sizeof(hashState_groestl256) );
-   update_and_final_groestl256( &ctx.groestl, hash2, hash2, 256 );
-   memcpy( &ctx.groestl, &allium_4way_ctx.groestl,
-           sizeof(hashState_groestl256) );
-   update_and_final_groestl256( &ctx.groestl, hash3, hash3, 256 );
+   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
 
-   memcpy( state,    hash0, 32 );
-   memcpy( state+32, hash1, 32 );
-   memcpy( state+64, hash2, 32 );
-   memcpy( state+96, hash3, 32 );
+   update_and_final_groestl256( &ctx.groestl, state, hash0, 256 );
+   memcpy( &ctx.groestl, &allium_4way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+32, hash1, 256 );
+   memcpy( &ctx.groestl, &allium_4way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+64, hash2, 256 );
+   memcpy( &ctx.groestl, &allium_4way_ctx.groestl,
+           sizeof(hashState_groestl256) );
+   update_and_final_groestl256( &ctx.groestl, state+96, hash3, 256 );
 }
 
 int scanhash_allium_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                             uint64_t *hashes_done )
+                             uint64_t *hashes_done, struct thr_info *mythr )
 {
    uint32_t hash[8*4] __attribute__ ((aligned (64)));
    uint32_t vdata[20*4] __attribute__ ((aligned (64)));
-   uint32_t _ALIGN(64) edata[20];
    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
    const uint32_t first_nonce = pdata[19];
    uint32_t n = first_nonce;
    const uint32_t Htarg = ptarget[7];
-   uint32_t *nonces = work->nonces;
-   int num_found = 0;
-   uint32_t *noncep = vdata + 76; // 19*4
+   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
    if ( opt_benchmark )
       ( (uint32_t*)ptarget )[7] = 0x0000ff;
 
-   swab32_array( edata, pdata, 20 );
-   mm128_interleave_4x32( vdata, edata, edata, edata, edata, 640 );
+   mm128_bswap_intrlv80_4x32( vdata, pdata );
    blake256_4way_init( &allium_4way_ctx.blake );
    blake256_4way( &allium_4way_ctx.blake, vdata, 64 );
 
    do {
-     be32enc( noncep,   n   );
-     be32enc( noncep+1, n+1 );
-     be32enc( noncep+2, n+2 );
-     be32enc( noncep+3, n+3 );
+     *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
 
      allium_4way_hash( hash, vdata );
      pdata[19] = n;
 
-     for ( int i = 0; i < 4; i++ )
-     if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget ) )
+     for ( int lane = 0; lane < 4; lane++ ) if ( (hash+(lane<<3))[7] <= Htarg )
      {
-         pdata[19] = n+i;
-         nonces[ num_found++ ] = n+i;
-         work_set_target_ratio( work, hash+(i<<3) );
+        if ( fulltest( hash+(lane<<3), ptarget ) && !opt_benchmark )
+        {
+           pdata[19] = n + lane;
+           submit_solution( work, hash+(lane<<3), mythr, lane );
+         }
      }
      n += 4;
-   } while ( (num_found == 0) && (n < max_nonce-4)
-                   && !work_restart[thr_id].restart);
+   } while ( (n < max_nonce-4) && !work_restart[thr_id].restart);
 
    *hashes_done = n - first_nonce + 1;
-   return num_found;
+   return 0;
 }
 
 #endif

algo/lyra2/allium.c

@@ -70,7 +70,7 @@ void allium_hash(void *state, const void *input)
 }
 
 int scanhash_allium( int thr_id, struct work *work, uint32_t max_nonce,
-                     uint64_t *hashes_done )
+                     uint64_t *hashes_done, struct thr_info *mythr )
 {
     uint32_t _ALIGN(128) hash[8];
     uint32_t _ALIGN(128) endiandata[20];
@@ -80,6 +80,7 @@ int scanhash_allium( int thr_id, struct work *work, uint32_t max_nonce,
     const uint32_t Htarg = ptarget[7];
     const uint32_t first_nonce = pdata[19];
     uint32_t nonce = first_nonce;
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
     if ( opt_benchmark )
         ptarget[7] = 0x3ffff;

algo/lyra2/lyra2-gate.c

@@ -1,6 +1,43 @@
 #include "lyra2-gate.h"
 
 
+// huge pages
+//
+// Use MAP_PRIVATE instead
+// In register algo:
+// replace thread safe whole matrix with a char**
+// alloc huge pages matrixsize * threads
+// make pointers to each thread to each thread, creating an 
+// array[thread][matrix].
+// Each thread can create its own matrix pointer:
+//  my_matrix = the matrix + ( thread_id * matrix_size  )
+//
+// Compiler version check?
+// Fallback?
+//
+// create a generic utility to map & unmap huge pages.
+// ptr = malloc_huge( size );
+// Yespower wrapper checks for 64 byte alignment, seems unnecessary as
+// it should be aligned to the page boundary. It may be desireable to
+// have the matrix size rounded up if necessary to something bigger
+// than 64 byte, say 4 kbytes a small page size.
+
+// Define some constants for indivual parameters and matrix size for
+// each algo. Use the parameter constants where apropriate.
+// Convert algos that don't yet do so to use dynamic alllocation.
+// Alloc huge pages globally. If ok each thread will create a pointer to
+// its chunk. If fail each thread will use use _mm_alloc for itself. 
+// BLOCK_LEN_BYTES is 768.
+
+#define LYRA2REV3_NROWS 4
+#define LYRA2REV3_NCOLS 4
+/*
+#define LYRA2REV3_MATRIX_SIZE ((BLOCK_LEN_BYTES)*(LYRA2REV3_NCOLS)* \
+                                                 (LYRA2REV3_NROWS)*8)
+*/
+
+#define LYRA2REV3_MATRIX_SIZE ((BLOCK_LEN_BYTES)<<4)
+
 __thread uint64_t* l2v3_wholeMatrix;
 
 bool lyra2rev3_thread_init()
@@ -10,7 +47,9 @@ bool lyra2rev3_thread_init()
 
    int size = (int64_t)ROW_LEN_BYTES * 4; // nRows;
    l2v3_wholeMatrix = _mm_malloc( size, 64 );
-#if defined (LYRA2REV3_4WAY)
+#if defined (LYRA2REV3_8WAY)
+   init_lyra2rev3_8way_ctx();;
+#elif defined (LYRA2REV3_4WAY)
    init_lyra2rev3_4way_ctx();;
 #else
    init_lyra2rev3_ctx();
@@ -20,7 +59,10 @@ bool lyra2rev3_thread_init()
 
 bool register_lyra2rev3_algo( algo_gate_t* gate )
 {
-#if defined (LYRA2REV3_4WAY)
+#if defined (LYRA2REV3_8WAY)
+  gate->scanhash  = (void*)&scanhash_lyra2rev3_8way;
+  gate->hash      = (void*)&lyra2rev3_8way_hash;
+#elif defined (LYRA2REV3_4WAY)
   gate->scanhash  = (void*)&scanhash_lyra2rev3_4way;
   gate->hash      = (void*)&lyra2rev3_4way_hash;
 #else
@@ -166,13 +208,18 @@ void phi2_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
 
 bool register_phi2_algo( algo_gate_t* gate )
 {
-   init_phi2_ctx();
+//   init_phi2_ctx();
    gate->optimizations = SSE2_OPT | AES_OPT | SSE42_OPT | AVX2_OPT;
    gate->get_work_data_size = (void*)&phi2_get_work_data_size;
    gate->decode_extra_data  = (void*)&phi2_decode_extra_data;
    gate->build_extraheader  = (void*)&phi2_build_extraheader;
    gate->set_target         = (void*)&alt_set_target; 
    gate->get_max64          = (void*)&get_max64_0xffffLL;
+#if defined(PHI2_4WAY)
+   gate->scanhash           = (void*)&scanhash_phi2_4way;
+#else
+   init_phi2_ctx();
    gate->scanhash           = (void*)&scanhash_phi2;
+#endif
    return true;
 }

algo/lyra2/lyra2-gate.h

@@ -6,14 +6,24 @@
 #include "lyra2.h"
 
 #if defined(__AVX2__)
+  #define LYRA2REV3_8WAY
+#endif
+
+#if defined(__SSE2__)
   #define LYRA2REV3_4WAY
 #endif
 
 extern __thread uint64_t* l2v3_wholeMatrix;
 
 bool register_lyra2rev3_algo( algo_gate_t* gate );
+#if defined(LYRA2REV3_8WAY)
 
-#if defined(LYRA2REV3_4WAY)
+void lyra2rev3_8way_hash( void *state, const void *input );
+int scanhash_lyra2rev3_8way( int thr_id, struct work *work, uint32_t max_nonce,
+                             uint64_t *hashes_done, struct thr_info *mythr );
+bool init_lyra2rev3_8way_ctx();
+
+#elif defined(LYRA2REV3_4WAY)
 
 void lyra2rev3_4way_hash( void *state, const void *input );
 int scanhash_lyra2rev3_4way( int thr_id, struct work *work, uint32_t max_nonce,
@@ -43,25 +53,25 @@ bool register_lyra2rev2_algo( algo_gate_t* gate );
 
 void lyra2rev2_4way_hash( void *state, const void *input );
 int scanhash_lyra2rev2_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                             uint64_t *hashes_done );
+                             uint64_t *hashes_done, struct thr_info *mythr );
 bool init_lyra2rev2_4way_ctx();
 
 #else
 
 void lyra2rev2_hash( void *state, const void *input );
 int scanhash_lyra2rev2( int thr_id, struct work *work, uint32_t max_nonce,
-                        uint64_t *hashes_done );
+                        uint64_t *hashes_done, struct thr_info *mythr );
 bool init_lyra2rev2_ctx();
 
 #endif
 
 /////////////////////////
 
-#if defined(__SSE4_2__)
+#if defined(__SSE2__)
   #define LYRA2Z_4WAY
 #endif
 #if defined(__AVX2__)
-//  #define LYRA2Z_8WAY
+  #define LYRA2Z_8WAY
 #endif
 
 
@@ -71,21 +81,21 @@ bool init_lyra2rev2_ctx();
 
 void lyra2z_8way_hash( void *state, const void *input );
 int scanhash_lyra2z_8way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done );
+                          uint64_t *hashes_done, struct thr_info *mythr );
 bool lyra2z_8way_thread_init();
 
 #elif defined(LYRA2Z_4WAY)
 
 void lyra2z_4way_hash( void *state, const void *input );
 int scanhash_lyra2z_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done );
+                          uint64_t *hashes_done, struct thr_info *mythr );
 bool lyra2z_4way_thread_init();
 
 #else
 
 void lyra2z_hash( void *state, const void *input );
 int scanhash_lyra2z( int thr_id, struct work *work, uint32_t max_nonce,
-                     uint64_t *hashes_done );
+                     uint64_t *hashes_done, struct thr_info *mythr );
 bool lyra2z_thread_init();
 
 #endif
@@ -102,14 +112,14 @@ bool lyra2z_thread_init();
 
 void lyra2h_4way_hash( void *state, const void *input );
 int scanhash_lyra2h_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done );
+                          uint64_t *hashes_done, struct thr_info *mythr );
 bool lyra2h_4way_thread_init();
 
 #else
 
 void lyra2h_hash( void *state, const void *input );
 int scanhash_lyra2h( int thr_id, struct work *work, uint32_t max_nonce,
-                     uint64_t *hashes_done );
+                     uint64_t *hashes_done, struct thr_info *mythr );
 bool lyra2h_thread_init();
 
 #endif
@@ -126,29 +136,43 @@ bool register_allium_algo( algo_gate_t* gate );
 
 void allium_4way_hash( void *state, const void *input );
 int scanhash_allium_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done );
+                          uint64_t *hashes_done, struct thr_info *mythr );
 bool init_allium_4way_ctx();
 
 #else
 
 void allium_hash( void *state, const void *input );
 int scanhash_allium( int thr_id, struct work *work, uint32_t max_nonce,
-                     uint64_t *hashes_done );
+                     uint64_t *hashes_done, struct thr_info *mythr );
 bool init_allium_ctx();
 
 #endif 
 
 /////////////////////////////////////////
 
+#if defined(__AVX2__) && defined(__AES__)
+//  #define PHI2_4WAY
+#endif
+
 bool phi2_has_roots;
 
 bool register_phi2_algo( algo_gate_t* gate );
+#if defined(PHI2_4WAY)
+
+void phi2_hash_4way( void *state, const void *input );
+int scanhash_phi2_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                     uint64_t *hashes_done, struct thr_info *mythr );
+//void init_phi2_ctx();
+
+#else
 
 void phi2_hash( void *state, const void *input );
 int scanhash_phi2( int thr_id, struct work *work, uint32_t max_nonce,
-                     uint64_t *hashes_done );
+                     uint64_t *hashes_done, struct thr_info *mythr );
 void init_phi2_ctx();
 
+#endif
+
 #endif  // LYRA2_GATE_H__
 
 

algo/lyra2/lyra2.c

@@ -236,7 +236,7 @@ int LYRA2REV3( uint64_t* wholeMatrix, void *K, uint64_t kLen, const void *pwd,
    //Tries to allocate enough space for the whole memory matrix
 
    const int64_t ROW_LEN_INT64 = BLOCK_LEN_INT64 * nCols;
-   const int64_t ROW_LEN_BYTES = ROW_LEN_INT64 * 8;
+//   const int64_t ROW_LEN_BYTES = ROW_LEN_INT64 * 8;
    const int64_t BLOCK_LEN = BLOCK_LEN_BLAKE2_SAFE_INT64;
 /*
    const int64_t ROW_LEN_INT64 = BLOCK_LEN_INT64 * nCols;
@@ -566,7 +566,7 @@ int LYRA2RE( void *K, uint64_t kLen, const void *pwd, const uint64_t pwdlen,
 
 #if defined(__AVX2__)
    memset_zero_256( (__m256i*)wholeMatrix, i>>5 );
-#elif defined(__SSE4_2__)
+#elif defined(__SSE2__)
    memset_zero_128( (__m128i*)wholeMatrix, i>>4 );   
 #else
    memset( wholeMatrix, 0, i );

algo/lyra2/lyra2h-4way.c

@@ -36,66 +36,53 @@ void lyra2h_4way_hash( void *state, const void *input )
      blake256_4way( &ctx_blake, input + (64*4), 16 );
      blake256_4way_close( &ctx_blake, vhash );
 
-     mm128_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash, 256 );
+     mm128_dintrlv_4x32( hash0, hash1, hash2, hash3, vhash, 256 );
 
-     LYRA2Z( lyra2h_4way_matrix, hash0, 32, hash0, 32, hash0, 32, 16, 16, 16 );
-     LYRA2Z( lyra2h_4way_matrix, hash1, 32, hash1, 32, hash1, 32, 16, 16, 16 );
-     LYRA2Z( lyra2h_4way_matrix, hash2, 32, hash2, 32, hash2, 32, 16, 16, 16 );
-     LYRA2Z( lyra2h_4way_matrix, hash3, 32, hash3, 32, hash3, 32, 16, 16, 16 );
-
-     memcpy( state,    hash0, 32 );
-     memcpy( state+32, hash1, 32 );
-     memcpy( state+64, hash2, 32 );
-     memcpy( state+96, hash3, 32 );
+     LYRA2Z( lyra2h_4way_matrix, state, 32, hash0, 32, hash0, 32,
+             16, 16, 16 );
+     LYRA2Z( lyra2h_4way_matrix, state+32, 32, hash1, 32, hash1,
+             32, 16, 16, 16 );
+     LYRA2Z( lyra2h_4way_matrix, state+64, 32, hash2, 32, hash2,
+             32, 16, 16, 16 );
+     LYRA2Z( lyra2h_4way_matrix, state+96, 32, hash3, 32, hash3,
+             32, 16, 16, 16 );
 }
 
 int scanhash_lyra2h_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done )
+                          uint64_t *hashes_done, struct thr_info *mythr )
 {
    uint32_t hash[8*4] __attribute__ ((aligned (64)));
    uint32_t vdata[20*4] __attribute__ ((aligned (64)));
-   uint32_t _ALIGN(64) edata[20];
    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;
-   uint32_t *nonces = work->nonces;
-   int num_found = 0;
-   uint32_t *noncep= vdata + 76; // 19*4
+   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
    if ( opt_benchmark )
       ptarget[7] = 0x0000ff;
 
-   for ( int i=0; i < 20; i++ )
-      be32enc( &edata[i], pdata[i] );
-
-   mm128_interleave_4x32( vdata, edata, edata, edata, edata, 640 );
-
+   mm128_bswap_intrlv80_4x32( vdata, pdata );
    lyra2h_4way_midstate( vdata );
 
    do {
-      be32enc( noncep,   n   );
-      be32enc( noncep+1, n+1 );
-      be32enc( noncep+2, n+2 );
-      be32enc( noncep+3, n+3 );
-
-      be32enc( &edata[19], n );
+     *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
       lyra2h_4way_hash( hash, vdata );
 
       for ( int i = 0; i < 4; i++ )
-      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget ) )
+      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget )
+           && !opt_benchmark )
       {
           pdata[19] = n+i;         
-          nonces[ num_found++ ] = n+i;
-          work_set_target_ratio( work, hash+(i<<3) );
+          submit_solution( work, hash+(i<<3), mythr, i );
       }
       n += 4;
-   } while ( (num_found == 0) && (n < max_nonce-4)
-                   && !work_restart[thr_id].restart);
+   } while (  (n < max_nonce-4) && !work_restart[thr_id].restart);
 
    *hashes_done = n - first_nonce + 1;
-   return num_found;
+   return 0;
 }
 
 #endif

algo/lyra2/lyra2h.c

@@ -36,7 +36,7 @@ void lyra2h_hash( void *state, const void *input )
 }
 
 int scanhash_lyra2h( int thr_id, struct work *work, uint32_t max_nonce,
-                    uint64_t *hashes_done )
+                    uint64_t *hashes_done, struct thr_info *mythr )
 {
 	uint32_t _ALIGN(64) hash[8];
 	uint32_t _ALIGN(64) endiandata[20];
@@ -45,6 +45,7 @@ int scanhash_lyra2h( int thr_id, struct work *work, uint32_t max_nonce,
 	const uint32_t Htarg = ptarget[7];
 	const uint32_t first_nonce = pdata[19];
 	uint32_t nonce = first_nonce;
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
 	if (opt_benchmark)
 		ptarget[7] = 0x0000ff;

algo/lyra2/lyra2re.c

@@ -6,7 +6,7 @@
 #include "algo/keccak/sph_keccak.h"
 #include "lyra2.h"
 #include "algo-gate-api.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 #if defined(__AES__)
   #include "algo/groestl/aes_ni/hash-groestl256.h"
 #endif
@@ -81,8 +81,8 @@ void lyra2re_hash(void *state, const void *input)
 	memcpy(state, hashA, 32);
 }
 
-int scanhash_lyra2re(int thr_id, struct work *work,
-	uint32_t max_nonce,	uint64_t *hashes_done)
+int scanhash_lyra2re( int thr_id, struct work *work, uint32_t max_nonce,
+	              uint64_t *hashes_done, struct thr_info *mythr )
 {
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
@@ -91,6 +91,7 @@ int scanhash_lyra2re(int thr_id, struct work *work,
 	const uint32_t first_nonce = pdata[19];
 	uint32_t nonce = first_nonce;
         const uint32_t Htarg = ptarget[7];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
         swab32_array( endiandata, pdata, 20 );
 

algo/lyra2/lyra2rev2-4way.c

@@ -42,10 +42,12 @@ void lyra2rev2_4way_hash( void *state, const void *input )
    blake256_4way( &ctx.blake, input + (64<<2), 16 );
    blake256_4way_close( &ctx.blake, vhash );
 
-   mm256_reinterleave_4x64( vhash64, vhash, 256 );
+   mm256_rintrlv_4x32_4x64( vhash64, vhash, 256 );
+
    keccak256_4way( &ctx.keccak, vhash64, 32 );
    keccak256_4way_close( &ctx.keccak, vhash64 );
-   mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
+
+   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
 
    cubehashUpdateDigest( &ctx.cube, (byte*) hash0, (const byte*) hash0, 32 );
    cubehashInit( &ctx.cube, 256, 16, 32 );
@@ -60,10 +62,12 @@ void lyra2rev2_4way_hash( void *state, const void *input )
    LYRA2REV2( l2v2_wholeMatrix, hash2, 32, hash2, 32, hash2, 32, 1, 4, 4 );
    LYRA2REV2( l2v2_wholeMatrix, hash3, 32, hash3, 32, hash3, 32, 1, 4, 4 );
 
-   mm256_interleave_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );
+   mm256_intrlv_4x64( vhash64, hash0, hash1, hash2, hash3, 256 );
+
    skein256_4way( &ctx.skein, vhash64, 32 );
    skein256_4way_close( &ctx.skein, vhash64 );
-   mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
+
+   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 256 );
 
    cubehashInit( &ctx.cube, 256, 16, 32 );
    cubehashUpdateDigest( &ctx.cube, (byte*) hash0, (const byte*) hash0, 32 );
@@ -74,60 +78,55 @@ void lyra2rev2_4way_hash( void *state, const void *input )
    cubehashInit( &ctx.cube, 256, 16, 32 );
    cubehashUpdateDigest( &ctx.cube, (byte*) hash3, (const byte*) hash3, 32 );
 
-   mm128_interleave_4x32( vhash, hash0, hash1, hash2, hash3, 256 );
-   bmw256_4way( &ctx.bmw, vhash, 32 );
-   bmw256_4way_close( &ctx.bmw, vhash );
+   mm128_intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 256 );
 
-   mm128_deinterleave_4x32( state, state+32, state+64, state+96, vhash, 256 );
+   bmw256_4way( &ctx.bmw, vhash, 32 );
+   bmw256_4way_close( &ctx.bmw, state );
 }
 
 int scanhash_lyra2rev2_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                             uint64_t *hashes_done )
+                             uint64_t *hashes_done, struct thr_info *mythr )
 {
    uint32_t hash[8*4] __attribute__ ((aligned (64)));
    uint32_t vdata[20*4] __attribute__ ((aligned (64)));
-   uint32_t _ALIGN(64) edata[20];
+   uint32_t *hash7 = &(hash[7<<2]);
+   uint32_t lane_hash[8];
    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
    const uint32_t first_nonce = pdata[19];
    uint32_t n = first_nonce;
    const uint32_t Htarg = ptarget[7];
-   uint32_t *nonces = work->nonces;
-   int num_found = 0;
-   uint32_t *noncep = vdata + 76; // 19*4
+   __m128i *noncev = (__m128i*)vdata + 19;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
    if ( opt_benchmark )
       ( (uint32_t*)ptarget )[7] = 0x0000ff;
 
-   swab32_array( edata, pdata, 20 );
-
-   mm128_interleave_4x32( vdata, edata, edata, edata, edata, 640 );
+   mm128_bswap_intrlv80_4x32( vdata, pdata );
 
    blake256_4way_init( &l2v2_4way_ctx.blake );
    blake256_4way( &l2v2_4way_ctx.blake, vdata, 64 );
 
-   do {
-      be32enc( noncep,   n   );
-      be32enc( noncep+1, n+1 );
-      be32enc( noncep+2, n+2 );
-      be32enc( noncep+3, n+3 );
+   do
+   {
+      *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
 
       lyra2rev2_4way_hash( hash, vdata );
       pdata[19] = n;
 
-      for ( int i = 0; i < 4; i++ )
-      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget ) )
+      for ( int lane = 0; lane < 4; lane++ ) if ( hash7[lane] <= Htarg )
       {
-          pdata[19] = n+i;         
-          nonces[ num_found++ ] = n+i;
-          work_set_target_ratio( work, hash+(i<<3) );
+         mm128_extract_lane_4x32( lane_hash, hash, lane, 256 );
+         if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+         {
+            pdata[19] = n + lane;         
+            submit_solution( work, lane_hash, mythr, lane );
+         }
       }
       n += 4;
-   } while ( (num_found == 0) && (n < max_nonce-4)
-                   && !work_restart[thr_id].restart);
-
+   } while ( (n < max_nonce-4) && !work_restart[thr_id].restart);
    *hashes_done = n - first_nonce + 1;
-   return num_found;
+   return 0;
 }
 
 #endif

algo/lyra2/lyra2rev2.c

@@ -73,7 +73,7 @@ void lyra2rev2_hash( void *state, const void *input )
 }
 
 int scanhash_lyra2rev2(int thr_id, struct work *work,
-	uint32_t max_nonce, uint64_t *hashes_done)
+	uint32_t max_nonce, uint64_t *hashes_done, struct thr_info *mythr)
 {
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
@@ -82,6 +82,7 @@ int scanhash_lyra2rev2(int thr_id, struct work *work,
 	const uint32_t first_nonce = pdata[19];
 	uint32_t nonce = first_nonce;
         const uint32_t Htarg = ptarget[7];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
 	if (opt_benchmark)
 		((uint32_t*)ptarget)[7] = 0x0000ff;

algo/lyra2/lyra2rev3-4way.c

@@ -1,12 +1,138 @@
 #include "lyra2-gate.h"
 #include <memory.h>
 
-#if defined (LYRA2REV3_4WAY)	
-
 #include "algo/blake/blake-hash-4way.h"
 #include "algo/bmw/bmw-hash-4way.h"
 #include "algo/cubehash/cubehash_sse2.h" 
 
+
+#if defined (LYRA2REV3_8WAY)
+
+typedef struct {
+   blake256_8way_context     blake;
+   cubehashParam             cube;
+   bmw256_8way_context       bmw;
+} lyra2v3_8way_ctx_holder;
+
+static lyra2v3_8way_ctx_holder l2v3_8way_ctx;
+
+bool init_lyra2rev3_8way_ctx()
+{
+   blake256_8way_init( &l2v3_8way_ctx.blake );
+   cubehashInit( &l2v3_8way_ctx.cube, 256, 16, 32 );
+   bmw256_8way_init( &l2v3_8way_ctx.bmw );
+   return true;
+}
+
+void lyra2rev3_8way_hash( void *state, const void *input )
+{
+   uint32_t vhash[8*8] __attribute__ ((aligned (64)));
+   uint32_t hash0[8] __attribute__ ((aligned (64)));
+   uint32_t hash1[8] __attribute__ ((aligned (32)));
+   uint32_t hash2[8] __attribute__ ((aligned (32)));
+   uint32_t hash3[8] __attribute__ ((aligned (32)));
+   uint32_t hash4[8] __attribute__ ((aligned (32)));
+   uint32_t hash5[8] __attribute__ ((aligned (32)));
+   uint32_t hash6[8] __attribute__ ((aligned (32)));
+   uint32_t hash7[8] __attribute__ ((aligned (32)));
+   lyra2v3_8way_ctx_holder ctx __attribute__ ((aligned (64)));
+   memcpy( &ctx, &l2v3_8way_ctx, sizeof(l2v3_8way_ctx) );
+
+   blake256_8way( &ctx.blake, input, 80 );
+   blake256_8way_close( &ctx.blake, vhash );
+
+   mm256_dintrlv_8x32( hash0, hash1, hash2, hash3,
+                       hash4, hash5, hash6, hash7, vhash, 256 );
+
+   LYRA2REV3( l2v3_wholeMatrix, hash0, 32, hash0, 32, hash0, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash1, 32, hash1, 32, hash1, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash2, 32, hash2, 32, hash2, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash3, 32, hash3, 32, hash3, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash4, 32, hash4, 32, hash4, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash5, 32, hash5, 32, hash5, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash6, 32, hash6, 32, hash6, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash7, 32, hash7, 32, hash7, 32, 1, 4, 4 );
+
+   cubehashUpdateDigest( &ctx.cube, (byte*) hash0, (const byte*) hash0, 32 );
+   cubehashInit( &ctx.cube, 256, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*) hash1, (const byte*) hash1, 32 );
+   cubehashInit( &ctx.cube, 256, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*) hash2, (const byte*) hash2, 32 );
+   cubehashInit( &ctx.cube, 256, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*) hash3, (const byte*) hash3, 32 );
+   cubehashInit( &ctx.cube, 256, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*) hash4, (const byte*) hash4, 32 );
+   cubehashInit( &ctx.cube, 256, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*) hash5, (const byte*) hash5, 32 );
+   cubehashInit( &ctx.cube, 256, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*) hash6, (const byte*) hash6, 32 );
+   cubehashInit( &ctx.cube, 256, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*) hash7, (const byte*) hash7, 32 );
+
+   LYRA2REV3( l2v3_wholeMatrix, hash0, 32, hash0, 32, hash0, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash1, 32, hash1, 32, hash1, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash2, 32, hash2, 32, hash2, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash3, 32, hash3, 32, hash3, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash4, 32, hash4, 32, hash4, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash5, 32, hash5, 32, hash5, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash6, 32, hash6, 32, hash6, 32, 1, 4, 4 );
+   LYRA2REV3( l2v3_wholeMatrix, hash7, 32, hash7, 32, hash7, 32, 1, 4, 4 );
+
+   mm256_intrlv_8x32( vhash, hash0, hash1, hash2, hash3,
+                             hash4, hash5, hash6, hash7, 256 );
+
+   bmw256_8way( &ctx.bmw, vhash, 32 );
+   bmw256_8way_close( &ctx.bmw, state );
+
+   }
+
+int scanhash_lyra2rev3_8way( int thr_id, struct work *work, uint32_t max_nonce,
+                             uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash[8*8] __attribute__ ((aligned (64)));
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[7<<3]);
+   uint32_t lane_hash[8];
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   uint32_t n = first_nonce;
+   const uint32_t Htarg = ptarget[7];
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
+
+   if ( opt_benchmark )
+      ( (uint32_t*)ptarget )[7] = 0x0000ff;
+
+   mm256_bswap_intrlv80_8x32( vdata, pdata );
+   do
+   {
+      *noncev = mm256_bswap_32( _mm256_set_epi32( n+7, n+6, n+5, n+4,
+                                                  n+3, n+2, n+1, n ) );
+
+      lyra2rev3_8way_hash( hash, vdata );
+      pdata[19] = n;
+
+      for ( int lane = 0; lane < 8; lane++ ) if ( hash7[lane] <= Htarg )
+      {
+         mm256_extract_lane_8x32( lane_hash, hash, lane, 256 );
+         if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+         {
+              pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr, lane );
+         }
+      }
+      n += 8;
+   } while ( (n < max_nonce-8) && !work_restart[thr_id].restart);
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#endif
+
+#if defined (LYRA2REV3_4WAY)  
+
+
 typedef struct {
    blake256_4way_context     blake;
    cubehashParam             cube;
@@ -35,7 +161,7 @@ void lyra2rev3_4way_hash( void *state, const void *input )
 
    blake256_4way( &ctx.blake, input, 80 );
    blake256_4way_close( &ctx.blake, vhash );
-   mm128_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash, 256 );
+   mm128_dintrlv_4x32( hash0, hash1, hash2, hash3, vhash, 256 );
 
    LYRA2REV3( l2v3_wholeMatrix, hash0, 32, hash0, 32, hash0, 32, 1, 4, 4 );
    LYRA2REV3( l2v3_wholeMatrix, hash1, 32, hash1, 32, hash1, 32, 1, 4, 4 );
@@ -55,10 +181,9 @@ void lyra2rev3_4way_hash( void *state, const void *input )
    LYRA2REV3( l2v3_wholeMatrix, hash2, 32, hash2, 32, hash2, 32, 1, 4, 4 );
    LYRA2REV3( l2v3_wholeMatrix, hash3, 32, hash3, 32, hash3, 32, 1, 4, 4 );
 
-   mm128_interleave_4x32( vhash, hash0, hash1, hash2, hash3, 256 );
+   mm128_intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 256 );
    bmw256_4way( &ctx.bmw, vhash, 32 );
    bmw256_4way_close( &ctx.bmw, state );
-
 }
 
 int scanhash_lyra2rev3_4way( int thr_id, struct work *work, uint32_t max_nonce,
@@ -66,7 +191,6 @@ int scanhash_lyra2rev3_4way( int thr_id, struct work *work, uint32_t max_nonce,
 {
    uint32_t hash[8*4] __attribute__ ((aligned (64)));
    uint32_t vdata[20*4] __attribute__ ((aligned (64)));
-   uint32_t edata[20] __attribute__ ((aligned (64)));
    uint32_t *hash7 = &(hash[7<<2]);
    uint32_t lane_hash[8];
    uint32_t *pdata = work->data;
@@ -74,22 +198,13 @@ int scanhash_lyra2rev3_4way( int thr_id, struct work *work, uint32_t max_nonce,
    const uint32_t first_nonce = pdata[19];
    uint32_t n = first_nonce;
    const uint32_t Htarg = ptarget[7];
-   int num_found = 0;
    __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
    /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
    
    if ( opt_benchmark )
       ( (uint32_t*)ptarget )[7] = 0x0000ff;
 
-   // Need big endian data
-   casti_m128i( edata, 0 ) = mm128_bswap_32( casti_m128i( pdata, 0 ) );
-   casti_m128i( edata, 1 ) = mm128_bswap_32( casti_m128i( pdata, 1 ) );
-   casti_m128i( edata, 2 ) = mm128_bswap_32( casti_m128i( pdata, 2 ) );
-   casti_m128i( edata, 3 ) = mm128_bswap_32( casti_m128i( pdata, 3 ) );
-   casti_m128i( edata, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
-
-   mm128_interleave_4x32( vdata, edata, edata, edata, edata, 640 );
-
+   mm128_bswap_intrlv80_4x32( vdata, pdata );
    do
    {
       *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
@@ -100,22 +215,14 @@ int scanhash_lyra2rev3_4way( int thr_id, struct work *work, uint32_t max_nonce,
       for ( int lane = 0; lane < 4; lane++ ) if ( hash7[lane] <= Htarg )
       {
          mm128_extract_lane_4x32( lane_hash, hash, lane, 256 );
-
-         if ( fulltest( lane_hash, ptarget ) )
+         if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
          {
               pdata[19] = n + lane;    
-              work_set_target_ratio( work, lane_hash );
-              if ( submit_work( mythr, work ) )
-                applog( LOG_NOTICE, "Share %d submitted by thread %d, lane %d.",
-		             accepted_share_count + rejected_share_count + 1,
-			     thr_id, lane );
-              else
-                applog( LOG_WARNING, "Failed to submit share." );
-	 }
+              submit_solution( work, lane_hash, mythr, lane );
+	      }
       }
       n += 4;
    } while ( (n < max_nonce-4) && !work_restart[thr_id].restart);
-
    *hashes_done = n - first_nonce + 1;
    return 0;
 }

algo/lyra2/lyra2z-4way.c

@@ -36,66 +36,51 @@ void lyra2z_4way_hash( void *state, const void *input )
      blake256_4way( &ctx_blake, input + (64*4), 16 );
      blake256_4way_close( &ctx_blake, vhash );
 
-     mm128_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash, 256 );
+     mm128_dintrlv_4x32( hash0, hash1, hash2, hash3, vhash, 256 );
 
-     LYRA2Z( lyra2z_4way_matrix, hash0, 32, hash0, 32, hash0, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_4way_matrix, hash1, 32, hash1, 32, hash1, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_4way_matrix, hash2, 32, hash2, 32, hash2, 32, 8, 8, 8 );
-     LYRA2Z( lyra2z_4way_matrix, hash3, 32, hash3, 32, hash3, 32, 8, 8, 8 );
-
-     memcpy( state,    hash0, 32 );
-     memcpy( state+32, hash1, 32 );
-     memcpy( state+64, hash2, 32 );
-     memcpy( state+96, hash3, 32 );
+     LYRA2Z( lyra2z_4way_matrix, state   , 32, hash0, 32, hash0, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_4way_matrix, state+32, 32, hash1, 32, hash1, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_4way_matrix, state+64, 32, hash2, 32, hash2, 32, 8, 8, 8 );
+     LYRA2Z( lyra2z_4way_matrix, state+96, 32, hash3, 32, hash3, 32, 8, 8, 8 );
 }
 
 int scanhash_lyra2z_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done )
+                          uint64_t *hashes_done, struct thr_info *mythr )
 {
    uint32_t hash[8*4] __attribute__ ((aligned (64)));
    uint32_t vdata[20*4] __attribute__ ((aligned (64)));
-   uint32_t _ALIGN(64) edata[20];
    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;
-   uint32_t *nonces = work->nonces;
-   int num_found = 0;
-   uint32_t *noncep = vdata + 76; // 19*4
+   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
    if ( opt_benchmark )
       ptarget[7] = 0x0000ff;
 
-   for ( int i=0; i < 20; i++ )
-      be32enc( &edata[i], pdata[i] );
-
-   mm128_interleave_4x32( vdata, edata, edata, edata, edata, 640 );
-
+   mm128_bswap_intrlv80_4x32( vdata, pdata );
    lyra2z_4way_midstate( vdata );
 
    do {
-      be32enc( noncep,   n   );
-      be32enc( noncep+1, n+1 );
-      be32enc( noncep+2, n+2 );
-      be32enc( noncep+3, n+3 );
+      *noncev = mm128_bswap_32( _mm_set_epi32( n+3, n+2, n+1, n ) );
 
       lyra2z_4way_hash( hash, vdata );
       pdata[19] = n;
 
       for ( int i = 0; i < 4; i++ )
-      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget ) )
+      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget )
+           && !opt_benchmark )
       {
           pdata[19] = n+i;         
-          nonces[ num_found++ ] = n+i;
-          work_set_target_ratio( work, hash+(i<<3) );
+          submit_solution( work, hash+(i<<3), mythr, i );
       }
       n += 4;
-   } while ( (num_found == 0) && (n < max_nonce-4)
-                   && !work_restart[thr_id].restart);
+   } while ( (n < max_nonce-4) && !work_restart[thr_id].restart);
 
    *hashes_done = n - first_nonce + 1;
-   return num_found;
+   return 0;
 }
 
 #endif
@@ -134,8 +119,8 @@ void lyra2z_8way_hash( void *state, const void *input )
      blake256_8way( &ctx_blake, input + (64*8), 16 );
      blake256_8way_close( &ctx_blake, vhash );
 
-     mm256_deinterleave_8x32( hash0, hash1, hash2, hash3,
-                              hash4, hash5, hash6, hash7, vhash, 256 );
+     mm256_dintrlv_8x32( hash0, hash1, hash2, hash3,
+                         hash4, hash5, hash6, hash7, vhash, 256 );
 
      LYRA2Z( lyra2z_8way_matrix, hash0, 32, hash0, 32, hash0, 32, 8, 8, 8 );
      LYRA2Z( lyra2z_8way_matrix, hash1, 32, hash1, 32, hash1, 32, 8, 8, 8 );
@@ -150,64 +135,49 @@ void lyra2z_8way_hash( void *state, const void *input )
      memcpy( state+ 32, hash1, 32 );
      memcpy( state+ 64, hash2, 32 );
      memcpy( state+ 96, hash3, 32 );
-     memcpy( state+128, hash1, 32 );
-     memcpy( state+160, hash2, 32 );
-     memcpy( state+192, hash3, 32 );
-     memcpy( state+224, hash1, 32 );
+     memcpy( state+128, hash4, 32 );
+     memcpy( state+160, hash5, 32 );
+     memcpy( state+192, hash6, 32 );
+     memcpy( state+224, hash7, 32 );
 }
 
 int scanhash_lyra2z_8way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done )
+                          uint64_t *hashes_done, struct thr_info *mythr )
 {
    uint32_t hash[8*8] __attribute__ ((aligned (64)));
    uint32_t vdata[20*8] __attribute__ ((aligned (64)));
-   uint32_t _ALIGN(64) edata[20];
    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;
-   uint32_t *nonces = work->nonces;
-   int num_found = 0;
-   uint32_t *noncep = vdata + 152; // 19*8
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
    if ( opt_benchmark )
       ptarget[7] = 0x0000ff;
 
-   for ( int i=0; i < 19; i++ )
-      be32enc( &edata[i], pdata[i] );
-
-   mm256_interleave_8x32( vdata, edata, edata, edata, edata,
-                                 edata, edata, edata, edata, 640 );
-
+   mm256_bswap_intrlv80_8x32( vdata, pdata );
    lyra2z_8way_midstate( vdata );
 
    do {
-      be32enc( noncep,   n   );
-      be32enc( noncep+1, n+1 );
-      be32enc( noncep+2, n+2 );
-      be32enc( noncep+3, n+3 );
-      be32enc( noncep+4, n+4 );
-      be32enc( noncep+5, n+5 );
-      be32enc( noncep+6, n+6 );
-      be32enc( noncep+7, n+7 );
-
+      *noncev = mm256_bswap_32(
+                 _mm256_set_epi32( n+7, n+6, n+5, n+4, n+3, n+2, n+1, n ) );
       lyra2z_8way_hash( hash, vdata );
       pdata[19] = n;
 
       for ( int i = 0; i < 8; i++ )
-      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget ) )
+      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget )
+           && !opt_benchmark )
       {
           pdata[19] = n+i;         
-          nonces[ num_found++ ] = n+i;
-          work_set_target_ratio( work, hash+(i<<3) );
+          submit_solution( work, hash+(i<<3), mythr, i );
       }
       n += 8;
-   } while ( (num_found == 0) && (n < max_nonce-4)
-                   && !work_restart[thr_id].restart);
+   } while ( (n < max_nonce-8) && !work_restart[thr_id].restart);
 
    *hashes_done = n - first_nonce + 1;
-   return num_found;
+   return 0;
 }
 
 

algo/lyra2/lyra2z.c

@@ -3,7 +3,7 @@
 #include "lyra2-gate.h"
 #include "lyra2.h"
 #include "algo/blake/sph_blake.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 __thread uint64_t* lyra2z_matrix;
 
@@ -44,7 +44,7 @@ void lyra2z_hash( void *state, const void *input )
 }
 
 int scanhash_lyra2z( int thr_id, struct work *work, uint32_t max_nonce,
-                    uint64_t *hashes_done )
+                    uint64_t *hashes_done, struct thr_info *mythr )
 {
 	uint32_t _ALIGN(64) hash[8];
 	uint32_t _ALIGN(64) endiandata[20];
@@ -53,6 +53,7 @@ int scanhash_lyra2z( int thr_id, struct work *work, uint32_t max_nonce,
 	const uint32_t Htarg = ptarget[7];
 	const uint32_t first_nonce = pdata[19];
 	uint32_t nonce = first_nonce;
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
 	if (opt_benchmark)
 		ptarget[7] = 0x0000ff;

algo/lyra2/lyra2z330.c

@@ -1,7 +1,7 @@
 #include <memory.h>
 #include "algo-gate-api.h"
 #include "lyra2.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 __thread uint64_t* lyra2z330_wholeMatrix;
 
@@ -16,39 +16,46 @@ void lyra2z330_hash(void *state, const void *input, uint32_t height)
 }
 
 int scanhash_lyra2z330( int thr_id, struct work *work, uint32_t max_nonce,
-                        uint64_t *hashes_done )
+                        uint64_t *hashes_done, struct thr_info *mythr )
 {
-	uint32_t hash[8] __attribute__ ((aligned (64))); 
-	uint32_t endiandata[20] __attribute__ ((aligned (64)));
-	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 nonce = first_nonce;
-	if (opt_benchmark)
-		ptarget[7] = 0x0000ff;
+   uint32_t hash[8] __attribute__ ((aligned (64))); 
+   uint32_t endiandata[20] __attribute__ ((aligned (64)));
+   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 nonce = first_nonce;
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
-	for (int i=0; i < 19; i++) {
-		be32enc(&endiandata[i], pdata[i]);
-	}
+   if (opt_benchmark)
+	ptarget[7] = 0x0000ff;
 
-	do {
-		be32enc(&endiandata[19], nonce);
-		lyra2z330_hash( hash, endiandata, work->height );
-
-		if (hash[7] <= Htarg && fulltest(hash, ptarget)) {
-			work_set_target_ratio(work, hash);
-			pdata[19] = nonce;
-			*hashes_done = pdata[19] - first_nonce;
-			return 1;
-		}
-		nonce++;
-
-	} while (nonce < max_nonce && !work_restart[thr_id].restart);
-
-	pdata[19] = nonce;
-	*hashes_done = pdata[19] - first_nonce + 1;
-	return 0;
+   casti_m128i( endiandata, 0 ) = mm128_bswap_32( casti_m128i( pdata, 0 ) );
+   casti_m128i( endiandata, 1 ) = mm128_bswap_32( casti_m128i( pdata, 1 ) );
+   casti_m128i( endiandata, 2 ) = mm128_bswap_32( casti_m128i( pdata, 2 ) );
+   casti_m128i( endiandata, 3 ) = mm128_bswap_32( casti_m128i( pdata, 3 ) );
+   casti_m128i( endiandata, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
+   
+   do
+   {
+      be32enc(&endiandata[19], nonce);
+      lyra2z330_hash( hash, endiandata, work->height );
+      if ( hash[7] <= Htarg && fulltest(hash, ptarget) && !opt_benchmark )
+      {
+         work_set_target_ratio(work, hash);
+         pdata[19] = nonce;
+         if ( submit_work( mythr, work ) )
+             applog( LOG_NOTICE, "Share %d submitted by thread %d",
+                     accepted_share_count + rejected_share_count + 1,
+                     mythr->id );
+         else
+             applog( LOG_WARNING, "Failed to submit share." );
+      }
+      nonce++;
+   } while (nonce < max_nonce && !work_restart[thr_id].restart);
+   pdata[19] = nonce;
+   *hashes_done = pdata[19] - first_nonce + 1;
+   return 0;
 }
 
 void lyra2z330_set_target( struct work* work, double job_diff )

algo/lyra2/phi2-4way.c

@@ -0,0 +1,233 @@
+/**
+ * Phi-2 algo Implementation
+ */
+
+#include "lyra2-gate.h"
+
+#if defined(PHI2_4WAY)
+
+#include "algo/skein/skein-hash-4way.h"
+#include "algo/jh/jh-hash-4way.h"
+#include "algo/gost/sph_gost.h"
+#include "algo/cubehash/cubehash_sse2.h"
+#include "algo/echo/aes_ni/hash_api.h"
+
+typedef struct {
+     cubehashParam           cube;
+     jh512_4way_context      jh;
+     hashState_echo          echo;
+//     hashState_echo          echo2;
+     sph_gost512_context     gost;
+     skein512_4way_context   skein;
+} phi2_ctx_holder;
+/*
+phi2_ctx_holder phi2_ctx;
+
+void init_phi2_ctx()
+{
+   cubehashInit( &phi2_ctx.cube, 512, 16, 32 );
+   sph_jh512_init(&phi2_ctx.jh);
+   init_echo( &phi2_ctx.echo1, 512 );
+   init_echo( &phi2_ctx.echo2, 512 );
+   sph_gost512_init(&phi2_ctx.gost);
+   sph_skein512_init(&phi2_ctx.skein);
+};
+*/
+void phi2_hash_4way( void *state, const void *input )
+{
+   uint32_t hash[4][16] __attribute__ ((aligned (64)));
+   uint32_t hashA[4][16] __attribute__ ((aligned (64)));
+   uint32_t hashB[4][16] __attribute__ ((aligned (64)));
+   uint32_t vhash[4*16] __attribute__ ((aligned (64)));
+
+//   unsigned char _ALIGN(128) hash[64];
+//	unsigned char _ALIGN(128) hashA[64];
+//	unsigned char _ALIGN(128) hashB[64];
+
+   phi2_ctx_holder ctx __attribute__ ((aligned (64)));
+//  memcpy( &ctx, &phi2_ctx, sizeof(phi2_ctx) );
+
+   cubehashInit( &ctx.cube, 512, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*)hashB[0], (const byte*)input,
+                        phi2_has_roots ? 144 : 80 );
+   cubehashInit( &ctx.cube, 512, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*)hashB[1], (const byte*)input+144,
+                        phi2_has_roots ? 144 : 80 );
+   cubehashInit( &ctx.cube, 512, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*)hashB[2], (const byte*)input+288,
+                        phi2_has_roots ? 144 : 80 );
+   cubehashInit( &ctx.cube, 512, 16, 32 );
+   cubehashUpdateDigest( &ctx.cube, (byte*)hashB[3], (const byte*)input+432,
+                        phi2_has_roots ? 144 : 80 );
+
+	LYRA2RE( &hashA[0][0], 32, &hashB[0][0], 32, &hashB[0][0], 32, 1, 8, 8 );
+	LYRA2RE( &hashA[0][8], 32, &hashB[0][8], 32, &hashB[0][8], 32, 1, 8, 8 );
+   LYRA2RE( &hashA[1][0], 32, &hashB[1][0], 32, &hashB[1][0], 32, 1, 8, 8 );
+   LYRA2RE( &hashA[1][8], 32, &hashB[1][8], 32, &hashB[1][8], 32, 1, 8, 8 );
+   LYRA2RE( &hashA[2][0], 32, &hashB[2][0], 32, &hashB[2][0], 32, 1, 8, 8 );
+   LYRA2RE( &hashA[2][8], 32, &hashB[2][8], 32, &hashB[2][8], 32, 1, 8, 8 );
+   LYRA2RE( &hashA[3][0], 32, &hashB[3][0], 32, &hashB[3][0], 32, 1, 8, 8 );
+   LYRA2RE( &hashA[3][8], 32, &hashB[3][8], 32, &hashB[3][8], 32, 1, 8, 8 );
+
+   mm256_intrlv_4x64( vhash, hashA[0], hashA[1], hashA[2], hashA[3], 512 );
+
+   jh512_4way_init( &ctx.jh );
+   jh512_4way( &ctx.jh, vhash, 64 );
+   jh512_4way_close( &ctx.jh, vhash );
+
+   mm256_dintrlv_4x64( hash[0], hash[1], hash[2], hash[3], vhash, 512 );
+
+   if ( hash[0][0] & 1 )
+  	{
+      sph_gost512_init( &ctx.gost );
+      sph_gost512( &ctx.gost, (const void*)hash[0], 64 );
+	   sph_gost512_close( &ctx.gost, (void*)hash[0] );
+	}
+  	else
+  	{
+      init_echo( &ctx.echo, 512 );
+      update_final_echo ( &ctx.echo, (BitSequence *)hash[0],
+                          (const BitSequence *)hash[0], 512 );
+      init_echo( &ctx.echo, 512 );
+      update_final_echo ( &ctx.echo, (BitSequence *)hash[0],
+                          (const BitSequence *)hash[0], 512 );
+	}
+
+   if ( hash[1][0] & 1 )
+   {
+      sph_gost512_init( &ctx.gost );
+      sph_gost512( &ctx.gost, (const void*)hash[1], 64 );
+      sph_gost512_close( &ctx.gost, (void*)hash[1] );
+   }
+   else
+   {
+      init_echo( &ctx.echo, 512 );
+      update_final_echo ( &ctx.echo, (BitSequence *)hash[1],
+                          (const BitSequence *)hash[1], 512 );
+      init_echo( &ctx.echo, 512 );
+      update_final_echo ( &ctx.echo, (BitSequence *)hash[1],
+                          (const BitSequence *)hash[1], 512 );
+   }
+
+   if ( hash[2][0] & 1 )
+   {
+      sph_gost512_init( &ctx.gost );
+      sph_gost512( &ctx.gost, (const void*)hash[2], 64 );
+      sph_gost512_close( &ctx.gost, (void*)hash[2] );
+   }
+   else
+   {
+      init_echo( &ctx.echo, 512 );
+      update_final_echo ( &ctx.echo, (BitSequence *)hash[2],
+                          (const BitSequence *)hash[2], 512 );
+      init_echo( &ctx.echo, 512 );
+      update_final_echo ( &ctx.echo, (BitSequence *)hash[2],
+                          (const BitSequence *)hash[2], 512 );
+   }
+
+   if ( hash[3][0] & 1 )
+   {
+      sph_gost512_init( &ctx.gost );
+      sph_gost512( &ctx.gost, (const void*)hash[3], 64 );
+      sph_gost512_close( &ctx.gost, (void*)hash[3] );
+   }
+   else
+   {
+      init_echo( &ctx.echo, 512 );
+      update_final_echo ( &ctx.echo, (BitSequence *)hash[3],
+                          (const BitSequence *)hash[3], 512 );
+      init_echo( &ctx.echo, 512 );
+      update_final_echo ( &ctx.echo, (BitSequence *)hash[3],
+                          (const BitSequence *)hash[3], 512 );
+   }
+
+   mm256_intrlv_4x64( vhash, hash[0], hash[1], hash[2], hash[3], 512 );
+   
+   skein512_4way_init( &ctx.skein );
+	skein512_4way( &ctx.skein, vhash, 64 );
+	skein512_4way_close( &ctx.skein, vhash );
+
+   for (int i=0; i<4; i++)
+   {
+      ( (uint64_t*)vhash    )[i] ^= ( (uint64_t*)vhash    )[i+4];
+      ( (uint64_t*)vhash+ 8 )[i] ^= ( (uint64_t*)vhash+ 8 )[i+4];
+      ( (uint64_t*)vhash+16 )[i] ^= ( (uint64_t*)vhash+16 )[i+4];
+      ( (uint64_t*)vhash+24 )[i] ^= ( (uint64_t*)vhash+24 )[i+4];
+   }
+//   for ( int i = 0; i < 4; i++ )
+//      casti_m256i( vhash, i ) = _mm256_xor_si256( casti_m256i( vhash, i   ),
+//                                                  casti_m256i( vhash, i+4 ) );
+
+	memcpy( state, vhash, 128 );
+}
+
+int scanhash_phi2_4way( int thr_id, struct work *work, uint32_t max_nonce,
+	                     uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t _ALIGN(128) hash[8];
+   uint32_t _ALIGN(128) edata[36];
+   uint32_t vdata[4][36] __attribute__ ((aligned (64)));
+   uint32_t *hash7 = &(hash[25]);
+   uint32_t lane_hash[8];
+   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;
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
+
+   if(opt_benchmark){
+   	ptarget[7] = 0x00ff;
+   }
+
+// Data is not interleaved, but hash is.
+// any non-zero data at index 20 or above sets roots true.
+// Split up the operations, bswap first, then set roots.
+
+   phi2_has_roots = false;
+   for ( int i=0; i < 36; i++ )
+   {
+   be32enc(&edata[i], pdata[i]);
+   if (i >= 20 && pdata[i]) phi2_has_roots = true;
+   }
+/*
+   casti_m256i( vdata[0], 0 ) = mm256_bswap_32( casti_m256i( pdata, 0 ) );   
+   casti_m256i( vdata[0], 1 ) = mm256_bswap_32( casti_m256i( pdata, 1 ) );
+   casti_m256i( vdata[0], 2 ) = mm256_bswap_32( casti_m256i( pdata, 2 ) );
+   casti_m256i( vdata[0], 3 ) = mm256_bswap_32( casti_m256i( pdata, 3 ) );
+   casti_m128i( vdata[0], 8 ) = mm128_bswap_32( casti_m128i( pdata, 8 ) );
+   phi2_has_roots = mm128_anybits1( casti_m128i( vdata[0], 5 ) ) ||
+                    mm128_anybits1( casti_m128i( vdata[0], 6 ) ) ||
+                    mm128_anybits1( casti_m128i( vdata[0], 7 ) ) ||
+                    mm128_anybits1( casti_m128i( vdata[0], 8 ) );
+*/   
+
+   memcpy( vdata[0], edata, 144 );
+   memcpy( vdata[1], edata, 144 );
+   memcpy( vdata[2], edata, 144 );
+   memcpy( vdata[3], edata, 144 );
+
+   do {
+      be32enc( &vdata[0][19], n );
+      be32enc( &vdata[1][19], n+1 );
+      be32enc( &vdata[2][19], n+2 );
+      be32enc( &vdata[3][19], n+3 );
+
+      phi2_hash_4way( hash, vdata );
+
+      for ( int lane = 0; lane < 4; lane++ ) if (  hash7[ lane<<1 ] < Htarg )
+      {
+          mm256_extract_lane_4x64( lane_hash, hash, lane, 256 );
+          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+          {
+              pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr, lane );
+          }
+       }
+       n += 4;
+    } while ( ( n < max_nonce - 4 ) && !work_restart[thr_id].restart );
+    *hashes_done = n - first_nonce + 1;
+    return 0;
+}
+   
+#endif  // PHI2_4WAY

algo/lyra2/phi2.c

@@ -50,11 +50,11 @@ void phi2_hash(void *state, const void *input)
 	unsigned char _ALIGN(128) hashA[64];
 	unsigned char _ALIGN(128) hashB[64];
 
-        phi2_ctx_holder ctx __attribute__ ((aligned (64)));
-        memcpy( &ctx, &phi2_ctx, sizeof(phi2_ctx) );
+  phi2_ctx_holder ctx __attribute__ ((aligned (64)));
+  memcpy( &ctx, &phi2_ctx, sizeof(phi2_ctx) );
 
-        cubehashUpdateDigest( &ctx.cube, (byte*)hashB, (const byte*)input,
-		              phi2_has_roots ? 144 : 80 );
+  cubehashUpdateDigest( &ctx.cube, (byte*)hashB, (const byte*)input,
+                        phi2_has_roots ? 144 : 80 );
 
 	LYRA2RE( &hashA[ 0], 32, &hashB[ 0], 32, &hashB[ 0], 32, 1, 8, 8 );
 	LYRA2RE( &hashA[32], 32, &hashB[32], 32, &hashB[32], 32, 1, 8, 8 );
@@ -63,17 +63,17 @@ void phi2_hash(void *state, const void *input)
 	sph_jh512_close( &ctx.jh, (void*)hash );
 
 	if ( hash[0] & 1 )
-       	{
-           sph_gost512( &ctx.gost, (const void*)hash, 64 );
+  	{
+      sph_gost512( &ctx.gost, (const void*)hash, 64 );
 	   sph_gost512_close( &ctx.gost, (void*)hash );
 	}
-       	else
-       	{
+  	else
+  	{
 #if defined(__AES__)
-           update_final_echo ( &ctx.echo1, (BitSequence *)hash,
-                               (const BitSequence *)hash, 512 );
-           update_final_echo ( &ctx.echo2, (BitSequence *)hash,
-                               (const BitSequence *)hash, 512 );
+      update_final_echo ( &ctx.echo1, (BitSequence *)hash,
+                          (const BitSequence *)hash, 512 );
+      update_final_echo ( &ctx.echo2, (BitSequence *)hash,
+                          (const BitSequence *)hash, 512 );
 #else
 	   sph_echo512( &ctx.echo1, (const void*)hash, 64 );
 	   sph_echo512_close( &ctx.echo1, (void*)hash );
@@ -92,42 +92,50 @@ void phi2_hash(void *state, const void *input)
 	memcpy(state, hash, 32);
 }
 
-int scanhash_phi2(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)
+int scanhash_phi2( int thr_id, struct work *work, uint32_t max_nonce,
+	           uint64_t *hashes_done, struct thr_info *mythr )
 {
-	uint32_t _ALIGN(128) hash[8];
-	uint32_t _ALIGN(128) endiandata[36];
-	uint32_t *pdata = work->data;
-	uint32_t *ptarget = work->target;
+   uint32_t _ALIGN(128) hash[8];
+   uint32_t _ALIGN(128) endiandata[36];
+   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;
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
-	const uint32_t Htarg = ptarget[7];
-	const uint32_t first_nonce = pdata[19];
-	uint32_t n = first_nonce;
+   if(opt_benchmark){
+   	ptarget[7] = 0x00ff;
+   }
 
-	if(opt_benchmark){
-		ptarget[7] = 0x00ff;
-	}
+   phi2_has_roots = false;
+   for ( int i=0; i < 36; i++ )
+   {
+	be32enc(&endiandata[i], pdata[i]);
+	if (i >= 20 && pdata[i]) phi2_has_roots = true;
+   }
 
-	phi2_has_roots = false;
-	for (int i=0; i < 36; i++) {
-		be32enc(&endiandata[i], pdata[i]);
-		if (i >= 20 && pdata[i]) phi2_has_roots = true;
-	}
+   do {
+	be32enc( &endiandata[19], n );
+	phi2_hash( hash, endiandata );
 
-	do {
-		be32enc(&endiandata[19], n);
-		phi2_hash(hash, endiandata);
-
-		if (hash[7] < Htarg && fulltest(hash, ptarget)) {
-			work_set_target_ratio(work, hash);
+	if ( hash[7] < Htarg && fulltest( hash, ptarget ) )
+       	{
+           pdata[19] = n;
+           work_set_target_ratio( work, hash );
+           if ( submit_work( mythr, work ) )
+               applog( LOG_NOTICE, "Share %d submitted by thread %d.",
+                            accepted_share_count + rejected_share_count + 1,
+                            thr_id );
+           else
+               applog( LOG_WARNING, "Failed to submit share." );
 			*hashes_done = n - first_nonce + 1;
-			pdata[19] = n;
-			return 1;
-		}
-		n++;
+	}
+	n++;
 
-	} while (n < max_nonce && !work_restart[thr_id].restart);
+   } while ( n < max_nonce && !work_restart[thr_id].restart );
 
-	*hashes_done = n - first_nonce + 1;
-	pdata[19] = n;
-	return 0;
+   *hashes_done = n - first_nonce + 1;
+   pdata[19] = n;
+   return 0;
 }

algo/lyra2/sponge.c

@@ -51,7 +51,7 @@ inline void initState( uint64_t State[/*16*/] )
   state[3] = _mm256_set_epi64x( blake2b_IV[7], blake2b_IV[6],
                                 blake2b_IV[5], blake2b_IV[4] );
 
-#elif defined (__SSE4_2__)
+#elif defined (__SSE2__)
 
   __m128i* state = (__m128i*)State;
 
@@ -137,7 +137,7 @@ inline void squeeze( uint64_t *State, byte *Out, unsigned int len )
     //Squeezes remaining bytes
     memcpy_256( out, state, ( len_m256i % BLOCK_LEN_M256I ) );
 
-#elif defined (__SSE4_2__)
+#elif defined (__SSE2__)
 
     const int len_m128i = len / 16;
     const int fullBlocks = len_m128i / BLOCK_LEN_M128I;
@@ -205,7 +205,7 @@ inline void absorbBlock( uint64_t *State, const uint64_t *In )
     _mm256_store_si256( (__m256i*)State + 2, state2 );
     _mm256_store_si256( (__m256i*)State + 3, state3 );
 
-#elif defined (__SSE4_2__)
+#elif defined (__SSE2__)
 
     __m128i* state = (__m128i*)State;
     __m128i* in    = (__m128i*)In;
@@ -273,7 +273,7 @@ inline void absorbBlockBlake2Safe( uint64_t *State, const uint64_t *In )
     _mm256_store_si256( (__m256i*)State + 2, state2 );
     _mm256_store_si256( (__m256i*)State + 3, state3 );
 
-#elif defined (__SSE4_2__)
+#elif defined (__SSE2__)
 
     __m128i* state = (__m128i*)State;
     __m128i* in    = (__m128i*)In;
@@ -355,7 +355,7 @@ inline void reducedSqueezeRow0( uint64_t* State, uint64_t* rowOut,
     _mm256_store_si256( (__m256i*)State + 2, state2 );
     _mm256_store_si256( (__m256i*)State + 3, state3 );
 
-#elif defined (__SSE4_2__)
+#elif defined (__SSE2__)
 
     __m128i* state = (__m128i*)State;
     __m128i  state0 = _mm_load_si128(  state    );
@@ -494,7 +494,7 @@ inline void reducedDuplexRow1( uint64_t *State, uint64_t *rowIn,
     _mm256_store_si256( (__m256i*)State + 2, state2 );
     _mm256_store_si256( (__m256i*)State + 3, state3 );
 
-#elif defined (__SSE4_2__)
+#elif defined (__SSE2__)
 
     __m128i* state = (__m128i*)State;
     __m128i  state0 = _mm_load_si128(  state    );
@@ -694,7 +694,7 @@ inline void reducedDuplexRowSetup( uint64_t *State, uint64_t *rowIn,
     _mm256_store_si256( (__m256i*)State + 2, state2 );
     _mm256_store_si256( (__m256i*)State + 3, state3 );
 
-#elif defined (__SSE4_2__)
+#elif defined (__SSE2__)
 
     __m128i* in    = (__m128i*)rowIn;
     __m128i* inout = (__m128i*)rowInOut;
@@ -713,9 +713,9 @@ inline void reducedDuplexRowSetup( uint64_t *State, uint64_t *rowIn,
     __m128i* state = (__m128i*)State;
 
     // For the last round in this function not optimized for AVX
-    uint64_t* ptrWordIn = rowIn;        //In Lyra2: pointer to prev
-    uint64_t* ptrWordInOut = rowInOut;  //In Lyra2: pointer to row*
-    uint64_t* ptrWordOut = rowOut + (nCols-1)*BLOCK_LEN_INT64; //In Lyra2: pointer to row
+//    uint64_t* ptrWordIn = rowIn;        //In Lyra2: pointer to prev
+//    uint64_t* ptrWordInOut = rowInOut;  //In Lyra2: pointer to row*
+//    uint64_t* ptrWordOut = rowOut + (nCols-1)*BLOCK_LEN_INT64; //In Lyra2: pointer to row
 
     for ( i = 0; i < nCols; i++ )
     {
@@ -750,6 +750,28 @@ inline void reducedDuplexRowSetup( uint64_t *State, uint64_t *rowIn,
         out[4] = _mm_xor_si128( state[4], in[4] );
         out[5] = _mm_xor_si128( state[5], in[5] );
 
+
+       __m128i t0, t1;
+       t0 = _mm_srli_si128( state[0], 8 );
+       t1 = _mm_srli_si128( state[1], 8 );
+       inout[0] = _mm_xor_si128( inout[0],
+                              _mm_or_si128( _mm_slli_si128( state[0], 8 ),
+                                            _mm_srli_si128( state[5], 8 ) ) );
+       inout[1] = _mm_xor_si128( inout[1],
+                        _mm_or_si128( _mm_slli_si128( state[1], 8 ), t0 ) );
+       t0 = _mm_srli_si128( state[2], 8 );
+       inout[2] = _mm_xor_si128( inout[2],
+                        _mm_or_si128( _mm_slli_si128( state[2], 8 ), t1 ) );
+       t1 = _mm_srli_si128( state[3], 8 );
+       inout[3] = _mm_xor_si128( inout[3],
+                        _mm_or_si128( _mm_slli_si128( state[3], 8 ), t0 ) );
+       t0 = _mm_srli_si128( state[4], 8 );
+       inout[4] = _mm_xor_si128( inout[4],
+                        _mm_or_si128( _mm_slli_si128( state[4], 8 ), t1 ) );
+       inout[5] = _mm_xor_si128( inout[5],
+                        _mm_or_si128( _mm_slli_si128( state[5], 8 ), t0 ) );
+
+/*
         ptrWordInOut[0]  ^= State[11];
         ptrWordInOut[1]  ^= State[0];
         ptrWordInOut[2]  ^= State[1];
@@ -768,7 +790,7 @@ inline void reducedDuplexRowSetup( uint64_t *State, uint64_t *rowIn,
         ptrWordIn += BLOCK_LEN_INT64;
         //Output: goes to previous column
         ptrWordOut -= BLOCK_LEN_INT64;
-
+*/
         inout += BLOCK_LEN_M128I;
         in    += BLOCK_LEN_M128I;
         out   -= BLOCK_LEN_M128I;
@@ -930,7 +952,7 @@ inline void reducedDuplexRow( uint64_t *State, uint64_t *rowIn,
    _mm256_store_si256( (__m256i*)State + 2, state2 );
    _mm256_store_si256( (__m256i*)State + 3, state3 );
 
-#elif defined(__SSE4_2__)
+#elif defined (__SSE2__)
 
     __m128i* state = (__m128i*)State;
     __m128i* in    = (__m128i*)rowIn;

algo/lyra2/sponge.h

@@ -23,7 +23,7 @@
 #define SPONGE_H_
 
 #include <stdint.h>
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #if defined(__GNUC__)
 #define ALIGN __attribute__ ((aligned(32)))
@@ -59,7 +59,7 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
 // returns void, updates all args
 #define G_4X64(a,b,c,d) \
    a = _mm256_add_epi64( a, b ); \
-   d = mm256_ror_64( _mm256_xor_si256( d, a), 32 ); \
+   d = mm256_ror_64( _mm256_xor_si256( d, a ), 32 ); \
    c = _mm256_add_epi64( c, d ); \
    b = mm256_ror_64( _mm256_xor_si256( b, c ), 24 ); \
    a = _mm256_add_epi64( a, b ); \
@@ -108,7 +108,7 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
 #define LYRA_ROUND_AVX(s0,s1,s2,s3,s4,s5,s6,s7) \
    G_2X64( s0, s2, s4, s6 ); \
    G_2X64( s1, s3, s5, s7 ); \
-   mm128_rol1x64_256( s2, s3 ); \
+   mm128_ror1x64_256( s2, s3 ); \
    mm128_swap128_256( s4, s5 ); \
    mm128_rol1x64_256( s6, s7 ); \
    G_2X64( s0, s2, s4, s6 ); \
@@ -132,7 +132,7 @@ static inline uint64_t rotr64( const uint64_t w, const unsigned c ){
    LYRA_ROUND_AVX(s0,s1,s2,s3,s4,s5,s6,s7) \
 
 
-#endif // AVX2
+#endif // AVX2 else SSE2
 
 // Scalar
 //Blake2b's G function

algo/m7m.c

@@ -144,8 +144,8 @@ void init_m7m_ctx()
 #define NM7M 5
 #define SW_DIVS 5
 #define M7_MIDSTATE_LEN 76
-int scanhash_m7m_hash( int thr_id, struct work* work,
-                       uint64_t max_nonce, unsigned long *hashes_done )
+int scanhash_m7m_hash( int thr_id, struct work* work, uint64_t max_nonce,
+                       unsigned long *hashes_done, struct thr_info *mythr )
 {
     uint32_t *pdata = work->data;
     uint32_t *ptarget = work->target;
@@ -154,6 +154,7 @@ int scanhash_m7m_hash( int thr_id, struct work* work,
     uint32_t hash[8] __attribute__((aligned(64)));
     uint8_t bhash[7][64] __attribute__((aligned(64)));
     uint32_t n = pdata[19] - 1;
+    /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
     uint32_t usw_, mpzscale;
     const uint32_t first_nonce = pdata[19];
     char data_str[161], hash_str[65], target_str[65];

algo/pluck.c

@@ -445,7 +445,7 @@ void pluck_hash(uint32_t *hash, const uint32_t *data, uchar *hashbuffer, const i
 }
 
 int scanhash_pluck(int thr_id, struct work *work, uint32_t max_nonce,
-        uint64_t *hashes_done  )
+        uint64_t *hashes_done, struct thr_info *mythr  )
 {
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
@@ -454,6 +454,8 @@ int scanhash_pluck(int thr_id, struct work *work, uint32_t max_nonce,
 	const uint32_t first_nonce = pdata[19];
 	volatile uint8_t *restart = &(work_restart[thr_id].restart);
 	uint32_t n = first_nonce;
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
+
 
 	if (opt_benchmark)
 		((uint32_t*)ptarget)[7] = 0x0ffff;

algo/quark/anime-4way.c

@@ -48,8 +48,8 @@ void anime_4way_hash( void *state, const void *input )
     __m256i* vhA = (__m256i*)vhashA;
     __m256i* vhB = (__m256i*)vhashB;
     __m256i vh_mask;
+    const uint32_t mask = 8;
     const __m256i bit3_mask = _mm256_set1_epi64x( 8 );
-    int i;
     anime_4way_ctx_holder ctx;
     memcpy( &ctx, &anime_4way_ctx, sizeof(anime_4way_ctx) );
 
@@ -62,27 +62,44 @@ void anime_4way_hash( void *state, const void *input )
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ),
                                   m256_zero );
 
-    mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
-    update_and_final_groestl( &ctx.groestl, (char*)hash0,
-                                            (char*)hash0, 512 );
-    reinit_groestl( &ctx.groestl );
-    update_and_final_groestl( &ctx.groestl, (char*)hash1,
-                                            (char*)hash1, 512 );
-    reinit_groestl( &ctx.groestl );
-    update_and_final_groestl( &ctx.groestl, (char*)hash2,
-                                            (char*)hash2, 512 );
-    reinit_groestl( &ctx.groestl );
-    update_and_final_groestl( &ctx.groestl, (char*)hash3,
-                                            (char*)hash3, 512 );
-    mm256_interleave_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
+    mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
-    skein512_4way( &ctx.skein, vhash, 64 );
-    skein512_4way_close( &ctx.skein, vhashB );
+    if ( hash0[0] & mask )
+    {
+       update_and_final_groestl( &ctx.groestl, (char*)hash0,
+                                               (char*)hash0, 512 );
+    }
+    if ( hash1[0] & mask )
+    {
+       reinit_groestl( &ctx.groestl );
+       update_and_final_groestl( &ctx.groestl, (char*)hash1,
+                                               (char*)hash1, 512 );
+    }
+    if ( hash2[0] & mask )
+    {
+       reinit_groestl( &ctx.groestl );
+       update_and_final_groestl( &ctx.groestl, (char*)hash2,
+                                               (char*)hash2, 512 );
+    }
+    if ( hash3[0] & mask )
+    {
+       reinit_groestl( &ctx.groestl );
+       update_and_final_groestl( &ctx.groestl, (char*)hash3,
+                                               (char*)hash3, 512 );
+    }
 
-    for ( i = 0; i < 8; i++ )
-       vh[i] = _mm256_blendv_epi8( vhA[i], vhB[i], vh_mask );
+    mm256_intrlv_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
+
+    if ( mm256_anybits0( vh_mask ) )
+    {
+       skein512_4way( &ctx.skein, vhash, 64 );
+       skein512_4way_close( &ctx.skein, vhashB );
+    }
+
+    mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
+
+    mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
-    mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
     reinit_groestl( &ctx.groestl );
     update_and_final_groestl( &ctx.groestl, (char*)hash0, (char*)hash0, 512 );
     reinit_groestl( &ctx.groestl );
@@ -91,7 +108,8 @@ void anime_4way_hash( void *state, const void *input )
     update_and_final_groestl( &ctx.groestl, (char*)hash2, (char*)hash2, 512 );
     reinit_groestl( &ctx.groestl );
     update_and_final_groestl( &ctx.groestl, (char*)hash3, (char*)hash3, 512 );
-    mm256_interleave_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+
+    mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
 
     jh512_4way( &ctx.jh, vhash, 64 );
     jh512_4way_close( &ctx.jh, vhash );
@@ -99,16 +117,20 @@ void anime_4way_hash( void *state, const void *input )
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ),
                                   m256_zero );
 
+    if ( mm256_anybits1( vh_mask ) )
+    {
        blake512_4way_init( &ctx.blake );
        blake512_4way( &ctx.blake, vhash, 64 );
        blake512_4way_close( &ctx.blake, vhashA );
-
+    }
+    if ( mm256_anybits0( vh_mask ) )
+    {
        bmw512_4way_init( &ctx.bmw );
        bmw512_4way( &ctx.bmw, vhash, 64 );
        bmw512_4way_close( &ctx.bmw, vhashB );
+    }
 
-    for ( i = 0; i < 8; i++ )
-       vh[i] = _mm256_blendv_epi8( vhA[i], vhB[i], vh_mask );
+    mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
 
     keccak512_4way( &ctx.keccak, vhash, 64 );
     keccak512_4way_close( &ctx.keccak, vhash );
@@ -120,33 +142,35 @@ void anime_4way_hash( void *state, const void *input )
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ),
                                   m256_zero );
 
-    keccak512_4way_init( &ctx.keccak );
-    keccak512_4way( &ctx.keccak, vhash, 64 );
-    keccak512_4way_close( &ctx.keccak, vhashA );
+    if ( mm256_anybits1( vh_mask ) )
+    {
+       keccak512_4way_init( &ctx.keccak );
+       keccak512_4way( &ctx.keccak, vhash, 64 );
+       keccak512_4way_close( &ctx.keccak, vhashA );
+    }
+    if ( mm256_anybits0( vh_mask ) )
+    {
+       jh512_4way_init( &ctx.jh );
+       jh512_4way( &ctx.jh, vhash, 64 );
+       jh512_4way_close( &ctx.jh, vhashB );
+    }
 
-    jh512_4way_init( &ctx.jh );
-    jh512_4way( &ctx.jh, vhash, 64 );
-    jh512_4way_close( &ctx.jh, vhashB );
+    mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
 
-    for ( i = 0; i < 8; i++ )
-       vh[i] = _mm256_blendv_epi8( vhA[i], vhB[i], vh_mask );
-
-    mm256_deinterleave_4x64( state, state+32, state+64, state+96, vhash, 256 );
+    mm256_dintrlv_4x64( state, state+32, state+64, state+96, vhash, 256 );
 }
 
 int scanhash_anime_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done)
+                         uint64_t *hashes_done, struct thr_info *mythr )
 {
     uint32_t hash[4*8] __attribute__ ((aligned (64)));
     uint32_t vdata[24*4] __attribute__ ((aligned (64)));
-    uint32_t endiandata[20] __attribute__((aligned(64)));
     uint32_t *pdata = work->data;
     uint32_t *ptarget = work->target;
     uint32_t n = pdata[19];
     const uint32_t first_nonce = pdata[19];
-    uint32_t *nonces = work->nonces;
-    int num_found = 0;
-    uint32_t *noncep = vdata + 73;   // 9*8 + 1
+    __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
+    /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
     const uint32_t Htarg = ptarget[7];
     uint64_t htmax[] = {
                 0,
@@ -165,10 +189,7 @@ int scanhash_anime_4way( int thr_id, struct work *work, uint32_t max_nonce,
                 0
         };
 
-    swab32_array( endiandata, pdata, 20 );
-
-    uint64_t *edata = (uint64_t*)endiandata;
-    mm256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+    mm256_bswap_intrlv80_4x64( vdata, pdata );
 
     for (int m=0; m < 6; m++)
        if (Htarg <= htmax[m])
@@ -177,30 +198,26 @@ int scanhash_anime_4way( int thr_id, struct work *work, uint32_t max_nonce,
 
           do
           {
-             be32enc( noncep,   n   );
-             be32enc( noncep+2, n+1 );
-             be32enc( noncep+4, n+2 );
-             be32enc( noncep+6, n+3 );
+             *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+                _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
 
              anime_4way_hash( hash, vdata );
              pdata[19] = n;
 
              for ( int i = 0; i < 4; i++ )
              if ( ( ( (hash+(i<<3))[7] & mask ) == 0 )
-                && fulltest( hash+(i<<3), ptarget ) )
+                && fulltest( hash+(i<<3), ptarget ) && !opt_benchmark )
              {
                 pdata[19] = n+i;
-                nonces[ num_found++ ] = n+i;
-                work_set_target_ratio( work, hash+(i<<3) );
+                submit_solution( work, hash+(i<<3), mythr, i );
              }
              n += 4;
-          } while ( ( num_found == 0 ) && ( n < max_nonce )
-              && !work_restart[thr_id].restart );
+          } while ( ( n < max_nonce ) && !work_restart[thr_id].restart );
           break;
        }
 
     *hashes_done = n - first_nonce + 1;
-    return num_found;
+    return 0;
 }
 
 #endif

algo/quark/anime-gate.h

@@ -13,19 +13,15 @@ bool register_anime_algo( algo_gate_t* gate );
 #if defined(ANIME_4WAY)
 
 void anime_4way_hash( void *state, const void *input );
-
 int scanhash_anime_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done );
-
+                         uint64_t *hashes_done, struct thr_info *mythr );
 void init_anime_4way_ctx();
 
 #endif
 
 void anime_hash( void *state, const void *input );
-
 int scanhash_anime( int thr_id, struct work *work, uint32_t max_nonce,
-                    uint64_t *hashes_done );
-
+                    uint64_t *hashes_done, struct thr_info *mythr );
 void init_anime_ctx();
 
 #endif

algo/quark/anime.c

@@ -46,20 +46,6 @@ void init_anime_ctx()
 void anime_hash( void *state, const void *input )
 {
     unsigned char hash[128] __attribute__ ((aligned (32)));
-/*
-    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)));
-    uint64_t vhashA[8*4] __attribute__ ((aligned (64)));
-    uint64_t vhashB[8*4] __attribute__ ((aligned (64)));
-    __m256i* vh  = (__m256i*)vhash;
-    __m256i* vhA = (__m256i*)vhashA;
-    __m256i* vhB = (__m256i*)vhashB;
-    __m256i vh_mask;
-    __m256i bit3_mask; bit3_mask = _mm256_set1_epi64x( 8 );
-*/
     uint32_t mask = 8;
     anime_ctx_holder ctx;
     memcpy( &ctx, &anime_ctx, sizeof(anime_ctx) );
@@ -134,7 +120,7 @@ void anime_hash( void *state, const void *input )
 }
 
 int scanhash_anime( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done)
+                         uint64_t *hashes_done, struct thr_info *mythr)
 {
     uint32_t hash[8] __attribute__ ((aligned (64)));
     uint32_t endiandata[20] __attribute__((aligned(64)));
@@ -142,6 +128,7 @@ int scanhash_anime( int thr_id, struct work *work, uint32_t max_nonce,
     uint32_t *ptarget = work->target;
     uint32_t n = pdata[19];
     const uint32_t first_nonce = pdata[19];
+    /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
     const uint32_t Htarg = ptarget[7];
     uint64_t htmax[] = {
                 0,

algo/quark/hmq1725-4way.c

@@ -0,0 +1,618 @@
+#include "hmq1725-gate.h"
+
+#if defined(HMQ1725_4WAY)
+
+#include <string.h>
+#include <stdint.h>
+#include "algo/blake/blake-hash-4way.h"
+#include "algo/bmw/bmw-hash-4way.h"
+#include "algo/groestl/aes_ni/hash-groestl.h"
+#include "algo/skein/skein-hash-4way.h"
+#include "algo/jh/jh-hash-4way.h"
+#include "algo/keccak/keccak-hash-4way.h"
+#include "algo/luffa/luffa_for_sse2.h"
+#include "algo/cubehash/cubehash_sse2.h"
+#include "algo/simd/nist.h"
+#include "algo/shavite/sph_shavite.h"
+#include "algo/simd/simd-hash-2way.h"
+#include "algo/echo/aes_ni/hash_api.h"
+#include "algo/hamsi/hamsi-hash-4way.h"
+#include "algo/fugue/sph_fugue.h"
+#include "algo/shabal/shabal-hash-4way.h"
+#include "algo/whirlpool/sph_whirlpool.h"
+#include "algo/haval/haval-hash-4way.h"
+#include "algo/sha/sha2-hash-4way.h"
+
+union _hmq1725_4way_context_overlay
+{
+    blake512_4way_context   blake;
+    bmw512_4way_context     bmw;
+    hashState_groestl       groestl;
+    skein512_4way_context   skein;
+    jh512_4way_context      jh;
+    keccak512_4way_context  keccak;
+    hashState_luffa         luffa;
+    cubehashParam           cube;
+    sph_shavite512_context  shavite;
+    hashState_sd            simd;
+    hashState_echo          echo;
+    hamsi512_4way_context   hamsi;
+    sph_fugue512_context    fugue;
+    shabal512_4way_context  shabal;
+    sph_whirlpool_context   whirlpool;
+    sha512_4way_context     sha512;
+    haval256_5_4way_context haval;
+};
+typedef union _hmq1725_4way_context_overlay hmq1725_4way_context_overlay;
+
+extern void hmq1725_4way_hash(void *state, const void *input)
+{
+// why so big? only really need 8, haval thing uses 16.
+     uint32_t hash0 [32]    __attribute__ ((aligned (64)));
+     uint32_t hash1 [32]    __attribute__ ((aligned (64)));
+     uint32_t hash2 [32]    __attribute__ ((aligned (64)));
+     uint32_t hash3 [32]    __attribute__ ((aligned (64)));
+     uint32_t vhash [32<<2] __attribute__ ((aligned (64)));
+     uint32_t vhashA[32<<2] __attribute__ ((aligned (64)));
+     uint32_t vhashB[32<<2] __attribute__ ((aligned (64)));
+     hmq1725_4way_context_overlay ctx __attribute__ ((aligned (64)));
+     __m256i vh_mask;     
+     const __m256i vmask = _mm256_set1_epi64x( 24 );
+     const uint32_t mask = 24;
+     __m256i* vh  = (__m256i*)vhash;
+     __m256i* vhA = (__m256i*)vhashA;
+     __m256i* vhB = (__m256i*)vhashB;
+
+     bmw512_4way_init( &ctx.bmw );
+     bmw512_4way( &ctx.bmw, input, 80 );
+     bmw512_4way_close( &ctx.bmw, vhash );
+
+     mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+
+     sph_whirlpool_init( &ctx.whirlpool );
+     sph_whirlpool( &ctx.whirlpool, hash0, 64 );
+     sph_whirlpool_close( &ctx.whirlpool, hash0 );
+     sph_whirlpool_init( &ctx.whirlpool );
+     sph_whirlpool( &ctx.whirlpool, hash1, 64 );
+     sph_whirlpool_close( &ctx.whirlpool, hash1 );
+     sph_whirlpool_init( &ctx.whirlpool );
+     sph_whirlpool( &ctx.whirlpool, hash2, 64 );
+     sph_whirlpool_close( &ctx.whirlpool, hash2 );
+     sph_whirlpool_init( &ctx.whirlpool );
+     sph_whirlpool( &ctx.whirlpool, hash3, 64 );
+     sph_whirlpool_close( &ctx.whirlpool, hash3 );
+
+// first fork, A is groestl serial, B is skein parallel.
+
+     mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+
+     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], vmask ),
+                                   m256_zero );
+
+// A
+
+//     if ( hash0[0] & mask )
+//     {
+       init_groestl( &ctx.groestl, 64 );
+       update_and_final_groestl( &ctx.groestl, (char*)hash0,
+                                               (char*)hash0, 512 );
+//     }
+//     if ( hash1[0] & mask )
+//     {
+       init_groestl( &ctx.groestl, 64 );
+       update_and_final_groestl( &ctx.groestl, (char*)hash1,
+                                               (char*)hash1, 512 );
+//     }
+//     if ( hash2[0] & mask )
+//     {
+       init_groestl( &ctx.groestl, 64 );
+       update_and_final_groestl( &ctx.groestl, (char*)hash2,
+                                               (char*)hash2, 512 );
+//     }
+//     if ( hash3[0] & mask )
+//     {
+       init_groestl( &ctx.groestl, 64 );
+       update_and_final_groestl( &ctx.groestl, (char*)hash3,
+                                               (char*)hash3, 512 );
+//     }
+
+     mm256_intrlv_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
+
+// B
+
+//     if ( mm256_any_clr_256( vh_mask ) )
+//     {
+       skein512_4way_init( &ctx.skein );
+       skein512_4way( &ctx.skein, vhash, 64 );
+       skein512_4way_close( &ctx.skein, vhashB );
+//     }
+
+     mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
+
+     jh512_4way_init( &ctx.jh );
+     jh512_4way( &ctx.jh, vhash, 64 );
+     jh512_4way_close( &ctx.jh, vhash );
+
+     keccak512_4way_init( &ctx.keccak );
+     keccak512_4way( &ctx.keccak, vhash, 64 );
+     keccak512_4way_close( &ctx.keccak, vhash );
+
+// second fork, A = blake parallel, B= bmw parallel.
+    
+     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], vmask ),
+                                   m256_zero );
+
+//     if ( mm256_any_set_256( vh_mask ) )
+//     {
+       blake512_4way_init( &ctx.blake );
+       blake512_4way( &ctx.blake, vhash, 64 );
+       blake512_4way_close( &ctx.blake, vhashA );
+//     }
+
+//     if ( mm256_any_clr_256( vh_mask ) )
+//     {
+       bmw512_4way_init( &ctx.bmw );
+       bmw512_4way( &ctx.bmw, vhash, 64 );
+       bmw512_4way_close( &ctx.bmw, vhashB );
+//     }
+
+     mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
+    
+     mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+
+     init_luffa( &ctx.luffa, 512 );
+     update_and_final_luffa( &ctx.luffa, (BitSequence*)hash0,
+                                   (const BitSequence*)hash0, 64 );
+     init_luffa( &ctx.luffa, 512 );
+     update_and_final_luffa( &ctx.luffa, (BitSequence*)hash1,
+                                   (const BitSequence*)hash1, 64 );
+     init_luffa( &ctx.luffa, 512 );
+     update_and_final_luffa( &ctx.luffa, (BitSequence*)hash2,
+                                   (const BitSequence*)hash2, 64 );
+     init_luffa( &ctx.luffa, 512 );
+     update_and_final_luffa( &ctx.luffa, (BitSequence*)hash3,
+                                   (const BitSequence*)hash3, 64 );
+
+     cubehashInit( &ctx.cube, 512, 16, 32 );
+     cubehashUpdateDigest( &ctx.cube, (BitSequence *)hash0,
+                                (const BitSequence *)hash0, 64 );
+     cubehashInit( &ctx.cube, 512, 16, 32 );
+     cubehashUpdateDigest( &ctx.cube, (BitSequence *)hash1,
+                                (const BitSequence *)hash1, 64 );
+     cubehashInit( &ctx.cube, 512, 16, 32 );
+     cubehashUpdateDigest( &ctx.cube, (BitSequence *)hash2,
+                                (const BitSequence *)hash2, 64 );
+     cubehashInit( &ctx.cube, 512, 16, 32 );
+     cubehashUpdateDigest( &ctx.cube, (BitSequence *)hash3,
+                                (const BitSequence *)hash3, 64 );
+
+     mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+
+// A= keccak parallel, B= jh parallel
+    
+     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], vmask ),
+                                  m256_zero );
+
+//     if ( mm256_any_set_256( vh_mask ) )
+//     {
+        keccak512_4way_init( &ctx.keccak );
+        keccak512_4way( &ctx.keccak, vhash, 64 );
+        keccak512_4way_close( &ctx.keccak, vhashA );
+//     }
+
+//     if ( mm256_any_clr_256( vh_mask ) )
+//     {
+        jh512_4way_init( &ctx.jh );
+        jh512_4way( &ctx.jh, vhash, 64 );
+        jh512_4way_close( &ctx.jh, vhashB );
+//     }
+
+     mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
+
+     mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+
+     sph_shavite512_init( &ctx.shavite );
+     sph_shavite512 ( &ctx.shavite, hash0, 64 );
+     sph_shavite512_close( &ctx.shavite, hash0 );
+     sph_shavite512_init( &ctx.shavite );
+     sph_shavite512 ( &ctx.shavite, hash1, 64 );
+     sph_shavite512_close( &ctx.shavite, hash1 );
+     sph_shavite512_init( &ctx.shavite );
+     sph_shavite512 ( &ctx.shavite, hash2, 64 );
+     sph_shavite512_close( &ctx.shavite, hash2 );
+     sph_shavite512_init( &ctx.shavite );
+     sph_shavite512 ( &ctx.shavite, hash3, 64 );
+     sph_shavite512_close( &ctx.shavite, hash3 );
+
+     init_sd( &ctx.simd, 512 );
+     update_final_sd( &ctx.simd, (BitSequence *)hash0,
+                           (const BitSequence *)hash0, 512 );
+     init_sd( &ctx.simd, 512 );
+     update_final_sd( &ctx.simd, (BitSequence *)hash1,
+                           (const BitSequence *)hash1, 512 );
+     init_sd( &ctx.simd, 512 );
+     update_final_sd( &ctx.simd, (BitSequence *)hash2,
+                           (const BitSequence *)hash2, 512 );
+     init_sd( &ctx.simd, 512 );
+     update_final_sd( &ctx.simd, (BitSequence *)hash3,
+                           (const BitSequence *)hash3, 512 );
+
+// A is whirlpool serial, B is haval parallel.
+    
+
+     mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+
+     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], vmask ),
+                                   m256_zero );
+     // A
+    
+//     if ( hash0[0] & mask )
+//     {
+        sph_whirlpool_init( &ctx.whirlpool );
+        sph_whirlpool( &ctx.whirlpool, hash0, 64 );
+        sph_whirlpool_close( &ctx.whirlpool, hash0 );
+//     }
+//     if ( hash1[0] & mask )
+//     {
+        sph_whirlpool_init( &ctx.whirlpool );
+        sph_whirlpool( &ctx.whirlpool, hash1, 64 );
+        sph_whirlpool_close( &ctx.whirlpool, hash1 );
+//     }
+//     if ( hash2[0] & mask )
+//     {
+        sph_whirlpool_init( &ctx.whirlpool );
+        sph_whirlpool( &ctx.whirlpool, hash2, 64 );
+        sph_whirlpool_close( &ctx.whirlpool, hash2 );
+//     }
+//     if ( hash3[0] & mask )
+//     {
+        sph_whirlpool_init( &ctx.whirlpool );
+        sph_whirlpool( &ctx.whirlpool, hash3, 64 );
+        sph_whirlpool_close( &ctx.whirlpool, hash3 );
+//     }
+
+     mm256_intrlv_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
+
+// B
+
+//     if ( mm256_any_clr_256( vh_mask ) )
+//     {
+        haval256_5_4way_init( &ctx.haval );
+        haval256_5_4way( &ctx.haval, vhash, 64 );
+        haval256_5_4way_close( &ctx.haval, vhashB );
+        memset( &vhashB[8<<2], 0, 32<<2);
+//     }
+
+     mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
+
+     mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+    
+     init_echo( &ctx.echo, 512 );
+     update_final_echo( &ctx.echo, (BitSequence *)hash0,
+                             (const BitSequence *)hash0, 512 );
+     init_echo( &ctx.echo, 512 );
+     update_final_echo( &ctx.echo, (BitSequence *)hash1,
+                             (const BitSequence *)hash1, 512 );
+     init_echo( &ctx.echo, 512 );
+     update_final_echo( &ctx.echo, (BitSequence *)hash2,
+                             (const BitSequence *)hash2, 512 );
+     init_echo( &ctx.echo, 512 );
+     update_final_echo( &ctx.echo, (BitSequence *)hash3,
+                             (const BitSequence *)hash3, 512 );
+
+     mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+     
+     blake512_4way_init( &ctx.blake );
+     blake512_4way( &ctx.blake, vhash, 64 );
+     blake512_4way_close( &ctx.blake, vhash );
+
+     mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+
+// shavite & luffa, both serial, select individually.
+
+   if ( hash0[0] & mask )
+   {
+      sph_shavite512_init( &ctx.shavite );
+      sph_shavite512( &ctx.shavite, hash0, 64 ); //
+      sph_shavite512_close( &ctx.shavite, hash0 ); //8
+   }
+   else
+   {
+      init_luffa( &ctx.luffa, 512 );
+      update_and_final_luffa( &ctx.luffa, (BitSequence *)hash0,
+                                    (const BitSequence *)hash0, 64 );
+   }
+
+   if ( hash1[0] & mask )
+   {
+      sph_shavite512_init( &ctx.shavite );
+      sph_shavite512( &ctx.shavite, hash1, 64 ); //
+      sph_shavite512_close( &ctx.shavite, hash1 ); //8
+   }
+   else
+   {
+      init_luffa( &ctx.luffa, 512 );
+      update_and_final_luffa( &ctx.luffa, (BitSequence *)hash1,
+                                    (const BitSequence *)hash1, 64 );
+   }
+
+   if ( hash2[0] & mask )
+   {
+      sph_shavite512_init( &ctx.shavite );
+      sph_shavite512( &ctx.shavite, hash2, 64 ); //
+      sph_shavite512_close( &ctx.shavite, hash2 ); //8
+   }
+   else
+   {
+      init_luffa( &ctx.luffa, 512 );
+      update_and_final_luffa( &ctx.luffa, (BitSequence *)hash2,
+                                    (const BitSequence *)hash2, 64 );
+   }
+
+   if ( hash3[0] & mask )
+   {
+      sph_shavite512_init( &ctx.shavite );
+      sph_shavite512( &ctx.shavite, hash3, 64 ); //
+      sph_shavite512_close( &ctx.shavite, hash3 ); //8
+   }
+   else
+   {
+      init_luffa( &ctx.luffa, 512 );
+      update_and_final_luffa( &ctx.luffa, (BitSequence *)hash3,
+                                    (const BitSequence *)hash3, 64 );
+   }
+
+   mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+
+   hamsi512_4way_init( &ctx.hamsi );
+   hamsi512_4way( &ctx.hamsi, vhash, 64 );
+   hamsi512_4way_close( &ctx.hamsi, vhash );
+
+   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+
+   sph_fugue512_init( &ctx.fugue );
+   sph_fugue512( &ctx.fugue, hash0, 64 );
+   sph_fugue512_close( &ctx.fugue, hash0 );
+   sph_fugue512_init( &ctx.fugue );
+   sph_fugue512( &ctx.fugue, hash1, 64 );
+   sph_fugue512_close( &ctx.fugue, hash1 );
+   sph_fugue512_init( &ctx.fugue );
+   sph_fugue512( &ctx.fugue, hash2, 64 );
+   sph_fugue512_close( &ctx.fugue, hash2 );
+   sph_fugue512_init( &ctx.fugue );
+   sph_fugue512( &ctx.fugue, hash3, 64 );
+   sph_fugue512_close( &ctx.fugue, hash3 );
+
+
+//  A echo, B sd both serial
+   
+   if ( hash0[0] & mask ) //4
+   {
+       init_echo( &ctx.echo, 512 );
+       update_final_echo( &ctx.echo, (BitSequence *)hash0,
+                               (const BitSequence *)hash0, 512 );
+   }
+   else
+   {
+       init_sd( &ctx.simd, 512 );
+       update_final_sd( &ctx.simd, (BitSequence *)hash0,
+                             (const BitSequence *)hash0, 512 );
+   }
+
+   if ( hash1[0] & mask ) //4
+   {
+       init_echo( &ctx.echo, 512 );
+       update_final_echo( &ctx.echo, (BitSequence *)hash1,
+                               (const BitSequence *)hash1, 512 );
+   }
+   else
+   {
+       init_sd( &ctx.simd, 512 );
+       update_final_sd( &ctx.simd, (BitSequence *)hash1,
+                             (const BitSequence *)hash1, 512 );
+   }
+
+   if ( hash2[0] & mask ) //4
+   {
+       init_echo( &ctx.echo, 512 );
+       update_final_echo( &ctx.echo, (BitSequence *)hash2,
+                               (const BitSequence *)hash2, 512 );
+   }
+   else
+   {
+       init_sd( &ctx.simd, 512 );
+       update_final_sd( &ctx.simd, (BitSequence *)hash2,
+                             (const BitSequence *)hash2, 512 );
+   }
+
+   if ( hash3[0] & mask ) //4
+   {
+       init_echo( &ctx.echo, 512 );
+       update_final_echo( &ctx.echo, (BitSequence *)hash3,
+                               (const BitSequence *)hash3, 512 );
+   }
+   else
+   {
+       init_sd( &ctx.simd, 512 );
+       update_final_sd( &ctx.simd, (BitSequence *)hash3,
+                             (const BitSequence *)hash3, 512 );
+   }
+
+   mm128_intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 512 );
+
+   shabal512_4way_init( &ctx.shabal );
+   shabal512_4way( &ctx.shabal, vhash, 64 );
+   shabal512_4way_close( &ctx.shabal, vhash );
+
+   mm128_dintrlv_4x32( hash0, hash1, hash2, hash3, vhash, 512 );
+
+   sph_whirlpool_init( &ctx.whirlpool );
+   sph_whirlpool( &ctx.whirlpool, hash0, 64 );
+   sph_whirlpool_close( &ctx.whirlpool, hash0 );
+   sph_whirlpool_init( &ctx.whirlpool );
+   sph_whirlpool( &ctx.whirlpool, hash1, 64 );
+   sph_whirlpool_close( &ctx.whirlpool, hash1 );
+   sph_whirlpool_init( &ctx.whirlpool );
+   sph_whirlpool( &ctx.whirlpool, hash2, 64 );
+   sph_whirlpool_close( &ctx.whirlpool, hash2 );
+   sph_whirlpool_init( &ctx.whirlpool );
+   sph_whirlpool( &ctx.whirlpool, hash3, 64 );
+   sph_whirlpool_close( &ctx.whirlpool, hash3 );
+
+// A = fugue serial, B = sha512 prarallel
+   
+   mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+
+   vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], vmask ),
+                                 m256_zero );
+
+//   if ( hash0[0] & mask ) 
+//   {
+      sph_fugue512_init( &ctx.fugue );
+      sph_fugue512( &ctx.fugue, hash0, 64 );
+      sph_fugue512_close( &ctx.fugue, hash0 );
+//   }
+//   if ( hash1[0] & mask ) 
+//   {
+      sph_fugue512_init( &ctx.fugue );
+      sph_fugue512( &ctx.fugue, hash1, 64 );
+      sph_fugue512_close( &ctx.fugue, hash1 );
+//   }
+//   if ( hash2[0] & mask ) 
+//   {
+      sph_fugue512_init( &ctx.fugue );
+      sph_fugue512( &ctx.fugue, hash2, 64 );
+      sph_fugue512_close( &ctx.fugue, hash2 );
+//   }
+//   if ( hash3[0] & mask ) 
+//   {
+      sph_fugue512_init( &ctx.fugue );
+      sph_fugue512( &ctx.fugue, hash3, 64 );
+      sph_fugue512_close( &ctx.fugue, hash3 );
+//   }
+
+   mm256_intrlv_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
+
+//   if ( mm256_any_clr_256( vh_mask ) )
+//   {
+      sha512_4way_init( &ctx.sha512 );
+      sha512_4way( &ctx.sha512, vhash, 64 );
+      sha512_4way_close( &ctx.sha512, vhashB );
+//   }
+
+   mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
+
+   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+
+   init_groestl( &ctx.groestl, 64 );
+   update_and_final_groestl( &ctx.groestl, (char*)hash0, (char*)hash0, 512 );
+   init_groestl( &ctx.groestl, 64 );
+   update_and_final_groestl( &ctx.groestl, (char*)hash1, (char*)hash1, 512 );
+   init_groestl( &ctx.groestl, 64 );
+   update_and_final_groestl( &ctx.groestl, (char*)hash2, (char*)hash2, 512 );
+   init_groestl( &ctx.groestl, 64 );
+   update_and_final_groestl( &ctx.groestl, (char*)hash3, (char*)hash3, 512 );
+
+   mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+
+   sha512_4way_init( &ctx.sha512 ); 
+   sha512_4way( &ctx.sha512, vhash, 64 );
+   sha512_4way_close( &ctx.sha512, vhash ); 
+
+// A = haval parallel, B = Whirlpool serial
+
+   vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], vmask ),
+                                 m256_zero );
+
+   mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+     
+//   if ( mm256_any_set_256( vh_mask ) ) //4
+//   {
+      haval256_5_4way_init( &ctx.haval );
+      haval256_5_4way( &ctx.haval, vhash, 64 );
+      haval256_5_4way_close( &ctx.haval, vhashA );
+      memset( &vhashA[8<<2], 0, 32<<2 );
+//   }
+
+//   if ( !( hash0[0] & mask ) )
+//   {
+      sph_whirlpool_init( &ctx.whirlpool );
+      sph_whirlpool( &ctx.whirlpool, hash0, 64 );
+      sph_whirlpool_close( &ctx.whirlpool, hash0 );
+//   }
+//   if ( !( hash2[0] & mask ) )
+//   {
+      sph_whirlpool_init( &ctx.whirlpool );
+      sph_whirlpool( &ctx.whirlpool, hash1, 64 );
+      sph_whirlpool_close( &ctx.whirlpool, hash1 );
+//   }
+//   if ( !( hash2[0] & mask ) )
+//   {
+      sph_whirlpool_init( &ctx.whirlpool );
+      sph_whirlpool( &ctx.whirlpool, hash2, 64 );
+      sph_whirlpool_close( &ctx.whirlpool, hash2 );
+//   }
+//   if ( !( hash3[0] & mask ) )
+//   {
+      sph_whirlpool_init( &ctx.whirlpool );
+      sph_whirlpool( &ctx.whirlpool, hash3, 64 );
+      sph_whirlpool_close( &ctx.whirlpool, hash3 );
+//   }
+
+   mm256_intrlv_4x64( vhashB, hash0, hash1, hash2, hash3, 512 );
+
+   mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
+
+   bmw512_4way_init( &ctx.bmw );
+   bmw512_4way( &ctx.bmw, vhash, 64 );
+   bmw512_4way_close( &ctx.bmw, vhash );
+
+ 	memcpy(state, vhash, 32<<2 );
+}
+
+int scanhash_hmq1725_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                           uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash[4*8] __attribute__ ((aligned (64)));
+//   uint32_t *hash7 = &(hash[7<<2]);
+//   uint32_t lane_hash[8];
+   uint32_t vdata[24*4] __attribute__ ((aligned (64)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   uint32_t n = pdata[19] - 1;
+   const uint32_t first_nonce = pdata[19];
+   __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
+   const uint32_t Htarg = ptarget[7];
+   uint64_t htmax[] = {          0,        0xF,       0xFF,
+                             0xFFF,     0xFFFF, 0x10000000  };
+   uint32_t masks[] = { 0xFFFFFFFF, 0xFFFFFFF0, 0xFFFFFF00,
+                        0xFFFFF000, 0xFFFF0000,          0  };
+
+   mm256_bswap_intrlv80_4x64( vdata, pdata );
+   for ( int m = 0; m < 6; m++ ) if ( Htarg <= htmax[m] )
+   {
+      uint32_t mask = masks[ m ];
+      do
+      {
+         *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+                 _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
+         hmq1725_4way_hash( hash, vdata );
+         for ( int i = 0; i < 4; i++ )
+         if ( ( (hash+(i<<3))[7] & mask ) == 0 )
+         {
+            if ( fulltest( (hash+(i<<3)), ptarget ) && !opt_benchmark )
+            {
+               pdata[19] = n + i;
+               submit_solution( work, (hash+(i<<3)), mythr, i );
+            }
+         }
+	      n += 4;
+      } while ( ( n < max_nonce-4 ) && !work_restart[thr_id].restart );	
+	   break;
+	}
+	*hashes_done = n - first_nonce + 1;
+	return 0;
+}
+
+#endif // HMQ1725_4WAY

algo/quark/hmq1725-gate.c

@@ -0,0 +1,17 @@
+#include "hmq1725-gate.h"
+
+bool register_hmq1725_algo( algo_gate_t* gate )
+{
+#if defined(HMQ1725_4WAY)
+  gate->scanhash  = (void*)&scanhash_hmq1725_4way;
+  gate->hash      = (void*)&hmq1725_4way_hash;
+#else
+  init_hmq1725_ctx();
+  gate->scanhash  = (void*)&scanhash_hmq1725;
+  gate->hash      = (void*)&hmq1725hash;
+#endif
+  gate->set_target       = (void*)&scrypt_set_target;
+  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT;
+  return true;
+};
+

algo/quark/hmq1725-gate.h

@@ -0,0 +1,28 @@
+#ifndef HMQ1725_GATE_H__
+#define HMQ1725_GATE_H__ 1
+
+#include "algo-gate-api.h"
+#include <stdint.h>
+
+#if defined(__AVX2__) && defined(__AES__)
+//  #define HMQ1725_4WAY
+#endif
+
+bool register_hmq1725_algo( algo_gate_t* gate );
+
+#if defined(HMQ1725_4WAY)
+
+void hmq1725_4way_hash( void *state, const void *input );
+int scanhash_hmq1725_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                           uint64_t *hashes_done, struct thr_info *mythr );
+
+#else
+
+void hmq1725hash( void *state, const void *input );
+int scanhash_hmq1725( int thr_id, struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
+void init_hmq1725_ctx();
+
+#endif
+
+#endif  // HMQ1725_GATE_H__

algo/quark/hmq1725.c

@@ -1,4 +1,4 @@
-#include "algo-gate-api.h"
+#include "hmq1725-gate.h"
 #include <string.h>
 #include <stdint.h>
 #include "algo/blake/sph_blake.h"
@@ -298,19 +298,22 @@ extern void hmq1725hash(void *state, const void *input)
 	memcpy(state, hashA, 32);
 }
 
-int scanhash_hmq1725( int thr_id, struct work *work, int32_t max_nonce,
-                      uint64_t *hashes_done )
+int scanhash_hmq1725( int thr_id, struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
 {
-        uint32_t endiandata[32] __attribute__((aligned(64)));
+//        uint32_t endiandata[32] __attribute__((aligned(64)));
+        uint32_t endiandata[20] __attribute__((aligned(64)));
         uint32_t hash64[8] __attribute__((aligned(64)));
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
 	uint32_t n = pdata[19] - 1;
 	const uint32_t first_nonce = pdata[19];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 	//const uint32_t Htarg = ptarget[7];
 
 	//we need bigendian data...
-        for (int k = 0; k < 32; k++)
+//        for (int k = 0; k < 32; k++)
+        for (int k = 0; k < 20; k++)
                 be32enc(&endiandata[k], pdata[k]);
 
         hmq_bmw512_midstate( endiandata );
@@ -406,14 +409,14 @@ int scanhash_hmq1725( int thr_id, struct work *work, int32_t max_nonce,
 	pdata[19] = n;
 	return 0;
 }
-
+/*
 bool register_hmq1725_algo( algo_gate_t* gate )
 {
   init_hmq1725_ctx();
-  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | SHA_OPT;
+  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT;
   gate->set_target       = (void*)&scrypt_set_target;
   gate->scanhash         = (void*)&scanhash_hmq1725;
   gate->hash             = (void*)&hmq1725hash;
   return true;
 };
-
+*/

algo/quark/quark-4way.c

@@ -48,9 +48,10 @@ void quark_4way_hash( void *state, const void *input )
     __m256i* vhA = (__m256i*)vhashA;
     __m256i* vhB = (__m256i*)vhashB;
     __m256i vh_mask;
-    __m256i bit3_mask; bit3_mask = _mm256_set1_epi64x( 8 );
-    int i;
     quark_4way_ctx_holder ctx;
+    const __m256i bit3_mask = _mm256_set1_epi64x( 8 );
+    const uint32_t mask = 8;
+
     memcpy( &ctx, &quark_4way_ctx, sizeof(quark_4way_ctx) );
 
     blake512_4way( &ctx.blake, input, 80 );
@@ -62,27 +63,44 @@ void quark_4way_hash( void *state, const void *input )
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ),
                                   m256_zero );
 
-       mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+    mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+
+    if ( hash0[0] & mask )
+    {
        update_and_final_groestl( &ctx.groestl, (char*)hash0,
                                                (char*)hash0, 512 );
+    }
+    if ( hash1[0] & mask )
+    {
        reinit_groestl( &ctx.groestl );
        update_and_final_groestl( &ctx.groestl, (char*)hash1,
                                                (char*)hash1, 512 );
+    }
+    if ( hash2[0] & mask )
+    {   
        reinit_groestl( &ctx.groestl );
        update_and_final_groestl( &ctx.groestl, (char*)hash2,
                                                (char*)hash2, 512 );
+    }
+    if ( hash3[0] & mask )
+    {   
        reinit_groestl( &ctx.groestl );
        update_and_final_groestl( &ctx.groestl, (char*)hash3,
                                                (char*)hash3, 512 );
-       mm256_interleave_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
+    }
 
+    mm256_intrlv_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
+
+    if ( mm256_anybits0( vh_mask ) )   
+    {
        skein512_4way( &ctx.skein, vhash, 64 );
        skein512_4way_close( &ctx.skein, vhashB );
+    }
 
-    for ( i = 0; i < 8; i++ )
-       vh[i] = _mm256_blendv_epi8( vhA[i], vhB[i], vh_mask );
+    mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
+
+    mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
-    mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
     reinit_groestl( &ctx.groestl );
     update_and_final_groestl( &ctx.groestl, (char*)hash0, (char*)hash0, 512 );
     reinit_groestl( &ctx.groestl );
@@ -91,7 +109,8 @@ void quark_4way_hash( void *state, const void *input )
     update_and_final_groestl( &ctx.groestl, (char*)hash2, (char*)hash2, 512 );
     reinit_groestl( &ctx.groestl );
     update_and_final_groestl( &ctx.groestl, (char*)hash3, (char*)hash3, 512 );
-    mm256_interleave_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
+
+    mm256_intrlv_4x64( vhash, hash0, hash1, hash2, hash3, 512 );
 
     jh512_4way( &ctx.jh, vhash, 64 );
     jh512_4way_close( &ctx.jh, vhash );
@@ -99,16 +118,21 @@ void quark_4way_hash( void *state, const void *input )
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ),
                                   m256_zero );
 
+    if ( mm256_anybits1( vh_mask ) )
+    {
        blake512_4way_init( &ctx.blake );
        blake512_4way( &ctx.blake, vhash, 64 );
        blake512_4way_close( &ctx.blake, vhashA );
+    }
 
+    if ( mm256_anybits0( vh_mask ) )
+    {
        bmw512_4way_init( &ctx.bmw );
        bmw512_4way( &ctx.bmw, vhash, 64 );
        bmw512_4way_close( &ctx.bmw, vhashB );
+    }
 
-    for ( i = 0; i < 8; i++ )
-       vh[i] = _mm256_blendv_epi8( vhA[i], vhB[i], vh_mask );
+    mm256_blend_hash_4x64( vh, vhA, vhB, vh_mask );
 
     keccak512_4way( &ctx.keccak, vhash, 64 );
     keccak512_4way_close( &ctx.keccak, vhash );
@@ -120,63 +144,65 @@ void quark_4way_hash( void *state, const void *input )
     vh_mask = _mm256_cmpeq_epi64( _mm256_and_si256( vh[0], bit3_mask ),
                                   m256_zero );
 
+    if ( mm256_anybits1( vh_mask ) )
+    {
        keccak512_4way_init( &ctx.keccak );
        keccak512_4way( &ctx.keccak, vhash, 64 );
        keccak512_4way_close( &ctx.keccak, vhashA );
+    }
 
+    if ( mm256_anybits0( vh_mask ) )
+    {
        jh512_4way_init( &ctx.jh );
        jh512_4way( &ctx.jh, vhash, 64 );
        jh512_4way_close( &ctx.jh, vhashB );
+    }
 
-    for ( i = 0; i < 8; i++ )
-       vh[i] = _mm256_blendv_epi8( vhA[i], vhB[i], vh_mask );
-
-    mm256_deinterleave_4x64( state, state+32, state+64, state+96, vhash, 256 );
+    // Final blend, directly to state, only need 32 bytes.
+    casti_m256i( state, 0 ) = _mm256_blendv_epi8( vhA[0], vhB[0], vh_mask );
+    casti_m256i( state, 1 ) = _mm256_blendv_epi8( vhA[1], vhB[1], vh_mask );
+    casti_m256i( state, 2 ) = _mm256_blendv_epi8( vhA[2], vhB[2], vh_mask );
+    casti_m256i( state, 3 ) = _mm256_blendv_epi8( vhA[3], vhB[3], vh_mask );
 }
 
 int scanhash_quark_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done)
+                         uint64_t *hashes_done, struct thr_info *mythr )
 {
     uint32_t hash[4*8] __attribute__ ((aligned (64)));
     uint32_t vdata[24*4] __attribute__ ((aligned (64)));
-    uint32_t endiandata[20] __attribute__((aligned(64)));
+    uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+    uint32_t *hash7 = &(hash[25]);
     uint32_t *pdata = work->data;
     uint32_t *ptarget = work->target;
     uint32_t n = pdata[19];
     const uint32_t first_nonce = pdata[19];
-    uint32_t *nonces = work->nonces;
-    int num_found = 0;
-    uint32_t *noncep = vdata + 73;   // 9*8 + 1
-
-    swab32_array( endiandata, pdata, 20 );
-
-    uint64_t *edata = (uint64_t*)endiandata;
-    mm256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+    __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
+    /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
+    mm256_bswap_intrlv80_4x64( vdata, pdata );
     do
     {
-       be32enc( noncep,   n   );
-       be32enc( noncep+2, n+1 );
-       be32enc( noncep+4, n+2 );
-       be32enc( noncep+6, n+3 );
+       *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+                _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
 
        quark_4way_hash( hash, vdata );
        pdata[19] = n;
 
        for ( int i = 0; i < 4; i++ )
-       if ( ( ( (hash+(i<<3))[7] & 0xFFFFFF00 ) == 0 )
-            && fulltest( hash+(i<<3), ptarget ) )
+       if ( ( hash7[ i<<1 ] & 0xFFFFFF00 ) == 0 )
        {
-          pdata[19] = n+i;
-          nonces[ num_found++ ] = n+i;
-          work_set_target_ratio( work, hash+(i<<3) );
+          mm256_extract_lane_4x64( lane_hash, hash, i, 256 );
+          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark  )
+          {
+            pdata[19] = n+i;
+            submit_solution( work, lane_hash, mythr, i );
+          }
        }
        n += 4;
-    } while ( ( num_found == 0 ) && ( n < max_nonce )
-              && !work_restart[thr_id].restart );
+    } while ( ( n < max_nonce ) && !work_restart[thr_id].restart );
 
     *hashes_done = n - first_nonce + 1;
-    return num_found;
+    return 0;
 }
 
 #endif

algo/quark/quark-gate.h

@@ -13,19 +13,15 @@ bool register_quark_algo( algo_gate_t* gate );
 #if defined(QUARK_4WAY)
 
 void quark_4way_hash( void *state, const void *input );
-
 int scanhash_quark_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done );
-
+                         uint64_t *hashes_done, struct thr_info *mythr );
 void init_quark_4way_ctx();
 
 #endif
 
 void quark_hash( void *state, const void *input );
-
 int scanhash_quark( int thr_id, struct work *work, uint32_t max_nonce,
-                    uint64_t *hashes_done );
-
+                    uint64_t *hashes_done, struct thr_info *mythr );
 void init_quark_ctx();
 
 #endif

algo/quark/quark.c

@@ -173,16 +173,17 @@ void quark_hash(void *state, const void *input)
 }
 
 int scanhash_quark( int thr_id, struct work *work, uint32_t max_nonce,
-                    uint64_t *hashes_done)
+                    uint64_t *hashes_done, struct thr_info *mythr )
 {
-        uint32_t endiandata[20] __attribute__((aligned(64)));
-        uint32_t hash64[8] __attribute__((aligned(32)));
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
+   uint32_t endiandata[20] __attribute__((aligned(64)));
+   uint32_t hash64[8] __attribute__((aligned(32)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
 	uint32_t n = pdata[19] - 1;
 	const uint32_t first_nonce = pdata[19];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
-        swab32_array( endiandata, pdata, 20 );
+   swab32_array( endiandata, pdata, 20 );
 
 	do {
 		pdata[19] = ++n;

algo/qubit/deep-2way.c

@@ -64,7 +64,7 @@ void deep_2way_hash( void *output, const void *input )
 }
 
 int scanhash_deep_2way( int thr_id, struct work *work,uint32_t max_nonce,
-                         uint64_t *hashes_done )
+                         uint64_t *hashes_done, struct thr_info *mythr )
 {
      uint32_t hash[4*8] __attribute__ ((aligned (64)));
      uint32_t vdata[24*4] __attribute__ ((aligned (64)));
@@ -73,17 +73,17 @@ int scanhash_deep_2way( int thr_id, struct work *work,uint32_t max_nonce,
      uint32_t *ptarget = work->target;
      uint32_t n = pdata[19];
      const uint32_t first_nonce = pdata[19];
-     uint32_t *nonces = work->nonces;
-     int num_found = 0;
      uint32_t *noncep = vdata + 32+3;   // 4*8 + 3
+     /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
      const uint32_t Htarg = ptarget[7];
      uint64_t htmax[] = {          0,        0xF,       0xFF,
                                0xFFF,     0xFFFF, 0x10000000  };
      uint32_t masks[] = { 0xFFFFFFFF, 0xFFFFFFF0, 0xFFFFFF00,
                           0xFFFFF000, 0xFFFF0000,          0  };
 
-     // big endian encode 0..18 uint32_t, 64 bits at a time
-     swab32_array( endiandata, pdata, 20 );
+     casti_m256i( endiandata, 0 ) = mm256_bswap_32( casti_m256i( pdata, 0 ) );
+     casti_m256i( endiandata, 1 ) = mm256_bswap_32( casti_m256i( pdata, 1 ) );
+     casti_m128i( endiandata, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
 
      uint64_t *edata = (uint64_t*)endiandata;
      mm256_interleave_2x128( (uint64_t*)vdata, edata, edata, 640 );
@@ -102,23 +102,24 @@ int scanhash_deep_2way( int thr_id, struct work *work,uint32_t max_nonce,
             deep_2way_hash( hash, vdata );
             pdata[19] = n;
 
-            if ( !( hash[7] & mask ) && fulltest( hash, ptarget) )
+            if ( !( hash[7] & mask ) )
+            if ( fulltest( hash, ptarget) && !opt_benchmark )
             {
-               nonces[ num_found++ ] = n;
-               work_set_target_ratio( work, hash );
+                pdata[19] = n;
+                submit_solution( work, hash, mythr, 0 );
             }
-            if ( !( (hash+8)[7] & mask ) && fulltest( hash+8, ptarget) )
+            if ( !( (hash+8)[7] & mask ) )
+            if ( fulltest( hash+8, ptarget) && !opt_benchmark )
             {
-               nonces[ num_found++ ] = n+1;
-               work_set_target_ratio( work, hash+8 );
+               pdata[19] = n+1;
+               submit_solution( work, hash+8, mythr, 1 );
             }
             n += 2;
-         } while ( ( num_found == 0 ) && ( n < max_nonce )
-                   && !work_restart[thr_id].restart );
+         } while ( ( n < max_nonce ) && !work_restart[thr_id].restart );
          break;
      }
      *hashes_done = n - first_nonce + 1;
-     return num_found;
+     return 0;
 }
 
 #endif

algo/qubit/deep-gate.h

@@ -13,19 +13,15 @@ bool register_deep_algo( algo_gate_t* gate );
 #if defined(DEEP_2WAY)
 
 void deep_2way_hash( void *state, const void *input );
-
 int scanhash_deep_2way( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done );
-
+                         uint64_t *hashes_done, struct thr_info *mythr );
 void init_deep_2way_ctx();
 
 #endif
 
 void deep_hash( void *state, const void *input );
-
 int scanhash_deep( int thr_id, struct work *work, uint32_t max_nonce,
-                    uint64_t *hashes_done );
-
+                    uint64_t *hashes_done, struct thr_info *mythr );
 void init_deep_ctx();
 
 #endif

algo/qubit/deep.c

@@ -72,14 +72,15 @@ void deep_hash(void *output, const void *input)
 }
 
 int scanhash_deep( int thr_id, struct work *work, uint32_t max_nonce,
-                   uint64_t *hashes_done)
+                   uint64_t *hashes_done, struct thr_info *mythr )
 {
-        uint32_t endiandata[20] __attribute__((aligned(64)));
-        uint32_t hash64[8] __attribute__((aligned(32)));
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
+   uint32_t endiandata[20] __attribute__((aligned(64)));
+   uint32_t hash64[8] __attribute__((aligned(32)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
 	uint32_t n = pdata[19] - 1;
 	const uint32_t first_nonce = pdata[19];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 	const uint32_t Htarg = ptarget[7];
 
 	uint64_t htmax[] = { 0, 0xF, 0xFF,  0xFFF, 0xFFFF, 0x10000000 };

algo/qubit/qubit-2way.c

@@ -70,7 +70,7 @@ void qubit_2way_hash( void *output, const void *input )
 }
 
 int scanhash_qubit_2way( int thr_id, struct work *work,uint32_t max_nonce,
-                         uint64_t *hashes_done )
+                         uint64_t *hashes_done, struct thr_info *mythr )
 {
      uint32_t hash[4*8] __attribute__ ((aligned (64)));
      uint32_t vdata[24*4] __attribute__ ((aligned (64)));
@@ -79,17 +79,17 @@ int scanhash_qubit_2way( int thr_id, struct work *work,uint32_t max_nonce,
      uint32_t *ptarget = work->target;
      uint32_t n = pdata[19];
      const uint32_t first_nonce = pdata[19];
-     uint32_t *nonces = work->nonces;
-     int num_found = 0;
      uint32_t *noncep = vdata + 32+3;   // 4*8 + 3
+     /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
      const uint32_t Htarg = ptarget[7];
      uint64_t htmax[] = {          0,        0xF,       0xFF,
                                0xFFF,     0xFFFF, 0x10000000  };
      uint32_t masks[] = { 0xFFFFFFFF, 0xFFFFFFF0, 0xFFFFFF00,
                           0xFFFFF000, 0xFFFF0000,          0  };
 
-     // big endian encode 0..18 uint32_t, 64 bits at a time
-     swab32_array( endiandata, pdata, 20 );
+     casti_m256i( endiandata, 0 ) = mm256_bswap_32( casti_m256i( pdata, 0 ) );
+     casti_m256i( endiandata, 1 ) = mm256_bswap_32( casti_m256i( pdata, 1 ) );
+     casti_m128i( endiandata, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
 
      uint64_t *edata = (uint64_t*)endiandata;
      mm256_interleave_2x128( (uint64_t*)vdata, edata, edata, 640 );
@@ -107,25 +107,24 @@ int scanhash_qubit_2way( int thr_id, struct work *work,uint32_t max_nonce,
             qubit_2way_hash( hash, vdata );
             pdata[19] = n;
 
-
-            if ( !( hash[7] & mask ) && fulltest( hash, ptarget) )
+            if ( !( hash[7] & mask ) )
+            if ( fulltest( hash, ptarget) && !opt_benchmark )
             {
-               nonces[ num_found++ ] = n;
-               work_set_target_ratio( work, hash );
+                pdata[19] = n;
+                submit_solution( work, hash, mythr, 0 );
             }
-            if ( !( (hash+8)[7] & mask ) && fulltest( hash+8, ptarget) )
+            if ( !( (hash+8)[7] & mask ) )
+            if ( fulltest( hash+8, ptarget) && !opt_benchmark )
             {
                pdata[19] = n+1;
-               nonces[ num_found++ ] = n+1;
-               work_set_target_ratio( work, hash+8 );
+               submit_solution( work, hash+8, mythr, 1 );
             }
             n += 2;
-         } while ( ( num_found == 0 ) && ( n < max_nonce )
-                   && !work_restart[thr_id].restart );
+         } while ( ( n < max_nonce ) && !work_restart[thr_id].restart );
          break;
      }
      *hashes_done = n - first_nonce + 1;
-     return num_found;
+     return 0;
 }
 
 #endif

algo/qubit/qubit-gate.h

@@ -13,19 +13,15 @@ bool register_qubit_algo( algo_gate_t* gate );
 #if defined(QUBIT_2WAY)
 
 void qubit_2way_hash( void *state, const void *input );
-
 int scanhash_qubit_2way( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done );
-
+                         uint64_t *hashes_done, struct thr_info *mythr );
 void init_qubit_2way_ctx();
 
 #endif
 
 void qubit_hash( void *state, const void *input );
-
 int scanhash_qubit( int thr_id, struct work *work, uint32_t max_nonce,
-                    uint64_t *hashes_done );
-
+                    uint64_t *hashes_done, struct thr_info *mythr );
 void init_qubit_ctx();
 
 #endif

algo/qubit/qubit.c

@@ -83,15 +83,16 @@ void qubit_hash(void *output, const void *input)
         memcpy(output, hash, 32);
 }
 
-int scanhash_qubit(int thr_id, struct work *work,
-		uint32_t max_nonce, uint64_t *hashes_done)
+int scanhash_qubit( int thr_id, struct work *work,	uint32_t max_nonce,
+                    uint64_t *hashes_done, struct thr_info *mythr )
 {
-        uint32_t endiandata[20] __attribute__((aligned(64)));
-        uint32_t hash64[8] __attribute__((aligned(64)));
-        uint32_t *pdata = work->data;
-        uint32_t *ptarget = work->target;
+   uint32_t endiandata[20] __attribute__((aligned(64)));
+   uint32_t hash64[8] __attribute__((aligned(64)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
 	uint32_t n = pdata[19] - 1;
 	const uint32_t first_nonce = pdata[19];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 	const uint32_t Htarg = ptarget[7];
 
 	uint64_t htmax[] = { 0, 0xF, 0xFF,  0xFFF, 0xFFFF, 0x10000000 };

algo/ripemd/lbry-4way.c

@@ -40,9 +40,9 @@ void lbry_8way_hash( void* output, const void* input )
    sha256_8way_close( &ctx_sha256, vhashA );
 
    // reinterleave to do sha512 4-way 64 bit twice.
-   mm256_deinterleave_8x32( h0, h1, h2, h3, h4, h5, h6, h7, vhashA, 256 );
-   mm256_interleave_4x64( vhashA, h0, h1, h2, h3, 256 );
-   mm256_interleave_4x64( vhashB, h4, h5, h6, h7, 256 );
+   mm256_dintrlv_8x32( h0, h1, h2, h3, h4, h5, h6, h7, vhashA, 256 );
+   mm256_intrlv_4x64( vhashA, h0, h1, h2, h3, 256 );
+   mm256_intrlv_4x64( vhashB, h4, h5, h6, h7, 256 );
 
    sha512_4way_init( &ctx_sha512 );
    sha512_4way( &ctx_sha512, vhashA, 32 );
@@ -53,9 +53,9 @@ void lbry_8way_hash( void* output, const void* input )
    sha512_4way_close( &ctx_sha512, vhashB );
 
    // back to 8-way 32 bit
-   mm256_deinterleave_4x64( h0, h1, h2, h3, vhashA, 512 );
-   mm256_deinterleave_4x64( h4, h5, h6, h7, vhashB, 512 );
-   mm256_interleave_8x32( vhashA, h0, h1, h2, h3, h4, h5, h6, h7, 512 );
+   mm256_dintrlv_4x64( h0, h1, h2, h3, vhashA, 512 );
+   mm256_dintrlv_4x64( h4, h5, h6, h7, vhashB, 512 );
+   mm256_intrlv_8x32( vhashA, h0, h1, h2, h3, h4, h5, h6, h7, 512 );
 
    ripemd160_8way_init( &ctx_ripemd );
    ripemd160_8way( &ctx_ripemd, vhashA, 32 );
@@ -72,27 +72,24 @@ void lbry_8way_hash( void* output, const void* input )
 
    sha256_8way_init( &ctx_sha256 );
    sha256_8way( &ctx_sha256, vhashA, 32 );
-   sha256_8way_close( &ctx_sha256, vhashA );
-
-   mm256_deinterleave_8x32( output,     output+ 32, output+ 64, output+ 96,
-                            output+128, output+160, output+192, output+224,
-                            vhashA, 256 );
+   sha256_8way_close( &ctx_sha256, output );
 }
 
 int scanhash_lbry_8way( int thr_id, struct work *work, uint32_t max_nonce,
-                        uint64_t *hashes_done)
+                        uint64_t *hashes_done, struct thr_info *mythr )
 {
    uint32_t hash[8*8] __attribute__ ((aligned (64)));
    uint32_t vdata[32*8] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash7 = &(hash[7<<3]);
    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
    uint32_t n = pdata[27];
    const uint32_t first_nonce = pdata[27];
    const uint32_t Htarg = ptarget[7];
    uint32_t edata[32] __attribute__ ((aligned (64)));
-   uint32_t *nonces = work->nonces;
-   int num_found = 0;
-   uint32_t *noncep = vdata + 216; // 27*8
+   __m256i  *noncev = (__m256i*)vdata + 27;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
    uint64_t htmax[] = {          0,        0xF,       0xFF,
                              0xFFF,     0xFFFF, 0x10000000 };
@@ -100,9 +97,12 @@ int scanhash_lbry_8way( int thr_id, struct work *work, uint32_t max_nonce,
                         0xFFFFF000, 0xFFFF0000,          0 };
 
    // we need bigendian data...
-   swab32_array( edata, pdata, 32 );
-   mm256_interleave_8x32( vdata, edata, edata, edata, edata,
-                                 edata, edata, edata, edata, 1024 );
+   casti_m256i( edata, 0 ) = mm256_bswap_32( casti_m256i( pdata, 0 ) );
+   casti_m256i( edata, 1 ) = mm256_bswap_32( casti_m256i( pdata, 1 ) );
+   casti_m256i( edata, 2 ) = mm256_bswap_32( casti_m256i( pdata, 2 ) );
+   casti_m256i( edata, 3 ) = mm256_bswap_32( casti_m256i( pdata, 3 ) );
+   mm256_intrlv_8x32( vdata, edata, edata, edata, edata,
+                             edata, edata, edata, edata, 1024 );
    sha256_8way_init( &sha256_8w_mid );
    sha256_8way( &sha256_8w_mid, vdata, LBRY_MIDSTATE );
 
@@ -111,136 +111,26 @@ int scanhash_lbry_8way( int thr_id, struct work *work, uint32_t max_nonce,
       uint32_t mask = masks[m];
       do
       {
-         be32enc( noncep,   n   );
-         be32enc( noncep+1, n+1 );
-         be32enc( noncep+2, n+2 );
-         be32enc( noncep+3, n+3 );
-         be32enc( noncep+4, n+4 );
-         be32enc( noncep+5, n+5 );
-         be32enc( noncep+6, n+6 );
-         be32enc( noncep+7, n+7 );
-
+        *noncev = mm256_bswap_32( _mm256_set_epi32(
+                                          n+7,n+6,n+5,n+4,n+3,n+2,n+1,n ) );
          lbry_8way_hash( hash, vdata );
 
-         for ( int i = 0; i < 8; i++ )
-         if ( !( (hash+(i<<3))[7] & mask ) && fulltest( hash+(i<<3), ptarget ) )
+         for ( int i = 0; i < 8; i++ )  if ( !( hash7[ i ] & mask ) )
          {
-            pdata[27] = n+i;
-            nonces[ num_found++ ] = n+i;
-            work_set_target_ratio( work, hash+(i<<3) );
+            // deinterleave hash for lane
+            mm256_extract_lane_8x32( lane_hash, hash, i, 256 );
+            if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+            {
+              pdata[27] = n + i;
+              submit_solution( work, lane_hash, mythr, i );
+            }
          }
-         n+=8;
-      } while ( ( num_found == 0 ) && ( n < max_nonce )
-                   && !work_restart[thr_id].restart );
+         n += 8;
+      } while ( (n < max_nonce-10) && !work_restart[thr_id].restart );
       break;
    }
-
-   *hashes_done = n - first_nonce;
-   return num_found;
-}
-
-#elif defined(LBRY_4WAY)
-
-static __thread sha256_4way_context sha256_mid;
-
-void lbry_4way_hash( void* output, const void* input )
-{
-   sha256_4way_context     ctx_sha256 __attribute__ ((aligned (64)));
-   sha512_4way_context     ctx_sha512;
-   ripemd160_4way_context  ctx_ripemd;
-   uint32_t _ALIGN(64) vhashA[16<<2];
-   uint32_t _ALIGN(64) vhashB[16<<2];
-   uint32_t _ALIGN(64) vhashC[16<<2];
-
-   memcpy( &ctx_sha256, &sha256_mid, sizeof(ctx_sha256) );
-   sha256_4way( &ctx_sha256, input + (LBRY_MIDSTATE<<2), LBRY_TAIL );
-   sha256_4way_close( &ctx_sha256, vhashA );
-
-   sha256_4way_init( &ctx_sha256 );
-   sha256_4way( &ctx_sha256, vhashA, 32 );
-   sha256_4way_close( &ctx_sha256, vhashA );
-
-   // sha512 64 bit data, 64 byte output
-   mm256_reinterleave_4x64( vhashB, vhashA, 256 );
-   sha512_4way_init( &ctx_sha512 );
-   sha512_4way( &ctx_sha512, vhashB, 32 );
-   sha512_4way_close( &ctx_sha512, vhashB );
-   mm256_reinterleave_4x32( vhashA, vhashB, 512 );
-
-   ripemd160_4way_init( &ctx_ripemd );
-   ripemd160_4way( &ctx_ripemd, vhashA, 32 );
-   ripemd160_4way_close( &ctx_ripemd, vhashB );
-
-   ripemd160_4way_init( &ctx_ripemd );
-   ripemd160_4way( &ctx_ripemd, vhashA+(8<<2), 32 );
-   ripemd160_4way_close( &ctx_ripemd, vhashC );
-
-   sha256_4way_init( &ctx_sha256 );
-   sha256_4way( &ctx_sha256, vhashB, 20 );
-   sha256_4way( &ctx_sha256, vhashC, 20 );
-   sha256_4way_close( &ctx_sha256, vhashA );
-
-   sha256_4way_init( &ctx_sha256 );
-   sha256_4way( &ctx_sha256, vhashA, 32 );
-   sha256_4way_close( &ctx_sha256, vhashA );
-
-   mm128_deinterleave_4x32( output, output+32, output+64, output+96,
-		            vhashA, 256 );
-}
-
-int scanhash_lbry_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[32*4] __attribute__ ((aligned (64)));
-   uint32_t *pdata = work->data;
-   uint32_t *ptarget = work->target;
-   uint32_t n = pdata[27];
-   const uint32_t first_nonce = pdata[27];
-   const uint32_t Htarg = ptarget[7];
-   uint32_t edata[32] __attribute__ ((aligned (64)));
-   uint32_t *nonces = work->nonces;
-   int num_found = 0;
-   uint32_t *noncep = vdata + 108; // 27*4
-
-   uint64_t htmax[] = {          0,        0xF,       0xFF,
-                             0xFFF,     0xFFFF, 0x10000000 };
-   uint32_t masks[] = {	0xFFFFFFFF, 0xFFFFFFF0,	0xFFFFFF00,
-                        0xFFFFF000, 0xFFFF0000,          0 };
-
-   // we need bigendian data...
-   swab32_array( edata, pdata, 32 );
-   mm128_interleave_4x32( vdata, edata, edata, edata, edata, 1024 );
-   sha256_4way_init( &sha256_mid );
-   sha256_4way( &sha256_mid, vdata, LBRY_MIDSTATE );
-
-   for ( int m = 0; m < sizeof(masks); m++ ) if ( Htarg <= htmax[m] )
-   {
-      uint32_t mask = masks[m];
-      do
-      {
-         be32enc( noncep,   n   );
-         be32enc( noncep+1, n+1 );
-         be32enc( noncep+2, n+2 );
-         be32enc( noncep+3, n+3 );
-
-         lbry_4way_hash( hash, vdata );
-
-         for ( int i = 0; i < 4; i++ )
-         if ( !( (hash+(i<<3))[7] & mask ) && fulltest( hash+(i<<3), ptarget ) )
-         {
-            pdata[27] = n+i;
-            nonces[ num_found++ ] = n+i;
-            work_set_target_ratio( work, hash+(i<<3) );
-         }
-         n+=4;
-      } while ( ( num_found == 0 ) && ( n < max_nonce )
-                   && !work_restart[thr_id].restart );
-      break;
-   }
-
-   *hashes_done = n - first_nonce;
-   return num_found;
+   *hashes_done = n - first_nonce + 1;
+   return 0;
 }
 
 #endif

algo/ripemd/lbry-gate.h

@@ -4,12 +4,10 @@
 #include "algo-gate-api.h"
 #include <stdint.h>
 
-// Overide multi way on ryzen, SHA is better.
-#if !defined(RYZEN_)
-// need sha512 2 way AVX x2 or 1 way scalar x4 to support 4way AVX.
-#if defined(__AVX2__)
+#if !defined(__SHA__)
+ #if defined(__AVX2__)
   #define LBRY_8WAY
-#endif
+ #endif
 #endif
 
 #define LBRY_NTIME_INDEX 25
@@ -24,17 +22,18 @@ bool register_lbry_algo( algo_gate_t* gate );
 
 void lbry_8way_hash( void *state, const void *input );
 int scanhash_lbry_8way( int thr_id, struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done );
-
+                         uint64_t *hashes_done, struct thr_info *mythr );
+/*
 #elif defined(LBRY_4WAY)
 
 void lbry_4way_hash( void *state, const void *input );
 int scanhash_lbry_4way( int thr_id, struct work *work, uint32_t max_nonce,
                          uint64_t *hashes_done );
+*/
 #else
 
 void lbry_hash( void *state, const void *input );
 int scanhash_lbry( int thr_id, struct work *work, uint32_t max_nonce,
-                    uint64_t *hashes_done );
+                    uint64_t *hashes_done, struct thr_info *mythr );
 #endif
 #endif

algo/ripemd/lbry.c

@@ -48,13 +48,14 @@ void lbry_hash(void* output, const void* input)
 }
 
 int scanhash_lbry( int thr_id, struct work *work, uint32_t max_nonce,
-                   uint64_t *hashes_done)
+                   uint64_t *hashes_done, struct thr_info *mythr)
 {
   uint32_t *pdata = work->data;
   uint32_t *ptarget = work->target;
 	uint32_t n = pdata[27] - 1;
 	const uint32_t first_nonce = pdata[27];
 	const uint32_t Htarg = ptarget[7];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
 	uint32_t hash64[8] __attribute__((aligned(64)));
 	uint32_t endiandata[32] __attribute__ ((aligned (64)));

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

@@ -6,7 +6,7 @@
 
 #if defined(__SSE4_2__)
 
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 typedef struct
 {

algo/scrypt.c

@@ -696,7 +696,7 @@ static void scrypt_1024_1_1_256_24way(const uint32_t *input,
 #endif /* HAVE_SCRYPT_6WAY */
 
 extern int scanhash_scrypt( int thr_id, struct work *work, uint32_t max_nonce,
-                            uint64_t *hashes_done )
+                            uint64_t *hashes_done, struct thr_info *mythr )
 {
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
@@ -704,6 +704,7 @@ extern int scanhash_scrypt( int thr_id, struct work *work, uint32_t max_nonce,
 	uint32_t midstate[8];
 	uint32_t n = pdata[19] - 1;
 	const uint32_t Htarg = ptarget[7];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 	int throughput = scrypt_best_throughput();
 	int i;
 	

algo/sha/sha2-hash-4way.c

@@ -30,7 +30,7 @@
  * @author   Thomas Pornin <thomas.pornin@cryptolog.com>
  */
 
-#if defined(__SSE4_2__)
+#if defined(__SSE2__)
 
 #include <stddef.h>
 #include <string.h>
@@ -716,4 +716,4 @@ void sha512_4way_close( sha512_4way_context *sc, void *dst )
 }
 
 #endif  // __AVX2__
-#endif  // __SSE4_2__
+#endif  // __SSE2__

algo/sha/sha2-hash-4way.h

@@ -42,9 +42,10 @@
 
 #include <stddef.h>
 #include "sph_types.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
-#if defined(__SSE4_2__)
+#if defined(__SSE2__)
+//#if defined(__SSE4_2__)
 
 //#define SPH_SIZE_sha256   256
 
@@ -60,6 +61,26 @@ void sha256_4way_init( sha256_4way_context *sc );
 void sha256_4way( sha256_4way_context *sc, const void *data, size_t len );
 void sha256_4way_close( sha256_4way_context *sc, void *dst );
 
+/*
+// SHA-256 7 way hybrid
+// Combines SSE, MMX and scalar data to do 8 + 2 + 1 parallel.
+typedef struct {
+   __m128i  bufx[64>>2];
+   __m128i  valx[8];
+   __m64    bufy[64>>2];
+   __m64    valy[8];
+   uint32_t bufz[64>>2];
+   uint32_t valz[8];
+   uint32_t count_high, count_low;
+} sha256_7way_context;
+
+void sha256_7way_init( sha256_7way_context *ctx );
+void sha256_7way( sha256_7way_context *ctx, const void *datax,
+                         void *datay, void *dataz, size_t len );
+void sha256_7way_close( sha256_7way_context *ctx, void *dstx, void *dstyx,
+                         void *dstz  );
+*/
+
 #if defined (__AVX2__)
 
 // SHA-256 8 way
@@ -88,6 +109,24 @@ void sha512_4way_init( sha512_4way_context *sc);
 void sha512_4way( sha512_4way_context *sc, const void *data, size_t len );
 void sha512_4way_close( sha512_4way_context *sc, void *dst );
 
-#endif
-#endif
-#endif
+// SHA-256 11 way hybrid
+// Combines AVX2, MMX and scalar data to do 8 + 2 + 1 parallel.
+typedef struct {
+   __m256i  bufx[64>>2];
+   __m256i  valx[8];
+   __m64    bufy[64>>2];
+   __m64    valy[8];
+   uint32_t bufz[64>>2];
+   uint32_t valz[8];
+   uint32_t count_high, count_low;
+} sha256_11way_context;
+
+void sha256_11way_init( sha256_11way_context *ctx );
+void sha256_11way_update( sha256_11way_context *ctx, const void *datax,
+	                 const void *datay, const void *dataz, size_t len );
+void sha256_11way_close( sha256_11way_context *ctx, void *dstx, void *dstyx,
+	                 void *dstz  );
+
+#endif  // __AVX2__
+#endif  // __SSE2__
+#endif  // SHA256_4WAY_H__

algo/sha/sha256_hash_11way.c

@@ -0,0 +1,538 @@
+#if 0
+
+#include <stddef.h>
+#include <string.h>
+
+#include "sha2-hash-4way.h"
+
+#if defined(__AVX2__)
+
+// naming convention for variables and macros
+// VARx: AVX2 8 way 32 bit
+// VARy: MMX 2 way 32 bit
+// VARz: scalar integer 32 bit
+
+
+static const uint32_t H256[8] =
+{
+        0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
+        0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
+};
+
+static const uint32_t K256[64] = 
+{
+        0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
+        0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
+        0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
+        0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
+        0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
+        0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
+        0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
+        0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
+        0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
+        0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
+        0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
+        0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
+        0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
+        0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
+        0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
+        0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2
+};
+
+#define CHx(X, Y, Z) \
+   _mm256_xor_si256( _mm256_and_si256( _mm256_xor_si256( Y, Z ), X ), Z ) 
+
+#define CHy(X, Y, Z) \
+   _mm_xor_si64( _mm_and_si64( _mm_xor_si64( Y, Z ), X ), Z )
+
+#define CHz(X, Y, Z) ((( (Y) ^ (Z) ) & (X) ) ^ (Z) )
+
+
+#define MAJx(X, Y, Z) \
+   _mm256_or_si256( _mm256_and_si256( X, Y ), \
+                    _mm256_and_si256( _mm256_or_si256( X, Y ), Z ) )
+
+#define MAJy(X, Y, Z) \
+   _mm_or_si64( _mm_and_si64( X, Y ), \
+                    _mm_and_si64( _mm_or_si64( X, Y ), Z ) )
+
+#define MAJz(X, Y, Z)  ( ( (X) & (Y) ) | ( ( (X) | (Y) ) & (Z) ) )
+
+#define BSG2_0x(x) \
+   _mm256_xor_si256( _mm256_xor_si256( \
+       mm256_ror_32(x,2), mm256_ror_32(x,13) ), _mm256_srli_epi32(x,22) )
+
+#define BSG2_0y(x) \
+   _mm_xor_si64( _mm_xor_si64( \
+       mm64_ror_32(x,2), mm64_ror_32(x,13) ), _mm_srli_pi32(x,22) )
+
+#define BSG2_0z(x)  ( u32_ror_32(x,2) ^ u32_ror_32(x,13)  ^ ((x)>>22) )
+
+#define BSG2_1x(x) \
+   _mm256_xor_si256( _mm256_xor_si256( \
+       mm256_ror_32(x,6), mm256_ror_32(x,11) ), _mm256_srli_epi32(x,25) )
+
+#define BSG2_1y(x) \
+   _mm_xor_si64( _mm_xor_si64( \
+       mm64_ror_32(x,6), mm64_ror_32(x,11) ), _mm_srli_pi32(x,25) )
+
+#define BSG2_1z(x)   ( u32_ror_32(x,6) ^ u32_ror_32(x,11) ^ ((x)>>25) )
+
+#define SSG2_0x(x) \
+   _mm256_xor_si256( _mm256_xor_si256( \
+       mm256_ror_32(x,7), mm256_ror_32(x,18) ), _mm256_srli_epi32(x,3) ) 
+
+#define SSG2_0y(x) \
+   _mm_xor_si64( _mm_xor_si64( \
+       mm64_ror_32(x,7), mm64_ror_32(x,18) ), _mm_srli_pi32(x,3) )
+
+#define SSG2_0z(x)  (( u32_ror_32(x,7) ^ u32_ror_32(x,18) ) ^ ((x)>>3) )
+
+#define SSG2_1x(x) \
+   _mm256_xor_si256( _mm256_xor_si256( \
+       mm256_ror_32(x,17), mm256_ror_32(x,19) ), _mm256_srli_epi32(x,10) )
+
+#define SSG2_1y(x) \
+   _mm_xor_si64( _mm_xor_si64( \
+       mm64_ror_32(x,17), mm64_ror_32(x,19) ), _mm_srli_pi32(x,10) )
+
+#define SSG2_1z(x)   ( u32_ror_32(x,17) ^ u32_ror_32(x,19)  ^ ((x)>>10) )
+
+#define SHA2x_MEXP( a, b, c, d ) \
+     _mm256_add_epi32( _mm256_add_epi32( _mm256_add_epi32( \
+                 SSG2_1x( Wx[a] ), Wx[b] ), SSG2_0x( Wx[c] ) ), Wx[d] )
+
+#define SHA2y_MEXP( a, b, c, d ) \
+     _mm_add_pi32( _mm_add_pi32( _mm_add_pi32( \
+                 SSG2_1y( Wy[a] ), Wy[b] ), SSG2_0y( Wy[c] ) ), Wy[d] )
+
+#define SHA2z_MEXP( a, b, c, d ) \
+               ( SSG2_1z( Wz[a] ) + Wz[b] + SSG2_0z( Wz[c] ) + Wz[d] )
+
+
+#define SHA2s_11WAY_STEP( Ax, Bx, Cx, Dx, Ex, Fx, Gx, Hx, \
+	                  Ay, By, Cy, Dy, Ey, Fy, Gy, Hy, \
+		          Az, Bz, Cz, Dz, Ez, Fz, Gz, Hz, i, j) \
+do { \
+  __m256i T1x, T2x; \
+  __m64 T1y, T2y; \
+  uint32_t T1z, T2z; \
+  T1x = _mm256_add_epi32( _mm256_add_epi32( _mm256_add_epi32( \
+        _mm256_add_epi32( Hx, BSG2_1x(Ex) ), CHx(Ex, Fx, Gx) ), \
+                          _mm256_set1_epi32( K256[( (j)+(i) )] ) ), Wx[i] ); \
+  T1y = _mm_add_pi32( _mm_add_pi32( _mm_add_pi32( \
+        _mm_add_pi32( Hy, BSG2_1y(Ey) ), CHy(Ey, Fy, Gy) ), \
+                          _mm_set1_pi32( K256[( (j)+(i) )] ) ), Wy[i] ); \
+  T1z = Hz + BSG2_1z( Ez ) + CHz( Ez, Fz, Gz ) + K256[ ((j)+(i)) ] + Wz[i]; \
+  T2x = _mm256_add_epi32( BSG2_0x(Ax), MAJx(Ax, Bx, Cx) ); \
+  T2y = _mm_add_pi32( BSG2_0y(Ay), MAJy(Ay, By, Cy) ); \
+  T2z = BSG2_0z( Az ) + MAJz( Az, Bz, Cz ); \
+  Dx  = _mm256_add_epi32( Dx,  T1x ); \
+  Dy  = _mm_add_pi32( Dy, T1y ); \
+  Dz  = Dz + T1z; \
+  Hx  = _mm256_add_epi32( T1x, T2x ); \
+  Hy  = _mm_add_pi32( T1y, T2y ); \
+  Hz  = T1z + T2z; \
+} while (0)
+	
+void sha256_11way_round( __m256i *inx, __m256i rx[8], __m64 *iny, __m64 ry[8],
+                         uint32_t *inz, uint32_t rz[8] )
+{
+   __m256i Ax, Bx, Cx, Dx, Ex, Fx, Gx, Hx;
+   __m256i Wx[16];
+   __m64 Ay, By, Cy, Dy, Ey, Fy, Gy, Hy;
+   __m64 Wy[16];
+   uint32_t Az, Bz, Cz, Dz, Ez, Fz, Gz, Hz;
+   uint32_t Wz[16];
+
+   Wx[ 0] = mm256_bswap_32( inx[ 0] );
+   Wy[ 0] =  mm64_bswap_32( iny[ 0] );
+   Wz[ 0] =       bswap_32( inz[ 0] );
+
+   Wx[ 1] = mm256_bswap_32( inx[ 1] );
+   Wy[ 1] =  mm64_bswap_32( iny[ 1] );
+   Wz[ 1] =       bswap_32( inz[ 1] );
+
+   Wx[ 2] = mm256_bswap_32( inx[ 2] );
+   Wy[ 2] =  mm64_bswap_32( iny[ 2] );
+   Wz[ 2] =       bswap_32( inz[ 2] );
+
+   Wx[ 3] = mm256_bswap_32( inx[ 3] );
+   Wy[ 3] =  mm64_bswap_32( iny[ 3] );
+   Wz[ 3] =       bswap_32( inz[ 3] );
+
+   Wx[ 4] = mm256_bswap_32( inx[ 4] );
+   Wy[ 4] =  mm64_bswap_32( iny[ 4] );
+   Wz[ 4] =       bswap_32( inz[ 4] );
+
+   Wx[ 5] = mm256_bswap_32( inx[ 5] );
+   Wy[ 5] =  mm64_bswap_32( iny[ 5] );
+   Wz[ 5] =       bswap_32( inz[ 5] );
+
+   Wx[ 6] = mm256_bswap_32( inx[ 6] );
+   Wy[ 6] =  mm64_bswap_32( iny[ 6] );
+   Wz[ 6] =       bswap_32( inz[ 6] );
+
+   Wx[ 7] = mm256_bswap_32( inx[ 7] );
+   Wy[ 7] =  mm64_bswap_32( iny[ 7] );
+   Wz[ 7] =       bswap_32( inz[ 7] );
+
+   Wx[ 8] = mm256_bswap_32( inx[ 8] );
+   Wy[ 8] =  mm64_bswap_32( iny[ 8] );
+   Wz[ 8] =       bswap_32( inz[ 8] );
+
+   Wx[ 9] = mm256_bswap_32( inx[ 9] );
+   Wy[ 9] =  mm64_bswap_32( iny[ 9] );
+   Wz[ 9] =       bswap_32( inz[ 9] );
+
+   Wx[10] = mm256_bswap_32( inx[10] );
+   Wy[10] =  mm64_bswap_32( iny[10] );
+   Wz[10] =       bswap_32( inz[10] );
+
+   Wx[11] = mm256_bswap_32( inx[11] );
+   Wy[11] =  mm64_bswap_32( iny[11] );
+   Wz[11] =       bswap_32( inz[11] );
+
+   Wx[12] = mm256_bswap_32( inx[12] );
+   Wy[12] =  mm64_bswap_32( iny[12] );
+   Wz[12] =       bswap_32( inz[12] );
+
+   Wx[13] = mm256_bswap_32( inx[13] );
+   Wy[13] =  mm64_bswap_32( iny[13] );
+   Wz[13] =       bswap_32( inz[13] );
+
+   Wx[14] = mm256_bswap_32( inx[14] );
+   Wy[14] =  mm64_bswap_32( iny[14] );
+   Wz[14] =       bswap_32( inz[14] );
+
+   Wx[15] = mm256_bswap_32( inx[15] );
+   Wy[15] =  mm64_bswap_32( iny[15] );
+   Wz[15] =       bswap_32( inz[15] );
+
+   Ax = rx[0];     Ay = ry[0];     Az = rz[0];
+   Bx = rx[1];     By = ry[1];     Bz = rz[1];
+   Cx = rx[2];     Cy = ry[2];     Cz = rz[2];
+   Dx = rx[3];     Dy = ry[3];     Dz = rz[3];
+   Ex = rx[4];     Ey = ry[4];     Ez = rz[4];
+   Fx = rx[5];     Fy = ry[5];     Fz = rz[5];
+   Gx = rx[6];     Gy = ry[6];     Gz = rz[6];
+   Hx = rx[7];     Hy = ry[7];     Hz = rz[7];
+
+   SHA2s_11WAY_STEP( Ax, Bx, Cx, Dx, Ex, Fx, Gx, Hx,
+                     Ay, By, Cy, Dy, Ey, Fy, Gy, Hy,
+                     Az, Bz, Cz, Dz, Ez, Fz, Gz, Hz,  0, 0 );
+   SHA2s_11WAY_STEP( Hx, Ax, Bx, Cx, Dx, Ex, Fx, Gx,
+		     Hy, Ay, By, Cy, Dy, Ey, Fy, Gy,
+		     Hz, Az, Bz, Cz, Dz, Ez, Fz, Gz,  1, 0 );
+   SHA2s_11WAY_STEP( Gx, Hx, Ax, Bx, Cx, Dx, Ex, Fx,
+		     Gy, Hy, Ay, By, Cy, Dy, Ey, Fy,
+		     Gz, Hz, Az, Bz, Cz, Dz, Ez, Fz,  2, 0 );
+   SHA2s_11WAY_STEP( Fx, Gx, Hx, Ax, Bx, Cx, Dx, Ex,
+		     Fy, Gy, Hy, Ay, By, Cy, Dy, Ey,
+		     Fz, Gz, Hz, Az, Bz, Cz, Dz, Ez,  3, 0 );
+   SHA2s_11WAY_STEP( Ex, Fx, Gx, Hx, Ax, Bx, Cx, Dx,
+		     Ey, Fy, Gy, Hy, Ay, By, Cy, Dy,
+		     Ez, Fz, Gz, Hz, Az, Bz, Cz, Dz,  4, 0 );
+   SHA2s_11WAY_STEP( Dx, Ex, Fx, Gx, Hx, Ax, Bx, Cx,
+		     Dy, Ey, Fy, Gy, Hy, Ay, By, Cy,
+		     Dz, Ez, Fz, Gz, Hz, Az, Bz, Cz,  5, 0 );
+   SHA2s_11WAY_STEP( Cx, Dx, Ex, Fx, Gx, Hx, Ax, Bx,
+		     Cy, Dy, Ey, Fy, Gy, Hy, Ay, By,
+		     Cz, Dz, Ez, Fz, Gz, Hz, Az, Bz,  6, 0 );
+   SHA2s_11WAY_STEP( Bx, Cx, Dx, Ex, Fx, Gx, Hx, Ax,
+		     By, Cy, Dy, Ey, Fy, Gy, Hy, Ay,
+		     Bz, Cz, Dz, Ez, Fz, Gz, Hz, Az,  7, 0 );
+   SHA2s_11WAY_STEP( Ax, Bx, Cx, Dx, Ex, Fx, Gx, Hx,
+		     Ay, By, Cy, Dy, Ey, Fy, Gy, Hy,
+		     Az, Bz, Cz, Dz, Ez, Fz, Gz, Hz,  8, 0 );
+   SHA2s_11WAY_STEP( Hx, Ax, Bx, Cx, Dx, Ex, Fx, Gx,
+		     Hy, Ay, By, Cy, Dy, Ey, Fy, Gy,
+		     Hz, Az, Bz, Cz, Dz, Ez, Fz, Gz,  9, 0 );
+   SHA2s_11WAY_STEP( Gx, Hx, Ax, Bx, Cx, Dx, Ex, Fx,
+		     Gy, Hy, Ay, By, Cy, Dy, Ey, Fy,
+		     Gz, Hz, Az, Bz, Cz, Dz, Ez, Fz, 10, 0 );
+   SHA2s_11WAY_STEP( Fx, Gx, Hx, Ax, Bx, Cx, Dx, Ex,
+		     Fy, Gy, Hy, Ay, By, Cy, Dy, Ey,
+		     Fz, Gz, Hz, Az, Bz, Cz, Dz, Ez, 11, 0 );
+   SHA2s_11WAY_STEP( Ex, Fx, Gx, Hx, Ax, Bx, Cx, Dx,
+		     Ey, Fy, Gy, Hy, Ay, By, Cy, Dy,
+		     Ez, Fz, Gz, Hz, Az, Bz, Cz, Dz, 12, 0 );
+   SHA2s_11WAY_STEP( Dx, Ex, Fx, Gx, Hx, Ax, Bx, Cx,
+		     Dy, Ey, Fy, Gy, Hy, Ay, By, Cy,
+		     Dz, Ez, Fz, Gz, Hz, Az, Bz, Cz, 13, 0 );
+   SHA2s_11WAY_STEP( Cx, Dx, Ex, Fx, Gx, Hx, Ax, Bx,
+		     Cy, Dy, Ey, Fy, Gy, Hy, Ay, By,
+		     Cz, Dz, Ez, Fz, Gz, Hz, Az, Bz, 14, 0 );
+   SHA2s_11WAY_STEP( Bx, Cx, Dx, Ex, Fx, Gx, Hx, Ax,
+		     By, Cy, Dy, Ey, Fy, Gy, Hy, Ay,
+		     Bz, Cz, Dz, Ez, Fz, Gz, Hz, Az, 15, 0 );
+
+   for ( int j = 16; j < 64; j += 16 )
+   {
+      Wx[ 0] = SHA2x_MEXP( 14,  9,  1,  0 );
+      Wy[ 0] = SHA2y_MEXP( 14,  9,  1,  0 );
+      Wz[ 0] = SHA2z_MEXP( 14,  9,  1,  0 );
+
+      Wx[ 1] = SHA2x_MEXP( 15, 10,  2,  1 );
+      Wy[ 1] = SHA2y_MEXP( 15, 10,  2,  1 );
+      Wz[ 1] = SHA2z_MEXP( 15, 10,  2,  1 );
+
+      Wx[ 2] = SHA2x_MEXP(  0, 11,  3,  2 );
+      Wy[ 2] = SHA2y_MEXP(  0, 11,  3,  2 );
+      Wz[ 2] = SHA2z_MEXP(  0, 11,  3,  2 );
+
+      Wx[ 3] = SHA2x_MEXP(  1, 12,  4,  3 );
+      Wy[ 3] = SHA2y_MEXP(  1, 12,  4,  3 );
+      Wz[ 3] = SHA2z_MEXP(  1, 12,  4,  3 );
+
+      Wx[ 4] = SHA2x_MEXP(  2, 13,  5,  4 );
+      Wy[ 4] = SHA2y_MEXP(  2, 13,  5,  4 );
+      Wz[ 4] = SHA2z_MEXP(  2, 13,  5,  4 );
+
+      Wx[ 5] = SHA2x_MEXP(  3, 14,  6,  5 );
+      Wy[ 5] = SHA2y_MEXP(  3, 14,  6,  5 );
+      Wz[ 5] = SHA2z_MEXP(  3, 14,  6,  5 );
+
+      Wx[ 6] = SHA2x_MEXP(  4, 15,  7,  6 );
+      Wy[ 6] = SHA2y_MEXP(  4, 15,  7,  6 );
+      Wz[ 6] = SHA2z_MEXP(  4, 15,  7,  6 );
+
+      Wx[ 7] = SHA2x_MEXP(  5,  0,  8,  7);
+      Wy[ 7] = SHA2y_MEXP(  5,  0,  8,  7);
+      Wz[ 7] = SHA2z_MEXP(  5,  0,  8,  7);
+
+      Wx[ 8] = SHA2x_MEXP(  6,  1,  9,  8);
+      Wy[ 8] = SHA2y_MEXP(  6,  1,  9,  8);
+      Wz[ 8] = SHA2z_MEXP(  6,  1,  9,  8);
+
+      Wx[ 9] = SHA2x_MEXP(  7,  2, 10,  9 );
+      Wy[ 9] = SHA2y_MEXP(  7,  2, 10,  9);
+      Wz[ 9] = SHA2z_MEXP(  7,  2, 10,  9);
+
+      Wx[10] = SHA2x_MEXP(  8,  3, 11, 10 );
+      Wy[10] = SHA2y_MEXP(  8,  3, 11, 10);
+      Wz[10] = SHA2z_MEXP(  8,  3, 11, 10);
+
+      Wx[11] = SHA2x_MEXP(  9,  4, 12, 11);
+      Wy[11] = SHA2y_MEXP(  9,  4, 12, 11);
+      Wz[11] = SHA2z_MEXP(  9,  4, 12, 11 );
+
+      Wx[12] = SHA2x_MEXP( 10,  5, 13, 12 );
+      Wy[12] = SHA2y_MEXP( 10,  5, 13, 12 );
+      Wz[12] = SHA2z_MEXP( 10,  5, 13, 12 );
+
+      Wx[13] = SHA2x_MEXP( 11,  6, 14, 13 );
+      Wy[13] = SHA2y_MEXP( 11,  6, 14, 13 );
+      Wz[13] = SHA2z_MEXP( 11,  6, 14, 13 );
+
+      Wx[14] = SHA2x_MEXP( 12,  7, 15, 14 );
+      Wy[14] = SHA2y_MEXP( 12,  7, 15, 14 );
+      Wz[14] = SHA2z_MEXP( 12,  7, 15, 14 );
+
+      Wx[15] = SHA2x_MEXP( 13,  8,  0, 15 );
+      Wy[15] = SHA2y_MEXP( 13,  8,  0, 15 );
+      Wz[15] = SHA2z_MEXP( 13,  8,  0, 15 );
+
+
+      SHA2s_11WAY_STEP( Ax, Bx, Cx, Dx, Ex, Fx, Gx, Hx,
+                        Ay, By, Cy, Dy, Ey, Fy, Gy, Hy,
+			Az, Bz, Cz, Dz, Ez, Fz, Gz, Hz,	 0, j );
+      SHA2s_11WAY_STEP( Hx, Ax, Bx, Cx, Dx, Ex, Fx, Gx,
+		        Hy, Ay, By, Cy, Dy, Ey, Fy, Gy,
+		       	Hz, Az, Bz, Cz, Dz, Ez, Fz, Gz,  1, j );
+      SHA2s_11WAY_STEP( Gx, Hx, Ax, Bx, Cx, Dx, Ex, Fx,
+		        Gy, Hy, Ay, By, Cy, Dy, Ey, Fy,
+		       	Gz, Hz, Az, Bz, Cz, Dz, Ez, Fz,  2, j );
+      SHA2s_11WAY_STEP( Fx, Gx, Hx, Ax, Bx, Cx, Dx, Ex,
+		        Fy, Gy, Hy, Ay, By, Cy, Dy, Ey,
+		       	Fz, Gz, Hz, Az, Bz, Cz, Dz, Ez,  3, j );
+      SHA2s_11WAY_STEP( Ex, Fx, Gx, Hx, Ax, Bx, Cx, Dx,
+		        Ey, Fy, Gy, Hy, Ay, By, Cy, Dy,
+		       	Ez, Fz, Gz, Hz, Az, Bz, Cz, Dz,  4, j );
+      SHA2s_11WAY_STEP( Dx, Ex, Fx, Gx, Hx, Ax, Bx, Cx,
+		        Dy, Ey, Fy, Gy, Hy, Ay, By, Cy,
+		       	Dz, Ez, Fz, Gz, Hz, Az, Bz, Cz,  5, j );
+      SHA2s_11WAY_STEP( Cx, Dx, Ex, Fx, Gx, Hx, Ax, Bx,
+		        Cy, Dy, Ey, Fy, Gy, Hy, Ay, By,
+		       	Cz, Dz, Ez, Fz, Gz, Hz, Az, Bz,  6, j );
+      SHA2s_11WAY_STEP( Bx, Cx, Dx, Ex, Fx, Gx, Hx, Ax,
+		        By, Cy, Dy, Ey, Fy, Gy, Hy, Ay,
+		       	Bz, Cz, Dz, Ez, Fz, Gz, Hz, Az,  7, j );
+      SHA2s_11WAY_STEP( Ax, Bx, Cx, Dx, Ex, Fx, Gx, Hx,
+                        Ay, By, Cy, Dy, Ey, Fy, Gy, Hy,
+                        Az, Bz, Cz, Dz, Ez, Fz, Gz, Hz,  8, j );
+      SHA2s_11WAY_STEP( Hx, Ax, Bx, Cx, Dx, Ex, Fx, Gx, 
+                        Hy, Ay, By, Cy, Dy, Ey, Fy, Gy, 
+                        Hz, Az, Bz, Cz, Dz, Ez, Fz, Gz,  9, j );
+      SHA2s_11WAY_STEP( Gx, Hx, Ax, Bx, Cx, Dx, Ex, Fx, 
+                        Gy, Hy, Ay, By, Cy, Dy, Ey, Fy, 
+                        Gz, Hz, Az, Bz, Cz, Dz, Ez, Fz, 10, j );
+      SHA2s_11WAY_STEP( Fx, Gx, Hx, Ax, Bx, Cx, Dx, Ex, 
+                        Fy, Gy, Hy, Ay, By, Cy, Dy, Ey, 
+                        Fz, Gz, Hz, Az, Bz, Cz, Dz, Ez, 11, j );
+      SHA2s_11WAY_STEP( Ex, Fx, Gx, Hx, Ax, Bx, Cx, Dx, 
+                        Ey, Fy, Gy, Hy, Ay, By, Cy, Dy, 
+                        Ez, Fz, Gz, Hz, Az, Bz, Cz, Dz, 12, j );
+      SHA2s_11WAY_STEP( Dx, Ex, Fx, Gx, Hx, Ax, Bx, Cx, 
+                        Dy, Ey, Fy, Gy, Hy, Ay, By, Cy, 
+                        Dz, Ez, Fz, Gz, Hz, Az, Bz, Cz, 13, j );
+      SHA2s_11WAY_STEP( Cx, Dx, Ex, Fx, Gx, Hx, Ax, Bx, 
+                        Cy, Dy, Ey, Fy, Gy, Hy, Ay, By, 
+                        Cz, Dz, Ez, Fz, Gz, Hz, Az, Bz, 14, j );
+      SHA2s_11WAY_STEP( Bx, Cx, Dx, Ex, Fx, Gx, Hx, Ax, 
+                        By, Cy, Dy, Ey, Fy, Gy, Hy, Ay, 
+                        Bz, Cz, Dz, Ez, Fz, Gz, Hz, Az, 15, j );
+   }
+
+   rx[0] = _mm256_add_epi32( rx[0], Ax );
+   ry[0] =     _mm_add_pi32( ry[0], Ay );
+   rz[0] =                   rz[0]+ Az;
+   rx[1] = _mm256_add_epi32( rx[1], Bx );
+   ry[1] =     _mm_add_pi32( ry[1], By );
+   rz[1] =                   rz[1]+ Bz;
+   rx[2] = _mm256_add_epi32( rx[2], Cx );
+   ry[2] =     _mm_add_pi32( ry[2], Cy );
+   rz[3] =                   rz[3]+ Dz;
+   rx[4] = _mm256_add_epi32( rx[4], Ex );
+   ry[4] =     _mm_add_pi32( ry[4], Ey );
+   rz[4] =                   rz[4]+ Ez;
+   rx[5] = _mm256_add_epi32( rx[5], Fx );
+   ry[5] =     _mm_add_pi32( ry[5], Fy );
+   rz[5] =                   rz[5]+ Fz;
+   rx[6] = _mm256_add_epi32( rx[6], Gx );
+   ry[6] =     _mm_add_pi32( ry[6], Gy );
+   rz[6] =                   rz[6]+ Gz;
+   rx[7] = _mm256_add_epi32( rx[7], Hx );
+   ry[7] =     _mm_add_pi32( ry[7], Hy );
+   rz[7] =                   rz[7]+ Hz;
+
+}
+
+void sha256_11way_init( sha256_11way_context *ctx )
+{
+   ctx->count_high = ctx->count_low = 0;
+   ctx->valx[0] = _mm256_set1_epi32( H256[0] );
+   ctx->valy[0] =     _mm_set1_pi32( H256[0] );
+   ctx->valx[1] = _mm256_set1_epi32( H256[0] );
+   ctx->valy[1] =     _mm_set1_pi32( H256[0] );
+   ctx->valx[2] = _mm256_set1_epi32( H256[0] );
+   ctx->valy[2] =     _mm_set1_pi32( H256[0] );
+   ctx->valx[3] = _mm256_set1_epi32( H256[0] );
+   ctx->valy[3] =     _mm_set1_pi32( H256[0] );
+   ctx->valx[4] = _mm256_set1_epi32( H256[0] );
+   ctx->valy[4] =     _mm_set1_pi32( H256[0] );
+   ctx->valx[5] = _mm256_set1_epi32( H256[0] );
+   ctx->valy[5] =     _mm_set1_pi32( H256[0] );
+   ctx->valx[6] = _mm256_set1_epi32( H256[0] );
+   ctx->valy[6] =     _mm_set1_pi32( H256[0] );
+   ctx->valx[7] = _mm256_set1_epi32( H256[0] );
+   ctx->valy[7] =     _mm_set1_pi32( H256[0] );
+   memcpy( ctx->valz, H256, 32 );
+}
+
+
+void sha256_11way_update( sha256_11way_context *ctx, const void *datax,
+	                  const void *datay, const void *dataz, size_t len )
+{
+   __m256i  *vdatax = (__m256i*) datax;
+    __m64   *vdatay = (__m64*)   datay;
+   uint32_t *idataz = (uint32_t*)dataz;
+   size_t ptr;
+   const int buf_size = 64;
+
+   ptr = (unsigned)ctx->count_low & (buf_size - 1U);
+   while ( len > 0 )
+   {
+      size_t clen;
+      uint32_t clow, clow2;
+
+      clen = buf_size - ptr;
+      if ( clen > len )
+         clen = len;
+      memcpy_256( ctx->bufx + (ptr>>2), vdatax + (ptr>>2), clen>>2 );
+      memcpy_m64( ctx->bufy + (ptr>>2), vdatay + (ptr>>2), clen>>2 );
+      memcpy    ( ctx->bufz +  ptr,     idataz +  ptr,     clen    );
+      ptr += clen;
+      len -= clen;
+      if ( ptr == buf_size )
+      {
+         sha256_11way_round( ctx->bufx, ctx->valx,
+			     ctx->bufy, ctx->valy,
+			     ctx->bufz, ctx->valz );
+         ptr = 0;
+      }
+      clow = ctx->count_low;
+      clow2 = clow + clen;
+      ctx->count_low = clow2;
+      if ( clow2 < clow )
+         ctx->count_high++;
+   }
+}
+
+
+void sha256_11way_close( sha256_11way_context *ctx, void *dstx, void *dsty,
+	                                            void *dstz)
+{
+    unsigned ptr, u;
+    uint32_t low, high;
+    const int buf_size = 64;
+    const int pad = buf_size - 8;
+
+    ptr = (unsigned)ctx->count_low & (buf_size - 1U);
+    ctx->bufx[ ptr>>2 ] = _mm256_set1_epi32( 0x80 );
+    ctx->bufy[ ptr>>2 ] = _mm_set1_pi32( 0x80 );
+    ctx->bufz[ ptr>>2 ] = 0x80;
+    ptr += 4;
+
+    if ( ptr > pad )
+    {
+         memset_zero_256( ctx->bufx + (ptr>>2), (buf_size - ptr) >> 2 );
+         memset_zero_m64( ctx->bufy + (ptr>>2), (buf_size - ptr) >> 2 );
+         memset(      ctx->bufz + (ptr>>2), 0,  (buf_size - ptr) >> 2 );
+         sha256_11way_round( ctx->bufx, ctx->valx,
+			     ctx->bufy, ctx->valy,
+			     ctx->bufz, ctx->valz );
+         memset_zero_256( ctx->bufx, pad >> 2 );
+         memset_zero_m64(  ctx->bufy, pad >> 2 );
+         memset(      ctx->bufz, 0,  pad >> 2 );
+    }
+    else
+    {
+        memset_zero_256( ctx->bufx + (ptr>>2),    (pad - ptr) >> 2 );
+        memset_zero_m64(  ctx->bufy + (ptr>>2),    (pad - ptr) >> 2 );
+        memset(          ctx->bufz + (ptr>>2), 0, (pad - ptr) >> 2 );
+    }
+
+    low = ctx->count_low;
+    high = (ctx->count_high << 3) | (low >> 29);
+    low = low << 3;
+
+    ctx->bufx[ pad >> 2 ] =
+                 mm256_bswap_32( _mm256_set1_epi32( high ) );
+    ctx->bufy[ pad >> 2 ] =
+                 mm64_bswap_32( _mm_set1_pi32( high ) );
+    ctx->bufz[ pad >> 2 ] =
+                 bswap_32( high );
+
+
+    ctx->bufx[ ( pad+4 ) >> 2 ] =
+                 mm256_bswap_32( _mm256_set1_epi32( low ) );
+    ctx->bufy[ ( pad+4 ) >> 2 ] =
+                 mm64_bswap_32( _mm_set1_pi32( low ) );
+    ctx->bufz[ ( pad+4 ) >> 2 ] =
+                 bswap_32( low );
+
+    sha256_11way_round( ctx->bufx, ctx->valx,
+		       ctx->bufy, ctx->valy,
+		       ctx->bufz, ctx->valz  );
+
+    for ( u = 0; u < 8; u ++ )
+    {
+       casti_m256i( dstx, u ) = mm256_bswap_32( ctx->valx[u] );
+       casti_m64  ( dsty, u ) =  mm64_bswap_32( ctx->valy[u] );
+       ((uint32_t*)dstz)[u] = bswap_32( ctx->valz[u] );
+   }
+}
+
+#endif
+#endif   // 0

algo/sha/sha256q-4way.c

@@ -0,0 +1,188 @@
+#include "sha256t-gate.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include "sha2-hash-4way.h"
+
+#if defined(SHA256T_8WAY)
+
+static __thread sha256_8way_context sha256_ctx8 __attribute__ ((aligned (64)));
+
+void sha256q_8way_hash( void* output, const void* input )
+{
+   uint32_t vhash[8*8] __attribute__ ((aligned (64)));
+   sha256_8way_context ctx;
+   memcpy( &ctx, &sha256_ctx8, sizeof ctx );
+
+   sha256_8way( &ctx, input + (64<<3), 16 );
+   sha256_8way_close( &ctx, vhash );
+
+   sha256_8way_init( &ctx );
+   sha256_8way( &ctx, vhash, 32 );
+   sha256_8way_close( &ctx, vhash );
+
+   sha256_8way_init( &ctx );
+   sha256_8way( &ctx, vhash, 32 );
+   sha256_8way_close( &ctx, vhash );
+
+   sha256_8way_init( &ctx );
+   sha256_8way( &ctx, vhash, 32 );
+   sha256_8way_close( &ctx, output );
+}
+
+int scanhash_sha256q_8way( int thr_id, struct work *work, uint32_t max_nonce,
+	                   uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
+   uint32_t hash[8*8] __attribute__ ((aligned (32)));
+   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;
+   __m256i  *noncev = (__m256i*)vdata + 19;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
+
+   const uint64_t htmax[] = {          0,
+                                     0xF,
+                                    0xFF,
+                                   0xFFF,
+                                  0xFFFF,
+                              0x10000000 };
+   const uint32_t masks[] = {  0xFFFFFFFF,
+                               0xFFFFFFF0,
+                               0xFFFFFF00,
+                               0xFFFFF000,
+                               0xFFFF0000,
+                                        0 };
+
+   // Need big endian data
+   mm256_bswap_intrlv80_8x32( vdata, pdata );
+   sha256_8way_init( &sha256_ctx8 );
+   sha256_8way( &sha256_ctx8, vdata, 64 );
+
+   for ( int m = 0; m < 6; m++ ) if ( Htarg <= htmax[m] )
+   {
+      uint32_t mask = masks[m];
+      do
+      {
+         *noncev = mm256_bswap_32(
+		            _mm256_set_epi32( n+7, n+6, n+5, n+4, n+3, n+2, n+1, n ) );
+
+	      pdata[19] = n;
+         sha256q_8way_hash( hash, vdata );
+
+         uint32_t *hash7 = &(hash[7<<3]); 
+	 
+         for ( int lane = 0; lane < 8; lane++ )
+         if ( !( hash7[ lane ] & mask ) )
+         { 
+            // deinterleave hash for lane
+	         uint32_t lane_hash[8];
+	         mm256_extract_lane_8x32( lane_hash, hash, lane, 256 );
+
+	         if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+            {
+	           pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr, lane );
+            }
+	      }
+         n += 8;
+      } while ( (n < max_nonce-10) && !work_restart[thr_id].restart );
+      break;
+   }
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#endif
+
+#if defined(SHA256T_4WAY)
+
+static __thread sha256_4way_context sha256_ctx4 __attribute__ ((aligned (64)));
+
+void sha256q_4way_hash( void* output, const void* input )
+{
+   uint32_t vhash[8*4] __attribute__ ((aligned (64)));
+   sha256_4way_context ctx;
+   memcpy( &ctx, &sha256_ctx4, sizeof ctx );
+
+   sha256_4way( &ctx, input + (64<<2), 16 );
+   sha256_4way_close( &ctx, vhash );
+
+   sha256_4way_init( &ctx );
+   sha256_4way( &ctx, vhash, 32 );
+   sha256_4way_close( &ctx, vhash );
+
+   sha256_4way_init( &ctx );
+   sha256_4way( &ctx, vhash, 32 );
+   sha256_4way_close( &ctx, vhash );
+
+   sha256_4way_init( &ctx );
+   sha256_4way( &ctx, vhash, 32 );
+   sha256_4way_close( &ctx, output );
+}
+
+int scanhash_sha256q_4way( int thr_id, struct work *work, uint32_t max_nonce,
+	                   uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t vdata[20*4] __attribute__ ((aligned (64)));
+   uint32_t hash[8*4] __attribute__ ((aligned (32)));
+   uint32_t *hash7 = &(hash[7<<2]);
+   uint32_t lane_hash[8];
+   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;
+   __m128i  *noncev = (__m128i*)vdata + 19;   // aligned
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
+
+   const uint64_t htmax[] = {          0,
+                                     0xF,
+                                    0xFF,
+                                   0xFFF,
+                                  0xFFFF,
+                              0x10000000 };
+   const uint32_t masks[] = {  0xFFFFFFFF,
+                               0xFFFFFFF0,
+                               0xFFFFFF00,
+                               0xFFFFF000,
+                               0xFFFF0000,
+                                        0 };
+
+   mm128_bswap_intrlv80_4x32( vdata, pdata );
+   sha256_4way_init( &sha256_ctx4 );
+   sha256_4way( &sha256_ctx4, vdata, 64 );
+
+   for ( int m = 0; m < 6; m++ ) if ( Htarg <= htmax[m] )
+   {
+      uint32_t mask = masks[m];
+      do {
+         *noncev = mm128_bswap_32( _mm_set_epi32( n+3,n+2,n+1,n ) );
+         pdata[19] = n;
+
+         sha256q_4way_hash( hash, vdata );
+
+         for ( int lane = 0; lane < 4; lane++ )
+         if ( !( hash7[ lane ] & mask ) )
+         {
+            mm128_extract_lane_4x32( lane_hash, hash, lane, 256 );
+
+            if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
+            {
+              pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr, lane );
+            }
+         }
+         n += 4;
+      } while ( (n < max_nonce - 4) && !work_restart[thr_id].restart );
+      break;
+   }
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#endif
+

algo/sha/sha256q.c

@@ -0,0 +1,113 @@
+#include "sha256t-gate.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include <openssl/sha.h>
+
+static __thread SHA256_CTX sha256q_ctx __attribute__ ((aligned (64)));
+
+void sha256q_midstate( const void* input )
+{
+    SHA256_Init( &sha256q_ctx );
+    SHA256_Update( &sha256q_ctx, input, 64 );
+}
+
+void sha256q_hash( void* output, const void* input )
+{
+   uint32_t _ALIGN(64) hash[16];
+   const int midlen = 64;            // bytes
+   const int tail   = 80 - midlen;   // 16
+
+   SHA256_CTX ctx __attribute__ ((aligned (64)));
+   memcpy( &ctx, &sha256q_ctx, sizeof sha256q_ctx );
+
+   SHA256_Update( &ctx, input + midlen, tail );
+   SHA256_Final( (unsigned char*)hash, &ctx );
+
+   SHA256_Init( &ctx );
+   SHA256_Update( &ctx, hash, 32 );
+   SHA256_Final( (unsigned char*)hash, &ctx );
+
+   SHA256_Init( &ctx );
+   SHA256_Update( &ctx, hash, 32 );
+   SHA256_Final( (unsigned char*)hash, &ctx );
+
+   SHA256_Init( &ctx );
+   SHA256_Update( &ctx, hash, 32 );
+   SHA256_Final( (unsigned char*)hash, &ctx );
+
+   memcpy( output, hash, 32 );
+}
+
+int scanhash_sha256q( int thr_id, struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   uint32_t n = pdata[19] - 1;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t Htarg = ptarget[7];
+#ifdef _MSC_VER
+   uint32_t __declspec(align(32)) hash64[8];
+#else
+   uint32_t hash64[8] __attribute__((aligned(32)));
+#endif
+   uint32_t endiandata[32];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
+
+   uint64_t htmax[] = {
+		0,
+		0xF,
+		0xFF,
+		0xFFF,
+		0xFFFF,
+		0x10000000
+	};
+   uint32_t masks[] = {
+		0xFFFFFFFF,
+		0xFFFFFFF0,
+		0xFFFFFF00,
+		0xFFFFF000,
+		0xFFFF0000,
+		0
+	};
+
+   // we need bigendian data...
+   casti_m128i( endiandata, 0 ) = mm128_bswap_32( casti_m128i( pdata, 0 ) );
+   casti_m128i( endiandata, 1 ) = mm128_bswap_32( casti_m128i( pdata, 1 ) );
+   casti_m128i( endiandata, 2 ) = mm128_bswap_32( casti_m128i( pdata, 2 ) );
+   casti_m128i( endiandata, 3 ) = mm128_bswap_32( casti_m128i( pdata, 3 ) );
+   casti_m128i( endiandata, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
+
+   sha256q_midstate( endiandata );
+
+   for ( int m = 0; m < 6; m++ )
+   {
+      if ( Htarg <= htmax[m] )
+      {
+         uint32_t mask = masks[m];
+         do {
+            pdata[19] = ++n;
+            be32enc(&endiandata[19], n);
+            sha256q_hash( hash64, endiandata );
+            if ( ( !(hash64[7] & mask) ) && fulltest( hash64, ptarget ) )
+            {
+               work_set_target_ratio( work, hash64 );
+               if ( submit_work( mythr, work ) )
+                  applog( LOG_NOTICE, "Share %d submitted by thread %d.",
+                             accepted_share_count + rejected_share_count + 1,
+                             thr_id );
+               else
+                  applog( LOG_WARNING, "Failed to submit share." );
+               *hashes_done = n - first_nonce + 1;
+            }
+         } while ( n < max_nonce && !work_restart[thr_id].restart );
+         break;
+      }
+   }
+
+   *hashes_done = n - first_nonce + 1;
+   pdata[19] = n;
+   return 0;
+}

algo/sha/sha256t-4way.c

@@ -5,6 +5,137 @@
 #include <stdio.h>
 #include "sha2-hash-4way.h"
 
+#if defined(SHA256T_11WAY)
+
+static __thread sha256_11way_context sha256_ctx11 __attribute__ ((aligned (64)));
+
+void sha256t_11way_hash( void *outx, void *outy, void *outz, const void *inpx,
+	                 const void *inpy, const void*inpz )
+{
+   uint32_t hashx[8*8] __attribute__ ((aligned (64)));
+   uint32_t hashy[8*2] __attribute__ ((aligned (64)));
+   uint32_t hashz[8]   __attribute__ ((aligned (64)));
+   sha256_11way_context ctx;
+   const void *inpx64 = inpx+(64<<3);
+   const void *inpy64 = inpy+(64<<1);
+   const void *inpz64 = inpz+ 64;
+
+   memcpy( &ctx, &sha256_ctx11, sizeof ctx );
+   sha256_11way_update( &ctx, inpx64, inpy64, inpz64,  16 );
+   sha256_11way_close( &ctx, hashx, hashy, hashz );
+
+   sha256_11way_init( &ctx );
+   sha256_11way_update( &ctx, hashx, hashy, hashz, 32 );
+   sha256_11way_close( &ctx, hashx, hashy, hashz );
+
+   sha256_11way_init( &ctx );
+   sha256_11way_update( &ctx, hashx, hashy, hashz, 32 );
+   sha256_11way_close( &ctx, outx, outy, outz );
+}
+
+int scanhash_sha256t_11way( int thr_id, struct work *work, uint32_t max_nonce,
+	                    uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t datax[20*8]  __attribute__ ((aligned (64)));
+   uint32_t datay[20*2]  __attribute__ ((aligned (32)));
+   uint32_t dataz[20]    __attribute__ ((aligned (32)));
+   uint32_t hashx[8*8]   __attribute__ ((aligned (32)));
+   uint32_t hashy[8*2]   __attribute__ ((aligned (32)));
+   uint32_t hashz[8]     __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash7;
+   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;
+   __m256i  *noncex = (__m256i*) datax + 19;
+   __m64    *noncey = (__m64*)   datay + 19;
+   uint32_t *noncez = (uint32_t*)dataz + 19;
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
+   int i;
+   const uint64_t htmax[] = {           0,
+                                      0xF,
+                                     0xFF,
+                                    0xFFF,
+                                   0xFFFF,
+                               0x10000000 };
+   const uint32_t masks[] = {  0xFFFFFFFF,
+                               0xFFFFFFF0,
+                               0xFFFFFF00,
+                               0xFFFFF000,
+                               0xFFFF0000,
+                                        0 };
+
+   // Use dataz (scalar) to stage bswapped data for the vectors.
+   casti_m256i( dataz, 0 ) = mm256_bswap_32( casti_m256i( pdata, 0 ) );
+   casti_m256i( dataz, 1 ) = mm256_bswap_32( casti_m256i( pdata, 1 ) );
+   casti_m128i( dataz, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
+
+   mm256_intrlv_8x32( datax, dataz, dataz, dataz, dataz,
+                                 dataz, dataz, dataz, dataz, 640 );
+   mm64_interleave_2x32( datay, dataz, dataz, 640 );
+
+   sha256_11way_init( &sha256_ctx11 );
+   sha256_11way_update( &sha256_ctx11, datax, datay, dataz, 64 );
+
+   for ( int m = 0; m < 6; m++ ) if ( Htarg <= htmax[m] )
+   {
+      uint32_t mask = masks[m];
+      do
+      {
+        *noncex = mm256_bswap_32(
+         _mm256_set_epi32( n+7, n+6, n+5, n+4, n+3, n+2, n+1, n ) );
+        *noncey = mm64_bswap_32( _mm_set_pi32( n+9, n+8 ) );
+        *noncez = bswap_32( n+10 );
+
+        pdata[19] = n;
+
+        sha256t_11way_hash( hashx, hashy, hashz, datax, datay, dataz );
+
+        if ( opt_benchmark ) { n += 11; continue; }
+
+        hash7 = &(hashx[7<<3]); 
+        for ( i = 0; i < 8; i++ ) if ( !( hash7[ i ] & mask ) )
+        { 
+            // deinterleave hash for lane
+            mm256_extract_lane_8x32( lane_hash, hashx, i, 256 );
+            if ( fulltest( lane_hash, ptarget ) )
+            {
+	            pdata[19] = n + i;
+               submit_solution( work, lane_hash, mythr, i );
+            }
+        }
+
+        hash7 = &(hashy[7<<1]);
+        for( i = 0; i < 2; i++ ) if ( !(hash7[ 0] & mask ) )
+ 
+        {
+            mm64_extract_lane_2x32( lane_hash, hashy, i, 256 );
+           if ( fulltest( lane_hash, ptarget ) )
+           {
+               pdata[19] = n + 8 + i;
+               submit_solution( work, lane_hash, mythr, i+8 );
+           }
+	     }
+
+        if ( !(hashz[7] & mask ) && fulltest( hashz, ptarget ) )
+        {
+            pdata[19] = n+10;
+            submit_solution( work, hashz, mythr, 10 );
+        }
+        n += 11;
+
+      } while ( (n < max_nonce-12) && !work_restart[thr_id].restart );
+      break;
+   }
+    
+   *hashes_done = n - first_nonce + 1;
+   return 0;
+}
+
+#endif
+
 #if defined(SHA256T_8WAY)
 
 static __thread sha256_8way_context sha256_ctx8 __attribute__ ((aligned (64)));
@@ -25,15 +156,15 @@ void sha256t_8way_hash( void* output, const void* input )
    sha256_8way_init( &ctx );
    sha256_8way( &ctx, vhash, 32 );
    sha256_8way_close( &ctx, output );
-
 }
 
 int scanhash_sha256t_8way( int thr_id, struct work *work, uint32_t max_nonce,
-	                   uint64_t *hashes_done, struct thr_info *mythr )
+                           uint64_t *hashes_done, struct thr_info *mythr )
 {
-   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
-   uint32_t hash[8*8] __attribute__ ((aligned (32)));
-   uint32_t edata[20] __attribute__ ((aligned (32)));;
+   uint32_t vdata[20*8]  __attribute__ ((aligned (64)));
+   uint32_t hash[8*8]    __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (32)));
+   uint32_t *hash7 = &(hash[7<<3]);
    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
    const uint32_t Htarg = ptarget[7];
@@ -56,12 +187,7 @@ int scanhash_sha256t_8way( int thr_id, struct work *work, uint32_t max_nonce,
                                         0 };
 
    // Need big endian data
-   casti_m256i( edata, 0 ) = mm256_bswap_32( casti_m256i( pdata, 0 ) );
-   casti_m256i( edata, 1 ) = mm256_bswap_32( casti_m256i( pdata, 1 ) );
-   casti_m128i( edata, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
-
-   mm256_interleave_8x32( vdata, edata, edata, edata, edata,
-                                 edata, edata, edata, edata, 640 );
+   mm256_bswap_intrlv80_8x32( vdata, pdata );
    sha256_8way_init( &sha256_ctx8 );
    sha256_8way( &sha256_ctx8, vdata, 64 );
 
@@ -70,45 +196,32 @@ int scanhash_sha256t_8way( int thr_id, struct work *work, uint32_t max_nonce,
       uint32_t mask = masks[m];
       do
       {
-        *noncev = mm256_bswap_32(
-		 _mm256_set_epi32( n+7, n+6, n+5, n+4, n+3, n+2, n+1, n ) );
-
-	 pdata[19] = n;
-
+        *noncev = mm256_bswap_32( _mm256_set_epi32(
+                                          n+7,n+6,n+5,n+4,n+3,n+2,n+1,n ) );
+         pdata[19] = n;
          sha256t_8way_hash( hash, vdata );
-
-         uint32_t *hash7 = &(hash[7<<3]); 
-	 
          for ( int lane = 0; lane < 8; lane++ )
          if ( !( hash7[ lane ] & mask ) )
-         { 
+         {
             // deinterleave hash for lane
-	    uint32_t lane_hash[8];
-	    mm256_extract_lane_8x32( lane_hash, hash, lane, 256 );
-
-	    if ( fulltest( lane_hash, ptarget ) )
+            mm256_extract_lane_8x32( lane_hash, hash, lane, 256 );
+            if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
             {
-	      pdata[19] = n + lane;
-              work_set_target_ratio( work, lane_hash );
-              if ( submit_work( mythr, work ) )
-                applog( LOG_NOTICE, "Share %d submitted by thread %d, lane %d.",
-                             accepted_share_count + rejected_share_count + 1,
-                             thr_id, lane );
-              else
-                applog( LOG_WARNING, "Failed to submit share." );
-	    }
-	 }
+              pdata[19] = n + lane;
+              submit_solution( work, lane_hash, mythr, lane );
+	         }
+         }
          n += 8;
-
       } while ( (n < max_nonce-10) && !work_restart[thr_id].restart );
       break;
    }
-    
    *hashes_done = n - first_nonce + 1;
    return 0;
 }
 
-#elif defined(SHA256T_4WAY)
+#endif
+
+#if defined(SHA256T_4WAY)
 
 static __thread sha256_4way_context sha256_ctx4 __attribute__ ((aligned (64)));
 
@@ -128,7 +241,6 @@ void sha256t_4way_hash( void* output, const void* input )
    sha256_4way_init( &ctx );
    sha256_4way( &ctx, vhash, 32 );
    sha256_4way_close( &ctx, output );
-
 }
 
 int scanhash_sha256t_4way( int thr_id, struct work *work, uint32_t max_nonce,
@@ -136,9 +248,8 @@ int scanhash_sha256t_4way( int thr_id, struct work *work, uint32_t max_nonce,
 {
    uint32_t vdata[20*4] __attribute__ ((aligned (64)));
    uint32_t hash[8*4] __attribute__ ((aligned (32)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
    uint32_t *hash7 = &(hash[7<<2]);
-   uint32_t lane_hash[8];
-   uint32_t edata[20] __attribute__ ((aligned (32)));;
    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
    const uint32_t Htarg = ptarget[7];
@@ -153,20 +264,14 @@ int scanhash_sha256t_4way( int thr_id, struct work *work, uint32_t max_nonce,
                                    0xFFF,
                                   0xFFFF,
                               0x10000000 };
-   const uint32_t masks[] = {  0xFFFFFFFF,
-                               0xFFFFFFF0,
-                               0xFFFFFF00,
-                               0xFFFFF000,
-                               0xFFFF0000,
-                                        0 };
+   const uint32_t masks[] = { 0xFFFFFFFF,
+                              0xFFFFFFF0,
+                              0xFFFFFF00,
+                              0xFFFFF000,
+                              0xFFFF0000,
+                                       0 };
 
-   casti_m128i( edata, 0 ) = mm128_bswap_32( casti_m128i( pdata, 0 ) );
-   casti_m128i( edata, 1 ) = mm128_bswap_32( casti_m128i( pdata, 1 ) );
-   casti_m128i( edata, 2 ) = mm128_bswap_32( casti_m128i( pdata, 2 ) );
-   casti_m128i( edata, 3 ) = mm128_bswap_32( casti_m128i( pdata, 3 ) );
-   casti_m128i( edata, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
-
-   mm128_interleave_4x32( vdata, edata, edata, edata, edata, 640 );
+   mm128_bswap_intrlv80_4x32( vdata, pdata );
    sha256_4way_init( &sha256_ctx4 );
    sha256_4way( &sha256_ctx4, vdata, 64 );
 
@@ -175,7 +280,7 @@ int scanhash_sha256t_4way( int thr_id, struct work *work, uint32_t max_nonce,
       uint32_t mask = masks[m];
       do {
          *noncev = mm128_bswap_32( _mm_set_epi32( n+3,n+2,n+1,n ) );
-	 pdata[19] = n;
+         pdata[19] = n;
 
          sha256t_4way_hash( hash, vdata );
 
@@ -183,26 +288,16 @@ int scanhash_sha256t_4way( int thr_id, struct work *work, uint32_t max_nonce,
          if ( !( hash7[ lane ] & mask ) )
          {
             mm128_extract_lane_4x32( lane_hash, hash, lane, 256 );
-
-            if ( fulltest( lane_hash, ptarget ) )
+            if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
             {
               pdata[19] = n + lane;
-              work_set_target_ratio( work, lane_hash );
-              if ( submit_work( mythr, work ) )
-                applog( LOG_NOTICE, "Share %d submitted by thread %d, lane %d.",
-                             accepted_share_count + rejected_share_count + 1,
-                             thr_id, lane );
-              else
-                applog( LOG_WARNING, "Failed to submit share." );
-            }
-         }
-
-	 n += 4;
-
+              submit_solution( work, lane_hash, mythr, lane );
+	         }
+         } 
+         n += 4;
       } while ( (n < max_nonce - 4) && !work_restart[thr_id].restart );
       break;
    }
-
    *hashes_done = n - first_nonce + 1;
    return 0;
 }

algo/sha/sha256t-gate.c

@@ -3,15 +3,15 @@
 bool register_sha256t_algo( algo_gate_t* gate )
 {
 #if defined(SHA256T_8WAY)
-    gate->optimizations = SSE42_OPT | AVX2_OPT;
+    gate->optimizations = SSE2_OPT | AVX2_OPT | SHA_OPT;
     gate->scanhash   = (void*)&scanhash_sha256t_8way;
     gate->hash       = (void*)&sha256t_8way_hash;
 #elif defined(SHA256T_4WAY)
-    gate->optimizations = SSE42_OPT | AVX2_OPT;
+    gate->optimizations = SSE2_OPT | AVX2_OPT | SHA_OPT;
     gate->scanhash   = (void*)&scanhash_sha256t_4way;
     gate->hash       = (void*)&sha256t_4way_hash;
 #else
-    gate->optimizations = SSE42_OPT | AVX2_OPT | SHA_OPT;
+gate->optimizations = SHA_OPT;
     gate->scanhash   = (void*)&scanhash_sha256t;
     gate->hash       = (void*)&sha256t_hash;
 #endif
@@ -19,3 +19,19 @@ bool register_sha256t_algo( algo_gate_t* gate )
     return true;
 }
 
+bool register_sha256q_algo( algo_gate_t* gate )
+{
+#if defined(SHA256T_4WAY)
+    gate->optimizations = SSE2_OPT | AVX2_OPT | SHA_OPT;
+    gate->scanhash   = (void*)&scanhash_sha256q_4way;
+    gate->hash       = (void*)&sha256q_4way_hash;
+#else
+    gate->optimizations = SHA_OPT;
+    gate->scanhash   = (void*)&scanhash_sha256q;
+    gate->hash       = (void*)&sha256q_hash;
+#endif
+    gate->get_max64  = (void*)&get_max64_0x3ffff;
+    return true;
+
+}
+

algo/sha/sha256t-gate.h

@@ -5,35 +5,43 @@
 #include "algo-gate-api.h"
 
 // Override multi way on ryzen, SHA is better.
-#if !defined(RYZEN_)
-#if defined(__SSE4_2__)
-  #define SHA256T_4WAY
-#endif
-#if defined(__AVX2__)
+#if !defined(__SHA__)
+ #if defined(__AVX2__)
   #define SHA256T_8WAY
-#endif
+#elif defined(__SSE2__)
+  #define SHA256T_4WAY
+ #endif
 #endif
 
-bool register_blake2s_algo( algo_gate_t* gate );
+bool register_sha256t_algo( algo_gate_t* gate );
+bool register_sha256q_algo( algo_gate_t* gate );
 
 #if defined(SHA256T_8WAY)
 
 void sha256t_8way_hash( void *output, const void *input );
 int scanhash_sha256t_8way( int thr_id, struct work *work, uint32_t max_nonce,
                            uint64_t *hashes_done, struct thr_info *mythr );
+void sha256q_8way_hash( void *output, const void *input );
+int scanhash_sha256q_8way( int thr_id, struct work *work, uint32_t max_nonce,
+                           uint64_t *hashes_done, struct thr_info *mythr );
+#endif
 
-#elif defined (SHA256T_4WAY)
+#if defined(SHA256T_4WAY)
 
 void sha256t_4way_hash( void *output, const void *input );
 int scanhash_sha256t_4way( int thr_id, struct work *work, uint32_t max_nonce,
                            uint64_t *hashes_done, struct thr_info *mythr );
-#else
+void sha256q_4way_hash( void *output, const void *input );
+int scanhash_sha256q_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                           uint64_t *hashes_done, struct thr_info *mythr );
+#endif
 
 void sha256t_hash( void *output, const void *input );
 int scanhash_sha256t( int thr_id, struct work *work, uint32_t max_nonce,
                       uint64_t *hashes_done, struct thr_info *mythr );
-
-#endif
+void sha256q_hash( void *output, const void *input );
+int scanhash_sha256q( int thr_id, struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
 
 #endif
 

algo/sha/sha256t.c

@@ -5,8 +5,6 @@
 #include <stdio.h>
 #include <openssl/sha.h>
 
-#if !defined(SHA256T_4WAY)
-
 static __thread SHA256_CTX sha256t_ctx __attribute__ ((aligned (64)));
 
 void sha256t_midstate( const void* input )
@@ -72,8 +70,11 @@ int scanhash_sha256t( int thr_id, struct work *work, uint32_t max_nonce,
 	};
 
    // we need bigendian data...
-   for ( int k = 0; k < 19; k++ )
-      be32enc( &endiandata[k], pdata[k] );
+   casti_m128i( endiandata, 0 ) = mm128_bswap_32( casti_m128i( pdata, 0 ) );
+   casti_m128i( endiandata, 1 ) = mm128_bswap_32( casti_m128i( pdata, 1 ) );
+   casti_m128i( endiandata, 2 ) = mm128_bswap_32( casti_m128i( pdata, 2 ) );
+   casti_m128i( endiandata, 3 ) = mm128_bswap_32( casti_m128i( pdata, 3 ) );
+   casti_m128i( endiandata, 4 ) = mm128_bswap_32( casti_m128i( pdata, 4 ) );
 
    sha256t_midstate( endiandata );
 
@@ -89,7 +90,13 @@ int scanhash_sha256t( int thr_id, struct work *work, uint32_t max_nonce,
             if ( ( !(hash64[7] & mask) ) && fulltest( hash64, ptarget ) )
             {
                *hashes_done = n - first_nonce + 1;
-               return true;
+               work_set_target_ratio( work, hash64 );
+               if ( submit_work( mythr, work ) )
+                  applog( LOG_NOTICE, "Share %d submitted by thread %d.",
+                             accepted_share_count + rejected_share_count + 1,
+                             thr_id );
+               else
+                  applog( LOG_WARNING, "Failed to submit share." );
             }
          } while ( n < max_nonce && !work_restart[thr_id].restart );
          break;
@@ -100,4 +107,3 @@ int scanhash_sha256t( int thr_id, struct work *work, uint32_t max_nonce,
    pdata[19] = n;
    return 0;
 }
-#endif

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

@@ -40,7 +40,7 @@
 
 #include <stddef.h>
 #include "algo/sha/sph_types.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #ifdef __cplusplus
 extern "C"{

algo/shavite/shavite-hash-2way.c

@@ -346,7 +346,7 @@ void shavite512_2way_update_close( shavite512_2way_context *ctx, void *dst,
       memcpy( buf + ptr, data, clen );
       data = (const unsigned char *)data + clen;
       ptr += clen;
-      len -= clen >> 1;
+      len -= (clen >> 1);
       if ( ptr == sizeof ctx->buf )
       {
          if ( ( ctx->count0 = ctx->count0 + 1024 )  == 0 )
@@ -365,16 +365,8 @@ void shavite512_2way_update_close( shavite512_2way_context *ctx, void *dst,
    }
 
    uint32_t vp = ptr>>5;
-
-   // Terminating byte then zero pad
-   casti_m256i( buf, vp++ ) = _mm256_set_epi32( 0,0,0,0x80, 0,0,0,0x80 );
-
-   // Zero pad full vectors up to count
-   for ( ; vp < 6; vp++ )
-       casti_m256i( buf, vp ) = m256_zero;
-
    // Count = { 0, 16, 64, 80 }. Outsize = 16 u32 = 512 bits = 0x0200
-   // Count is misaligned to 16 bits and straddles a vector.
+   // Count is misaligned to 16 bits and straddles 2 vectors.
    // Use u32 overlay to stage then u16 to load buf.
    union
    {
@@ -387,6 +379,18 @@ void shavite512_2way_update_close( shavite512_2way_context *ctx, void *dst,
    count.u32[2] = ctx->count2;
    count.u32[3] = ctx->count3;
 
+   if ( vp == 0 )    // empty buf, xevan.
+   { 
+      casti_m256i( buf, 0 ) = _mm256_set_epi32( 0,0,0,0x80, 0,0,0,0x80 );
+      memset_zero_256( (__m256i*)buf + 1, 5 );
+      ctx->count0 = ctx->count1 = ctx->count2 = ctx->count3 = 0;
+   }
+   else     // half full buf, everyone else.
+   {
+      casti_m256i( buf, vp++ ) = _mm256_set_epi32( 0,0,0,0x80, 0,0,0,0x80 );
+      memset_zero_256( (__m256i*)buf + vp, 6 - vp );
+   }
+
    casti_m256i( buf, 6 ) = _mm256_set_epi16( count.u16[0], 0,0,0,0,0,0,0,
                                              count.u16[0], 0,0,0,0,0,0,0 );
    casti_m256i( buf, 7 ) = _mm256_set_epi16(

algo/shavite/shavite-hash-2way.h

@@ -3,7 +3,7 @@
 
 #if defined(__AVX2__)
   
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 typedef struct {
         unsigned char buf[128<<1];

algo/shavite/sph-shavite-aesni.c

@@ -36,7 +36,7 @@
 #ifdef __AES__
 
 #include "sph_shavite.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #ifdef __cplusplus
 extern "C"{

algo/simd/simd-hash-2way.c

@@ -6,6 +6,12 @@
 
 #if defined (__AVX2__)
 
+union _m256_v16 {
+  uint16_t u16[16];
+  __m256i v256;
+};
+typedef union _m256_v16 m256_v16;
+
 // imported from simd_iv.h
 
 uint32_t SIMD_IV_512[] = { 0x0ba16b95, 0x72f999ad, 0x9fecc2ae, 0xba3264fc,

algo/simd/simd-hash-2way.h

@@ -5,7 +5,7 @@
 
 #if defined(__AVX2__)
 
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 typedef struct {
   uint32_t A[ 32*2 ] __attribute__((aligned(64)));

algo/skein/skein-4way.c

@@ -2,7 +2,11 @@
 #include <string.h>
 #include <stdint.h>
 #include "skein-hash-4way.h"
-#include "algo/sha/sha2-hash-4way.h"
+#if defined(__SHA__)
+  #include <openssl/sha.h>
+#else
+  #include "algo/sha/sha2-hash-4way.h"
+#endif
 
 #if defined (SKEIN_4WAY)
 
@@ -11,53 +15,69 @@ void skeinhash_4way( void *state, const void *input )
      uint64_t vhash64[8*4] __attribute__ ((aligned (64)));
      uint32_t vhash32[16*4] __attribute__ ((aligned (64)));
      skein512_4way_context ctx_skein;
+#if defined(__SHA__)
+     uint32_t hash0[16] __attribute__ ((aligned (64)));
+     uint32_t hash1[16] __attribute__ ((aligned (64)));
+     uint32_t hash2[16] __attribute__ ((aligned (64)));
+     uint32_t hash3[16] __attribute__ ((aligned (64)));
+     SHA256_CTX           ctx_sha256;
+#else
      sha256_4way_context ctx_sha256;
+#endif
 
      skein512_4way_init( &ctx_skein );
      skein512_4way( &ctx_skein, input, 80 );
      skein512_4way_close( &ctx_skein, vhash64 );
 
-     mm256_reinterleave_4x32( vhash32, vhash64, 512 );
+#if defined(__SHA__)      
+     mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash64, 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 );
+
+     mm128_intrlv_4x32( state, hash0, hash1, hash2, hash3, 256 );
+#else
+     mm256_rintrlv_4x64_4x32( vhash32, vhash64, 512 );
 
      sha256_4way_init( &ctx_sha256 );
      sha256_4way( &ctx_sha256, vhash32, 64 );
      sha256_4way_close( &ctx_sha256, state );
-
-     mm128_deinterleave_4x32( state, state+32, state+64, state+96,
-		              vhash32, 256 );
+#endif
 }
 
 int scanhash_skein_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                    uint64_t *hashes_done )
+                         uint64_t *hashes_done, struct thr_info *mythr )
 {
     uint32_t vdata[20*4] __attribute__ ((aligned (64)));
     uint32_t hash[8*4] __attribute__ ((aligned (64)));
     uint32_t lane_hash[8];
     uint32_t *hash7 = &(hash[7<<2]);
-    uint32_t edata[20] __attribute__ ((aligned (64)));
     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;
-    int num_found = 0;
-
-// data is 80 bytes, 20 u32 or 4 u64.
-	
-    swab32_array( edata, pdata, 20 );
- 
-    mm256_interleave_4x64( vdata, edata, edata, edata, edata, 640 );
-
-    uint32_t *noncep = vdata + 73;   // 9*8 + 1
+    __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
+    /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
+   mm256_bswap_intrlv80_4x64( vdata, pdata );
    do
    {
-       be32enc( noncep,   n   );
-       be32enc( noncep+2, n+1 );
-       be32enc( noncep+4, n+2 );
-       be32enc( noncep+6, n+3 );
+       *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+                _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
 
        skeinhash_4way( hash, vdata );
 
@@ -68,16 +88,14 @@ int scanhash_skein_4way( int thr_id, struct work *work, uint32_t max_nonce,
           if ( fulltest( lane_hash, ptarget ) )
           {
              pdata[19] = n + lane;
-             nonces[ num_found++ ] = n + lane;
-             work_set_target_ratio( work, lane_hash );
+             submit_solution( work, lane_hash, mythr, lane );
           }
        }
        n += 4;
-    } while ( (num_found == 0) && (n < max_nonce)
-               && !work_restart[thr_id].restart );
+    } while ( (n < max_nonce) && !work_restart[thr_id].restart );
 
     *hashes_done = n - first_nonce + 1;
-    return num_found;
+    return 0;
 }
 
 #endif

algo/skein/skein-gate.h

@@ -3,24 +3,21 @@
 #include <stdint.h>
 #include "algo-gate-api.h"
 
-// Override multi way on ryzen, SHA is better.
-#if !defined(RYZEN_)
 #if defined(__AVX2__)
   #define SKEIN_4WAY
 #endif
-#endif
 
 #if defined(SKEIN_4WAY)
 
 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 );
+                         uint64_t *hashes_done, struct thr_info *mythr );
 #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 );
+                    uint64_t *hashes_done, struct thr_info *mythr );
 
 #endif

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

@@ -49,7 +49,7 @@ extern "C"{
 
 #include <stddef.h>
 #include "algo/sha/sph_types.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 // Output size in bits
 #define SPH_SIZE_skein256   256

algo/skein/skein.c

@@ -21,8 +21,8 @@ void skeinhash(void *state, const void *input)
      memcpy(state, hash, 32);
 }
 
-int scanhash_skein(int thr_id, struct work *work,
-	uint32_t max_nonce, uint64_t *hashes_done)
+int scanhash_skein( int thr_id, struct work *work, uint32_t max_nonce,
+                    uint64_t *hashes_done, struct thr_info *mythr )
 {
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
@@ -31,7 +31,8 @@ int scanhash_skein(int thr_id, struct work *work,
 	const uint32_t Htarg = ptarget[7];
 	const uint32_t first_nonce = pdata[19];
 	uint32_t n = first_nonce;
-	
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
+
         swab32_array( endiandata, pdata, 20 );
 
 	do {

algo/skein/skein2-4way.c

@@ -20,55 +20,43 @@ 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 )
+                          uint64_t *hashes_done, struct thr_info *mythr )
 {
     uint32_t hash[8*4] __attribute__ ((aligned (64)));
     uint32_t *hash7 = &(hash[25]);
     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;
-    uint32_t *nonces = work->nonces;
-    int num_found = 0;
-
-    swab32_array( endiandata, pdata, 20 );
-
-    mm256_interleave_4x64( vdata, edata, edata, edata, edata, 640 );
-
-    uint32_t *noncep = vdata + 73;   // 9*8 + 1
+    __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
+    /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
+    mm256_bswap_intrlv80_4x64( vdata, pdata );
     do 
     {
-       be32enc( noncep,   n   );
-       be32enc( noncep+2, n+1 );
-       be32enc( noncep+4, n+2 );
-       be32enc( noncep+6, n+3 );
+       *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+                _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
 
-       skein2hash( hash, vdata );
+       skein2hash_4way( hash, vdata );
 
        for ( int lane = 0; lane < 4; lane++ )
-       if ( hash7[ lane ] <= Htarg )
+       if ( hash7[ lane<<1 ] <= Htarg )
        {
-          // deinterleave hash for lane
           uint32_t lane_hash[8];
           mm256_extract_lane_4x64( lane_hash, hash, lane, 256 );
-          if ( fulltest( lane_hash, ptarget ) )
+          if ( fulltest( lane_hash, ptarget ) && !opt_benchmark )
           {
              pdata[19] = n + lane;
-             nonces[ num_found++ ] = n + lane;
-             work_set_target_ratio( work, lane_hash );
+             submit_solution( work, lane_hash, mythr, lane );
           }
        }
        n += 4;
-    } while ( (num_found == 0) && (n < max_nonce)
-             &&  !work_restart[thr_id].restart );
+    } while ( (n < max_nonce) && !work_restart[thr_id].restart );
 
     *hashes_done = n - first_nonce + 1;
-    return num_found;
+    return 0;
 }
 
 #endif

algo/skein/skein2-gate.c

@@ -10,10 +10,9 @@ int64_t skein2_get_max64 ()
 bool register_skein2_algo( algo_gate_t* gate )
 {
   gate->optimizations = AVX2_OPT;
-#if defined (FOUR_WAY) && defined (__AVX2__)
+#if defined (SKEIN2_4WAY)
   gate->scanhash  = (void*)&scanhash_skein2_4way;
   gate->hash      = (void*)&skein2hash_4way;
-  four_way_not_tested();
 #else
   gate->scanhash  = (void*)&scanhash_skein2;
   gate->hash      = (void*)&skein2hash;

algo/skein/skein2-gate.h

@@ -10,11 +10,11 @@
 #if defined(SKEIN2_4WAY)
 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 );
+                          uint64_t* hashes_done, struct thr_info *mythr );
 #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 );
+                     uint64_t *hashes_done, struct thr_info *mythr );
 #endif
 

algo/skein/skein2.c

@@ -34,8 +34,8 @@ void skein2hash(void *output, const void *input)
 
 }
 
-int scanhash_skein2(int thr_id, struct work *work,
-	uint32_t max_nonce, uint64_t *hashes_done)
+int scanhash_skein2( int thr_id, struct work *work,	uint32_t max_nonce,
+                     uint64_t *hashes_done, struct thr_info *mythr )
 {
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
@@ -44,6 +44,7 @@ int scanhash_skein2(int thr_id, struct work *work,
 	const uint32_t Htarg = ptarget[7];
 	const uint32_t first_nonce = pdata[19];
 	uint32_t n = first_nonce;
+    /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
         swab32_array( endiandata, pdata, 20 );
 

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

@@ -59,7 +59,7 @@
 #include <sys/types.h>
 #include <stdint.h>
 #include <string.h>
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 #ifdef __cplusplus
 extern "C" {

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

@@ -52,7 +52,7 @@
 
 #include <stddef.h>
 #include "algo/sha/sph_types.h"
-#include "avxdefs.h"
+#include "simd-utils.h"
 
 /**
  * Output size (in bits) for WHIRLPOOL.

algo/x14/axiom.c

@@ -44,12 +44,13 @@ void axiomhash(void *output, const void *input)
 }
 
 int scanhash_axiom(int thr_id, struct work *work,
-	uint32_t max_nonce, uint64_t *hashes_done)
+	uint32_t max_nonce, uint64_t *hashes_done, struct thr_info *mythr )
 {
         uint32_t *pdata = work->data;
         uint32_t *ptarget = work->target;
 	uint32_t _ALIGN(64) hash64[8];
 	uint32_t _ALIGN(64) endiandata[20];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 
 	const uint32_t Htarg = ptarget[7];
 	const uint32_t first_nonce = pdata[19];

algo/x14/polytimos-4way.c

@@ -13,26 +13,16 @@
 #include "algo/gost/sph_gost.h"
 #include "algo/echo/aes_ni/hash_api.h"
 
-typedef struct {
+union _poly_4way_context_overlay
+{
    skein512_4way_context   skein;
    shabal512_4way_context  shabal;
    hashState_echo          echo;
    luffa_2way_context      luffa;
    sph_fugue512_context    fugue;
    sph_gost512_context     gost;
-} poly_4way_ctx_holder;
-
-poly_4way_ctx_holder poly_4way_ctx;
-
-void init_polytimos_4way_ctx()
-{
-    skein512_4way_init( &poly_4way_ctx.skein );
-    shabal512_4way_init( &poly_4way_ctx.shabal );
-    init_echo( &poly_4way_ctx.echo, 512  );
-    luffa_2way_init( &poly_4way_ctx.luffa, 512 );
-    sph_fugue512_init( &poly_4way_ctx.fugue );
-    sph_gost512_init( &poly_4way_ctx.gost );
-}
+};
+typedef union _poly_4way_context_overlay poly_4way_context_overlay;
 
 void polytimos_4way_hash( void *output, const void *input )
 {
@@ -41,51 +31,57 @@ void polytimos_4way_hash( void *output, const void *input )
      uint64_t hash2[8] __attribute__ ((aligned (64)));
      uint64_t hash3[8] __attribute__ ((aligned (64)));
      uint64_t vhash[8*4] __attribute__ ((aligned (64)));
-     poly_4way_ctx_holder ctx __attribute__ ((aligned (64)));
-     memcpy( &ctx, &poly_4way_ctx, sizeof(poly_4way_ctx) );
+     poly_4way_context_overlay ctx;
 
+     skein512_4way_init( &ctx.skein );
      skein512_4way( &ctx.skein, input, 80 );
      skein512_4way_close( &ctx.skein, vhash );
 
      // Need to convert from 64 bit interleaved to 32 bit interleaved.
      uint32_t vhash32[16*4];
-     mm256_reinterleave_4x32( vhash32, vhash, 512 );
+     mm256_rintrlv_4x64_4x32( vhash32, vhash, 512 );
+     shabal512_4way_init( &ctx.shabal );
      shabal512_4way( &ctx.shabal, vhash32, 64 );
      shabal512_4way_close( &ctx.shabal, vhash32 );
-     mm128_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash32, 512 );
+     mm128_dintrlv_4x32( hash0, hash1, hash2, hash3, vhash32, 512 );
 
+     init_echo( &ctx.echo, 512 );
      update_final_echo ( &ctx.echo, (BitSequence *)hash0,
                          (const BitSequence *)hash0, 512 );
-     memcpy( &ctx.echo, &poly_4way_ctx.echo, sizeof(hashState_echo) );
+     init_echo( &ctx.echo, 512 );
      update_final_echo( &ctx.echo, (BitSequence *)hash1,
                        (const BitSequence *) hash1, 512 );
-     memcpy( &ctx.echo, &poly_4way_ctx.echo, sizeof(hashState_echo) );
+     init_echo( &ctx.echo, 512 );
      update_final_echo( &ctx.echo, (BitSequence *)hash2,
                        (const BitSequence *) hash2, 512 );
-     memcpy( &ctx.echo, &poly_4way_ctx.echo, sizeof(hashState_echo) );
+     init_echo( &ctx.echo, 512 );
      update_final_echo( &ctx.echo, (BitSequence *)hash3,
                        (const BitSequence *) hash3, 512 );
 
-     mm256_interleave_2x128( vhash, hash0, hash1, 512 );
-     luffa_2way_update_close( &ctx.luffa, vhash, vhash, 64 );
-     mm256_deinterleave_2x128( hash0, hash1, vhash, 512 );
-     mm256_interleave_2x128( vhash, hash2, hash3, 512 );
+     mm256_intrlv_2x128( vhash, hash0, hash1, 512 );
      luffa_2way_init( &ctx.luffa, 512 );
      luffa_2way_update_close( &ctx.luffa, vhash, vhash, 64 );
-     mm256_deinterleave_2x128( hash2, hash3, vhash, 512 );
+     mm256_dintrlv_2x128( hash0, hash1, vhash, 512 );
+     mm256_intrlv_2x128( vhash, hash2, hash3, 512 );
+     luffa_2way_init( &ctx.luffa, 512 );
+     luffa_2way_init( &ctx.luffa, 512 );
+     luffa_2way_update_close( &ctx.luffa, vhash, vhash, 64 );
+     mm256_dintrlv_2x128( hash2, hash3, vhash, 512 );
 
+     sph_fugue512_init( &ctx.fugue );
      sph_fugue512( &ctx.fugue, hash0, 64 );
      sph_fugue512_close( &ctx.fugue, hash0 );
-     memcpy( &ctx.fugue, &poly_4way_ctx.fugue, sizeof(sph_fugue512_context) );
+     sph_fugue512_init( &ctx.fugue );
      sph_fugue512( &ctx.fugue, hash1, 64 );
      sph_fugue512_close( &ctx.fugue, hash1 );
-     memcpy( &ctx.fugue, &poly_4way_ctx.fugue, sizeof(sph_fugue512_context) );
+     sph_fugue512_init( &ctx.fugue );
      sph_fugue512( &ctx.fugue, hash2, 64 );
      sph_fugue512_close( &ctx.fugue, hash2 );
-     memcpy( &ctx.fugue, &poly_4way_ctx.fugue, sizeof(sph_fugue512_context) );
+     sph_fugue512_init( &ctx.fugue );
      sph_fugue512( &ctx.fugue, hash3, 64 );
      sph_fugue512_close( &ctx.fugue, hash3 );
 
+     sph_gost512_init( &ctx.gost );
      sph_gost512( &ctx.gost, hash0, 64 );
      sph_gost512_close( &ctx.gost, hash0 );
      sph_gost512_init( &ctx.gost );
@@ -104,51 +100,43 @@ void polytimos_4way_hash( void *output, const void *input )
      memcpy( output+96, hash3, 32 );
 }
 
-int scanhash_polytimos_4way( int thr_id, struct work *work, uint32_t max_nonce,                              uint64_t *hashes_done )
+int scanhash_polytimos_4way( int thr_id, struct work *work, uint32_t max_nonce,
+                             uint64_t *hashes_done, struct thr_info *mythr )
 {
    uint32_t hash[4*8] __attribute__ ((aligned (64)));
    uint32_t vdata[24*4] __attribute__ ((aligned (64)));
-   uint32_t endiandata[20] __attribute__((aligned(64)));
    uint32_t *pdata = work->data;
    uint32_t *ptarget = work->target;
    const uint32_t first_nonce = pdata[19];
    uint32_t n = first_nonce;
-   uint32_t *nonces = work->nonces;
-   int num_found = 0;
-   uint32_t *noncep = vdata + 73;   // 9*8 + 1
+     __m256i  *noncev = (__m256i*)vdata + 9;   // aligned
    const uint32_t Htarg = ptarget[7];
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
    volatile uint8_t *restart = &(work_restart[thr_id].restart);
 
    if ( opt_benchmark )
       ptarget[7] = 0x0cff;
 
-   for ( int i=0; i < 19; i++ )
-      be32enc( &endiandata[i], pdata[i] );
-
-   uint64_t *edata = (uint64_t*)endiandata;
-   mm256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+   mm256_bswap_intrlv80_4x64( vdata, pdata );
    do {
-      be32enc( noncep,   n   );
-      be32enc( noncep+2, n+1 );
-      be32enc( noncep+4, n+2 );
-      be32enc( noncep+6, n+3 );
+      *noncev = mm256_intrlv_blend_32( mm256_bswap_32(
+                 _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ) ), *noncev );
 
       polytimos_4way_hash(hash, vdata);
       pdata[19] = n;
 
-      for ( int i = 0; i < 4; i++ )
-      if ( (hash+(i<<3))[7] <= Htarg && fulltest( hash+(i<<3), ptarget ) )
+      for ( int i = 0; i < 4; i++ ) if ( (hash+(i<<3))[7] <= Htarg )
+      if( fulltest( hash+(i<<3), ptarget ) && !opt_benchmark )
       {
          pdata[19] = n+i;
-         nonces[ num_found++ ] = n+i;
-         work_set_target_ratio( work, hash+(i<<3) );
+         submit_solution( work, hash+(i<<3), mythr, i );
       }
       n += 4;
 
-   } while ( ( num_found == 0 ) && ( n < max_nonce ) && !(*restart));
+   } while ( ( n < max_nonce-4 ) && !(*restart));
 
    *hashes_done = n - first_nonce + 1;
-   return num_found;
+   return 0;
 }
 
 #endif

algo/x14/polytimos-gate.c

@@ -4,7 +4,6 @@ bool register_polytimos_algo( algo_gate_t* gate )
 {
   gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT;
 #ifdef POLYTIMOS_4WAY
-  init_polytimos_4way_ctx();
   gate->scanhash  = (void*)&scanhash_polytimos_4way;
   gate->hash      = (void*)&polytimos_4way_hash;
 #else

algo/x14/polytimos-gate.h

@@ -13,19 +13,14 @@ bool register_polytimos_algo( algo_gate_t* gate );
 #if defined(POLYTIMOS_4WAY)
 
 void polytimos_4way_hash( void *state, const void *input );
-
 int scanhash_polytimos_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                       uint64_t *hashes_done );
-
-void init_polytimos_4way_ctx();
+                       uint64_t *hashes_done, struct thr_info *mythr );
 
 #endif
 
 void polytimos_hash( void *state, const void *input );
-
 int scanhash_polytimos( int thr_id, struct work *work, uint32_t max_nonce,
-                  uint64_t *hashes_done );
-
+                  uint64_t *hashes_done, struct thr_info *mythr );
 void init_polytimos_ctx();
 
 #endif

algo/x14/polytimos.c

@@ -76,13 +76,14 @@ void polytimos_hash(void *output, const void *input)
 	memcpy(output, hashA, 32);
 }
 
-int scanhash_polytimos(int thr_id, struct work *work, uint32_t max_nonce, uint64_t *hashes_done)
+int scanhash_polytimos( int thr_id, struct work *work, uint32_t max_nonce,
+                        uint64_t *hashes_done, struct thr_info *mythr )
 {
 	uint32_t _ALIGN(128) hash[8];
 	uint32_t _ALIGN(128) endiandata[20];
 	uint32_t *pdata = work->data;
 	uint32_t *ptarget = work->target;
-
+   /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
 	const uint32_t Htarg = ptarget[7];
 	const uint32_t first_nonce = pdata[19];
 	uint32_t nonce = first_nonce;

algo/x14/veltor-4way.c

@@ -40,7 +40,7 @@ void veltor_4way_hash( void *output, const void *input )
 
      skein512_4way( &ctx.skein, input, 80 );
      skein512_4way_close( &ctx.skein, vhash );
-     mm256_deinterleave_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
+     mm256_dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
      sph_shavite512( &ctx.shavite, hash0, 64 );
      sph_shavite512_close( &ctx.shavite, hash0 );
@@ -54,10 +54,10 @@ void veltor_4way_hash( void *output, const void *input )
      sph_shavite512( &ctx.shavite, hash3, 64 );
      sph_shavite512_close( &ctx.shavite, hash3 );
 
-     mm128_interleave_4x32( vhash, hash0, hash1, hash2, hash3, 512 );
+     mm128_intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 512 );
      shabal512_4way( &ctx.shabal, vhash, 64 );
      shabal512_4way_close( &ctx.shabal, vhash );
-     mm128_deinterleave_4x32( hash0, hash1, hash2, hash3, vhash, 512 );
+     mm128_dintrlv_4x32( hash0, hash1, hash2, hash3, vhash, 512 );
 
      sph_gost512( &ctx.gost, hash0, 64 );
      sph_gost512_close( &ctx.gost, hash0 );
@@ -78,7 +78,7 @@ void veltor_4way_hash( void *output, const void *input )
 }
 
 int scanhash_veltor_4way( int thr_id, struct work *work, uint32_t max_nonce,
-                          uint64_t *hashes_done )
+                          uint64_t *hashes_done, struct thr_info *mythr )
 {
      uint32_t hash[4*8] __attribute__ ((aligned (64)));
      uint32_t vdata[24*4] __attribute__ ((aligned (64)));
@@ -91,6 +91,7 @@ int scanhash_veltor_4way( int thr_id, struct work *work, uint32_t max_nonce,
      uint32_t *nonces = work->nonces;
      int num_found = 0;
      uint32_t *noncep = vdata + 73;   // 9*8 + 1
+     /* int */ thr_id = mythr->id;  // thr_id arg is deprecated
      volatile uint8_t *restart = &(work_restart[thr_id].restart);
 
      if ( opt_benchmark )
@@ -101,7 +102,7 @@ int scanhash_veltor_4way( int thr_id, struct work *work, uint32_t max_nonce,
      }
 
      uint64_t *edata = (uint64_t*)endiandata;
-     mm256_interleave_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
+     mm256_intrlv_4x64( (uint64_t*)vdata, edata, edata, edata, edata, 640 );
      do
      {
          be32enc( noncep,   n   );