This is a work in progress, and will be updated as necessary.

No, this thread is not about any other mining software because mining software is very specific. CGminer, since it’s release has been very dependent on driver specifics to work with ATI GPU’s, and although this release is not by the original author, it still depends on the drivers.

How does this effect you? Well, it depends on what you want to get out of GPU mining.

If all you want, is plug and play mining, it simply means that you need 13.11 or 13.12 ATI drivers, and a batch file with the correct settings. This will give you about 60% of what your GPU is currently capable of for hashrate.

If you want the maximum performance out of your GPU’s, plan on spending some time. Below is the best step by step procedure that has been found to work. (if a better procedure is found, the procedure shown will be updated)

First, download the following:(any of these you already have don’t need to be re-downloaded)

CGminer 3.7.7B (windows) - https://www.dropbox.com/s/mbteys6opg4odlj/cgminer-3.7.7.bNeoscrypt.zip?dl=0

CGminer 3.7.7B source - https://github.com/vehre/neo-gpuminer/

Display Driver Uninstaller - http://www.guru3d.com/files-details/display-driver-uninstaller-download.html

ATI 13.11 drivers - http://www.guru3d.com/files-details/amd-catalyst-13-11-beta-9-5-driver-download.html

The latest ATI drivers - http://support.amd.com/en-us/download

and to overclock

MSI Afterburner - http://www.guru3d.com/files-details/msi-afterburner-beta-download.html

Why download all that stuff? Well, you did want to mine faster than the lazy guy, right?

The driver updating procedure is a revision of what is posted by rynomite here : https://forum.feathercoin.com/index.php?/topic/7780-neoscrypt-gpu-miner-public-beta-test/?p=68636

NOTE - read this entire process below through before you start it, as if you forget something you have to start over -

-uninstall existing ATI drivers

-run the driver uninstaller to clean out the remnants

-reboot

-install 13.11 drivers

-reboot

At this point, you now have a clean 13.xx driver install.

• if you have already been experimenting with CGminer 3.7.7B, go to that folder and delete ALL .bin files (this is critical)

-If you haven’t, then unzip CGminer (or compile if you have the source)

You now have CGminer 3.7.7B ready to start creating the .bin files that you need to use to run the updated ATI drivers.

-if you have found known settings that work create your batch file or .conf file with those settings and run it. If you have everything right it should detect your GPU(s) and start mining

-if you want to try out your own settings, try them out and WRITE THEM DOWN as you will need them again. Try as many settings as you want, it will just create more .bin files that you will need later

Once you are satisfied with the settings that you have, move on.

-update the drivers to 14.xx. (if you are anal, you can run DDU again, but upgrading it shouldn’t be necessary)

-reboot

You are now ready to start mining at increased speeds available by using the 14.xx drivers.

-if you have known settings to use, just run CGminer and start mining

-if you are experimenting, get your list of settings I told you to make, and start trying them out. Some will run the same speed as the 13.xx drivers, others will run with a drastic increase in speed. Note which is which, and after trying them all pick the fastest and start mining.

**If you’re happy with what you have now, STOP HERE!!! ** If you want to go even further:

-install afterburner

-lower voltage and increase core and memory clocks in small increments (note: neoscrypt is not a huge heat creator, you will crash the drivers long before you burn the cards)

-after finding the optimized settings and getting another 15% increase (my experience) save the settings

-grin and be smug, because you just took a little time and got a drastic increase over the lazy people!!

A list of best known settings will be in the next post… (if you have something that works well, feel free to post it in this thread, and it will get added to the list)

What happens of you skip a step? You’ll see what happens by others posting issues below.

test, 1, 2, 3…

Anyone following the Nvidia neoscrypt development?

https://bitcointalk.org/index.php?topic=916336.0

NeoScrypt CPUminer updated to v2.4.1, up to 50% performance increase.

NeoScrypt CPUminer at Cryptocointalk

-e, --engine=N choose a NeoScrypt hashing engine
0 integer (default)
1 SSE2
2 SSE2 4-way

I was not aware of different ‘engines’ for hashing on CPU’s as I don’t CPU mine. What is the reason for them?

^^ and like you said, the compiler probably fixed that.

But people are trying, in order to make mistakes like that. :)

Nice to know that the interest in improving the kernel didn’t go away when Wolf said he was keeping his improvements to himself…

I’m not in any way faulting him for that decision, but that doesn’t mean that I have to like it either… ;)

BTW, I got into X11 mining, and guess who showed up as the top kernel writer… lol

