Estoy usando 63 registros / subprocesos, por lo que (32768 es el máximo) puedo usar aproximadamente 520 subprocesos. Ahora estoy usando 512 subprocesos en este ejemplo.

(El paralelismo está en la función "computeEvec" dentro de la función de función global computeEHfields). Los problemas son:

1) El error de verificación de mem a continuación.

2) Cuando uso numPointsRp> 2000, me muestra "sin memoria", pero (si no lo estoy haciendo mal) calculo la memoria global y está bien.

-------------------------------ACTUALIZADO------------------ ---------

Ejecuto el programa con cuda-memcheck y me da (solo cuando numPointsRs> numPointsRp):

========= Inválidoglobal lectura de tamaño 4

========= at 0x00000428 en computeEHfields

========= por hilo (2,0,0) en el bloque (0,0,0)

========= La dirección 0x4001076e0 está fuera de los límites

========= ========= Inválidoglobal lectura de tamaño 4

========= at 0x00000428 en computeEHfields

========= por hilo (1,0,0) en el bloque (0,0,0)

========= La dirección 0x4001076e0 está fuera de los límites

========= ========= Inválidoglobal lectura de tamaño 4

========= at 0x00000428 en computeEHfields

========= por hilo (0,0,0) en el bloque (0,0,0)

========= La dirección 0x4001076e0 está fuera de los límites

RESUMEN DE ERRORES: 160 errores

-----------EDITAR----------------------------

Además, algunas veces (si uso solo subprocesos y no bloques (no lo he probado para bloques)) si, por ejemplo, tengo numPointsRs = 1000 y numPointsRp = 100 y luego cambio numPointsRp = 200 y luego de nuevo cambio numPointsRp = 100 no estoy tomando los primeros resultados!

import pycuda.gpuarray as gpuarray
import pycuda.autoinit
from pycuda.compiler import SourceModule
import numpy as np
import cmath
import pycuda.driver as drv


Rs=np.zeros((numPointsRs,3)).astype(np.float32)
for k in range (numPointsRs): 
    Rs[k]=[0,k,0]

Rp=np.zeros((numPointsRp,3)).astype(np.float32)
for k in range (numPointsRp): 
    Rp[k]=[1+k,0,0]


#---- Initialization and passing(allocate memory and transfer data) to GPU -------------------------
Rs_gpu=gpuarray.to_gpu(Rs)
Rp_gpu=gpuarray.to_gpu(Rp)


J_gpu=gpuarray.to_gpu(np.ones((numPointsRs,3)).astype(np.complex64))
M_gpu=gpuarray.to_gpu(np.ones((numPointsRs,3)).astype(np.complex64))

Evec_gpu=gpuarray.to_gpu(np.zeros((numPointsRp,3)).astype(np.complex64))
Hvec_gpu=gpuarray.to_gpu(np.zeros((numPointsRp,3)).astype(np.complex64))
All_gpu=gpuarray.to_gpu(np.ones(numPointsRp).astype(np.complex64))


mod =SourceModule("""
#include <pycuda-complex.hpp>
#include <cmath>
#include <vector>
#define RowRsSize %(numrs)d
#define RowRpSize %(numrp)d


typedef  pycuda::complex<float> cmplx;
extern "C"{


    __device__ void computeEvec(float Rs_mat[][3], int numPointsRs,   
         cmplx J[][3],
         cmplx M[][3],
         float *Rp,
         cmplx kp, 
         cmplx eta,
         cmplx *Evec,
         cmplx *Hvec, cmplx *All)

{

    while (c<numPointsRs){
        ...         
                c++;

                }     
        }


__global__  void computeEHfields(float *Rs_mat_, int numPointsRs,   
        float *Rp_mat_, int numPointsRp,    
    cmplx *J_,
    cmplx *M_,
    cmplx  kp, 
    cmplx  eta,
    cmplx E[][3],
    cmplx H[][3], cmplx *All )
    {
        float Rs_mat[RowRsSize][3];
        float Rp_mat[RowRpSize][3];

        cmplx J[RowRsSize][3];
        cmplx M[RowRsSize][3];


    int k=threadIdx.x+blockIdx.x*blockDim.x;

      while (k<numPointsRp)  
     {

        computeEvec( Rs_mat, numPointsRs,  J, M, Rp_mat[k], kp, eta, E[k], H[k], All );
        k+=blockDim.x*gridDim.x;


    }

}
}

"""% { "numrs":numPointsRs, "numrp":numPointsRp},no_extern_c=1)


func = mod.get_function("computeEHfields")


func(Rs_gpu,np.int32(numPointsRs),Rp_gpu,np.int32(numPointsRp),J_gpu, M_gpu, np.complex64(kp), np.complex64(eta),Evec_gpu,Hvec_gpu, All_gpu, block=(128,1,1),grid=(200,1))

print(" \n")


#----- get data back from GPU-----
Rs=Rs_gpu.get()
Rp=Rp_gpu.get()
J=J_gpu.get()
M=M_gpu.get()
Evec=Evec_gpu.get()
Hvec=Hvec_gpu.get()
All=All_gpu.get()

-------------------- MODELO GPU ---------------------------- --------------------

Device 0: "GeForce GTX 560"
  CUDA Driver Version / Runtime Version          4.20 / 4.10
  CUDA Capability Major/Minor version number:    2.1
  Total amount of global memory:                 1024 MBytes (1073283072 bytes)
  ( 0) Multiprocessors x (48) CUDA Cores/MP:     0 CUDA Cores   //CUDA Cores    336 => 7 MP and 48 Cores/MP