Sunday, July 31, 2016

In my last post about mining ethereum, I explained why I preferred Genoil's fork of the Ethereum Foundation's ethminer. After that post, I started having stability problems with one of the newer releases of Genoil's miner. I suspected the problem was likely deadlocks with mutexes that had been added to the code. They had been added to reduce the chance of the miner submitting stale or invalid shares, but in this case the solution was worse than the problem, since there is no harm in submitting a small number of invalid shares to a pool. After taking some time to review the code and discuss my ideas with the author, I decided to make some improvements. The result is ethminer-nr.

A description of some of the changes can be found on the issues tracker for Genoil's miner, since I expect most of my changes to be merged upstream. The first thing I did was remove the mutexes. This does open the possibility of a rare race condition that could cause an invalid share submit when one thread processes a share from a GPU while another thread processes a new job from the pool. On Linux the threads can be serialized using the taskset command to pin the process to a single CPU. On a multi-CPU system, use "taskset 1 ./ethminer ..." to pin the process to the first CPU.

As described in the issues tracker, I added per-GPU reporting of hash rate. I also reduced the stats output to accepted (A) and rejected (R), including stales, since I have never seen a pool submit fail, and only some pools will report a rejected share. The more compact output helps the stats still fit on a single line, even with hashrate reporting from multiple GPUs: m 13:28:46|ethminer 15099 24326 15099 =54525Khs A807+6:R0+0

To help detect when a pool connection has failed, instead of trying to manage timeouts in the code, I decided to rely on the TCP stack. The first thing I did was enable TCP keepalives on the stratum connection to the pool. If the pool server is alive but just didn't have any new jobs for a while, the socket connection will remain open. If the network connection to the pool fails, there will be no keepalive response and the socket will be closed. Since the default timeouts are rather long, I reduced them to make network failure detection faster:

sudo sysctl -w net.ipv4.tcp_keepalive_time=30

sudo sysctl -w net.ipv4.tcp_keepalive_intvl=5

sudo sysctl -w net.ipv4.tcp_keepalive_intvl=3

I wasn't certain if packets sent to the server will reset the keepalive timer, even if there is no response (even an ACK) from the server. Therefore I also reduced the default TCP retransmission count to 5, so the pool connection will close after a packet is sent (i.e. share submit) 5 times without an acknowledgement.

sudo sysctl -w net.ipv4.tcp_retries2=5

I was also able to make a stand-alone linux binary. Until now the Linux builds had made extensive use of shared libraries, so the binary could not be used without first installing several shared library dependencies like boost and json. I had to do some of the build manually, so to make your own static linked binary you'll have to wait a few days for some updates to the cmake build scripts. If you want to try it now anyway, you can add "-DETH_STATIC=1" to the cmake command line.

As for future improvements, since I've started learning OpenCL, I'm hoping to optimize the ethminer OpenCL kernel to improve hashing performance. Look for something in late August or early September.

Sunday, July 17, 2016

Programs for mining on GPUs are usually written in OpenCL. It's based on C, which I know well, so a few weeks ago I decided to try to improve some mining OpenCL code. My intention was to both learn OpenCL and better understand mining algorithims.

The first thing I tried was replacing the rotate code in the ror64 function to use amd_bitalign. The bitalign instruction (v_alignbit_b32) can do a 32-bit rotate in a single cycle, much like the ARM barrel shifter. I was surprised that the speed did not improve, which suggests the AMD OpenCL drivers are optimized to use the alignbit instruction. What was worse was that the kernel would calculate incorrect hash values. After double and triple-checking my code, I found a post indicating a bug with amd_bitalign when using values divisible by 8. I then tried amd_bytealign, and that didn't work either. I was able to confirm the bug when I found that a bitalign of 21 followed by 3 worked (albeit slower), while a single bitalign of 24 did not.

It would seem there is no reason to use the amd_bitalign any more. Relying on the driver to optimize the code makes it portable to other platforms. I couldn't find any documentation from AMD saying the bitalign and other media ops are deprected, but I did verify that the pragmas make no difference in kernel:#pragma OPENCL EXTENSION cl_amd_media_ops : enable

Mining on Windows is relatively easy, with nanopool posting a binary build of siamining's gominer fork. For Ubuntu, you need to build it from the source. For that, you'll need to install go first. If you type 'go' in Ubuntu 14.04, you'll get the following message:The program 'go' is currently not installed. You can install it by typing:apt-get install gccgo-go

I tried the similar package 'gccgo', which turned out to be a rabbit hole. The version 1.4.2 referred to in the gominer readme is a version of the package 'golang'. Neither gccgo-go or gccgo have the latest libraries needed my gominer. And the most recent version of golang in the standard Ubuntu repositories is 1.3.3. However the Ethereum foundation publishes a 1.5.1 build of golang in their ppa.

Even with the golang 1.5.1, building gominer wasn't as simple as "go get github.com/SiaMining/gominer". The reason is that the gominer modifications to support pooled mining are in the "poolmod3" branch, and there is no option to install directly from a branch. So I made my own fork of the poolmod3 branch, and added detailed install instructions for Ubuntu:

Once I got it running on a single GPU, I wanted to find out if it was worthwhile to switch my eth mining rigs to sia. I couldn't find a good sia mining calculator, so I pieced together some information about mining rewards and used the Sia Pulse calculator. I wanted to compare a single R9 290 clocked at 1050/1125, which gets about 29Mh/s mining eth, earning $2.17/day. For Sia, the R9 290 gets about 1100Mh, which if you put that into the Sia Pulse calculator along with the current difficulty of 4740Th, it will calculate daily earnings of 6015 SC/day. Multiplying by the 62c/1000SC shown on sia.nanopool.org will give you a total of $3.73/d, but that will be wrong. The Sia Pulse calculator defaults to a block reward of 300,000, but that goes down by 1 for each block. So at block 59,900, the block reward is 240,100. and the actual earnings would be $2.99/d.

Since the earnings are almost 40% better than eth, I decided to switch my mining rigs from eth to sia. I had to adjust the overclocking settings, as sia is a compute-intensive algorithm instead of a memory-intensive algorithm like ethereum. After reducing the core clock of a couple cards from 1050 to 1025, the rigs were stable. When trying out nanopool, I was getting a lot of "ERROR fetching work;" and "Error submitting solution - Share rejected" messages. I think their servers may have been getting overloaded, as it worked fine when I switched to siamining.com. I also find siamining.com has more detailed stats, in particular % of rejected shares (all below 0.5% for me).

I may end up switching back to eth in the near future, since a doubling in network hashare for sia will eventually mean a doubling of the difficulty, cutting the amount of sia mined in half. In the process I'll at least have learned a bit about golang, and I can easily switch between eth and sia when one is more profitable than the other.

About Me

I have four children, two step-children, and a grand-daughter. Wife 1.0 was a failure, but as with many nerd projects, version 2.0 is a big improvement. :-) As an adult I was diagnosed with ADHD and Asperger's. gmail: ralphdoncaster