4 Хэши параллельно на SSE2 процессоров для 0.3.6

Похоже pastebin.com путает патч ...

Код:

Diff --git а / cryptopp / sha256.cpp б / cryptopp / sha256.cpp
Новый режим файла 100644
индекс 0000000..15f8be1
--- / DEV / нуль
+++ б / cryptopp / sha256.cpp
@@ -0,0 1443 @@
+#включают 
+#включают 
+
+#включают 
+#включают 
+#включают 
+
+#define НПБР 32
+
+статические константные без знака INT sha256_consts [] = {
+	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
+};
+
+
+статический встроенный __m128i Ch (Const __m128i б, Const __m128i с, Const __m128i г) {
+	Возвращение (б & в) ^ (~ Ь & г);
+}
+
+статический инлайн __m128i Maj (Const __m128i б, Const __m128i с, Const __m128i г) {
+	Возвращение (б & в) ^ (б & г) ^ (с & г);
+}
+
+статический встроенный __m128i ROTR (__ m128i х, сопзЬ Int N) 
+	вернуть _mm_srli_epi32 (х, п) 
+
+статический встроенный __m128i ШР (__ m128i х, сопзЬ Int N) {
+	вернуть _mm_srli_epi32 (х, п);
+}
+
+/ * SHA256 функции * /
+#define BIGSIGMA0_256 (х) (ROTR ((х), 2) ^ ROTR ((х), 13) ^ ROTR ((х), 22))
+#define BIGSIGMA1_256 (х) (ROTR ((х), 6) ^ ROTR ((х), 11) ^ ROTR ((х), 25))
+#define SIGMA0_256 (х) (ROTR ((х), 7) ^ ROTR ((х), 18) ^ ШР ((х), 3))
+#define SIGMA1_256 (х) (ROTR ((х), 17) ^ ROTR ((х), 19) ^ ШР ((х), 10))
+
+статический встроенный __m128i load_epi32 (Const беззнаковое целочисленное значение х0, Const беззнаковое целочисленное значение x1, Const беззнаковое целочисленное значение х2, Const беззнаковое целочисленное значение х3) {
+	вернуть _mm_set_epi32 (x0, x1, x2, x3);
+}
+
+Статическая рядный беззнаковое целочисленное значение store32 (Const __m128i х, INT I) {
+	объединение {беззнаковое INT RET [4]; __m128i х; } Коробка;
+	box.x = х;
+	вернуть box.ret [I];
+}
+
+Статическая рядный аннулируются store_epi32 (Const __m128i х, неподписанные INT * x0, беззнаковое INT * x1, беззнаковое INT * x2, беззнаковое INT * x3) {
+	объединение {беззнаковое INT RET [4]; __m128i х; } Коробка;
+	box.x = х;
+	* Х0 = box.ret [3]; * X1 = box.ret [2]; * Х2 = box.ret [1]; * Х3 = box.ret [0];
+}
+
+статический встроенный __m128i SHA256_CONST (Const INT I) {
+	вернуть _mm_set1_epi32 (sha256_consts [I]);
+}
+
+#define add4 (x0, x1, x2, x3) _mm_add_epi32 (_mm_add_epi32 (_mm_add_epi32 (x0, x1), х2), х3)
+#define add5 (x0, x1, x2, x3, x4) _mm_add_epi32 (add4 (x0, x1, x2, x3), x4)
+
+#define SHA256ROUND (а, б, в, г, д, е, ж, з, и, ш) \
+	Т1 = add5 (ч, BIGSIGMA1_256 (е), гл (д, е, ж), SHA256_CONST (я), ш); \
+д = _mm_add_epi32 (д, Т1); \
+Т2 = _mm_add_epi32 (BIGSIGMA0_256 (а), майор (а, б, в)); \
+ч = _mm_add_epi32 (Т1, Т2);
+
+#define SHA256ROUND_lastd (а, б, в, г, д, е, ж, з, и, ш) \
+	Т1 = add5 (ч, BIGSIGMA1_256 (е), гл (д, е, ж), SHA256_CONST (я), ш); \
+д = _mm_add_epi32 (д, Т1);                                           
+// Т2 = _mm_add_epi32 (BIGSIGMA0_256 (а), майор (а, б, в));                 
+// ч = _mm_add_epi32 (Т1, Т2);
+
+#define SHA256ROUND_last (а, б, в, г, д, е, ж, з, и, ш) \
+	Т1 = add5 (ч, BIGSIGMA1_256 (е), гл (д, е, ж), SHA256_CONST (я), ш); \
+Т2 = _mm_add_epi32 (BIGSIGMA0_256 (а), майор (а, б, в)); \
+ч = _mm_add_epi32 (Т1, Т2);
+
+Статическая рядный беззнаковое целочисленное значение замены (без знака INT значение) {
+	__как м__ ("BSWAP% 0" : "= г" (стоимость) : "0" (стоимость));
+	возвращаемое значение;
+}
+
+Статическая рядный без знака INT SWAP32 (сопзЬ пустота * адр) {
+	беззнаковое INT значение = (* ((беззнаковое INT *) (адрес)));
+	__как м__ ("BSWAP% 0" : "= г" (стоимость) : "0" (стоимость));
+	возвращаемое значение;
+}
+
+Статические рядный недействительный dumpreg (__ m128i х, символ * тзд) {
+	объединение {беззнаковое INT RET [4]; __m128i х; } Коробка;
+	box.x = х;
+	Е ("% S% 08x% 08x% 08x% 08x \ п", MSG, box.ret [0], box.ret [1], box.ret [2], box.ret [3]);
+}
+
+#if 1
+#define dumpstate (я) Е ("% S:% 08x% 08x% 08x% 08x% 08x% 08x% 08x% 08x% 08x \ п"\
+		__func__, store32 (w 0, я), store32 (а, я), store32 (б, г), store32 (с, я), store32 (д, I), store32 (е, я), store32 (F, I) , store32 (г, я), store32 (H, I));
+#else
+#define dumpstate ()
+#endif
+аннулированию Double_BlockSHA256 (сопзИте пустоту * контактная, недействительный * коврик, сопзИте пустоту * предварительно, беззнаковая INT Тхача [8] [НПБРЫ], сопзИте пустоту * INIT)
+{
+	беззнаковое INT * В = (беззнаковое INT *) контактный;
+	беззнаковое INT * Pad = (беззнаковое INT *) площадку;
+	неподписанных INT * hPre = (беззнаковое INT *) заранее;
+	неподписанных INT * hInit = (беззнаковое INT *) инициализации;
+	неподписанных INT I, J, K;
+
+	/ * Векторы, используемые при расчете * /
+	__m128i w0, w1, w2, w3, w4, W5, W6, W7;
+	__m128i W8, W9, W10, W11, W12, W13, W14, W15;
+	__m128i Т1, Т2;
+	__m128i а, б, в, г, д, е, ж, з;
+
+	/ * Смещение для временного значения вектора * /
+	__m128i смещение = load_epi32 (0x00000003, 0x00000002, 0x00000001, 0x00000000);
+
+
+	для (к = 0; K+		w 0 = load_epi32 (В [0], В [0], В [0], В [0]);
+		w1 = load_epi32 (В работе [1], В [1], В [1], В [1]);
+		ш2 = load_epi32 (В работе [2], В [2], В [2], В [2]);
+		W3 = load_epi32 (В работе [3], В работе [3], В работе [3], В [3]);
+		W4 = load_epi32 (В [4], В [4], В [4], В [4]);
+		W5 = load_epi32 (В работе [5], В [5], В [5], В [5]);
+		W6 = load_epi32 (В работе [6], В [6], В [6], В [6]);
+		W7 = load_epi32 (В работе [7], В [7], В [7], В [7]);
+		W8 = load_epi32 (В работе [8], В [8], В [8], в [8]);
+		W9 = load_epi32 (В работе [9], в [9], в [9], в [9]);
+		W10 = load_epi32 (В работе [10], В [10], В [10], в [10]);
+		W11 = load_epi32 (В работе [11], в [11], в [11], в [11]);
+		W12 = load_epi32 (В работе [12], в [12], в [12], в [12]);
+		W13 = load_epi32 (В работе [13], В работе [13], В работе [13], в [13]);
+		W14 = load_epi32 (В работе [14], В [14], В [14], в [14]);
+		W15 = load_epi32 (В работе [15], в [15], в [15], в [15]);
+
+		/ * Взломать в одноразовом номер низких байт w3 * /
+		__m128i k_vec = load_epi32 (к, к, к, к);
+		W3 = _mm_add_epi32 (W3, смещение);
+		W3 = _mm_add_epi32 (W3, k_vec);
+
+		а = load_epi32 (hPre [0], hPre [0], hPre [0], hPre [0]);
+		б = load_epi32 (hPre [1], hPre [1], hPre [1], hPre [1]);
+		с = load_epi32 (hPre [2], hPre [2], hPre [2], hPre [2]);
+		д = load_epi32 (hPre [3], hPre [3], hPre [3], hPre [3]);
+		е = load_epi32 (hPre [4], hPre [4], hPre [4], hPre [4]);
+		е = load_epi32 (hPre [5], hPre [5], hPre [5], hPre [5]);
+		г = load_epi32 (hPre [6], hPre [6], hPre [6], hPre [6]);
+		ч = load_epi32 (hPre [7], hPre [7], hPre [7], hPre [7]);
+
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 0, w 0);    
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 1, w 1);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 2, w2);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 3, W3);
+		SHA256ROUND (д, е, ж, з, а, б, в, г, 4, W4);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 5, W5);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 6, W6);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 7, W7);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 8, W8);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 9, W9);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 10, W10);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 11, W11);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 12, W12);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 13, W13);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 14, W14);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 15, W15);
+
+		w 0 = add4 (SIGMA1_256 (W14), W9, SIGMA0_256 (w1), w0);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 16, w 0);
+		w1 = add4 (SIGMA1_256 (W15), W10, SIGMA0_256 (w2), w 1);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 17, w 1);
+		ш2 = add4 (SIGMA1_256 (w0), W11, SIGMA0_256 (W3), ш2);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 18, w2);
+		W3 = add4 (SIGMA1_256 (w1), W12, SIGMA0_256 (W4), W3);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 19, W3);
+		W4 = add4 (SIGMA1_256 (w2), W13, SIGMA0_256 (W5), W4);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 20, W4);
+		W5 = add4 (SIGMA1_256 (W3), W14, SIGMA0_256 (W6), W5);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 21, W5);
+		W6 = add4 (SIGMA1_256 (W4), W15, SIGMA0_256 (W7), W6);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 22, W6);
+		W7 = add4 (SIGMA1_256 (W5), w 0, SIGMA0_256 (W8), W7);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 23, W7);
+		W8 = add4 (SIGMA1_256 (W6), w1, SIGMA0_256 (W9), W8);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 24, W8);
+		W9 = add4 (SIGMA1_256 (W7), w2, SIGMA0_256 (W10), W9);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 25, W9);
+		W10 = add4 (SIGMA1_256 (W8), W3, SIGMA0_256 (W11), W10);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 26, W10);
+		W11 = add4 (SIGMA1_256 (W9), W4, SIGMA0_256 (W12), W11);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 27, W11);
+		W12 = add4 (SIGMA1_256 (W10), W5, SIGMA0_256 (W13), W12);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 28, W12);
+		W13 = add4 (SIGMA1_256 (W11), W6, SIGMA0_256 (W14), W13);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 29, W13);
+		W14 = add4 (SIGMA1_256 (W12), W7, SIGMA0_256 (W15), W14);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 30, W14);
+		W15 = add4 (SIGMA1_256 (W13), W8, SIGMA0_256 (w0), W15);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 31, W15);
+
+		w 0 = add4 (SIGMA1_256 (W14), W9, SIGMA0_256 (w1), w0);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 32, w 0);
+		w1 = add4 (SIGMA1_256 (W15), W10, SIGMA0_256 (w2), w 1);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 33, w 1);
+		ш2 = add4 (SIGMA1_256 (w0), W11, SIGMA0_256 (W3), ш2);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 34, w2);
+		W3 = add4 (SIGMA1_256 (w1), W12, SIGMA0_256 (W4), W3);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 35, W3);
+		W4 = add4 (SIGMA1_256 (w2), W13, SIGMA0_256 (W5), W4);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 36, W4);
+		W5 = add4 (SIGMA1_256 (W3), W14, SIGMA0_256 (W6), W5);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 37, W5);
+		W6 = add4 (SIGMA1_256 (W4), W15, SIGMA0_256 (W7), W6);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 38, W6);
+		W7 = add4 (SIGMA1_256 (W5), w 0, SIGMA0_256 (W8), W7);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 39, W7);
+		W8 = add4 (SIGMA1_256 (W6), w1, SIGMA0_256 (W9), W8);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 40, W8);
+		W9 = add4 (SIGMA1_256 (W7), w2, SIGMA0_256 (W10), W9);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 41, W9);
+		W10 = add4 (SIGMA1_256 (W8), W3, SIGMA0_256 (W11), W10);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 42, W10);
+		W11 = add4 (SIGMA1_256 (W9), W4, SIGMA0_256 (W12), W11);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 43, W11);
+		W12 = add4 (SIGMA1_256 (W10), W5, SIGMA0_256 (W13), W12);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 44, W12);
+		W13 = add4 (SIGMA1_256 (W11), W6, SIGMA0_256 (W14), W13);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 45, W13);
+		W14 = add4 (SIGMA1_256 (W12), W7, SIGMA0_256 (W15), W14);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 46, W14);
+		W15 = add4 (SIGMA1_256 (W13), W8, SIGMA0_256 (w0), W15);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 47, W15);
+
+		w 0 = add4 (SIGMA1_256 (W14), W9, SIGMA0_256 (w1), w0);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 48, w 0);
+		w1 = add4 (SIGMA1_256 (W15), W10, SIGMA0_256 (w2), w 1);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 49, w 1);
+		ш2 = add4 (SIGMA1_256 (w0), W11, SIGMA0_256 (W3), ш2);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 50, w2);
+		W3 = add4 (SIGMA1_256 (w1), W12, SIGMA0_256 (W4), W3);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 51, W3);
+		W4 = add4 (SIGMA1_256 (w2), W13, SIGMA0_256 (W5), W4);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 52, W4);
+		W5 = add4 (SIGMA1_256 (W3), W14, SIGMA0_256 (W6), W5);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 53, W5);
+		W6 = add4 (SIGMA1_256 (W4), W15, SIGMA0_256 (W7), W6);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 54, W6);
+		W7 = add4 (SIGMA1_256 (W5), w 0, SIGMA0_256 (W8), W7);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 55, W7);
+		W8 = add4 (SIGMA1_256 (W6), w1, SIGMA0_256 (W9), W8);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 56, W8);
+		W9 = add4 (SIGMA1_256 (W7), w2, SIGMA0_256 (W10), W9);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 57, W9);
+		W10 = add4 (SIGMA1_256 (W8), W3, SIGMA0_256 (W11), W10);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 58, W10);
+		W11 = add4 (SIGMA1_256 (W9), W4, SIGMA0_256 (W12), W11);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 59, W11);
+		W12 = add4 (SIGMA1_256 (W10), W5, SIGMA0_256 (W13), W12);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 60, W12);
+		W13 = add4 (SIGMA1_256 (W11), W6, SIGMA0_256 (W14), W13);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 61, W13);
+		W14 = add4 (SIGMA1_256 (W12), W7, SIGMA0_256 (W15), W14);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 62, W14);
+		W15 = add4 (SIGMA1_256 (W13), W8, SIGMA0_256 (w0), W15);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 63, W15);
+
+#define store_load (х, я, Dest) \
+		W8 = load_epi32 ((hPre) [I], (hPre) [I], (hPre) [I], (hPre) [I]); \
+		приемник = _mm_add_epi32 (W8, х);
+
+		store_load (а, 0, w 0);
+		store_load (б, 1, w 1);
+		store_load (с, 2, w2);
+		store_load (д, 3, W3);
+		store_load (е, 4, W4);
+		store_load (е, 5, W5);
+		store_load (г, 6, W6);
+		store_load (ч, 7, W7);
+
+		W8 = load_epi32 (Pad [8], Pad [8], Pad [8], Pad [8]);
+		W9 = load_epi32 (Pad [9], Pad [9], Pad [9], Pad [9]);
+		W10 = load_epi32 (Pad [10], Pad [10], Pad [10], Pad [10]);
+		W11 = load_epi32 (Pad [11], Pad [11], Pad [11], Pad [11]);
+		W12 = load_epi32 (Pad [12], Pad [12], Pad [12], Pad [12]);
+		W13 = load_epi32 (Pad [13], Pad [13], Pad [13], Pad [13]);
+		W14 = load_epi32 (Pad [14], Pad [14], Pad [14], Pad [14]);
+		W15 = load_epi32 (Pad [15], Pad [15], Pad [15], Pad [15]);
+
+		а = load_epi32 (hInit [0], hInit [0], hInit [0], hInit [0]);
+		б = load_epi32 (hInit [1], hInit [1], hInit [1], hInit [1]);
+		с = load_epi32 (hInit [2], hInit [2], hInit [2], hInit [2]);
+		д = load_epi32 (hInit [3], hInit [3], hInit [3], hInit [3]);
+		е = load_epi32 (hInit [4], hInit [4], hInit [4], hInit [4]);
+		е = load_epi32 (hInit [5], hInit [5], hInit [5], hInit [5]);
+		г = load_epi32 (hInit [6], hInit [6], hInit [6], hInit [6]);
+		ч = load_epi32 (hInit [7], hInit [7], hInit [7], hInit [7]);
+
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 0, w 0);    
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 1, w 1);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 2, w2);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 3, W3);
+		SHA256ROUND (д, е, ж, з, а, б, в, г, 4, W4);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 5, W5);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 6, W6);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 7, W7);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 8, W8);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 9, W9);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 10, W10);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 11, W11);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 12, W12);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 13, W13);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 14, W14);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 15, W15);
+
+		w 0 = add4 (SIGMA1_256 (W14), W9, SIGMA0_256 (w1), w0);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 16, w 0);
+		w1 = add4 (SIGMA1_256 (W15), W10, SIGMA0_256 (w2), w 1);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 17, w 1);
+		ш2 = add4 (SIGMA1_256 (w0), W11, SIGMA0_256 (W3), ш2);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 18, w2);
+		W3 = add4 (SIGMA1_256 (w1), W12, SIGMA0_256 (W4), W3);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 19, W3);
+		W4 = add4 (SIGMA1_256 (w2), W13, SIGMA0_256 (W5), W4);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 20, W4);
+		W5 = add4 (SIGMA1_256 (W3), W14, SIGMA0_256 (W6), W5);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 21, W5);
+		W6 = add4 (SIGMA1_256 (W4), W15, SIGMA0_256 (W7), W6);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 22, W6);
+		W7 = add4 (SIGMA1_256 (W5), w 0, SIGMA0_256 (W8), W7);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 23, W7);
+		W8 = add4 (SIGMA1_256 (W6), w1, SIGMA0_256 (W9), W8);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 24, W8);
+		W9 = add4 (SIGMA1_256 (W7), w2, SIGMA0_256 (W10), W9);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 25, W9);
+		W10 = add4 (SIGMA1_256 (W8), W3, SIGMA0_256 (W11), W10);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 26, W10);
+		W11 = add4 (SIGMA1_256 (W9), W4, SIGMA0_256 (W12), W11);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 27, W11);
+		W12 = add4 (SIGMA1_256 (W10), W5, SIGMA0_256 (W13), W12);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 28, W12);
+		W13 = add4 (SIGMA1_256 (W11), W6, SIGMA0_256 (W14), W13);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 29, W13);
+		W14 = add4 (SIGMA1_256 (W12), W7, SIGMA0_256 (W15), W14);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 30, W14);
+		W15 = add4 (SIGMA1_256 (W13), W8, SIGMA0_256 (w0), W15);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 31, W15);
+
+		w 0 = add4 (SIGMA1_256 (W14), W9, SIGMA0_256 (w1), w0);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 32, w 0);
+		w1 = add4 (SIGMA1_256 (W15), W10, SIGMA0_256 (w2), w 1);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 33, w 1);
+		ш2 = add4 (SIGMA1_256 (w0), W11, SIGMA0_256 (W3), ш2);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 34, w2);
+		W3 = add4 (SIGMA1_256 (w1), W12, SIGMA0_256 (W4), W3);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 35, W3);
+		W4 = add4 (SIGMA1_256 (w2), W13, SIGMA0_256 (W5), W4);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 36, W4);
+		W5 = add4 (SIGMA1_256 (W3), W14, SIGMA0_256 (W6), W5);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 37, W5);
+		W6 = add4 (SIGMA1_256 (W4), W15, SIGMA0_256 (W7), W6);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 38, W6);
+		W7 = add4 (SIGMA1_256 (W5), w 0, SIGMA0_256 (W8), W7);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 39, W7);
+		W8 = add4 (SIGMA1_256 (W6), w1, SIGMA0_256 (W9), W8);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 40, W8);
+		W9 = add4 (SIGMA1_256 (W7), w2, SIGMA0_256 (W10), W9);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 41, W9);
+		W10 = add4 (SIGMA1_256 (W8), W3, SIGMA0_256 (W11), W10);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 42, W10);
+		W11 = add4 (SIGMA1_256 (W9), W4, SIGMA0_256 (W12), W11);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 43, W11);
+		W12 = add4 (SIGMA1_256 (W10), W5, SIGMA0_256 (W13), W12);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 44, W12);
+		W13 = add4 (SIGMA1_256 (W11), W6, SIGMA0_256 (W14), W13);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 45, W13);
+		W14 = add4 (SIGMA1_256 (W12), W7, SIGMA0_256 (W15), W14);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 46, W14);
+		W15 = add4 (SIGMA1_256 (W13), W8, SIGMA0_256 (w0), W15);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 47, W15);
+
+		w 0 = add4 (SIGMA1_256 (W14), W9, SIGMA0_256 (w1), w0);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 48, w 0);
+		w1 = add4 (SIGMA1_256 (W15), W10, SIGMA0_256 (w2), w 1);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 49, w 1);
+		ш2 = add4 (SIGMA1_256 (w0), W11, SIGMA0_256 (W3), ш2);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 50, w2);
+		W3 = add4 (SIGMA1_256 (w1), W12, SIGMA0_256 (W4), W3);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 51, W3);
+		W4 = add4 (SIGMA1_256 (w2), W13, SIGMA0_256 (W5), W4);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 52, W4);
+		W5 = add4 (SIGMA1_256 (W3), W14, SIGMA0_256 (W6), W5);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 53, W5);
+		W6 = add4 (SIGMA1_256 (W4), W15, SIGMA0_256 (W7), W6);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 54, W6);
+		W7 = add4 (SIGMA1_256 (W5), w 0, SIGMA0_256 (W8), W7);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 55, W7);
+		W8 = add4 (SIGMA1_256 (W6), w1, SIGMA0_256 (W9), W8);
+		SHA256ROUND (а, б, в, г, д, е, ж, з, 56, W8);
+		W9 = add4 (SIGMA1_256 (W7), w2, SIGMA0_256 (W10), W9);
+		SHA256ROUND (ч, а, б, в, г, д, е, ж, 57, W9);
+		W10 = add4 (SIGMA1_256 (W8), W3, SIGMA0_256 (W11), W10);
+		SHA256ROUND (г, ч, а, б, в, г, д, е, 58, W10);
+		W11 = add4 (SIGMA1_256 (W9), W4, SIGMA0_256 (W12), W11);
+		SHA256ROUND (е, ж, з, а, б, в, г, д, 59, W11);
+		W12 = add4 (SIGMA1_256 (W10), W5, SIGMA0_256 (W13), W12);
+		SHA256ROUND (д, е, ж, з, а, б, в, д, 60, W12);
+		W13 = add4 (SIGMA1_256 (W11), W6, SIGMA0_256 (W14), W13);
+		SHA256ROUND (д, д, е, ж, з, а, б, в, 61, W13);
+		W14 = add4 (SIGMA1_256 (W12), W7, SIGMA0_256 (W15), W14);
+		SHA256ROUND (в, г, д, е, ж, з, а, б, 62, W14);
+		W15 = add4 (SIGMA1_256 (W13), W8, SIGMA0_256 (w0), W15);
+		SHA256ROUND (б, в, г, д, е, ж, з, а, 63, W15);
+
+		/ * Магазин resulsts непосредственно в Тхач * /
+#define store_2 (х, я) \
+		w 0 = load_epi32 ((hInit) [I], (hInit) [I], (hInit) [I], (hInit) [I]); \
+		* (__ m128i *)&(Тхач) [I] [0 + к] = _mm_add_epi32 (w 0, х); 
+
+		store_2 (а, 0);
+		store_2 (б, 1);
+		store_2 (с, 2);
+		store_2 (д, 3);
+		store_2 (е, 4);
+		store_2 (е, 5);
+		store_2 (г, 6);
+		store_2 (ч, 7);
+	}
+
+}
дифференциал --git а / б / main.cpp main.cpp
Индекс ddc359a..d30d642 100755
--- а / main.cpp
+++ б / main.cpp
@@ -2555,8 +2555,10 @@ рядных аннулируются SHA256Transform (недействительный * pstate, недействительный * Pinput, сопзИте пустоту * pinit)
     CryptoPP :: SHA256 :: Transform ((CryptoPP :: word32 *) pstate (CryptoPP :: word32 *) Pinput);
 }
 
