30 июня 2011, 11:59:19 PM   # 1
 
 
Сообщения: 270
Цитировать по имени
цитировать ответ
по умолчанию Re: Altivec / PowerPC / G5 / FPGA

Взлом Биткоин адресов.
500 Биткоинов взломаны в "мозговом кошельке" с паролем "bitcoin is awesome"
Адрес кошелька: 14NWDXkQwcGN1Pd9fboL8npVynD5SfyJAE
Приватный ключ: 5J64pq77XjeacCezwmAr2V1s7snvvJkuAz8sENxw7xCkikceV6e
подробнее...


Всем кто хочет заработать Биткоины без вложений - рекомендую сайт http://bitcoin-zarabotat.ru
Хорошо, это было бы лучше в горнодобывающей промышленности оборудования на форуме, но я новичок в этом так разрешено только разместить здесь.

Еще до графических процессоров были API, чтобы эффективно управлять SIMD для ошеломляюще-параллельных алгоритмов, суперкомпьютеры используются «векторных процессоров» и компании Apple (наряду с PowerPC консорциума) имели свою собственную маленькую версию этого - Altivec.

На G4 и G5 серии PowerPC процессоров, используемых до того Apple, прогнулся и перешел на процессоры Intel, каждый чип был специальный блок вектора обработки под названием Altivec. Основное различие между этим и инструкцией MMX / SSE, которые затем разработанным Intel было одна инструкции называется "вектор переставлять. Я не буду вдаваться в детали архитектуры процессора, но для некоторых алгоритмов - особенно поддающихся параллелизации - в Altivec единиц в PowerPC чипов может работать намного быстрее, чем в противном случае * массово * превосходящими процессоров Intel.

Apple, не был готов платить за надлежащее R&D, так что G5 не стала конкурентоспособной как * общего назначения * CPU, а затем Apple, лег в постель с Intel, который, безусловно, * сделал * плата за R&D.

Однако, опять же, до революции GPU, подобно распределенной вычислительной усилия, когда оптимизированы для Altivec, сделанные Apple, выглядят довольно хорошо. Проект SETI @ Home был лидеры для «недавнего среднего кредита» - который фактически означал «который имеет самое быстрое поле прямо сейчас» - и мне удалось получить номер 1 в мире на некоторое время с моим «последним из PowerMacs» - жидкостного охлаждения Quad G5 монстр Mac. Это было безумием.


Так что ... бы любой из этих старых PowerMacs быть достаточно полезным для Bitcoin добычи? Мое шестое чувство говорит, что нет, так как мой Quad G5 (все еще сидит здесь ...) был специальный кабель, поскольку он нуждался в 2 кВт блок питания или что-то подобным идиотский. Если власть была свободна, и вам необходимо, чтобы нагреть ваш дом, это может иметь смысл ...


Но думать вперед, у меня есть старый приятель из колледжа, который является FPGA свистом и зарабатывает на жизнь в качестве консультанта, обучения инженерных фирм, как проектировать оборудование (большинство из его последних работ было аппаратное сжатие видео / декомпрессия, AFAIK). Там были потоки в горнодобывающей промышленности оборудования форума о том, когда посвященный кремния может сделать GPU станков избыточным, и один из наиболее заметных характеристик имеющегося «образования» FPGA плата является то, что они, как правило, используют чипы PowerPC.

Является ли это просто совпадение, или PowerPC процессоров заметно лучше для обработки потока при низких квотах мощности на-инструкции?


Я не думаю, что старый PowerMac Quad G5s вдруг будет востребован как шахтеры ... но разработка специализированного кремния для добычи полезных ископаемых является справедливой старой инвестиции времени и денег. Много старых Altivec оптимизации кодеров, хотя могли бы легко превратить свои руки в письменном виде G4-зависимый код для добычи полезных ископаемых - таким же образом, что мы имеем OpenCL код. И мне было бы интересно, чтобы более эффективно, чем графические процессоры геймер-спецификации, которые мы в настоящее время используют ли современные Altivec-порошковая G4 PowerPC процессоры (по-прежнему производится в количестве, используемых в сетевых маршрутизаторах по всему миру) работают.

