GOSTSec
/
sgminer
mirror of https://github.com/GOSTSec/sgminer
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

X86_64 SSE2 support for Linux

nfactor-troky
Mark Crichton 14 years ago
parent
1d8b6e13a3
commit
96d2287c72
8 changed files with 424 additions and 1 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 7
      Makefile.am
  2. 33
      configure.ac
  3. 19
      cpu-miner.c
  4. 9
      miner.h
  5. 129
      sha256_sse2_amd64.c
  6. 1
      x86_64/.gitignore
  7. 8
      x86_64/Makefile.am
  8. 219
      x86_64/sha256_xmm_amd64.asm

7
Makefile.am
Unescape View File

@ -14,7 +14,12 @@ INCLUDES = $(PTHREAD_FLAGS) -fno-strict-aliasing $(JANSSON_INCLUDES)
bin_PROGRAMS = minerd bin_PROGRAMS = minerd
minerd_SOURCES = cpu-miner.c sha256_generic.c sha256_4way.c sha256_via.c \ minerd_SOURCES = cpu-miner.c sha256_generic.c sha256_4way.c sha256_via.c \
sha256_cryptopp.c util.c miner.h compat.h sha256_cryptopp.c sha256_sse2_amd64.c util.c miner.h compat.h
minerd_LDFLAGS = $(PTHREAD_FLAGS) minerd_LDFLAGS = $(PTHREAD_FLAGS)
minerd_LDADD = @LIBCURL@ @JANSSON_LIBS@ @PTHREAD_LIBS@ minerd_LDADD = @LIBCURL@ @JANSSON_LIBS@ @PTHREAD_LIBS@
if HAS_YASM
SUBDIRS += x86_64
minerd_LDADD += x86_64/libx8664.a
AM_CFLAGS = -DHAS_YASM
endif

33
configure.ac
Unescape View File

@ -42,6 +42,38 @@ else
JANSSON_LIBS=-ljansson JANSSON_LIBS=-ljansson
fi fi
dnl Find YASM
has_yasm=false
AC_PATH_PROG(YASM,[yasm],[true yasm])
if test "$YASM" = "false" ; then
AC_MSG_WARN([yasm is required for the x86_64 SSE2 code, but it was not found])
fi
AC_MSG_CHECKING([if yasm version is greater than 1.0.1])
yasmver=`yasm --version | head -1 | cut -d\ -f2`
yamajor=`echo $yasmver | cut -d. -f1`
yaminor=`echo $yasmver | cut -d. -f2`
yamini=`echo $yasmver | cut -d. -f3`
if test "$yamajor" -ge "1" ; then
if test "$yamajor" -eq "1" ; then
if test "$yaminor" -ge "0" ; then
if test "$yamini" -ge "1"; then
has_yasm=true
fi
fi
fi
else
has_yasm=false
fi
if test "x$has_yasm" != "x" ; then
AC_MSG_RESULT([yes])
else
AC_MSG_RESULT([no])
fi
AM_CONDITIONAL([HAS_YASM], [test x$has_yasm = xtrue])
PKG_PROG_PKG_CONFIG() PKG_PROG_PKG_CONFIG()
LIBCURL_CHECK_CONFIG(, 7.10.1, , LIBCURL_CHECK_CONFIG(, 7.10.1, ,
@ -55,6 +87,7 @@ AC_CONFIG_FILES([
Makefile Makefile
compat/Makefile compat/Makefile
compat/jansson/Makefile compat/jansson/Makefile
x86_64/Makefile
]) ])
AC_OUTPUT AC_OUTPUT

19
cpu-miner.c
Unescape View File

