v3.15.0

Makefile.am

@@ -85,6 +85,7 @@ cpuminer_SOURCES = \
   algo/groestl/aes_ni/hash-groestl.c \
   algo/groestl/aes_ni/hash-groestl256.c \
   algo/fugue/sph_fugue.c \
+  algo/fugue/fugue-aesni.c \
   algo/hamsi/sph_hamsi.c \
   algo/hamsi/hamsi-hash-4way.c \
   algo/haval/haval.c \
@@ -257,6 +258,7 @@ cpuminer_SOURCES = \
   algo/x16/hex.c \
   algo/x16/x21s-4way.c \
   algo/x16/x21s.c \
+  algo/x16/minotaur.c \
   algo/x17/x17-gate.c \
   algo/x17/x17.c \
   algo/x17/x17-4way.c \

README.md

@@ -93,6 +93,7 @@ Supported Algorithms
                           lyra2z        
                           lyra2z330     Lyra2 330 rows, Zoin (ZOI)
                           m7m           Magi (XMG)
+                          minotaur      Ringcoin (RNG)
                           myr-gr        Myriad-Groestl
                           neoscrypt     NeoScrypt(128, 2, 1)
                           nist5         Nist5

README.txt

@@ -1,8 +1,8 @@
 This file is included in the Windows binary package. Compile instructions
 for Linux and Windows can be found in RELEASE_NOTES.
 
-cpuminer is a console program that is executed from a DOS command prompt.
-There is no GUI and no mouse support.
+cpuminer is a console program that is executed from a DOS or Powershell
+prompt. There is no GUI and no mouse support.
 
 Miner programs are often flagged as malware by antivirus programs. This is
 a false positive, they are flagged simply because they are cryptocurrency 
@@ -15,8 +15,8 @@ the features listed at cpuminer startup to ensure you are mining at
 optimum speed using the best available features.
 
 Architecture names and compile options used are only provided for Intel
-Core series. Budget CPUs like Pentium and Celeron are often missing the
-latest features.
+Core series. Budget CPUs like Pentium and Celeron are often missing some
+features.
 
 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
@@ -31,14 +31,29 @@ https://en.wikipedia.org/wiki/List_of_Intel_CPU_microarchitectures
 https://en.wikipedia.org/wiki/List_of_AMD_CPU_microarchitectures
 
 
-Exe name                Compile flags            Arch name
+Exe file name              Compile flags              Arch name
 
-cpuminer-sse2.exe      "-msse2"                  Core2, Nehalem   
-cpuminer-aes-sse42.exe "-march=westmere"         Westmere
-cpuminer-avx.exe       "-march=corei7-avx"       Sandybridge
-cpuminer-avx2.exe      "-march=core-avx2 -maes"  Haswell, Skylake, Coffeelake
-cpuminer-avx512.exe    "-march=skylake-avx512"   Skylake-X, Cascadelake-X
-cpuminer-zen           "-march=znver1"           AMD Ryzen, Threadripper
+cpuminer-sse2.exe            "-msse2"                 Core2, Nehalem   
+cpuminer-aes-sse42.exe       "-march=westmere"        Westmere
+cpuminer-avx.exe             "-march=corei7-avx"      Sandybridge, Ivybridge
+cpuminer-avx2.exe            "-march=core-avx2 -maes" Haswell*
+cpuminer-avx512.exe          "-march=skylake-avx512"  Skylake-X, Cascadelake-X
+cpuminer-zen.exe             "-march=znver1"          AMD Ryzen, Threadripper
+cpuminer-avx512-sha-vaes.exe "-march=icelake-client"  Icelake*
+
+* Haswell includes Broadwell, Skylake, Kabylake, Coffeelake & Cometlake. 
+Icelake is only available on some laptops. Mining with a laptop is not
+recommended. The icelake build is included in anticipation of Intel eventually
+releasing a desktop CPU with a microarchitecture newer than Skylake.
+
+Notes about included DLL files:
+
+Downloading DLL files from alternative sources presents an inherent
+security risk if their source is unknown. All DLL files included have
+been copied from the Ubuntu-20.04 instalation or compiled by me from
+source code obtained from the author's official repository. The exact
+procedure is documented in the build instructions for Windows:
+https://github.com/JayDDee/cpuminer-opt/wiki/Compiling-from-source
 
 If you like this software feel free to donate:
 

RELEASE_NOTES

@@ -44,7 +44,7 @@ Please include the following information:
 1. CPU model, operating system, cpuminer-opt version (must be latest),
    binary file for Windows, changes to default build procedure for Linux.
 
-2. Exact comand line (except user and pw) and intial output showing
+2. Exact command line (except user and pw) and intial output showing
    the above requested info.
 
 3. Additional program output showing any error messages or other
@@ -65,6 +65,80 @@ If not what makes it happen or not happen?
 Change Log
 ----------
 
+v3.15.0
+
+Fugue optimized with AES, improves many sha3 algos.
+Minotaur algo optimized for all architectures.
+Fixed neoscrypt BUG log.
+ 
+v3.14.3
+
+#265: more mutex changes to reduce blocking with high thread count.
+
+#267: fixed hodl algo potential memory alignment issue,
+      add warning when thread count is not valid for mining hodl algo.
+
+v3.14.2
+
+The second line of the Share Accepted log is no longer displayed,
+new Xnonce log is added and other small log tweaks.
+
+#265: Cleanup use of mutex.
+
+v3.14.1
+
+GBT and getwork log changes:
+ fixed missing TTF in New Block log,
+ ntime no longer byte-swapped for display in New Work log,
+ fixed zero effective hash rate in Periodic Report log,
+ deleted "Current block is..." log.
+
+Renamed stratum "New Job" log to "New Work" to be consistent with the solo
+version of the log. Added more data to both versions.
+
+v3.14.0
+
+Changes to solo mining:
+  - segwit is supported by getblocktemplate,
+  - longpolling is not working and is disabled,
+  - Periodic Report log is output,
+  - New Block log includes TTF estimates,
+  - Stratum thread no longer created when using getwork or GBT.
+
+Fixed BUG log mining sha256d.
+
+v3.13.1.1
+
+Fixed Windows crash mining minotaur algo.
+
+Fixed GCC 10 compile again.
+Added -fno-common to testing to be consistent with GCC 10 default.
+
+v3.13.1
+
+Added minotaur algo for Ringcoin.
+
+v3.13.0.1
+
+Issue #262: Fixed xevan AVX2 invalid shares.
+
+v3.13.0
+
+Updated Windows binaries compiled with GCC 9. Included DLLs also updated.
+Icelake build (cpuminer-avx512-sha-vaes.exe) now included in Windows
+binaries package.
+
+No source code changes.
+
+v3.12.8.2
+
+Fixed x12 AVX2 rejects.
+Fixed phi AVX2 crash.
+
+v3.12.8.1
+
+Issue #261: Fixed yescryptr8g invalid shares.
+
 v3.12.8
 
 Yespower sha256 prehash made thread safe.

aclocal.m4

@@ -1,6 +1,6 @@
-# generated automatically by aclocal 1.15.1 -*- Autoconf -*-
+# generated automatically by aclocal 1.16.1 -*- Autoconf -*-
 
-# Copyright (C) 1996-2017 Free Software Foundation, Inc.
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
 
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -20,7 +20,7 @@ You have another version of autoconf.  It may work, but is not guaranteed to.
 If you have problems, you may need to regenerate the build system entirely.
 To do so, use the procedure documented by the package, typically 'autoreconf'.])])
 
-# Copyright (C) 2002-2017 Free Software Foundation, Inc.
+# Copyright (C) 2002-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -32,10 +32,10 @@ To do so, use the procedure documented by the package, typically 'autoreconf'.])
 # generated from the m4 files accompanying Automake X.Y.
 # (This private macro should not be called outside this file.)
 AC_DEFUN([AM_AUTOMAKE_VERSION],
-[am__api_version='1.15'
+[am__api_version='1.16'
 dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
 dnl require some minimum version.  Point them to the right macro.
-m4_if([$1], [1.15.1], [],
+m4_if([$1], [1.16.1], [],
       [AC_FATAL([Do not call $0, use AM_INIT_AUTOMAKE([$1]).])])dnl
 ])
 
@@ -51,14 +51,14 @@ m4_define([_AM_AUTOCONF_VERSION], [])
 # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
 # This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
 AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION],
-[AM_AUTOMAKE_VERSION([1.15.1])dnl
+[AM_AUTOMAKE_VERSION([1.16.1])dnl
 m4_ifndef([AC_AUTOCONF_VERSION],
   [m4_copy([m4_PACKAGE_VERSION], [AC_AUTOCONF_VERSION])])dnl
 _AM_AUTOCONF_VERSION(m4_defn([AC_AUTOCONF_VERSION]))])
 
 # Figure out how to run the assembler.                      -*- Autoconf -*-
 
-# Copyright (C) 2001-2017 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -78,7 +78,7 @@ _AM_IF_OPTION([no-dependencies],, [_AM_DEPENDENCIES([CCAS])])dnl
 
 # AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
 
-# Copyright (C) 2001-2017 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -130,7 +130,7 @@ am_aux_dir=`cd "$ac_aux_dir" && pwd`
 
 # AM_CONDITIONAL                                            -*- Autoconf -*-
 
-# Copyright (C) 1997-2017 Free Software Foundation, Inc.
+# Copyright (C) 1997-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -161,7 +161,7 @@ AC_CONFIG_COMMANDS_PRE(
 Usually this means the macro was only invoked conditionally.]])
 fi])])
 
-# Copyright (C) 1999-2017 Free Software Foundation, Inc.
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -352,13 +352,12 @@ _AM_SUBST_NOTMAKE([am__nodep])dnl
 
 # Generate code to set up dependency tracking.              -*- Autoconf -*-
 
-# Copyright (C) 1999-2017 Free Software Foundation, Inc.
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
 
-
 # _AM_OUTPUT_DEPENDENCY_COMMANDS
 # ------------------------------
 AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
@@ -366,49 +365,41 @@ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
   # Older Autoconf quotes --file arguments for eval, but not when files
   # are listed without --file.  Let's play safe and only enable the eval
   # if we detect the quoting.
-  case $CONFIG_FILES in
-  *\'*) eval set x "$CONFIG_FILES" ;;
-  *)   set x $CONFIG_FILES ;;
-  esac
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  AS_CASE([$CONFIG_FILES],
+          [*\'*], [eval set x "$CONFIG_FILES"],
+          [*], [set x $CONFIG_FILES])
   shift
-  for mf
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
   do
     # Strip MF so we end up with the name of the file.
-    mf=`echo "$mf" | sed -e 's/:.*$//'`
-    # Check whether this is an Automake generated Makefile or not.
-    # We used to match only the files named 'Makefile.in', but
-    # some people rename them; so instead we look at the file content.
-    # Grep'ing the first line is not enough: some people post-process
-    # each Makefile.in and add a new line on top of each file to say so.
-    # Grep'ing the whole file is not good either: AIX grep has a line
+    am_mf=`AS_ECHO(["$am_mf"]) | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
     # limit of 2048, but all sed's we know have understand at least 4000.
-    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
-      dirpart=`AS_DIRNAME("$mf")`
-    else
-      continue
-    fi
-    # Extract the definition of DEPDIR, am__include, and am__quote
-    # from the Makefile without running 'make'.
-    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
-    test -z "$DEPDIR" && continue
-    am__include=`sed -n 's/^am__include = //p' < "$mf"`
-    test -z "$am__include" && continue
-    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
-    # Find all dependency output files, they are included files with
-    # $(DEPDIR) in their names.  We invoke sed twice because it is the
-    # simplest approach to changing $(DEPDIR) to its actual value in the
-    # expansion.
-    for file in `sed -n "
-      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
-	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
-      # Make sure the directory exists.
-      test -f "$dirpart/$file" && continue
-      fdir=`AS_DIRNAME(["$file"])`
-      AS_MKDIR_P([$dirpart/$fdir])
-      # echo "creating $dirpart/$file"
-      echo '# dummy' > "$dirpart/$file"
-    done
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`AS_DIRNAME(["$am_mf"])`
+    am_filepart=`AS_BASENAME(["$am_mf"])`
+    AM_RUN_LOG([cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles]) || am_rc=$?
   done
+  if test $am_rc -ne 0; then
+    AC_MSG_FAILURE([Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  Try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).])
+  fi
+  AS_UNSET([am_dirpart])
+  AS_UNSET([am_filepart])
+  AS_UNSET([am_mf])
+  AS_UNSET([am_rc])
+  rm -f conftest-deps.mk
 }
 ])# _AM_OUTPUT_DEPENDENCY_COMMANDS
 
@@ -417,18 +408,17 @@ AC_DEFUN([_AM_OUTPUT_DEPENDENCY_COMMANDS],
 # -----------------------------
 # This macro should only be invoked once -- use via AC_REQUIRE.
 #
-# This code is only required when automatic dependency tracking
-# is enabled.  FIXME.  This creates each '.P' file that we will
-# need in order to bootstrap the dependency handling code.
+# This code is only required when automatic dependency tracking is enabled.
+# This creates each '.Po' and '.Plo' makefile fragment that we'll need in
+# order to bootstrap the dependency handling code.
 AC_DEFUN([AM_OUTPUT_DEPENDENCY_COMMANDS],
 [AC_CONFIG_COMMANDS([depfiles],
      [test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS],
-     [AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"])
-])
+     [AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"])])
 
 # Do all the work for Automake.                             -*- Autoconf -*-
 
-# Copyright (C) 1996-2017 Free Software Foundation, Inc.
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -515,8 +505,8 @@ AC_REQUIRE([AM_PROG_INSTALL_STRIP])dnl
 AC_REQUIRE([AC_PROG_MKDIR_P])dnl
 # For better backward compatibility.  To be removed once Automake 1.9.x
 # dies out for good.  For more background, see:
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
 AC_SUBST([mkdir_p], ['$(MKDIR_P)'])
 # We need awk for the "check" target (and possibly the TAP driver).  The
 # system "awk" is bad on some platforms.
@@ -583,7 +573,7 @@ END
 Aborting the configuration process, to ensure you take notice of the issue.
 
 You can download and install GNU coreutils to get an 'rm' implementation
-that behaves properly: <http://www.gnu.org/software/coreutils/>.
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
 
 If you want to complete the configuration process using your problematic
 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
@@ -625,7 +615,7 @@ for _am_header in $config_headers :; do
 done
 echo "timestamp for $_am_arg" >`AS_DIRNAME(["$_am_arg"])`/stamp-h[]$_am_stamp_count])
 
-# Copyright (C) 2001-2017 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -646,7 +636,7 @@ if test x"${install_sh+set}" != xset; then
 fi
 AC_SUBST([install_sh])])
 
-# Copyright (C) 2003-2017 Free Software Foundation, Inc.
+# Copyright (C) 2003-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -668,7 +658,7 @@ AC_SUBST([am__leading_dot])])
 # Add --enable-maintainer-mode option to configure.         -*- Autoconf -*-
 # From Jim Meyering
 
-# Copyright (C) 1996-2017 Free Software Foundation, Inc.
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -703,7 +693,7 @@ AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
 
 # Check to see how 'make' treats includes.	            -*- Autoconf -*-
 
-# Copyright (C) 2001-2017 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -711,49 +701,42 @@ AC_MSG_CHECKING([whether to enable maintainer-specific portions of Makefiles])
 
 # AM_MAKE_INCLUDE()
 # -----------------
-# Check to see how make treats includes.
+# Check whether make has an 'include' directive that can support all
+# the idioms we need for our automatic dependency tracking code.
 AC_DEFUN([AM_MAKE_INCLUDE],
-[am_make=${MAKE-make}
-cat > confinc << 'END'
+[AC_MSG_CHECKING([whether ${MAKE-make} supports the include directive])
+cat > confinc.mk << 'END'
 am__doit:
-	@echo this is the am__doit target
+	@echo this is the am__doit target >confinc.out
 .PHONY: am__doit
 END
-# If we don't find an include directive, just comment out the code.
-AC_MSG_CHECKING([for style of include used by $am_make])
 am__include="#"
 am__quote=
-_am_result=none
-# First try GNU make style include.
-echo "include confinc" > confmf
-# Ignore all kinds of additional output from 'make'.
-case `$am_make -s -f confmf 2> /dev/null` in #(
-*the\ am__doit\ target*)
-  am__include=include
-  am__quote=
-  _am_result=GNU
-  ;;
-esac
-# Now try BSD make style include.
-if test "$am__include" = "#"; then
-   echo '.include "confinc"' > confmf
-   case `$am_make -s -f confmf 2> /dev/null` in #(
-   *the\ am__doit\ target*)
-     am__include=.include
-     am__quote="\""
-     _am_result=BSD
-     ;;
-   esac
-fi
-AC_SUBST([am__include])
-AC_SUBST([am__quote])
-AC_MSG_RESULT([$_am_result])
-rm -f confinc confmf
-])
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  AM_RUN_LOG([${MAKE-make} -f confmf.$s && cat confinc.out])
+  AS_CASE([$?:`cat confinc.out 2>/dev/null`],
+      ['0:this is the am__doit target'],
+      [AS_CASE([$s],
+          [BSD], [am__include='.include' am__quote='"'],
+          [am__include='include' am__quote=''])])
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+AC_MSG_RESULT([${_am_result}])
+AC_SUBST([am__include])])
+AC_SUBST([am__quote])])
 
 # Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
 
-# Copyright (C) 1997-2017 Free Software Foundation, Inc.
+# Copyright (C) 1997-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -792,7 +775,7 @@ fi
 
 # Helper functions for option handling.                     -*- Autoconf -*-
 
-# Copyright (C) 2001-2017 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -821,7 +804,7 @@ AC_DEFUN([_AM_SET_OPTIONS],
 AC_DEFUN([_AM_IF_OPTION],
 [m4_ifset(_AM_MANGLE_OPTION([$1]), [$2], [$3])])
 
-# Copyright (C) 1999-2017 Free Software Foundation, Inc.
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -868,7 +851,7 @@ AC_LANG_POP([C])])
 # For backward compatibility.
 AC_DEFUN_ONCE([AM_PROG_CC_C_O], [AC_REQUIRE([AC_PROG_CC])])
 
-# Copyright (C) 2001-2017 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -887,7 +870,7 @@ AC_DEFUN([AM_RUN_LOG],
 
 # Check to make sure that the build environment is sane.    -*- Autoconf -*-
 
-# Copyright (C) 1996-2017 Free Software Foundation, Inc.
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -968,7 +951,7 @@ AC_CONFIG_COMMANDS_PRE(
 rm -f conftest.file
 ])
 
-# Copyright (C) 2009-2017 Free Software Foundation, Inc.
+# Copyright (C) 2009-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -1028,7 +1011,7 @@ AC_SUBST([AM_BACKSLASH])dnl
 _AM_SUBST_NOTMAKE([AM_BACKSLASH])dnl
 ])
 
-# Copyright (C) 2001-2017 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -1056,7 +1039,7 @@ fi
 INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
 AC_SUBST([INSTALL_STRIP_PROGRAM])])
 
-# Copyright (C) 2006-2017 Free Software Foundation, Inc.
+# Copyright (C) 2006-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -1075,7 +1058,7 @@ AC_DEFUN([AM_SUBST_NOTMAKE], [_AM_SUBST_NOTMAKE($@)])
 
 # Check how to create a tarball.                            -*- Autoconf -*-
 
-# Copyright (C) 2004-2017 Free Software Foundation, Inc.
+# Copyright (C) 2004-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,

algo-gate-api.c

@@ -90,13 +90,157 @@ void algo_not_implemented()
 }
 
 // default null functions
-
+// deprecated, use generic as default
 int null_scanhash()
 {
    applog(LOG_WARNING,"SWERR: undefined scanhash function in algo_gate");
    return 0;
 }
 
