Small program that burdens the GPU? - cuda

Question

What is the most efficient way to burden a GPU and increase the energy consuming for testing purpose?
I do want the program to be as small as possible. Is there a specific kernel function that does the job?
Any suggestion on Metal or Cuda will be perfect.

Answer 1

I am sketching a possible solution here. You will need some experiments to maximize the thermal load of your GPU. Generally speaking, data movement is energetically expensive, much more so than computation in modern processors. So shuffling a lot of data will drive up power consumption. At the same time, we want an additive contribution to power consumption from computational units. Multipliers tend to be the largest power hogs; in modern processors we might want to target FMA (fused multiply-add) units.
Various GPUs have low throughput of double-precision math ops, others have low throughput of half-precision math ops. Therefore we would want to focus on single-precision math for the computational portion of our load. We want to be able to change the ratio of computation to memory activity easily. One approach would be to use the unrolled evaluation of a polynomial with the Horner scheme as the basic building block, using POLY_DEPTH steps. This we repeat REPS time in a loop. Prior to the loop we retrieve source data from global memory, and after the loop terminates we store the result to global memory. By varying REPS we can experiment with various settings of compute / memory balances.
One could further experiment with instruction-level parallelism, data patterns (as the power consumption of multipliers often differs based on bit patterns), and adding PCIe activity by using CUDA streams to achieve overlap of kernel execution and PCIe data transfers. Below I just used some random constants as multiplier data.
Obviously we would want to fill the GPU with lots of threads. For this we may use a fairly small THREADS_PER_BLK value giving us fine granularity for filling each SM. We might want to choose the number of blocks to be a multiple of the number of SM to spread load as evenly as possible, or use a MAX_BLOCKS value that is evenly divides common SM counts. How much source and destination memory we should touch will be up to experimentation: We can define arrays of LEN elements as a multiple of the number of blocks. Lastly, we want to execute the kernel thus defined and configured ITER number of times to create a continuous load for some time.
Note that as we apply load, the GPU will heat up and this will in turn further increase its power draw. To achieve maximum thermal load it will be necessary to run the load-generating app for 5 minutes or more. Note further that the GPU power management may dynamically reduce clock frequencies and voltages to reduce power consumption, and the power cap may kick in before you reach the thermal limit. Depending on the GPU you may be able to set a power cap higher than the one used by default with the nvidia-smi utility.
The program below keeps my Quadro P2000 pegged at the power cap, with a GPU load of 98% and a memory controller load of 83%-86%, as reported by TechPowerUp's GPU-Z utility. It will certainly require adjustments for other GPUs.
#include <stdlib.h>
#include <stdio.h>
#define THREADS_PER_BLK (128)
#define MAX_BLOCKS (65520)
#define LEN (MAX_BLOCKS * 1024)
#define POLY_DEPTH (30)
#define REPS (2)
#define ITER (100000)
// Macro to catch CUDA errors in CUDA runtime calls
#define CUDA_SAFE_CALL(call) \
do { \
cudaError_t err = call; \
if (cudaSuccess != err) { \
fprintf (stderr, "Cuda error in file '%s' in line %i : %s.\n",\
__FILE__, __LINE__, cudaGetErrorString(err) ); \
exit(EXIT_FAILURE); \
} \
} while (0)
// Macro to catch CUDA errors in kernel launches
#define CHECK_LAUNCH_ERROR() \
do { \
/* Check synchronous errors, i.e. pre-launch */ \
cudaError_t err = cudaGetLastError(); \
if (cudaSuccess != err) { \
fprintf (stderr, "Cuda error in file '%s' in line %i : %s.\n",\
__FILE__, __LINE__, cudaGetErrorString(err) ); \
exit(EXIT_FAILURE); \
} \
/* Check asynchronous errors, i.e. kernel failed (ULF) */ \
err = cudaDeviceSynchronize(); \
if (cudaSuccess != err) { \
fprintf (stderr, "Cuda error in file '%s' in line %i : %s.\n",\
__FILE__, __LINE__, cudaGetErrorString( err) ); \
exit(EXIT_FAILURE); \
} \
} while (0)
__global__ void burn (const float * __restrict__ src,
float * __restrict__ dst, int len)
{
int stride = gridDim.x * blockDim.x;
int tid = blockDim.x * blockIdx.x + threadIdx.x;
for (int i = tid; i < len; i += stride) {
float p = src[i] + 1.0;
float q = src[i] + 3.0f;
for (int k = 0; k < REPS; k++) {
#pragma unroll POLY_DEPTH
for (int j = 0; j < POLY_DEPTH; j++) {
p = fmaf (p, 0.68073987f, 0.8947237f);
q = fmaf (q, 0.54639739f, 0.9587058f);
}
}
dst[i] = p + q;
}
}
int main (int argc, char *argv[])
{
float *d_a, *d_b;
/* Allocate memory on device */
CUDA_SAFE_CALL (cudaMalloc((void**)&d_a, sizeof(d_a[0]) * LEN));
CUDA_SAFE_CALL (cudaMalloc((void**)&d_b, sizeof(d_b[0]) * LEN));
/* Initialize device memory */
CUDA_SAFE_CALL (cudaMemset(d_a, 0x00, sizeof(d_a[0]) * LEN)); // zero
CUDA_SAFE_CALL (cudaMemset(d_b, 0xff, sizeof(d_b[0]) * LEN)); // NaN
/* Compute execution configuration */
dim3 dimBlock(THREADS_PER_BLK);
int threadBlocks = (LEN + (dimBlock.x - 1)) / dimBlock.x;
if (threadBlocks > MAX_BLOCKS) threadBlocks = MAX_BLOCKS;
dim3 dimGrid(threadBlocks);
printf ("burn: using %d threads per block, %d blocks, %f GB\n",
dimBlock.x, dimGrid.x, 2e-9*LEN*sizeof(d_a[0]));
for (int k = 0; k < ITER; k++) {
burn<<<dimGrid,dimBlock>>>(d_a, d_b, LEN);
CHECK_LAUNCH_ERROR();
}
CUDA_SAFE_CALL (cudaFree(d_a));
CUDA_SAFE_CALL (cudaFree(d_b));
return EXIT_SUCCESS;
}