CUDA，使用memset（或fill或...）设置float到max val的数组

Question

Edit: Thanks for the previous answers. but in fact I want to do it in CUDA, and apparently there is no function Fill for CUDA. I have to fill the matrix once for each thread so I want to make sure I'm using the fastest way possible. Is this for loop my best choice?

I want to set the matrix of float to the maximum value possible (in float). What is the correct way of doing this job?

float *matrix=new float[N*N];

for (int i=0;i<N*N;i++){
        matrix[i*N+j]=999999;
}

Thanks in advance.

Answer 1

The easiest approach in CUDA is to use thrust::fill . Thrust is included with CUDA 4.0 and later, or you can install it if you are using CUDA 3.2.

#include <thrust/fill.h>
#include <thrust/device_vector.h>
...
thrust::device_vector<float> v(N*N);
thrust::fill(v.begin(), v.end(), std::numeric_limits<float>::max()); // or 999999.f if you prefer

You could also write pure CUDA code something like this:

template <typename T>
__global__ void initMatrix(T *matrix, int width, int height, T val) {
    int idx = blockIdx.x * blockDim.x + threadIdx.x;

    for (int i = idx; i < width * height; i += gridDim.x * blockDim.x) {
        matrix[i]=val;
    }
}

int main(void) {
    float *matrix = 0;
    cudaMalloc((void*)&matrix, N*N * sizeof(float));

    int blockSize = 256;
    int numBlocks = (N*N + blockSize - 1) / (N*N);
    initMatrix<<<numBlocks, blockSize>>>(matrix, N, N, 
                                         std::numeric_limits<float>::max()); // or 999999.f if you prefer
}

Answer 2

You need to iterate through the array and set each float element to std::numeric_limits<float>::max() in limits ... you can't use memset for this since it sets every byte in a memory buffer, not a multi-byte value like a float, etc., to a specific value.

So you would end up with code that looks like the following since you're only using a single array for your matrix (ie, you don't need the second for-loop):

#include <limits>

float* matrix = new float[N*N];

for (int i=0; i < N*N; i++)
{
    matrix[i] = std::numeric_limits<float>::max();
}

The second huge problem with your request is that memset takes an integral-type for the value to set each byte to, so you'd have to get the actual bit-pattern of the max floating point value, and use that as the input to memset . But even that won't work since memset can only set each byte in a memory buffer to a given value, therefore if you pass a 32-bit integral value representing a floating point value to memset , it's only going to use the lower 8-bits ... so in the end it's not just something we're not advising you to-do, but it's impossible for the way that memset has been implemented. You simply can't use memset to initialize a memory buffer of multi-byte types to a specific value unless you are wanting to zero-out the values, or you are doing some odd hack that lets you write the same value to all the bytes that compose a multi-byte data-type.

Answer 3

Use std::numeric_limits<float>::max() and std::fill as:

#include <limits>     //for std::numeric_limits<> 
#include <algorithm>  //for std::fill

std::fill(matrix, matrix + N*N, std::numeric_limits<float>::max());

Or, std::fill_n as (looks better):

std::fill_n(matrix, N*N, std::numeric_limits<float>::max());

See these online documentation:

• std::fill
• std::fill_n

Answer 4

我建议轻松完成这项工作，使用std :: fill代替算法标题。

std::fill( matrix, matrix + (N*N), 999999 ) ;

Answer 5

Instead of using dynamic memory in C++, use vector and watch it do all the work for you:

std::vector<float> matrix(N * N, std::numeric_limits<float>::max());

In fact you can even make it a 2d matrix easily:

std::vector<std::vector<float> > matrix(N, std::vector<float>(N, std::numeric_limits<float>::max()));

Answer 6

C ++方式：

std::fill(matrix, matrix + N*N, std::numeric_limits<float>::max());

Answer 7

Is matrix global memory or thread local memory? If it is in global memory, and you only need to initialize (rather than a reset in the middle of a kernel), then you can use memset from the host before launching the kernel. If it is in the middle of the kernel, consider breaking the kernel into two pieces so you can still use cudaMemset.

cudaMemset(matrix,std::numeric_limits<float>::max(),N*N*blockSize);