+// Default generic scanhash can be used in many cases.
+int scanhash_generic( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t edata[20] __attribute__((aligned(64)));
+   uint32_t hash[8] __attribute__((aligned(64)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 1;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+
+   mm128_bswap32_80( edata, pdata );
+   do
+   {
+      edata[19] = n;
+      if ( likely( algo_gate.hash( hash, edata, thr_id ) ) )
+      if ( unlikely( valid_hash( hash, ptarget ) && !bench ) )
+      {
+         pdata[19] = bswap_32( n );
+         submit_solution( work, hash, mythr );
+      }
+      n++;
+   } while ( n < last_nonce && !work_restart[thr_id].restart );
+   *hashes_done = n - first_nonce;
+   pdata[19] = n;
+   return 0;
+}
+
+#if defined(__AVX2__)
+
+//int scanhash_4way_64_64( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+//int scanhash_4way_64_640( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+int scanhash_4way_64in_32out( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash32[8*4] __attribute__ ((aligned (64)));
+   uint32_t vdata[20*4] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash32_d7 = &(hash32[ 7*4 ]);
+   uint32_t *pdata = work->data;
+   const uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 4;
+   __m256i  *noncev = (__m256i*)vdata + 9;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const uint32_t targ32_d7 = ptarget[7];
+   const bool bench = opt_benchmark;
+
+   mm256_bswap32_intrlv80_4x64( vdata, pdata );
+   *noncev = mm256_intrlv_blend_32(
+                   _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
+   do
+   {
+      if ( likely( algo_gate.hash( hash32, vdata, thr_id ) ) )
+      for ( int lane = 0; lane < 4; lane++ )
+      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 && !bench ) )
+      {
+         extr_lane_4x32( lane_hash, hash32, lane, 256 );
+         if ( valid_hash( lane_hash, ptarget ) )
+         {
+            pdata[19] = bswap_32( n + lane );
+            submit_solution( work, lane_hash, mythr );
+         }
+      }
+      *noncev = _mm256_add_epi32( *noncev,
+                                  m256_const1_64( 0x0000000400000000 ) );
+      n += 4;
+   } while ( likely( ( n <= last_nonce ) && !work_restart[thr_id].restart ) );
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+//int scanhash_8way_32_32( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+#endif
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+//int scanhash_8way_64_64( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+//int scanhash_8way_64_640( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+int scanhash_8way_64in_32out( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t hash32[8*8] __attribute__ ((aligned (128)));
+   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
+   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
+   uint32_t *hash32_d7 = &(hash32[7*8]);
+   uint32_t *pdata = work->data;
+   const uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 8;
+   __m512i  *noncev = (__m512i*)vdata + 9;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const uint32_t targ32_d7 = ptarget[7];
+   const bool bench = opt_benchmark;
+
+   mm512_bswap32_intrlv80_8x64( vdata, pdata );
+   *noncev = mm512_intrlv_blend_32(
+              _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0,
+                                n+3, 0, n+2, 0, n+1, 0, n,   0 ), *noncev );
+   do
+   {
+      if ( likely( algo_gate.hash( hash32, vdata, thr_id ) ) )
+      for ( int lane = 0; lane < 8; lane++ )
+      if ( unlikely( ( hash32_d7[ lane ] <= targ32_d7 ) && !bench ) )
+      {
+         extr_lane_8x32( lane_hash, hash32, lane, 256 );
+         if ( likely( valid_hash( lane_hash, ptarget ) ) )
+         {
+            pdata[19] = bswap_32( n + lane );
+            submit_solution( work, lane_hash, mythr );
+         }
+      }
+      *noncev = _mm512_add_epi32( *noncev,
+                                  m512_const1_64( 0x0000000800000000 ) );
+      n += 8;
+   } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
+   pdata[19] = n;
+   *hashes_done = n - first_nonce;
+   return 0;
+}
+
+//int scanhash_16way_32_32( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr )
+
+#endif
+
+
+
 int null_hash()
 {
    applog(LOG_WARNING,"SWERR: null_hash unsafe null function");
@@ -106,7 +250,7 @@ int null_hash()
 void init_algo_gate( algo_gate_t* gate )
 {
    gate->miner_thread_init       = (void*)&return_true;
-   gate->scanhash                = (void*)&null_scanhash;
+   gate->scanhash                = (void*)&scanhash_generic;
    gate->hash                    = (void*)&null_hash;
    gate->get_new_work            = (void*)&std_get_new_work;
    gate->work_decode             = (void*)&std_le_work_decode;
@@ -179,6 +323,7 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
     case ALGO_LYRA2Z:        register_lyra2z_algo        ( gate ); break;
     case ALGO_LYRA2Z330:     register_lyra2z330_algo     ( gate ); break;
     case ALGO_M7M:           register_m7m_algo           ( gate ); break;
+    case ALGO_MINOTAUR:      register_minotaur_algo      ( gate ); break;
     case ALGO_MYR_GR:        register_myriad_algo        ( gate ); break;
     case ALGO_NEOSCRYPT:     register_neoscrypt_algo     ( gate ); break;
     case ALGO_NIST5:         register_nist5_algo         ( gate ); break;
@@ -251,7 +396,6 @@ bool register_algo_gate( int algo, algo_gate_t *gate )
 // restore warnings
 #pragma GCC diagnostic pop
 
-// run the alternate hash function for a specific algo
 void exec_hash_function( int algo, void *output, const void *pdata )
 {
   algo_gate_t gate;   

algo-gate-api.h

@@ -110,11 +110,13 @@ inline bool set_excl ( set_t a, set_t b ) { return (a & b) == 0; }
 
 typedef struct
 {
-// mandatory function, must be overwritten
+// Mandatory functions, one of these is mandatory. If a generic scanhash
+// is used a custom hash function must be registered, with a custom scanhash
+// the custom hash function can be called directly and doesn't need to be
+// registered in the gate. 
 int ( *scanhash ) ( struct work*, uint32_t, uint64_t*, struct thr_info* );
 
-// Deprecated, will be removed
-int ( *hash )     ( void*, const void*, uint32_t ) ;
+int ( *hash )     ( void*, const void*, int );
 
 //optional, safe to use default in most cases
 
@@ -126,7 +128,7 @@ bool ( *miner_thread_init )     ( int );
 void ( *get_new_work )          ( struct work*, struct work*, int, uint32_t* );
 
 // Decode getwork blockheader
-bool ( *work_decode )           ( const json_t*, struct work* );
+bool ( *work_decode )           ( struct work* );
 
 // Extra getwork data
 void ( *decode_extra_data )     ( struct work*, uint64_t* );
@@ -201,15 +203,61 @@ void four_way_not_tested();
 #define STD_WORK_DATA_SIZE 128
 #define STD_WORK_CMP_SIZE 76
 
-#define JR2_NONCE_INDEX 39  // 8 bit offset
+//#define JR2_NONCE_INDEX 39  // 8 bit offset
 
 // These indexes are only used with JSON RPC2 and are not gated.
-#define JR2_WORK_CMP_INDEX_2 43
-#define JR2_WORK_CMP_SIZE_2 33
+//#define JR2_WORK_CMP_INDEX_2 43
+//#define JR2_WORK_CMP_SIZE_2 33
 
-// allways returns failure
+// deprecated, use generic instead
 int null_scanhash();
 
+// Default generic, may be used in many cases.
+// N-way is more complicated, requires many different implementations
+// depending on architecture, input format, and output format.
+// Naming convention is scanhash_[N]way_[input format]in_[output format]out
+// N = number of lanes
+// input/output format:
+//    32: 32 bit interleaved parallel lanes
+//    64: 64 bit interleaved parallel lanes
+//    640: input only, not interleaved, contiguous serial 640 bit lanes.
+//    256: output only, not interleaved, contiguous serial 256 bit lanes.
+
+int scanhash_generic( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
+
+#if defined(__AVX2__)
+
+//int scanhash_4way_64in_64out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+//int scanhash_4way_64in_256out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+int scanhash_4way_64in_32out( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
+
+//int scanhash_8way_32in_32out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+#endif
+
+#if defined(__AVX512F__) && defined(__AVX512VL__) && defined(__AVX512DQ__) && defined(__AVX512BW__)
+
+//int scanhash_8way_64in_64out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+//int scanhash_8way_64in_256out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+int scanhash_8way_64in_32out( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr );
+
+//int scanhash_16way_32in_32out( struct work *work, uint32_t max_nonce,
+//                      uint64_t *hashes_done, struct thr_info *mythr );
+
+#endif
+
 // displays warning
 int null_hash    ();
 
@@ -221,8 +269,8 @@ void std_get_new_work( struct work *work, struct work *g_work, int thr_id,
 void sha256d_gen_merkle_root( char *merkle_root, struct stratum_ctx *sctx );
 void SHA256_gen_merkle_root ( char *merkle_root, struct stratum_ctx *sctx );
 
-bool std_le_work_decode( const json_t *val, struct work *work );
-bool std_be_work_decode( const json_t *val, struct work *work );
+bool std_le_work_decode( struct work *work );
+bool std_be_work_decode( struct work *work );
 
 bool std_le_submit_getwork_result( CURL *curl, struct work *work );
 bool std_be_submit_getwork_result( CURL *curl, struct work *work );
@@ -257,7 +305,7 @@ int std_get_work_data_size();
 // by calling the algo's register function.
 bool register_algo_gate( int algo, algo_gate_t *gate );
 
-// Called by algos toverride any default gate functions that are applicable
+// Called by algos to verride any default gate functions that are applicable
 // and do any other algo-specific initialization.
 // The register functions for all the algos can be declared here to reduce
 // compiler warnings but that's just more work for devs adding new algos.

algo/blake/decred-gate.c

@@ -78,7 +78,6 @@ void decred_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
    uint32_t extraheader[32] = { 0 };
    int headersize = 0;
    uint32_t* extradata = (uint32_t*) sctx->xnonce1;
-   size_t t;
    int i;
 
    // getwork over stratum, getwork merkle + header passed in coinb1
@@ -87,9 +86,6 @@ void decred_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
                   sizeof(extraheader) );
    memcpy( extraheader, &sctx->job.coinbase[32], headersize );
 
-   // Increment extranonce2 
-   for ( t = 0; t < sctx->xnonce2_size && !( ++sctx->job.xnonce2[t] ); t++ );
-
    // Assemble block header 
    memset( g_work->data, 0, sizeof(g_work->data) );
    g_work->data[0] = le32dec( sctx->job.version );

algo/fugue/fugue-aesni.c

@@ -0,0 +1,567 @@
+/*
+ * file        : fugue_vperm.c
+ * version     : 1.0.208
+ * date        : 14.12.2010
+ * 
+ * - vperm and aes_ni implementations of hash function Fugue
+ * - implements NIST hash api
+ * - assumes that message lenght is multiple of 8-bits
+ * - _FUGUE_VPERM_ must be defined if compiling with ../main.c
+ * - default version is vperm, define AES_NI for aes_ni version
+ * 
+ * Cagdas Calik
+ * ccalik@metu.edu.tr
+ * Institute of Applied Mathematics, Middle East Technical University, Turkey.
+ *
+ */
+
+#if defined(__AES__)
+
+#include <x86intrin.h>
+
+#include <memory.h>
+#include "fugue-aesni.h"
+
+
+MYALIGN const unsigned long long _supermix1a[]	= {0x0202010807020100, 0x0a05000f06010c0b};
+MYALIGN const unsigned long long _supermix1b[]	= {0x0b0d080703060504, 0x0e0a090c050e0f0a};
+MYALIGN const unsigned long long _supermix1c[]	= {0x0402060c070d0003, 0x090a060580808080};
+MYALIGN const unsigned long long _supermix1d[]	= {0x808080800f0e0d0c, 0x0f0e0d0c80808080};
+MYALIGN const unsigned long long _supermix2a[]	= {0x07020d0880808080, 0x0b06010c050e0f0a};
+MYALIGN const unsigned long long _supermix4a[]	= {0x000f0a050c0b0601, 0x0302020404030e09};
+MYALIGN const unsigned long long _supermix4b[]	= {0x07020d08080e0d0d, 0x07070908050e0f0a};
+MYALIGN const unsigned long long _supermix4c[]	= {0x0706050403020000, 0x0302000007060504};
+MYALIGN const unsigned long long _supermix7a[]	= {0x010c0b060d080702, 0x0904030e03000104};
+MYALIGN const unsigned long long _supermix7b[]	= {0x8080808080808080, 0x0504070605040f06};
+MYALIGN const unsigned long long _k_n[] = {0x4E4E4E4E4E4E4E4E, 0x1B1B1B1B0E0E0E0E};
+MYALIGN const unsigned int _maskd3n[] = {0xffffffff, 0xffffffff, 0xffffffff, 0x00000000};
+MYALIGN const unsigned char _shift_one_mask[]   = {7, 4, 5, 6, 11, 8, 9, 10, 15, 12, 13, 14, 3, 0, 1, 2};
+MYALIGN const unsigned char _shift_four_mask[]  = {13, 14, 15, 12, 1, 2, 3, 0, 5, 6, 7, 4, 9, 10, 11, 8};
+MYALIGN const unsigned char _shift_seven_mask[] = {10, 11, 8, 9, 14, 15, 12, 13, 2, 3, 0, 1, 6, 7, 4, 5};
+MYALIGN const unsigned char _aes_shift_rows[]   = {0, 5, 10, 15, 4, 9, 14, 3, 8, 13, 2, 7, 12, 1, 6, 11};
+MYALIGN const unsigned int _inv_shift_rows[] = {0x070a0d00, 0x0b0e0104, 0x0f020508, 0x0306090c};
+MYALIGN const unsigned int _zero[] = {0x00000000, 0x00000000, 0x00000000, 0x00000000};
+MYALIGN const unsigned int _mul2mask[] = {0x1b1b0000, 0x00000000, 0x00000000, 0x00000000};
+MYALIGN const unsigned int _mul4mask[] = {0x2d361b00, 0x00000000, 0x00000000, 0x00000000};
+MYALIGN const unsigned int _lsbmask2[] = {0x03030303, 0x03030303, 0x03030303, 0x03030303};
+
+
+MYALIGN const unsigned int _IV512[] = {		
+	0x00000000, 0x00000000,	0x7ea50788, 0x00000000,
+	0x75af16e6, 0xdbe4d3c5, 0x27b09aac, 0x00000000,
+	0x17f115d9, 0x54cceeb6, 0x0b02e806, 0x00000000,
+	0xd1ef924a, 0xc9e2c6aa, 0x9813b2dd, 0x00000000,
+	0x3858e6ca, 0x3f207f43, 0xe778ea25, 0x00000000,
+	0xd6dd1f95, 0x1dd16eda, 0x67353ee1, 0x00000000};
+
+#if defined(__SSE4_1__)
+
+#define PACK_S0(s0, s1, t1)\
+   s0 = _mm_castps_si128(_mm_insert_ps(_mm_castsi128_ps(s0), _mm_castsi128_ps(s1), 0x30))
+
+#define UNPACK_S0(s0, s1, t1)\
+   s1 = _mm_castps_si128(_mm_insert_ps(_mm_castsi128_ps(s1), _mm_castsi128_ps(s0), 0xc0));\
+   s0 = _mm_and_si128(s0, M128(_maskd3n))
+
+#define CMIX(s1, s2, r1, r2, t1, t2)\
+   t1 = s1;\
+   t1 = _mm_castps_si128(_mm_shuffle_ps(_mm_castsi128_ps(t1), _mm_castsi128_ps(s2), _MM_SHUFFLE(3, 0, 2, 1)));\
+   r1 = _mm_xor_si128(r1, t1);\
+   r2 = _mm_xor_si128(r2, t1);
+
+#else   // SSE2
+
+#define PACK_S0(s0, s1, t1)\
+   t1 = _mm_shuffle_epi32(s1, _MM_SHUFFLE(0, 3, 3, 3));\
+   s0 = _mm_xor_si128(s0, t1);
+
+#define UNPACK_S0(s0, s1, t1)\
+   t1 = _mm_shuffle_epi32(s0, _MM_SHUFFLE(3, 3, 3, 3));\
+   s1 = _mm_castps_si128(_mm_move_ss(_mm_castsi128_ps(s1), _mm_castsi128_ps(t1)));\
+   s0 = _mm_and_si128(s0, M128(_maskd3n))
+
+#define CMIX(s1, s2, r1, r2, t1, t2)\
+   t1 = _mm_shuffle_epi32(s1, 0xf9);\
+   t2 = _mm_shuffle_epi32(s2, 0xcf);\
+   t1 = _mm_xor_si128(t1, t2);\
+   r1 = _mm_xor_si128(r1, t1);\
+   r2 = _mm_xor_si128(r2, t1)
+
+#endif
+
+#define TIX256(msg, s10, s8, s24, s0, t1, t2, t3)\
+	t1 = _mm_shuffle_epi32(s0, _MM_SHUFFLE(3, 3, 0, 3));\
+	s10 = _mm_xor_si128(s10, t1);\
+	t1 = _mm_castps_si128(_mm_load_ss((float*)msg));\
+	s0 = _mm_castps_si128(_mm_move_ss(_mm_castsi128_ps(s0), _mm_castsi128_ps(t1)));\
+	t1 = _mm_slli_si128(t1, 8);\
+	s8 = _mm_xor_si128(s8, t1);\
+	t1 = _mm_shuffle_epi32(s24, _MM_SHUFFLE(3, 3, 0, 3));\
+	s0 = _mm_xor_si128(s0, t1)
+
+
+#define TIX384(msg, s16, s8, s27, s30, s0, s4, t1, t2, t3)\
+	t1 = _mm_shuffle_epi32(s0, _MM_SHUFFLE(3, 3, 0, 3));\
+	s16 = _mm_xor_si128(s16, t1);\
+	t1 = _mm_castps_si128(_mm_load_ss((float*)msg));\
+	s0 = _mm_castps_si128(_mm_move_ss(_mm_castsi128_ps(s0), _mm_castsi128_ps(t1)));\
+	t1 = _mm_slli_si128(t1, 8);\
+	s8 = _mm_xor_si128(s8, t1);\
+	t1 = _mm_shuffle_epi32(s27, _MM_SHUFFLE(3, 3, 0, 3));\
+	s0 = _mm_xor_si128(s0, t1);\
+	t1 = _mm_shuffle_epi32(s30, _MM_SHUFFLE(3, 3, 0, 3));\
+	s4 = _mm_xor_si128(s4, t1)
+
+#define TIX512(msg, s22, s8, s24, s27, s30, s0, s4, s7, t1, t2, t3)\
+	t1 = _mm_shuffle_epi32(s0, _MM_SHUFFLE(3, 3, 0, 3));\
+	s22 = _mm_xor_si128(s22, t1);\
+	t1 = _mm_castps_si128(_mm_load_ss((float*)msg));\
+	s0 = _mm_castps_si128(_mm_move_ss(_mm_castsi128_ps(s0), _mm_castsi128_ps(t1)));\
+	t1 = _mm_slli_si128(t1, 8);\
+	s8 = _mm_xor_si128(s8, t1);\
+	t1 = _mm_shuffle_epi32(s24, _MM_SHUFFLE(3, 3, 0, 3));\
+	s0 = _mm_xor_si128(s0, t1);\
+	t1 = _mm_shuffle_epi32(s27, _MM_SHUFFLE(3, 3, 0, 3));\
+	s4 = _mm_xor_si128(s4, t1);\
+	t1 = _mm_shuffle_epi32(s30, _MM_SHUFFLE(3, 3, 0, 3));\
+	s7 = _mm_xor_si128(s7, t1)
+
+
+#define PRESUPERMIX(x, t1, s1, s2, t2)\
+	s1 = x;\
+	s2 = _mm_add_epi8(x, x);\
+	t2 = _mm_add_epi8(s2, s2);\
+	t1 = _mm_srli_epi16(x, 6);\
+	t1 = _mm_and_si128(t1, M128(_lsbmask2));\
+	s2 = _mm_xor_si128(s2, _mm_shuffle_epi8(M128(_mul2mask), t1));\
+	x  = _mm_xor_si128(t2, _mm_shuffle_epi8(M128(_mul4mask), t1))
+
+#define SUBSTITUTE(r0, _t1, _t2, _t3, _t0)\
+	_t2 = _mm_shuffle_epi8(r0, M128(_inv_shift_rows));\
+	_t2 = _mm_aesenclast_si128(_t2, M128(_zero))
+	
+#define SUPERMIX(t0, t1, t2, t3, t4)\
+	PRESUPERMIX(t0, t1, t2, t3, t4);\
+	POSTSUPERMIX(t0, t1, t2, t3, t4)
+
+
+#define POSTSUPERMIX(t0, t1, t2, t3, t4)\
+	t1 = t2;\
+	t1 = _mm_shuffle_epi8(t1, M128(_supermix1b));\
+	t4 = t1;\
+	t1 = _mm_shuffle_epi8(t1, M128(_supermix1c));\
+	t4 = _mm_xor_si128(t4, t1);\
+	t1 = t4;\
+	t1 = _mm_shuffle_epi8(t1, M128(_supermix1d));\
+	t4 = _mm_xor_si128(t4, t1);\
+	t1 = t2;\
+	t1 = _mm_shuffle_epi8(t1, M128(_supermix1a));\
+	t4 = _mm_xor_si128(t4, t1);\
+	t2 = _mm_xor_si128(t2, t3);\
+	t2 = _mm_xor_si128(t2, t0);\
+	t2 = _mm_shuffle_epi8(t2, M128(_supermix7a));\
+	t4 = _mm_xor_si128(t4, t2);\
+	t2 = _mm_shuffle_epi8(t2, M128(_supermix7b));\
+	t4 = _mm_xor_si128(t4, t2);\
+	t3 = _mm_shuffle_epi8(t3, M128(_supermix2a));\
+	t1 = t0;\
+	t1 = _mm_shuffle_epi8(t1, M128(_supermix4a));\
+	t4 = _mm_xor_si128(t4, t1);\
+	t0 = _mm_shuffle_epi8(t0, M128(_supermix4b));\
+	t0 = _mm_xor_si128(t0, t3);\
+	t4 = _mm_xor_si128(t4, t0);\
+	t0 = _mm_shuffle_epi8(t0, M128(_supermix4c));\
+	t4 = _mm_xor_si128(t4, t0)
+
+
+#define SUBROUND512_3(r1a, r1b, r1c, r1d, r2a, r2b, r2c, r2d, r3a, r3b, r3c, r3d)\
+	CMIX(r1a, r1b, r1c, r1d, _t0, _t1);\
+	PACK_S0(r1c, r1a, _t0);\
+	SUBSTITUTE(r1c, _t1, _t2, _t3, _t0);\
+	SUPERMIX(_t2, _t3, _t0, _t1, r1c);\
+	_t0 = _mm_shuffle_epi32(r1c, 0x39);\
+	r2c = _mm_xor_si128(r2c, _t0);\
+	_t0 = _mm_and_si128(_t0, M128(_maskd3n));\
+	r2d = _mm_xor_si128(r2d, _t0);\
+	UNPACK_S0(r1c, r1a, _t3);\
+	SUBSTITUTE(r2c, _t1, _t2, _t3, _t0);\
+	SUPERMIX(_t2, _t3, _t0, _t1, r2c);\
+	_t0 = _mm_shuffle_epi32(r2c, 0x39);\
+	r3c = _mm_xor_si128(r3c, _t0);\
+	_t0 = _mm_and_si128(_t0, M128(_maskd3n));\
+	r3d = _mm_xor_si128(r3d, _t0);\
+	UNPACK_S0(r2c, r2a, _t3);\
+	SUBSTITUTE(r3c, _t1, _t2, _t3, _t0);\
+	SUPERMIX(_t2, _t3, _t0, _t1, r3c);\
+	UNPACK_S0(r3c, r3a, _t3)
+
+
+#define SUBROUND512_4(r1a, r1b, r1c, r1d, r2a, r2b, r2c, r2d, r3a, r3b, r3c, r3d, r4a, r4b, r4c, r4d)\
+	CMIX(r1a, r1b, r1c, r1d, _t0, _t1);\
+	PACK_S0(r1c, r1a, _t0);\
+	SUBSTITUTE(r1c, _t1, _t2, _t3, _t0);\
+	SUPERMIX(_t2, _t3, _t0, _t1, r1c);\
+	_t0 = _mm_shuffle_epi32(r1c, 0x39);\
+	r2c = _mm_xor_si128(r2c, _t0);\
+	_t0 = _mm_and_si128(_t0, M128(_maskd3n));\
+	r2d = _mm_xor_si128(r2d, _t0);\
+	UNPACK_S0(r1c, r1a, _t3);\
+	SUBSTITUTE(r2c, _t1, _t2, _t3, _t0);\
+	SUPERMIX(_t2, _t3, _t0, _t1, r2c);\
+	_t0 = _mm_shuffle_epi32(r2c, 0x39);\
+	r3c = _mm_xor_si128(r3c, _t0);\
+	_t0 = _mm_and_si128(_t0, M128(_maskd3n));\
+	r3d = _mm_xor_si128(r3d, _t0);\
+	UNPACK_S0(r2c, r2a, _t3);\
+	SUBSTITUTE(r3c, _t1, _t2, _t3, _t0);\
+	SUPERMIX(_t2, _t3, _t0, _t1, r3c);\
+	_t0 = _mm_shuffle_epi32(r3c, 0x39);\
+	r4c = _mm_xor_si128(r4c, _t0);\
+	_t0 = _mm_and_si128(_t0, M128(_maskd3n));\
+	r4d = _mm_xor_si128(r4d, _t0);\
+	UNPACK_S0(r3c, r3a, _t3);\
+	SUBSTITUTE(r4c, _t1, _t2, _t3, _t0);\
+	SUPERMIX(_t2, _t3, _t0, _t1, r4c);\
+	UNPACK_S0(r4c, r4a, _t3)
+
+
+
+#define LOADCOLUMN(x, s, a)\
+	block[0] = col[(base + a + 0) % s];\
+	block[1] = col[(base + a + 1) % s];\
+	block[2] = col[(base + a + 2) % s];\
+	block[3] = col[(base + a + 3) % s];\
+	x = _mm_load_si128((__m128i*)block)
+
+#define STORECOLUMN(x, s)\
+	_mm_store_si128((__m128i*)block, x);\
+	col[(base + 0) % s] = block[0];\
+	col[(base + 1) % s] = block[1];\
+	col[(base + 2) % s] = block[2];\
+	col[(base + 3) % s] = block[3]
+
+void Compress512(hashState_fugue *ctx, const unsigned char *pmsg, unsigned int uBlockCount)
+{
+   __m128i _t0, _t1, _t2, _t3;
+
+   switch(ctx->base)
+   {
+      case 1:
+         TIX512( pmsg, ctx->state[3], ctx->state[10], ctx->state[4],
+                       ctx->state[5], ctx->state[ 6], ctx->state[8],
+		       ctx->state[9], ctx->state[10], _t0, _t1, _t2 );
+
+	 SUBROUND512_4( ctx->state[8], ctx->state[9], ctx->state[7],
+                        ctx->state[1], ctx->state[7], ctx->state[8],
+		       	ctx->state[6], ctx->state[0], ctx->state[6],
+		       	ctx->state[7], ctx->state[5], ctx->state[11],
+		       	ctx->state[5], ctx->state[6], ctx->state[4],
+		       	ctx->state[10] );
+         ctx->base++;
+         pmsg += 4;
+         uBlockCount--;
+      if( uBlockCount == 0 ) break;
+
+      case 2:
+         TIX512( pmsg, ctx->state[11], ctx->state[6], ctx->state[0],
+                       ctx->state[ 1], ctx->state[2], ctx->state[4],
+		       ctx->state[ 5], ctx->state[6], _t0, _t1, _t2);
+
+         SUBROUND512_4( ctx->state[4], ctx->state[5], ctx->state[3],
+                        ctx->state[9], ctx->state[3], ctx->state[4],
+		       	ctx->state[2], ctx->state[8], ctx->state[2],
+		       	ctx->state[3], ctx->state[1], ctx->state[7],
+		       	ctx->state[1], ctx->state[2], ctx->state[0],
+		       	ctx->state[6]);
+
+         ctx->base = 0;
+         pmsg += 4;
+         uBlockCount--;
+      break;
+   }
+
+
+   while( uBlockCount > 0 )
+   {
+      TIX512( pmsg, ctx->state[ 7], ctx->state[2], ctx->state[8], ctx->state[9],
+                    ctx->state[10], ctx->state[0], ctx->state[1], ctx->state[2],
+              _t0, _t1, _t2 );
+      SUBROUND512_4( ctx->state[0], ctx->state[1], ctx->state[11],
+                     ctx->state[5], ctx->state[11], ctx->state[0],
+		     ctx->state[10], ctx->state[4], ctx->state[10],
+		     ctx->state[11], ctx->state[9], ctx->state[3],
+		     ctx->state[9], ctx->state[10], ctx->state[8],
+		     ctx->state[2] );
+
+      ctx->base++;
+      pmsg += 4;
+      uBlockCount--;
+      if( uBlockCount == 0 ) break;
+
+      TIX512( pmsg, ctx->state[3], ctx->state[10], ctx->state[4], ctx->state[5],
+                    ctx->state[6], ctx->state[8], ctx->state[9], ctx->state[10],
+              _t0, _t1, _t2 );
+
+      SUBROUND512_4( ctx->state[8], ctx->state[9], ctx->state[7], ctx->state[1],                     ctx->state[7], ctx->state[8], ctx->state[6], ctx->state[0],
+		     ctx->state[6], ctx->state[7], ctx->state[5], ctx->state[11],
+		     ctx->state[5], ctx->state[6, ctx->state[4], ctx->state[10]);
+
+      ctx->base++;
+      pmsg += 4;
+      uBlockCount--;
+      if( uBlockCount == 0 ) break;
+
+      TIX512( pmsg, ctx->state[11], ctx->state[6], ctx->state[0], ctx->state[1],
+		    ctx->state[2], ctx->state[4], ctx->state[5], ctx->state[6],
+               _t0, _t1, _t2);
+      SUBROUND512_4( ctx->state[4], ctx->state[5], ctx->state[3], ctx->state[9],
+		     ctx->state[3], ctx->state[4], ctx->state[2], ctx->state[8],
+		     ctx->state[2], ctx->state[3], ctx->state[1], ctx->state[7],
+		     ctx->state[1], ctx->state[2], ctx->state[0], ctx->state[6]);
+
+      ctx->base = 0;
+      pmsg += 4;
+      uBlockCount--;
+   }
+
+}
+
+void Final512(hashState_fugue *ctx, BitSequence *hashval)
+{
+        unsigned int block[4] __attribute__ ((aligned (32)));
+        unsigned int col[36] __attribute__ ((aligned (16)));
+	unsigned int i, base;
+	__m128i r0, _t0, _t1, _t2, _t3;
+
+	for(i = 0; i < 12; i++)
+	{
+		_mm_store_si128((__m128i*)block, ctx->state[i]);
+
+		col[3 * i + 0] = block[0];
+		col[3 * i + 1] = block[1];
+		col[3 * i + 2] = block[2];
+	}
+
+	base = (36 - (12 * ctx->base)) % 36;
+
+	for(i = 0; i < 32; i++)
+	{
+		// ROR3
+		base = (base + 33) % 36;
+
+		// CMIX
+		col[(base +  0) % 36] ^= col[(base + 4) % 36];
+		col[(base +  1) % 36] ^= col[(base + 5) % 36];
+		col[(base +  2) % 36] ^= col[(base + 6) % 36];
+		col[(base +  18) % 36] ^= col[(base + 4) % 36];
+		col[(base +  19) % 36] ^= col[(base + 5) % 36];
+		col[(base +  20) % 36] ^= col[(base + 6) % 36];
+
+		// SMIX
+		LOADCOLUMN(r0, 36, 0);
+		SUBSTITUTE(r0, _t1, _t2, _t3, _t0);
+		SUPERMIX(_t2, _t3, _t0, _t1, r0);
+		STORECOLUMN(r0, 36);
+	}
+
+	for(i = 0; i < 13; i++)
+	{
+		// S4 += S0; S9 += S0; S18 += S0; S27 += S0;
+		col[(base +  4) % 36] ^= col[(base + 0) % 36];
+		col[(base +  9) % 36] ^= col[(base + 0) % 36];
+		col[(base + 18) % 36] ^= col[(base + 0) % 36];
+		col[(base + 27) % 36] ^= col[(base + 0) % 36];
+
+		// ROR9
+		base = (base + 27) % 36;
+
+		// SMIX
+		LOADCOLUMN(r0, 36, 0);
+		SUBSTITUTE(r0, _t1, _t2, _t3, _t0);
+		SUPERMIX(_t2, _t3, _t0, _t1, r0);
+		STORECOLUMN(r0, 36);
+
+		// S4 += S0; S10 += S0; S18 += S0; S27 += S0;
+		col[(base +  4) % 36] ^= col[(base + 0) % 36];
+		col[(base + 10) % 36] ^= col[(base + 0) % 36];
+		col[(base + 18) % 36] ^= col[(base + 0) % 36];
+		col[(base + 27) % 36] ^= col[(base + 0) % 36];
+
+		// ROR9
+		base = (base + 27) % 36;
+
+		// SMIX
+		LOADCOLUMN(r0, 36, 0);
+		SUBSTITUTE(r0, _t1, _t2, _t3, _t0);
+		SUPERMIX(_t2, _t3, _t0, _t1, r0);
+		STORECOLUMN(r0, 36);
+
+		// S4 += S0; S10 += S0; S19 += S0; S27 += S0;
+		col[(base +  4) % 36] ^= col[(base + 0) % 36];
+		col[(base + 10) % 36] ^= col[(base + 0) % 36];
+		col[(base + 19) % 36] ^= col[(base + 0) % 36];
+		col[(base + 27) % 36] ^= col[(base + 0) % 36];
+
+		// ROR9
+		base = (base + 27) % 36;
+
+		// SMIX
+		LOADCOLUMN(r0, 36, 0);
+		SUBSTITUTE(r0, _t1, _t2, _t3, _t0);
+		SUPERMIX(_t2, _t3, _t0, _t1, r0);
+		STORECOLUMN(r0, 36);
+
+		// S4 += S0; S10 += S0; S19 += S0; S28 += S0;
+		col[(base +  4) % 36] ^= col[(base + 0) % 36];
+		col[(base + 10) % 36] ^= col[(base + 0) % 36];
+		col[(base + 19) % 36] ^= col[(base + 0) % 36];
+		col[(base + 28) % 36] ^= col[(base + 0) % 36];
+
+		// ROR8
+		base = (base + 28) % 36;
+
+		// SMIX
+		LOADCOLUMN(r0, 36, 0);
+		SUBSTITUTE(r0, _t1, _t2, _t3, _t0);
+		SUPERMIX(_t2, _t3, _t0, _t1, r0);
+		STORECOLUMN(r0, 36);
+	}
+
+	// S4 += S0; S9 += S0; S18 += S0; S27 += S0;
+	col[(base +  4) % 36] ^= col[(base + 0) % 36];
+	col[(base +  9) % 36] ^= col[(base + 0) % 36];
+	col[(base + 18) % 36] ^= col[(base + 0) % 36];
+	col[(base + 27) % 36] ^= col[(base + 0) % 36];
+
+	// Transform to the standard basis and store output; S1 || S2 || S3 || S4
+	LOADCOLUMN(r0, 36, 1);
+	_mm_store_si128((__m128i*)hashval, r0);
+
+	// Transform to the standard basis and store output; S9 || S10 || S11 || S12
+	LOADCOLUMN(r0, 36, 9);
+	_mm_store_si128((__m128i*)hashval + 1, r0);
+
+	// Transform to the standard basis and store output; S18 || S19 || S20 || S21
+	LOADCOLUMN(r0, 36, 18);
+	_mm_store_si128((__m128i*)hashval + 2, r0);
+
+	// Transform to the standard basis and store output; S27 || S28 || S29 || S30
+	LOADCOLUMN(r0, 36, 27);
+	_mm_store_si128((__m128i*)hashval + 3, r0);
+}
+
+HashReturn fugue512_Init(hashState_fugue *ctx, int nHashSize)
+{
+	int i;
+	ctx->processed_bits = 0;
+	ctx->uBufferBytes = 0;
+	ctx->base = 0;
+
+
+	ctx->uHashSize = 512;
+	ctx->uBlockLength = 4;
+
+	for(i = 0; i < 6; i++)
+		ctx->state[i] = _mm_setzero_si128();
+
+	ctx->state[6]  = _mm_load_si128((__m128i*)_IV512 + 0);
+	ctx->state[7]  = _mm_load_si128((__m128i*)_IV512 + 1);
+	ctx->state[8]  = _mm_load_si128((__m128i*)_IV512 + 2);
+	ctx->state[9]  = _mm_load_si128((__m128i*)_IV512 + 3);
+	ctx->state[10] = _mm_load_si128((__m128i*)_IV512 + 4);
+	ctx->state[11] = _mm_load_si128((__m128i*)_IV512 + 5);
+
+	return SUCCESS;
+}
+
+
+HashReturn fugue512_Update(hashState_fugue *state, const void *data, DataLength databitlen)
+{
+	unsigned int uByteLength, uBlockCount, uRemainingBytes;
+
+	uByteLength = (unsigned int)(databitlen / 8);
+
+	if(state->uBufferBytes + uByteLength >= state->uBlockLength)
+	{
+		if(state->uBufferBytes != 0)
+		{
+			// Fill the buffer
+			memcpy(state->buffer + state->uBufferBytes, (void*)data, state->uBlockLength - state->uBufferBytes);
+
+			// Process the buffer
+			Compress512(state, state->buffer, 1);
+
+			state->processed_bits += state->uBlockLength * 8;
+			data += state->uBlockLength - state->uBufferBytes;
+			uByteLength -= state->uBlockLength - state->uBufferBytes;
+		}
+
+		// buffer now does not contain any unprocessed bytes
+
+		uBlockCount = uByteLength / state->uBlockLength;
+		uRemainingBytes = uByteLength % state->uBlockLength;
+
+		if(uBlockCount > 0)
+		{
+			Compress512(state, data, uBlockCount);
+
+			state->processed_bits += uBlockCount * state->uBlockLength * 8;
+			data += uBlockCount * state->uBlockLength;
+		}
+
+		if(uRemainingBytes > 0)
+		{
+			memcpy(state->buffer, (void*)data, uRemainingBytes);
+		}
+
+		state->uBufferBytes = uRemainingBytes;
+	}
+	else
+	{
+		memcpy(state->buffer + state->uBufferBytes, (void*)data, uByteLength);
+		state->uBufferBytes += uByteLength;
+	}
+
+	return SUCCESS;
+}
+
+HashReturn fugue512_Final(hashState_fugue *state, void *hashval)
+{
+	unsigned int i;
+	BitSequence lengthbuf[8] __attribute__((aligned(64)));
+
+	// Update message bit count
+	state->processed_bits += state->uBufferBytes * 8;
+
+	// Pad the remaining buffer bytes with zero
+	if(state->uBufferBytes != 0)
+	{
+	   if ( state->uBufferBytes != state->uBlockLength)
+		memset(state->buffer + state->uBufferBytes, 0, state->uBlockLength - state->uBufferBytes);
+
+	   Compress512(state, state->buffer, 1);
+	}
+
+	// Last two blocks are message length in bits
+	for(i = 0; i < 8; i++)
+           lengthbuf[i] = ((state->processed_bits) >> (8 * (7 - i))) & 0xff;
+
+	// Process the last two blocks
+	Compress512(state, lengthbuf, 2);
+
+	// Finalization
+	Final512(state, hashval);
+
+	return SUCCESS;
+}
+
+
+HashReturn fugue512_full(hashState_fugue *hs, void *hashval, const void *data, DataLength databitlen)
+{
+	fugue512_Init(hs, 512);
+	fugue512_Update(hs, data, databitlen*8);
+	fugue512_Final(hs, hashval);
+	return SUCCESS;
+}
+
+#endif  // AES

algo/fugue/fugue-aesni.h

@@ -0,0 +1,46 @@
+/*
+ * file        : hash_api.h
+ * version     : 1.0.208
+ * date        : 14.12.2010
+ * 
+ * Fugue vperm implementation Hash API
+ *
+ * Cagdas Calik
+ * ccalik@metu.edu.tr
+ * Institute of Applied Mathematics, Middle East Technical University, Turkey.
+ *
+ */
+
+#ifndef FUGUE_HASH_API_H
+#define FUGUE_HASH_API_H
+
+#if defined(__AES__)
+
+#include "algo/sha/sha3_common.h"
+#include <x86intrin.h>
+
+
+typedef struct
+{
+	__m128i			state[12];
+	unsigned int	base;
+
+	unsigned int	uHashSize;
+	unsigned int	uBlockLength;
+	unsigned int	uBufferBytes;
+	DataLength		processed_bits;
+	BitSequence		buffer[4];
+
+} hashState_fugue __attribute__ ((aligned (64)));
+
+HashReturn fugue512_Init(hashState_fugue *state, int hashbitlen);
+
+HashReturn fugue512_Update(hashState_fugue *state, const void *data, DataLength databitlen);
+
+HashReturn fugue512_Final(hashState_fugue *state, void *hashval);
+
+HashReturn fugue512_full(hashState_fugue *hs, void *hashval, const void *data, DataLength databitlen);
+
+#endif // AES
+#endif // HASH_API_H
+

algo/hodl/hodl-gate.c

@@ -99,9 +99,13 @@ void hodl_build_block_header( struct work* g_work, uint32_t version,
 // called only by thread 0, saves a backup of g_work
 void hodl_get_new_work( struct work* work, struct work* g_work)
 {
-     work_free( &hodl_work );
-     work_copy( &hodl_work, g_work );
-     hodl_work.data[ algo_gate.nonce_index ] = ( clock() + rand() ) % 9999;
+   pthread_rwlock_rdlock( &g_work_lock );
+
+   work_free( &hodl_work );
+   work_copy( &hodl_work, g_work );
+   hodl_work.data[ algo_gate.nonce_index ] = ( clock() + rand() ) % 9999;
+
+   pthread_rwlock_unlock( &g_work_lock );
 }
 
 json_t *hodl_longpoll_rpc_call( CURL *curl, int *err, char* lp_url )
@@ -155,11 +159,10 @@ bool register_hodl_algo( algo_gate_t* gate )
   applog( LOG_ERR, "Only CPUs with AES are supported, use legacy version.");
   return false;
 #endif
-//  if ( TOTAL_CHUNKS % opt_n_threads )
-//  {
-//     applog(LOG_ERR,"Thread count must be power of 2.");
-//     return false;
-//  }
+
+  if ( GARBAGE_SIZE % opt_n_threads )
+     applog( LOG_WARNING,"WARNING: Thread count must be power of 2. Miner may crash or produce invalid hash!" );
+
   pthread_barrier_init( &hodl_barrier, NULL, opt_n_threads );
   gate->optimizations         = SSE42_OPT | AES_OPT | AVX2_OPT;
   gate->scanhash              = (void*)&hodl_scanhash;
@@ -171,7 +174,7 @@ bool register_hodl_algo( algo_gate_t* gate )
   gate->resync_threads        = (void*)&hodl_resync_threads;
   gate->do_this_thread        = (void*)&hodl_do_this_thread;
   gate->work_cmp_size         = 76;
-  hodl_scratchbuf = (unsigned char*)malloc( 1 << 30 );
+  hodl_scratchbuf = (unsigned char*)_mm_malloc( 1 << 30, 64 );
   allow_getwork = false;
   opt_target_factor = 8388608.0;
   return ( hodl_scratchbuf != NULL );

algo/hodl/hodl-wolf.c

@@ -70,7 +70,7 @@ int scanhash_hodl_wolf( struct work* work, uint32_t max_nonce,
     uint32_t *ptarget = work->target;
     int threadNumber = mythr->id;
     CacheEntry *Garbage = (CacheEntry*)hodl_scratchbuf;
-    CacheEntry Cache[AES_PARALLEL_N];
+    CacheEntry Cache[AES_PARALLEL_N] __attribute__ ((aligned (64)));
     __m128i* data[AES_PARALLEL_N];
     const __m128i* next[AES_PARALLEL_N];
     uint32_t CollisionCount = 0;

algo/lyra2/lyra2-gate.c

@@ -215,9 +215,6 @@ void phi2_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
    size_t t;
 
    algo_gate.gen_merkle_root( merkle_tree, sctx );
-   // Increment extranonce2
-   for ( t = 0; t < sctx->xnonce2_size && !( ++sctx->job.xnonce2[t] ); t++ );
-   // Assemble block header
    algo_gate.build_block_header( g_work, le32dec( sctx->job.version ),
                   (uint32_t*) sctx->job.prevhash, (uint32_t*) merkle_tree,
                   le32dec( sctx->job.ntime ), le32dec(sctx->job.nbits), NULL );
@@ -225,7 +222,6 @@ void phi2_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
       g_work->data[ 20+t ] = ((uint32_t*)sctx->job.extra)[t];
 }
 
-
 bool register_phi2_algo( algo_gate_t* gate )
 {
    gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT | VAES_OPT;

algo/nist5/zr5.c

@@ -156,6 +156,8 @@ int scanhash_zr5( struct work *work, uint32_t max_nonce,
 void zr5_get_new_work( struct work* work, struct work* g_work, int thr_id,
                        uint32_t* end_nonce_ptr )
 {
+   pthread_rwlock_rdlock( &g_work_lock );
+
    // ignore POK in first word
    const int wkcmp_sz = 72;  // (19-1) * sizeof(uint32_t)
    uint32_t *nonceptr = work->data + algo_gate.nonce_index;
@@ -171,6 +173,8 @@ void zr5_get_new_work( struct work* work, struct work* g_work, int thr_id,
    }
    else
        ++(*nonceptr);
+
+   pthread_rwlock_unlock( &g_work_lock );
 }
 
 void zr5_display_pok( struct work* work )

algo/quark/hmq1725-4way.c

@@ -16,7 +16,7 @@
 #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/fugue/fugue-aesni.h"
 #include "algo/shabal/shabal-hash-4way.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/haval/haval-hash-4way.h"
@@ -40,7 +40,7 @@ union _hmq1725_8way_context_overlay
     cube_4way_context       cube;
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_8way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_8way_context     sha512;
@@ -363,14 +363,14 @@ extern void hmq1725_8way_hash(void *state, const void *input)
    dintrlv_8x64_512( hash0, hash1, hash2, hash3,
                      hash4, hash5, hash6, hash7, vhash );
 
-   sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-   sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-   sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-   sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
-   sph_fugue512_full( &ctx.fugue, hash4, hash4, 64 );
-   sph_fugue512_full( &ctx.fugue, hash5, hash5, 64 );
-   sph_fugue512_full( &ctx.fugue, hash6, hash6, 64 );
-   sph_fugue512_full( &ctx.fugue, hash7, hash7, 64 );
+   fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+   fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+   fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+   fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+   fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+   fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+   fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+   fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
    intrlv_8x64_512( vhash, hash0, hash1, hash2, hash3,
                            hash4, hash5, hash6, hash7 );
@@ -459,21 +459,21 @@ extern void hmq1725_8way_hash(void *state, const void *input)
                                        m512_zero );
 
    if ( hash0[0] & mask )
-      sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+      fugue512_full( &ctx.fugue, hash0, hash0, 64 );
    if ( hash1[0] & mask )
-      sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+      fugue512_full( &ctx.fugue, hash1, hash1, 64 );
    if ( hash2[0] & mask )
-      sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+      fugue512_full( &ctx.fugue, hash2, hash2, 64 );
    if ( hash3[0] & mask )
-      sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+      fugue512_full( &ctx.fugue, hash3, hash3, 64 );
    if ( hash4[0] & mask )
-      sph_fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+      fugue512_full( &ctx.fugue, hash4, hash4, 64 );
    if ( hash5[0] & mask )
-      sph_fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+      fugue512_full( &ctx.fugue, hash5, hash5, 64 );
    if ( hash6[0] & mask )
-      sph_fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+      fugue512_full( &ctx.fugue, hash6, hash6, 64 );
    if ( hash7[0] & mask )
-      sph_fugue512_full( &ctx.fugue, hash7, hash7, 64 );
+      fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
    intrlv_8x64_512( vhashA, hash0, hash1, hash2, hash3,
                             hash4, hash5, hash6, hash7 );
@@ -628,7 +628,7 @@ union _hmq1725_4way_context_overlay
     simd_2way_context       simd;
     hashState_echo          echo;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_4way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_4way_context     sha512;
@@ -846,10 +846,10 @@ extern void hmq1725_4way_hash(void *state, const void *input)
 
     dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
-    sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-    sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-    sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-    sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+    fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+    fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+    fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+    fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
     // In this situation serial simd seems to be faster.
 
@@ -920,13 +920,13 @@ extern void hmq1725_4way_hash(void *state, const void *input)
    h_mask = _mm256_movemask_epi8( vh_mask );
 
    if ( hash0[0] & mask ) 
-      sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+      fugue512_full( &ctx.fugue, hash0, hash0, 64 );
    if ( hash1[0] & mask ) 
-      sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+      fugue512_full( &ctx.fugue, hash1, hash1, 64 );
    if ( hash2[0] & mask ) 
-      sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+      fugue512_full( &ctx.fugue, hash2, hash2, 64 );
    if ( hash3[0] & mask ) 
-      sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+      fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
    intrlv_4x64( vhashA, hash0, hash1, hash2, hash3, 512 );
 

algo/quark/hmq1725.c

@@ -21,9 +21,11 @@
 #if defined(__AES__)
   #include "algo/groestl/aes_ni/hash-groestl.h"
   #include "algo/echo/aes_ni/hash_api.h"
+  #include "algo/fugue/fugue-aesni.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 #include "algo/luffa/luffa_for_sse2.h"
 #include "algo/cubehash/cubehash_sse2.h"
@@ -40,7 +42,6 @@ typedef struct {
   sph_shavite512_context  shavite1, shavite2;
   hashState_sd            simd1, simd2;
   sph_hamsi512_context    hamsi1;
-  sph_fugue512_context    fugue1, fugue2;
   sph_shabal512_context   shabal1;
   sph_whirlpool_context   whirlpool1, whirlpool2, whirlpool3, whirlpool4;
   SHA512_CTX              sha1, sha2;
@@ -48,9 +49,11 @@ typedef struct {
 #if defined(__AES__)
   hashState_echo          echo1, echo2;
   hashState_groestl       groestl1, groestl2;
+  hashState_fugue         fugue1, fugue2;
 #else
   sph_groestl512_context  groestl1, groestl2;
   sph_echo512_context     echo1, echo2;
+  sph_fugue512_context    fugue1, fugue2;
 #endif
 } hmq1725_ctx_holder;
 
@@ -88,8 +91,13 @@ void init_hmq1725_ctx()
 
     sph_hamsi512_init(&hmq1725_ctx.hamsi1);
 
+#if defined(__AES__)
+    fugue512_Init( &hmq1725_ctx.fugue1, 512 );
+    fugue512_Init( &hmq1725_ctx.fugue2, 512 );
+#else
     sph_fugue512_init(&hmq1725_ctx.fugue1);
     sph_fugue512_init(&hmq1725_ctx.fugue2);
+#endif
 
     sph_shabal512_init(&hmq1725_ctx.shabal1);
 
@@ -235,8 +243,13 @@ extern void hmq1725hash(void *state, const void *input)
     sph_hamsi512 (&h_ctx.hamsi1, hashA, 64); //3
     sph_hamsi512_close(&h_ctx.hamsi1, hashB); //4
 
+#if defined(__AES__)
+    fugue512_Update( &h_ctx.fugue1, hashB, 512 ); //2   ////
+    fugue512_Final( &h_ctx.fugue1, hashA ); //3 
+#else
     sph_fugue512 (&h_ctx.fugue1, hashB, 64); //2   ////
     sph_fugue512_close(&h_ctx.fugue1, hashA); //3 
+#endif
 
     if ( hashA[0] & mask ) //4
     {
@@ -262,8 +275,13 @@ extern void hmq1725hash(void *state, const void *input)
 
     if ( hashB[0] & mask ) //7
     {
+#if defined(__AES__)
+        fugue512_Update( &h_ctx.fugue2, hashB, 512 ); //
+        fugue512_Final( &h_ctx.fugue2, hashA ); //8
+#else
         sph_fugue512 (&h_ctx.fugue2, hashB, 64); //
         sph_fugue512_close(&h_ctx.fugue2, hashA); //8
+#endif
     }
     else
     {

algo/ripemd/lbry-gate.c

@@ -69,13 +69,9 @@ void lbry_build_block_header( struct work* g_work, uint32_t version,
 void lbry_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
 {
    unsigned char merkle_root[64] = { 0 };
-   size_t t;
    int i;
 
    algo_gate.gen_merkle_root( merkle_root, sctx );
-   // Increment extranonce2 
-   for ( t = 0; t < sctx->xnonce2_size && !( ++sctx->job.xnonce2[t] ); t++ );
-   // Assemble block header 
 
    memset( g_work->data, 0, sizeof(g_work->data) );
    g_work->data[0] = le32dec( sctx->job.version );

algo/scrypt/neoscrypt.c

@@ -1051,16 +1051,16 @@ int scanhash_neoscrypt( struct work *work,
     uint32_t _ALIGN(64) hash[8];
     const uint32_t Htarg = ptarget[7];
     const uint32_t first_nonce = pdata[19];
-    int thr_id = mythr->id;  // thr_id arg is deprecated
+    int thr_id = mythr->id; 
 
     while (pdata[19] < max_nonce && !work_restart[thr_id].restart)
     {
         neoscrypt((uint8_t *) hash, (uint8_t *) pdata );
 
         /* Quick hash check */
-        if (hash[7] <= Htarg && fulltest_le(hash, ptarget)) {
-            *hashes_done = pdata[19] - first_nonce + 1;
-            return 1;
+        if (hash[7] <= Htarg && fulltest_le(hash, ptarget))
+        {
+          submit_solution( work, hash, mythr );
         }
 
         pdata[19]++;

algo/sha/sha2.c

@@ -479,8 +479,8 @@ static inline void sha256d_ms(uint32_t *hash, uint32_t *W,
 void sha256d_ms_4way(uint32_t *hash,  uint32_t *data,
 	const uint32_t *midstate, const uint32_t *prehash);
 
-static inline int scanhash_sha256d_4way(int thr_id, struct work *work,
-             uint32_t max_nonce, uint64_t *hashes_done)
+static inline int scanhash_sha256d_4way( 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;
@@ -492,6 +492,7 @@ static inline int scanhash_sha256d_4way(int thr_id, struct work *work,
 	uint32_t n = pdata[19] - 1;
 	const uint32_t first_nonce = pdata[19];
 	const uint32_t Htarg = ptarget[7];
+   int thr_id = mythr->id;
 	int i, j;
 	
 	memcpy(data, pdata + 16, 64);
@@ -521,10 +522,8 @@ static inline int scanhash_sha256d_4way(int thr_id, struct work *work,
 			if (swab32(hash[4 * 7 + i]) <= Htarg) {
 				pdata[19] = data[4 * 3 + i];
 				sha256d_80_swap(hash, pdata);
-				if (fulltest(hash, ptarget)) {
-					*hashes_done = n - first_nonce + 1;
-					return 1;
-				}
+            if ( fulltest( hash, ptarget ) && !opt_benchmark )
+               submit_solution( work, hash, mythr );
 			}
 		}
 	} while (n < max_nonce && !work_restart[thr_id].restart);
@@ -541,8 +540,8 @@ static inline int scanhash_sha256d_4way(int thr_id, struct work *work,
 void sha256d_ms_8way(uint32_t *hash,  uint32_t *data,
 	const uint32_t *midstate, const uint32_t *prehash);
 
-static inline int scanhash_sha256d_8way(int thr_id, struct work *work,
-                              uint32_t max_nonce, uint64_t *hashes_done)
+static inline int scanhash_sha256d_8way( 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;
@@ -554,6 +553,7 @@ static inline int scanhash_sha256d_8way(int thr_id, struct work *work,
 	uint32_t n = pdata[19] - 1;
 	const uint32_t first_nonce = pdata[19];
 	const uint32_t Htarg = ptarget[7];
+   int thr_id = mythr->id;
 	int i, j;
 	
 	memcpy(data, pdata + 16, 64);
@@ -583,10 +583,8 @@ static inline int scanhash_sha256d_8way(int thr_id, struct work *work,
 			if (swab32(hash[8 * 7 + i]) <= Htarg) {
 				pdata[19] = data[8 * 3 + i];
 				sha256d_80_swap(hash, pdata);
-				if (fulltest(hash, ptarget)) {
-					*hashes_done = n - first_nonce + 1;
-					return 1;
-				}
+            if ( fulltest( hash, ptarget ) && !opt_benchmark )
+               submit_solution( work, hash, mythr );
 			}
 		}
 	} while (n < max_nonce && !work_restart[thr_id].restart);
@@ -614,13 +612,11 @@ int scanhash_sha256d( struct work *work,
 
 #ifdef HAVE_SHA256_8WAY
 	if (sha256_use_8way())
-		return scanhash_sha256d_8way(thr_id, work,
-			max_nonce, hashes_done);
+		return scanhash_sha256d_8way( work,	max_nonce, hashes_done, mythr );
 #endif
 #ifdef HAVE_SHA256_4WAY
 	if (sha256_use_4way())
-		return scanhash_sha256d_4way(thr_id, work,
-			max_nonce, hashes_done);
+		return scanhash_sha256d_4way( work,	max_nonce, hashes_done, mythr );
 #endif
 	
 	memcpy(data, pdata + 16, 64);
@@ -657,7 +653,7 @@ int scanhash_SHA256d( struct work *work, const uint32_t max_nonce,
    uint32_t n = pdata[19] - 1;
    const uint32_t first_nonce = pdata[19];
    const uint32_t Htarg = ptarget[7];
-   int thr_id = mythr->id;  // thr_id arg is deprecated
+   int thr_id = mythr->id;
 
    memcpy( data, pdata, 80 );
 

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

@@ -731,7 +731,7 @@ void skein512_8way_full( skein512_8way_context *sc, void *out, const void *data,
 void
 skein512_8way_prehash64( skein512_8way_context *sc, const void *data )
 {
-   __m512i *vdata = (__m512*)data;
+   __m512i *vdata = (__m512i*)data;
    __m512i *buf = sc->buf;
    buf[0] = vdata[0];
    buf[1] = vdata[1];
@@ -1099,6 +1099,7 @@ skein512_4way_final16( skein512_4way_context *sc,  void *out, const void *data )
    casti_m256i( out, 7 ) = h7;
 }
 
+// Broken for 80 bytes, use prehash.
 void
 skein256_4way_update(void *cc, const void *data, size_t len)
 {

algo/x12/x12-4way.c

@@ -170,6 +170,9 @@ void x12_8way_hash( void *state, const void *input )
      dintrlv_4x128_512( hash0, hash1, hash2, hash3, vhashA );
      dintrlv_4x128_512( hash4, hash5, hash6, hash7, vhashB );
 
+     update_final_echo( &ctx.echo, (BitSequence *)hash0,
+                       (const BitSequence *) hash0, 512 );
+     memcpy( &ctx.echo, &x12_8way_ctx.echo, sizeof(hashState_echo) );
      update_final_echo( &ctx.echo, (BitSequence *)hash1,
                        (const BitSequence *) hash1, 512 );
      memcpy( &ctx.echo, &x12_8way_ctx.echo, sizeof(hashState_echo) );
@@ -363,6 +366,18 @@ void x12_4way_hash( void *state, const void *input )
      simd_2way_update_close( &ctx.simd, vhash, vhash, 512 );
      dintrlv_2x128( hash2, hash3, vhash, 512 );
 
+     update_final_echo( &ctx.echo, (BitSequence *)hash0,
+                       (const BitSequence *) hash0, 512 );
+     memcpy( &ctx.echo, &x12_4way_ctx.echo, sizeof(hashState_echo) );
+     update_final_echo( &ctx.echo, (BitSequence *)hash1,
+                       (const BitSequence *) hash1, 512 );
+     memcpy( &ctx.echo, &x12_4way_ctx.echo, sizeof(hashState_echo) );
+     update_final_echo( &ctx.echo, (BitSequence *)hash2,
+                       (const BitSequence *) hash2, 512 );
+     memcpy( &ctx.echo, &x12_4way_ctx.echo, sizeof(hashState_echo) );
+     update_final_echo( &ctx.echo, (BitSequence *)hash3,
+                       (const BitSequence *) hash3, 512 );
+     
      update_and_final_groestl( &ctx.groestl, (char*)hash0, (char*)hash0, 512 );
      memcpy( &ctx.groestl, &x12_4way_ctx.groestl, sizeof(hashState_groestl) );
      update_and_final_groestl( &ctx.groestl, (char*)hash1, (char*)hash1, 512 );

algo/x13/phi1612-4way.c

@@ -7,7 +7,7 @@
 #include "algo/jh/jh-hash-4way.h"
 #include "algo/cubehash/cubehash_sse2.h"
 #include "algo/cubehash/cube-hash-2way.h"
-#include "algo/fugue/sph_fugue.h"
+#include "algo/fugue/fugue-aesni.h"
 #include "algo/gost/sph_gost.h"
 #include "algo/echo/aes_ni/hash_api.h"
 #if defined(__VAES__)
@@ -20,7 +20,7 @@ typedef struct {
     skein512_8way_context   skein;
     jh512_8way_context      jh;
     cube_4way_context       cube;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     sph_gost512_context     gost;
 #if defined(__VAES__)
     echo_4way_context       echo;
@@ -36,7 +36,7 @@ void init_phi1612_8way_ctx()
      skein512_8way_init( &phi1612_8way_ctx.skein );
      jh512_8way_init( &phi1612_8way_ctx.jh );
      cube_4way_init( &phi1612_8way_ctx.cube, 512, 16, 32 );
-     sph_fugue512_init( &phi1612_8way_ctx.fugue );
+     fugue512_Init( &phi1612_8way_ctx.fugue, 512 );
      sph_gost512_init( &phi1612_8way_ctx.gost );
 #if defined(__VAES__)
      echo_4way_init( &phi1612_8way_ctx.echo, 512 );
@@ -79,29 +79,14 @@ void phi1612_8way_hash( void *state, const void *input )
      dintrlv_4x128_512( hash4, hash5, hash6, hash7, vhash );
 
      // 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 );
-     sph_fugue512_init( &ctx.fugue );
-     sph_fugue512( &ctx.fugue, hash4, 64 );
-     sph_fugue512_close( &ctx.fugue, hash4 );
-     sph_fugue512_init( &ctx.fugue );
-     sph_fugue512( &ctx.fugue, hash5, 64 );
-     sph_fugue512_close( &ctx.fugue, hash5 );
-     sph_fugue512_init( &ctx.fugue );
-     sph_fugue512( &ctx.fugue, hash6, 64 );
-     sph_fugue512_close( &ctx.fugue, hash6 );
-     sph_fugue512_init( &ctx.fugue );
-     sph_fugue512( &ctx.fugue, hash7, 64 );
-     sph_fugue512_close( &ctx.fugue, hash7 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+     fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+     fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+     fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
      // Gost
      sph_gost512( &ctx.gost, hash0, 64 );
@@ -223,7 +208,7 @@ typedef struct {
     skein512_4way_context   skein;
     jh512_4way_context      jh;
     cubehashParam           cube;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     sph_gost512_context     gost;
     hashState_echo          echo;
 } phi1612_4way_ctx_holder;
@@ -235,7 +220,6 @@ void init_phi1612_4way_ctx()
      skein512_4way_init( &phi1612_4way_ctx.skein );
      jh512_4way_init( &phi1612_4way_ctx.jh );
      cubehashInit( &phi1612_4way_ctx.cube, 512, 16, 32 );
-     sph_fugue512_init( &phi1612_4way_ctx.fugue );
      sph_gost512_init( &phi1612_4way_ctx.gost );
      init_echo( &phi1612_4way_ctx.echo, 512 );
 };
@@ -251,8 +235,12 @@ void phi1612_4way_hash( void *state, const void *input )
      memcpy( &ctx, &phi1612_4way_ctx, sizeof(phi1612_4way_ctx) );
 
      // Skein parallel 4way
-     skein512_4way_update( &ctx.skein, input, 80 );
-     skein512_4way_close( &ctx.skein, vhash );
+
+// skein 4way is broken for 80 bytes
+//     skein512_4way_update( &ctx.skein, input, 80 );
+//     skein512_4way_close( &ctx.skein, vhash );
+     skein512_4way_prehash64( &ctx.skein, input );
+     skein512_4way_final16( &ctx.skein, vhash, input + (64*4) );
 
      // JH
      jh512_4way_update( &ctx.jh, vhash, 64 );
@@ -271,17 +259,10 @@ void phi1612_4way_hash( void *state, const void *input )
      cubehashUpdateDigest( &ctx.cube, (byte*)hash3, (const byte*) hash3, 64 );
 
      // 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 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
      // Gost
      sph_gost512( &ctx.gost, hash0, 64 );

algo/x13/phi1612.c

@@ -8,24 +8,28 @@
 #include <stdio.h>
 #include "algo/gost/sph_gost.h"
 #include "algo/echo/sph_echo.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/cubehash/cubehash_sse2.h"
 #include "algo/skein/sph_skein.h"
 #include "algo/jh/sph_jh.h"
 #ifdef __AES__
   #include "algo/echo/aes_ni/hash_api.h"
+  #include "algo/fugue/fugue-aesni.h"
+#else
+  #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 
 typedef struct {
      sph_skein512_context    skein;
      sph_jh512_context       jh;
      cubehashParam           cube;
-     sph_fugue512_context    fugue;
      sph_gost512_context     gost;
 #ifdef __AES__
      hashState_echo          echo;
+     hashState_fugue         fugue;
 #else
      sph_echo512_context     echo;
+     sph_fugue512_context    fugue;
 #endif
 } phi_ctx_holder;
 
@@ -42,8 +46,10 @@ void init_phi1612_ctx()
      sph_gost512_init( &phi_ctx.gost );
 #ifdef __AES__
      init_echo( &phi_ctx.echo, 512 );
+     fugue512_Init( &phi_ctx.fugue, 512 );
 #else
      sph_echo512_init( &phi_ctx.echo );
+     sph_fugue512_init( &phi_ctx.fugue );
 #endif
 }
 
@@ -69,8 +75,13 @@ void phi1612_hash(void *output, const void *input)
 
      cubehashUpdateDigest( &ctx.cube, (byte*) hash, (const byte*)hash, 64 );
 
+#if defined(__AES__)
+     fugue512_Update( &ctx.fugue, hash, 512 ); 
+     fugue512_Final( &ctx.fugue, hash ); 
+#else
      sph_fugue512( &ctx.fugue, (const void*)hash, 64 );
      sph_fugue512_close( &ctx.fugue, (void*)hash );
+#endif
 
      sph_gost512( &ctx.gost, hash, 64 );
      sph_gost512_close( &ctx.gost, hash );

algo/x13/skunk-4way.c

@@ -5,7 +5,7 @@
 #include <stdio.h>
 #include "algo/skein/skein-hash-4way.h"
 #include "algo/gost/sph_gost.h"
-#include "algo/fugue/sph_fugue.h"
+#include "algo/fugue/fugue-aesni.h"
 #include "algo/cubehash/cubehash_sse2.h"
 #include "algo/cubehash/cube-hash-2way.h"
 
@@ -14,7 +14,7 @@
 typedef struct {
     skein512_8way_context skein;
     cube_4way_context     cube;
-    sph_fugue512_context  fugue;
+    hashState_fugue         fugue;
     sph_gost512_context   gost;
 } skunk_8way_ctx_holder;
 
@@ -46,29 +46,15 @@ void skunk_8way_hash( void *output, const void *input )
      cube_4way_init( &ctx.cube, 512, 16, 32 );           
      cube_4way_update_close( &ctx.cube, vhash, vhash, 64 );  
      dintrlv_4x128_512( hash4, hash5, hash6, hash7, vhash );
-     
-     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 );
-     sph_fugue512( &ctx.fugue, hash4, 64 );
-     sph_fugue512_close( &ctx.fugue, hash4 );
-     sph_fugue512_init( &ctx.fugue );
-     sph_fugue512( &ctx.fugue, hash5, 64 );
-     sph_fugue512_close( &ctx.fugue, hash5 );
-     sph_fugue512_init( &ctx.fugue );
-     sph_fugue512( &ctx.fugue, hash6, 64 );
-     sph_fugue512_close( &ctx.fugue, hash6 );
-     sph_fugue512_init( &ctx.fugue );
-     sph_fugue512( &ctx.fugue, hash7, 64 );
-     sph_fugue512_close( &ctx.fugue, hash7 );
+
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+     fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+     fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+     fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
      sph_gost512( &ctx.gost, hash0, 64 );
      sph_gost512_close( &ctx.gost, output );
@@ -140,7 +126,6 @@ bool skunk_8way_thread_init()
 {
    skein512_8way_init( &skunk_8way_ctx.skein );
    cube_4way_init( &skunk_8way_ctx.cube, 512, 16, 32 );
-   sph_fugue512_init( &skunk_8way_ctx.fugue );
    sph_gost512_init( &skunk_8way_ctx.gost );
    return true;
 }
@@ -150,7 +135,7 @@ bool skunk_8way_thread_init()
 typedef struct {
     skein512_4way_context skein;
     cubehashParam         cube;
-    sph_fugue512_context  fugue;
+    hashState_fugue       fugue;
     sph_gost512_context   gost;
 } skunk_4way_ctx_holder;
 
@@ -178,17 +163,10 @@ void skunk_4way_hash( void *output, const void *input )
      memcpy( &ctx.cube, &skunk_4way_ctx.cube, sizeof(cubehashParam) );
      cubehashUpdateDigest( &ctx.cube, (byte*)hash3, (const byte*) hash3, 64 );
 
-     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 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
      sph_gost512( &ctx.gost, hash0, 64 );
      sph_gost512_close( &ctx.gost, hash0 );
@@ -252,7 +230,6 @@ bool skunk_4way_thread_init()
 {
    skein512_4way_init( &skunk_4way_ctx.skein );
    cubehashInit( &skunk_4way_ctx.cube, 512, 16, 32 );
-   sph_fugue512_init( &skunk_4way_ctx.fugue );
    sph_gost512_init( &skunk_4way_ctx.gost );
    return true;
 }

algo/x13/skunk-gate.c

@@ -2,7 +2,7 @@
 
 bool register_skunk_algo( algo_gate_t* gate )
 {
-   gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT;
+   gate->optimizations = SSE2_OPT | AVX2_OPT | AVX512_OPT | AES_OPT;
 #if defined (SKUNK_8WAY)
    gate->miner_thread_init = (void*)&skunk_8way_thread_init;
    gate->scanhash = (void*)&scanhash_skunk_8way;

algo/x13/skunk.c

@@ -8,13 +8,21 @@
 #include <stdio.h>
 #include "algo/gost/sph_gost.h"
 #include "algo/skein/sph_skein.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/cubehash/cubehash_sse2.h"
+#if defined(__AES__)
+  #include "algo/fugue/fugue-aesni.h"
+#else
+  #include "algo/fugue/sph_fugue.h"
+#endif
 
 typedef struct {
     sph_skein512_context  skein;
     cubehashParam         cube;
+#if defined(__AES__)
+    hashState_fugue       fugue;
+#else
     sph_fugue512_context  fugue;
+#endif
     sph_gost512_context   gost;
 } skunk_ctx_holder;
 
@@ -32,8 +40,13 @@ void skunkhash( void *output, const void *input )
 
      cubehashUpdateDigest( &ctx.cube, (byte*) hash, (const byte*)hash, 64 );
 
+#if defined(__AES__)
+     fugue512_Update( &ctx.fugue, hash, 512 ); 
+     fugue512_Final( &ctx.fugue, hash ); 
+#else
      sph_fugue512( &ctx.fugue, hash, 64 );
      sph_fugue512_close( &ctx.fugue, hash );
+#endif
 
      sph_gost512( &ctx.gost, hash, 64 );
      sph_gost512_close( &ctx.gost, hash );
@@ -87,8 +100,12 @@ bool skunk_thread_init()
 {
    sph_skein512_init( &skunk_ctx.skein );
    cubehashInit( &skunk_ctx.cube, 512, 16, 32 );
-   sph_fugue512_init( &skunk_ctx.fugue );
-   sph_gost512_init( &skunk_ctx.gost );
+#if defined(__AES__)
+    fugue512_Init( &skunk_ctx.fugue, 512 );
+#else
+    sph_fugue512_init( &skunk_ctx.fugue );
+#endif
+    sph_gost512_init( &skunk_ctx.gost );
    return true;
 }
 #endif

algo/x13/x13-4way.c

@@ -16,7 +16,7 @@
 #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/fugue/fugue-aesni.h"
 #if defined(__VAES__)
   #include "algo/groestl/groestl512-hash-4way.h"
   #include "algo/shavite/shavite-hash-4way.h"
@@ -35,7 +35,7 @@ typedef struct {
     cube_4way_context       cube;
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
 #if defined(__VAES__)
     groestl512_4way_context groestl;
     shavite512_4way_context shavite;
@@ -60,7 +60,7 @@ void init_x13_8way_ctx()
      cube_4way_init( &x13_8way_ctx.cube, 512, 16, 32 );
      simd_4way_init( &x13_8way_ctx.simd, 512 );
      hamsi512_8way_init( &x13_8way_ctx.hamsi );
-     sph_fugue512_init( &x13_8way_ctx.fugue );
+     fugue512_Init( &x13_8way_ctx.fugue, 512 );
 #if defined(__VAES__)
      groestl512_4way_init( &x13_8way_ctx.groestl, 64 );
      shavite512_4way_init( &x13_8way_ctx.shavite );
@@ -255,29 +255,29 @@ void x13_8way_hash( void *state, const void *input )
                        vhash );
 
      // 13 Fugue serial
-     sph_fugue512( &ctx.fugue, hash0, 64 );
-     sph_fugue512_close( &ctx.fugue, hash0 );
-     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash1, 64 );
-     sph_fugue512_close( &ctx.fugue, hash1 );
-     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash2, 64 );
-     sph_fugue512_close( &ctx.fugue, hash2 );
-     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash3, 64 );
-     sph_fugue512_close( &ctx.fugue, hash3 );
-     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash4, 64 );
-     sph_fugue512_close( &ctx.fugue, hash4 );
-     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash5, 64 );
-     sph_fugue512_close( &ctx.fugue, hash5 );
-     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash6, 64 );
-     sph_fugue512_close( &ctx.fugue, hash6 );
-     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash7, 64 );
-     sph_fugue512_close( &ctx.fugue, hash7 );
+     fugue512_Update( &ctx.fugue, hash0, 512 );
+     fugue512_Final( &ctx.fugue, hash0 ); 
+     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash1, 512 );
+     fugue512_Final( &ctx.fugue, hash1 );   
+     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash2, 512 );
+     fugue512_Final( &ctx.fugue, hash2 );   
+     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash3, 512 );
+     fugue512_Final( &ctx.fugue, hash3 );   
+     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash4, 512 );
+     fugue512_Final( &ctx.fugue, hash4 );   
+     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash5, 512 );
+     fugue512_Final( &ctx.fugue, hash5 );   
+     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash6, 512 );
+     fugue512_Final( &ctx.fugue, hash6 );   
+     memcpy( &ctx.fugue, &x13_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash7, 512 );
+     fugue512_Final( &ctx.fugue, hash7 );   
      
      memcpy( state,     hash0, 32 );
      memcpy( state+ 32, hash1, 32 );
@@ -344,7 +344,7 @@ typedef struct {
     simd_2way_context       simd;
     hashState_echo          echo;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
 } x13_4way_ctx_holder;
 
 x13_4way_ctx_holder x13_4way_ctx __attribute__ ((aligned (64)));
@@ -363,7 +363,7 @@ void init_x13_4way_ctx()
      simd_2way_init( &x13_4way_ctx.simd, 512 );
      init_echo( &x13_4way_ctx.echo, 512 );
      hamsi512_4way_init( &x13_4way_ctx.hamsi );
-     sph_fugue512_init( &x13_4way_ctx.fugue );
+     fugue512_Init( &x13_4way_ctx.fugue, 512 );
 };
 
 void x13_4way_hash( void *state, const void *input )
@@ -477,17 +477,17 @@ void x13_4way_hash( void *state, const void *input )
      dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
      // 13 Fugue serial
-     sph_fugue512( &ctx.fugue, hash0, 64 );
-     sph_fugue512_close( &ctx.fugue, hash0 );
-     memcpy( &ctx.fugue, &x13_4way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash1, 64 );
-     sph_fugue512_close( &ctx.fugue, hash1 );
-     memcpy( &ctx.fugue, &x13_4way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash2, 64 );
-     sph_fugue512_close( &ctx.fugue, hash2 );
-     memcpy( &ctx.fugue, &x13_4way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash3, 64 );
-     sph_fugue512_close( &ctx.fugue, hash3 );
+     fugue512_Update( &ctx.fugue, hash0, 512 );
+     fugue512_Final( &ctx.fugue, hash0 );      
+     memcpy( &ctx.fugue, &x13_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash1, 512 );
+     fugue512_Final( &ctx.fugue, hash1 );       
+     memcpy( &ctx.fugue, &x13_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash2, 512 );
+     fugue512_Final( &ctx.fugue, hash2 );      
+     memcpy( &ctx.fugue, &x13_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash3, 512 );
+     fugue512_Final( &ctx.fugue, hash3 );   
 
      memcpy( state,    hash0, 32 );
      memcpy( state+32, hash1, 32 );

algo/x13/x13.c

@@ -13,7 +13,6 @@
 #include "algo/skein/sph_skein.h"
 #include "algo/shavite/sph_shavite.h"
 #include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/luffa/luffa_for_sse2.h"
 #include "algo/cubehash/cubehash_sse2.h"
 #include "algo/simd/nist.h"
@@ -21,9 +20,11 @@
 #if defined(__AES__)
   #include "algo/echo/aes_ni/hash_api.h"
   #include "algo/groestl/aes_ni/hash-groestl.h"
+  #include "algo/fugue/fugue-aesni.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 
 typedef struct {
@@ -32,9 +33,11 @@ typedef struct {
 #if defined(__AES__)
    hashState_echo          echo;
    hashState_groestl       groestl;
+   hashState_fugue         fugue;
 #else
    sph_groestl512_context   groestl;
    sph_echo512_context      echo;
+   sph_fugue512_context    fugue;
 #endif
    sph_jh512_context       jh;
    sph_keccak512_context   keccak;
@@ -44,7 +47,6 @@ typedef struct {
    sph_shavite512_context  shavite;
    hashState_sd            simd;
    sph_hamsi512_context    hamsi;
-   sph_fugue512_context    fugue;
 } x13_ctx_holder;
 
 x13_ctx_holder x13_ctx;
@@ -56,9 +58,11 @@ void init_x13_ctx()
 #if defined(__AES__)
    init_groestl( &x13_ctx.groestl, 64 );
    init_echo( &x13_ctx.echo, 512 );
+   fugue512_Init( &x13_ctx.fugue, 512 );
 #else
    sph_groestl512_init( &x13_ctx.groestl );
    sph_echo512_init( &x13_ctx.echo );
+   sph_fugue512_init( &x13_ctx.fugue );
 #endif
    sph_skein512_init( &x13_ctx.skein );
    sph_jh512_init( &x13_ctx.jh );
@@ -68,7 +72,6 @@ void init_x13_ctx()
    sph_shavite512_init( &x13_ctx.shavite );
    init_sd( &x13_ctx.simd, 512 );
    sph_hamsi512_init( &x13_ctx.hamsi );
-   sph_fugue512_init( &x13_ctx.fugue );
 };
 
 void x13hash(void *output, const void *input)
@@ -84,11 +87,9 @@ void x13hash(void *output, const void *input)
     sph_bmw512_close( &ctx.bmw, hash );
 
 #if defined(__AES__)
-    init_groestl( &ctx.groestl, 64 );
     update_and_final_groestl( &ctx.groestl, (char*)hash,
                                       (const char*)hash, 512 );
 #else
-    sph_groestl512_init( &ctx.groestl );
     sph_groestl512( &ctx.groestl, hash, 64 );
     sph_groestl512_close( &ctx.groestl, hash );
 #endif
@@ -125,8 +126,13 @@ void x13hash(void *output, const void *input)
     sph_hamsi512( &ctx.hamsi, hash, 64 );
     sph_hamsi512_close( &ctx.hamsi, hash );
 
+#if defined(__AES__)
+    fugue512_Update( &ctx.fugue, hash, 512 );
+    fugue512_Final( &ctx.fugue, hash );  
+#else
     sph_fugue512( &ctx.fugue, hash, 64 );
-    sph_fugue512_close( &ctx.fugue, hash );
+    sph_fugue512_close( &ctx.fugue, hash ); 
+#endif
 
 	 memcpy( output, hash, 32 );
 }

algo/x13/x13bcd-4way.c

@@ -16,7 +16,7 @@
 #include "algo/echo/aes_ni/hash_api.h"
 #include "algo/sm3/sm3-hash-4way.h"
 #include "algo/hamsi/hamsi-hash-4way.h"
-#include "algo/fugue/sph_fugue.h"
+#include "algo/fugue/fugue-aesni.h"
 #if defined(__VAES__)
   #include "algo/groestl/groestl512-hash-4way.h"
   #include "algo/shavite/shavite-hash-4way.h"
@@ -35,7 +35,7 @@ typedef struct {
     simd_4way_context       simd;
     sm3_8way_ctx_t          sm3;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
 #if defined(__VAES__)
     groestl512_4way_context groestl;
     shavite512_4way_context shavite;
@@ -61,7 +61,7 @@ void init_x13bcd_8way_ctx()
      simd_4way_init( &x13bcd_8way_ctx.simd, 512 );
      sm3_8way_init( &x13bcd_8way_ctx.sm3 );
      hamsi512_8way_init( &x13bcd_8way_ctx.hamsi );
-     sph_fugue512_init( &x13bcd_8way_ctx.fugue );
+     fugue512_Init( &x13bcd_8way_ctx.fugue, 512 );
 #if defined(__VAES__)
      groestl512_4way_init( &x13bcd_8way_ctx.groestl, 64 );
      shavite512_4way_init( &x13bcd_8way_ctx.shavite );
@@ -257,36 +257,30 @@ void x13bcd_8way_hash( void *state, const void *input )
                        hash4, hash5, hash6, hash7, vhash );
 
      // Fugue serial
-     sph_fugue512( &ctx.fugue, hash0, 64 );
-     sph_fugue512_close( &ctx.fugue, state );
-     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash1, 64 );
-     sph_fugue512_close( &ctx.fugue, state+32 );
-     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash2, 64 );
-     sph_fugue512_close( &ctx.fugue, state+64 );
-     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash3, 64 );
-     sph_fugue512_close( &ctx.fugue, state+96 );
-     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash4, 64 );
-     sph_fugue512_close( &ctx.fugue, state+128 );
-     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash5, 64 );
-     sph_fugue512_close( &ctx.fugue, state+160 );
-     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash6, 64 );
-     sph_fugue512_close( &ctx.fugue, state+192 );
-     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash7, 64 );
-     sph_fugue512_close( &ctx.fugue, state+224 );
+     fugue512_Update( &ctx.fugue, hash0, 512 );
+     fugue512_Final( &ctx.fugue, state );
+     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash1, 512 );
+     fugue512_Final( &ctx.fugue, state+32 );
+     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash2, 512 );
+     fugue512_Final( &ctx.fugue, state+64 );
+     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash3, 512 );
+     fugue512_Final( &ctx.fugue, state+96 );
+     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash4, 512 );
+     fugue512_Final( &ctx.fugue, state+128 );
+     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash5, 512 );
+     fugue512_Final( &ctx.fugue, state+160 );
+     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash6, 512 );
+     fugue512_Final( &ctx.fugue, state+192 );
+     memcpy( &ctx.fugue, &x13bcd_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash7, 512 );
+     fugue512_Final( &ctx.fugue, state+224 );
+
 }
 
 int scanhash_x13bcd_8way( struct work *work, uint32_t max_nonce,
@@ -346,7 +340,7 @@ typedef struct {
     hashState_echo          echo;
     sm3_4way_ctx_t          sm3;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
 } x13bcd_4way_ctx_holder;
 
 x13bcd_4way_ctx_holder x13bcd_4way_ctx __attribute__ ((aligned (64)));
@@ -366,7 +360,7 @@ void init_x13bcd_4way_ctx()
      init_echo( &x13bcd_4way_ctx.echo, 512 );
      sm3_4way_init( &x13bcd_4way_ctx.sm3 );
      hamsi512_4way_init( &x13bcd_4way_ctx.hamsi );
-     sph_fugue512_init( &x13bcd_4way_ctx.fugue );
+     fugue512_Init( &x13bcd_4way_ctx.fugue, 512 );
 };
 
 void x13bcd_4way_hash( void *state, const void *input )