+// !!!! NPAR должен соответствовать Npar в cryptopp / sha256.cpp !!!!
+#define НПБР 32
 
-
+ехЬегп недействительная Double_BlockSHA256 (сопзИте пустоту * контактной, недействительный * выпячивание, сопзИте пустоту * pinit, беззнаковое целочисленное значение хеш [8] [НПБРЫ], сопзИте пустоту * init2);
 
 
 аннулированию BitcoinMiner ()
@@ -2701.108 +2703.123 @@ BitcoinMiner недействительными ()
         uint256 hashTarget = CBigNum (). SetCompact (pblock->Nbits) .getuint256 ();
         uint256 hashbuf [2];
         uint256& хэш = * alignup<16>(Hashbuf);
+
+        // Кэш Npar хэшей
+        беззнаковая INT Тхач [8] [НПБРЫ];
+
+        неподписанных Int J;
         петля
         {
-            SHA256Transform (&tmp.hash1 (символ *)&tmp.block + 64, &Midstate);
-            SHA256Transform (&хэш, &tmp.hash1, pSHA256InitState);
+          Double_BlockSHA256 ((символ *)&tmp.block + 64, &tmp.hash1, &Midstate, Тхач, pSHA256InitState);
 
-            если (((беззнаковое короткое *)&хэш) [14] == 0)
+          для (J = 0, J+            если (Тхач [7] [J] == 0)
             {
-                // Byte своп результат после предварительной проверки
-                для (INT I = 0; я < SizeOf (хэш) / 4; я ++)
-                    ((Неподписанные INT *)&хэш) [I] = ByteReverse (((беззнаковое INT *)&хэш) [I]);
-
-                если (хэш <= HashTarget)
+              // Byte своп результат после предварительной проверки
+              для (INT I = 0; я < SizeOf (хэш) / 4; я ++)
+                ((Неподписанные INT *)&хэш) [I] = ByteReverse ((беззнаковое целое) Тхач [I] [J]);
+
+              если (хэш <= HashTarget)
+              {
+                // Double_BlocSHA256 может вычислить только части хэш.
+                // Мы будем вставлять и случайное слово получить реальный хэш.
+                // pblock->nNonce = ByteReverse (tmp.block.nNonce + J);
+                // хэш = pblock->GetHash ();
+
+                pblock->nNonce = ByteReverse (tmp.block.nNonce + J);
+                утверждать (хэш == pblock->GetHash ());
+
+                //// отладки печати
+                Е ("BitcoinMiner: \ п");
+                Е ("доказательство правильности работы нашли \ п хэша:% s \ ntarget:% s \ п", Hash.GetHex () c_str (), hashTarget.GetHex () c_str ())..;
+                pblock->Распечатать();
+                Е ("% s ", DateTimeStrFormat ("% Х% H:% M"., GetTime ()) c_str ());
+                Е ("генерируется% s \ п", FormatMoney (pblock->VTX [0] .vout [0] .nValue) .c_str ());
+
+                SetThreadPriority (THREAD_PRIORITY_NORMAL);
+                CRITICAL_BLOCK (cs_main)
                 {
-                    pblock->nNonce = ByteReverse (tmp.block.nNonce);
-                    утверждать (хэш == pblock->GetHash ());
-
-                        //// отладки печати
-                        Е ("BitcoinMiner: \ п");
-                        Е ("доказательство правильности работы нашли \ п хэша:% s \ ntarget:% s \ п", Hash.GetHex () c_str (), hashTarget.GetHex () c_str ())..;
-                        pblock->Распечатать();
-                        Е ("% s ", DateTimeStrFormat ("% Х% H:% M"., GetTime ()) c_str ());
-                        Е ("генерируется% s \ п", FormatMoney (pblock->VTX [0] .vout [0] .nValue) .c_str ());
-
-                    SetThreadPriority (THREAD_PRIORITY_NORMAL);
-                    CRITICAL_BLOCK (cs_main)
-                    {
-                        если (pindexPrev == pindexBest)
-                        {
-                            // Сохранить ключ
-                            если (! ADDKEY (ключ))
-                                вернуть;
-                            key.MakeNewKey ();
-
-                            // Отслеживание сколько GetData запросов этот блок получает
-                            CRITICAL_BLOCK (cs_mapRequestCount)
-                                mapRequestCount [pblock->GetHash ()] = 0;
-
-                            // Процесс этот блок так же, как если бы мы получили от другого узла
-                            если (! ProcessBlock (NULL, pblock.release ()))
-                                Е ("ОШИБКА в BitcoinMiner, ProcessBlock, блок не принял \ п");
-                        }
-                    }
-                    SetThreadPriority (THREAD_PRIORITY_LOWEST);
-
-                    Сон (500);
-                    ломать;
+                  если (pindexPrev == pindexBest)
+                  {
+                    // Сохранить ключ
+                    если (! ADDKEY (ключ))
+                      вернуть;
+                    key.MakeNewKey ();
+
+                    // Отслеживание сколько GetData запросов этот блок получает
+                    CRITICAL_BLOCK (cs_mapRequestCount)
+                      mapRequestCount [pblock->GetHash ()] = 0;
+
+                    // Процесс этот блок так же, как если бы мы получили от другого узла
+                    если (! ProcessBlock (NULL, pblock.release ()))
+                      Е ("ОШИБКА в BitcoinMiner, ProcessBlock, блок не принял \ п");
+
+                  }
                 }
-            }
+                SetThreadPriority (THREAD_PRIORITY_LOWEST);
 
-            // Обновление NTime каждые несколько секунд
-            сопзЬ неподписанных INT nMask = 0xFFFF;
-            если ((++ tmp.block.nNonce & nMask) == 0)
+                Сон (500);
+                ломать;
+              }
+            }
+          }
+
+          // Обновление нонс
+          tmp.block.nNonce + = НПБРЫ;
+
+          // Обновление NTime каждые несколько секунд
+          сопзЬ неподписанных INT nMask = 0xFFFF;
+          если ((tmp.block.nNonce & nMask) == 0)
+          {
+            // Счетчик хэшей / сек
+            Статическая int64 nTimerStart;
+            Статическая INT nHashCounter;
+            если (nTimerStart == 0)
+              nTimerStart = GetTimeMillis ();
+            еще
+              nHashCounter ++;
+            если (GetTimeMillis () - nTimerStart > 4000)
             {
-                // Счетчик хэшей / сек
-                Статическая int64 nTimerStart;
-                Статическая INT nHashCounter;
-                если (nTimerStart == 0)
-                    nTimerStart = GetTimeMillis ();
-                еще
-                    nHashCounter ++;
+              Статическая CCriticalSection CS;
+              CRITICAL_BLOCK (CS)
+              {
                 если (GetTimeMillis () - nTimerStart > 4000)
                 {
-                    Статическая CCriticalSection CS;
-                    CRITICAL_BLOCK (CS)
-                    {
-                        если (GetTimeMillis () - nTimerStart > 4000)
-                        {
-                            двойная dHashesPerSec = 1000,0 * (nMask + 1) * nHashCounter / (GetTimeMillis () - nTimerStart);
-                            nTimerStart = GetTimeMillis ();
-                            nHashCounter = 0;
-                            Строка strStatus = strprintf ("    % .0f хаш / с", DHashesPerSec / 1000,0);
-                            UIThreadCall (Bind (CalledSetStatusBar, strStatus, 0));
-                            Статическая int64 nLogTime;
-                            если (GetTime () - nLogTime > 30 * 60)
-                            {
-                                nLogTime = GetTime ();
-                                Е ("% s ", DateTimeStrFormat ("% Х% H:% M"., GetTime ()) c_str ());
-                                Е ("hashmeter% 3d процессоры% 6.0f хаш / с \ п", VnThreadsRunning [3], dHashesPerSec / 1000,0);
-                            }
-                        }
-                    }
+                  двойная dHashesPerSec = 1000,0 * (nMask + 1) * nHashCounter / (GetTimeMillis () - nTimerStart);
+                  nTimerStart = GetTimeMillis ();
+                  nHashCounter = 0;
+                  Строка strStatus = strprintf ("    % .0f хаш / с", DHashesPerSec / 1000,0);
+                  UIThreadCall (Bind (CalledSetStatusBar, strStatus, 0));
+                  Статическая int64 nLogTime;
+                  если (GetTime () - nLogTime > 30 * 60)
+                  {
+                    nLogTime = GetTime ();
+                    Е ("% s ", DateTimeStrFormat ("% Х% H:% M"., GetTime ()) c_str ());
+                    Е ("hashmeter% 3d процессоры% 6.0f хаш / с \ п", VnThreadsRunning [3], dHashesPerSec / 1000,0);
+                  }
                 }
-
-                // Проверяет остановку или, если блок должен быть восстановлен
-                если (fShutdown)
-                    вернуть;
-                если (! fGenerateBitcoins)
-                    вернуть;
-                если (fLimitProcessors && vnThreadsRunning [3] > nLimitProcessors)
-                    вернуть;
-                если (vNodes.empty ())
-                    ломать;
-                если (tmp.block.nNonce == 0)
-                    ломать;
-                если (nTransactionsUpdated! = nTransactionsUpdatedLast && GetTime () - nStart > 60)
-                    ломать;
-                если (pindexPrev! = pindexBest)
-                    ломать;
-
-                pblock->Ntime = макс (pindexPrev->GetMedianTimePast () + 1, GetAdjustedTime ());
-                tmp.block.nTime = ByteReverse (pblock->Ntime);
+              }
             }
+
+            // Проверяет остановку или, если блок должен быть восстановлен
+            если (fShutdown)
+              вернуть;
+            если (! fGenerateBitcoins)
+              вернуть;
+            если (fLimitProcessors && vnThreadsRunning [3] > nLimitProcessors)
+              вернуть;
+            если (vNodes.empty ())
+              ломать;
+            если (tmp.block.nNonce == 0)
+              ломать;
+            если (nTransactionsUpdated! = nTransactionsUpdatedLast && GetTime () - nStart > 60)
+              ломать;
+            если (pindexPrev! = pindexBest)
+              ломать;
+
+            pblock->Ntime = макс (pindexPrev->GetMedianTimePast () + 1, GetAdjustedTime ());
+            tmp.block.nTime = ByteReverse (pblock->Ntime);
+          }
         }
     }
 }
