0

Makefile.am

@@ -68,6 +68,11 @@ sgminer_SOURCES += algorithm/x14.c algorithm/x14.h
 sgminer_SOURCES += algorithm/fresh.c algorithm/fresh.h
 sgminer_SOURCES += algorithm/whirlcoin.c algorithm/whirlcoin.h
 sgminer_SOURCES += algorithm/neoscrypt.c algorithm/neoscrypt.h
+sgminer_SOURCES += algorithm/pluck.c algorithm/pluck.h
+sgminer_SOURCES += algorithm/credits.c algorithm/credits.h
+sgminer_SOURCES += algorithm/Lyra2RE_old.c algorithm/Lyra2RE_old.h algorithm/Lyra2_old.c algorithm/Lyra2_old.h algorithm/Sponge_old.c algorithm/Sponge_old.h
+sgminer_SOURCES += algorithm/Lyra2RE.c algorithm/Lyra2RE.h algorithm/Lyra2.c algorithm/Lyra2.h algorithm/Sponge.c algorithm/Sponge.h
+sgminer_SOURCES += algorithm/yescrypt.h algorithm/yescrypt.c algorithm/yescrypt_core.h algorithm/yescrypt-opt.c algorithm/yescryptcommon.c algorithm/sysendian.h 
 
 bin_SCRIPTS	= $(top_srcdir)/kernel/*.cl
 

algorithm.c

@@ -31,14 +31,20 @@
 #include "algorithm/fresh.h"
 #include "algorithm/whirlcoin.h"
 #include "algorithm/neoscrypt.h"
+#include "algorithm/Lyra2RE.h"     //lyra new version
+#include "algorithm/Lyra2RE_old.h" //lyra old version
+#include "algorithm/pluck.h"
+#include "algorithm/yescrypt.h"
+#include "algorithm/credits.h"
 
 #include "compat.h"
 
 #include <inttypes.h>
 #include <string.h>
-
+bool opt_lyra;
 const char *algorithm_type_str[] = {
   "Unknown",
+  "credits",
   "Scrypt",
   "NScrypt",
   "X11",
@@ -52,7 +58,12 @@ const char *algorithm_type_str[] = {
   "NIST",
   "Fresh",
   "Whirlcoin",
-  "Neoscrypt"
+  "Neoscrypt",
+  "Lyra2RE",
+  "Lyra2REv2"
+  "pluck",
+  "yescrypt",
+  "yescrypt-multi"
 };
 
 void sha256(const unsigned char *message, unsigned int len, unsigned char *digest)
@@ -178,6 +189,150 @@ static cl_int queue_neoscrypt_kernel(_clState *clState, dev_blk_ctx *blk, __mayb
   return status;
 }
 
+static cl_int queue_pluck_kernel(_clState *clState, dev_blk_ctx *blk, __maybe_unused cl_uint threads)
+{
+	cl_kernel *kernel = &clState->kernel;
+	unsigned int num = 0;
+	cl_uint le_target;
+	cl_int status = 0;
+
+
+//	le_target = (*(cl_uint *)(blk->work->device_target + 28));
+	le_target = (cl_uint)le32toh(((uint32_t *)blk->work->/*device_*/target)[7]);
+//	memcpy(clState->cldata, blk->work->data, 80);
+	flip80(clState->cldata, blk->work->data);
+//int i;
+//for (i = 0; i<20; i++) ((uint32_t*)clState->cldata)[i] = ((uint32_t*)blk->work->data)[i]; // don't flip
+	status = clEnqueueWriteBuffer(clState->commandQueue, clState->CLbuffer0, true, 0, 80, clState->cldata, 0, NULL, NULL);
+
+	CL_SET_ARG(clState->CLbuffer0);
+	CL_SET_ARG(clState->outputBuffer);
+	CL_SET_ARG(clState->padbuffer8);
+	CL_SET_ARG(le_target);
+
+	return status;
+}
+
+static cl_int queue_credits_kernel(_clState *clState, dev_blk_ctx *blk, __maybe_unused cl_uint threads)
+{
+	cl_kernel *kernel = &clState->kernel;
+	unsigned int num = 0;
+	cl_ulong le_target;
+	cl_int status = 0;
+
+
+		// le_target = (*(cl_uint *)(blk->work->device_target + 24));
+	le_target = (cl_ulong)le64toh(((uint64_t *)blk->work->/*device_*/target)[3]);
+	//	le_target = (cl_uint)((uint32_t *)blk->work->target)[6];
+
+
+	memcpy(clState->cldata, blk->work->data, 168);
+//	flip168(clState->cldata, blk->work->data);
+	status = clEnqueueWriteBuffer(clState->commandQueue, clState->CLbuffer0, true, 0, 168, clState->cldata, 0, NULL, NULL);
+
+	CL_SET_ARG(clState->CLbuffer0);
+	CL_SET_ARG(clState->outputBuffer);
+	CL_SET_ARG(le_target);
+	CL_SET_ARG(blk->work->midstate);
+
+	return status;
+}
+
+
+static cl_int queue_yescrypt_kernel(_clState *clState, dev_blk_ctx *blk, __maybe_unused cl_uint threads)
+{
+	cl_kernel *kernel = &clState->kernel;
+	unsigned int num = 0;
+	cl_uint le_target;
+	cl_int status = 0;
+
+
+//	le_target = (*(cl_uint *)(blk->work->device_target + 28));
+	le_target = (cl_uint)le32toh(((uint32_t *)blk->work->/*device_*/target)[7]);
+//	le_target = (cl_uint)((uint32_t *)blk->work->target)[7];
+
+
+//	memcpy(clState->cldata, blk->work->data, 80);
+	flip80(clState->cldata, blk->work->data);
+	status = clEnqueueWriteBuffer(clState->commandQueue, clState->CLbuffer0, true, 0, 80, clState->cldata, 0, NULL, NULL);
+
+	CL_SET_ARG(clState->CLbuffer0);
+	CL_SET_ARG(clState->outputBuffer);
+	CL_SET_ARG(clState->padbuffer8);
+	CL_SET_ARG(clState->buffer1);
+	CL_SET_ARG(clState->buffer2);
+	CL_SET_ARG(le_target);
+
+	return status;
+}
+
+static cl_int queue_yescrypt_multikernel(_clState *clState, dev_blk_ctx *blk, __maybe_unused cl_uint threads)
+{
+//	cl_kernel *kernel = &clState->kernel;
+	cl_kernel *kernel;
+	unsigned int num = 0;
+	cl_uint le_target;
+	cl_int status = 0;
+
+
+	//	le_target = (*(cl_uint *)(blk->work->device_target + 28));
+	le_target = (cl_uint)le32toh(((uint32_t *)blk->work->/*device_*/target)[7]);
+	memcpy(clState->cldata, blk->work->data, 80);
+//	flip80(clState->cldata, blk->work->data);
+	status = clEnqueueWriteBuffer(clState->commandQueue, clState->CLbuffer0, true, 0, 80, clState->cldata, 0, NULL, NULL);
+//pbkdf and initial sha
+	kernel = &clState->kernel;
+
+	CL_SET_ARG(clState->CLbuffer0);
+	CL_SET_ARG(clState->outputBuffer);
+	CL_SET_ARG(clState->padbuffer8);
+	CL_SET_ARG(clState->buffer1);
+	CL_SET_ARG(clState->buffer2);
+	CL_SET_ARG(clState->buffer3);
+	CL_SET_ARG(le_target);
+
+//inactive kernel
+	num = 0;
+	kernel = clState->extra_kernels;
+	CL_SET_ARG_N(0,clState->buffer1);
+	CL_SET_ARG_N(1,clState->buffer2);
+//	CL_SET_ARG_N(3, clState->buffer3);
+
+//mix2_2
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG_N(0, clState->padbuffer8);
+	CL_SET_ARG_N(1,clState->buffer1);
+	CL_SET_ARG_N(2,clState->buffer2);
+	//mix2_2
+//inactive kernel
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG_N(0, clState->buffer1);
+	CL_SET_ARG_N(1, clState->buffer2);
+	//mix2_2
+
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG_N(0, clState->padbuffer8);
+	CL_SET_ARG_N(1, clState->buffer1);
+	CL_SET_ARG_N(2, clState->buffer2);
+
+	//inactive kernel
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG_N(0, clState->buffer1);
+	CL_SET_ARG_N(1, clState->buffer2);
+	//mix2_2
+
+
+//pbkdf and finalization
+    num=0;
+	CL_NEXTKERNEL_SET_ARG(clState->CLbuffer0);
+	CL_SET_ARG(clState->outputBuffer);
+	CL_SET_ARG(clState->buffer2);
+	CL_SET_ARG(clState->buffer3);
+    CL_SET_ARG(le_target);
+
+	return status;
+}
+
 static cl_int queue_maxcoin_kernel(struct __clState *clState, struct _dev_blk_ctx *blk, __maybe_unused cl_uint threads)
 {
   cl_kernel *kernel = &clState->kernel;
@@ -211,6 +366,108 @@ static cl_int queue_sph_kernel(struct __clState *clState, struct _dev_blk_ctx *b
   return status;
 }
 
+static cl_int queue_lyra2RE_kernel(struct __clState *clState, struct _dev_blk_ctx *blk, __maybe_unused cl_uint threads)
+{
+	cl_kernel *kernel;
+	unsigned int num;
+	cl_int status = 0;
+	cl_ulong le_target;
+
+//	le_target = *(cl_uint *)(blk->work->device_target + 28);
+	le_target = *(cl_ulong *)(blk->work->device_target + 24);
+	flip80(clState->cldata, blk->work->data);
+	status = clEnqueueWriteBuffer(clState->commandQueue, clState->CLbuffer0, true, 0, 80, clState->cldata, 0, NULL, NULL);
+
+	// blake - search
+	kernel = &clState->kernel;
+	num = 0;
+//	CL_SET_ARG(clState->CLbuffer0);
+	CL_SET_ARG(clState->padbuffer8);
+	CL_SET_ARG(blk->work->blk.ctx_a);
+	CL_SET_ARG(blk->work->blk.ctx_b);
+	CL_SET_ARG(blk->work->blk.ctx_c);
+	CL_SET_ARG(blk->work->blk.ctx_d);
+	CL_SET_ARG(blk->work->blk.ctx_e);
+	CL_SET_ARG(blk->work->blk.ctx_f);
+	CL_SET_ARG(blk->work->blk.ctx_g);
+	CL_SET_ARG(blk->work->blk.ctx_h);
+	CL_SET_ARG(blk->work->blk.cty_a);
+	CL_SET_ARG(blk->work->blk.cty_b);
+	CL_SET_ARG(blk->work->blk.cty_c);
+
+	// bmw - search1
+	kernel = clState->extra_kernels;
+	CL_SET_ARG_0(clState->padbuffer8);
+	// groestl - search2
+	CL_NEXTKERNEL_SET_ARG_0(clState->padbuffer8);
+	// skein - search3
+	CL_NEXTKERNEL_SET_ARG_0(clState->padbuffer8);
+	// jh - search4
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG(clState->padbuffer8);
+	CL_SET_ARG(clState->outputBuffer);
+	CL_SET_ARG(le_target);
+
+	return status;
+}
+
+static cl_int queue_lyra2REv2_kernel(struct __clState *clState, struct _dev_blk_ctx *blk, __maybe_unused cl_uint threads)
+{
+	cl_kernel *kernel;
+	unsigned int num;
+	cl_int status = 0;
+	cl_ulong le_target;
+
+	//	le_target = *(cl_uint *)(blk->work->device_target + 28);
+	le_target = *(cl_ulong *)(blk->work->device_target + 24);
+	flip80(clState->cldata, blk->work->data);
+	status = clEnqueueWriteBuffer(clState->commandQueue, clState->CLbuffer0, true, 0, 80, clState->cldata, 0, NULL, NULL);
+
+	// blake - search
+	kernel = &clState->kernel;
+	num = 0;
+	//	CL_SET_ARG(clState->CLbuffer0);
+	CL_SET_ARG(clState->buffer1);
+	CL_SET_ARG(blk->work->blk.ctx_a);
+	CL_SET_ARG(blk->work->blk.ctx_b);
+	CL_SET_ARG(blk->work->blk.ctx_c);
+	CL_SET_ARG(blk->work->blk.ctx_d);
+	CL_SET_ARG(blk->work->blk.ctx_e);
+	CL_SET_ARG(blk->work->blk.ctx_f);
+	CL_SET_ARG(blk->work->blk.ctx_g);
+	CL_SET_ARG(blk->work->blk.ctx_h);
+	CL_SET_ARG(blk->work->blk.cty_a);
+	CL_SET_ARG(blk->work->blk.cty_b);
+	CL_SET_ARG(blk->work->blk.cty_c);
+
+	// keccak - search1
+	kernel = clState->extra_kernels;
+	CL_SET_ARG_0(clState->buffer1);
+	// cubehash - search2 
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG_0(clState->buffer1);
+	// lyra - search3
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG_N(0, clState->buffer1);
+	CL_SET_ARG_N(1, clState->padbuffer8);
+	// skein -search4 
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG_0(clState->buffer1);
+	// cubehash - search5
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG_0(clState->buffer1);
+	// bmw - search6
+	num = 0;
+	CL_NEXTKERNEL_SET_ARG(clState->buffer1);
+	CL_SET_ARG(clState->outputBuffer);
+	CL_SET_ARG(le_target);
+
+	return status;
+}
+
+
+
+
 static cl_int queue_darkcoin_mod_kernel(struct __clState *clState, struct _dev_blk_ctx *blk, __maybe_unused cl_uint threads)
 {
   cl_kernel *kernel;
@@ -669,6 +926,29 @@ static algorithm_settings_t algos[] = {
   A_NEOSCRYPT("neoscrypt"),
 #undef A_NEOSCRYPT
 
+#define A_PLUCK(a) \
+            { a, ALGO_PLUCK, "", 1, 65536, 65536, 0, 0, 0xFF, 0xFFFF000000000000ULL, 0x0000ffffUL, 0, -1, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, pluck_regenhash, queue_pluck_kernel, gen_hash, append_neoscrypt_compiler_options}
+  A_PLUCK("pluck"),
+#undef A_PLUCK
+
+#define A_CREDITS(a) \
+                { a, ALGO_CRE, "", 1, 1, 1, 0, 0, 0xFF, 0xFFFF000000000000ULL, 0x0000ffffUL, 0, -1, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, credits_regenhash, queue_credits_kernel, gen_hash, NULL}
+  A_CREDITS("credits"),
+#undef A_CREDITS
+
+
+
+#define A_YESCRYPT(a) \
+              { a, ALGO_YESCRYPT, "", 1, 65536, 65536, 0, 0, 0xFF, 0xFFFF000000000000ULL, 0x0000ffffUL, 0, -1, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, yescrypt_regenhash, queue_yescrypt_kernel, gen_hash, append_neoscrypt_compiler_options}
+  A_YESCRYPT("yescrypt"),
+#undef A_YESCRYPT
+
+#define A_YESCRYPT_MULTI(a) \
+                  { a, ALGO_YESCRYPT_MULTI, "", 1, 65536, 65536, 0, 0, 0xFF, 0xFFFF000000000000ULL, 0x0000ffffUL, 6,-1,CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE , yescrypt_regenhash, queue_yescrypt_multikernel, gen_hash, append_neoscrypt_compiler_options}
+  A_YESCRYPT_MULTI("yescrypt-multi"),
+#undef A_YESCRYPT_MULTI
+
+
   // kernels starting from this will have difficulty calculated by using quarkcoin algorithm
 #define A_QUARK(a, b) \
     { a, ALGO_QUARK, "", 256, 256, 256, 0, 0, 0xFF, 0xFFFFFFULL, 0x0000ffffUL, 0, 0, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, b, queue_sph_kernel, gen_hash, append_x11_compiler_options}
@@ -705,6 +985,11 @@ static algorithm_settings_t algos[] = {
 
   { "fresh", ALGO_FRESH, "", 1, 256, 256, 0, 0, 0xFF, 0xFFFFULL, 0x0000ffffUL, 4, 4 * 16 * 4194304, 0, fresh_regenhash, queue_fresh_kernel, gen_hash, NULL},
 
+  { "Lyra2RE", ALGO_LYRA2RE, "", 1, 128, 128, 0, 0, 0xFF, 0xFFFFULL, 0x0000ffffUL, 4,2 * 8 * 4194304 , 0, lyra2reold_regenhash, queue_lyra2RE_kernel, gen_hash, NULL},
+
+  { "Lyra2REv2", ALGO_LYRA2REv2, "", 1, 256, 256, 0, 0, 0xFF, 0xFFFFULL, 0x0000ffffUL, 6, -1, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, lyra2re_regenhash, queue_lyra2REv2_kernel, gen_hash, append_neoscrypt_compiler_options },
+
+
   // kernels starting from this will have difficulty calculated by using fuguecoin algorithm
 #define A_FUGUE(a, b, c) \
     { a, ALGO_FUGUE, "", 1, 256, 256, 0, 0, 0xFF, 0xFFFFULL, 0x0000ffffUL, 0, 0, CL_QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE, b, queue_sph_kernel, c, NULL}
@@ -786,6 +1071,15 @@ static const char *lookup_algorithm_alias(const char *lookup_alias, uint8_t *nfa
   ALGO_ALIAS("nist5", "talkcoin-mod");
   ALGO_ALIAS("keccak", "maxcoin");
   ALGO_ALIAS("whirlpool", "whirlcoin");
+  ALGO_ALIAS("Lyra2REv2", "Lyra2REv2");
+  ALGO_ALIAS("lyra2rev2", "Lyra2REv2");
+  ALGO_ALIAS("lyra2v2", "Lyra2REv2");
+  ALGO_ALIAS("Lyra2RE", "Lyra2RE");
+  ALGO_ALIAS("lyra2re", "Lyra2RE");
+  ALGO_ALIAS("lyra2", "Lyra2RE");
+
+
+
 
   #undef ALGO_ALIAS
   #undef ALGO_ALIAS_NF
@@ -811,7 +1105,7 @@ void set_algorithm(algorithm_t* algo, const char* newname_alias)
   // use old nfactor if it was previously set and is different than the one set by alias
   if ((old_nfactor > 0) && (old_nfactor != nfactor))
     nfactor = old_nfactor;
-
+  if (algo->type == ALGO_LYRA2RE || algo->type == ALGO_LYRA2REv2 ) { opt_lyra = true; }
   set_algorithm_nfactor(algo, nfactor);
 
   //reapply kernelfile if was set

algorithm.h

@@ -12,6 +12,7 @@
 
 typedef enum {
   ALGO_UNK,
+  ALGO_CRE,
   ALGO_SCRYPT,
   ALGO_NSCRYPT,
   ALGO_X11,
@@ -25,7 +26,12 @@ typedef enum {
   ALGO_NIST,
   ALGO_FRESH,
   ALGO_WHIRL,
-  ALGO_NEOSCRYPT
+  ALGO_NEOSCRYPT,
+  ALGO_LYRA2RE,
+  ALGO_LYRA2REv2,
+  ALGO_PLUCK,
+  ALGO_YESCRYPT,
+  ALGO_YESCRYPT_MULTI,
 } algorithm_type_t;
 
 extern const char *algorithm_type_str[];