Add S3 Algo (1Coin)

Simple addition of the algo using existing X11 code

Makefile.am

@@ -46,7 +46,8 @@ ccminer_SOURCES		= elist.h miner.h compat.h \
 			  x13/x13.cu x13/cuda_x13_hamsi512.cu x13/cuda_x13_fugue512.cu \
 			  x15/x14.cu x15/x15.cu x15/cuda_x14_shabal512.cu x15/cuda_x15_whirlpool.cu \
 			  x15/whirlpool.cu \
-			  x17/x17.cu x17/cuda_x17_haval512.cu x17/cuda_x17_sha512.cu
+			  x17/x17.cu x17/cuda_x17_haval512.cu x17/cuda_x17_sha512.cu \
+			  x11/s3.cu
 
 
 ccminer_LDFLAGS		= $(PTHREAD_FLAGS) @CUDA_LDFLAGS@

ccminer.vcxproj

@@ -509,6 +509,7 @@
       <AdditionalOptions Condition="'$(Configuration)'=='Debug'">%(AdditionalOptions)</AdditionalOptions>
       <TargetMachinePlatform Condition="'$(Platform)'=='x64'">64</TargetMachinePlatform>
     </CudaCompile>
+    <CudaCompile Include="x11\s3.cu" />
     <CudaCompile Include="x11\simd_functions.cu">
       <ExcludedFromBuild>true</ExcludedFromBuild>
     </CudaCompile>

ccminer.vcxproj.filters

@@ -469,5 +469,8 @@
     <CudaCompile Include="keccak\keccak256.cu">
       <Filter>Source Files\CUDA\keccak</Filter>
     </CudaCompile>
+    <CudaCompile Include="x11\s3.cu">
+      <Filter>Source Files\CUDA\x11</Filter>
+    </CudaCompile>
   </ItemGroup>
 </Project>

cpu-miner.c