@@ -489,20 +483,17 @@ void x13bcd_4way_hash( void *state, const void *input )
      dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
      // Fugue serial
-     sph_fugue512( &ctx.fugue, hash0, 64 );
-     sph_fugue512_close( &ctx.fugue, hash0 );
-     memcpy( &ctx.fugue, &x13bcd_4way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash1, 64 );
-     sph_fugue512_close( &ctx.fugue, hash1 );
-     memcpy( &ctx.fugue, &x13bcd_4way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash2, 64 );
-     sph_fugue512_close( &ctx.fugue, hash2 );
-     memcpy( &ctx.fugue, &x13bcd_4way_ctx.fugue,
-                         sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash3, 64 );
-     sph_fugue512_close( &ctx.fugue, hash3 );
+     fugue512_Update( &ctx.fugue, hash0, 512 );
+     fugue512_Final( &ctx.fugue, hash0 );
+     memcpy( &ctx.fugue, &x13bcd_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash1, 512 );
+     fugue512_Final( &ctx.fugue, hash1 );
+     memcpy( &ctx.fugue, &x13bcd_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash2, 512 );
+     fugue512_Final( &ctx.fugue, hash2 );
+     memcpy( &ctx.fugue, &x13bcd_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash3, 512 );
+     fugue512_Final( &ctx.fugue, hash3 );
 
      memcpy( state,    hash0, 32 );
      memcpy( state+32, hash1, 32 );