дифференциал --git а / Makefile.unix б / Makefile.unix
Индекс 597a0ea..8fb0aa6 100755
--- а / Makefile.unix
+++ б / Makefile.unix
@@ -45,7 +45,8 @@ OBJS = \
     объект / rpc.o \
     объект / init.o \
     cryptopp / объект / sha.o \
-    cryptopp / объект / cpu.o
+    cryptopp / объект / cpu.o \
+		cryptopp / объект / sha256.o
 
 
 всего: Bitcoin
@@ -58,18 +59,20 @@ OBJ /% о:.% .cpp $ (HEADERS) headers.h.gch
 	г ++ -c $ (CFLAGS) -DGUI -o $ @ $<
 
 cryptopp / объект /% о:.. cryptopp /% каст
-	г ++ -c $ (CFLAGS) -O3 -DCRYPTOPP_DISABLE_SSE2 -o $ @ $<
+	г ++ -c $ (CFLAGS) -frename-регистры -funroll-все-петля -fomit-каркасно-указатель -march = родной -msse2 -msse3 -ffast-математические -O3 -o $ @ $<
 
 Bitcoin: $ (Objs) объект / ui.o объект / uibase.o
 	г ++ $ (CFLAGS) -o $ @ $ (LIBPATHS) $ ^ $ (WXLIBS) $ (LIBS)
 
