Haskell中的OpenCL仅处理输入数组的某些元素

因此，我试图在Haskell中使用

OpenCL

，但它似乎只处理我给它的列表的一半，在每个元素之间放置一个0，然后只处理前

n

元素，即：我给它的列表：

[1,2,3,4,5,6]

它看到的列表：

[1,0,2,0,3,0]

。我正在使用

cabal

和

AMD

的

OpenCL库版本2.9-1中的
OpenCL
包。

OpenCL内核代码（C）：

int-power（int-a、int-n、int-mod）
{
整数倍=a；
int结果=1；
while（n）
{
如果（n&1）
结果=（结果*功率）%mod；
功率=（功率*功率）%mod；
n>>=1；
}
返回结果；
}
布尔见证（整数n、整数s、整数d、整数a）
{
int x=功率（a，d，n）；
int-y；
而{
y=（x*x）%n；
如果（y==1&&x！=1&&x！=n-1）
返回0；
x=y；
--s；
}
如果（y！=1）
返回0；
返回1；
}
int是素数（int n）
{
如果（（！（n&1））和&n！=2）| |（n<2）| |（n%3==0和&n！=3））
返回0；
如果（n您需要确保主机代码中缓冲区的数据布局符合设备的预期。这可以在示例代码中通过使用
Int32
而不是
Int
实现，使用
long
对我有效：

\uuuuu内核无效数组（\uuuu全局长*入，\uuuu全局长*出）
如果在主机代码中使用
Int32
而不是
Int
，会发生什么？哇，我从来没有想到问题是发送到内核的二进制数据。将其更改为32位Int似乎可以解决这个问题，谢谢you@jprice你应该把它作为一个答案贴出来。你应该使用
CInt
来回答这个问题是保证兼容的类型（通过可存储）使用C
int
类型。当提供一个旧问题的答案和现有答案时，解释你的答案有什么不同是很有用的。使用long over cint有什么好处？谢谢Jason Aller，邋遢的我…“cint”在我的代码版本中不起作用。所以我尝试了“long”。它确实起作用，所以它更像是一个额外的选项。（也许我应该问一个问题，为什么‘cint’在我的情况下不起作用？）
int power(int a, int n, int mod)
{
    int power = a;
    int result = 1;

    while (n)
    {
        if (n & 1)
            result = (result * power) % mod;
        power = (power * power) % mod;
        n >>= 1;
    }
    return result;
}

bool witness(int n, int s, int d, int a)
{
    int x = power(a, d, n);
    int y;

    while (s) {
        y = (x * x) % n;
        if (y == 1 && x != 1 && x != n - 1)
            return 0;
        x = y;
        --s;
    }
    if (y != 1)
        return 0;
    return 1;
}

int is_prime_mr(int n)
{
    if (((!(n & 1)) && n != 2) || (n < 2) || (n % 3 == 0 && n != 3))
        return 0;
    if (n <= 3)
        return 1;

    int d = n / 2;
    int s = 1;
    while (!(d & 1)) {
        d /= 2;
        ++s;
    }

    if (n < 1373653)
        return witness(n, s, d, 2) && witness(n, s, d, 3);
    if (n < 9080191)
        return witness(n, s, d, 31) && witness(n, s, d, 73);
    if (n < 4759123141)
        return witness(n, s, d, 2) && witness(n, s, d, 7) && witness(n, s, d, 61);
    if (n < 1122004669633)
        return witness(n, s, d, 2) && witness(n, s, d, 13) && witness(n, s, d, 23) && witness(n, s, d, 1662803);
    if (n < 2152302898747)
        return witness(n, s, d, 2) && witness(n, s, d, 3) && witness(n, s, d, 5) && witness(n, s, d, 7) && witness(n, s, d, 11);
    if (n < 3474749660383)
        return witness(n, s, d, 2) && witness(n, s, d, 3) && witness(n, s, d, 5) && witness(n, s, d, 7) && witness(n, s, d, 11) && witness(n, s, d, 13);
    return witness(n, s, d, 2) && witness(n, s, d, 3) && witness(n, s, d, 5) && witness(n, s, d, 7) && witness(n, s, d, 11) && witness(n, s, d, 13) && witness(n, s, d, 17);
}

__kernel void duparray(__global int *in, __global int *out )
{
    int id = get_global_id(0);

    if(id == 1)
    {
        int i = 0;
        for(i = 0; i <= 200; i++)
        {
            printf("%d\t", in[i]);
        }
    }

    //printf("%d :: %d\t\t",id, in[id]*2);
    out[id] = (is_prime_mr(in[id]) == 0) ? 0 : in[id];
    //out[id] = in[id];
}

import Control.Parallel.OpenCL
import Foreign( castPtr, nullPtr, sizeOf )
import Foreign.C.Types( CFloat )
import Foreign.Marshal.Array( newArray, peekArray )
import System.IO

upper = 200
lower = 0

main :: IO ()
main = do
  -- Initialize OpenCL
  (platform:_) <- clGetPlatformIDs
  (dev:_) <- clGetDeviceIDs platform CL_DEVICE_TYPE_ALL
  context <- clCreateContext [CL_CONTEXT_PLATFORM platform] [dev] print
  q <- clCreateCommandQueue context dev []


  handle <- openFile "gpuPrimalityTest.c" ReadMode
  programSource <- hGetContents handle

  -- Initialize Kernel
  program <- clCreateProgramWithSource context (programSource)
  clBuildProgram program [dev] ""
  kernel <- clCreateKernel program "duparray"

  -- Initialize parameters
  let original = [lower .. upper] :: [Int]
      elemSize = sizeOf (0 :: Int)
      vecSize = elemSize * length original
  -- putStrLn $ "Original array = " ++ show original
  input  <- newArray original

  mem_in <- clCreateBuffer context [CL_MEM_READ_ONLY, CL_MEM_COPY_HOST_PTR] (vecSize, castPtr input)  
  mem_out <- clCreateBuffer context [CL_MEM_WRITE_ONLY] (vecSize, nullPtr)

  clSetKernelArgSto kernel 0 mem_in
  clSetKernelArgSto kernel 1 mem_out

  -- Execute Kernel
  eventExec <- clEnqueueNDRangeKernel q kernel [length original] [] []

  -- Get Result
  eventRead <- clEnqueueReadBuffer q mem_out True 0 vecSize (castPtr input) [eventExec]

  result <- peekArray (length original) input
  putStrLn $ "Result array = " ++ show (filter (\x -> x/=0) result)

  return ()