algo/x13/x13bcd.c

@@ -14,16 +14,17 @@
 #include "algo/skein/sph_skein.h"
 #include "algo/shavite/sph_shavite.h"
 #include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/cubehash/cubehash_sse2.h"
 #include "algo/simd/nist.h"
 
 #if defined(__AES__)
   #include "algo/echo/aes_ni/hash_api.h"
   #include "algo/groestl/aes_ni/hash-groestl.h"
+  #include "algo/fugue/fugue-aesni.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 
 typedef struct {
@@ -32,9 +33,11 @@ typedef struct {
 #if defined(__AES__)
    hashState_echo          echo;
    hashState_groestl       groestl;
+   hashState_fugue         fugue;
 #else
    sph_groestl512_context   groestl;
    sph_echo512_context      echo;
+   sph_fugue512_context    fugue;
 #endif
    sph_jh512_context       jh;
    sph_keccak512_context   keccak;
@@ -43,7 +46,6 @@ typedef struct {
    sph_shavite512_context  shavite;
    hashState_sd            simd;
    sph_hamsi512_context    hamsi;
-   sph_fugue512_context    fugue;
    sm3_ctx_t               sm3;
 } x13bcd_ctx_holder;
 
@@ -56,9 +58,11 @@ void init_x13bcd_ctx()
 #if defined(__AES__)
    init_groestl( &x13bcd_ctx.groestl, 64 );
    init_echo( &x13bcd_ctx.echo, 512 );
+   fugue512_Init( &x13bcd_ctx.fugue, 512 );
 #else
    sph_groestl512_init( &x13bcd_ctx.groestl );
    sph_echo512_init( &x13bcd_ctx.echo );
+   sph_fugue512_init( &x13bcd_ctx.fugue );
 #endif
    sph_skein512_init( &x13bcd_ctx.skein );
    sph_jh512_init( &x13bcd_ctx.jh );
@@ -68,7 +72,6 @@ void init_x13bcd_ctx()
    init_sd( &x13bcd_ctx.simd,512 );
    sm3_init( &x13bcd_ctx.sm3 );
    sph_hamsi512_init( &x13bcd_ctx.hamsi );
-   sph_fugue512_init( &x13bcd_ctx.fugue );
 };
 
 void x13bcd_hash(void *output, const void *input)
@@ -129,8 +132,13 @@ void x13bcd_hash(void *output, const void *input)
     sph_hamsi512( &ctx.hamsi, hash, 64 );
     sph_hamsi512_close( &ctx.hamsi, hash );
 
+#if defined(__AES__)
+    fugue512_Update( &ctx.fugue, hash, 512 );
+    fugue512_Final( &ctx.fugue, hash );
+#else
     sph_fugue512( &ctx.fugue, hash, 64 );
     sph_fugue512_close( &ctx.fugue, hash );
+#endif
 
     memcpy( output, hash, 32 );
 }

algo/x14/x14-4way.c

@@ -17,7 +17,7 @@
 #include "algo/echo/aes_ni/hash_api.h"
 #include "algo/echo/sph_echo.h"
 #include "algo/hamsi/hamsi-hash-4way.h"
-#include "algo/fugue/sph_fugue.h"
+#include "algo/fugue/fugue-aesni.h"
 #include "algo/shabal/shabal-hash-4way.h"
 #if defined(__VAES__)
   #include "algo/groestl/groestl512-hash-4way.h"
@@ -37,7 +37,7 @@ typedef struct {
     cube_4way_context       cube;
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_8way_context  shabal;
 #if defined(__VAES__)
     groestl512_4way_context groestl;
@@ -63,7 +63,7 @@ void init_x14_8way_ctx()
      cube_4way_init( &x14_8way_ctx.cube, 512, 16, 32 );
      simd_4way_init( &x14_8way_ctx.simd, 512 );
      hamsi512_8way_init( &x14_8way_ctx.hamsi );
-     sph_fugue512_init( &x14_8way_ctx.fugue );
+     fugue512_Init( &x14_8way_ctx.fugue, 512 );
      shabal512_8way_init( &x14_8way_ctx.shabal );
 #if defined(__VAES__)
      groestl512_4way_init( &x14_8way_ctx.groestl, 64 );
@@ -259,29 +259,29 @@ void x14_8way_hash( void *state, const void *input )
                        vhash );
 
      // 13 Fugue serial
-     sph_fugue512( &ctx.fugue, hash0, 64 );
-     sph_fugue512_close( &ctx.fugue, hash0 );
-     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash1, 64 );
-     sph_fugue512_close( &ctx.fugue, hash1 );
-     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash2, 64 );
-     sph_fugue512_close( &ctx.fugue, hash2 );
-     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash3, 64 );
-     sph_fugue512_close( &ctx.fugue, hash3 );
-     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash4, 64 );
-     sph_fugue512_close( &ctx.fugue, hash4 );
-     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash5, 64 );
-     sph_fugue512_close( &ctx.fugue, hash5 );
-     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash6, 64 );
-     sph_fugue512_close( &ctx.fugue, hash6 );
-     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash7, 64 );
-     sph_fugue512_close( &ctx.fugue, hash7 );
+     fugue512_Update( &ctx.fugue, hash0, 512 );
+     fugue512_Final( &ctx.fugue, hash0 );
+     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash1, 512 );
+     fugue512_Final( &ctx.fugue, hash1 );
+     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash2, 512 );
+     fugue512_Final( &ctx.fugue, hash2 );
+     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash3, 512 );
+     fugue512_Final( &ctx.fugue, hash3 );
+     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash4, 512 );
+     fugue512_Final( &ctx.fugue, hash4 );
+     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash5, 512 );
+     fugue512_Final( &ctx.fugue, hash5 );
+     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash6, 512 );
+     fugue512_Final( &ctx.fugue, hash6 );
+     memcpy( &ctx.fugue, &x14_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash7, 512 );
+     fugue512_Final( &ctx.fugue, hash7 );
 
      // 14 Shabal, parallel 32 bit
      intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
@@ -348,7 +348,7 @@ typedef struct {
     simd_2way_context       simd;
     hashState_echo          echo;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_4way_context  shabal;
 } x14_4way_ctx_holder;
 
@@ -368,7 +368,7 @@ void init_x14_4way_ctx()
      simd_2way_init( &x14_4way_ctx.simd, 512 );
      init_echo( &x14_4way_ctx.echo, 512 );
      hamsi512_4way_init( &x14_4way_ctx.hamsi );
-     sph_fugue512_init( &x14_4way_ctx.fugue );
+     fugue512_Init( &x14_4way_ctx.fugue, 512 );
      shabal512_4way_init( &x14_4way_ctx.shabal );
 };
 
@@ -483,17 +483,17 @@ void x14_4way_hash( void *state, const void *input )
      dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
      // 13 Fugue serial
-     sph_fugue512( &ctx.fugue, hash0, 64 );
-     sph_fugue512_close( &ctx.fugue, hash0 );
-     memcpy( &ctx.fugue, &x14_4way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash1, 64 );
-     sph_fugue512_close( &ctx.fugue, hash1 );
-     memcpy( &ctx.fugue, &x14_4way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash2, 64 );
-     sph_fugue512_close( &ctx.fugue, hash2 );
-     memcpy( &ctx.fugue, &x14_4way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash3, 64 );
-     sph_fugue512_close( &ctx.fugue, hash3 );
+     fugue512_Update( &ctx.fugue, hash0, 512 );
+     fugue512_Final( &ctx.fugue, hash0 );
+     memcpy( &ctx.fugue, &x14_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash1, 512 );
+     fugue512_Final( &ctx.fugue, hash1 );
+     memcpy( &ctx.fugue, &x14_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash2, 512 );
+     fugue512_Final( &ctx.fugue, hash2 );
+     memcpy( &ctx.fugue, &x14_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash3, 512 );
+     fugue512_Final( &ctx.fugue, hash3 );
 
      // 14 Shabal, parallel 32 bit
      intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 512 );

algo/x14/x14.c

@@ -13,7 +13,6 @@
 #include "algo/skein/sph_skein.h"
 #include "algo/shavite/sph_shavite.h"
 #include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/shabal/sph_shabal.h"
 #include "algo/luffa/luffa_for_sse2.h"
 #include "algo/cubehash/cubehash_sse2.h"
@@ -21,9 +20,11 @@
 #if defined(__AES__)
   #include "algo/echo/aes_ni/hash_api.h"
   #include "algo/groestl/aes_ni/hash-groestl.h"
+  #include "algo/fugue/fugue-aesni.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 
 typedef struct {
@@ -32,9 +33,11 @@ typedef struct {
 #if defined(__AES__)
    hashState_groestl       groestl;
    hashState_echo          echo;
+   hashState_fugue         fugue;
 #else
    sph_groestl512_context  groestl;
    sph_echo512_context     echo;
+   sph_fugue512_context    fugue;
 #endif
    sph_jh512_context       jh;
    sph_keccak512_context   keccak;
@@ -44,7 +47,6 @@ typedef struct {
    sph_shavite512_context  shavite;
    hashState_sd            simd;
    sph_hamsi512_context    hamsi;
-   sph_fugue512_context    fugue;
    sph_shabal512_context   shabal;
 } x14_ctx_holder;
 
@@ -57,9 +59,11 @@ void init_x14_ctx()
 #if defined(__AES__)
    init_groestl( &x14_ctx.groestl, 64 );
    init_echo( &x14_ctx.echo, 512 );
+   fugue512_Init( &x14_ctx.fugue, 512 );
 #else
    sph_groestl512_init( &x14_ctx.groestl );
    sph_echo512_init( &x14_ctx.echo );
+   sph_fugue512_init( &x14_ctx.fugue );
 #endif
    sph_skein512_init( &x14_ctx.skein );
    sph_jh512_init( &x14_ctx.jh );
@@ -69,7 +73,6 @@ void init_x14_ctx()
    sph_shavite512_init( &x14_ctx.shavite );
    init_sd( &x14_ctx.simd,512 );
    sph_hamsi512_init( &x14_ctx.hamsi );
-   sph_fugue512_init( &x14_ctx.fugue );
    sph_shabal512_init( &x14_ctx.shabal );
 };
 
@@ -125,8 +128,13 @@ void x14hash(void *output, const void *input)
     sph_hamsi512(&ctx.hamsi, hash, 64);
     sph_hamsi512_close(&ctx.hamsi, hash);
 
+#if defined(__AES__)
+    fugue512_Update( &ctx.fugue, hash, 512 );
+    fugue512_Final( &ctx.fugue, hash );
+#else
     sph_fugue512(&ctx.fugue, hash, 64);
     sph_fugue512_close(&ctx.fugue, hash);
+#endif
 
     sph_shabal512( &ctx.shabal, hash, 64 );
 	 sph_shabal512_close( &ctx.shabal, hash );

algo/x15/x15-4way.c

@@ -17,7 +17,7 @@
 #include "algo/echo/aes_ni/hash_api.h"
 #include "algo/echo/sph_echo.h"
 #include "algo/hamsi/hamsi-hash-4way.h"
-#include "algo/fugue/sph_fugue.h"
+#include "algo/fugue/fugue-aesni.h"
 #include "algo/shabal/shabal-hash-4way.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #if defined(__VAES__)
@@ -38,7 +38,7 @@ typedef struct {
     cube_4way_context       cube;
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_8way_context  shabal;
     sph_whirlpool_context   whirlpool;
 #if defined(__VAES__)
@@ -65,7 +65,7 @@ void init_x15_8way_ctx()
      cube_4way_init( &x15_8way_ctx.cube, 512, 16, 32 );
      simd_4way_init( &x15_8way_ctx.simd, 512 );
      hamsi512_8way_init( &x15_8way_ctx.hamsi );
-     sph_fugue512_init( &x15_8way_ctx.fugue );
+     fugue512_Init( &x15_8way_ctx.fugue, 512 );
      shabal512_8way_init( &x15_8way_ctx.shabal );
      sph_whirlpool_init( &x15_8way_ctx.whirlpool );
 #if defined(__VAES__)
@@ -260,30 +260,29 @@ void x15_8way_hash( void *state, const void *input )
                        vhash );
 
      // 13 Fugue
-     sph_fugue512( &ctx.fugue, hash0, 64 );
-     sph_fugue512_close( &ctx.fugue, hash0 );
-     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash1, 64 );
-     sph_fugue512_close( &ctx.fugue, hash1 );
-     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash2, 64 );
-     sph_fugue512_close( &ctx.fugue, hash2 );
-     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash3, 64 );
-     sph_fugue512_close( &ctx.fugue, hash3 );
-     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash4, 64 );
-     sph_fugue512_close( &ctx.fugue, hash4 );
-     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash5, 64 );
-     sph_fugue512_close( &ctx.fugue, hash5 );
-     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash6, 64 );
-     sph_fugue512_close( &ctx.fugue, hash6 );
-     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash7, 64 );
-     sph_fugue512_close( &ctx.fugue, hash7 );
-
+     fugue512_Update( &ctx.fugue, hash0, 512 );
+     fugue512_Final( &ctx.fugue, hash0 );
+     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash1, 512 );
+     fugue512_Final( &ctx.fugue, hash1 );
+     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash2, 512 );
+     fugue512_Final( &ctx.fugue, hash2 );
+     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash3, 512 );
+     fugue512_Final( &ctx.fugue, hash3 );
+     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash4, 512 );
+     fugue512_Final( &ctx.fugue, hash4 );
+     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash5, 512 );
+     fugue512_Final( &ctx.fugue, hash5 );
+     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash6, 512 );
+     fugue512_Final( &ctx.fugue, hash6 );
+     memcpy( &ctx.fugue, &x15_8way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash7, 512 );
+     fugue512_Final( &ctx.fugue, hash7 );
 
      // 14 Shabal, parallel 32 bit
      intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
@@ -387,7 +386,7 @@ typedef struct {
     simd_2way_context       simd;
     hashState_echo          echo;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_4way_context  shabal;
     sph_whirlpool_context   whirlpool;
 } x15_4way_ctx_holder;
@@ -408,7 +407,7 @@ void init_x15_4way_ctx()
      simd_2way_init( &x15_4way_ctx.simd, 512 );
      init_echo( &x15_4way_ctx.echo, 512 );
      hamsi512_4way_init( &x15_4way_ctx.hamsi );
-     sph_fugue512_init( &x15_4way_ctx.fugue );
+     fugue512_Init( &x15_4way_ctx.fugue, 512 );
      shabal512_4way_init( &x15_4way_ctx.shabal );
      sph_whirlpool_init( &x15_4way_ctx.whirlpool );
 };
@@ -524,17 +523,17 @@ void x15_4way_hash( void *state, const void *input )
      dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, 512 );
 
      // 13 Fugue
-     sph_fugue512( &ctx.fugue, hash0, 64 );
-     sph_fugue512_close( &ctx.fugue, hash0 );
-     memcpy( &ctx.fugue, &x15_4way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash1, 64 );
-     sph_fugue512_close( &ctx.fugue, hash1 );
-     memcpy( &ctx.fugue, &x15_4way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash2, 64 );
-     sph_fugue512_close( &ctx.fugue, hash2 );
-     memcpy( &ctx.fugue, &x15_4way_ctx.fugue, sizeof(sph_fugue512_context) );
-     sph_fugue512( &ctx.fugue, hash3, 64 );
-     sph_fugue512_close( &ctx.fugue, hash3 );
+     fugue512_Update( &ctx.fugue, hash0, 512 );
+     fugue512_Final( &ctx.fugue, hash0 );
+     memcpy( &ctx.fugue, &x15_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash1, 512 );
+     fugue512_Final( &ctx.fugue, hash1 );
+     memcpy( &ctx.fugue, &x15_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash2, 512 );
+     fugue512_Final( &ctx.fugue, hash2 );
+     memcpy( &ctx.fugue, &x15_4way_ctx.fugue, sizeof(hashState_fugue) );
+     fugue512_Update( &ctx.fugue, hash3, 512 );
+     fugue512_Final( &ctx.fugue, hash3 );
 
      // 14 Shabal, parallel 32 bit
      intrlv_4x32( vhash, hash0, hash1, hash2, hash3, 512 );

algo/x15/x15.c

@@ -23,9 +23,11 @@
 #if defined(__AES__)
   #include "algo/echo/aes_ni/hash_api.h"
   #include "algo/groestl/aes_ni/hash-groestl.h"