-
 объект / nogui /% о:.% .cpp $ (HEADERS)
 	г ++ -c $ (CFLAGS) -o $ @ $<
 
 bitcoind: $ (OBJS: объект /% = OBJ / nogui /%)
 	г ++ $ (CFLAGS) -o $ @ $ (LIBPATHS) $ ^ $ (LIBS)
 
+Тест: cryptopp / объект / sha.o cryptopp / объект / sha256.o test.cpp
+	  г ++ $ (CFLAGS) -o $ @ $ (LIBPATHS) $ ^ $ (WXLIBS) $ (LIBS)
+
 
 чистить:
 	-гт -f объект / *. о
дифференциал --git а / test.cpp б / test.cpp
Новый режим файла 100755
индекс 0000000..7cab332
--- / DEV / нуль
+++ б / test.cpp
@@ -0,0 1237 @@
+// Copyright (с) 2009-2010 Сатоси Накамото
+// Распространяется под лицензией MIT / X11 см сопровождающего
+// файл license.txt или http://www.opensource.org/licenses/mit-license.php.
+#включают 
+#включают 
+#включают 
+#включают 
+#включают 
+#включают 
+#включают 
+#включают 
+#включают 
+#включают 
+#включают 
+#включают 
+#включают 
+#включают <Память>
+#включают 
+#включают 
+#включают <строка>
+#включают <вектор>
+#включают <список>
+#включают 
+#включают <карта>
+#включают <задавать>
+#включают <алгоритм>
+#включают <числовой>
+#включают <повышение / foreach.hpp>
+#включают <повышение / lexical_cast.hpp>
+#включают <повышение / Кортеж / tuple.hpp>
+#включают <усиление / слияния / контейнер / vector.hpp>
+#включают <повышение / Кортеж / tuple_comparison.hpp>
+#включают <повышение / Кортеж / tuple_io.hpp>
+#включают <повышение / array.hpp>
+#включают <повышение / bind.hpp>
+#включают <повышение / function.hpp>
+#включают <повышение / filesystem.hpp>
+#включают <повышение / файловой системы / fstream.hpp>
+#включают <повышение / алгоритм / string.hpp>
+#включают <повышение / межпроцессного / синхронизации / interprocess_mutex.hpp>
+#включают <повышение / межпроцессного / синхронизации / interprocess_recursive_mutex.hpp>
+#включают <повышение / date_time / григорианский / gregorian_types.hpp>
+#включают <повышение / date_time / posix_time / posix_time_types.hpp>
+#включают 
+#включают 
+используя патезрас;
+используя подталкивание пространства имен;
+#включают "cryptopp / sha.h"
+#включают "strlcpy.h"
+#включают "serialize.h"
+#включают "uint256.h"
+#включают "bignum.h"
+
+#undef Printf
+	шаблон 
+Т * alignup (Т * р)
+{
+	союз
+	{   
+		Т * PTR;
+		size_t н;
+	} И;
+	u.ptr = р;
+	u.n = (u.n + (1-число-байт)) & ~ (1-число-байт);
+	вернуться u.ptr;
+}
+
+Int FormatHashBlocks (пустое * пиксельный буфер, беззнаковое целочисленное значение LEN) 
+{
+	неподписанный символ * PDATA = (неподписанный символ *) пиксельный буфер;
+	без знака INT блоков = 1 + ((Len + 8) / 64); 
+	неподписанные символ * PEND = PDATA + 64 * блоки;
+	MemSet (PDATA + LEN, 0, 64 * блоки - LEN);
+	PDATA [Len] = 0x80;
+	беззнаковое целочисленное значение бит = Len * 8; 
+	PEND [-1] = (биты >> 0) & 0xff;
+	PEND [-2] = (биты >> 8) & 0xff;
+	PEND [-3] = (биты >> 16) & 0xff;
+	PEND [-4] = (биты >> 24) & 0xff;
+	возвращать блоки;
+}
+
+используя CryptoPP :: ByteReverse;
+статические INT detectlittleendian = 1;
+
+#define НПБР 32 
+
+ехЬегп недействительная Double_BlockSHA256 (сопзИте пустоту * контактной, недействительный * выпячивание, сопзИте пустоту * pinit, беззнаковое целочисленное значение хеш [8] [НПБРЫ], сопзИте пустоту * init2);
+
+используя CryptoPP :: ByteReverse;
+
+статические Const беззнаковое INT pSHA256InitState [8] = {0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};
+
+рядный недействительный SHA256Transform (недействительный * pstate, недействительный * Pinput, сопзИте пустоту * pinit)
+{
+	тетср (pstate, pinit, 32); 
+	CryptoPP :: SHA256 :: Transform ((CryptoPP :: word32 *) pstate (CryptoPP :: word32 *) Pinput);
+}
+
+недействительным BitcoinTester (символ * имя файла)
+{
+	Е ("Тест SHA256 начал \ п");
+
+	структура tmpworkspace
+	{
+		структура unnamed2
+		{
+			INT nVersion;
+			uint256 hashPrevBlock;
+			uint256 hashMerkleRoot;
+			неподписанных INT NTime;
+			неподписанных INT Nbits;
+			неподписанных INT nNonce;
+		}
+		блок;
+		символ без знака pchPadding0 [64];
+		uint256 hash1;
+		символ без знака pchPadding1 [64];
+	};
+	обугливается tmpbuf [SizeOf (tmpworkspace) + 16];
+	tmpworkspace& TMP = * (tmpworkspace *) alignup<16>(Tmpbuf);
+
+
+	символ линии [180];
+	ifstream плавник (имя файла);
+	символ * р;
+	неподписанный длинный ИНТ totalhashes = 0;
+	неподписанный долгий INT найдено = 0;
+	clock_t начало, конец;
+	неподписанных долгое INT cpu_time_used;
+	неподписанных INT tnonce;
+	Start = часы ();
+
+	в то время как (fin.getline (линия, 180)) 
+	{
+		Строка в (линии);
+		// Е ("% S \ п", In.c_str ());
+		tmp.block.nVersion = strtol (in.substr (0,8) .c_str (), &р, 16);
+		tmp.block.hashPrevBlock.SetHex (in.substr (8,64));
+		tmp.block.hashMerkleRoot.SetHex (in.substr (64 + 8,64));
+		tmp.block.nTime = strtol (in.substr (128 + 8,8) .c_str (), &р, 16);
+		tmp.block.nBits = strtol (in.substr (128 + 16,8) .c_str (), &р, 16);
+		tnonce = strtol (in.substr (128 + 24,8) .c_str (), &р, 16);
+		tmp.block.nNonce = tnonce;
+
+		неподписанных INT nBlocks0 = FormatHashBlocks (&tmp.block, SizeOf (tmp.block));
+		неподписанных INT nBlocks1 = FormatHashBlocks (&tmp.hash1, SizeOf (tmp.hash1));
+
+		// Byte подкачки все входной буфер
+		для (INT I = 0; я < SizeOf (TMP) / 4; я ++) 
+			((Неподписанные INT *)&TMP) [I] = ByteReverse (((беззнаковое INT *)&TMP) [I]);
+
+		// Precalc первая половина первого хэш, который остается постоянным
+		uint256 midstatebuf [2];
+		uint256& Midstate = * alignup<16>(Midstatebuf);
+		SHA256Transform (&Midstate, &tmp.block, pSHA256InitState);
+
+
+		uint256 hashTarget = CBigNum () SetCompact (ByteReverse (tmp.block.nBits)) getuint256 ()..;
+		// Е ("цель% s \ п", HashTarget.GetHex () c_str ()).
+		uint256 хэш;
+		uint256 hashbuf [2];
+		uint256& refhash = * alignup<16>(Hashbuf);
+
+		беззнаковая INT Тхач [8] [НПБРЫ];
+		Int сделано = 0;
+		неподписанных INT I, J;
+
+		/* Справка */
+		SHA256Transform (&tmp.hash1 (символ *)&tmp.block + 64, &Midstate);
+		SHA256Transform (&refhash, &tmp.hash1, pSHA256InitState);
+		для (INT I = 0; я < SizeOf (refhash) / 4; я ++)
+			((Неподписанные INT *)&refhash) [I] = ByteReverse (((беззнаковое INT *)&refhash) [I]);
+
+		// Е ("ссылка нонс% 08x: \ п% S \ п \ п", Tnonce, refhash.GetHex () c_str ()).
+
+		tmp.block.nNonce = ByteReverse (tnonce) & 0xfffff000;
+
+
+		для(;;)
+		{
+
+			Double_BlockSHA256 ((символ *)&tmp.block + 64, &tmp.hash1, &Midstate, Тхач, pSHA256InitState);
+
+			для (я = 0; я+				/ * Быстрая проверка хэша * /
+				если (Тхач [7] [I] == 0) {
+			// Е ("нашел что-то ... ");
+
+					для (J = 0, J<8; j ++) ((неподписанных INT *)&хэш) [J] = ByteReverse ((беззнаковое целое) Тхач [J] [I]);
+				// Е ("% S \ п", Hash.GetHex () c_str ()).
+
+					если (хэш <= HashTarget)
+					{
+						найдено ++;
+						если (tnonce == ByteReverse (tmp.block.nNonce + I)) {
+							если (хэш == refhash) {
+								Е ("\ Г% лу", найденный);
+								totalhashes + = НПБРЫ;
+								сделано = 1;
+							} Еще {
+								Е ("Хэш не совпадают! \ П");
+							}
+						} Еще {
+							Е ("одноразовое значение не совпадает. % 08x! =% 08x \ п", Tnonce, ByteReverse (tmp.block.nNonce + I));
+						}
+						ломать;
+					}
+				}
+			}
+			если (сделано) перерыв;
+
+			tmp.block.nNonce + = НПБРЫ;
+			totalhashes + = НПБРЫ;
+			если (tmp.block.nNonce == 0) {
+				Е ("ОШИБКА: Hash не найдено: \ п% s \ п", In.c_str ());
+				вернуть;
+			}
+		}
+	}
+	Е ("\ п");
+	конец = часы ();
+	cpu_time_used + = (без знака целое) (окончание - начало);
+	cpu_time_used / = ((CLOCKS_PER_SEC) / 1000);
+	Е ("Найденные решения =% л \ п", найденный);
+	Е ("всего хеши =% л \ п", Totalhashes);
+	Е ("Общее время =% л мс \ п", Cpu_time_used);
+	Е ("Средняя скорость:% л хаш / с \ п", (Totalhashes) / cpu_time_used);
+}
+
+INT основных (INT ARGC, символ * ARGV []) {
+	если (ARGC == 2) {
+		BitcoinTester (ARGV [1]);
+	} еще 
+		Е ("Отсутствует имя файла! \ П");
+	возвращать 0;
+}

