TransSectorOnGPU.cu File Reference

Functions
template<typename Scalar_t >
__global__ void	adjointBasis_kernel (SparseCompressed< Complex_t< Scalar_t > > *res, TransSector< Scalar_t > *transSectorPtr)
template<typename Scalar_t >
__global__ void	testObject_kernel (TransSector< Scalar_t > *transSectorPtr)
template<typename Scalar_t >
__global__ void	testObject_kernel (SparseCompressed< Scalar_t > const *inMatPtr)
int	main (int argc, char **argv)

Function Documentation

adjointBasis_kernel()

template<typename Scalar_t >

__global__ void adjointBasis_kernel	(	SparseCompressed< Complex_t< Scalar_t > > *	res,
		TransSector< Scalar_t > *	transSectorPtr
	)

                                                                                           {
    (*res) = (*transSectorPtr).basis().adjoint();
}

main()

int main	(	int	argc,
		char **	argv
	)

                                {
    if(argc != 2) {
        std::cerr << "Usage: 1.This, 2.SystemSize" << std::endl;
        std::exit(EXIT_FAILURE);
    }
    int L      = std::atoi(argv[1]);
    int dimLoc = 2, k = 0;
 
    size_t size;
    cudaDeviceGetLimit(&size, cudaLimitMallocHeapSize);
    printf("Heap Size=%ld\n", size);
    size = 1024 * 1024 * 1024;
    cudaDeviceSetLimit(cudaLimitMallocHeapSize, size_t(4) * size_t(1024 * 1024 * 1024));
    void (*funcPtr)(TransSector<float>*) = testObject_kernel;
    struct cudaFuncAttributes attr;
    cuCHECK(cudaFuncGetAttributes(&attr, funcPtr));
    std::cout << "# Function: testObject_kernel(TransSector<float>*)"
              << "\n"
              << "# constSizeBytes            = " << attr.constSizeBytes << "\n"
              << "# localSizeBytes            = " << attr.localSizeBytes << "\n"
              << "# maxDynamicSharedSizeBytes = " << attr.maxDynamicSharedSizeBytes << "\n"
              << "# maxThreadsPerBlock        = " << attr.maxThreadsPerBlock << "\n"
              << "# sharedSizeBytes           = " << attr.sharedSizeBytes << std::endl;
 
    ObjectOnGPU< TransSector<float> > dTransSector(k, L, dimLoc);
    testObject_kernel<<<1, 1>>>(dTransSector.ptr());
    cuCHECK(cudaPeekAtLastError());
    cuCHECK(cudaDeviceSynchronize());
    std::cout << "Constructed an instance of ObjectOnGPU< TransSector<float> >" << std::endl;
 
    ObjectOnGPU< SparseCompressed<Complex_t<float>> > adjointBasis;
    adjointBasis_kernel<<<1, 1>>>(adjointBasis.ptr(), dTransSector.ptr());
    cuCHECK(cudaPeekAtLastError());
    cuCHECK(cudaDeviceSynchronize());
 
    testObject_kernel<<<1, 1>>>(adjointBasis.ptr());
    cuCHECK(cudaPeekAtLastError());
    cuCHECK(cudaDeviceSynchronize());
 
    return EXIT_SUCCESS;
}

testObject_kernel() [1/2]

template<typename Scalar_t >

__global__ void testObject_kernel

(

SparseCompressed< Scalar_t > const *

inMatPtr

)

                                                                              {
    SparseCompressed<Scalar_t> const& inMat = *inMatPtr;
    printf("\ntestObject_kernel: OuterIndex\n");
    for(int j = 0; j != inMat.outerSize() + 1; ++j) { printf("%d ", inMat.outerIndexPtr()[j]); }
    printf("\n");
    printf("testObject_kernel: NonZeros\n");
    for(int j = 0; j != inMat.nonZeros(); ++j) {
        printf("(%d %f%+f*i) ", inMat.innerIndexPtr()[j], inMat.valuePtr()[j].real(),
               inMat.valuePtr()[j].imag());
    }
    printf("\n\n");
}

testObject_kernel() [2/2]

template<typename Scalar_t >

__global__ void testObject_kernel

(

TransSector< Scalar_t > *

transSectorPtr

)

                                                                         {
    int const idx = blockIdx.x * blockDim.x + threadIdx.x;
    int const idy = blockIdx.y * blockDim.y + threadIdx.y;
    if(idx >= 1 || idy >= 1) return;
 
    TransSector<Scalar_t>& transSector = *transSectorPtr;
 
    printf("testObject_kernel: OuterIndex\n");
    for(int j = 0; j != transSector.dim() + 1; ++j) {
        printf("%d ", transSector.basis().outerIndexPtr()[j]);
    }
    printf("\n");
    printf("testObject_kernel: NonZeros\n");
    for(int j = 0; j != transSector.basis().nonZeros(); ++j) {
        printf("(%d %f%+f*i) ", transSector.basis().innerIndexPtr()[j],
               transSector.basis().valuePtr()[j].real(), transSector.basis().valuePtr()[j].imag());
    }
    printf("\n\n");
 
    printf("testObject_kernel: transSector.totalSpace().transEqDim() = %d\n",
           transSector.totalSpace().transEqDim());
    printf("testObject_kernel: transEqClassRep\n");
    for(int j = 0; j != transSector.totalSpace().transEqDim(); ++j) {
        printf("%d ", transSector.totalSpace().transEqClassRep(j));
    }
    printf("\n");
    printf("testObject_kernel: transPeriod\n");
    for(int j = 0; j != transSector.totalSpace().transEqDim(); ++j) {
        printf("%d ", transSector.totalSpace().transPeriod(j));
    }
    printf("\n\n");
}