There are people doing minor mods to the latest wolf kernel, and bumping the speed up just a tad. One decreased my speed by about 1.5%, the other increased by about 1.5%, but combined they gave me about 9 kh/s on my 290’s, roughly 2.5%.

// NeoScrypt(128, 2, 1) with Salsa20/20 and ChaCha20/20

// Stupid AMD compiler ignores the unroll pragma in these two
#define SALSA_SMALL_UNROLL 3
#define CHACHA_SMALL_UNROLL 3

// If SMALL_BLAKE2S is defined, BLAKE2S_UNROLL is interpreted
// as the unroll factor; must divide cleanly into ten.
// Usually a bad idea.
//#define SMALL_BLAKE2S
//#define BLAKE2S_UNROLL 5

#define BLOCK_SIZE 64U
#define FASTKDF_BUFFER_SIZE 256U
#ifndef PASSWORD_LEN
#define PASSWORD_LEN 80U
#endif

#if !defined(cl_khr_byte_addressable_store)
#error “Device does not support unaligned stores”
#endif

// Swaps 128 bytes at a time without using temp vars
void SwapBytes128(void *restrict A, void *restrict B, uint len)
{
#pragma unroll 2
for(int i = 0; i < (len >> 7); ++i)
{
((ulong16 *)A)[i] ^= ((ulong16 *)B)[i];
((ulong16 *)B)[i] ^= ((ulong16 *)A)[i];
((ulong16 *)A)[i] ^= ((ulong16 *)B)[i];
}
}

void CopyBytes128(void *restrict dst, const void *restrict src, uint len)
{
#pragma unroll 2
for(int i = 0; i < len; ++i)
((ulong16 *)dst)[i] = ((ulong16 *)src)[i];
}

void CopyBytes(void *restrict dst, const void *restrict src, uint len)
{
for(int i = 0; i < len; ++i)
((uchar *)dst)[i] = ((uchar *)src)[i];
}

//
// a bit of byte alignment checking goes a long ways…
//
void XORBytesInPlace(void *restrict dst, const void *restrict src, uint mod)
{
switch(mod % 4)
{
case 0:
#pragma unroll 2
for(int i = 0; i < 4; i+=2)
{
((uint2 *)dst)[i] ^= ((uint2 *)src)[i];
((uint2 *)dst)[i+1] ^= ((uint2 *)src)[i+1];
}
break;

case 2:
#pragma unroll 8
for(int i = 0; i < 16; i+=2)
{
((uchar2 *)dst)[i] ^= ((uchar2 *)src)[i];
((uchar2 *)dst)[i+1] ^= ((uchar2 *)src)[i+1];
}
break;

default:
#pragma unroll 8
for(int i = 0; i < 31; i+=4)
{
((uchar *)dst)[i] ^= ((uchar *)src)[i];
((uchar *)dst)[i+1] ^= ((uchar *)src)[i+1];
((uchar *)dst)[i+2] ^= ((uchar *)src)[i+2];
((uchar *)dst)[i+3] ^= ((uchar *)src)[i+3];
}
}
}

void XORBytes(void *restrict dst, const void *restrict src1, const void *restrict src2, uint len)
{
#pragma unroll 1
for(int i = 0; i < len; ++i)
((uchar *)dst)[i] = ((uchar *)src1)[i] ^ ((uchar *)src2)[i];
}

// Blake2S

#define BLAKE2S_BLOCK_SIZE 64U
#define BLAKE2S_OUT_SIZE 32U
#define BLAKE2S_KEY_SIZE 32U

static const __constant uint BLAKE2S_IV[8] =
{
0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A,
0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19
};

static const __constant uchar BLAKE2S_SIGMA[10][16] =
{
{ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 } ,
{ 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 } ,
{ 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 } ,
{ 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 } ,
{ 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 } ,
{ 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 } ,
{ 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 } ,
{ 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 } ,
{ 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 } ,
{ 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 } ,
};

#define BLAKE_G(idx0, idx1, a, b, c, d, key) do { \
a += b + key[BLAKE2S_SIGMA[idx0][idx1]]; \
d = rotate(d ^ a, 16U); \
c += d; \
b = rotate(b ^ c, 20U); \
a += b + key[BLAKE2S_SIGMA[idx0][idx1 + 1]]; \
d = rotate(d ^ a, 24U); \
c += d; \
b = rotate(b ^ c, 25U); \
} while(0)