30 июля 2010, 9:23:10 PM	# 1
tcatm Сообщения: 337 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Взлом Биткоин адресов. 500 Биткоинов взломаны в "мозговом кошельке" с паролем "bitcoin is awesome" Адрес кошелька: 14NWDXkQwcGN1Pd9fboL8npVynD5SfyJAE Приватный ключ: 5J64pq77XjeacCezwmAr2V1s7snvvJkuAz8sENxw7xCkikceV6e подробнее... Всем кто хочет заработать Биткоины без вложений - рекомендую сайт http://bitcoin-zarabotat.ru Этот патч будет вычислять четыре хэшей на одном ядре с использованием векторных инструкций. Там в тест включены программа, которая проверяет новую хеш-функции от старого поэтому он должен быть правильным. Пластырь против 0.3.6. Повышает Хаш / с примерно 115%. http://pastebin.com/XN1JDb53

30 июля 2010, 9:33:29 PM	# 2
knightmb Сообщения: 322 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Получил 1806 Биткоинов Реальная история. Я считать, что вы уже протестировали предел хэширования перед выполнением начинает страдать от фондового кода? Я просто любопытно, сам.

30 июля 2010, 9:47:22 PM	# 3
tcatm Сообщения: 337 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Производительность на склад коде (как измерено с помощью тестовой программы / бенчмарки) составляет около 1500khash / с. Мой код делает 3500khash / с. Обе цифры для одного ядра. Это хорошо масштабируется, потому что я 128 хэшей сразу и держать datastructures достаточно мал, чтобы поместиться в кэш процессора. У меня есть два локальных атак столкновения, которые втиснуть еще 300khash / с, но они не являются стабильными еще.