В конце концов, требования к конструкции геймера GPU не действительно сосредоточиться на производительности на ватт. Встроенная PowerPC чипы, используемые в сеть и телекоммуникационной шестерне во всем мире, безусловно, делают. Да, вы должны были бы Нагрузки PowerPC процессоров, чтобы конкурировать с GPU карты топовой ... но будет стоимость энергии будет ниже?
сома сейчас офлайн Пожаловаться на сом   Ответить с цитированием Мультицитирование сообщения от сома Быстрый ответ на сообщение сома


Как заработать Биткоины?
Без вложений. Не майнинг.


11 сентября 2011, 6:39:14 PM   # 2
 
 
Сообщений: 10
Цитировать по имени
цитировать ответ
по умолчанию Re: Altivec / PowerPC / G5 / FPGA

Получил 1806 Биткоинов
Реальная история.





Хорошо, это было бы лучше в горнодобывающей промышленности оборудования на форуме, но я новичок в этом так разрешено только разместить здесь.

Еще до графических процессоров были API, чтобы эффективно управлять SIMD для ошеломляюще-параллельных алгоритмов, суперкомпьютеры используются «векторных процессоров» и компании Apple (наряду с PowerPC консорциума) имели свою собственную маленькую версию этого - Altivec.

На G4 и G5 серии PowerPC процессоров, используемых до того Apple, прогнулся и перешел на процессоры Intel, каждый чип был специальный блок вектора обработки под названием Altivec. Основное различие между этим и инструкцией MMX / SSE, которые затем разработанным Intel было одна инструкции называется "вектор переставлять. Я не буду вдаваться в детали архитектуры процессора, но для некоторых алгоритмов - особенно поддающихся параллелизации - в Altivec единиц в PowerPC чипов может работать намного быстрее, чем в противном случае * массово * превосходящими процессоров Intel.

Apple, не был готов платить за надлежащее R&D, так что G5 не стала конкурентоспособной как * общего назначения * CPU, а затем Apple, лег в постель с Intel, который, безусловно, * сделал * плата за R&D.

Однако, опять же, до революции GPU, подобно распределенной вычислительной усилия, когда оптимизированы для Altivec, сделанные Apple, выглядят довольно хорошо. Проект SETI @ Home был лидеры для «недавнего среднего кредита» - который фактически означал «который имеет самое быстрое поле прямо сейчас» - и мне удалось получить номер 1 в мире на некоторое время с моим «последним из PowerMacs» - жидкостного охлаждения Quad G5 монстр Mac. Это было безумием.


Так что ... бы любой из этих старых PowerMacs быть достаточно полезным для Bitcoin добычи? Мое шестое чувство говорит, что нет, так как мой Quad G5 (все еще сидит здесь ...) был специальный кабель, поскольку он нуждался в 2 кВт блок питания или что-то подобным идиотский. Если власть была свободна, и вам необходимо, чтобы нагреть ваш дом, это может иметь смысл ...

Привет сома,

Iґm еще использует G4 ноутбук PowerBook от Apple, и также заинтересованы, как хорошо Altivec устройство будет выполнять. В настоящее время Iґm перевод 4way SSE код в Altivec код. Моя самая первая версия уже работает с jgarzikґs cpuminer:

Мой файл sha256_altivec_4way.c:
Код:
// Copyright (с) 2010 Сатоси Накамото
// Copyright (с) 2011 Жиль Риш
// Распространяется под лицензией MIT / X11 см сопровождающего
// файл license.txt или http://www.opensource.org/licenses/mit-license.php.


// 4-полосные 128-битный Altivec SHA-256,
// на основе tcatm в 4-полосная 128-битным SSE2 SHA-256
//


#включают "cpuminer-config.h"
#включают "miner.h"

#ifdef WANT_ALTIVEC_4WAY

#включают
#включают

//#включают

#включают
#включают

#define НПБР 32

статическая сила DoubleBlockSHA256 (сопзИте пустоту * контактная, недействительный * выпячивание, сопзИте пустоту * pinit, беззнаковое целочисленное значение хеш [8] [НПБРЫ], сопзИте пустоту * init2);

