Bitcoin Forum
December 04, 2016, 04:34:27 PM *
News: Latest stable version of Bitcoin Core: 0.13.1  [Torrent].
 
   Home   Help Search Donate Login Register  
Pages: « 1 ... 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 [74] 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 ... 830 »
  Print  
Author Topic: OFFICIAL CGMINER mining software thread for linux/win/osx/mips/arm/r-pi 4.9.2  (Read 4816951 times)
This is a self-moderated topic. If you do not want to be moderated by the person who started this topic, create a new topic.
-ck
Moderator
Legendary
*
Offline Offline

Activity: 1988


Ruu \o/


View Profile WWW
September 14, 2011, 04:13:19 AM
 #1461

I've been having problems with cgminer crashing after about 1-3 hours.  I'm running on Windows 7 x64 with a pair of Sapphire HD 5770 cards.  I launch cgminer using a scheduled task with the following command line in a batch file:

Code:
cgminer -o http://<pool0>:8332 -u <username> -p <passwd> -o http://<pool1>:8332 -u <username> -p <passwd> --enable-cpu -t 4 -a 4way --text-only -l 30 > "_logs\%date:~10,4%%date:~4,2%%date:~7,2%_%time:~0,2%%time:~3,2%%time:~6,2%.log" 2>&1

Eventually Windows pops-up a dialog saying the program has crashed.  The pattern I've seen is cgminer is always trying to perform a pool fail-over right before the crash:

Code:
[2011-09-13 17:15:47] Pool 0 http://<pool0>:8332 not responding!                   
[2011-09-13 17:15:47] Switching to http://<pool1>:8332                   
[2011-09-13 17:15:47] Pool 0 http://<pool0>:8332 recovered                   
[2011-09-13 17:15:47] Switching to http://<pool0>:8332

That's the last message before the program crashes.  Windows reports the following regarding the crash:

Code:
Problem signature:
  Problem Event Name:    APPCRASH
  Application Name:    cgminer.exe
  Application Version:    0.0.0.0
  Application Timestamp:    4e6c4b8a
  Fault Module Name:    libpthread-2.dll
  Fault Module Version:    2.8.0.0
  Fault Module Timestamp:    4b7d316b
  Exception Code:    c0000005
  Exception Offset:    00001b73
  OS Version:    6.1.7601.2.1.0.256.1
  Locale ID:    1033
  Additional Information 1:    0a9e
  Additional Information 2:    0a9e372d3b4ad19135b953a78882e789
  Additional Information 3:    0a9e
  Additional Information 4:    0a9e372d3b4ad19135b953a78882e789

Any ideas why this is happening?
Likely this is a dereferencing error somewhere in my code, but being on windows the bug report is largely unusable unfortunately since the windows crashes are un-debuggable.

Should anyone be experiencing this on linux, please enable core dumps and get a stacktrace if you know how. If not, contact me.

Primary developer/maintainer for cgminer and ckpool/ckproxy.
Pooled mine at kano.is, solo mine at solo.ckpool.org
-ck
1480869267
Hero Member
*
Offline Offline

Posts: 1480869267

View Profile Personal Message (Offline)

Ignore
1480869267
Reply with quote  #2

1480869267
Report to moderator
1480869267
Hero Member
*
Offline Offline

Posts: 1480869267

View Profile Personal Message (Offline)

Ignore
1480869267
Reply with quote  #2

1480869267
Report to moderator
Be very wary of relying on JavaScript for security on sites such as blockchain.info and brainwallet.org. The site can change the JavaScript at any time unless you take unusual precautions, and browsers are not generally known for their airtight security.
Advertised sites are not endorsed by the Bitcoin Forum. They may be unsafe, untrustworthy, or illegal in your jurisdiction. Advertise here.
1480869267
Hero Member
*
Offline Offline

Posts: 1480869267

View Profile Personal Message (Offline)

Ignore
1480869267
Reply with quote  #2

1480869267
Report to moderator
1480869267
Hero Member
*
Offline Offline

Posts: 1480869267

View Profile Personal Message (Offline)

Ignore
1480869267
Reply with quote  #2

1480869267
Report to moderator
1480869267
Hero Member
*
Offline Offline

Posts: 1480869267

View Profile Personal Message (Offline)

Ignore
1480869267
Reply with quote  #2

1480869267
Report to moderator
SlapHappy
Newbie
*
Offline Offline

Activity: 9


View Profile
September 14, 2011, 04:51:53 AM
 #1462

...
Any ideas why this is happening?
You should supply the version number of what you are running.
It says on the screen when you start.
My bad.  I'm currently using cgminer 2.0.2 but I've had this happening since 1.6.x.
mmortal03
Legendary
*
Offline Offline

Activity: 1395


View Profile
September 14, 2011, 05:58:04 PM
 #1463

Just sent you a 3.63 donation!