30 июля 2010, 9:51:10 PM	# 4
knightmb Сообщения: 322 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Высокий, я должен дать ему попробовать себя тогда.

30 июля 2010, 10:00:24 PM	# 5
tcatm Сообщения: 337 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Скажите мне, если это работает Пожертвования приветствуются. 17asVKkzRGTFvvGH9dMGQaHe78xzfvgSSA

31 июля 2010, 12:29:20 AM	# 6
Satoshi Сообщения: 364 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Это восхитительно... Так вы говорите, вы используете 128-разрядные регистры SIMD четыре 32-битных данных одновременно? Я задавался вопрос о том, что в течение долгого времени, но я не думаю, что можно было бы из-за того, несущее в стоимость соседа.

31 июля 2010, 4:49:33 AM	# 7
knightmb Сообщения: 322 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Чёрт, это означает, что следующий релиз, трудность придется увеличить до 1000 или около того, чтобы не отставать, LOL

31 июля 2010, 10:12:38 AM	# 8
tcatm Сообщения: 337 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Цитата: Satoshi 31 июля 2010, 12:29:20 AM Это восхитительно... Так вы говорите, вы используете 128-разрядные регистры SIMD четыре 32-битных данных одновременно? Я задавался вопрос о том, что в течение долгого времени, но я не думаю, что можно было бы из-за того, несущее в стоимость соседа. Вот как это работает. Четыре 32 разрядные значения в 128 битового вектора а. Они рассчитываются независимо друг от друга, но в то же время. Btw. Почему вы используете этот alignup<16> Функция при __attribute__ ((выровнен (16))) сообщит компилятору выравнивать в compiletime?