статические константные без знака 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
};


статический встроенный вектор без знака INT Ch (Const вектор беззнаковое целочисленное значение Ь, Const вектор беззнаковое целочисленное значение с, Const вектор без знака INT г) {
    вернуть vec_sel (д, с, б);
}

статический встроенный вектор беззнаковое INT Maj (Const вектор беззнаковое целочисленное значение Ь, Const вектор беззнаковое целочисленное значение с, Const вектор без знака INT г) {
    вернуть vec_sel (B, C, vec_xor (б, г));
}

/ * RotateRight (х, п): = RotateLeft (х, 32-п) * /
/ * SHA256 функции * /
#define BIGSIGMA0_256 (х) (vec_xor (vec_xor (vec_rl ((х), (вектор беззнаковое целое) (32-2)), vec_rl ((х), (вектор беззнаковое целое) (32-13))), vec_rl ( (х), (вектор беззнаковое целое) (32-22))))
#define BIGSIGMA1_256 (х) (vec_xor (vec_xor (vec_rl ((х), (вектор беззнаковое целое) (32-6)), vec_rl ((х), (вектор беззнаковое целое) (32-11))), vec_rl ( (х), (вектор беззнаковое целое) (32-25))))

#define SIGMA0_256 (х) (vec_xor (vec_xor (vec_rl ((х), (вектор беззнаковое целое) (32- 7)), vec_rl ((х), (вектор беззнаковое целое) (32-18))), vec_sr ( (х), (вектор беззнаковое целое) (3))))
#define SIGMA1_256 (х) (vec_xor (vec_xor (vec_rl ((х), (вектор беззнаковое целое) (32-17)), vec_rl ((х), (вектор беззнаковое целое) (32-19))), vec_sr ( (х), (вектор беззнаковое целое) (10))))

#define add4 (x0, x1, x2, x3) vec_add (vec_add (x0, x1), vec_add (x2, x3))
#define add5 (x0, x1, x2, x3, x4) vec_add (add4 (x0, x1, x2, x3), x4)

#define SHA256ROUND (а, б, в, г, д, е, ж, з, и, ш) \
    Т1 = add5 (ч, BIGSIGMA1_256 (е), гл (д, е, ж), (вектор беззнаковое целое) (sha256_consts [I], sha256_consts [I], sha256_consts [I], sha256_consts [I]), ш); \
    д = vec_add (д, Т1); \
    ч = vec_add (Т1, vec_add (BIGSIGMA0_256 (а), майор (а, б, в)));


статические Const беззнаковое INT pSHA256InitState [8] =
{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};


неподписанный INT scanhash_altivec_4way (интермедиат thr_id, Const символ без знака * pmidstate,
неподписанный символ * PDATA,
неподписанный символ * phash1, неподписанный символ * phash,
Const символ без знака * ptarget,
uint32_t max_nonce, беззнаковое долго * nHashesDone)
{
    беззнаковое INT * nNonce_p = (беззнаковое INT *) (PDATA + 12);
    беззнаковое целочисленное значение Nonce = 0;

    work_restart [thr_id] .restart = 0;

    для (;;)
    {
        беззнаковая INT Тхач [9] [НПБРЫ] __attribute __ ((выровнено (128)));
Int J, IC;

* NNonce_p = Nonce;

        DoubleBlockSHA256 (PDATA, phash1, pmidstate, Тхач, pSHA256InitState);

        для (J = 0, J < NPAR; j ++)
        {
            если (маловероятно (Тхач [7] [J] == 0))
            {
Int я;

                для (я = 0; я < 32/4; я ++)
                    ((Беззнаковое INT *) phash) [I] = Тхач [I] [J];
               
если (fulltest (phash, ptarget)) {
* NHashesDone = Nonce;
* NNonce_p = Nonce + J;
                вернуться нонсом + J;
}
            }
        }

        если ((нонс >= Max_nonce) || work_restart [thr_id] .restart)
        {
            * NHashesDone = Nonce;
            вернуться -1;
        }

        Nonce + = НПБРЫ;
    }
}


