Method genBlocks

src/backend/cuda/threadsMgt.hpp:215–327

// executed in the kernel
template<typename T>
inline dim3 threadsMgt<T>::genBlocks(const dim3& threads,
                                     const unsigned nrInputs,
                                     const unsigned nrOutputs,
                                     const size_t totalSize,
                                     const size_t sizeofT) {
    // The bottleneck of anykernel is dependent on the type of memory
    // used.
    // a) For very small arrays (elements < maxParallelThreads), each
    //  element receives it individual thread.
    // b) For arrays (in+out) smaller than 3/2 L2cache, memory access no
    //  longer is the bottleneck, because enough L2cache is available at any
    //  time. Threads are limited to reduce scheduling overhead.
    // c) For very large arrays and type sizes (<long double), 1 thread will
    //  not generate enough data to keep the memory sync mechanism
    //  saturated, so we start loooping inside each thread.
    dim3 blocks{1};
    const int activeDeviceId{getActiveDeviceId()};
    const unsigned* maxGridSize{
        reinterpret_cast<const unsigned*>(getMaxGridSize(activeDeviceId))};
    const size_t L2CacheSize{getL2CacheSize(activeDeviceId)};
    const unsigned cacheLine{getMemoryBusWidth(activeDeviceId)};
    const unsigned multiProcessorCount{getMultiProcessorCount(activeDeviceId)};
    const unsigned maxThreads{maxParallelThreads *
                              (sizeofT * nrInputs * nrInputs > 8 ? 1 : 2)};

    if (ndims == 1) {
        if (d0 > maxThreads) {
            if (totalSize * 2 > L2CacheSize * 3) {
                // General formula to calculate best #loops
                // Dedicated GPUs:
                //  32/sizeof(T)**2/#outBuffers*(3/4)**(#inBuffers-1)
                // Integrated GPUs:
                //  4/sizeof(T)/#outBuffers*(3/4)**(#inBuffers-1)
                unsigned largeVolDivider{cacheLine == 64
                                             ? sizeofT == 1   ? 4
                                               : sizeofT == 2 ? 2
                                                              : 1
                                             : (sizeofT == 1   ? 32
                                                : sizeofT == 2 ? 8
                                                               : 1) /
                                                   nrOutputs};
                for (unsigned i{1}; i < nrInputs; ++i)
                    largeVolDivider = largeVolDivider * 3 / 4;
                if (largeVolDivider > 1) {
                    blocks.x = d0 / (largeVolDivider * threads.x);
                    if (blocks.x == 0) blocks.x = 1;
                    loop0 = true;
                }
            } else {
                // A reduction to (1|2*)maxParallelThreads will be
                // performed
                blocks.x = maxThreads / threads.x;
                if (blocks.x == 0) blocks.x = 1;
                loop0 = true;
            }
        }
        if (!loop0) { blocks.x = divup(d0, threads.x); }
    } else {