31 июля 2010, 1:42:48 PM	# 9
em3rgentOrdr Сообщения: 434 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Хмм ... Я не был в состоянии применить патч (я Noobie). Вот команда, я побежал от Bitcoin-0.3.6 / ЦСИ # пластыря < XN1JDb53.txt Вывод: 1 из 1 ломоть игнорируется (Зачистки задней CRs из пластыря.) латание файл main.cpp Hunk # 1 FAILED в 2555. Hunk # 2 FAILED в 2701. 2 из 2 ханков FAILED (Зачистки задней CRs из пластыря.) латание файл Makefile.unix Hunk # 1 FAILED на 45. Hunk # 2 FAILED на 58. Что собственно команда ввести в Linux? Или у вас есть Linux исполняемые файлы?

31 июля 2010, 2:18:03 PM	# 10
tcatm Сообщения: 337 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 средний клиент будет отправлять все сгенерированные биткоен к определенному адресу @ Em3rgent0rder: я не знаю, почему это не удается, но это должно быть легко исправить его вручную ...

31 июля 2010, 5:18:30 PM	# 11
jgarzik Сообщения: 1484 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Цитата: em3rgentOrdr 31 июля 2010 года, 1:42:48 PM Хмм ... Я не был в состоянии применить патч (я Noobie). Вот команда, я побежал от Bitcoin-0.3.6 / ЦСИ # пластыря < XN1JDb53.txt Вывод: 1 из 1 ломоть игнорируется (Зачистки задней CRs из пластыря.) латание файл main.cpp Hunk # 1 FAILED в 2555. Hunk # 2 FAILED в 2701. 2 из 2 ханков FAILED (Зачистки задней CRs из пластыря.) латание файл Makefile.unix Hunk # 1 FAILED на 45. Hunk # 2 FAILED на 58. Это, безусловно, не относится к стволу SVN. Может быть, tcatm может опубликовать сам main.cpp?