статическая сила DoubleBlockSHA256 (сопзИте пустоту * контактная, недействительный * коврик, сопзИте пустоту * предварительно, беззнаковая INT Тхач [9] [НПБРЫ], сопзИте пустоту * INIT)
{
    беззнаковое INT * В = (беззнаковое INT *) контактный;
    беззнаковое INT * Pad = (беззнаковое INT *) площадку;
    неподписанных INT * hPre = (беззнаковое INT *) заранее;
    неподписанных INT * hInit = (беззнаковое INT *) инициализации;
    неподписанных INT / * I, J, * / к;

    / * Векторы, используемые при расчете * /
    вектор беззнаковое целочисленное значение w0, w1, w2, w3, w4, W5, W6, W7, W8, W9, W10, W11, W12, W13, W14, W15;
    вектор без знака INT Т1;
    вектор без знака INT а, б, в, г, д, е, ж, з;
    вектор беззнаковое целочисленное значение одноразового номера, preNonce;

    / * Смещение для временного значения вектора * /
    вектор без знака Int смещение = (вектор беззнаковое целое) (0, 1, 2, 3);
   
    preNonce = vec_add ((вектор беззнаковое целое) (В работе [3], В работе [3], В работе [3], В [3]), смещение);

   для (к = 0; K   {
        w 0 = (вектор беззнаковое целое) (В [0], В [0], В [0], В [0]);
        w 1 = (вектор беззнаковое целое) (В работе [1], В [1], В [1], В [1]);
        ш2 = (вектор беззнаковое целое) (В работе [2], В [2], В [2], В [2]);
        // W3 = (вектор беззнаковое целое) (В работе [3], В работе [3], В работе [3], В [3]); нонс позже будет взломан в хэш
        W4 = (вектор беззнаковое целое) (В [4], В [4], В [4], В [4]);
        W5 = (вектор беззнаковое целое) (В работе [5], В [5], В [5], В [5]);
        W6 = (вектор беззнаковое целое) (В работе [6], В [6], В [6], В [6]);
        W7 = (вектор беззнаковое целое) (В работе [7], В [7], В [7], В [7]);
        W8 = (вектор беззнаковое целое) (В работе [8], В [8], В [8], в [8]);
        W9 = (вектор беззнаковое целое) (В работе [9], в [9], в [9], в [9]);
        W10 = (вектор беззнаковое целое) (В работе [10], [10], [10], в [10]);
        W11 = (вектор беззнаковое целое) (В работе [11], [11], [11], в [11]);
        W12 = (вектор беззнаковое целое) (В работе [12], [12], [12], в [12]);
        W13 = (вектор беззнаковое целое) (В работе [13], [13], [13], в [13]);
        W14 = (вектор беззнаковое целое) (В работе [14], [14], [14], в [14]);
        W15 = (вектор беззнаковое целое) (В работе [15], [15], [15], в [15]);

        / * Взломать в одноразовом номер низких байт w3 * /
Nonce = vec_add (preNonce (вектор беззнаковое целое) (к, к, к, к));

        W3 = Nonce;
        // Е ("W3:% 08vlx \ п", W3);

        а = (вектор беззнаковое целое) (hPre [0], hPre [0], hPre [0], hPre [0]);
        б = (вектор беззнаковое целое) (hPre [1], hPre [1], hPre [1], hPre [1]);
        с = (вектор беззнаковое целое) (hPre [2], hPre [2], hPre [2], hPre [2]);
        d = (вектор беззнаковое целое) (hPre [3], hPre [3], hPre [3], hPre [3]);
        е = (вектор беззнаковое целое) (hPre [4], hPre [4], hPre [4], hPre [4]);
        F = (вектор беззнаковое целое) (hPre [5], hPre [5], hPre [5], hPre [5]);
        г = (вектор беззнаковое целое) (hPre [6], hPre [6], hPre [6], hPre [6]);
        ч = (вектор беззнаковое целое) (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) \
        T1 = (вектор беззнаковое целое) ((hPre) [I], (hPre) [I], (hPre) [I], (hPre) [I]); \
        приемник = vec_add (Т1, х);

        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);

        / * Конец первого SHA256 раунд * /

        W8 = (вектор беззнаковое целое) (Pad [8], Pad [8], Pad [8], Pad [8]);
        W9 = (вектор беззнаковое целое) (Pad [9], Pad [9], Pad [9], Pad [9]);
        W10 = (вектор беззнаковое целое) (Pad [10], Pad [10], Pad [10], Pad [10]);
        W11 = (вектор беззнаковое целое) (Pad [11], Pad [11], Pad [11], Pad [11]);
        W12 = (вектор беззнаковое целое) (Pad [12], Pad [12], Pad [12], Pad [12]);
        W13 = (вектор беззнаковое целое) (Pad [13], Pad [13], Pad [13], Pad [13]);
        W14 = (вектор беззнаковое целое) (Pad [14], Pad [14], Pad [14], Pad [14]);
        W15 = (вектор беззнаковое целое) (Pad [15], Pad [15], Pad [15], Pad [15]);

        а = (вектор беззнаковое целое) (hInit [0], hInit [0], hInit [0], hInit [0]);
        б = (вектор беззнаковое целое) (hInit [1], hInit [1], hInit [1], hInit [1]);
        с = (вектор беззнаковое целое) (hInit [2], hInit [2], hInit [2], hInit [2]);
        d = (вектор беззнаковое целое) (hInit [3], hInit [3], hInit [3], hInit [3]);
        е = (вектор беззнаковое целое) (hInit [4], hInit [4], hInit [4], hInit [4]);
        F = (вектор беззнаковое целое) (hInit [5], hInit [5], hInit [5], hInit [5]);
        г = (вектор беззнаковое целое) (hInit [6], hInit [6], hInit [6], hInit [6]);
        ч = (вектор беззнаковое целое) (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);

/ * Пропустить последние 3 раундов; нет необходимости H == 0 * /
/ * # Если 0
        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);
# ENDIF * /

        / * Магазин resulsts непосредственно в Тхач * /
#define store_2 (х, я) \
        w 0 = (вектор беззнаковое целое) (hInit [I], hInit [I], hInit [I], hInit [I]); \
        vec_st (vec_add (w 0, х), 0,&Тхач [I] [K]);

        store_2 (а, 0);
        store_2 (б, 1);
        store_2 (с, 2);
        store_2 (д, 3);
        store_2 (е, 4);
        store_2 (е, 5);
        store_2 (г, 6);
        store_2 (ч, 7);

        vec_st (Nonce, 0,&Тхач [8] [K]);
        / * Запись результатов в массив время интенсивной * /
        / * -> попробовать, если itґs быстрее, чтобы сравнить полученные результаты с целью внутри этой функции * /
    }

}