@@ -148,6 +148,7 @@ typedef enum {
 	ALGO_PENTABLAKE,
 	ALGO_QUARK,
 	ALGO_QUBIT,
+	ALGO_S3,
 	ALGO_WHC,
 	ALGO_X11,
 	ALGO_X13,
@@ -176,6 +177,7 @@ static const char *algo_names[] = {
 	"penta",
 	"quark",
 	"qubit",
+	"s3",
 	"whirl",
 	"x11",
 	"x13",
@@ -265,6 +267,7 @@ Options:\n\
 			penta       Pentablake hash (5x Blake 512)\n\
 			quark       Quark\n\
 			qubit       Qubit\n\
+			s3          S3 (1Coin)\n\
 			x11         X11 (DarkCoin)\n\
 			x13         X13 (MaruCoin)\n\
 			x14         X14\n\
@@ -1235,6 +1238,11 @@ continue_scan:
 			                      max_nonce, &hashes_done);
 			break;
 
+		case ALGO_S3:
+			rc = scanhash_s3(thr_id, work.data, work.target,
+			                      max_nonce, &hashes_done);
+			break;
+
 		case ALGO_WHC:
 			rc = scanhash_whc(thr_id, work.data, work.target,
 			                      max_nonce, &hashes_done);

miner.h

@@ -295,6 +295,10 @@ extern int scanhash_scrypt(int thr_id, uint32_t *pdata,
 	unsigned char *scratchbuf, const uint32_t *ptarget,
 	uint32_t max_nonce, unsigned long *hashes_done);
 
+extern int scanhash_s3(int thr_id, uint32_t *pdata,
+	const uint32_t *ptarget, uint32_t max_nonce,
+	unsigned long *hashes_done);
+
 extern int scanhash_whc(int thr_id, uint32_t *pdata,
 	const uint32_t *ptarget, uint32_t max_nonce,
 	unsigned long *hashes_done);
@@ -483,6 +487,7 @@ void nist5hash(void *state, const void *input);
 void pentablakehash(void *output, const void *input);
 void quarkhash(void *state, const void *input);
 void qubithash(void *state, const void *input);
+void s3hash(void *output, const void *input);
 void wcoinhash(void *state, const void *input);
 void x11hash(void *output, const void *input);
 void x13hash(void *output, const void *input);

util.c

@@ -1534,6 +1534,10 @@ void print_hash_tests(void)
 	qubithash(&hash[0], &buf[0]);
 	printpfx("qubit", hash);
 
+	memset(hash, 0, sizeof hash);
+	s3hash(&hash[0], &buf[0]);
+	printpfx("S3", hash);
+
 	memset(hash, 0, sizeof hash);
 	wcoinhash(&hash[0], &buf[0]);
 	printpfx("whirl", hash);

x11/s3.cu

@@ -0,0 +1,123 @@
+/**
+ * S3 Hash (Also called 3S - Used by 1Coin)
+ */
+
+extern "C" {
+#include "sph/sph_skein.h"
+#include "sph/sph_shavite.h"
+#include "sph/sph_simd.h"
+}
+
+#include "miner.h"
+#include "cuda_helper.h"
+
+#include <stdint.h>
+
+extern int device_map[8];
+
+static uint32_t *d_hash[8];
+
+extern void x11_shavite512_cpu_init(int thr_id, int threads);
+extern void x11_shavite512_cpu_hash_80(int thr_id, int threads, uint32_t startNounce, uint32_t *d_hash, int order);
+extern void x11_shavite512_setBlock_80(void *pdata);
+
+extern void x11_simd512_cpu_init(int thr_id, int threads);
+extern void x11_simd512_cpu_hash_64(int thr_id, int threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
+
+extern void quark_skein512_cpu_init(int thr_id, int threads);
+extern void quark_skein512_cpu_hash_64(int thr_id, int threads, uint32_t startNounce, uint32_t *d_nonceVector, uint32_t *d_hash, int order);
+
+/* CPU HASH */
+extern "C" void s3hash(void *output, const void *input)
+{
+	sph_shavite512_context ctx_shavite;
+	sph_simd512_context ctx_simd;
+	sph_skein512_context ctx_skein;
+
+	unsigned char hash[64];
+
+	sph_shavite512_init(&ctx_shavite);
+	sph_shavite512(&ctx_shavite, input, 80);
+	sph_shavite512_close(&ctx_shavite, (void*) hash);
+
+	sph_simd512_init(&ctx_simd);
+	sph_simd512(&ctx_simd, (const void*) hash, 64);
+	sph_simd512_close(&ctx_simd, (void*) hash);
+
+	sph_skein512_init(&ctx_skein);
+	sph_skein512(&ctx_skein, (const void*) hash, 64);
+	sph_skein512_close(&ctx_skein, (void*) hash);
+
+	memcpy(output, hash, 32);
+}
+
+/* Main S3 entry point */
+extern "C" int scanhash_s3(int thr_id, uint32_t *pdata,
+	const uint32_t *ptarget, uint32_t max_nonce,
+	unsigned long *hashes_done)
+{
+	const uint32_t first_nonce = pdata[19];
+	const int throughput = 256*256*8*2;
+
+	static bool init[8] = { 0, 0, 0, 0, 0, 0, 0, 0 };
+
+	if (opt_benchmark)
+		((uint32_t*)ptarget)[7] = 0xF;
+
+	if (!init[thr_id])
+	{
+		CUDA_SAFE_CALL(cudaSetDevice(device_map[thr_id]));
+
+		CUDA_SAFE_CALL(cudaMalloc(&d_hash[thr_id], 64 * throughput));
+
+		x11_shavite512_cpu_init(thr_id, throughput);
+		x11_simd512_cpu_init(thr_id, throughput);
+		quark_skein512_cpu_init(thr_id, throughput);
+
+		cuda_check_cpu_init(thr_id, throughput);
+
+		init[thr_id] = true;
+	}
+
+	uint32_t endiandata[20];
+	for (int k=0; k < 20; k++)
+		be32enc(&endiandata[k], ((uint32_t*)pdata)[k]);
+
+	x11_shavite512_setBlock_80((void*)endiandata);
+	cuda_check_cpu_setTarget(ptarget);
+
+	do {
+		const uint32_t Htarg = ptarget[7];
+		uint32_t foundNonce;
+		int order = 0;
+
+		x11_shavite512_cpu_hash_80(thr_id, throughput, pdata[19], d_hash[thr_id], order++);
+		x11_simd512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+		quark_skein512_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+
+		foundNonce = cuda_check_cpu_hash_64(thr_id, throughput, pdata[19], NULL, d_hash[thr_id], order++);
+
+		if (foundNonce != 0xffffffff)
+		{
+			uint32_t vhash64[8];
+			be32enc(&endiandata[19], foundNonce);
+			s3hash(vhash64, endiandata);
+
+			if (vhash64[7] <= Htarg && fulltest(vhash64, ptarget)) {
+
+				pdata[19] = foundNonce;
+				*hashes_done = foundNonce - first_nonce + 1;
+				return 1;
+
+			} else {
+				applog(LOG_INFO, "GPU #%d: result for nonce $%08X does not validate on CPU!", thr_id, foundNonce);
+			}
+		}
+
+		pdata[19] += throughput;
+
+	} while (pdata[19] < max_nonce && !work_restart[thr_id].restart);
+
+	*hashes_done = pdata[19] - first_nonce + 1;
+	return 0;
+}