31 июля 2010, 7:17:17 PM	# 13
nelisky Сообщения: 1554 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Если бы вручную исправить, так как я не использую Git для Bitcoin и «патч» не жуют этот формат, я думаю. Во всяком случае, есть почти в два раза скорость на стороне OSX, (i5 2.4, теперь ~ 2400 с ~ 1400), но мой линукс на Q6600 четырехъядерный 2.4Ghz качал ~ 2500 с 0.3.6 (от источника), и теперь, с патчем это ... ~ 2400. Нужно ли настроить что-нибудь, чтобы воспользоваться на это?

31 июля 2010, 8:34:06 PM	# 14
nelisky Сообщения: 1554 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 AHM, позвольте мне исправить себя: на четырехъядерном Linux, я пошел от ~ 4400 с междугородним Svn @ 119 до ~ 2400 с патчем ... не совсем то, что я надеялся после успеха в OSX.

31 июля 2010, 8:57:49 PM	# 15
aceat64 Сообщения: 132 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Цитата: nelisky 31 июля 2010 года, 8:34:06 PM AHM, позвольте мне исправить себя: на четырехъядерном Linux, я пошел от ~ 4400 с междугородним Svn @ 119 до ~ 2400 с патчем ... не совсем то, что я надеялся после успеха в OSX. Я заметил, что то же самое, я пошел приблизительно от 4300 до 2100, когда я тестировал его на Linux.

31 июля 2010, 10:38:29 PM	# 16
tcatm Сообщения: 337 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Какие процессоры вы используете его? Не могли бы вы прислать мне sha256.o (скомпилированный объект алгоритма)?

31 июля 2010, 11:18:07 PM	# 17
nelisky Сообщения: 1554 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Я бегу на Intel Q6600 2.4Ghz, как мне получить файл для вас?

31 июля 2010, 11:30:11 PM	# 18
Mionione Сообщений: 10 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 уход за больными __attribute__ ((выровнено (16))), это не работает с локальными переменным, GCC не выравнивает стек

31 июля 2010, 11:37:02 PM	# 19
tcatm Сообщения: 337 Цитировать по имени цитировать ответ	Re: 4 хэшей параллельно на SSE2 процессоров для 0.3.6 Цитата: nelisky 31 июля 2010, 11:18:07 PM Я бегу на Intel Q6600 2.4Ghz, как мне получить файл для вас? да. Я буду смотреть на код ассемблера. может быть, компилятор сделал что-то "неправильно",

Заголовок