#endif / * WANT_ALTIVEC_4WAY * /

Iґll отправить файл автору cpuminer. Помимо этого файла необходимо также изменить две функции внутри файла CPU-miner.c, так как код для прямой порядок байтов машин и PowerPC большой обратный порядок байт:
Код:
статическая BOOL work_decode (Const json_t * Вал, структура работа * работа) {
    если (маловероятно (! jobj_binary (VAL, "Midstate",
            Работа->Midstate, SizeOf (работы->Midstate)))) {
        applog (LOG_ERR, "JSON Inval Midstate");
        Гото err_out;
    }

    если (маловероятно (! jobj_binary (VAL, "данные", Работа->Данные, SizeOf (работы->данные)))) {
        applog (LOG_ERR, "JSON Inval данных");
        Гото err_out;
    }

    если (маловероятно (! jobj_binary (VAL, "hash1", Работа->hash1, SizeOf (работы->hash1)))) {
        applog (LOG_ERR, "JSON Inval hash1");
        Гото err_out;
    }

    если (маловероятно (! jobj_binary (VAL, "цель", Работа->мишень, SizeOf (работы->мишень)))) {
        applog (LOG_ERR, "JSON Inval цель");
        Гото err_out;
    }

    MemSet (работы->хэш, 0, SizeOf (работы->хэш));

#ifdef __BIG_ENDIAN__
    INT swapcounter = 0;
    для (swapcounter = 0; swapcounter < 32; swapcounter ++)
        (((Uint32_t *) (работы->данные)) [swapcounter]) = swab32 (((uint32_t *) (работы->данные)) [swapcounter]);
    для (swapcounter = 0; swapcounter < 16; swapcounter ++)
        (((Uint32_t *) (работы->hash1)) [swapcounter]) = swab32 (((uint32_t *) (работы->hash1)) [swapcounter]);
    для (swapcounter = 0; swapcounter < 8; swapcounter ++)
        (((Uint32_t *) (работы->Midstate)) [swapcounter]) = swab32 (((uint32_t *) (работы->Midstate)) [swapcounter]);
    для (swapcounter = 0; swapcounter < 8; swapcounter ++)
        (((Uint32_t *) (работы->мишень)) [swapcounter]) = swab32 (((uint32_t *) (работы->мишень)) [swapcounter]);
#endif

    возвращает истину;

err_out:
    вернуться ложным;
}