@ -38,6 +38,7 @@ enum sha256_algos {
ALGO_VIA, /* VIA padlock */ ALGO_VIA, /* VIA padlock */
ALGO_CRYPTOPP, /* Crypto++ (C) */ ALGO_CRYPTOPP, /* Crypto++ (C) */
ALGO_CRYPTOPP_ASM32, /* Crypto++ 32-bit assembly */ ALGO_CRYPTOPP_ASM32, /* Crypto++ 32-bit assembly */
ALGO_SSE2_64, /* SSE2 for x86_64 */
}; };
static const char *algo_names[] = { static const char *algo_names[] = {
@ -52,6 +53,9 @@ static const char *algo_names[] = {
#ifdef WANT_CRYPTOPP_ASM32 #ifdef WANT_CRYPTOPP_ASM32
[ALGO_CRYPTOPP_ASM32] = "cryptopp_asm32", [ALGO_CRYPTOPP_ASM32] = "cryptopp_asm32",
#endif #endif
#ifdef WANT_X8664_SSE2
[ALGO_SSE2_64] = "sse2_64",
#endif
}; };
bool opt_debug = false; bool opt_debug = false;
@ -93,6 +97,9 @@ static struct option_help options_help[] = {
"\n\tcryptopp\tCrypto++ C/C++ implementation" "\n\tcryptopp\tCrypto++ C/C++ implementation"
#ifdef WANT_CRYPTOPP_ASM32 #ifdef WANT_CRYPTOPP_ASM32
"\n\tcryptopp_asm32\tCrypto++ 32-bit assembler implementation" "\n\tcryptopp_asm32\tCrypto++ 32-bit assembler implementation"
#endif
#ifdef WANT_X8664_SSE2
"\n\tsse2_64\t\tSSE2 implementation for x86_64 machines"
#endif #endif
}, },
@ -331,6 +338,18 @@ static void *miner_thread(void *thr_id_int)
max_nonce, &hashes_done); max_nonce, &hashes_done);
break; break;
#ifdef WANT_X8664_SSE2
case ALGO_SSE2_64: {
unsigned int rc5 =
scanhash_sse2_64(work.midstate, work.data + 64,
work.hash1, work.hash,
work.target,
max_nonce, &hashes_done);
rc = (rc5 == -1) ? false : true;
}
break;
#endif
#ifdef WANT_SSE2_4WAY #ifdef WANT_SSE2_4WAY
case ALGO_4WAY: { case ALGO_4WAY: {
unsigned int rc4 = unsigned int rc4 =

9
miner.h
Unescape View File

@ -15,6 +15,10 @@
#define WANT_VIA_PADLOCK 1 #define WANT_VIA_PADLOCK 1
#endif #endif
#if defined(__x86_64__) && defined(__SSE2__) && defined(HAS_YASM)
#define WANT_X8664_SSE2 1
#endif
#if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) #if ((__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
#define WANT_BUILTIN_BSWAP #define WANT_BUILTIN_BSWAP
#else #else
@ -74,6 +78,11 @@ extern unsigned int ScanHash_4WaySSE2(const unsigned char *pmidstate,
const unsigned char *ptarget, const unsigned char *ptarget,
uint32_t max_nonce, unsigned long *nHashesDone); uint32_t max_nonce, unsigned long *nHashesDone);
extern unsigned int scanhash_sse2_amd64(const unsigned char *pmidstate,
unsigned char *pdata, unsigned char *phash1, unsigned char *phash,
const unsigned char *ptarget,
uint32_t max_nonce, unsigned long *nHashesDone);
extern bool scanhash_via(unsigned char *data_inout, extern bool scanhash_via(unsigned char *data_inout,
const unsigned char *target, const unsigned char *target,
uint32_t max_nonce, unsigned long *hashes_done); uint32_t max_nonce, unsigned long *hashes_done);

129
sha256_sse2_amd64.c
Unescape View File

@ -0,0 +1,129 @@
/*
* SHA-256 driver for ASM routine for x86_64 on Linux
* Copyright (c) Mark Crichton <crichton@gimp.org>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
*/
#include "miner.h"
#ifdef WANT_X8664_SSE2
#include <string.h>
#include <assert.h>
#include <xmmintrin.h>
#include <stdint.h>
#include <stdio.h>
extern void CalcSha256_x64(__m128i *res, __m128i *data, uint32_t init[8]);
uint32_t g_sha256_k[] = {
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, /* 0 */
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, /* 8 */
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, /* 16 */
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, /* 24 */
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, /* 32 */
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, /* 40 */
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, /* 48 */
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, /* 56 */
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
};
uint32_t g_sha256_hinit[8] =
{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
__m128i g_4sha256_k[64];
int scanhash_sse2_64(const unsigned char *pmidstate, unsigned char *pdata,
unsigned char *phash1, unsigned char *phash,
const unsigned char *ptarget,
uint32_t max_nonce, unsigned long *nHashesDone)
{
uint32_t *nNonce_p = (uint32_t *)(pdata + 12);
uint32_t nonce = 0;
uint32_t m_midstate[8], m_w[16], m_w1[16];
__m128i m_4w[64], m_4hash[64], m_4hash1[64];
__m128i offset;
__m128i g_4sha256_hinit[8];
int i;
/* For debugging */
union {
__m128i m;
uint32_t i[4];
} mi;
/* Message expansion */
memcpy(m_midstate, pmidstate, sizeof(m_midstate));
memcpy(m_w, pdata, sizeof(m_w)); /* The 2nd half of the data */
memcpy(m_w1, phash1, sizeof(m_w1));
memset(m_4hash, 0, sizeof(m_4hash));
/* Transmongrify */
for (i = 0; i < 16; i++)
m_4w[i] = _mm_set1_epi32(m_w[i]);
for (i = 0; i < 16; i++)
m_4hash1[i] = _mm_set1_epi32(m_w1[i]);
for (i = 0; i < 64; i++)
g_4sha256_k[i] = _mm_set1_epi32(g_sha256_k[i]);
offset = _mm_set_epi32(0x3, 0x2, 0x1, 0x0);
for (;;)
{
int j;
m_4w[3] = _mm_add_epi32(offset, _mm_set1_epi32(nonce));
/* Some optimization can be done here W.R.T. precalculating some hash */
CalcSha256_x64(m_4hash1, m_4w, m_midstate);
CalcSha256_x64(m_4hash, m_4hash1, g_sha256_hinit);
for (j = 0; j < 4; j++) {
mi.m = m_4hash[7];
if (mi.i[j] == 0)
break;
}
/* If j = true, we found a hit...so check it */
/* Use the C version for a check... */
if (j != 4) {
for (i = 0; i < 8; i++) {
mi.m = m_4hash[i];
*(uint32_t *)&(phash)[i*4] = mi.i[j];
}
if (fulltest(phash, ptarget)) {
*nHashesDone = nonce;
*nNonce_p = nonce + j;
return nonce + j;
}
}
nonce += 4;
if (nonce >= max_nonce)
{
*nHashesDone = nonce;
return -1;
}
}
}
#endif /* WANT_X8664_SSE2 */

1
x86_64/.gitignore vendored
Unescape View File

@ -0,0 +1 @@
libx8664.a

8
x86_64/Makefile.am
Unescape View File

@ -0,0 +1,8 @@
noinst_LIBRARIES = libx8664.a
SUFFIXES = .asm
libx8664_a_SOURCES = sha256_xmm_amd64.asm
.asm.o:
$(YASM) -f elf64 $<

219
x86_64/sha256_xmm_amd64.asm
Unescape View File

@ -0,0 +1,219 @@
;; SHA-256 for X86-64 for Linux, based off of:
; (c) Ufasoft 2011 http://ufasoft.com mailto:support@ufasoft.com
; Version 2011
; This software is Public Domain
; SHA-256 CPU SSE cruncher for Bitcoin Miner
ALIGN 32
BITS 64
%define hash rdi
%define data rsi
%define init rdx
extern g_4sha256_k
global CalcSha256_x64
; CalcSha256 hash(rdi), data(rsi), init(rdx)
CalcSha256_x64:
push rbx
LAB_NEXT_NONCE:
mov r11, data
; mov rax, pnonce
; mov eax, [rax]
; mov [rbx+3*16], eax
; inc eax
; mov [rbx+3*16+4], eax
; inc eax
; mov [rbx+3*16+8], eax
; inc eax
; mov [rbx+3*16+12], eax
mov rcx, 64*4 ;rcx is # of SHA-2 rounds
mov rax, 16*4 ;rax is where we expand to
LAB_SHA:
push rcx
lea rcx, qword [r11+rcx*4]
lea r11, qword [r11+rax*4]
LAB_CALC:
movdqa xmm0, [r11-15*16]
movdqa xmm2, xmm0 ; (Rotr32(w_15, 7) ^ Rotr32(w_15, 18) ^ (w_15 >> 3))
psrld xmm0, 3
movdqa xmm1, xmm0
pslld xmm2, 14
psrld xmm1, 4
pxor xmm0, xmm1
pxor xmm0, xmm2
pslld xmm2, 11
psrld xmm1, 11
pxor xmm0, xmm1
pxor xmm0, xmm2
paddd xmm0, [r11-16*16]
movdqa xmm3, [r11-2*16]
movdqa xmm2, xmm3 ; (Rotr32(w_2, 17) ^ Rotr32(w_2, 19) ^ (w_2 >> 10))
psrld xmm3, 10
movdqa xmm1, xmm3
pslld xmm2, 13
psrld xmm1, 7
pxor xmm3, xmm1
pxor xmm3, xmm2
pslld xmm2, 2
psrld xmm1, 2
pxor xmm3, xmm1
pxor xmm3, xmm2
paddd xmm0, xmm3
paddd xmm0, [r11-7*16]
movdqa [r11], xmm0
add r11, 16
cmp r11, rcx
jb LAB_CALC
pop rcx
mov rax, 0
; Load the init values of the message into the hash.
movd xmm0, dword [rdx+4*4] ; xmm0 == e
pshufd xmm0, xmm0, 0
movd xmm3, dword [rdx+3*4] ; xmm3 == d
pshufd xmm3, xmm3, 0
movd xmm4, dword [rdx+2*4] ; xmm4 == c
pshufd xmm4, xmm4, 0
movd xmm5, dword [rdx+1*4] ; xmm5 == b
pshufd xmm5, xmm5, 0
movd xmm7, dword [rdx+0*4] ; xmm7 == a
pshufd xmm7, xmm7, 0
movd xmm8, dword [rdx+5*4] ; xmm8 == f
pshufd xmm8, xmm8, 0
movd xmm9, dword [rdx+6*4] ; xmm9 == g
pshufd xmm9, xmm9, 0
movd xmm10, dword [rdx+7*4] ; xmm10 == h
pshufd xmm10, xmm10, 0
LAB_LOOP:
;; T t1 = h + (Rotr32(e, 6) ^ Rotr32(e, 11) ^ Rotr32(e, 25)) + ((e & f) ^ AndNot(e, g)) + Expand32<T>(g_sha256_k[j]) + w[j]
movdqa xmm6, [rsi+rax*4]
paddd xmm6, g_4sha256_k[rax*4]
add rax, 4
paddd xmm6, xmm10 ; +h
movdqa xmm1, xmm0
movdqa xmm2, xmm9
pandn xmm1, xmm2 ; ~e & g
movdqa xmm10, xmm2 ; h = g
movdqa xmm2, xmm8 ; f
movdqa xmm9, xmm2 ; g = f
pand xmm2, xmm0 ; e & f
pxor xmm1, xmm2 ; (e & f) ^ (~e & g)
movdqa xmm8, xmm0 ; f = e
paddd xmm6, xmm1 ; Ch + h + w[i] + k[i]
movdqa xmm1, xmm0
psrld xmm0, 6
movdqa xmm2, xmm0
pslld xmm1, 7
psrld xmm2, 5
pxor xmm0, xmm1
pxor xmm0, xmm2
pslld xmm1, 14
psrld xmm2, 14
pxor xmm0, xmm1
pxor xmm0, xmm2
pslld xmm1, 5
pxor xmm0, xmm1 ; Rotr32(e, 6) ^ Rotr32(e, 11) ^ Rotr32(e, 25)
paddd xmm6, xmm0 ; xmm6 = t1
movdqa xmm0, xmm3 ; d
paddd xmm0, xmm6 ; e = d+t1
movdqa xmm1, xmm5 ; =b
movdqa xmm3, xmm4 ; d = c
movdqa xmm2, xmm4 ; c
pand xmm2, xmm5 ; b & c
pand xmm4, xmm7 ; a & c
pand xmm1, xmm7 ; a & b
pxor xmm1, xmm4
movdqa xmm4, xmm5 ; c = b
movdqa xmm5, xmm7 ; b = a
pxor xmm1, xmm2 ; (a & c) ^ (a & d) ^ (c & d)
paddd xmm6, xmm1 ; t1 + ((a & c) ^ (a & d) ^ (c & d))
movdqa xmm2, xmm7
psrld xmm7, 2
movdqa xmm1, xmm7
pslld xmm2, 10
psrld xmm1, 11
pxor xmm7, xmm2
pxor xmm7, xmm1
pslld xmm2, 9
psrld xmm1, 9
pxor xmm7, xmm2
pxor xmm7, xmm1
pslld xmm2, 11
pxor xmm7, xmm2
paddd xmm7, xmm6 ; a = t1 + (Rotr32(a, 2) ^ Rotr32(a, 13) ^ Rotr32(a, 22)) + ((a & c) ^ (a & d) ^ (c & d));
cmp rax, rcx
jb LAB_LOOP
; Finished the 64 rounds, calculate hash and save
movd xmm1, dword [rdx+0*4]
pshufd xmm1, xmm1, 0
paddd xmm7, xmm1
movd xmm1, dword [rdx+1*4]
pshufd xmm1, xmm1, 0
paddd xmm5, xmm1
movd xmm1, dword [rdx+2*4]
pshufd xmm1, xmm1, 0
paddd xmm4, xmm1
movd xmm1, dword [rdx+3*4]
pshufd xmm1, xmm1, 0
paddd xmm3, xmm1
movd xmm1, dword [rdx+4*4]
pshufd xmm1, xmm1, 0
paddd xmm0, xmm1
movd xmm1, dword [rdx+5*4]
pshufd xmm1, xmm1, 0
paddd xmm8, xmm1
movd xmm1, dword [rdx+6*4]
pshufd xmm1, xmm1, 0
paddd xmm9, xmm1
movd xmm1, dword [rdx+7*4]
pshufd xmm1, xmm1, 0
paddd xmm10, xmm1
debug_me:
movdqa [rdi+0*16], xmm7
movdqa [rdi+1*16], xmm5
movdqa [rdi+2*16], xmm4
movdqa [rdi+3*16], xmm3
movdqa [rdi+4*16], xmm0
movdqa [rdi+5*16], xmm8
movdqa [rdi+6*16], xmm9
movdqa [rdi+7*16], xmm10
LAB_RET:
pop rbx
ret
Write Preview
Loading…
Cancel
Save