OFFICIAL CGMINER mining software thread for linux/win/osx/mips/arm/r-pi 4.11.0 - page 774.

pokerface6578

newbie

Activity: 21

Merit: 0

Hi, my client is suddenly not working. I reboot from windows and try to log onto the deepbit pool with no success, rebooted, same thing. tried btcguild, again, no dice. ive doublechecked all my login info, none of it is mis typed. resetting my router did nothing.....

edit- ive downloaded it in windows and retested, surprise surprise, it works with both pools there however back in linux its not working. I keep getting invalid credentials/url

cablepair

hero member

Activity: 896

Merit: 1000

Buy this account on March-2019. New Owner here!!

Quote from: bitlane on September 16, 2011, 10:45:40 AM

Considering I have been mining for about a half a year, I almost feel stupid for having to ask this question....BUT;

Why do some pools produce up to 10-15% stales at times, while other, using the EXACT SAME SETTINGS produce less than 1-1.5% ?

I have no clue what it takes to set up a pool for mining, but I assumed it was pretty standard yet I notice that some mining software is more friendly at certain pools than others.

On my PPS Pool, I am able to get away with about 1% stales (CGMiner kicks ass!), while on a Proportional Pool that I mine on, I get approx 10-14% Stales constantly and the only thing that differs in my settings are the login details......LOL

I used to notice the same while using Guiminer and switching between Phoenix & POCLBM, depending on which was faster on certain pools and generated the least number of stales.

Any comments ?

actually most pools are custom coded back/front ends

many of the new pools use pool push but even with those they make a lot of modification and create their own custom front ends.

Also large amount of stales could have to do a problem with the server that the pool is on cannot keep up or even connection problems.

So to answer your problem it could be a number if different things and the best place to start would be that particular pools thread / operator.

hope i could help...

bitlane

sr. member

Activity: 462

Merit: 250

I heart thebaron

Considering I have been mining for about a half a year, I almost feel stupid for having to ask this question....BUT;

Why do some pools produce up to 10-15% stales at times, while other, using the EXACT SAME SETTINGS produce less than 1-1.5% ?

I have no clue what it takes to set up a pool for mining, but I assumed it was pretty standard yet I notice that some mining software is more friendly at certain pools than others.

On my PPS Pool, I am able to get away with about 1% stales (CGMiner kicks ass!), while on a Proportional Pool that I mine on, I get approx 10-14% Stales constantly and the only thing that differs in my settings are the login details......LOL

I used to notice the same while using Guiminer and switching between Phoenix & POCLBM, depending on which was faster on certain pools and generated the least number of stales.

Any comments ?

kano

legendary

Activity: 4634

Merit: 1851

Linux since 1997 RedHat 4

Quote from: Roodemol on September 16, 2011, 01:52:11 AM

Quote from: -ck on September 16, 2011, 01:50:29 AM

Thanks very much Gilles

. Could you be so kind as to email me patches for these instead or provide a git branch that I could pull off? That would be most helpful.

No problem, but that will take until next week.

Gilles

Note - you don't need to do the last 3.5 rounds of calculation to be able to determine if a hash is a share.
See here for discussion of that and other optimisations elsewhere in the thread:
https://bitcointalksearch.org/topic/m.455128
(My last Edit of that and a few posts above that one for the discussion)
Also the comments about setting up the beginning of the hash process that is common across multiple calls

Roodemol

newbie

Activity: 9

Merit: 0

Quote from: -ck on September 16, 2011, 01:50:29 AM

Thanks very much Gilles

. Could you be so kind as to email me patches for these instead or provide a git branch that I could pull off? That would be most helpful.

No problem, you´ve got mail. All the modified files are attached.
Gilles

-ck

legendary

Activity: 4088

Merit: 1631

Ruu \o/

Thanks very much Gilles

. Could you be so kind as to email me patches for these instead or provide a git branch that I could pull off? That would be most helpful.

Roodemol

newbie

Activity: 9

Merit: 0

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 
#include 

//#include 
#include 
#include 

#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   {
        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

Boyd

newbie

Activity: 16

Merit: 0

No, I did not, and with that its works perfectly. Respect and thx Kano

kano

legendary

Activity: 4634

Merit: 1851

Linux since 1997 RedHat 4

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

Boyd

newbie

Activity: 16

Merit: 0

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

os2sam

legendary

Activity: 3583

Merit: 1094

Think for yourself

Quote from: DiabloD3 on September 15, 2011, 03:42:25 AM

Quote from: xcloudx01 on September 15, 2011, 03:28:02 AM

Quote from: DiabloD3 on September 14, 2011, 03:27:31 PM

Quote from: xcloudx01 on September 14, 2011, 02:59:39 PM

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.

-ck

legendary

Activity: 4088

Merit: 1631

Ruu \o/

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.

mmortal03

legendary

Activity: 1762

Merit: 1011

Quote from: -ck on September 14, 2011, 04:57:42 PM

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

legendary

Activity: 4088

Merit: 1631

Ruu \o/

Quote from: phorensic on September 15, 2011, 01:40:19 AM

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

DiabloD3

legendary

Activity: 1162

Merit: 1000

DiabloMiner author

Quote from: bitlane on September 15, 2011, 02:26:38 AM

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.

DiabloD3

legendary

Activity: 1162

Merit: 1000

DiabloMiner author

Quote from: xcloudx01 on September 15, 2011, 03:28:02 AM

Quote from: DiabloD3 on September 14, 2011, 03:27:31 PM

Quote from: xcloudx01 on September 14, 2011, 02:59:39 PM

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.

xcloudx01

newbie

Activity: 14

Merit: 0

Quote from: DiabloD3 on September 14, 2011, 03:27:31 PM

Quote from: xcloudx01 on September 14, 2011, 02:59:39 PM

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?

bitlane

sr. member

Activity: 462

Merit: 250

I heart thebaron

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

simonk83

hero member

Activity: 798

Merit: 1000

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

phorensic

hero member

Activity: 630

Merit: 500

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*

Topic: OFFICIAL CGMINER mining software thread for linux/win/osx/mips/arm/r-pi 4.11.0 - page 774. (Read 5805728 times)