статическая BOOL submit_upstream_work (CURL * локон, Const структуры работа * работа) {
    символ * hexstr = NULL;
    json_t * вал, * Рез;
    символ с [345];
    BOOL гс = ложь;

#ifdef __BIG_ENDIAN__
    INT swapcounter;
    для (swapcounter = 0; swapcounter < 32; swapcounter ++)
        (((Uint32_t *) (работы->данные)) [swapcounter]) = swab32 (((uint32_t *) (работы->данные)) [swapcounter]);
#endif

    / * Сборка шестнадцатеричная строка * /
    hexstr = bin2hex (работы->Данные, SizeOf (работы->данные));
    если (что маловероятно (! hexstr)) {
        applog (LOG_ERR, "submit_upstream_work ООМ");
        Гото вне;
    }

    / * Создать запрос JSON-RPC * /
    Sprintf (с,
            "{\"метод \": \"getwork \"\"Титулы \": [\"% S \" ], \"Я бы\": 1} \ г \ п",
            hexstr);

    если (opt_debug)
        applog (LOG_DEBUG, "DBG: отправка RPC вызов:% s", С);

    / * Вопрос запрос JSON-RPC * /
    Val = json_rpc_call (локон, rpc_url, rpc_userpass, с, ложь, ложь);
    если (что маловероятно (! Вэл)) {
        applog (LOG_ERR, "submit_upstream_work json_rpc_call не удалось");
        Гото вне;
    }

    разреш = json_object_get (вал, "результат");

    applog (LOG_INFO, "Доказательство РАБОТЫ РЕЗУЛЬТАТ:% s",
            json_is_true (разрешение)? "правда (яй !!!)" : "ложь (booooo)");

    json_decref (вал);

    RC = TRUE;

вне:
    бесплатно (hexstr);
    вернуться Гс;
}
Эти изменения могут быть также полезны, если вы хотите использовать cpuminer на ARM процессоре.



С Уважением,
жилль
Roodemol сейчас офлайн Пожаловаться на Roodemol   Ответить с цитированием Мультицитирование сообщения от Roodemol Быстрый ответ на сообщение Roodemol

23 октября 2011, 11:34:55 AM   # 3
 
 
Сообщений: 10
Цитировать по имени
цитировать ответ
по умолчанию Re: Altivec / PowerPC / G5 / FPGA

Здравствуй,

предлагаемый были объединены в cgminer ().

Не стесняйтесь, чтобы проверить это. Любая обратная связь приветствуется.

С Уважением,
жилль
Roodemol сейчас офлайн Пожаловаться на Roodemol   Ответить с цитированием Мультицитирование сообщения от Roodemol Быстрый ответ на сообщение Roodemol



Как заработать Биткоины?

Bitcoin Wallet * Portefeuille Bitcoin * Monedero Bitcoin * Carteira Bitcoin * Portafoglio Bitcoin * Bitcoin Cüzdan * 比特币钱包

bitcoin-zarabotat.ru
Почта для связи: bitcoin-zarabotat.ru@yandex.ru

3HmAQ9FkRFk6HZGuwExYxL62y7C1B9MwPW