mirror of
https://github.com/NVIDIA/cuda-samples.git
synced 2026-10-25 22:28:17 +08:00
Apply consistent code formatting across the repo. Add clang-format and pre-commit hooks.
This commit is contained in:
Rob Armstrong
@@ -25,8 +25,8 @@
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#include <helper_cuda.h> // helper functions for CUDA error check
|
||||
#include <iostream>
|
||||
#include <helper_cuda.h> // helper functions for CUDA error check
|
||||
|
||||
const int manualBlockSize = 32;
|
||||
|
||||
@@ -38,13 +38,14 @@ const int manualBlockSize = 32;
|
||||
// execution configuration, including anything the launch configurator
|
||||
// API suggests.
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
__global__ void square(int *array, int arrayCount) {
|
||||
extern __shared__ int dynamicSmem[];
|
||||
int idx = threadIdx.x + blockIdx.x * blockDim.x;
|
||||
__global__ void square(int *array, int arrayCount)
|
||||
{
|
||||
extern __shared__ int dynamicSmem[];
|
||||
int idx = threadIdx.x + blockIdx.x * blockDim.x;
|
||||
|
||||
if (idx < arrayCount) {
|
||||
array[idx] *= array[idx];
|
||||
}
|
||||
if (idx < arrayCount) {
|
||||
array[idx] *= array[idx];
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -58,29 +59,28 @@ __global__ void square(int *array, int arrayCount) {
|
||||
// This wrapper routine computes the occupancy of kernel, and reports
|
||||
// it in terms of active warps / maximum warps per SM.
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
static double reportPotentialOccupancy(void *kernel, int blockSize,
|
||||
size_t dynamicSMem) {
|
||||
int device;
|
||||
cudaDeviceProp prop;
|
||||
static double reportPotentialOccupancy(void *kernel, int blockSize, size_t dynamicSMem)
|
||||
{
|
||||
int device;
|
||||
cudaDeviceProp prop;
|
||||
|
||||
int numBlocks;
|
||||
int activeWarps;
|
||||
int maxWarps;
|
||||
int numBlocks;
|
||||
int activeWarps;
|
||||
int maxWarps;
|
||||
|
||||
double occupancy;
|
||||
double occupancy;
|
||||
|
||||
checkCudaErrors(cudaGetDevice(&device));
|
||||
checkCudaErrors(cudaGetDeviceProperties(&prop, device));
|
||||
checkCudaErrors(cudaGetDevice(&device));
|
||||
checkCudaErrors(cudaGetDeviceProperties(&prop, device));
|
||||
|
||||
checkCudaErrors(cudaOccupancyMaxActiveBlocksPerMultiprocessor(
|
||||
&numBlocks, kernel, blockSize, dynamicSMem));
|
||||
checkCudaErrors(cudaOccupancyMaxActiveBlocksPerMultiprocessor(&numBlocks, kernel, blockSize, dynamicSMem));
|
||||
|
||||
activeWarps = numBlocks * blockSize / prop.warpSize;
|
||||
maxWarps = prop.maxThreadsPerMultiProcessor / prop.warpSize;
|
||||
activeWarps = numBlocks * blockSize / prop.warpSize;
|
||||
maxWarps = prop.maxThreadsPerMultiProcessor / prop.warpSize;
|
||||
|
||||
occupancy = (double)activeWarps / maxWarps;
|
||||
occupancy = (double)activeWarps / maxWarps;
|
||||
|
||||
return occupancy;
|
||||
return occupancy;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -99,65 +99,63 @@ static double reportPotentialOccupancy(void *kernel, int blockSize,
|
||||
// This function configures the launch based on the "automatic"
|
||||
// argument, records the runtime, and reports occupancy and runtime.
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
static int launchConfig(int *array, int arrayCount, bool automatic) {
|
||||
int blockSize;
|
||||
int minGridSize;
|
||||
int gridSize;
|
||||
size_t dynamicSMemUsage = 0;
|
||||
static int launchConfig(int *array, int arrayCount, bool automatic)
|
||||
{
|
||||
int blockSize;
|
||||
int minGridSize;
|
||||
int gridSize;
|
||||
size_t dynamicSMemUsage = 0;
|
||||
|
||||
cudaEvent_t start;
|
||||
cudaEvent_t end;
|
||||
cudaEvent_t start;
|
||||
cudaEvent_t end;
|
||||
|
||||
float elapsedTime;
|
||||
float elapsedTime;
|
||||
|
||||
double potentialOccupancy;
|
||||
double potentialOccupancy;
|
||||
|
||||
checkCudaErrors(cudaEventCreate(&start));
|
||||
checkCudaErrors(cudaEventCreate(&end));
|
||||
checkCudaErrors(cudaEventCreate(&start));
|
||||
checkCudaErrors(cudaEventCreate(&end));
|
||||
|
||||
if (automatic) {
|
||||
checkCudaErrors(cudaOccupancyMaxPotentialBlockSize(
|
||||
&minGridSize, &blockSize, (void *)square, dynamicSMemUsage,
|
||||
arrayCount));
|
||||
if (automatic) {
|
||||
checkCudaErrors(
|
||||
cudaOccupancyMaxPotentialBlockSize(&minGridSize, &blockSize, (void *)square, dynamicSMemUsage, arrayCount));
|
||||
|
||||
std::cout << "Suggested block size: " << blockSize << std::endl
|
||||
<< "Minimum grid size for maximum occupancy: " << minGridSize
|
||||
<< std::endl;
|
||||
} else {
|
||||
// This block size is too small. Given limited number of
|
||||
// active blocks per multiprocessor, the number of active
|
||||
// threads will be limited, and thus unable to achieve maximum
|
||||
// occupancy.
|
||||
std::cout << "Suggested block size: " << blockSize << std::endl
|
||||
<< "Minimum grid size for maximum occupancy: " << minGridSize << std::endl;
|
||||
}
|
||||
else {
|
||||
// This block size is too small. Given limited number of
|
||||
// active blocks per multiprocessor, the number of active
|
||||
// threads will be limited, and thus unable to achieve maximum
|
||||
// occupancy.
|
||||
//
|
||||
blockSize = manualBlockSize;
|
||||
}
|
||||
|
||||
// Round up
|
||||
//
|
||||
blockSize = manualBlockSize;
|
||||
}
|
||||
gridSize = (arrayCount + blockSize - 1) / blockSize;
|
||||
|
||||
// Round up
|
||||
//
|
||||
gridSize = (arrayCount + blockSize - 1) / blockSize;
|
||||
// Launch and profile
|
||||
//
|
||||
checkCudaErrors(cudaEventRecord(start));
|
||||
square<<<gridSize, blockSize, dynamicSMemUsage>>>(array, arrayCount);
|
||||
checkCudaErrors(cudaEventRecord(end));
|
||||
|
||||
// Launch and profile
|
||||
//
|
||||
checkCudaErrors(cudaEventRecord(start));
|
||||
square<<<gridSize, blockSize, dynamicSMemUsage>>>(array, arrayCount);
|
||||
checkCudaErrors(cudaEventRecord(end));
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
|
||||
checkCudaErrors(cudaDeviceSynchronize());
|
||||
// Calculate occupancy
|
||||
//
|
||||
potentialOccupancy = reportPotentialOccupancy((void *)square, blockSize, dynamicSMemUsage);
|
||||
|
||||
// Calculate occupancy
|
||||
//
|
||||
potentialOccupancy =
|
||||
reportPotentialOccupancy((void *)square, blockSize, dynamicSMemUsage);
|
||||
std::cout << "Potential occupancy: " << potentialOccupancy * 100 << "%" << std::endl;
|
||||
|
||||
std::cout << "Potential occupancy: " << potentialOccupancy * 100 << "%"
|
||||
<< std::endl;
|
||||
// Report elapsed time
|
||||
//
|
||||
checkCudaErrors(cudaEventElapsedTime(&elapsedTime, start, end));
|
||||
std::cout << "Elapsed time: " << elapsedTime << "ms" << std::endl;
|
||||
|
||||
// Report elapsed time
|
||||
//
|
||||
checkCudaErrors(cudaEventElapsedTime(&elapsedTime, start, end));
|
||||
std::cout << "Elapsed time: " << elapsedTime << "ms" << std::endl;
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -166,41 +164,41 @@ static int launchConfig(int *array, int arrayCount, bool automatic) {
|
||||
// The test generates an array and squares it with a CUDA kernel, then
|
||||
// verifies the result.
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
static int test(bool automaticLaunchConfig, const int count = 1000000) {
|
||||
int *array;
|
||||
int *dArray;
|
||||
int size = count * sizeof(int);
|
||||
static int test(bool automaticLaunchConfig, const int count = 1000000)
|
||||
{
|
||||
int *array;
|
||||
int *dArray;
|
||||
int size = count * sizeof(int);
|
||||
|
||||
array = new int[count];
|
||||
array = new int[count];
|
||||
|
||||
for (int i = 0; i < count; i += 1) {
|
||||
array[i] = i;
|
||||
}
|
||||
|
||||
checkCudaErrors(cudaMalloc(&dArray, size));
|
||||
checkCudaErrors(cudaMemcpy(dArray, array, size, cudaMemcpyHostToDevice));
|
||||
|
||||
for (int i = 0; i < count; i += 1) {
|
||||
array[i] = 0;
|
||||
}
|
||||
|
||||
launchConfig(dArray, count, automaticLaunchConfig);
|
||||
|
||||
checkCudaErrors(cudaMemcpy(array, dArray, size, cudaMemcpyDeviceToHost));
|
||||
checkCudaErrors(cudaFree(dArray));
|
||||
|
||||
// Verify the return data
|
||||
//
|
||||
for (int i = 0; i < count; i += 1) {
|
||||
if (array[i] != i * i) {
|
||||
std::cout << "element " << i << " expected " << i * i << " actual "
|
||||
<< array[i] << std::endl;
|
||||
return 1;
|
||||
for (int i = 0; i < count; i += 1) {
|
||||
array[i] = i;
|
||||
}
|
||||
}
|
||||
delete[] array;
|
||||
|
||||
return 0;
|
||||
checkCudaErrors(cudaMalloc(&dArray, size));
|
||||
checkCudaErrors(cudaMemcpy(dArray, array, size, cudaMemcpyHostToDevice));
|
||||
|
||||
for (int i = 0; i < count; i += 1) {
|
||||
array[i] = 0;
|
||||
}
|
||||
|
||||
launchConfig(dArray, count, automaticLaunchConfig);
|
||||
|
||||
checkCudaErrors(cudaMemcpy(array, dArray, size, cudaMemcpyDeviceToHost));
|
||||
checkCudaErrors(cudaFree(dArray));
|
||||
|
||||
// Verify the return data
|
||||
//
|
||||
for (int i = 0; i < count; i += 1) {
|
||||
if (array[i] != i * i) {
|
||||
std::cout << "element " << i << " expected " << i * i << " actual " << array[i] << std::endl;
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
delete[] array;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
@@ -210,31 +208,31 @@ static int test(bool automaticLaunchConfig, const int count = 1000000) {
|
||||
// automatically configured launch, and reports the occupancy and
|
||||
// performance.
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
int main() {
|
||||
int status;
|
||||
int main()
|
||||
{
|
||||
int status;
|
||||
|
||||
std::cout << "starting Simple Occupancy" << std::endl << std::endl;
|
||||
std::cout << "starting Simple Occupancy" << std::endl << std::endl;
|
||||
|
||||
std::cout << "[ Manual configuration with " << manualBlockSize
|
||||
<< " threads per block ]" << std::endl;
|
||||
std::cout << "[ Manual configuration with " << manualBlockSize << " threads per block ]" << std::endl;
|
||||
|
||||
status = test(false);
|
||||
if (status) {
|
||||
std::cerr << "Test failed\n" << std::endl;
|
||||
return -1;
|
||||
}
|
||||
status = test(false);
|
||||
if (status) {
|
||||
std::cerr << "Test failed\n" << std::endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::cout << std::endl;
|
||||
std::cout << std::endl;
|
||||
|
||||
std::cout << "[ Automatic, occupancy-based configuration ]" << std::endl;
|
||||
status = test(true);
|
||||
if (status) {
|
||||
std::cerr << "Test failed\n" << std::endl;
|
||||
return -1;
|
||||
}
|
||||
std::cout << "[ Automatic, occupancy-based configuration ]" << std::endl;
|
||||
status = test(true);
|
||||
if (status) {
|
||||
std::cerr << "Test failed\n" << std::endl;
|
||||
return -1;
|
||||
}
|
||||
|
||||
std::cout << std::endl;
|
||||
std::cout << "Test PASSED\n" << std::endl;
|
||||
std::cout << std::endl;
|
||||
std::cout << "Test PASSED\n" << std::endl;
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user