+  #include "algo/fugue/fugue-aesni.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 
 typedef struct {
@@ -34,9 +36,11 @@ typedef struct {
 #if defined(__AES__)
    hashState_echo          echo;
    hashState_groestl       groestl;
+   hashState_fugue         fugue;
 #else
    sph_groestl512_context   groestl;
    sph_echo512_context      echo;
+   sph_fugue512_context    fugue;
 #endif
    sph_jh512_context       jh;
    sph_keccak512_context   keccak;
@@ -46,7 +50,6 @@ typedef struct {
    sph_shavite512_context  shavite;
    hashState_sd            simd;
    sph_hamsi512_context    hamsi;
-   sph_fugue512_context    fugue;
    sph_shabal512_context   shabal;
    sph_whirlpool_context   whirlpool;
 } x15_ctx_holder;
@@ -60,9 +63,11 @@ void init_x15_ctx()
 #if defined(__AES__)
    init_groestl( &x15_ctx.groestl, 64 );
    init_echo( &x15_ctx.echo, 512 );
+   fugue512_Init( &x15_ctx.fugue, 512 );
 #else
    sph_groestl512_init( &x15_ctx.groestl );
    sph_echo512_init( &x15_ctx.echo );
+   sph_fugue512_init( &x15_ctx.fugue );
 #endif
    sph_skein512_init( &x15_ctx.skein );
    sph_jh512_init( &x15_ctx.jh );
@@ -72,7 +77,6 @@ void init_x15_ctx()
    sph_shavite512_init( &x15_ctx.shavite );
    init_sd( &x15_ctx.simd, 512 );
    sph_hamsi512_init( &x15_ctx.hamsi );
-   sph_fugue512_init( &x15_ctx.fugue );
    sph_shabal512_init( &x15_ctx.shabal );
    sph_whirlpool_init( &x15_ctx.whirlpool );
 };
@@ -131,8 +135,13 @@ void x15hash(void *output, const void *input)
     sph_hamsi512( &ctx.hamsi, hash, 64 );
     sph_hamsi512_close( &ctx.hamsi, hash );
 
+#if defined(__AES__)
+    fugue512_Update( &ctx.fugue, hash, 512 );
+    fugue512_Final( &ctx.fugue, hash );
+#else
     sph_fugue512( &ctx.fugue, hash, 64 );
     sph_fugue512_close( &ctx.fugue, hash );
+#endif
 
     sph_shabal512( &ctx.shabal, hash, 64 );
     sph_shabal512_close( &ctx.shabal, hash );

algo/x16/hex.c

@@ -6,30 +6,6 @@
  */
 #include "x16r-gate.h"
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "algo/blake/sph_blake.h"
-#include "algo/bmw/sph_bmw.h"
-#include "algo/groestl/sph_groestl.h"
-#include "algo/jh/sph_jh.h"
-#include "algo/keccak/sph_keccak.h"
-#include "algo/skein/sph_skein.h"
-#include "algo/shavite/sph_shavite.h"
-#include "algo/luffa/luffa_for_sse2.h"
-#include "algo/cubehash/cubehash_sse2.h"
-#include "algo/simd/nist.h"
-#include "algo/echo/sph_echo.h"
-#include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
-#include "algo/shabal/sph_shabal.h"
-#include "algo/whirlpool/sph_whirlpool.h"
-#include <openssl/sha.h>
-#if defined(__AES__)
-  #include "algo/echo/aes_ni/hash_api.h"
-  #include "algo/groestl/aes_ni/hash-groestl.h"
-#endif
-
 static void hex_getAlgoString(const uint32_t* prevblock, char *output)
 {
    char *sptr = output;
@@ -47,34 +23,6 @@ static void hex_getAlgoString(const uint32_t* prevblock, char *output)
    *sptr = '\0';
 }
 
-/*
-union _hex_context_overlay
-{
-#if defined(__AES__)
-        hashState_echo          echo;
-        hashState_groestl       groestl;
-#else
-        sph_groestl512_context   groestl;
-        sph_echo512_context      echo;
-#endif
-        sph_blake512_context    blake;
-        sph_bmw512_context      bmw;
-        sph_skein512_context    skein;
-        sph_jh512_context       jh;
-        sph_keccak512_context   keccak;
-        hashState_luffa         luffa;
-        cubehashParam           cube;
-        shavite512_context      shavite;
-        hashState_sd            simd;
-        sph_hamsi512_context    hamsi;
-        sph_fugue512_context    fugue;
-        sph_shabal512_context   shabal;
-        sph_whirlpool_context   whirlpool;
-        SHA512_CTX              sha512;
-};
-typedef union _hex_context_overlay hex_context_overlay;
-*/
-
 static __thread x16r_context_overlay hex_ctx;
 
 int hex_hash( void* output, const void* input, int thrid )
@@ -187,8 +135,12 @@ int hex_hash( void* output, const void* input, int thrid )
             sph_hamsi512_close( &ctx.hamsi, hash );
          break;
          case FUGUE:
+#if defined(__AES__)
+             fugue512_full( &ctx.fugue, hash, in, size );
+#else
              sph_fugue512_full( &ctx.fugue, hash, in, size );
-         break;
+#endif
+	     break;
          case SHABAL:
             if ( i == 0 ) 
                sph_shabal512( &ctx.shabal, in+64, 16 );

algo/x16/minotaur.c

@@ -0,0 +1,302 @@
+// Minotaur hash
+
+#include "algo-gate-api.h"
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <stdio.h>
+#include "algo/blake/sph_blake.h"
+#include "algo/bmw/sph_bmw.h"
+#include "algo/jh/sph_jh.h"
+#include "algo/keccak/sph_keccak.h"
+#include "algo/skein/sph_skein.h"
+#include "algo/shavite/sph_shavite.h"
+#include "algo/luffa/luffa_for_sse2.h"
+#include "algo/cubehash/cubehash_sse2.h"
+#include "algo/simd/nist.h"
+#include "algo/hamsi/sph_hamsi.h"
+#include "algo/shabal/sph_shabal.h"
+#include "algo/whirlpool/sph_whirlpool.h"
+#include <openssl/sha.h>
+#if defined(__AES__)
+  #include "algo/echo/aes_ni/hash_api.h"
+  #include "algo/groestl/aes_ni/hash-groestl.h"
+  #include "algo/fugue/fugue-aesni.h"
+#else
+  #include "algo/echo/sph_echo.h"
+  #include "algo/groestl/sph_groestl.h"
+  #include "algo/fugue/sph_fugue.h"
+#endif
+
+// Config
+#define MINOTAUR_ALGO_COUNT	16
+
+typedef struct TortureNode TortureNode;
+typedef struct TortureGarden TortureGarden;
+
+// Graph of hash algos plus SPH contexts
+struct TortureGarden
+{
+#if defined(__AES__)
+        hashState_echo          echo;
+        hashState_groestl       groestl;
+        hashState_fugue         fugue;
+#else
+        sph_echo512_context     echo;
+        sph_groestl512_context  groestl;
+        sph_fugue512_context    fugue;
+#endif
+        sph_blake512_context    blake;
+        sph_bmw512_context      bmw;
+        sph_skein512_context    skein;
+        sph_jh512_context       jh;
+        sph_keccak512_context   keccak;
+        hashState_luffa         luffa;
+        cubehashParam           cube;
+        shavite512_context      shavite;
+        hashState_sd            simd;
+        sph_hamsi512_context    hamsi;
+        sph_shabal512_context   shabal;
+        sph_whirlpool_context   whirlpool;
+        SHA512_CTX              sha512;
+
+    struct TortureNode {
+        unsigned int algo;
+        TortureNode *child[2];
+    } nodes[22];
+} __attribute__ ((aligned (64)));
+
+// Get a 64-byte hash for given 64-byte input, using given TortureGarden contexts and given algo index
+static void get_hash( void *output, const void *input, TortureGarden *garden,
+	              unsigned int algo )
+{    
+	unsigned char hash[64] __attribute__ ((aligned (64)));
+
+    switch (algo) {
+        case 0:
+            sph_blake512_init(&garden->blake);
+            sph_blake512(&garden->blake, input, 64);
+            sph_blake512_close(&garden->blake, hash);
+            break;
+        case 1:
+            sph_bmw512_init(&garden->bmw);
+            sph_bmw512(&garden->bmw, input, 64);
+            sph_bmw512_close(&garden->bmw, hash);        
+            break;
+        case 2:
+            cubehashInit( &garden->cube, 512, 16, 32 );
+            cubehashUpdateDigest( &garden->cube, (byte*)hash,
+			         (const byte*)input, 64 );
+            break;
+        case 3:
+#if defined(__AES__)
+            echo_full( &garden->echo, (BitSequence *)hash, 512,
+                              (const BitSequence *)input, 64 );
+#else
+            sph_echo512_init(&garden->echo);
+            sph_echo512(&garden->echo, input, 64);
+            sph_echo512_close(&garden->echo, hash);          
+#endif
+	    break;
+        case 4:
+#if defined(__AES__)
+            fugue512_full( &garden->fugue, hash, input, 64 );
+#else
+            sph_fugue512_full( &garden->fugue, hash, input, 64 );
+#endif
+	    break;
+        case 5:
+#if defined(__AES__)
+            groestl512_full( &garden->groestl, (char*)hash, (char*)input, 512 );
+#else
+            sph_groestl512_init(&garden->groestl);
+            sph_groestl512(&garden->groestl, input, 64);
+            sph_groestl512_close(&garden->groestl, hash);          
+#endif
+	    break;
+        case 6:
+            sph_hamsi512_init(&garden->hamsi);
+            sph_hamsi512(&garden->hamsi, input, 64);
+            sph_hamsi512_close(&garden->hamsi, hash);          
+            break;
+        case 7:
+            SHA512_Init( &garden->sha512 );
+            SHA512_Update( &garden->sha512, input, 64 );
+            SHA512_Final( (unsigned char*)hash, &garden->sha512 );
+            break;
+        case 8:
+            sph_jh512_init(&garden->jh);
+            sph_jh512(&garden->jh, input, 64);
+            sph_jh512_close(&garden->jh, hash);          
+            break;
+        case 9:
+            sph_keccak512_init(&garden->keccak);
+            sph_keccak512(&garden->keccak, input, 64);
+            sph_keccak512_close(&garden->keccak, hash);
+            break;
+        case 10:
+            init_luffa( &garden->luffa, 512 );
+            update_and_final_luffa( &garden->luffa, (BitSequence*)hash,
+                                    (const BitSequence*)input, 64 );
+            break;
+        case 11:
+            sph_shabal512_init(&garden->shabal);
+            sph_shabal512(&garden->shabal, input, 64);
+            sph_shabal512_close(&garden->shabal, hash);          
+            break;
+        case 12:
+            sph_shavite512_init(&garden->shavite);
+            sph_shavite512(&garden->shavite, input, 64);
+            sph_shavite512_close(&garden->shavite, hash);          
+            break;
+        case 13:
+            init_sd( &garden->simd, 512 );
+            update_final_sd( &garden->simd, (BitSequence *)hash,
+                              (const BitSequence*)input, 512 );
+            break;
+        case 14:
+            sph_skein512_init(&garden->skein);
+            sph_skein512(&garden->skein, input, 64);
+            sph_skein512_close(&garden->skein, hash);          
+            break;
+        case 15:
+            sph_whirlpool_init(&garden->whirlpool);
+            sph_whirlpool(&garden->whirlpool, input, 64);
+            sph_whirlpool_close(&garden->whirlpool, hash);          
+            break;
+    }
+
+    memcpy(output, hash, 64);
+}
+
+static __thread TortureGarden garden;
+
+bool initialize_torture_garden()
+{
+    // Create torture garden nodes. Note that both sides of 19 and 20 lead to 21, and 21 has no children (to make traversal complete).
+
+   garden.nodes[ 0].child[0] = &garden.nodes[ 1];
+   garden.nodes[ 0].child[1] = &garden.nodes[ 2];
+   garden.nodes[ 1].child[0] = &garden.nodes[ 3];
+   garden.nodes[ 1].child[1] = &garden.nodes[ 4];
+   garden.nodes[ 2].child[0] = &garden.nodes[ 5];
+   garden.nodes[ 2].child[1] = &garden.nodes[ 6];
+   garden.nodes[ 3].child[0] = &garden.nodes[ 7];
+   garden.nodes[ 3].child[1] = &garden.nodes[ 8];
+   garden.nodes[ 4].child[0] = &garden.nodes[ 9];
+   garden.nodes[ 4].child[1] = &garden.nodes[10];
+   garden.nodes[ 5].child[0] = &garden.nodes[11];
+   garden.nodes[ 5].child[1] = &garden.nodes[12];
+   garden.nodes[ 6].child[0] = &garden.nodes[13];
+   garden.nodes[ 6].child[1] = &garden.nodes[14];
+   garden.nodes[ 7].child[0] = &garden.nodes[15];
+   garden.nodes[ 7].child[1] = &garden.nodes[16];
+   garden.nodes[ 8].child[0] = &garden.nodes[15];
+   garden.nodes[ 8].child[1] = &garden.nodes[16];
+   garden.nodes[ 9].child[0] = &garden.nodes[15];
+   garden.nodes[ 9].child[1] = &garden.nodes[16];
+   garden.nodes[10].child[0] = &garden.nodes[15];
+   garden.nodes[10].child[1] = &garden.nodes[16];
+   garden.nodes[11].child[0] = &garden.nodes[17];
+   garden.nodes[11].child[1] = &garden.nodes[18];
+   garden.nodes[12].child[0] = &garden.nodes[17];
+   garden.nodes[12].child[1] = &garden.nodes[18];
+   garden.nodes[13].child[0] = &garden.nodes[17];
+   garden.nodes[13].child[1] = &garden.nodes[18];
+   garden.nodes[14].child[0] = &garden.nodes[17];
+   garden.nodes[14].child[1] = &garden.nodes[18];
+   garden.nodes[15].child[0] = &garden.nodes[19];
+   garden.nodes[15].child[1] = &garden.nodes[20];
+   garden.nodes[16].child[0] = &garden.nodes[19];
+   garden.nodes[16].child[1] = &garden.nodes[20];
+   garden.nodes[17].child[0] = &garden.nodes[19];
+   garden.nodes[17].child[1] = &garden.nodes[20];
+   garden.nodes[18].child[0] = &garden.nodes[19];
+   garden.nodes[18].child[1] = &garden.nodes[20];
+   garden.nodes[19].child[0] = &garden.nodes[21];
+   garden.nodes[19].child[1] = &garden.nodes[21];
+   garden.nodes[20].child[0] = &garden.nodes[21];
+   garden.nodes[20].child[1] = &garden.nodes[21];
+   garden.nodes[21].child[0] = NULL;
+   garden.nodes[21].child[1] = NULL;
+
+   return true;
+}
+
+// Produce a 32-byte hash from 80-byte input data
+int minotaur_hash( void *output, const void *input, int thr_id )
+{    
+    unsigned char hash[64] __attribute__ ((aligned (64)));
+
+    // Find initial sha512 hash
+    SHA512_Init( &garden.sha512 );
+    SHA512_Update( &garden.sha512, input, 80 );
+    SHA512_Final( (unsigned char*) hash, &garden.sha512 );
+
+    // algo 6 (Hamsi) is very slow. It's faster to skip hashing this nonce
+    // if Hamsi is needed but only the first and last functions are
+    // currently known. Abort if either is Hamsi.
+    if ( ( ( hash[ 0] % MINOTAUR_ALGO_COUNT ) == 6 )
+      || ( ( hash[21] % MINOTAUR_ALGO_COUNT ) == 6 ) )
+         return 0;
+
+    // Assign algos to torture garden nodes based on initial hash
+    for ( int i = 0; i < 22; i++ )
+        garden.nodes[i].algo = hash[i] % MINOTAUR_ALGO_COUNT;
+
+    // Send the initial hash through the torture garden
+    TortureNode *node = &garden.nodes[0];
+
+    while ( node )
+    {
+      get_hash( hash, hash, &garden, node->algo );
+      node = node->child[ hash[63] & 1 ];
+    }
+
+    memcpy( output, hash, 32 );
+    return 1;
+}
+
+int scanhash_minotaur( struct work *work, uint32_t max_nonce,
+                      uint64_t *hashes_done, struct thr_info *mythr )
+{
+   uint32_t edata[20] __attribute__((aligned(64)));
+   uint32_t hash[8] __attribute__((aligned(64)));
+   uint32_t *pdata = work->data;
+   uint32_t *ptarget = work->target;
+   const uint32_t first_nonce = pdata[19];
+   const uint32_t last_nonce = max_nonce - 1;
+   uint32_t n = first_nonce;
+   const int thr_id = mythr->id;
+   const bool bench = opt_benchmark;
+   uint64_t skipped = 0;
+
+   mm128_bswap32_80( edata, pdata );
+   do
+   {
+      edata[19] = n;
+      if ( likely( algo_gate.hash( hash, edata, thr_id ) ) )
+      {
+	 if ( unlikely( valid_hash( hash, ptarget ) && !bench ) )
+         {
+            pdata[19] = bswap_32( n );
+            submit_solution( work, hash, mythr );
+         }
+      }
+      else skipped++;
+      n++;
+   } while ( n < last_nonce && !work_restart[thr_id].restart );
+   *hashes_done = n - first_nonce - skipped;
+   pdata[19] = n;
+   return 0;
+}
+
+bool register_minotaur_algo( algo_gate_t* gate )
+{
+  gate->scanhash = (void*)&scanhash_minotaur;
+  gate->hash      = (void*)&minotaur_hash;
+  gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT;
+  gate->miner_thread_init = (void*)&initialize_torture_garden;
+  return true;
+};
+

algo/x16/x16r-4way.c

@@ -347,14 +347,14 @@ int x16r_8way_hash_generic( void* output, const void* input, int thrid )
                           hash7, vhash );
          break;
          case FUGUE:
-             sph_fugue512_full( &ctx.fugue, hash0, in0, size );
-             sph_fugue512_full( &ctx.fugue, hash1, in1, size );
-             sph_fugue512_full( &ctx.fugue, hash2, in2, size );
-             sph_fugue512_full( &ctx.fugue, hash3, in3, size );
-             sph_fugue512_full( &ctx.fugue, hash4, in4, size );
-             sph_fugue512_full( &ctx.fugue, hash5, in5, size );
-             sph_fugue512_full( &ctx.fugue, hash6, in6, size );
-             sph_fugue512_full( &ctx.fugue, hash7, in7, size );
+             fugue512_full( &ctx.fugue, hash0, in0, size );
+             fugue512_full( &ctx.fugue, hash1, in1, size );
+             fugue512_full( &ctx.fugue, hash2, in2, size );
+             fugue512_full( &ctx.fugue, hash3, in3, size );
+             fugue512_full( &ctx.fugue, hash4, in4, size );
+             fugue512_full( &ctx.fugue, hash5, in5, size );
+             fugue512_full( &ctx.fugue, hash6, in6, size );
+             fugue512_full( &ctx.fugue, hash7, in7, size );
          break;
          case SHABAL:
              intrlv_8x32( vhash, in0, in1, in2, in3, in4, in5, in6, in7,
@@ -747,10 +747,10 @@ int x16r_4way_hash_generic( void* output, const void* input, int thrid )
             dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
          break;
          case FUGUE:
-             sph_fugue512_full( &ctx.fugue, hash0, in0, size );
-             sph_fugue512_full( &ctx.fugue, hash1, in1, size );
-             sph_fugue512_full( &ctx.fugue, hash2, in2, size );
-             sph_fugue512_full( &ctx.fugue, hash3, in3, size );
+             fugue512_full( &ctx.fugue, hash0, in0, size );
+             fugue512_full( &ctx.fugue, hash1, in1, size );
+             fugue512_full( &ctx.fugue, hash2, in2, size );
+             fugue512_full( &ctx.fugue, hash3, in3, size );
          break;
          case SHABAL:
              intrlv_4x32( vhash, in0, in1, in2, in3, size<<3 );

algo/x16/x16r-gate.c

@@ -135,18 +135,16 @@ void x16rt_getAlgoString( const uint32_t *timeHash, char *output)
 
 void veil_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
 {
+   uint32_t merkleroothash[8];
+   uint32_t witmerkleroothash[8];
+   uint32_t denom10[8];
+   uint32_t denom100[8];
+   uint32_t denom1000[8];
+   uint32_t denom10000[8];
+   int i;
    uchar merkle_tree[64] = { 0 };
-   size_t t;
 
    algo_gate.gen_merkle_root( merkle_tree, sctx );
-   // Increment extranonce2
-   for ( t = 0; t < sctx->xnonce2_size && !( ++sctx->job.xnonce2[t] ); t++ );
-
-   // Assemble block header
-//   algo_gate.build_block_header( g_work, le32dec( sctx->job.version ),
-//          (uint32_t*) sctx->job.prevhash, (uint32_t*) merkle_tree,
-//          le32dec( sctx->job.ntime ), le32dec(sctx->job.nbits) );
-   int i;
 
    memset( g_work->data, 0, sizeof(g_work->data) );
    g_work->data[0] = le32dec( sctx->job.version );
@@ -164,35 +162,35 @@ void veil_build_extraheader( struct work* g_work, struct stratum_ctx* sctx )
    g_work->data[31] = 0x00000280;
 
    for ( i = 0; i < 8; i++ )
-      g_work->merkleroothash[7 - i] = be32dec((uint32_t *)merkle_tree + i);
+      merkleroothash[7 - i] = be32dec((uint32_t *)merkle_tree + i);
    for ( i = 0; i < 8; i++ )
-      g_work->witmerkleroothash[7 - i] = be32dec((uint32_t *)merkle_tree + i);
+      witmerkleroothash[7 - i] = be32dec((uint32_t *)merkle_tree + i);
    for ( i = 0; i < 8; i++ )
-      g_work->denom10[i] =    le32dec((uint32_t *)sctx->job.denom10 + i);
+      denom10[i] =    le32dec((uint32_t *)sctx->job.denom10 + i);
    for ( i = 0; i < 8; i++ )
-      g_work->denom100[i] =   le32dec((uint32_t *)sctx->job.denom100 + i);
+      denom100[i] =   le32dec((uint32_t *)sctx->job.denom100 + i);
    for ( i = 0; i < 8; i++ )
-      g_work->denom1000[i] =  le32dec((uint32_t *)sctx->job.denom1000 + i);
+      denom1000[i] =  le32dec((uint32_t *)sctx->job.denom1000 + i);
    for ( i = 0; i < 8; i++ )
-      g_work->denom10000[i] = le32dec((uint32_t *)sctx->job.denom10000 + i);
+      denom10000[i] = le32dec((uint32_t *)sctx->job.denom10000 + i);
 
    uint32_t pofnhash[8];
    memset(pofnhash, 0x00, 32);
 
-   char denom10_str      [ 2 * sizeof( g_work->denom10 )           + 1 ];
-   char denom100_str     [ 2 * sizeof( g_work->denom100 )          + 1 ];
-   char denom1000_str    [ 2 * sizeof( g_work->denom1000 )         + 1 ];
-   char denom10000_str   [ 2 * sizeof( g_work->denom10000 )        + 1 ];
-   char merkleroot_str   [ 2 * sizeof( g_work->merkleroothash )    + 1 ];
-   char witmerkleroot_str[ 2 * sizeof( g_work->witmerkleroothash ) + 1 ];
+   char denom10_str      [ 2 * sizeof( denom10 )           + 1 ];
+   char denom100_str     [ 2 * sizeof( denom100 )          + 1 ];
+   char denom1000_str    [ 2 * sizeof( denom1000 )         + 1 ];
+   char denom10000_str   [ 2 * sizeof( denom10000 )        + 1 ];
+   char merkleroot_str   [ 2 * sizeof( merkleroothash )    + 1 ];
+   char witmerkleroot_str[ 2 * sizeof( witmerkleroothash ) + 1 ];
    char pofn_str         [ 2 * sizeof( pofnhash )                  + 1 ];
 
-   cbin2hex( denom10_str,       (char*) g_work->denom10,           32 );
-   cbin2hex( denom100_str,      (char*) g_work->denom100,          32 );
-   cbin2hex( denom1000_str,     (char*) g_work->denom1000,         32 );
-   cbin2hex( denom10000_str,    (char*) g_work->denom10000,        32 );
-   cbin2hex( merkleroot_str,    (char*) g_work->merkleroothash,    32 );
-   cbin2hex( witmerkleroot_str, (char*) g_work->witmerkleroothash, 32 );
+   cbin2hex( denom10_str,       (char*) denom10,           32 );
+   cbin2hex( denom100_str,      (char*) denom100,          32 );
+   cbin2hex( denom1000_str,     (char*) denom1000,         32 );
+   cbin2hex( denom10000_str,    (char*) denom10000,        32 );
+   cbin2hex( merkleroot_str,    (char*) merkleroothash,    32 );
+   cbin2hex( witmerkleroot_str, (char*) witmerkleroothash, 32 );
    cbin2hex( pofn_str,          (char*) pofnhash,                  32 );
 
    if ( true )

algo/x16/x16r-gate.h

@@ -24,6 +24,7 @@
 #if defined(__AES__)
   #include "algo/echo/aes_ni/hash_api.h"
   #include "algo/groestl/aes_ni/hash-groestl.h"
+  #include "algo/fugue/fugue-aesni.h"
 #endif
 #if defined (__AVX2__)
 #include "algo/blake/blake-hash-4way.h"
@@ -111,7 +112,7 @@ union _x16r_8way_context_overlay
     cubehashParam           cube;
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_8way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_8way_context     sha512;
@@ -155,7 +156,7 @@ union _x16r_4way_context_overlay
     shavite512_context      shavite;
     simd_2way_context       simd;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_4way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_4way_context     sha512;
@@ -180,9 +181,11 @@ union _x16r_context_overlay
 #if defined(__AES__)
         hashState_echo          echo;
         hashState_groestl       groestl;
+        hashState_fugue         fugue;
 #else
         sph_groestl512_context   groestl;
         sph_echo512_context      echo;
+        sph_fugue512_context    fugue;
 #endif
         sph_blake512_context    blake;
         sph_bmw512_context      bmw;
@@ -194,7 +197,6 @@ union _x16r_context_overlay
         shavite512_context      shavite;
         hashState_sd            simd;
         sph_hamsi512_context    hamsi;
-        sph_fugue512_context    fugue;
         sph_shabal512_context   shabal;
         sph_whirlpool_context   whirlpool;
         SHA512_CTX              sha512;

algo/x16/x16r.c

@@ -151,8 +151,12 @@ int x16r_hash_generic( void* output, const void* input, int thrid )
             sph_hamsi512_close( &ctx.hamsi, hash );
          break;
          case FUGUE:
-            sph_fugue512_full( &ctx.fugue, hash, in, size );
-         break;
+#if defined(__AES__)
+         fugue512_full( &ctx.fugue, hash, in, size );
+#else
+	 sph_fugue512_full( &ctx.fugue, hash, in, size );
+#endif
+	 break;
          case SHABAL:
             if ( i == 0 )
                sph_shabal512( &ctx.shabal, in+64, 16 );

algo/x16/x16rv2-4way.c

@@ -8,30 +8,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.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/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/shavite/sph_shavite.h"
-#include "algo/luffa/luffa-hash-2way.h"
-#include "algo/cubehash/cubehash_sse2.h"
-#include "algo/cubehash/cube-hash-2way.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/sha/sha-hash-4way.h"
 #include "algo/tiger/sph_tiger.h"
-#if defined(__VAES__)
-  #include "algo/groestl/groestl512-hash-4way.h"
-  #include "algo/shavite/shavite-hash-4way.h"
-  #include "algo/echo/echo-hash-4way.h"
-#endif
 
 #if defined (X16RV2_8WAY)
 
@@ -46,7 +23,7 @@ union _x16rv2_8way_context_overlay
     cubehashParam           cube;
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_8way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_8way_context     sha512;
@@ -432,14 +409,14 @@ int x16rv2_8way_hash( void* output, const void* input, int thrid )
                           hash7, vhash );
          break;
          case FUGUE:
-            sph_fugue512_full( &ctx.fugue, hash0, in0, size );
-            sph_fugue512_full( &ctx.fugue, hash1, in1, size );
-            sph_fugue512_full( &ctx.fugue, hash2, in2, size );
-            sph_fugue512_full( &ctx.fugue, hash3, in3, size );
-            sph_fugue512_full( &ctx.fugue, hash4, in4, size );
-            sph_fugue512_full( &ctx.fugue, hash5, in5, size );
-            sph_fugue512_full( &ctx.fugue, hash6, in6, size );
-            sph_fugue512_full( &ctx.fugue, hash7, in7, size );
+            fugue512_full( &ctx.fugue, hash0, in0, size );
+            fugue512_full( &ctx.fugue, hash1, in1, size );
+            fugue512_full( &ctx.fugue, hash2, in2, size );
+            fugue512_full( &ctx.fugue, hash3, in3, size );
+            fugue512_full( &ctx.fugue, hash4, in4, size );
+            fugue512_full( &ctx.fugue, hash5, in5, size );
+            fugue512_full( &ctx.fugue, hash6, in6, size );
+            fugue512_full( &ctx.fugue, hash7, in7, size );
          break;
          case SHABAL:
             intrlv_8x32( vhash, in0, in1, in2, in3, in4, in5, in6, in7,
@@ -705,7 +682,7 @@ union _x16rv2_4way_context_overlay
     shavite512_context      shavite;
     simd_2way_context       simd;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_4way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_4way_context     sha512;
@@ -946,10 +923,10 @@ int x16rv2_4way_hash( void* output, const void* input, int thrid )
             dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
          break;
          case FUGUE:
-            sph_fugue512_full( &ctx.fugue, hash0, in0, size );
-            sph_fugue512_full( &ctx.fugue, hash1, in1, size );
-            sph_fugue512_full( &ctx.fugue, hash2, in2, size );
-            sph_fugue512_full( &ctx.fugue, hash3, in3, size );
+            fugue512_full( &ctx.fugue, hash0, in0, size );
+            fugue512_full( &ctx.fugue, hash1, in1, size );
+            fugue512_full( &ctx.fugue, hash2, in2, size );
+            fugue512_full( &ctx.fugue, hash3, in3, size );
          break;
          case SHABAL:
              intrlv_4x32( vhash, in0, in1, in2, in3, size<<3 );

algo/x16/x16rv2.c

@@ -8,41 +8,18 @@
 
 #if !defined(X16R_8WAY) && !defined(X16R_4WAY)
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include "algo/blake/sph_blake.h"
-#include "algo/bmw/sph_bmw.h"
-#include "algo/groestl/sph_groestl.h"
-#include "algo/jh/sph_jh.h"
-#include "algo/keccak/sph_keccak.h"
-#include "algo/skein/sph_skein.h"
-#include "algo/shavite/sph_shavite.h"
-#include "algo/luffa/luffa_for_sse2.h"
-#include "algo/cubehash/cubehash_sse2.h"
-#include "algo/simd/nist.h"
-#include "algo/echo/sph_echo.h"
-#include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
-#include "algo/shabal/sph_shabal.h"
-#include "algo/whirlpool/sph_whirlpool.h"
-#include <openssl/sha.h>
 #include "algo/tiger/sph_tiger.h"
-#if defined(__AES__)
-  #include "algo/echo/aes_ni/hash_api.h"
-  #include "algo/groestl/aes_ni/hash-groestl.h"
-#endif
-
-static __thread uint32_t s_ntime = UINT32_MAX;
 
 union _x16rv2_context_overlay
 {
 #if defined(__AES__)
         hashState_echo          echo;
         hashState_groestl       groestl;
+        hashState_fugue         fugue;
 #else
         sph_groestl512_context   groestl;
         sph_echo512_context      echo;
+        sph_fugue512_context    fugue;
 #endif
         sph_blake512_context    blake;
         sph_bmw512_context      bmw;
@@ -54,7 +31,6 @@ union _x16rv2_context_overlay
         shavite512_context      shavite;
         hashState_sd            simd;
         sph_hamsi512_context    hamsi;
-        sph_fugue512_context    fugue;
         sph_shabal512_context   shabal;
         sph_whirlpool_context   whirlpool;
         SHA512_CTX              sha512;
@@ -160,8 +136,12 @@ int x16rv2_hash( void* output, const void* input, int thrid )
              sph_hamsi512_close( &ctx.hamsi, hash );
          break;
          case FUGUE:
+#if defined(__AES__)
+             fugue512_full( &ctx.fugue, hash, in, size );
+#else
              sph_fugue512_full( &ctx.fugue, hash, in, size );
-         break;
+#endif
+	     break;
          case SHABAL:
              sph_shabal512_init( &ctx.shabal );
              sph_shabal512( &ctx.shabal, in, size );

algo/x17/sonoa-4way.c

@@ -16,7 +16,7 @@
 #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/fugue/fugue-aesni.h"
 #include "algo/shabal/shabal-hash-4way.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/haval/haval-hash-4way.h"
@@ -40,7 +40,7 @@ union _sonoa_8way_context_overlay
     cube_4way_context       cube;
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_8way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_8way_context     sha512;
@@ -58,7 +58,7 @@ union _sonoa_8way_context_overlay
 
 typedef union _sonoa_8way_context_overlay sonoa_8way_context_overlay;
 
-int sonoa_8way_hash( void *state, const void *input, int thrid )
+int sonoa_8way_hash( void *state, const void *input, int thr_id )
 {
      uint64_t vhash[8*8] __attribute__ ((aligned (128)));
      uint64_t vhashA[8*8] __attribute__ ((aligned (64)));
@@ -186,7 +186,7 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
 
 #endif
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 2
 
      bmw512_8way_full( &ctx.bmw, vhash, vhash, 64 );
@@ -302,7 +302,7 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
      hamsi512_8way_update( &ctx.hamsi, vhash, 64 );
      hamsi512_8way_close( &ctx.hamsi, vhash );
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 3
 
      bmw512_8way_full( &ctx.bmw, vhash, vhash, 64 );
@@ -423,16 +423,16 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
      dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                        vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
-     sph_fugue512_full( &ctx.fugue, hash4, hash4, 64 );
-     sph_fugue512_full( &ctx.fugue, hash5, hash5, 64 );
-     sph_fugue512_full( &ctx.fugue, hash6, hash6, 64 );
-     sph_fugue512_full( &ctx.fugue, hash7, hash7, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+     fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+     fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+     fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 4
 
      intrlv_8x64_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
@@ -554,14 +554,14 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
      dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                        vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
-     sph_fugue512_full( &ctx.fugue, hash4, hash4, 64 );
-     sph_fugue512_full( &ctx.fugue, hash5, hash5, 64 );
-     sph_fugue512_full( &ctx.fugue, hash6, hash6, 64 );
-     sph_fugue512_full( &ctx.fugue, hash7, hash7, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+     fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+     fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+     fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
      intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                       hash7 );
@@ -630,7 +630,7 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
 
 #endif
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 5
 
      bmw512_8way_full( &ctx.bmw, vhash, vhash, 64 );
@@ -755,14 +755,14 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
      dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                        vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
-     sph_fugue512_full( &ctx.fugue, hash4, hash4, 64 );
-     sph_fugue512_full( &ctx.fugue, hash5, hash5, 64 );
-     sph_fugue512_full( &ctx.fugue, hash6, hash6, 64 );
-     sph_fugue512_full( &ctx.fugue, hash7, hash7, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+     fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+     fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+     fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
      intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                       hash7 );
@@ -783,7 +783,7 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
      sph_whirlpool512_full( &ctx.whirlpool, hash6, hash6, 64 );
      sph_whirlpool512_full( &ctx.whirlpool, hash7, hash7, 64 );
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 6
 
      intrlv_8x64_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
@@ -905,14 +905,14 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
      dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                        vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
-     sph_fugue512_full( &ctx.fugue, hash4, hash4, 64 );
-     sph_fugue512_full( &ctx.fugue, hash5, hash5, 64 );
-     sph_fugue512_full( &ctx.fugue, hash6, hash6, 64 );
-     sph_fugue512_full( &ctx.fugue, hash7, hash7, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+     fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+     fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+     fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
      intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                       hash7 );
@@ -952,7 +952,7 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
      sph_whirlpool512_full( &ctx.whirlpool, hash6, hash6, 64 );
      sph_whirlpool512_full( &ctx.whirlpool, hash7, hash7, 64 );
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 7
 
      intrlv_8x64_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
@@ -1074,14 +1074,14 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
      dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                        vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
-     sph_fugue512_full( &ctx.fugue, hash4, hash4, 64 );
-     sph_fugue512_full( &ctx.fugue, hash5, hash5, 64 );
-     sph_fugue512_full( &ctx.fugue, hash6, hash6, 64 );
-     sph_fugue512_full( &ctx.fugue, hash7, hash7, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+     fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+     fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+     fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
      intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                       hash7 );
@@ -1117,49 +1117,6 @@ int sonoa_8way_hash( void *state, const void *input, int thrid )
 
      return 1;
 }
-     
-int scanhash_sonoa_8way( struct work *work, uint32_t max_nonce,
-                       uint64_t *hashes_done, struct thr_info *mythr )
-{
-   uint32_t hash[8*16] __attribute__ ((aligned (128)));
-   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
-   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
-   uint32_t *hashd7 = &(hash[7<<3]);
-   uint32_t *pdata = work->data;
-   const uint32_t *ptarget = work->target;
-   const uint32_t first_nonce = pdata[19];
-   const uint32_t last_nonce = max_nonce - 8;
-   __m512i  *noncev = (__m512i*)vdata + 9;   // aligned
-   uint32_t n = first_nonce;
-   const int thr_id = mythr->id;
-   const uint32_t targ32 = ptarget[7];
-
-   mm512_bswap32_intrlv80_8x64( vdata, pdata );
-   *noncev = mm512_intrlv_blend_32(
-              _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0,
-                                n+3, 0, n+2, 0, n+1, 0, n,   0 ), *noncev );
-
-   do
-   {
-      if ( sonoa_8way_hash( hash, vdata, thr_id ) )
-      for ( int lane = 0; lane < 8; lane++ )
-      if unlikely( ( hashd7[ lane ] <= targ32 ) )
-      {
-         extr_lane_8x32( lane_hash, hash, lane, 256 );
-         if ( likely( valid_hash( lane_hash, ptarget ) && !opt_benchmark ) )
-         {
-            pdata[19] = bswap_32( n + lane );
-            submit_solution( work, lane_hash, mythr );
-         }
-      }
-      *noncev = _mm512_add_epi32( *noncev,
-                                  m512_const1_64( 0x0000000800000000 ) );
-      n += 8;
-   } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
-   pdata[19] = n;
-   *hashes_done = n - first_nonce;
-   return 0;
-}
 
 #elif defined(SONOA_4WAY)
 
@@ -1177,7 +1134,7 @@ union _sonoa_4way_context_overlay
     simd_2way_context       simd;
     hashState_echo          echo;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_4way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_4way_context     sha512;
@@ -1186,7 +1143,7 @@ union _sonoa_4way_context_overlay
 
 typedef union _sonoa_4way_context_overlay sonoa_4way_context_overlay;
 
-int sonoa_4way_hash( void *state, const void *input, int thrid )
+int sonoa_4way_hash( void *state, const void *input, int thr_id )
 {
      uint64_t hash0[8] __attribute__ ((aligned (64)));
      uint64_t hash1[8] __attribute__ ((aligned (64)));
@@ -1250,7 +1207,7 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
      echo_full( &ctx.echo, (BitSequence *)hash3, 512,
                      (const BitSequence *)hash3, 64 );
      
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 2
 
      intrlv_4x64_512( vhash, hash0, hash1, hash2, hash3 );
@@ -1310,7 +1267,7 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
      hamsi512_4way_update( &ctx.hamsi, vhash, 64 );
      hamsi512_4way_close( &ctx.hamsi, vhash );
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 3
 
      bmw512_4way_init( &ctx.bmw );
@@ -1370,12 +1327,12 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
 
      dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 4
      intrlv_4x64_512( vhash, hash0, hash1, hash2, hash3 );
 
@@ -1436,10 +1393,10 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
 
      dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
      intrlv_4x32_512( vhash, hash0, hash1, hash2, hash3 );
 
@@ -1472,7 +1429,7 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
      shavite512_2way_init( &ctx.shavite );
      shavite512_2way_update_close( &ctx.shavite, vhashB, vhashB, 64 );
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 5
      rintrlv_2x128_4x64( vhash, vhashA, vhashB, 512 );
 
@@ -1539,10 +1496,10 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
 
      dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
      intrlv_4x32_512( vhash, hash0, hash1, hash2, hash3 );
 
@@ -1557,7 +1514,7 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
      sph_whirlpool512_full( &ctx.whirlpool, hash2, hash2, 64 );
      sph_whirlpool512_full( &ctx.whirlpool, hash3, hash3, 64 );
 
-     if ( work_restart[thrid].restart ) return 0;
+     if ( work_restart[thr_id].restart ) return 0;
 // 6
 
      intrlv_4x64_512( vhash, hash0, hash1, hash2, hash3 );
@@ -1619,10 +1576,10 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
 
      dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
      intrlv_4x32_512( vhash, hash0, hash1, hash2, hash3 );
 
@@ -1650,7 +1607,7 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
      sph_whirlpool512_full( &ctx.whirlpool, hash2, hash2, 64 );
      sph_whirlpool512_full( &ctx.whirlpool, hash3, hash3, 64 );
 
-     if ( work_restart[thrid].restart ) return 0;    
+     if ( work_restart[thr_id].restart ) return 0;    
 // 7
 
      intrlv_4x64_512( vhash, hash0, hash1, hash2, hash3 );
@@ -1712,10 +1669,10 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
 
      dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
      intrlv_4x32_512( vhash, hash0, hash1, hash2, hash3 );
 
@@ -1745,46 +1702,4 @@ int sonoa_4way_hash( void *state, const void *input, int thrid )
      return 1;
 }
 
-int scanhash_sonoa_4way( struct work *work, const uint32_t max_nonce,
-	            uint64_t *hashes_done, struct thr_info *mythr )
-{
-     uint32_t hash[4*16] __attribute__ ((aligned (64)));
-     uint32_t vdata[24*4] __attribute__ ((aligned (64)));
-     uint32_t lane_hash[8] __attribute__ ((aligned (32)));
-     uint32_t *hashd7 = &( hash[7<<2] );
-     uint32_t *pdata = work->data;
-     const uint32_t *ptarget = work->target;
-     const uint32_t first_nonce = pdata[19];
-     const uint32_t last_nonce = max_nonce - 4;
-     const uint32_t targ32 = ptarget[7];
-     uint32_t n = first_nonce;
-     __m256i  *noncev = (__m256i*)vdata + 9;  
-     const int thr_id = mythr->id;
-
-     mm256_bswap32_intrlv80_4x64( vdata, pdata );
-     *noncev = mm256_intrlv_blend_32(
-                   _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
-
-     do
-     {
-        if ( sonoa_4way_hash( hash, vdata, thr_id ) )
-        for ( int lane = 0; lane < 4; lane++ )
-        if ( unlikely( hashd7[ lane ] <= targ32 ) )
-        {
-           extr_lane_4x32( lane_hash, hash, lane, 256 );
-           if ( likely( valid_hash( lane_hash, ptarget ) && !opt_benchmark ) )
-           {
-              pdata[19] = bswap_32( n + lane );
-              submit_solution( work, lane_hash, mythr );
-           }
-        }
-        *noncev = _mm256_add_epi32( *noncev,
-                                    m256_const1_64( 0x0000000400000000 ) );
-        n += 4;
-     } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
-     pdata[19] = n;
-     *hashes_done = n - first_nonce;
-     return 0;
-}
-
 #endif

algo/x17/sonoa-gate.c

@@ -3,15 +3,14 @@
 bool register_sonoa_algo( algo_gate_t* gate )
 {
 #if defined (SONOA_8WAY)
-  gate->scanhash  = (void*)&scanhash_sonoa_8way;
-//  gate->hash      = (void*)&sonoa_8way_hash;
+  gate->scanhash  = (void*)&scanhash_8way_64in_32out;
+  gate->hash      = (void*)&sonoa_8way_hash;
 #elif defined (SONOA_4WAY)
-  gate->scanhash  = (void*)&scanhash_sonoa_4way;
-//  gate->hash      = (void*)&sonoa_4way_hash;
+  gate->scanhash  = (void*)&scanhash_4way_64in_32out;
+  gate->hash      = (void*)&sonoa_4way_hash;
 #else
   init_sonoa_ctx();
-  gate->scanhash  = (void*)&scanhash_sonoa;
-//  gate->hash      = (void*)&sonoa_hash;
+  gate->hash      = (void*)&sonoa_hash;
 #endif
   gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT | VAES_OPT;
   return true;

algo/x17/sonoa-gate.h

@@ -14,21 +14,15 @@ bool register_sonoa_algo( algo_gate_t* gate );
 
 #if defined(SONOA_8WAY)
 
-int sonoa_8way_hash( void *state, const void *input, int thrid );
-int scanhash_sonoa_8way( struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done, struct thr_info *mythr );
+int sonoa_8way_hash( void *state, const void *input, int thr_id );
 
 #elif defined(SONOA_4WAY)
 
-int sonoa_4way_hash( void *state, const void *input, int thrid );
-int scanhash_sonoa_4way( struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done, struct thr_info *mythr );
+int sonoa_4way_hash( void *state, const void *input, int thr_id );
 
 #else
 
-int sonoa_hash( void *state, const void *input, int thrid );
-int scanhash_sonoa( struct work *work, uint32_t max_nonce,
-                  uint64_t *hashes_done, struct thr_info *mythr );
+int sonoa_hash( void *state, const void *input, int thr_id );
 void init_sonoa_ctx();
 
 #endif

algo/x17/sonoa.c

@@ -14,7 +14,6 @@
 #include "algo/skein/sph_skein.h"
 #include "algo/shavite/sph_shavite.h"
 #include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/shabal/sph_shabal.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/haval/sph-haval.h"
@@ -25,9 +24,11 @@
 #if defined(__AES__)
   #include "algo/echo/aes_ni/hash_api.h"
   #include "algo/groestl/aes_ni/hash-groestl.h"
+  #include "algo/fugue/fugue-aesni.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 
 typedef struct {
@@ -36,9 +37,11 @@ typedef struct {
 #if defined(__AES__)
         hashState_echo          echo;
         hashState_groestl       groestl;
+        hashState_fugue         fugue;
 #else
         sph_groestl512_context  groestl;
         sph_echo512_context     echo;
+        sph_fugue512_context    fugue;
 #endif
         sph_jh512_context       jh;
         sph_keccak512_context   keccak;
@@ -48,7 +51,6 @@ typedef struct {
         sph_shavite512_context  shavite;
         hashState_sd            simd;
         sph_hamsi512_context    hamsi;
-        sph_fugue512_context    fugue;
         sph_shabal512_context   shabal;
         sph_whirlpool_context   whirlpool;
         SHA512_CTX              sha512;
@@ -64,9 +66,11 @@ void init_sonoa_ctx()
 #if defined(__AES__)
         init_echo( &sonoa_ctx.echo, 512 );
         init_groestl( &sonoa_ctx.groestl, 64 );
+        fugue512_Init( &sonoa_ctx.fugue, 512 );
 #else
         sph_groestl512_init(&sonoa_ctx.groestl );
         sph_echo512_init( &sonoa_ctx.echo );
+        sph_fugue512_init( &sonoa_ctx.fugue );
 #endif
         sph_skein512_init( &sonoa_ctx.skein);
         sph_jh512_init( &sonoa_ctx.jh);
@@ -76,14 +80,13 @@ void init_sonoa_ctx()
         sph_shavite512_init( &sonoa_ctx.shavite );
         init_sd( &sonoa_ctx.simd, 512 );
         sph_hamsi512_init( &sonoa_ctx.hamsi );
-        sph_fugue512_init( &sonoa_ctx.fugue );
         sph_shabal512_init( &sonoa_ctx.shabal );
         sph_whirlpool_init( &sonoa_ctx.whirlpool );
         SHA512_Init( &sonoa_ctx.sha512 );
         sph_haval256_5_init(&sonoa_ctx.haval);
 };
 
-int sonoa_hash( void *state, const void *input, int thrid )
+int sonoa_hash( void *state, const void *input, int thr_id )
 {
 	uint8_t hash[128] __attribute__ ((aligned (64)));
    sonoa_ctx_holder ctx __attribute__ ((aligned (64)));
@@ -132,7 +135,7 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_echo512_close(&ctx.echo, hash);
 #endif
 
-   if ( work_restart[thrid].restart ) return 0;
+   if ( work_restart[thr_id].restart ) return 0;
 //
 
    sph_bmw512_init( &ctx.bmw);
@@ -190,7 +193,7 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_hamsi512(&ctx.hamsi, hash, 64);
    sph_hamsi512_close(&ctx.hamsi, hash);
 	
-   if ( work_restart[thrid].restart ) return 0;
+   if ( work_restart[thr_id].restart ) return 0;
 //
 
    sph_bmw512_init( &ctx.bmw);
@@ -249,10 +252,15 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_hamsi512(&ctx.hamsi, hash, 64);
    sph_hamsi512_close(&ctx.hamsi, hash);
 
+#if defined(__AES__)
+   fugue512_Update( &ctx.fugue, hash, 512 );
+   fugue512_Final( &ctx.fugue, hash ); 
+#else   
    sph_fugue512(&ctx.fugue, hash, 64);
    sph_fugue512_close(&ctx.fugue, hash);
+#endif
 
-   if ( work_restart[thrid].restart ) return 0;
+   if ( work_restart[thr_id].restart ) return 0;
 //
 
    sph_bmw512_init( &ctx.bmw);
@@ -311,9 +319,11 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_hamsi512(&ctx.hamsi, hash, 64);
    sph_hamsi512_close(&ctx.hamsi, hash);
 
-   sph_fugue512_init( &ctx.fugue );
-   sph_fugue512(&ctx.fugue, hash, 64);
-   sph_fugue512_close(&ctx.fugue, hash);
+#if defined(__AES__)
+    fugue512_full( &ctx.fugue, hash, hash, 64 );
+#else
+    sph_fugue512_full( &ctx.fugue, hash, hash, 64 );
+#endif
 
    sph_shabal512(&ctx.shabal, hash, 64);
    sph_shabal512_close(&ctx.shabal, hash);
@@ -336,7 +346,7 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_shavite512(&ctx.shavite, hash, 64);
    sph_shavite512_close(&ctx.shavite, hash);
 
-   if ( work_restart[thrid].restart ) return 0;
+   if ( work_restart[thr_id].restart ) return 0;
 //
 
    sph_bmw512_init( &ctx.bmw);
@@ -399,9 +409,11 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_hamsi512(&ctx.hamsi, hash, 64);
    sph_hamsi512_close(&ctx.hamsi, hash);
 
-   sph_fugue512_init( &ctx.fugue );
-   sph_fugue512(&ctx.fugue, hash, 64);
-   sph_fugue512_close(&ctx.fugue, hash);
+#if defined(__AES__)
+    fugue512_full( &ctx.fugue, hash, hash, 64 );
+#else
+    sph_fugue512_full( &ctx.fugue, hash, hash, 64 );
+#endif
 
    sph_shabal512_init( &ctx.shabal );
    sph_shabal512(&ctx.shabal, hash, 64);
@@ -410,7 +422,7 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_whirlpool(&ctx.whirlpool, hash, 64);
    sph_whirlpool_close(&ctx.whirlpool, hash);
 
-   if ( work_restart[thrid].restart ) return 0;
+   if ( work_restart[thr_id].restart ) return 0;
 //
    sph_bmw512_init( &ctx.bmw);
    sph_bmw512(&ctx.bmw, hash, 64);
@@ -468,9 +480,11 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_hamsi512(&ctx.hamsi, hash, 64);
    sph_hamsi512_close(&ctx.hamsi, hash);
 
-   sph_fugue512_init( &ctx.fugue );
-   sph_fugue512(&ctx.fugue, hash, 64);
-   sph_fugue512_close(&ctx.fugue, hash);
+#if defined(__AES__)
+    fugue512_full( &ctx.fugue, hash, hash, 64 );
+#else
+    sph_fugue512_full( &ctx.fugue, hash, hash, 64 );
+#endif
 
    sph_shabal512_init( &ctx.shabal );
    sph_shabal512(&ctx.shabal, hash, 64);
@@ -487,7 +501,7 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_whirlpool(&ctx.whirlpool, hash, 64);
    sph_whirlpool_close(&ctx.whirlpool, hash);
 
-   if ( work_restart[thrid].restart ) return 0;
+   if ( work_restart[thr_id].restart ) return 0;
 //
 
    sph_bmw512_init( &ctx.bmw);
@@ -546,9 +560,11 @@ int sonoa_hash( void *state, const void *input, int thrid )
    sph_hamsi512(&ctx.hamsi, hash, 64);
    sph_hamsi512_close(&ctx.hamsi, hash);
 
-   sph_fugue512_init( &ctx.fugue );
-   sph_fugue512(&ctx.fugue, hash, 64);
-   sph_fugue512_close(&ctx.fugue, hash);
+#if defined(__AES__)
+    fugue512_full( &ctx.fugue, hash, hash, 64 );
+#else
+    sph_fugue512_full( &ctx.fugue, hash, hash, 64 );
+#endif
 
    sph_shabal512_init( &ctx.shabal );
    sph_shabal512(&ctx.shabal, hash, 64);
@@ -569,34 +585,4 @@ int sonoa_hash( void *state, const void *input, int thrid )
    return 1;
 }
 
-int scanhash_sonoa( struct work *work, uint32_t max_nonce,
-             uint64_t *hashes_done, struct thr_info *mythr)
-{
-   uint32_t edata[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];
-   const uint32_t first_nonce = pdata[19];
-   const int thr_id = mythr->id;
-   const bool bench = opt_benchmark;
-
-   mm128_bswap32_80( edata, pdata );
-
-   do
-   {
-      edata[19] = n;
-      if ( sonoa_hash( hash64, edata, thr_id ) )
-      if ( unlikely( valid_hash( hash64, ptarget ) && !bench ) )
-      {
-         pdata[19] = bswap_32( n );
-         submit_solution( work, hash64, mythr );
-      }
-      n++;
-   } while ( n < max_nonce && !work_restart[thr_id].restart );
-   *hashes_done = n - first_nonce;
-   pdata[19] = n;
-   return 0;
-}
-
 #endif

algo/x17/x17-4way.c

@@ -21,7 +21,7 @@
 #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/fugue/fugue-aesni.h"
 #include "algo/shabal/shabal-hash-4way.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/haval/haval-hash-4way.h"
@@ -49,7 +49,7 @@ union _x17_8way_context_overlay
 #endif
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_8way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_8way_context     sha512;
@@ -57,7 +57,7 @@ union _x17_8way_context_overlay
 } __attribute__ ((aligned (64)));
 typedef union _x17_8way_context_overlay x17_8way_context_overlay;
 
-void x17_8way_hash( void *state, const void *input )
+int x17_8way_hash( void *state, const void *input, int thr_id )
 {
      uint64_t vhash[8*8] __attribute__ ((aligned (128)));
      uint64_t vhashA[8*8] __attribute__ ((aligned (64)));
@@ -190,14 +190,14 @@ void x17_8way_hash( void *state, const void *input )
      dintrlv_8x64_512( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                        vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
-     sph_fugue512_full( &ctx.fugue, hash4, hash4, 64 );
-     sph_fugue512_full( &ctx.fugue, hash5, hash5, 64 );
-     sph_fugue512_full( &ctx.fugue, hash6, hash6, 64 );
-     sph_fugue512_full( &ctx.fugue, hash7, hash7, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+     fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+     fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+     fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
      intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                       hash7 );
@@ -230,50 +230,8 @@ void x17_8way_hash( void *state, const void *input )
      haval256_5_8way_init( &ctx.haval );
      haval256_5_8way_update( &ctx.haval, vhashA, 64 );
      haval256_5_8way_close( &ctx.haval, state );
-}
 
-int scanhash_x17_8way( struct work *work, uint32_t max_nonce,
-                       uint64_t *hashes_done, struct thr_info *mythr )
-{
-   uint32_t hash32[8*8] __attribute__ ((aligned (128)));
-   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
-   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
-   uint32_t *hash32_d7 = &(hash32[7*8]);
-   uint32_t *pdata = work->data;
-   const uint32_t *ptarget = work->target;
-   const uint32_t first_nonce = pdata[19];
-   const uint32_t last_nonce = max_nonce - 8;
-   __m512i  *noncev = (__m512i*)vdata + 9; 
-   uint32_t n = first_nonce;
-   const int thr_id = mythr->id;
-   const uint32_t targ32_d7 = ptarget[7];
-   const bool bench = opt_benchmark;
-
-   mm512_bswap32_intrlv80_8x64( vdata, pdata );
-   *noncev = mm512_intrlv_blend_32(
-              _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0,
-                                n+3, 0, n+2, 0, n+1, 0, n,   0 ), *noncev );
-   do
-   {
-      x17_8way_hash( hash32, vdata );
-
-      for ( int lane = 0; lane < 8; lane++ )
-      if ( unlikely( ( hash32_d7[ lane ] <= targ32_d7 ) && !bench ) )
-      {
-         extr_lane_8x32( lane_hash, hash32, lane, 256 );
-         if ( likely( valid_hash( lane_hash, ptarget ) ) )
-         {
-            pdata[19] = bswap_32( n + lane );
-            submit_solution( work, lane_hash, mythr );
-         }
-      }
-      *noncev = _mm512_add_epi32( *noncev,
-                                  m512_const1_64( 0x0000000800000000 ) );
-      n += 8;
-   } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
-   pdata[19] = n;
-   *hashes_done = n - first_nonce;
-   return 0;
+     return 1;
 }
 
 #elif defined(X17_4WAY)
@@ -292,7 +250,7 @@ union _x17_4way_context_overlay
     simd_2way_context       simd;
     hashState_echo          echo;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_4way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_4way_context     sha512;
@@ -300,7 +258,7 @@ union _x17_4way_context_overlay
 };  
 typedef union _x17_4way_context_overlay x17_4way_context_overlay;
 
-void x17_4way_hash( void *state, const void *input )
+int x17_4way_hash( void *state, const void *input, int thr_id )
 {
      uint64_t vhash[8*4] __attribute__ ((aligned (64)));
      uint64_t vhashA[8*4] __attribute__ ((aligned (64)));
@@ -370,10 +328,10 @@ void x17_4way_hash( void *state, const void *input )
 
      dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+     fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+     fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+     fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
      intrlv_4x32_512( vhash, hash0, hash1, hash2, hash3 );
 
@@ -399,49 +357,8 @@ void x17_4way_hash( void *state, const void *input )
      haval256_5_4way_init( &ctx.haval );
      haval256_5_4way_update( &ctx.haval, vhashB, 64 );
      haval256_5_4way_close( &ctx.haval, state );
-}
 
-int scanhash_x17_4way( struct work *work, uint32_t max_nonce,
-                       uint64_t *hashes_done, struct thr_info *mythr )
-{
-   uint32_t hash32[8*4] __attribute__ ((aligned (64)));
-   uint32_t vdata[20*4] __attribute__ ((aligned (64)));
-   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
-   uint32_t *hash32_d7 = &(hash32[ 7*4 ]);
-   uint32_t *pdata = work->data;
-   const uint32_t *ptarget = work->target;
-   const uint32_t first_nonce = pdata[19];
-   const uint32_t last_nonce = max_nonce - 4;
-   __m256i  *noncev = (__m256i*)vdata + 9;
-   uint32_t n = first_nonce;
-   const int thr_id = mythr->id;
-   const uint32_t targ32_d7 = ptarget[7];
-   const bool bench = opt_benchmark;
-
-   mm256_bswap32_intrlv80_4x64( vdata, pdata );
-   *noncev = mm256_intrlv_blend_32(
-                   _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
-   do
-   {
-      x17_4way_hash( hash32, vdata );
-
-      for ( int lane = 0; lane < 4; lane++ )
-      if ( unlikely( hash32_d7[ lane ] <= targ32_d7 && !bench ) )
-      {  
-         extr_lane_4x32( lane_hash, hash32, lane, 256 );
-         if ( valid_hash( lane_hash, ptarget ) )
-         {
-            pdata[19] = bswap_32( n + lane );
-            submit_solution( work, lane_hash, mythr );
-         }            
-      }
-      *noncev = _mm256_add_epi32( *noncev,
-                                  m256_const1_64( 0x0000000400000000 ) );
-      n += 4;
-   } while ( likely( ( n <= last_nonce ) && !work_restart[thr_id].restart ) );
-   pdata[19] = n;
-   *hashes_done = n - first_nonce;
-   return 0;
+     return 1;
 }
 
 #endif

algo/x17/x17-gate.c

@@ -3,13 +3,12 @@
 bool register_x17_algo( algo_gate_t* gate )
 {
 #if defined (X17_8WAY)
-  gate->scanhash  = (void*)&scanhash_x17_8way;
+  gate->scanhash  = (void*)&scanhash_8way_64in_32out;
   gate->hash      = (void*)&x17_8way_hash;
 #elif defined (X17_4WAY)
-  gate->scanhash  = (void*)&scanhash_x17_4way;
+  gate->scanhash  = (void*)&scanhash_4way_64in_32out;
   gate->hash      = (void*)&x17_4way_hash;
 #else
-  gate->scanhash  = (void*)&scanhash_x17;
   gate->hash      = (void*)&x17_hash;
 #endif
   gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT | VAES_OPT;

algo/x17/x17-gate.h

@@ -14,20 +14,15 @@ bool register_x17_algo( algo_gate_t* gate );
 
 #if defined(X17_8WAY)
 
-void x17_8way_hash( void *state, const void *input );
-int scanhash_x17_8way( struct work *work, uint32_t max_nonce,
-                       uint64_t *hashes_done, struct thr_info *mythr );
+int x17_8way_hash( void *state, const void *input, int thr_id );
+
 #elif defined(X17_4WAY)
 
-void x17_4way_hash( void *state, const void *input );
-int scanhash_x17_4way( struct work *work, uint32_t max_nonce,
-                       uint64_t *hashes_done, struct thr_info *mythr );
+int x17_4way_hash( void *state, const void *input, int thr_id );
 
 #endif
 
-void x17_hash( void *state, const void *input );
-int scanhash_x17( struct work *work, uint32_t max_nonce,
-                  uint64_t *hashes_done, struct thr_info *mythr );
+int x17_hash( void *state, const void *input, int thr_id );
 
 #endif
 

algo/x17/x17.c

@@ -13,7 +13,6 @@
 #include "algo/skein/sph_skein.h"
 #include "algo/shavite/sph_shavite.h"
 #include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/shabal/sph_shabal.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/haval/sph-haval.h"
@@ -22,11 +21,13 @@
 #include "algo/simd/nist.h"
 #include <openssl/sha.h>
 #if defined(__AES__)
+  #include "algo/fugue/fugue-aesni.h"
   #include "algo/echo/aes_ni/hash_api.h"
   #include "algo/groestl/aes_ni/hash-groestl.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 
 union _x17_context_overlay
@@ -36,9 +37,11 @@ union _x17_context_overlay
 #if defined(__AES__)
         hashState_groestl       groestl;
         hashState_echo          echo;
+        hashState_fugue         fugue;
 #else
         sph_groestl512_context  groestl;
         sph_echo512_context     echo;
+        sph_fugue512_context    fugue;
 #endif
         sph_jh512_context       jh;
         sph_keccak512_context   keccak;
@@ -48,7 +51,6 @@ union _x17_context_overlay
         sph_shavite512_context  shavite;
         hashState_sd            simd;
         sph_hamsi512_context    hamsi;
-        sph_fugue512_context    fugue;
         sph_shabal512_context   shabal;
         sph_whirlpool_context   whirlpool;
         SHA512_CTX              sha512;
@@ -56,7 +58,7 @@ union _x17_context_overlay
 };
 typedef union _x17_context_overlay x17_context_overlay;
 
-void x17_hash(void *output, const void *input)
+int x17_hash(void *output, const void *input, int thr_id )
 {
 //    unsigned char hash[64 * 4] __attribute__((aligned(64))) = {0};
     unsigned char hash[64] __attribute__((aligned(64)));
@@ -122,9 +124,11 @@ void x17_hash(void *output, const void *input)
     sph_hamsi512_close( &ctx.hamsi, hash );
 
     // 13 Fugue
-    sph_fugue512_init( &ctx.fugue );
-    sph_fugue512(&ctx.fugue, hash, 64 );
-    sph_fugue512_close(&ctx.fugue, hash );
+#if defined(__AES__)
+    fugue512_full( &ctx.fugue, hash, hash, 64 );
+#else
+    sph_fugue512_full( &ctx.fugue, hash, hash, 64 );
+#endif
 
     // X14 Shabal
     sph_shabal512_init( &ctx.shabal );
@@ -143,36 +147,8 @@ void x17_hash(void *output, const void *input)
     sph_haval256_5_init(&ctx.haval);
     sph_haval256_5( &ctx.haval, (const void*)hash, 64 );
     sph_haval256_5_close( &ctx.haval, output );
-}
 
-int scanhash_x17( struct work *work, uint32_t max_nonce,
-	          uint64_t *hashes_done, struct thr_info *mythr)
-{
-   uint32_t edata[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];
-   const int thr_id = mythr->id;
-   const bool bench = opt_benchmark;
-
-   mm128_bswap32_80( edata, pdata );
-   
-   do
-   {
-      edata[19] = n;
-      x17_hash( hash64, edata );
-      if ( unlikely( valid_hash( hash64, ptarget ) && !bench ) )
-      {
-         pdata[19] = bswap_32( n );
-         submit_solution( work, hash64, mythr );
-      }
-      n++;
-   } while ( n < max_nonce && !work_restart[thr_id].restart );
-   *hashes_done = n - first_nonce;
-   pdata[19] = n;
-   return 0;
+    return 1;
 }
 
 #endif

algo/x17/xevan-4way.c

@@ -16,7 +16,7 @@
 #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/fugue/fugue-aesni.h"
 #include "algo/shabal/shabal-hash-4way.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/sha/sha-hash-4way.h"
@@ -40,7 +40,7 @@ union _xevan_8way_context_overlay
    cube_4way_context       cube;
    simd_4way_context       simd;
    hamsi512_8way_context   hamsi;
-   sph_fugue512_context    fugue;
+   hashState_fugue         fugue;
    shabal512_8way_context  shabal;
    sph_whirlpool_context   whirlpool;
    sha512_8way_context     sha512;
@@ -57,7 +57,7 @@ union _xevan_8way_context_overlay
 } __attribute__ ((aligned (64)));
 typedef union _xevan_8way_context_overlay xevan_8way_context_overlay;
 
-void xevan_8way_hash( void *output, const void *input )
+int xevan_8way_hash( void *output, const void *input, int thr_id )
 {
      uint64_t vhash[16<<3] __attribute__ ((aligned (128)));
      uint64_t vhashA[16<<3] __attribute__ ((aligned (64)));
@@ -192,14 +192,14 @@ void xevan_8way_hash( void *output, const void *input )
      dintrlv_8x64( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                    vhash, dataLen<<3 );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash4, hash4, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash5, hash5, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash6, hash6, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash7, hash7, dataLen );
+     fugue512_full( &ctx.fugue, hash0, hash0, dataLen );
+     fugue512_full( &ctx.fugue, hash1, hash1, dataLen );
+     fugue512_full( &ctx.fugue, hash2, hash2, dataLen );
+     fugue512_full( &ctx.fugue, hash3, hash3, dataLen );
+     fugue512_full( &ctx.fugue, hash4, hash4, dataLen );
+     fugue512_full( &ctx.fugue, hash5, hash5, dataLen );
+     fugue512_full( &ctx.fugue, hash6, hash6, dataLen );
+     fugue512_full( &ctx.fugue, hash7, hash7, dataLen );
 
      intrlv_8x32( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                   hash7, dataLen<<3 );
@@ -355,14 +355,14 @@ void xevan_8way_hash( void *output, const void *input )
      dintrlv_8x64( hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7,
                    vhash, dataLen<<3 );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash4, hash4, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash5, hash5, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash6, hash6, dataLen );
-     sph_fugue512_full( &ctx.fugue, hash7, hash7, dataLen );
+     fugue512_full( &ctx.fugue, hash0, hash0, dataLen );
+     fugue512_full( &ctx.fugue, hash1, hash1, dataLen );
+     fugue512_full( &ctx.fugue, hash2, hash2, dataLen );
+     fugue512_full( &ctx.fugue, hash3, hash3, dataLen );
+     fugue512_full( &ctx.fugue, hash4, hash4, dataLen );
+     fugue512_full( &ctx.fugue, hash5, hash5, dataLen );
+     fugue512_full( &ctx.fugue, hash6, hash6, dataLen );
+     fugue512_full( &ctx.fugue, hash7, hash7, dataLen );
 
      intrlv_8x32( vhash, hash0, hash1, hash2, hash3, hash4, hash5, hash6,
                   hash7, dataLen<<3 );
@@ -395,50 +395,8 @@ void xevan_8way_hash( void *output, const void *input )
      haval256_5_8way_init( &ctx.haval );
      haval256_5_8way_update( &ctx.haval, vhashA, dataLen );
      haval256_5_8way_close( &ctx.haval, output );
-}
 
-int scanhash_xevan_8way( struct work *work, uint32_t max_nonce,
-                       uint64_t *hashes_done, struct thr_info *mythr )
-{
-   uint32_t hash[8*8] __attribute__ ((aligned (128)));
-   uint32_t vdata[20*8] __attribute__ ((aligned (64)));
-   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
-   uint32_t *hashd7 = &(hash[7*8]);
-   uint32_t *pdata = work->data;
-   const uint32_t *ptarget = work->target;
-   const uint32_t first_nonce = pdata[19];
-   const uint32_t last_nonce = max_nonce - 8;
-   __m512i  *noncev = (__m512i*)vdata + 9;
-   uint32_t n = first_nonce;
-   const int thr_id = mythr->id;
-   const uint32_t targ32 = ptarget[7];
-   const bool bench = opt_benchmark;
-
-   mm512_bswap32_intrlv80_8x64( vdata, pdata );
-   *noncev = mm512_intrlv_blend_32(
-              _mm512_set_epi32( n+7, 0, n+6, 0, n+5, 0, n+4, 0,
-                                n+3, 0, n+2, 0, n+1, 0, n,   0 ), *noncev );
-   do
-   {
-      xevan_8way_hash( hash, vdata );
-
-      for ( int lane = 0; lane < 8; lane++ )
-      if ( unlikely( ( hashd7[ lane ] <= targ32 ) && !bench ) )
-      {
-         extr_lane_8x32( lane_hash, hash, lane, 256 );
-         if ( likely( valid_hash( lane_hash, ptarget ) ) )
-         {
-            pdata[19] = bswap_32( n + lane );
-            submit_solution( work, lane_hash, mythr );
-         }
-      }
-      *noncev = _mm512_add_epi32( *noncev,
-                                  m512_const1_64( 0x0000000800000000 ) );
-      n += 8;
-   } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
-   pdata[19] = n;
-   *hashes_done = n - first_nonce;
-   return 0;
+     return 1;
 }
 
 #elif defined(XEVAN_4WAY)
@@ -457,7 +415,7 @@ union _xevan_4way_context_overlay
         simd_2way_context       simd;
         hashState_echo          echo;
         hamsi512_4way_context   hamsi;
-        sph_fugue512_context    fugue;
+        hashState_fugue         fugue;
         shabal512_4way_context  shabal;
         sph_whirlpool_context   whirlpool;
         sha512_4way_context     sha512;
@@ -465,7 +423,7 @@ union _xevan_4way_context_overlay
 };
 typedef union _xevan_4way_context_overlay xevan_4way_context_overlay;
 
-void xevan_4way_hash( void *output, const void *input )
+int xevan_4way_hash( void *output, const void *input, int thr_id )
 {
      uint64_t hash0[16] __attribute__ ((aligned (64)));
      uint64_t hash1[16] __attribute__ ((aligned (64)));
@@ -540,10 +498,10 @@ void xevan_4way_hash( void *output, const void *input )
 
      dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, dataLen<<3 );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, dataLen );
+     fugue512_full( &ctx.fugue, hash1, hash1, dataLen );
+     fugue512_full( &ctx.fugue, hash2, hash2, dataLen );
+     fugue512_full( &ctx.fugue, hash3, hash3, dataLen );
 
      // Parallel 4way 32 bit
      intrlv_4x32( vhash, hash0, hash1, hash2, hash3, dataLen<<3 );
@@ -637,10 +595,10 @@ void xevan_4way_hash( void *output, const void *input )
 
      dintrlv_4x64( hash0, hash1, hash2, hash3, vhash, dataLen<<3 );
 
-     sph_fugue512_full( &ctx.fugue, hash0, hash0, 64 );
-     sph_fugue512_full( &ctx.fugue, hash1, hash1, 64 );
-     sph_fugue512_full( &ctx.fugue, hash2, hash2, 64 );
-     sph_fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+     fugue512_full( &ctx.fugue, hash0, hash0, dataLen );
+     fugue512_full( &ctx.fugue, hash1, hash1, dataLen );
+     fugue512_full( &ctx.fugue, hash2, hash2, dataLen );
+     fugue512_full( &ctx.fugue, hash3, hash3, dataLen );
 
      intrlv_4x32( vhash, hash0, hash1, hash2, hash3, dataLen<<3 );
 
@@ -666,49 +624,8 @@ void xevan_4way_hash( void *output, const void *input )
      haval256_5_4way_init( &ctx.haval );
      haval256_5_4way_update( &ctx.haval, vhashA, dataLen );
      haval256_5_4way_close( &ctx.haval, output );
-}
 
