如何在OpenCV GPU环境下指定线程数或使用的核心数？

Hey there! Let's break down how to handle thread/core control when using OpenCV with GPU in VB/C++:

First off, OpenCV's GPU module (the cuda::* functions) is a high-level wrapper around CUDA. It automatically handles thread block and grid scheduling based on your GPU's streaming multiprocessors (SMs) and core count. The goal here is to abstract away low-level CUDA details so you can focus on computer vision logic, rather than manually tuning thread configurations.

Short answer: No, not directly through OpenCV's GPU API. OpenCV hides the underlying CUDA thread setup from users. It optimizes thread layouts automatically for common CV operations, so there’s no built-in way to force 8, 16, or a specific number of threads via OpenCV calls alone.

If you need precise control over thread counts, you can bridge OpenCV's GPU data structures with raw CUDA kernel code. Here's how to do it in C++ (for VB, you’ll need to wrap this into a DLL to call from your VB project):

1. Access raw CUDA pointers from OpenCV GpuMat

   cv::cuda::GpuMat d_input;
   // Load/process your image into d_input using OpenCV GPU functions...
   uchar* d_ptr = d_input.ptr<uchar>();
   size_t row_step = d_input.step;
   int rows = d_input.rows;
   int cols = d_input.cols;
   

2. Write a custom CUDA kernel with explicit thread sizing
   Define your kernel and specify how many threads run per block (this is where you set 8, 16, etc.):

   __global__ void custom_processing(uchar* input, size_t step, int rows, int cols) {
       // Calculate pixel coordinates from thread/block indices
       int x = blockIdx.x * blockDim.x + threadIdx.x;
       int y = blockIdx.y * blockDim.y + threadIdx.y;
       
       if (x < cols && y < rows) {
           uchar* row_ptr = input + y * step;
           // Your custom pixel-level logic here (e.g., invert pixel value)
           row_ptr[x] = 255 - row_ptr[x];
       }
   }
   

3. Launch the kernel with your desired thread configuration
   Choose your thread block size (e.g., 8x8, 16x1) and calculate the grid size to cover all pixels:

   // Example: Use 16x16 threads per block (256 total threads per block)
   dim3 block_size(16, 16);
   // Calculate grid dimensions to cover the entire image
   dim3 grid_size((cols + block_size.x - 1) / block_size.x, 
                  (rows + block_size.y - 1) / block_size.y);
   
   // Launch the kernel
   custom_processing<<<grid_size, block_size>>>(d_ptr, row_step, rows, cols);
   // Wait for kernel to finish before using the data again
   cudaDeviceSynchronize();
   

4. Continue processing with OpenCV
   After running your custom kernel, you can keep using the GpuMat with OpenCV's GPU functions as usual.

You can’t directly "assign" specific GPU cores to your program—CUDA’s scheduler dynamically distributes thread blocks across available SMs. However, you can indirectly influence core utilization by adjusting your kernel’s thread block count and size:

• Using fewer thread blocks may result in fewer SMs being utilized (though CUDA may still distribute work to idle SMs if possible).
• For tighter control, you can use CUDA’s cudaSetDeviceFlags or system-level tools (like NVIDIA Control Panel) to limit overall GPU utilization, but these are global settings, not per-program.

Since VB doesn’t natively support CUDA, you’ll need to:

1. Compile your CUDA/C++ code into a Windows DLL.
2. Use VB’s Declare statement or P/Invoke to call functions from the DLL, passing image data (or pointers to GpuMat buffers) between your VB project and the CUDA code.

内容的提问来源于stack exchange，提问作者walid hamdy