Function philoxUniform

src/backend/cpu/kernel/random_engine.hpp:192–233

// This change was prompted by issue #2429
template<typename T>
void philoxUniform(T *out, size_t elements, const uintl seed, uintl counter) {
    uint hi  = seed >> 32;
    uint lo  = seed;
    uint hic = counter >> 32;
    uint loc = counter;

    constexpr size_t RESET_CTR = MAX_RESET_CTR_VAL / sizeof(T);
    constexpr size_t ELEMS_PER_ITER =
        WRITE_STRIDE * 4 * sizeof(uint) / sizeof(T);

    int num_iters = divup(elements, ELEMS_PER_ITER);
    size_t len    = num_iters * ELEMS_PER_ITER;

    constexpr size_t NUM_WRITES = 16 / sizeof(T);
    for (size_t iter = 0; iter < len; iter += ELEMS_PER_ITER) {
        for (size_t i = 0; i < WRITE_STRIDE; i += RESET_CTR) {
            for (size_t j = 0; j < RESET_CTR; ++j) {
                // first_write_idx is the first of the 4 locations that will
                // be written to
                uintptr_t first_write_idx = iter + i + j;
                if (first_write_idx >= elements) { break; }

                // Recalculate key and ctr to emulate how the CUDA backend
                // calculates these per thread
                uint key[2] = {lo, hi};
                uint ctr[4] = {loc + (uint)first_write_idx, 0, 0, 0};
                ctr[1]      = hic + (ctr[0] < loc);
                ctr[2]      = (ctr[1] < hic);
                philox(key, ctr);

                // Use the same ctr array for each of the 4 locations,
                // but each of the location gets a different ctr value
                for (uint buf_idx = 0; buf_idx < NUM_WRITES; ++buf_idx) {
                    size_t out_idx = iter + buf_idx * WRITE_STRIDE + i + j;
                    if (out_idx < elements) {
                        out[out_idx] = transform<T>(ctr, buf_idx);
                    }
                }
            }
        }
    }
}

#undef MAX_RESET_CTR_VAL
#undef WRITE_STRIDE