-int scanhash_xevan_4way( struct work *work, uint32_t max_nonce,
-                         uint64_t *hashes_done, struct thr_info *mythr )
-{
-   uint32_t hash[16*4] __attribute__ ((aligned (128)));
-   uint32_t vdata[20*4] __attribute__ ((aligned (64)));
-   uint32_t lane_hash[8] __attribute__ ((aligned (64)));
-   uint32_t *hashd7 = &(hash[7<<2]);
-   uint32_t *pdata = work->data;
-   uint32_t *ptarget = work->target;
-   int thr_id = mythr->id;
-   __m256i  *noncev = (__m256i*)vdata + 9; 
-   const uint32_t targ32 = ptarget[7];
-   const uint32_t first_nonce = pdata[19];
-   const uint32_t last_nonce = max_nonce - 4;
-   uint32_t n = first_nonce;
-   const bool bench = opt_benchmark;
-
-   if ( bench )  ptarget[7] = 0x0cff;
-
-   mm256_bswap32_intrlv80_4x64( vdata, pdata );
-   *noncev = mm256_intrlv_blend_32(
-                   _mm256_set_epi32( n+3, 0, n+2, 0, n+1, 0, n, 0 ), *noncev );
-   do {
-      xevan_4way_hash( hash, vdata );
-      for ( int lane = 0; lane < 4; lane++ )
-      if ( unlikely( hashd7[ lane ] <= targ32 ) && ! bench )
-      {
-         extr_lane_4x32( lane_hash, hash, lane, 256 );
-	      if ( valid_hash( lane_hash, ptarget ) )
-         {
-             pdata[19] = bswap_32( n + lane );
-             submit_solution( work, lane_hash, mythr );
-         }
-      }
-      *noncev = _mm256_add_epi32( *noncev,
-                                  m256_const1_64( 0x0000000400000000 ) );
-      n += 4;
-   } while ( likely( ( n < last_nonce ) && !work_restart[thr_id].restart ) );
-   pdata[19] = n;
-   *hashes_done = n - first_nonce;
-   return 0;
+     return 1;
 }
 
 #endif

algo/x17/xevan-gate.c

@@ -3,14 +3,13 @@
 bool register_xevan_algo( algo_gate_t* gate )
 {
 #if defined (XEVAN_8WAY)
-  gate->scanhash  = (void*)&scanhash_xevan_8way;
+  gate->scanhash  = (void*)&scanhash_8way_64in_32out;
   gate->hash      = (void*)&xevan_8way_hash;
 #elif defined (XEVAN_4WAY)
-  gate->scanhash  = (void*)&scanhash_xevan_4way;
+  gate->scanhash  = (void*)&scanhash_4way_64in_32out;
   gate->hash      = (void*)&xevan_4way_hash;
 #else
   init_xevan_ctx();
-  gate->scanhash  = (void*)&scanhash_xevan;
   gate->hash      = (void*)&xevan_hash;
 #endif
   gate->optimizations = SSE2_OPT | AES_OPT | AVX2_OPT | AVX512_OPT | VAES_OPT;

algo/x17/xevan-gate.h

@@ -14,26 +14,15 @@ bool register_xevan_algo( algo_gate_t* gate );
 
 #if defined(XEVAN_8WAY)
 
-void xevan_8way_hash( void *state, const void *input );
+int xevan_8way_hash( void *state, const void *input, int thr_id );
 
-int scanhash_xevan_8way( struct work *work, uint32_t max_nonce,
-                       uint64_t *hashes_done, struct thr_info *mythr );
 #elif defined(XEVAN_4WAY)
 
-void xevan_4way_hash( void *state, const void *input );
-
-int scanhash_xevan_4way( struct work *work, uint32_t max_nonce,
-                       uint64_t *hashes_done, struct thr_info *mythr );
-
-//void init_xevan_4way_ctx();
+int xevan_4way_hash( void *state, const void *input, int thr_id );
 
 #else
 
-void xevan_hash( void *state, const void *input );
-
-int scanhash_xevan( struct work *work, uint32_t max_nonce,
-                  uint64_t *hashes_done, struct thr_info *mythr );
-
+int xevan_hash( void *state, const void *input, int trh_id );
 void init_xevan_ctx();
 
 #endif

algo/x17/xevan.c

@@ -15,7 +15,6 @@
 #include "algo/shavite/sph_shavite.h"
 #include "algo/luffa/luffa_for_sse2.h"
 #include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/shabal/sph_shabal.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/haval/sph-haval.h"
@@ -25,9 +24,11 @@
 #if defined(__AES__)
   #include "algo/groestl/aes_ni/hash-groestl.h"
   #include "algo/echo/aes_ni/hash_api.h"
+  #include "algo/fugue/fugue-aesni.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 
 typedef struct {
@@ -41,7 +42,6 @@ typedef struct {
         sph_shavite512_context  shavite;
         hashState_sd            simd;
         sph_hamsi512_context    hamsi;
-        sph_fugue512_context    fugue;
         sph_shabal512_context   shabal;
         sph_whirlpool_context   whirlpool;
         SHA512_CTX              sha512;
@@ -49,9 +49,11 @@ typedef struct {
 #if defined(__AES__)
         hashState_echo          echo;
         hashState_groestl       groestl;
+        hashState_fugue         fugue;
 #else
 	sph_groestl512_context  groestl;
         sph_echo512_context     echo;
+        sph_fugue512_context    fugue;
 #endif
 } xevan_ctx_holder;
 
@@ -69,7 +71,6 @@ void init_xevan_ctx()
         sph_shavite512_init( &xevan_ctx.shavite );
         init_sd( &xevan_ctx.simd, 512 );
         sph_hamsi512_init( &xevan_ctx.hamsi );
-        sph_fugue512_init( &xevan_ctx.fugue );
         sph_shabal512_init( &xevan_ctx.shabal );
         sph_whirlpool_init( &xevan_ctx.whirlpool );
         SHA512_Init( &xevan_ctx.sha512 );
@@ -77,13 +78,15 @@ void init_xevan_ctx()
 #if defined(__AES__)
         init_groestl( &xevan_ctx.groestl, 64 );
         init_echo( &xevan_ctx.echo, 512 );
+        fugue512_Init( &xevan_ctx.fugue, 512 );
 #else
 	sph_groestl512_init( &xevan_ctx.groestl );
         sph_echo512_init( &xevan_ctx.echo );
+        sph_fugue512_init( &xevan_ctx.fugue );
 #endif
 };
 
-void xevan_hash(void *output, const void *input)
+int xevan_hash(void *output, const void *input, int thr_id )
 {
    uint32_t _ALIGN(64) hash[32]; // 128 bytes required
 	const int dataLen = 128;
@@ -137,8 +140,13 @@ void xevan_hash(void *output, const void *input)
 	sph_hamsi512(&ctx.hamsi, hash, dataLen);
 	sph_hamsi512_close(&ctx.hamsi, hash);
 
+#if defined(__AES__)
+    fugue512_Update( &ctx.fugue, hash, dataLen*8 );
+    fugue512_Final( &ctx.fugue, hash ); 
+#else
 	sph_fugue512(&ctx.fugue, hash, dataLen);
 	sph_fugue512_close(&ctx.fugue, hash);
+#endif
 
 	sph_shabal512(&ctx.shabal, hash, dataLen);
 	sph_shabal512_close(&ctx.shabal, hash);
@@ -202,8 +210,13 @@ void xevan_hash(void *output, const void *input)
 	sph_hamsi512(&ctx.hamsi, hash, dataLen);
 	sph_hamsi512_close(&ctx.hamsi, hash);
 
+#if defined(__AES__)
+    fugue512_Update( &ctx.fugue, hash, dataLen*8 );
+    fugue512_Final( &ctx.fugue, hash );   
+#else
 	sph_fugue512(&ctx.fugue, hash, dataLen);
 	sph_fugue512_close(&ctx.fugue, hash);
+#endif
 
 	sph_shabal512(&ctx.shabal, hash, dataLen);
 	sph_shabal512_close(&ctx.shabal, hash);
@@ -218,36 +231,8 @@ void xevan_hash(void *output, const void *input)
 	sph_haval256_5_close(&ctx.haval, hash);
 
 	memcpy(output, hash, 32);
-}
 
-int scanhash_xevan( struct work *work, uint32_t max_nonce,
-             uint64_t *hashes_done, struct thr_info *mythr)
-{
-   uint32_t edata[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];
-   const uint32_t first_nonce = pdata[19];
-   const int thr_id = mythr->id;
-   const bool bench = opt_benchmark;
-
-   mm128_bswap32_80( edata, pdata );
-
-   do
-   {
-      edata[19] = n;
-      xevan_hash( hash64, edata );
-      if ( unlikely( valid_hash( hash64, ptarget ) && !bench ) )
-      {
-         pdata[19] = bswap_32( n );
-         submit_solution( work, hash64, mythr );
-      }
-      n++;
-   } while ( n < max_nonce && !work_restart[thr_id].restart );
-   pdata[19] = n;
-   *hashes_done = n - first_nonce;
-   return 0;
+   return 1;
 }
 
 #endif

algo/x22/x22i-4way.c

@@ -13,7 +13,7 @@
 #include "algo/simd/simd-hash-2way.h"
 #include "algo/shavite/sph_shavite.h"
 #include "algo/hamsi/hamsi-hash-4way.h"
-#include "algo/fugue/sph_fugue.h"
+#include "algo/fugue/fugue-aesni.h"
 #include "algo/shabal/shabal-hash-4way.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/sha/sha-hash-4way.h"
@@ -42,7 +42,7 @@ union _x22i_8way_ctx_overlay
     cube_4way_context       cube;
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_8way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_8way_context     sha512;
@@ -225,30 +225,14 @@ int x22i_8way_hash( void *output, const void *input, int thrid )
    dintrlv_8x64_512( hash0, hash1, hash2, hash3,
                      hash4, hash5, hash6, hash7, vhash );
    
-   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 );
-   sph_fugue512_init( &ctx.fugue );
-   sph_fugue512( &ctx.fugue, hash4, 64 );
-   sph_fugue512_close( &ctx.fugue, hash4 );
-   sph_fugue512_init( &ctx.fugue );
-   sph_fugue512( &ctx.fugue, hash5, 64 );
-   sph_fugue512_close( &ctx.fugue, hash5 );
-   sph_fugue512_init( &ctx.fugue );
-   sph_fugue512( &ctx.fugue, hash6, 64 );
-   sph_fugue512_close( &ctx.fugue, hash6 );
-   sph_fugue512_init( &ctx.fugue );
-   sph_fugue512( &ctx.fugue, hash7, 64 );
-   sph_fugue512_close( &ctx.fugue, hash7 );
+   fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+   fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+   fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+   fugue512_full( &ctx.fugue, hash3, hash3, 64 );
+   fugue512_full( &ctx.fugue, hash4, hash4, 64 );
+   fugue512_full( &ctx.fugue, hash5, hash5, 64 );
+   fugue512_full( &ctx.fugue, hash6, hash6, 64 );
+   fugue512_full( &ctx.fugue, hash7, hash7, 64 );
 
    intrlv_8x32_512( vhash, hash0, hash1, hash2, hash3,
                            hash4, hash5, hash6, hash7 );
@@ -520,7 +504,7 @@ union _x22i_4way_ctx_overlay
     shavite512_2way_context shavite;
     simd_2way_context       simd;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_4way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_4way_context     sha512;
@@ -607,18 +591,10 @@ int x22i_4way_hash( void *output, const void *input, int thrid )
    hamsi512_4way_close( &ctx.hamsi, vhash );
    dintrlv_4x64_512( hash0, hash1, hash2, hash3, vhash );
 
-   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 );
+   fugue512_full( &ctx.fugue, hash0, hash0, 64 );
+   fugue512_full( &ctx.fugue, hash1, hash1, 64 );
+   fugue512_full( &ctx.fugue, hash2, hash2, 64 );
+   fugue512_full( &ctx.fugue, hash3, hash3, 64 );
 
    intrlv_4x32_512( vhash, hash0, hash1, hash2, hash3 );
 

algo/x22/x22i.c

@@ -7,9 +7,11 @@
 #if defined(__AES__)
   #include "algo/echo/aes_ni/hash_api.h"
   #include "algo/groestl/aes_ni/hash-groestl.h"
+  #include "algo/fugue/fugue-aesni.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 #include "algo/skein/sph_skein.h"
 #include "algo/jh/sph_jh.h"
@@ -19,7 +21,6 @@
 #include "algo/shavite/sph_shavite.h"
 #include "algo/simd/nist.h"
 #include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/shabal/sph_shabal.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include <openssl/sha.h>
@@ -36,9 +37,11 @@ union _x22i_context_overlay
 #if defined(__AES__)
         hashState_groestl       groestl;
         hashState_echo          echo;
+        hashState_fugue         fugue;
 #else
         sph_groestl512_context  groestl;
         sph_echo512_context     echo;
+        sph_fugue512_context    fugue;
 #endif
         sph_jh512_context       jh;
         sph_keccak512_context   keccak;
@@ -48,7 +51,6 @@ union _x22i_context_overlay
         sph_shavite512_context  shavite;
         hashState_sd            simd;
         sph_hamsi512_context    hamsi;
-        sph_fugue512_context    fugue;
         sph_shabal512_context   shabal;
         sph_whirlpool_context   whirlpool;
         SHA512_CTX              sha512;
@@ -129,9 +131,13 @@ int x22i_hash( void *output, const void *input, int thrid )
 	sph_hamsi512(&ctx.hamsi, (const void*) hash, 64);
 	sph_hamsi512_close(&ctx.hamsi, hash);
 
+#if defined(__AES__)
+        fugue512_full( &ctx.fugue, hash, hash, 64 );
+#else
 	sph_fugue512_init(&ctx.fugue);
 	sph_fugue512(&ctx.fugue, (const void*) hash, 64);
 	sph_fugue512_close(&ctx.fugue, hash);
+#endif
 
 	sph_shabal512_init(&ctx.shabal);
 	sph_shabal512(&ctx.shabal, (const void*) hash, 64);

algo/x22/x25x-4way.c

@@ -18,7 +18,7 @@
 #include "algo/shavite/sph_shavite.h"
 #include "algo/simd/nist.h"
 #include "algo/simd/simd-hash-2way.h"
-#include "algo/fugue/sph_fugue.h"
+#include "algo/fugue/fugue-aesni.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include "algo/tiger/sph_tiger.h"
 #include "algo/lyra2/lyra2.h"
@@ -72,7 +72,7 @@ union _x25x_8way_ctx_overlay
     cube_4way_context       cube;
     simd_4way_context       simd;
     hamsi512_8way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_8way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_8way_context     sha512;
@@ -303,30 +303,15 @@ int x25x_8way_hash( void *output, const void *input, int thrid )
    dintrlv_8x64_512( hash0[11], hash1[11], hash2[11], hash3[11],
                      hash4[11], hash5[11], hash6[11], hash7[11], vhash );
    