Also, an issue I just noticed with the program yesterday (I'm using 2.0.2) was a scenario where both mining threads went dead, and after I tried manually restarting the GPU with that feature you already have built in, it didn't help.  However, then I closed out cgminer and opened it back up, and it had no problems mining again. Based on this, can you build into the program an option to have the program automatically restart itself if the mining threads go dead?  Of course, it should first try to automatically restart the GPU, but doesn't it already try this? I think this latter complete restart could help work around a lot of issues where mining still gets stuck.  Thanks!
xcloudx01
Newbie
*
Offline Offline

Activity: 14


View Profile
September 14, 2011, 07:59:39 PM
 #1464

When i'm using this each gpu uses a full cpu core all the time. Is it supposed to or is something wrong on my end?
DiabloD3
Legendary
*
Offline Offline

Activity: 1162


DiabloMiner author


View Profile WWW
September 14, 2011, 08:27:31 PM
 #1465

When i'm using this each gpu uses a full cpu core all the time. Is it supposed to or is something wrong on my end?

Driver bug.

-ck
Moderator
Legendary
*
Offline Offline

Activity: 1988


Ruu \o/


View Profile WWW
September 14, 2011, 09:57:42 PM
 #1466

Just sent you a 3.63 donation!

Also, an issue I just noticed with the program yesterday (I'm using 2.0.2) was a scenario where both mining threads went dead, and after I tried manually restarting the GPU with that feature you already have built in, it didn't help.  However, then I closed out cgminer and opened it back up, and it had no problems mining again. Based on this, can you build into the program an option to have the program automatically restart itself if the mining threads go dead?  Of course, it should first try to automatically restart the GPU, but doesn't it already try this? I think this latter complete restart could help work around a lot of issues where mining still gets stuck.  Thanks!
Thanks very much for your donation!

I can't do that because there are many scenarios where a dead device implies a driver hang. Restarting cgminer in that circumstance will crash everything since the problem is at such a low level that the system would normally need a reboot. The idea is to only soft restart devices that have soft failed and then recover. The default behaviour has to be the least harmful. Some people grep the output of cgminer and force a restart if they get the DEAD message.

Primary developer/maintainer for cgminer and ckpool/ckproxy.
Pooled mine at kano.is, solo mine at solo.ckpool.org
-ck
phorensic
Hero Member
*****
Offline Offline

Activity: 630



View Profile
September 15, 2011, 06:40:19 AM
 #1467

Holy moly this software is amazing! Why didn't I get off my lazy butt and trying this out a long time ago instead of sticking with guiminer?  I just replaced guiminer AND Sapphire Trixx with *one* program.  And I'm able to use just one mining account for all GPU's instead of separate like other programs.  *happy dance*
simonk83
Hero Member
*****
Offline Offline

Activity: 896


View Profile
September 15, 2011, 06:58:05 AM
 #1468

ckolivas, I'm having specific issues that I PM'd you about another day, and to cut a long story short I can't get it working properly and I have to stick with cgminer 1.5.6 as that works great.  Unfortuantely (for me), I adore the overclocking functionality as it works way better than MSI Afterburner with regards to keeping the cards at a constant temp.

What are the chances of you splitting the overclocking stuff into a separate standalone little proggy, so that I can run that to handle the cards, and run 1.5.6 to handle the mining?

Probably a big ask I know, but there'd be a donation in it for you at the very least Smiley
bitlane
Internet detective
Sr. Member
****
Offline Offline

Activity: 462


I heart thebaron


View Profile
September 15, 2011, 07:26:38 AM
 #1469

PING: Windows Miners (perhaps Win7 x64) ....or anyone who has had VOLTAGE CONTROL problems.

I can't seem to get VOLTAGE CONTROL working on any of my cards. Could anyone offer advice ?

I am using the latest version of CGMiner w/11.8 Drivers and have a selection of 5770, 6870 & 6950 Cards that do not seem to recognize the voltage flag in my BAT files. I have also tried changing values INSIDE of CGMiner and again, failed....so, same results.
I know that a few of my cards will never work properly (Asus 6950 DCU II cards) in terms of voltage control, but most of my 5770 & 6870 cards are all REFERENCE models and SHOULD work....but seemingly, do not.

I simply added:
Quote
--gpu-vddc 1.2
....along with my regular settings and none of the cards seemed to be affected by the voltage increase as confirmed in CGMiner & GPU-Z.

Complete BAT file looks like:
Quote
cgminer -o http://pool:port -u username -p password -I 8 -Q 10 --auto-fan --gpu-vddc 1.2 --gpu-engine 975 --gpu-memclock 300 --temp-target 70

Everything works EXCEPT for Voltage increases.....Help ?

Thanks in advance,
Allan

xcloudx01
Newbie
*
Offline Offline

Activity: 14


View Profile
September 15, 2011, 08:28:02 AM
 #1470

When i'm using this each gpu uses a full cpu core all the time. Is it supposed to or is something wrong on my end?

Driver bug.

Any idea how to fix it?
DiabloD3
Legendary
*
Offline Offline

Activity: 1162


DiabloMiner author


View Profile WWW
September 15, 2011, 08:42:25 AM
 #1471

When i'm using this each gpu uses a full cpu core all the time. Is it supposed to or is something wrong on my end?

Driver bug.

Any idea how to fix it?

Bitch at AMD until they fix it.

DiabloD3
Legendary
*
Offline Offline

Activity: 1162


DiabloMiner author


View Profile WWW
September 15, 2011, 08:43:30 AM
 #1472

PING: Windows Miners (perhaps Win7 x64) ....or anyone who has had VOLTAGE CONTROL problems.

I can't seem to get VOLTAGE CONTROL working on any of my cards. Could anyone offer advice ?

I am using the latest version of CGMiner w/11.8 Drivers and have a selection of 5770, 6870 & 6950 Cards that do not seem to recognize the voltage flag in my BAT files. I have also tried changing values INSIDE of CGMiner and again, failed....so, same results.
I know that a few of my cards will never work properly (Asus 6950 DCU II cards) in terms of voltage control, but most of my 5770 & 6870 cards are all REFERENCE models and SHOULD work....but seemingly, do not.

I simply added:
Quote
--gpu-vddc 1.2
....along with my regular settings and none of the cards seemed to be affected by the voltage increase as confirmed in CGMiner & GPU-Z.

Complete BAT file looks like:
Quote
cgminer -o http://pool:port -u username -p password -I 8 -Q 10 --auto-fan --gpu-vddc 1.2 --gpu-engine 975 --gpu-memclock 300 --temp-target 70

Everything works EXCEPT for Voltage increases.....Help ?

Thanks in advance,
Allan

You can't change the voltage on non-ref cards that use VRMs that the driver doesn't understand how to talk to. Do not try using RBE to edit the firmware either, you can easily brick or damage a card that way.

-ck
Moderator
Legendary
*
Offline Offline

Activity: 1988


Ruu \o/


View Profile WWW
September 15, 2011, 09:23:28 AM
 #1473

Holy moly this software is amazing! Why didn't I get off my lazy butt and trying this out a long time ago instead of sticking with guiminer?  I just replaced guiminer AND Sapphire Trixx with *one* program.  And I'm able to use just one mining account for all GPU's instead of separate like other programs.  *happy dance*
Lovely feedback, thanks  Cheesy

Primary developer/maintainer for cgminer and ckpool/ckproxy.
Pooled mine at kano.is, solo mine at solo.ckpool.org
-ck
mmortal03
Legendary
*
Offline Offline

Activity: 1395


View Profile
September 15, 2011, 09:23:56 AM
 #1474

Thanks very much for your donation!

I can't do that because there are many scenarios where a dead device implies a driver hang. Restarting cgminer in that circumstance will crash everything since the problem is at such a low level that the system would normally need a reboot. The idea is to only soft restart devices that have soft failed and then recover. The default behaviour has to be the least harmful. Some people grep the output of cgminer and force a restart if they get the DEAD message.

Gotcha, so is the DEAD text (all capitals) going to appear in the quiet mode status output when logging the stderr (2>) to a text file, or do I need to log the verbose output to get that?

I'd like to be able to log the least amount of text possible that will contain DEAD, and run the following to check for it in the log every so often:

Code:
grep DEAD mylog.txt && restart_cgminer.bat

I'm using grep for Windows, and for those who don't know DOS, what that does is the following:

If the text "DEAD" is found anywhere in mylog.txt, grep produces a successful output to stdout, triggering the part after the ampersands to run.  My .bat file will be written to simply taskkill the current instance of cgminer, clear mylog.txt, and start a new instance of cgminer.
-ck
Moderator
Legendary
*
Offline Offline

Activity: 1988


Ruu \o/


View Profile WWW
September 15, 2011, 09:26:28 AM
 #1475

You do not need to go into quiet mode to be able to log. In fact, you should be able to still log stderr while having the curses formatted text output as cgminer is designed to do those independently. Yes, the DEAD in uppercase should only appear when a device is declared dead.

Primary developer/maintainer for cgminer and ckpool/ckproxy.
Pooled mine at kano.is, solo mine at solo.ckpool.org
-ck
os2sam
Legendary
*
Offline Offline

Activity: 1918


Think for yourself


View Profile
September 15, 2011, 11:49:30 AM
 #1476

When i'm using this each gpu uses a full cpu core all the time. Is it supposed to or is something wrong on my end?

Driver bug.

Any idea how to fix it?

Bitch at AMD until they fix it.

Or use Catalyst 11.6 or earlier.

A: Because it messes up the order in which people normally read text.
Q: Why is top-posting such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?
Boyd
Newbie
*
Offline Offline

Activity: 16


View Profile
September 15, 2011, 12:45:38 PM
 #1477

First of all - hello everybody, and second ... I already tried to look for help in newbie section, but unfortunately nobody was able to give me any answers (0 replies) so hoping that more experienced users will do ... Wink

Since the version 2.x cgminer has a module which allows to control GPU settings (clocks, voltage etc), however in my case I am not able to activate this (cgminer looks exactly the same as in previous versions despite of fact that required *.h files from /ADL_SDK/include are already in cgminer's ADL_SDK directory)
System based on: 2x HD6870(Asus) & 2x HD6950(MSI), ubuntu 11.04 x64, Catalyst 11.6, SDK 2.5, required files copied from ADL_SDK_3.0

I will be gratefull for any hints/advices regarding additional steps required to activate this. Thx in advance.

Below output from CFLAGS="-O2 -Wall -march=native" ./configure

Quote
------------------------------------------------------------------------
cgminer 2.0.2
------------------------------------------------------------------------


Configuration Options Summary:

  OpenCL...............: FOUND. GPU mining support enabled
  ADL..................: SDK found, GPU monitoring support enabled
  ASM..................: true

Compilation............: make (or gmake)
  CPPFLAGS.............:
  CFLAGS...............: -O2 -Wall -march=native
  LDFLAGS..............:  -lpthread -ldl

Installation...........: make install (as root if needed, with 'su' or 'sudo')
  prefix...............: /usr/local
kano
Legendary
*
Offline Offline

Activity: 1918


Linux since 1997 RedHat 4


View Profile
September 15, 2011, 12:58:49 PM
 #1478

Did you type "export DISPLAY=:0" before you started cgminer?

Pool: https://kano.is BTC: 1KanoiBupPiZfkwqB7rfLXAzPnoTshAVmb
CKPool and CGMiner developer, IRC FreeNode #ckpool and #cgminer kanoi
Help keep Bitcoin secure by mining on pools with Stratum, the best protocol to mine Bitcoins with ASIC hardware
Boyd
Newbie
*
Offline Offline

Activity: 16


View Profile
September 15, 2011, 01:07:51 PM
 #1479

No, I did not, and with that its works perfectly. Respect and thx Kano Smiley
Roodemol
Newbie
*
Offline Offline

Activity: 11


View Profile
September 16, 2011, 06:47:18 AM
 #1480

Hi ckolivas,

I´m still using a old PowerBook G4 laptop from Apple, the CPU has an SIMD unit, Altivec, very simular to the SSE unit on x86 processors. I´ve translated the 4way SSE code into Altivec code. My very first version is already working with jgarzik´s cpuminer, could you also add the code into the cgminer:

My sha256_altivec_4way.c file:
Code:
// Copyright (c) 2010 Satoshi Nakamoto
// Copyright (c) 2011 Gilles Risch
// Distributed under the MIT/X11 software license, see the accompanying
// file license.txt or http://www.opensource.org/licenses/mit-license.php.


// 4-way 128-bit Altivec SHA-256,
// based on tcatm's 4-way 128-bit SSE2 SHA-256
//


#include "cpuminer-config.h"
#include "miner.h"

#ifdef WANT_ALTIVEC_4WAY

#include <string.h>
#include <assert.h>

//#include <altivec.h>
#include <stdint.h>
#include <stdio.h>

#define NPAR 32

static void DoubleBlockSHA256(const void* pin, void* pout, const void* pinit, unsigned int hash[8][NPAR], const void* init2);

static const unsigned 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
};


static inline vector unsigned int Ch(const vector unsigned int b, const vector unsigned int c, const vector unsigned int d) {
    return vec_sel(d,c,b);
}

static inline vector unsigned int Maj(const vector unsigned int b, const vector unsigned int c, const vector unsigned int d) {
    return vec_sel(b,c, vec_xor(b,d));
}

/* RotateRight(x, n) := RotateLeft(x, 32-n) */
/* SHA256 Functions */
#define BIGSIGMA0_256(x)    (vec_xor(vec_xor(vec_rl((x), (vector unsigned int)(32-2)),vec_rl((x), (vector unsigned int)(32-13))),vec_rl((x), (vector unsigned int)(32-22))))
#define BIGSIGMA1_256(x)    (vec_xor(vec_xor(vec_rl((x), (vector unsigned int)(32-6)),vec_rl((x), (vector unsigned int)(32-11))),vec_rl((x), (vector unsigned int)(32-25))))

#define SIGMA0_256(x)       (vec_xor(vec_xor(vec_rl((x), (vector unsigned int)(32- 7)),vec_rl((x), (vector unsigned int)(32-18))), vec_sr((x), (vector unsigned int)(3 ))))
#define SIGMA1_256(x)       (vec_xor(vec_xor(vec_rl((x), (vector unsigned int)(32-17)),vec_rl((x), (vector unsigned int)(32-19))), vec_sr((x), (vector unsigned int)(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(a, b, c, d, e, f, g, h, i, w)                       \
    T1 = add5(h, BIGSIGMA1_256(e), Ch(e, f, g), (vector unsigned int)(sha256_consts[i],sha256_consts[i],sha256_consts[i],sha256_consts[i]), w);   \
    d = vec_add(d, T1);                                           \
    h = vec_add(T1, vec_add(BIGSIGMA0_256(a), Maj(a, b, c)));


static const unsigned int pSHA256InitState[8] =
{0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19};


unsigned int scanhash_altivec_4way(int thr_id, const unsigned char *pmidstate,
unsigned char *pdata,
unsigned char *phash1, unsigned char *phash,
const unsigned char *ptarget,
uint32_t max_nonce, unsigned long *nHashesDone)
{
    unsigned int *nNonce_p = (unsigned int*)(pdata + 12);
    unsigned int nonce = 0;

    work_restart[thr_id].restart = 0;

    for (;;)
    {
        unsigned int thash[9][NPAR] __attribute__((aligned(128)));
int j, ic;

*nNonce_p = nonce;

        DoubleBlockSHA256(pdata, phash1, pmidstate, thash, pSHA256InitState);

        for (j = 0; j < NPAR; j++)
        {
            if (unlikely(thash[7][j] == 0))
            {
int i;

                for (i = 0; i < 32/4; i++)
                    ((unsigned int*)phash)[i] = thash[i][j];
               
if (fulltest(phash, ptarget)) {
*nHashesDone = nonce;
*nNonce_p = nonce + j;
                return nonce + j;
}
            }
        }

        if ((nonce >= max_nonce) || work_restart[thr_id].restart)
        {
            *nHashesDone = nonce;
            return -1;
        }

        nonce += NPAR;
    }
}


static void DoubleBlockSHA256(const void* pin, void* pad, const void *pre, unsigned int thash[9][NPAR], const void *init)
{
    unsigned int* In = (unsigned int*)pin;
    unsigned int* Pad = (unsigned int*)pad;
    unsigned int* hPre = (unsigned int*)pre;
    unsigned int* hInit = (unsigned int*)init;
    unsigned int /* i, j, */ k;

    /* vectors used in calculation */
    vector unsigned int w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
    vector unsigned int T1;
    vector unsigned int a, b, c, d, e, f, g, h;
    vector unsigned int nonce, preNonce;

    /* nonce offset for vector */
    vector unsigned int offset = (vector unsigned int)(0, 1, 2, 3);
   
    preNonce = vec_add((vector unsigned int)(In[3],In[3],In[3],In[3]), offset);

   for(k = 0; k<NPAR; k+=4)
   {
        w0 = (vector unsigned int)(In[0],In[0],In[0],In[0]);
        w1 = (vector unsigned int)(In[1],In[1],In[1],In[1]);
        w2 = (vector unsigned int)(In[2],In[2],In[2],In[2]);
        //w3 = (vector unsigned int)(In[3],In[3],In[3],In[3]); nonce will be later hacked into the hash
        w4 = (vector unsigned int)(In[4],In[4],In[4],In[4]);
        w5 = (vector unsigned int)(In[5],In[5],In[5],In[5]);
        w6 = (vector unsigned int)(In[6],In[6],In[6],In[6]);
        w7 = (vector unsigned int)(In[7],In[7],In[7],In[7]);
        w8 = (vector unsigned int)(In[8],In[8],In[8],In[8]);
        w9 = (vector unsigned int)(In[9],In[9],In[9],In[9]);
        w10 = (vector unsigned int)(In[10],In[10],In[10],In[10]);
        w11 = (vector unsigned int)(In[11],In[11],In[11],In[11]);
        w12 = (vector unsigned int)(In[12],In[12],In[12],In[12]);
        w13 = (vector unsigned int)(In[13],In[13],In[13],In[13]);
        w14 = (vector unsigned int)(In[14],In[14],In[14],In[14]);
        w15 = (vector unsigned int)(In[15],In[15],In[15],In[15]);

        /* hack nonce into lowest byte of w3 */
nonce = vec_add(preNonce, (vector unsigned int)(k,k,k,k));

        w3 = nonce;
        //printf ("W3: %08vlx\n", w3);

        a = (vector unsigned int)(hPre[0],hPre[0],hPre[0],hPre[0]);
        b = (vector unsigned int)(hPre[1],hPre[1],hPre[1],hPre[1]);
        c = (vector unsigned int)(hPre[2],hPre[2],hPre[2],hPre[2]);
        d = (vector unsigned int)(hPre[3],hPre[3],hPre[3],hPre[3]);
        e = (vector unsigned int)(hPre[4],hPre[4],hPre[4],hPre[4]);
        f = (vector unsigned int)(hPre[5],hPre[5],hPre[5],hPre[5]);
        g = (vector unsigned int)(hPre[6],hPre[6],hPre[6],hPre[6]);
        h = (vector unsigned int)(hPre[7],hPre[7],hPre[7],hPre[7]);

        SHA256ROUND(a, b, c, d, e, f, g, h, 0, w0);
        SHA256ROUND(h, a, b, c, d, e, f, g, 1, w1);
        SHA256ROUND(g, h, a, b, c, d, e, f, 2, w2);
        SHA256ROUND(f, g, h, a, b, c, d, e, 3, w3);
        SHA256ROUND(e, f, g, h, a, b, c, d, 4, w4);
        SHA256ROUND(d, e, f, g, h, a, b, c, 5, w5);
        SHA256ROUND(c, d, e, f, g, h, a, b, 6, w6);
        SHA256ROUND(b, c, d, e, f, g, h, a, 7, w7);
        SHA256ROUND(a, b, c, d, e, f, g, h, 8, w8);
        SHA256ROUND(h, a, b, c, d, e, f, g, 9, w9);
        SHA256ROUND(g, h, a, b, c, d, e, f, 10, w10);
        SHA256ROUND(f, g, h, a, b, c, d, e, 11, w11);
        SHA256ROUND(e, f, g, h, a, b, c, d, 12, w12);
        SHA256ROUND(d, e, f, g, h, a, b, c, 13, w13);
        SHA256ROUND(c, d, e, f, g, h, a, b, 14, w14);
        SHA256ROUND(b, c, d, e, f, g, h, a, 15, w15);

        w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
        SHA256ROUND(a, b, c, d, e, f, g, h, 16, w0);
        w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
        SHA256ROUND(h, a, b, c, d, e, f, g, 17, w1);
        w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
        SHA256ROUND(g, h, a, b, c, d, e, f, 18, w2);
        w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
        SHA256ROUND(f, g, h, a, b, c, d, e, 19, w3);
        w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
        SHA256ROUND(e, f, g, h, a, b, c, d, 20, w4);
        w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
        SHA256ROUND(d, e, f, g, h, a, b, c, 21, w5);
        w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
        SHA256ROUND(c, d, e, f, g, h, a, b, 22, w6);
        w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
        SHA256ROUND(b, c, d, e, f, g, h, a, 23, w7);
        w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
        SHA256ROUND(a, b, c, d, e, f, g, h, 24, w8);
        w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
        SHA256ROUND(h, a, b, c, d, e, f, g, 25, w9);
        w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
        SHA256ROUND(g, h, a, b, c, d, e, f, 26, w10);
        w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
        SHA256ROUND(f, g, h, a, b, c, d, e, 27, w11);
        w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
        SHA256ROUND(e, f, g, h, a, b, c, d, 28, w12);
        w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
        SHA256ROUND(d, e, f, g, h, a, b, c, 29, w13);
        w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
        SHA256ROUND(c, d, e, f, g, h, a, b, 30, w14);
        w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
        SHA256ROUND(b, c, d, e, f, g, h, a, 31, w15);

        w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
        SHA256ROUND(a, b, c, d, e, f, g, h, 32, w0);
        w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
        SHA256ROUND(h, a, b, c, d, e, f, g, 33, w1);
        w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
        SHA256ROUND(g, h, a, b, c, d, e, f, 34, w2);
        w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
        SHA256ROUND(f, g, h, a, b, c, d, e, 35, w3);
        w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
        SHA256ROUND(e, f, g, h, a, b, c, d, 36, w4);
        w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
        SHA256ROUND(d, e, f, g, h, a, b, c, 37, w5);
        w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
        SHA256ROUND(c, d, e, f, g, h, a, b, 38, w6);
        w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
        SHA256ROUND(b, c, d, e, f, g, h, a, 39, w7);
        w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
        SHA256ROUND(a, b, c, d, e, f, g, h, 40, w8);
        w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
        SHA256ROUND(h, a, b, c, d, e, f, g, 41, w9);
        w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
        SHA256ROUND(g, h, a, b, c, d, e, f, 42, w10);
        w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
        SHA256ROUND(f, g, h, a, b, c, d, e, 43, w11);
        w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
        SHA256ROUND(e, f, g, h, a, b, c, d, 44, w12);
        w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
        SHA256ROUND(d, e, f, g, h, a, b, c, 45, w13);
        w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
        SHA256ROUND(c, d, e, f, g, h, a, b, 46, w14);
        w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
        SHA256ROUND(b, c, d, e, f, g, h, a, 47, w15);

        w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
        SHA256ROUND(a, b, c, d, e, f, g, h, 48, w0);
        w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
        SHA256ROUND(h, a, b, c, d, e, f, g, 49, w1);
        w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
        SHA256ROUND(g, h, a, b, c, d, e, f, 50, w2);
        w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
        SHA256ROUND(f, g, h, a, b, c, d, e, 51, w3);
        w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
        SHA256ROUND(e, f, g, h, a, b, c, d, 52, w4);
        w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
        SHA256ROUND(d, e, f, g, h, a, b, c, 53, w5);
        w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
        SHA256ROUND(c, d, e, f, g, h, a, b, 54, w6);
        w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
        SHA256ROUND(b, c, d, e, f, g, h, a, 55, w7);
        w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
        SHA256ROUND(a, b, c, d, e, f, g, h, 56, w8);
        w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
        SHA256ROUND(h, a, b, c, d, e, f, g, 57, w9);
        w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
        SHA256ROUND(g, h, a, b, c, d, e, f, 58, w10);
        w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
        SHA256ROUND(f, g, h, a, b, c, d, e, 59, w11);
        w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
        SHA256ROUND(e, f, g, h, a, b, c, d, 60, w12);
        w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
        SHA256ROUND(d, e, f, g, h, a, b, c, 61, w13);
        w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
        SHA256ROUND(c, d, e, f, g, h, a, b, 62, w14);
        w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
        SHA256ROUND(b, c, d, e, f, g, h, a, 63, w15);

#define store_load(x, i, dest) \
        T1 = (vector unsigned int)((hPre)[i],(hPre)[i],(hPre)[i],(hPre)[i]); \
        dest = vec_add(T1, x);

        store_load(a, 0, w0);
        store_load(b, 1, w1);
        store_load(c, 2, w2);
        store_load(d, 3, w3);
        store_load(e, 4, w4);
        store_load(f, 5, w5);
        store_load(g, 6, w6);
        store_load(h, 7, w7);

        /* end of first SHA256 round */

        w8 = (vector unsigned int)(Pad[8],Pad[8],Pad[8],Pad[8]);
        w9 = (vector unsigned int)(Pad[9],Pad[9],Pad[9],Pad[9]);
        w10 = (vector unsigned int)(Pad[10],Pad[10],Pad[10],Pad[10]);
        w11 = (vector unsigned int)(Pad[11],Pad[11],Pad[11],Pad[11]);
        w12 = (vector unsigned int)(Pad[12],Pad[12],Pad[12],Pad[12]);
        w13 = (vector unsigned int)(Pad[13],Pad[13],Pad[13],Pad[13]);
        w14 = (vector unsigned int)(Pad[14],Pad[14],Pad[14],Pad[14]);
        w15 = (vector unsigned int)(Pad[15],Pad[15],Pad[15],Pad[15]);

        a = (vector unsigned int)(hInit[0],hInit[0],hInit[0],hInit[0]);
        b = (vector unsigned int)(hInit[1],hInit[1],hInit[1],hInit[1]);
        c = (vector unsigned int)(hInit[2],hInit[2],hInit[2],hInit[2]);
        d = (vector unsigned int)(hInit[3],hInit[3],hInit[3],hInit[3]);
        e = (vector unsigned int)(hInit[4],hInit[4],hInit[4],hInit[4]);
        f = (vector unsigned int)(hInit[5],hInit[5],hInit[5],hInit[5]);
        g = (vector unsigned int)(hInit[6],hInit[6],hInit[6],hInit[6]);
        h = (vector unsigned int)(hInit[7],hInit[7],hInit[7],hInit[7]);

        SHA256ROUND(a, b, c, d, e, f, g, h, 0, w0);
        SHA256ROUND(h, a, b, c, d, e, f, g, 1, w1);
        SHA256ROUND(g, h, a, b, c, d, e, f, 2, w2);
        SHA256ROUND(f, g, h, a, b, c, d, e, 3, w3);
        SHA256ROUND(e, f, g, h, a, b, c, d, 4, w4);
        SHA256ROUND(d, e, f, g, h, a, b, c, 5, w5);
        SHA256ROUND(c, d, e, f, g, h, a, b, 6, w6);
        SHA256ROUND(b, c, d, e, f, g, h, a, 7, w7);
        SHA256ROUND(a, b, c, d, e, f, g, h, 8, w8);
        SHA256ROUND(h, a, b, c, d, e, f, g, 9, w9);
        SHA256ROUND(g, h, a, b, c, d, e, f, 10, w10);
        SHA256ROUND(f, g, h, a, b, c, d, e, 11, w11);
        SHA256ROUND(e, f, g, h, a, b, c, d, 12, w12);
        SHA256ROUND(d, e, f, g, h, a, b, c, 13, w13);
        SHA256ROUND(c, d, e, f, g, h, a, b, 14, w14);
        SHA256ROUND(b, c, d, e, f, g, h, a, 15, w15);

        w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
        SHA256ROUND(a, b, c, d, e, f, g, h, 16, w0);
        w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
        SHA256ROUND(h, a, b, c, d, e, f, g, 17, w1);
        w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
        SHA256ROUND(g, h, a, b, c, d, e, f, 18, w2);
        w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
        SHA256ROUND(f, g, h, a, b, c, d, e, 19, w3);
        w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
        SHA256ROUND(e, f, g, h, a, b, c, d, 20, w4);
        w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
        SHA256ROUND(d, e, f, g, h, a, b, c, 21, w5);
        w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
        SHA256ROUND(c, d, e, f, g, h, a, b, 22, w6);
        w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
        SHA256ROUND(b, c, d, e, f, g, h, a, 23, w7);
        w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
        SHA256ROUND(a, b, c, d, e, f, g, h, 24, w8);
        w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
        SHA256ROUND(h, a, b, c, d, e, f, g, 25, w9);
        w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
        SHA256ROUND(g, h, a, b, c, d, e, f, 26, w10);
        w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
        SHA256ROUND(f, g, h, a, b, c, d, e, 27, w11);
        w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
        SHA256ROUND(e, f, g, h, a, b, c, d, 28, w12);
        w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
        SHA256ROUND(d, e, f, g, h, a, b, c, 29, w13);
        w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
        SHA256ROUND(c, d, e, f, g, h, a, b, 30, w14);
        w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
        SHA256ROUND(b, c, d, e, f, g, h, a, 31, w15);

        w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
        SHA256ROUND(a, b, c, d, e, f, g, h, 32, w0);
        w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
        SHA256ROUND(h, a, b, c, d, e, f, g, 33, w1);
        w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
        SHA256ROUND(g, h, a, b, c, d, e, f, 34, w2);
        w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
        SHA256ROUND(f, g, h, a, b, c, d, e, 35, w3);
        w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
        SHA256ROUND(e, f, g, h, a, b, c, d, 36, w4);
        w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
        SHA256ROUND(d, e, f, g, h, a, b, c, 37, w5);
        w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
        SHA256ROUND(c, d, e, f, g, h, a, b, 38, w6);
        w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
        SHA256ROUND(b, c, d, e, f, g, h, a, 39, w7);
        w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
        SHA256ROUND(a, b, c, d, e, f, g, h, 40, w8);
        w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
        SHA256ROUND(h, a, b, c, d, e, f, g, 41, w9);
        w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
        SHA256ROUND(g, h, a, b, c, d, e, f, 42, w10);
        w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
        SHA256ROUND(f, g, h, a, b, c, d, e, 43, w11);
        w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
        SHA256ROUND(e, f, g, h, a, b, c, d, 44, w12);
        w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
        SHA256ROUND(d, e, f, g, h, a, b, c, 45, w13);
        w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
        SHA256ROUND(c, d, e, f, g, h, a, b, 46, w14);
        w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
        SHA256ROUND(b, c, d, e, f, g, h, a, 47, w15);

        w0 = add4(SIGMA1_256(w14), w9, SIGMA0_256(w1), w0);
        SHA256ROUND(a, b, c, d, e, f, g, h, 48, w0);
        w1 = add4(SIGMA1_256(w15), w10, SIGMA0_256(w2), w1);
        SHA256ROUND(h, a, b, c, d, e, f, g, 49, w1);
        w2 = add4(SIGMA1_256(w0), w11, SIGMA0_256(w3), w2);
        SHA256ROUND(g, h, a, b, c, d, e, f, 50, w2);
        w3 = add4(SIGMA1_256(w1), w12, SIGMA0_256(w4), w3);
        SHA256ROUND(f, g, h, a, b, c, d, e, 51, w3);
        w4 = add4(SIGMA1_256(w2), w13, SIGMA0_256(w5), w4);
        SHA256ROUND(e, f, g, h, a, b, c, d, 52, w4);
        w5 = add4(SIGMA1_256(w3), w14, SIGMA0_256(w6), w5);
        SHA256ROUND(d, e, f, g, h, a, b, c, 53, w5);
        w6 = add4(SIGMA1_256(w4), w15, SIGMA0_256(w7), w6);
        SHA256ROUND(c, d, e, f, g, h, a, b, 54, w6);
        w7 = add4(SIGMA1_256(w5), w0, SIGMA0_256(w8), w7);
        SHA256ROUND(b, c, d, e, f, g, h, a, 55, w7);
        w8 = add4(SIGMA1_256(w6), w1, SIGMA0_256(w9), w8);
        SHA256ROUND(a, b, c, d, e, f, g, h, 56, w8);
        w9 = add4(SIGMA1_256(w7), w2, SIGMA0_256(w10), w9);
        SHA256ROUND(h, a, b, c, d, e, f, g, 57, w9);
        w10 = add4(SIGMA1_256(w8), w3, SIGMA0_256(w11), w10);
        SHA256ROUND(g, h, a, b, c, d, e, f, 58, w10);
        w11 = add4(SIGMA1_256(w9), w4, SIGMA0_256(w12), w11);
        SHA256ROUND(f, g, h, a, b, c, d, e, 59, w11);
        w12 = add4(SIGMA1_256(w10), w5, SIGMA0_256(w13), w12);
        SHA256ROUND(e, f, g, h, a, b, c, d, 60, w12);

/* Skip last 3-rounds; not necessary for H==0 */
/*#if 0
        w13 = add4(SIGMA1_256(w11), w6, SIGMA0_256(w14), w13);
        SHA256ROUND(d, e, f, g, h, a, b, c, 61, w13);
        w14 = add4(SIGMA1_256(w12), w7, SIGMA0_256(w15), w14);
        SHA256ROUND(c, d, e, f, g, h, a, b, 62, w14);
        w15 = add4(SIGMA1_256(w13), w8, SIGMA0_256(w0), w15);
        SHA256ROUND(b, c, d, e, f, g, h, a, 63, w15);
#endif*/

        /* store resulsts directly in thash */
#define store_2(x,i)  \
        w0 = (vector unsigned int)(hInit[i],hInit[i],hInit[i],hInit[i]); \
        vec_st(vec_add(w0, x), 0 ,&thash[i][k]);

        store_2(a, 0);
        store_2(b, 1);
        store_2(c, 2);
        store_2(d, 3);
        store_2(e, 4);
        store_2(f, 5);
        store_2(g, 6);
        store_2(h, 7);

        vec_st(nonce, 0 ,&thash[8][k]);
        /* writing the results into the array is time intensive */
        /* -> try if it´s faster to compare the results with the target inside this function */
    }

}

#endif /* WANT_ALTIVEC_4WAY */

On my 1.5GHz G4 laptop I end up somewhere around 1100 khash/sec, not a lot, but better than the generic algo. The code should also word on G5's but I couldn't test due to the lack of hardware.

Beside of this file you must also change two functions inside the main.c file because the code is for little-endian machines and the PowerPc is big-endian:
Code:
static bool work_decode(const json_t *val, struct work *work) {
    if (unlikely(!jobj_binary(val, "midstate",
            work->midstate, sizeof (work->midstate)))) {
        applog(LOG_ERR, "JSON inval midstate");
        goto err_out;
    }

    if (unlikely(!jobj_binary(val, "data", work->data, sizeof (work->data)))) {
        applog(LOG_ERR, "JSON inval data");
        goto err_out;
    }

    if (unlikely(!jobj_binary(val, "hash1", work->hash1, sizeof (work->hash1)))) {
        applog(LOG_ERR, "JSON inval hash1");
        goto err_out;
    }

    if (unlikely(!jobj_binary(val, "target", work->target, sizeof (work->target)))) {
        applog(LOG_ERR, "JSON inval target");
        goto err_out;
    }

    memset(work->hash, 0, sizeof (work->hash));

#ifdef __BIG_ENDIAN__
    int swapcounter = 0;
    for (swapcounter = 0; swapcounter < 32; swapcounter++)
        (((uint32_t*) (work->data))[swapcounter]) = swab32(((uint32_t*) (work->data))[swapcounter]);
    for (swapcounter = 0; swapcounter < 16; swapcounter++)
        (((uint32_t*) (work->hash1))[swapcounter]) = swab32(((uint32_t*) (work->hash1))[swapcounter]);
    for (swapcounter = 0; swapcounter < 8; swapcounter++)
        (((uint32_t*) (work->midstate))[swapcounter]) = swab32(((uint32_t*) (work->midstate))[swapcounter]);
    for (swapcounter = 0; swapcounter < 8; swapcounter++)
        (((uint32_t*) (work->target))[swapcounter]) = swab32(((uint32_t*) (work->target))[swapcounter]);
#endif

    return true;

err_out:
    return false;
}

static bool submit_upstream_work(CURL *curl, const struct work *work) {
    char *hexstr = NULL;
    json_t *val, *res;
    char s[345];
    bool rc = false;

#ifdef __BIG_ENDIAN__
    int swapcounter;
    for (swapcounter = 0; swapcounter < 32; swapcounter++)
        (((uint32_t*) (work->data))[swapcounter]) = swab32(((uint32_t*) (work->data))[swapcounter]);
#endif

    /* build hex string */
    hexstr = bin2hex(work->data, sizeof (work->data));
    if (unlikely(!hexstr)) {
        applog(LOG_ERR, "submit_upstream_work OOM");
        goto out;
    }

    /* build JSON-RPC request */
    sprintf(s,
            "{\"method\": \"getwork\", \"params\": [ \"%s\" ], \"id\":1}\r\n",
            hexstr);

    if (opt_debug)
        applog(LOG_DEBUG, "DBG: sending RPC call: %s", s);

    /* issue JSON-RPC request */
    val = json_rpc_call(curl, rpc_url, rpc_userpass, s, false, false);
    if (unlikely(!val)) {
        applog(LOG_ERR, "submit_upstream_work json_rpc_call failed");
        goto out;
    }

    res = json_object_get(val, "result");

    applog(LOG_INFO, "PROOF OF WORK RESULT: %s",
            json_is_true(res) ? "true (yay!!!)" : "false (booooo)");

    json_decref(val);

    rc = true;

out:
    free(hexstr);
    return rc;
}
These changes could also be useful if you like to use the cgminer on big-endian ARM cpu's.



Regards,
Gilles

You like my work? Feel free to send me a coin:
1JXGvtLFwTafEanEA4hwBYfRbMbgHae9Jt
Pages: « 1 ... 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 [74] 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 ... 830 »
  Print  
 
Jump to:  

Sponsored by , a Bitcoin-accepting VPN.
Powered by MySQL Powered by PHP Powered by SMF 1.1.19 | SMF © 2006-2009, Simple Machines Valid XHTML 1.0! Valid CSS!