void Blake2S(uint *restrict inout, const uint *restrict inkey)
{
uint16 V;
uint8 tmpblock;

// Load first block (IV into V.lo) and constants (IV into V.hi)
V.lo = V.hi = vload8(0U, BLAKE2S_IV);

// XOR with initial constant
V.s0 ^= 0x01012020;

// Copy input block for later
tmpblock = V.lo;

// XOR length of message so far (including this block)
// There are two uints for this field, but high uint is zero
V.sc ^= BLAKE2S_BLOCK_SIZE;

// Compress state, using the key as the key
#ifdef SMALL_BLAKE2S
#pragma unroll BLAKE2S_UNROLL
#else
#pragma unroll
#endif
for(int x = 0; x < 10; ++x)
{
BLAKE_G(x, 0x00, V.s0, V.s4, V.s8, V.sc, inkey);
BLAKE_G(x, 0x02, V.s1, V.s5, V.s9, V.sd, inkey);
BLAKE_G(x, 0x04, V.s2, V.s6, V.sa, V.se, inkey);
BLAKE_G(x, 0x06, V.s3, V.s7, V.sb, V.sf, inkey);
BLAKE_G(x, 0x08, V.s0, V.s5, V.sa, V.sf, inkey);
BLAKE_G(x, 0x0A, V.s1, V.s6, V.sb, V.sc, inkey);
BLAKE_G(x, 0x0C, V.s2, V.s7, V.s8, V.sd, inkey);
BLAKE_G(x, 0x0E, V.s3, V.s4, V.s9, V.se, inkey);
}

// XOR low part of state with the high part,
// then with the original input block.
V.lo ^= V.hi ^ tmpblock;

// Load constants (IV into V.hi)
V.hi = vload8(0U, BLAKE2S_IV);

// Copy input block for later
tmpblock = V.lo;

// XOR length of message into block again
V.sc ^= BLAKE2S_BLOCK_SIZE << 1;

// Last block compression - XOR final constant into state
V.se ^= 0xFFFFFFFFU;

// Compress block, using the input as the key
#ifdef SMALL_BLAKE2S
#pragma unroll BLAKE2S_UNROLL
#else
#pragma unroll
#endif
for(int x = 0; x < 10; ++x)
{
BLAKE_G(x, 0x00, V.s0, V.s4, V.s8, V.sc, inout);
BLAKE_G(x, 0x02, V.s1, V.s5, V.s9, V.sd, inout);
BLAKE_G(x, 0x04, V.s2, V.s6, V.sa, V.se, inout);
BLAKE_G(x, 0x06, V.s3, V.s7, V.sb, V.sf, inout);
BLAKE_G(x, 0x08, V.s0, V.s5, V.sa, V.sf, inout);
BLAKE_G(x, 0x0A, V.s1, V.s6, V.sb, V.sc, inout);
BLAKE_G(x, 0x0C, V.s2, V.s7, V.s8, V.sd, inout);
BLAKE_G(x, 0x0E, V.s3, V.s4, V.s9, V.se, inout);
}

// XOR low part of state with high part, then with input block
V.lo ^= V.hi ^ tmpblock;

// Store result in input/output buffer
vstore8(V.lo, 0, inout);
}

/* FastKDF, a fast buffered key derivation function:
* FASTKDF_BUFFER_SIZE must be a power of 2;
* password_len, salt_len and output_len should not exceed FASTKDF_BUFFER_SIZE;
* prf_output_size must be

You can bump the sapphire R9 290 Tri-x OC up from 333 to 340… The GPU’s came back from warranty replacement, and can get the juice cranked up a little with fans that aren’t failing…

Will get this added asap, having a few delays with stuff, usual festive stuff with family and being unable to access a fully working pc to actually do things on

Recently tested an R7 240 (its pointless dont try)

Got the core clock to 1300 MHz (default 780), and the memory from 800 to 1300 also (tried upping the voltage from 1.15v all the way up to 1.4v but still couldnt push past that 1300mhz), huge boost in hashrate, from around 12kh/s to about 20 kh/s, this didnt last long sadly as the cards VRMs blew after just 3 days, poor thing, ohwell was a free gpu :D

If someone hands you a 7990, please don’t do the same overclock till burnout test… lol

+1 for Wolfs kernel. Took this card from 78kh/s to 200+ Kh/s.

Wolf’s kernel took my 290’s from 70 to 330, and my 290x’s from 70 to 302… (%^@$^ Elpida memory)

My guess is that they are building drivers for faster gaming frame rates, not mining.

But what do I know? lol