-	sph_fugue512_init(&ctx.fugue);
-	sph_fugue512(&ctx.fugue, (const void*) hash0[11], 64);
-	sph_fugue512_close(&ctx.fugue, hash0[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash1[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash1[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash2[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash2[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash3[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash3[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash4[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash4[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash5[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash5[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash6[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash6[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash7[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash7[12]);
+   fugue512_full( &ctx.fugue, hash0[12], hash0[11], 64 );
+   fugue512_full( &ctx.fugue, hash1[12], hash1[11], 64 );
+   fugue512_full( &ctx.fugue, hash2[12], hash2[11], 64 );
+   fugue512_full( &ctx.fugue, hash3[12], hash3[11], 64 );
+   fugue512_full( &ctx.fugue, hash4[12], hash4[11], 64 );
+   fugue512_full( &ctx.fugue, hash5[12], hash5[11], 64 );
+   fugue512_full( &ctx.fugue, hash6[12], hash6[11], 64 );
+   fugue512_full( &ctx.fugue, hash7[12], hash7[11], 64 );
+
    intrlv_8x32_512( vhash, hash0[12], hash1[12], hash2[12], hash3[12],
                            hash4[12], hash5[12], hash6[12], hash7[12] );
 
@@ -652,7 +637,7 @@ union _x25x_4way_ctx_overlay
     sph_shavite512_context  shavite;
     hashState_sd            simd;
     hamsi512_4way_context   hamsi;
-    sph_fugue512_context    fugue;
+    hashState_fugue         fugue;
     shabal512_4way_context  shabal;
     sph_whirlpool_context   whirlpool;
     sha512_4way_context     sha512;
@@ -758,18 +743,10 @@ int x25x_4way_hash( void *output, const void *input, int thrid )
    hamsi512_4way_close( &ctx.hamsi, vhash );
    dintrlv_4x64_512( hash0[11], hash1[11], hash2[11], hash3[11], vhash );
 
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash0[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash0[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash1[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash1[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash2[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash2[12]);
-   sph_fugue512_init(&ctx.fugue);
-   sph_fugue512(&ctx.fugue, (const void*) hash3[11], 64);
-   sph_fugue512_close(&ctx.fugue, hash3[12]);
+   fugue512_full( &ctx.fugue, hash0[12], hash0[11], 64 );
+   fugue512_full( &ctx.fugue, hash1[12], hash1[11], 64 );
+   fugue512_full( &ctx.fugue, hash2[12], hash2[11], 64 );
+   fugue512_full( &ctx.fugue, hash3[12], hash3[11], 64 );
 
    intrlv_4x32_512( vhash, hash0[12], hash1[12], hash2[12], hash3[12] );
 

algo/x22/x25x.c

@@ -7,9 +7,11 @@
 #if defined(__AES__)
   #include "algo/echo/aes_ni/hash_api.h"
   #include "algo/groestl/aes_ni/hash-groestl.h"
+  #include "algo/fugue/fugue-aesni.h"
 #else
   #include "algo/groestl/sph_groestl.h"
   #include "algo/echo/sph_echo.h"
+  #include "algo/fugue/sph_fugue.h"
 #endif
 #include "algo/skein/sph_skein.h"
 #include "algo/jh/sph_jh.h"
@@ -19,7 +21,6 @@
 #include "algo/shavite/sph_shavite.h"
 #include "algo/simd/nist.h"
 #include "algo/hamsi/sph_hamsi.h"
-#include "algo/fugue/sph_fugue.h"
 #include "algo/shabal/sph_shabal.h"
 #include "algo/whirlpool/sph_whirlpool.h"
 #include <openssl/sha.h>
@@ -39,9 +40,11 @@ union _x25x_context_overlay
 #if defined(__AES__)
         hashState_groestl       groestl;
         hashState_echo          echo;
+        hashState_fugue         fugue;
 #else
         sph_groestl512_context  groestl;
         sph_echo512_context     echo;
+        sph_fugue512_context    fugue;
 #endif
         sph_jh512_context       jh;
         sph_keccak512_context   keccak;
@@ -51,7 +54,6 @@ union _x25x_context_overlay
         sph_shavite512_context  shavite;
         hashState_sd            simd;
         sph_hamsi512_context    hamsi;
-        sph_fugue512_context    fugue;
         sph_shabal512_context   shabal;
         sph_whirlpool_context   whirlpool;
         SHA512_CTX              sha512;
@@ -133,9 +135,13 @@ int x25x_hash( void *output, const void *input, int thrid )
 	sph_hamsi512(&ctx.hamsi, (const void*) &hash[10], 64);
 	sph_hamsi512_close(&ctx.hamsi, &hash[11]);
 
+#if defined(__AES__)
+        fugue512_full( &ctx.fugue, &hash[12], &hash[11], 64 );
+#else
 	sph_fugue512_init(&ctx.fugue);
 	sph_fugue512(&ctx.fugue, (const void*) &hash[11], 64);
 	sph_fugue512_close(&ctx.fugue, &hash[12]);
+#endif
 
 	sph_shabal512_init(&ctx.shabal);
 	sph_shabal512(&ctx.shabal, (const void*) &hash[12], 64);

algo/yescrypt/yescrypt.c

@@ -445,7 +445,7 @@ bool register_yescrypt_algo( algo_gate_t* gate )
 
    YESCRYPT_P = 1;
 
-   applog( LOG_NOTICE,"Yescrypt parameters: N= %d, R= %d.", YESCRYPT_N,
+   applog( LOG_NOTICE,"Yescrypt parameters: N= %d, R= %d", YESCRYPT_N,
                                                             YESCRYPT_R );
    if ( yescrypt_client_key )
      applog( LOG_NOTICE,"Key= \"%s\"\n", yescrypt_client_key );

algo/yespower/yescrypt-r8g.c

@@ -19,12 +19,11 @@
  */
 
 #include "cpuminer-config.h"
+#include "miner.h"
 #include <stdio.h>
 #include <string.h>
 #include <stdint.h>
-#include <stdlib.h> 
-#include "algo-gate-api.h"
-#include "yespower.h"
+#include "yescrypt-r8g.h"
 
 int scanhash_yespower_r8g( struct work *work, uint32_t max_nonce,
                        uint64_t *hashes_done, struct thr_info *mythr )
@@ -38,17 +37,7 @@ int scanhash_yespower_r8g( struct work *work, uint32_t max_nonce,
     const uint32_t last_nonce = max_nonce;
     const int thr_id = mythr->id;
 
-   static __thread int initialized = 0;
-   static __thread yespower_local_t local;
-
-   if ( !initialized )
-   {
-      if ( yespower_init_local( &local ) )
-         return -1;
-      initialized = 1;
-   }
-
-   yespower_params_t params =
+    yespower_params_t params =
     {
 		.version = YESPOWER_0_5,
 		.N = 2048,
@@ -67,7 +56,7 @@ int scanhash_yespower_r8g( struct work *work, uint32_t max_nonce,
    SHA256_Update( &sha256_prehash_ctx, endiandata, 64 );
     
     do {
-       yespower_hash( &local, (unsigned char *)endiandata, params.perslen,
+       yespower_tls( (unsigned char *)endiandata, params.perslen,
                       &params, (yespower_binary_t*)hash, thr_id );
       
        if unlikely( valid_hash( hash, ptarget ) && !opt_benchmark )
@@ -87,6 +76,7 @@ bool register_yescryptr8g_algo( algo_gate_t* gate )
 {
   gate->optimizations = SSE2_OPT | SHA_OPT;
   gate->scanhash      = (void*)&scanhash_yespower_r8g;
+  gate->hash          = (void*)&yespower_tls;
   pk_buffer_size      = 26;
   opt_sapling         = true;
   opt_target_factor   = 65536.0;

algo/yespower/yescrypt-r8g.h

@@ -0,0 +1,49 @@
+/*-
+ * Copyright 2009 Colin Percival
+ * Copyright 2013-2018 Alexander Peslyak
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * This file was originally written by Colin Percival as part of the Tarsnap
+ * online backup system.
+ */
+#ifndef _YESPOWERR8G_H_
+#define _YESPOWERR8G_H_
+
+#include <stdint.h>
+#include <stdlib.h> /* for size_t */
+#include "algo-gate-api.h"
+#include "algo/yespower/yespower.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int yespowerr8g_tls(const uint8_t *src, size_t srclen,
+    const yespower_params_t *params, yespower_binary_t *dst);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !_YESPOWERR8G_H_ */

algo/yespower/yespower-blake2b.c

@@ -1112,10 +1112,10 @@ static void smix(uint8_t *B, size_t r, uint32_t N,
  *
  * Return 0 on success; or -1 on error.
  */
-int yespower_b2b_hash(yespower_local_t *local,
+int yespower_b2b(yespower_local_t *local,
     const uint8_t *src, size_t srclen,
     const yespower_params_t *params,
-    void *dst, int thrid )
+    yespower_binary_t *dst, int thrid )
 {
     uint32_t N = params->N;
     uint32_t r = params->r;
@@ -1191,4 +1191,37 @@ fail:
     return 0;
 }
 
+/**
+ * yespower_tls(src, srclen, params, dst):
+ * Compute yespower(src[0 .. srclen - 1], N, r), to be checked for "< target".
+ * The memory allocation is maintained internally using thread-local storage.
+ *
+ * Return 0 on success; or -1 on error.
+ */
+int yespower_b2b_tls(const uint8_t *src, size_t srclen,
+    const yespower_params_t *params, yespower_binary_t *dst, int thrid )
+{
+    static __thread int initialized = 0;
+    static __thread yespower_local_t local;
+
+    if (!initialized) {
+        init_region(&local);
+        initialized = 1;
+    }
+
+    return yespower_b2b(&local, src, srclen, params, dst, thrid);
+}
+/*
+int yespower_init_local(yespower_local_t *local)
+{
+    init_region(local);
+    return 0;
+}
+
+int yespower_free_local(yespower_local_t *local)
+{
+    return free_region(local);
+}
+*/
+
 #endif

algo/yespower/yespower-gate.c

@@ -23,17 +23,26 @@
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
+ * This file was originally written by Cryply team as part of the Cryply
+ * coin.
  */
 #include "yespower.h"
+
 #include "algo-gate-api.h"
 
 yespower_params_t yespower_params;
 
-// Give each thread its own copy to avoid requiring mutex.
+//SHA256_CTX sha256_prehash_ctx;
 __thread SHA256_CTX sha256_prehash_ctx;
 
 // YESPOWER
 
+int yespower_hash( const char *input, char *output, uint32_t len, int thrid )
+{
+   return yespower_tls( input, len, &yespower_params,
+           (yespower_binary_t*)output, thrid ); 
+}
+
 int scanhash_yespower( struct work *work, uint32_t max_nonce,
                        uint64_t *hashes_done, struct thr_info *mythr )
 {
@@ -46,16 +55,6 @@ int scanhash_yespower( struct work *work, uint32_t max_nonce,
    uint32_t n = first_nonce;
    const int thr_id = mythr->id;
 
-   static __thread int initialized = 0;
-   static __thread yespower_local_t local;
-
-   if ( !initialized )
-   {   
-      if ( yespower_init_local( &local ) )
-         return -1;
-      initialized = 1;
-   }
-   
    for ( int k = 0; k < 19; k++ )
       be32enc( &endiandata[k], pdata[k] );
    endiandata[19] = n;
@@ -65,8 +64,7 @@ int scanhash_yespower( struct work *work, uint32_t max_nonce,
    SHA256_Update( &sha256_prehash_ctx, endiandata, 64 );
 
    do {
-      if ( yespower_hash( &local, (char*)endiandata, 80, &yespower_params,
-                         (char*)vhash, thr_id ) )
+      if ( yespower_hash( (char*)endiandata, (char*)vhash, 80, thr_id ) )
       if unlikely( valid_hash( vhash, ptarget ) && !opt_benchmark )
       {
           be32enc( pdata+19, n );
@@ -81,6 +79,11 @@ int scanhash_yespower( struct work *work, uint32_t max_nonce,
 
 // YESPOWER-B2B
 
+int yespower_b2b_hash( const char *input, char *output, uint32_t len, int thrid )
+{
+  return yespower_b2b_tls( input, len, &yespower_params, (yespower_binary_t*)output, thrid );
+}
+
 int scanhash_yespower_b2b( struct work *work, uint32_t max_nonce,
                        uint64_t *hashes_done, struct thr_info *mythr )
 {
@@ -93,16 +96,6 @@ int scanhash_yespower_b2b( struct work *work, uint32_t max_nonce,
    const uint32_t last_nonce = max_nonce;
    const int thr_id = mythr->id;
 
-   static __thread int initialized = 0;
-   static __thread yespower_local_t local;
-
-   if ( !initialized )
-   {
-      if ( yespower_init_local( &local ) )
-         return -1;
-      initialized = 1;
-   }
-   
    for ( int k = 0; k < 19; k++ )
       be32enc( &endiandata[k], pdata[k] );
    endiandata[19] = n;
@@ -112,8 +105,7 @@ int scanhash_yespower_b2b( struct work *work, uint32_t max_nonce,
    SHA256_Update( &sha256_prehash_ctx, endiandata, 64 );
 
    do {
-      if (yespower_b2b_hash( &local, (char*) endiandata, 80, &yespower_params,
-                            (char*) vhash, thr_id ) )
+      if (yespower_b2b_hash( (char*) endiandata, (char*) vhash, 80, thr_id ) )
       if unlikely( valid_hash( vhash, ptarget ) && !opt_benchmark )
       {
           be32enc( pdata+19, n );
@@ -147,13 +139,14 @@ bool register_yespower_algo( algo_gate_t* gate )
      yespower_params.perslen = 0;
   }
 
-  applog( LOG_NOTICE,"Yespower parameters: N= %d, R= %d.", yespower_params.N,
+  applog( LOG_NOTICE,"Yespower parameters: N= %d, R= %d", yespower_params.N,
                                                            yespower_params.r );
   if ( yespower_params.pers )
      applog( LOG_NOTICE,"Key= \"%s\"\n", yespower_params.pers );
 
   gate->optimizations = SSE2_OPT | SHA_OPT;
   gate->scanhash      = (void*)&scanhash_yespower;
+  gate->hash          = (void*)&yespower_hash;
   opt_target_factor = 65536.0;
   return true;
 };
@@ -167,6 +160,7 @@ bool register_yespowerr16_algo( algo_gate_t* gate )
   yespower_params.perslen = 0;
   gate->optimizations = SSE2_OPT | SHA_OPT;
   gate->scanhash      = (void*)&scanhash_yespower;
+  gate->hash          = (void*)&yespower_hash;
   opt_target_factor = 65536.0;
   return true;
  };
@@ -270,13 +264,14 @@ bool register_power2b_algo( algo_gate_t* gate )
   yespower_params.pers = "Now I am become Death, the destroyer of worlds";
   yespower_params.perslen = 46;
 
-  applog( LOG_NOTICE,"yespower-b2b parameters: N= %d, R= %d.", yespower_params.N,
+  applog( LOG_NOTICE,"yespower-b2b parameters: N= %d, R= %d", yespower_params.N,
                                                            yespower_params.r );
   applog( LOG_NOTICE,"Key= \"%s\"", yespower_params.pers );
   applog( LOG_NOTICE,"Key length= %d\n", yespower_params.perslen );
 
   gate->optimizations = SSE2_OPT;
   gate->scanhash      = (void*)&scanhash_yespower_b2b;
+  gate->hash          = (void*)&yespower_b2b_hash;
   opt_target_factor = 65536.0;
   return true;
 };
@@ -316,6 +311,7 @@ bool register_yespower_b2b_algo( algo_gate_t* gate )
 
   gate->optimizations = SSE2_OPT;
   gate->scanhash      = (void*)&scanhash_yespower_b2b;
+  gate->hash          = (void*)&yespower_b2b_hash;
   opt_target_factor = 65536.0;
   return true;
 };

algo/yespower/yespower-opt.c

@@ -1024,10 +1024,10 @@ static void smix(uint8_t *B, size_t r, uint32_t N,
  *
  * Return 0 on success; or -1 on error.
  */
-int yespower_hash( yespower_local_t *local,
+int yespower(yespower_local_t *local,
     const uint8_t *src, size_t srclen,
     const yespower_params_t *params,
-    void *dst, int thrid )
+    yespower_binary_t *dst, int thrid )
 {
 	yespower_version_t version = params->version;
 	uint32_t N = params->N;
@@ -1158,6 +1158,27 @@ int yespower_hash( yespower_local_t *local,
 	return 1;
 }
 
+/**
+ * yespower_tls(src, srclen, params, dst):
+ * Compute yespower(src[0 .. srclen - 1], N, r), to be checked for "< target".
+ * The memory allocation is maintained internally using thread-local storage.
+ *
+ * Return 0 on success; or -1 on error.
+ */
+int yespower_tls(const uint8_t *src, size_t srclen,
+    const yespower_params_t *params, yespower_binary_t *dst, int thrid )
+{
+	static __thread int initialized = 0;
+	static __thread yespower_local_t local;
+
+	if (!initialized) {
+		if (yespower_init_local(&local))
+			return -1;
+		initialized = 1;
+	}
+
+	return yespower( &local, src, srclen, params, dst, thrid );
+}
 
 int yespower_init_local(yespower_local_t *local)
 {
@@ -1169,5 +1190,4 @@ int yespower_free_local(yespower_local_t *local)
 {
 	return free_region(local);
 }
-
 #endif

algo/yespower/yespower.h

@@ -78,19 +78,66 @@ typedef struct {
 
 extern yespower_params_t yespower_params;
 
+//SHA256_CTX sha256_prehash_ctx;
 extern __thread SHA256_CTX sha256_prehash_ctx;
 
+/**
+ * yespower_init_local(local):
+ * Initialize the thread-local (RAM) data structure.  Actual memory allocation
+ * is currently fully postponed until a call to yespower().
+ *
+ * Return 0 on success; or -1 on error.
+ *
+ * MT-safe as long as local is local to the thread.
+ */
 extern int yespower_init_local(yespower_local_t *local);
 
+/**
+ * yespower_free_local(local):
+ * Free memory that may have been allocated for an initialized thread-local
+ * (RAM) data structure.
+ *
+ * Return 0 on success; or -1 on error.
+ *
+ * MT-safe as long as local is local to the thread.
+ */
 extern int yespower_free_local(yespower_local_t *local);
 
-extern int yespower_hash(yespower_local_t *local,
+/**
+ * yespower(local, src, srclen, params, dst):
+ * Compute yespower(src[0 .. srclen - 1], N, r), to be checked for "< target".
+ * local is the thread-local data structure, allowing to preserve and reuse a
+ * memory allocation across calls, thereby reducing processing overhead.
+ *
+ * Return 0 on success; or -1 on error.
+ *
+ * local must be initialized with yespower_init_local().
+ *
+ * MT-safe as long as local and dst are local to the thread.
+ */
+extern int yespower(yespower_local_t *local,
     const uint8_t *src, size_t srclen,
-    const yespower_params_t *params, void *dst, int thrid);
+    const yespower_params_t *params, yespower_binary_t *dst, int thrid);
 
-extern int yespower_b2b_hash(yespower_local_t *local,
+extern int yespower_b2b(yespower_local_t *local,
     const uint8_t *src, size_t srclen,
-    const yespower_params_t *params, void *dst, int thrid );
+    const yespower_params_t *params, yespower_binary_t *dst, int thrid );
+
+/**
+ * yespower_tls(src, srclen, params, dst):
+ * Compute yespower(src[0 .. srclen - 1], N, r), to be checked for "< target".
+ * The memory allocation is maintained internally using thread-local storage.
+ *
+ * Return 0 on success; or -1 on error.
+ *
+ * MT-safe as long as dst is local to the thread.
+ */
+extern int yespower_tls(const uint8_t *src, size_t srclen,
+    const yespower_params_t *params, yespower_binary_t *dst, int thr_id);
+
+extern int yespower_b2b_tls(const uint8_t *src, size_t srclen,
+    const yespower_params_t *params, yespower_binary_t *dst, int thr_id);
+
 
 #if defined(__AVX2__)
 
@@ -103,6 +150,7 @@ extern int yespower_8way( yespower_local_t *local, const __m256i *src,
                           size_t srclen, const yespower_params_t *params,
                           yespower_8way_binary_t *dst, int thrid );
 
+
 extern int yespower_8way_tls( const __m256i *src, size_t srclen,
     const yespower_params_t *params, yespower_8way_binary_t *dst, int thr_id );
 

build-allarch.sh

@@ -4,13 +4,20 @@
 # during develpment. However the information contained may provide compilation
 # tips to users.
 
-rm cpuminer-avx512 cpuminer-avx2 cpuminer-aes-avx cpuminer-aes-sse42 cpuminer-sse42 cpuminer-ssse3 cpuminer-sse2 cpuminer-zen  > /dev/null
+rm cpuminer-avx512-sha-vaes cpuminer-avx512 cpuminer-avx2 cpuminer-aes-avx cpuminer-aes-sse42 cpuminer-sse42 cpuminer-ssse3 cpuminer-sse2 cpuminer-zen  > /dev/null
 
 make distclean || echo clean
 rm -f config.status
 ./autogen.sh || echo done
-CFLAGS="-O3 -march=skylake-avx512 -Wall" ./configure --with-curl
-make -j 16
+CFLAGS="-O3 -march=icelake-client -Wall -fno-common" ./configure --with-curl
+make -j 8
+strip -s cpuminer.exe
+mv cpuminer.exe cpuminer-avx512-sha-vaes.exe
+strip -s cpuminer
+mv cpuminer cpuminer-avx512-sha-vaes
+
+CFLAGS="-O3 -march=skylake-avx512 -Wall -fno-common" ./configure --with-curl
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe cpuminer-avx512.exe
 strip -s cpuminer
@@ -19,8 +26,8 @@ mv cpuminer cpuminer-avx512
 make clean || echo clean
 rm -f config.status
 # GCC 9 doesn't include AES with core-avx2
-CFLAGS="-O3 -march=core-avx2 -maes -Wall" ./configure --with-curl
-make -j 16
+CFLAGS="-O3 -march=core-avx2 -maes -Wall -fno-common" ./configure --with-curl
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe cpuminer-avx2.exe
 strip -s cpuminer
@@ -28,44 +35,44 @@ mv cpuminer cpuminer-avx2
 
 make clean || echo clean
 rm -f config.status
-CFLAGS="-O3 -march=corei7-avx -maes -Wall" ./configure --with-curl
-make -j 16
+CFLAGS="-O3 -march=corei7-avx -maes -Wall -fno-common" ./configure --with-curl
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe cpuminer-avx.exe
 strip -s cpuminer
-mv cpuminer cpuminer-aes-avx
+mv cpuminer cpuminer-avx
 
 make clean || echo clean
 rm -f config.status
-CFLAGS="-O3 -maes -msse4.2 -Wall" ./configure --with-curl
-make -j 16
+CFLAGS="-O3 -maes -msse4.2 -Wall -fno-common" ./configure --with-curl
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe cpuminer-aes-sse42.exe
 strip -s cpuminer
 mv cpuminer cpuminer-aes-sse42
 
-#make clean || echo clean
-#rm -f config.status
-#CFLAGS="-O3 -march=corei7 -Wall" ./configure --with-curl
-#make -j 16
-#strip -s cpuminer.exe
-#mv cpuminer.exe cpuminer-sse42.exe
-#strip -s cpuminer
-#mv cpuminer cpuminer-sse42
-
-#make clean || echo clean
-#rm -f config.status
-#CFLAGS="-O3 -march=core2 -Wall" ./configure --with-curl
-#make -j 16
-#strip -s cpuminer.exe
-#mv cpuminer.exe cpuminer-ssse3.exe
-#strip -s cpuminer
-#mv cpuminer cpuminer-ssse3
+make clean || echo clean
+rm -f config.status
+CFLAGS="-O3 -march=corei7 -Wall -fno-common" ./configure --with-curl
+make -j 8
+strip -s cpuminer.exe
+mv cpuminer.exe cpuminer-sse42.exe
+strip -s cpuminer
+mv cpuminer cpuminer-sse42
 
 make clean || echo clean
 rm -f config.status
-CFLAGS="-O3 -msse2 -Wall" ./configure --with-curl
-make -j 16
+CFLAGS="-O3 -march=core2 -Wall -fno-common" ./configure --with-curl
+make -j 8
+strip -s cpuminer.exe
+mv cpuminer.exe cpuminer-ssse3.exe
+strip -s cpuminer
+mv cpuminer cpuminer-ssse3
+
+make clean || echo clean
+rm -f config.status
+CFLAGS="-O3 -msse2 -Wall -fno-common" ./configure --with-curl
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe cpuminer-sse2.exe
 strip -s cpuminer
@@ -73,8 +80,8 @@ mv cpuminer cpuminer-sse2
 
 make clean || echo done
 rm -f config.status
-CFLAGS="-O3 -march=znver1 -Wall" ./configure --with-curl
-make -j 16
+CFLAGS="-O3 -march=znver1 -Wall -fno-common" ./configure --with-curl
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe cpuminer-zen.exe
 strip -s cpuminer
@@ -82,8 +89,8 @@ mv cpuminer cpuminer-zen
 
 make clean || echo done
 rm -f config.status
-CFLAGS="-O3 -march=native -Wall" ./configure --with-curl
-make -j 16
+CFLAGS="-O3 -march=native -Wall -fno-common" ./configure --with-curl
+make -j 8
 strip -s cpuminer.exe
 strip -s cpuminer
 

build-no-common.sh

@@ -0,0 +1,27 @@
+#!/bin/bash
+
+#if [ "$OS" = "Windows_NT" ]; then
+#    ./mingw64.sh
+#    exit 0
+#fi
+
+# Linux build
+
+make distclean || echo clean
+
+rm -f config.status
+./autogen.sh || echo done
+
+# Ubuntu 10.04 (gcc 4.4)
+# extracflags="-O3 -march=native -Wall -D_REENTRANT -funroll-loops -fvariable-expansion-in-unroller -fmerge-all-constants -fbranch-target-load-optimize2 -fsched2-use-superblocks -falign-loops=16 -falign-functions=16 -falign-jumps=16 -falign-labels=16"
+
+# Debian 7.7 / Ubuntu 14.04 (gcc 4.7+)
+#extracflags="$extracflags -Ofast -flto -fuse-linker-plugin -ftree-loop-if-convert-stores"
+
+#CFLAGS="-O3 -march=native -Wall" ./configure --with-curl --with-crypto=$HOME/usr
+CFLAGS="-O3 -march=native -Wall -fno-common" ./configure --with-curl
+#CFLAGS="-O3 -march=native -Wall" CXXFLAGS="$CFLAGS -std=gnu++11" ./configure --with-curl
+
+make -j 4
+
+strip -s cpuminer

clean-all.sh

@@ -3,8 +3,8 @@
 # imake clean and rm all the targetted executables.
 # tips to users.
 
-rm cpuminer-avx512 cpuminer-avx2 cpuminer-aes-avx cpuminer-aes-sse42 cpuminer-sse2 cpuminer-zen  > /dev/null
+rm cpuminer-avx512-sha-vaes cpuminer-avx512 cpuminer-avx2 cpuminer-avx cpuminer-aes-sse42 cpuminer-sse2 cpuminer-zen cpuminer-sse42 cpuminer-ssse3 > /dev/null
 
-rm cpuminer-avx512.exe cpuminer-avx2.exe cpuminer-aes-avx.exe cpuminer-aes-sse42.exe cpuminer-sse2.exe cpuminer-zen.exe  > /dev/null
+rm cpuminer-avx512-sha-vaes.exe cpuminer-avx512.exe cpuminer-avx2.exe cpuminer-avx.exe cpuminer-aes-sse42.exe cpuminer-sse2.exe cpuminer-zen.exe  cpuminer-sse42 cpuminer-ssse3 > /dev/null
 
 make distclean > /dev/null

configure

@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for cpuminer-opt 3.12.8.
+# Generated by GNU Autoconf 2.69 for cpuminer-opt 3.15.0.
 #
 #
 # Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
@@ -577,8 +577,8 @@ MAKEFLAGS=
 # Identity of this package.
 PACKAGE_NAME='cpuminer-opt'
 PACKAGE_TARNAME='cpuminer-opt'
-PACKAGE_VERSION='3.12.8'
-PACKAGE_STRING='cpuminer-opt 3.12.8'
+PACKAGE_VERSION='3.15.0'
+PACKAGE_STRING='cpuminer-opt 3.15.0'
 PACKAGE_BUGREPORT=''
 PACKAGE_URL=''
 
@@ -667,7 +667,6 @@ am__nodep
 AMDEPBACKSLASH
 AMDEP_FALSE
 AMDEP_TRUE
-am__quote
 am__include
 DEPDIR
 OBJEXT
@@ -757,7 +756,8 @@ PACKAGE_VERSION
 PACKAGE_TARNAME
 PACKAGE_NAME
 PATH_SEPARATOR
-SHELL'
+SHELL
+am__quote'
 ac_subst_files=''
 ac_user_opts='
 enable_option_checking
@@ -1332,7 +1332,7 @@ if test "$ac_init_help" = "long"; then
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures cpuminer-opt 3.12.8 to adapt to many kinds of systems.
+\`configure' configures cpuminer-opt 3.15.0 to adapt to many kinds of systems.
 
 Usage: $0 [OPTION]... [VAR=VALUE]...
 
@@ -1404,7 +1404,7 @@ fi
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of cpuminer-opt 3.12.8:";;
+     short | recursive ) echo "Configuration of cpuminer-opt 3.15.0:";;
    esac
   cat <<\_ACEOF
 
@@ -1509,7 +1509,7 @@ fi
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-cpuminer-opt configure 3.12.8
+cpuminer-opt configure 3.15.0
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -2012,7 +2012,7 @@ cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by cpuminer-opt $as_me 3.12.8, which was
+It was created by cpuminer-opt $as_me 3.15.0, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -2507,7 +2507,7 @@ ac_config_headers="$ac_config_headers cpuminer-config.h"
 
 
 
-am__api_version='1.15'
+am__api_version='1.16'
 
 # Find a good install program.  We prefer a C program (faster),
 # so one script is as good as another.  But avoid the broken or
@@ -2993,7 +2993,7 @@ fi
 
 # Define the identity of the package.
  PACKAGE='cpuminer-opt'
- VERSION='3.12.8'
+ VERSION='3.15.0'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -3023,8 +3023,8 @@ MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
 
 # For better backward compatibility.  To be removed once Automake 1.9.x
 # dies out for good.  For more background, see:
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
 mkdir_p='$(MKDIR_P)'
 
 # We need awk for the "check" target (and possibly the TAP driver).  The
@@ -3075,7 +3075,7 @@ END
 Aborting the configuration process, to ensure you take notice of the issue.
 
 You can download and install GNU coreutils to get an 'rm' implementation
-that behaves properly: <http://www.gnu.org/software/coreutils/>.
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
 
 If you want to complete the configuration process using your problematic
 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
@@ -3115,45 +3115,45 @@ DEPDIR="${am__leading_dot}deps"
 
 ac_config_commands="$ac_config_commands depfiles"
 
-
-am_make=${MAKE-make}
-cat > confinc << 'END'
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
+$as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
+cat > confinc.mk << 'END'
 am__doit:
-	@echo this is the am__doit target
+	@echo this is the am__doit target >confinc.out
 .PHONY: am__doit
 END
-# If we don't find an include directive, just comment out the code.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
-$as_echo_n "checking for style of include used by $am_make... " >&6; }
 am__include="#"
 am__quote=
-_am_result=none
-# First try GNU make style include.
-echo "include confinc" > confmf
-# Ignore all kinds of additional output from 'make'.
-case `$am_make -s -f confmf 2> /dev/null` in #(
-*the\ am__doit\ target*)
-  am__include=include
-  am__quote=
-  _am_result=GNU
-  ;;
-esac
-# Now try BSD make style include.
-if test "$am__include" = "#"; then
-   echo '.include "confinc"' > confmf
-   case `$am_make -s -f confmf 2> /dev/null` in #(
-   *the\ am__doit\ target*)
-     am__include=.include
-     am__quote="\""
-     _am_result=BSD
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
+   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+  case $?:`cat confinc.out 2>/dev/null` in #(
+  '0:this is the am__doit target') :
+    case $s in #(
+  BSD) :
+    am__include='.include' am__quote='"' ;; #(
+  *) :
+    am__include='include' am__quote='' ;;
+esac ;; #(
+  *) :
      ;;
-   esac
-fi
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
-$as_echo "$_am_result" >&6; }
-rm -f confinc confmf
+esac
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
+$as_echo "${_am_result}" >&6; }
 
 # Check whether --enable-dependency-tracking was given.
 if test "${enable_dependency_tracking+set}" = set; then :
@@ -6690,7 +6690,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by cpuminer-opt $as_me 3.12.8, which was
+This file was extended by cpuminer-opt $as_me 3.15.0, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -6756,7 +6756,7 @@ _ACEOF
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
 ac_cs_version="\\
-cpuminer-opt config.status 3.12.8
+cpuminer-opt config.status 3.15.0
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
@@ -6875,7 +6875,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 #
 # INIT-COMMANDS
 #
-AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
 
 _ACEOF
 
@@ -7489,29 +7489,35 @@ $as_echo "$as_me: executing $ac_file commands" >&6;}
   # Older Autoconf quotes --file arguments for eval, but not when files
   # are listed without --file.  Let's play safe and only enable the eval
   # if we detect the quoting.
-  case $CONFIG_FILES in
-  *\'*) eval set x "$CONFIG_FILES" ;;
-  *)   set x $CONFIG_FILES ;;
-  esac
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  case $CONFIG_FILES in #(
+  *\'*) :
+    eval set x "$CONFIG_FILES" ;; #(
+  *) :
+    set x $CONFIG_FILES ;; #(
+  *) :
+     ;;
+esac
   shift
-  for mf
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
   do
     # Strip MF so we end up with the name of the file.
-    mf=`echo "$mf" | sed -e 's/:.*$//'`
-    # Check whether this is an Automake generated Makefile or not.
-    # We used to match only the files named 'Makefile.in', but
-    # some people rename them; so instead we look at the file content.
-    # Grep'ing the first line is not enough: some people post-process
-    # each Makefile.in and add a new line on top of each file to say so.
-    # Grep'ing the whole file is not good either: AIX grep has a line
+    am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
     # limit of 2048, but all sed's we know have understand at least 4000.
-    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
-      dirpart=`$as_dirname -- "$mf" ||
-$as_expr X"$mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$mf" : 'X\(//\)[^/]' \| \
-	 X"$mf" : 'X\(//\)$' \| \
-	 X"$mf" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$mf" |
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`$as_dirname -- "$am_mf" ||
+$as_expr X"$am_mf" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+	 X"$am_mf" : 'X\(//\)[^/]' \| \
+	 X"$am_mf" : 'X\(//\)$' \| \
+	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X"$am_mf" |
     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
 	    s//\1/
 	    q
@@ -7529,53 +7535,48 @@ $as_echo X"$mf" |
 	    q
 	  }
 	  s/.*/./; q'`
-    else
-      continue
-    fi
-    # Extract the definition of DEPDIR, am__include, and am__quote
-    # from the Makefile without running 'make'.
-    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
-    test -z "$DEPDIR" && continue
-    am__include=`sed -n 's/^am__include = //p' < "$mf"`
-    test -z "$am__include" && continue
-    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
-    # Find all dependency output files, they are included files with
-    # $(DEPDIR) in their names.  We invoke sed twice because it is the
-    # simplest approach to changing $(DEPDIR) to its actual value in the
-    # expansion.
-    for file in `sed -n "
-      s/^$am__include $am__quote\(.*(DEPDIR).*\)$am__quote"'$/\1/p' <"$mf" | \
-	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
-      # Make sure the directory exists.
-      test -f "$dirpart/$file" && continue
-      fdir=`$as_dirname -- "$file" ||
-$as_expr X"$file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
-	 X"$file" : 'X\(//\)[^/]' \| \
-	 X"$file" : 'X\(//\)$' \| \
-	 X"$file" : 'X\(/\)' \| . 2>/dev/null ||
-$as_echo X"$file" |
-    sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+    am_filepart=`$as_basename -- "$am_mf" ||
+$as_expr X/"$am_mf" : '.*/\([^/][^/]*\)/*$' \| \
+	 X"$am_mf" : 'X\(//\)$' \| \
+	 X"$am_mf" : 'X\(/\)' \| . 2>/dev/null ||
+$as_echo X/"$am_mf" |
+    sed '/^.*\/\([^/][^/]*\)\/*$/{
 	    s//\1/
 	    q
 	  }
-	  /^X\(\/\/\)[^/].*/{
+	  /^X\/\(\/\/\)$/{
 	    s//\1/
 	    q
 	  }
-	  /^X\(\/\/\)$/{
-	    s//\1/
-	    q
-	  }
-	  /^X\(\/\).*/{
+	  /^X\/\(\/\).*/{
 	    s//\1/
 	    q
 	  }
 	  s/.*/./; q'`
-      as_dir=$dirpart/$fdir; as_fn_mkdir_p
-      # echo "creating $dirpart/$file"
-      echo '# dummy' > "$dirpart/$file"
-    done
+    { echo "$as_me:$LINENO: cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles" >&5
+   (cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } || am_rc=$?
   done
+  if test $am_rc -ne 0; then
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  Try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+  { am_dirpart=; unset am_dirpart;}
+  { am_filepart=; unset am_filepart;}
+  { am_mf=; unset am_mf;}
+  { am_rc=; unset am_rc;}
+  rm -f conftest-deps.mk
 }
  ;;
 

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([cpuminer-opt], [3.12.8])
+AC_INIT([cpuminer-opt], [3.15.0])
 
 AC_PREREQ([2.59c])
 AC_CANONICAL_SYSTEM

miner.h

@@ -83,6 +83,8 @@ enum {
 };
 #endif
 
+extern bool is_power_of_2( int n );
+
 static inline bool is_windows(void)
 {
 #ifdef WIN32
@@ -313,6 +315,10 @@ size_t address_to_script( unsigned char *out, size_t outsz, const char *addr );
 int    timeval_subtract( struct timeval *result, struct timeval *x,
                            struct timeval *y);
 
+// Segwit BEGIN
+extern void memrev(unsigned char *p, size_t len);
+// Segwit END
+
 // Bitcoin formula for converting difficulty to an equivalent
 // number of hashes.
 //
@@ -324,12 +330,12 @@ int    timeval_subtract( struct timeval *result, struct timeval *x,
 
 #define EXP16 65536.
 #define EXP32 4294967296.
-const long double exp32;  // 2**32
-const long double exp48;  // 2**48
-const long double exp64;  // 2**64
-const long double exp96;  // 2**96
-const long double exp128; // 2**128
-const long double exp160; // 2**160
+extern const long double exp32;  // 2**32
+extern const long double exp48;  // 2**48
+extern const long double exp64;  // 2**64
+extern const long double exp96;  // 2**96
+extern const long double exp128; // 2**128
+extern const long double exp160; // 2**160
 
 bool   fulltest( const uint32_t *hash, const uint32_t *target );
 bool   valid_hash( const void*, const void* );
@@ -374,36 +380,25 @@ void   cpu_brand_string( char* s );
 float cpu_temp( int core );
 */
 
-struct work {
+struct work
+{
+   uint32_t target[8] __attribute__ ((aligned (64)));
 	uint32_t data[48] __attribute__ ((aligned (64)));
-	uint32_t target[8] __attribute__ ((aligned (64)));
-
 	double targetdiff;
-//	double shareratio;
 	double sharediff;
    double stratum_diff;
-
 	int height;
 	char *txs;
 	char *workid;
-
 	char *job_id;
 	size_t xnonce2_len;
 	unsigned char *xnonce2;
    bool sapling;
    bool stale;
-
-   // x16rt
-   uint32_t merkleroothash[8];
-   uint32_t witmerkleroothash[8];
-   uint32_t denom10[8];
-   uint32_t denom100[8];
-   uint32_t denom1000[8];
-   uint32_t denom10000[8];
-
 } __attribute__ ((aligned (64)));
 
-struct stratum_job {
+struct stratum_job
+{
 	unsigned char prevhash[32];
    unsigned char final_sapling_hash[32];
    char *job_id;
@@ -417,7 +412,7 @@ struct stratum_job {
 	unsigned char ntime[4];
 	double diff;
    bool clean;
-   // for x16rt
+   // for x16rt-veil
    unsigned char extra[64];
    unsigned char denom10[32];
    unsigned char denom100[32];
@@ -551,15 +546,16 @@ enum algos {
         ALGO_LYRA2RE,       
         ALGO_LYRA2REV2,   
         ALGO_LYRA2REV3,
-	     ALGO_LYRA2Z,
+        ALGO_LYRA2Z,
         ALGO_LYRA2Z330,
-        ALGO_M7M,
+	ALGO_M7M,
+        ALGO_MINOTAUR,
         ALGO_MYR_GR,      
         ALGO_NEOSCRYPT,
         ALGO_NIST5,       
         ALGO_PENTABLAKE,  
         ALGO_PHI1612,
-	     ALGO_PHI2,
+        ALGO_PHI2,
         ALGO_POLYTIMOS,
         ALGO_POWER2B,
         ALGO_QUARK,
@@ -642,10 +638,11 @@ static const char* const algo_names[] = {
         "lyra2re",
         "lyra2rev2",
         "lyra2rev3",
-	     "lyra2z",
+        "lyra2z",
         "lyra2z330",
         "m7m",
-        "myr-gr",
+        "minotaur",
+	"myr-gr",
         "neoscrypt",
         "nist5",
         "pentablake",
@@ -750,6 +747,7 @@ extern double opt_diff_factor;
 extern double opt_target_factor;
 extern bool opt_randomize;
 extern bool allow_mininginfo;
+extern pthread_rwlock_t g_work_lock;
 extern time_t g_work_time;
 extern bool opt_stratum_stats;
 extern int num_cpus;
@@ -802,7 +800,8 @@ Options:\n\
                           lyra2z330     Lyra2 330 rows\n\
                           m7m           Magi (XMG)\n\
                           myr-gr        Myriad-Groestl\n\
-                          neoscrypt     NeoScrypt(128, 2, 1)\n\
+                          minotaur      Ringcoin (RNG)\n\
+			  neoscrypt     NeoScrypt(128, 2, 1)\n\
                           nist5         Nist5\n\
                           pentablake    5 x blake512\n\
                           phi1612       phi\n\

simd-utils/simd-512.h

@@ -375,10 +375,10 @@ static inline void memcpy_512( __m512i *dst, const __m512i *src, const int n )
 
 // Generic for odd rotations
 #define mm512_ror_x64( v, n )      _mm512_alignr_epi64( v, v, n )
-#define mm512_rol_x64( v, n )      _mm512_alignr_epi64( v, v, 8-n )
+#define mm512_rol_x64( v, n )      _mm512_alignr_epi64( v, v, 8-(n) )
 
 #define mm512_ror_x32( v, n )      _mm512_alignr_epi32( v, v, n )
-#define mm512_rol_x32( v, n )      _mm512_alignr_epi32( v, v, 16-n )
+#define mm512_rol_x32( v, n )      _mm512_alignr_epi32( v, v, 16-(n) )
 
 #define mm512_ror_1x16( v ) \
    _mm512_permutexvar_epi16( m512_const_64( \

sysinfos.c

@@ -1,4 +1,4 @@
-#if !defined(SYSINJFOS_C___)
+#if !defined(SYSINFOS_C__)
 #define SYSINFOS_C__
 
 /**

util.c

@@ -81,6 +81,15 @@ struct thread_q {
 	pthread_cond_t		cond;
 };
 
+bool is_power_of_2( int n ) 
+{ 
+  while ( n > 1 ) 
+  { 
+      if ( n % 2 != 0 ) return false; 
+      n = n / 2; 
+  } 
+  return true; 
+} 
 
 void applog2( int prio, const char *fmt, ... )
 {
@@ -609,6 +618,8 @@ json_t *json_rpc_call(CURL *curl, const char *url,
 		goto err_out;
 	}
 
+// want_stratum is useless, and so is this code it seems. Nothing in
+// hi appears to be set.   
 	/* If X-Stratum was found, activate Stratum */
 	if (want_stratum && hi.stratum_url &&
 	    !strncasecmp(hi.stratum_url, "stratum+tcp://", 14)) {
@@ -747,6 +758,19 @@ err_out:
 	return cfg;
 }
 
+// Segwit BEGIN
+void memrev(unsigned char *p, size_t len)
+{
+   unsigned char c, *q;
+   for (q = p + len - 1; p < q; p++, q--) {
+      c = *p;
+      *p = *q;
+      *q = c;
+   }
+}
+// Segwit END
+
+
 void cbin2hex(char *out, const char *in, size_t len)
 {
    if (out) {
@@ -1072,9 +1096,10 @@ bool fulltest( const uint32_t *hash, const uint32_t *target )
 // increases the effective precision. Due to the floating nature of the 
 // decimal point leading zeros aren't counted.
 //
-// Unfortunately I can't get float128 to work so long double it is.
+// Unfortunately I can't get float128 to work so long double (float80) is
+// as precise as it gets.
 // All calculations will be done using long double then converted to double.
-// This prevent introducing significant new error while taking advantage
+// This prevents introducing significant new error while taking advantage
 // of HW rounding.
 
 #if defined(GCC_INT128)
@@ -1083,7 +1108,8 @@ void diff_to_hash( uint32_t *target, const double diff )
 {
   uint128_t *targ = (uint128_t*)target;
   register long double m = 1. / diff;
-  targ[0] = 0;
+//  targ[0] = 0;
+  targ[0] = -1;
   targ[1] = (uint128_t)( m * exp96 );
 }
 
@@ -1111,7 +1137,8 @@ void diff_to_hash( uint32_t *target, const double diff )
 {
   uint64_t *targ = (uint64_t*)target;
   register long double m = ( 1. / diff ) * exp32;
-  targ[1] = targ[0] = 0;
+//  targ[1] = targ[0] = 0;
+  targ[1] = targ[0] = -1;
   targ[3] = (uint64_t)m;
   targ[2] = (uint64_t)( ( m - (long double)targ[3] ) * exp64 );
 }

winbuild-cross.sh

@@ -10,13 +10,10 @@
 # define some local variables
 
 export LOCAL_LIB="$HOME/usr/lib"
-
 export CONFIGURE_ARGS="--with-curl=$LOCAL_LIB/curl --with-crypto=$LOCAL_LIB/openssl --host=x86_64-w64-mingw32"
-
 export MINGW_LIB="/usr/x86_64-w64-mingw32/lib"
-
-export GCC_MINGW_LIB="/usr/lib/gcc/x86_64-w64-mingw32/7.3-win32"
-
+# set correct gcc version
+export GCC_MINGW_LIB="/usr/lib/gcc/x86_64-w64-mingw32/9.3-win32"
 # used by GCC
 export LDFLAGS="-L$LOCAL_LIB/curl/lib/.libs -L$LOCAL_LIB/gmp/.libs -L$LOCAL_LIB/openssl"
 
@@ -43,19 +40,27 @@ cp $LOCAL_LIB/curl/lib/.libs/libcurl-4.dll release/
 
 # Start building...
 
-make distclean || echo clean
+./clean-all.sh || echo clean
 rm -f config.status
 ./autogen.sh || echo done
+CFLAGS="-O3 -march=icelake-client -Wall" ./configure $CONFIGURE_ARGS
+make -j 8
+strip -s cpuminer.exe
+mv cpuminer.exe release/cpuminer-avx512-sha-vaes.exe
+
+make clean || echo clean
+rm -f config.status
 CFLAGS="-O3 -march=znver1 -Wall" ./configure $CONFIGURE_ARGS
-make -j 16
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe release/cpuminer-zen.exe
 
 # mingw won't compile avx512 without -fno-asynchronous-unwind-tables
 make clean || echo clean
 rm -f config.status
-CFLAGS="-O3 -march=skylake-avx512 -Wall -fno-asynchronous-unwind-tables" ./configure $CONFIGURE_ARGS
-make -j 16
+CFLAGS="-O3 -march=skylake-avx512 -Wall" ./configure $CONFIGURE_ARGS
+#CFLAGS="-O3 -march=skylake-avx512 -Wall -fno-asynchronous-unwind-tables" ./configure $CONFIGURE_ARGS
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe release/cpuminer-avx512.exe
 
@@ -63,7 +68,7 @@ make clean || echo clean
 rm -f config.status
 # GCC 9 doesn't include AES in -march=core-avx2
 CFLAGS="-O3 -march=core-avx2 -maes -Wall" ./configure $CONFIGURE_ARGS
-make -j 16
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe release/cpuminer-avx2.exe
 
@@ -71,7 +76,7 @@ make clean || echo clean
 rm -f config.status
 # -march=corei7-avx still includes aes, but just in case
 CFLAGS="-O3 -march=corei7-avx -maes -Wall" ./configure $CONFIGURE_ARGS 
-make -j 16
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe release/cpuminer-avx.exe
 
@@ -80,7 +85,7 @@ make clean || echo clean
 rm -f config.status
 CFLAGS="-O3 -march=westmere -Wall" ./configure $CONFIGURE_ARGS
 #CFLAGS="-O3 -maes -msse4.2 -Wall" ./configure $CONFIGURE_ARGS
-make -j 16
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe release/cpuminer-aes-sse42.exe
 
@@ -102,7 +107,7 @@ mv cpuminer.exe release/cpuminer-aes-sse42.exe
 make clean || echo clean
 rm -f config.status
 CFLAGS="-O3 -msse2 -Wall" ./configure $CONFIGURE_ARGS
-make -j 16
+make -j 8
 strip -s cpuminer.exe
 mv cpuminer.exe release/cpuminer-sse2.exe
 make clean || echo clean