constructGlobal_h_gpu.cu File Reference

Functions
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

                                {
    if(argc != 6) {
        std::cerr << "Usage: constructGlobal_h 1.N 2.Momentum 3.Type 4.Param 5.InputFile for matLoc"
                  << std::endl;
        std::exit(EX_USAGE);
    }
    Integer_t N        = (Integer_t)std::atoi(argv[1]);
    Integer_t momentum = (Integer_t)std::atoi(argv[2]);
 
    char* initStr[9];
    initStr[1] = argv[1];
    initStr[2] = argv[1];
    initStr[7] = argv[3];
    initStr[8] = argv[4];
    Initialize(9, (char**)initStr);
 
    std::string   InFName(argv[5]);
    std::ifstream Infs(InFName);
    Infs.exceptions(std::ios::badbit);
    if(!Infs.is_open()) {
        std::cerr << "Can't open a file \"" << InFName << "\"" << std::endl;
        std::exit(EX_NOINPUT);
    }
    try {
        skip_header(Infs);
    }
    catch(std::exception& e) {
        std::cerr << "Error(skip_header): " << e.what() << std::endl;
        std::cerr << "File: \"" << InFName << "\" is empty." << std::endl;
        std::exit(EX_NOINPUT);
    }
    Infs.exceptions(std::ifstream::badbit);
 
    std::cout << "########## Input ##########" << std::endl;
    bool              dimLocFlag = false, numLocFlag = false;
    Integer_t         dimLoc = 0, numLoc = 0, dimLocMat = 0;
    matrix<Complex_t> matLoc;
    std::string       str;
    std::stringstream ss;
    auto              oldPos = Infs.tellg();
    while(std::getline(Infs, str)) {
        ss.str(str);
        ss.clear(std::stringstream::goodbit);
        ss >> str;
        if(str.find("dimLoc") != std::string::npos) {
            ss >> str;
            dimLoc     = std::atoi(str.c_str());
            dimLocFlag = true;
        }
        else if(str.find("numLoc") != std::string::npos) {
            ss >> str;
            numLoc     = std::atoi(str.c_str());
            numLocFlag = true;
        }
        else if(str.find("mat") != std::string::npos) {
            if(dimLocFlag && numLocFlag != true) {
                std::cerr << "Error: Invalid data format." << std::endl;
                std::exit(EX_DATAERR);
            }
            dimLocMat = pow(dimLoc, numLoc);
            Infs.seekg(oldPos);
            std::cout << "dimLocMat=" << dimLocMat << std::endl;
            matLoc.resize(dimLocMat, dimLocMat);
            readMatrix(Infs, dimLocMat, matLoc);
            std::cout << "matLoc:" << std::endl;
            matLoc.print(dimLocMat, dimLocMat);
        }
        oldPos = Infs.tellg();
    }
 
    magma_init();
    magma_queue_t queue = NULL;
    magma_int_t   dev   = 0;
    magma_getdevice(&dev);
    magma_queue_create(dev, &queue);
 
    TransSector Sector;
    Sector.initialize(N, momentum, dimLoc);
    Sector.copyToGPU(queue);
 
    std::cout << "########## Output ##########" << std::endl;
    GlobFuncPtr = MatrixElementsInSector;
    struct cudaFuncAttributes attr;
    cudaFuncGetAttributes(&attr, GlobFuncPtr);
    Integer_t nThread = (Integer_t)sqrt(attr.maxThreadsPerBlock);
    Integer_t nBlock  = (Integer_t)Sector.dim() / nThread;
    if(Sector.dim() > nBlock * nThread) nBlock += 1;
    GPUconfig conf(dim3(nBlock, nBlock, 1), dim3(nThread, nThread, 1), 0, queue);
 
    std::cout << "# constSizeBytes     = " << attr.constSizeBytes << "\n"
              << "# maxThreadsPerBlock = " << attr.maxThreadsPerBlock << "\n"
              << "# (dim=" << Sector.dim() << ") nBlock=" << nBlock << ", nThread= " << nThread
              << "*" << nThread << " =" << nThread * nThread << std::endl;
    magma_queue_sync(queue);
 
    constexpr Integer_t   GPU_UNIT = 32;
    Integer_t const       LDT      = magma_roundup(Sector.dim(), GPU_UNIT);
    matrix_gpu<Complex_t> dmatLoc(LDT, dimLocMat);
    matrix_gpu<Complex_t> dmatTot(LDT, Sector.dim());
 
    magma_setmatrix(dimLocMat, dimLocMat, sizeof(Complex_t), &*matLoc.begin(), dimLocMat,
                    dmatLoc.ptr(), dmatLoc.LD(), queue);
    constructGlobal_h(dmatTot, dmatLoc, numLoc, Sector, conf);
 
    std::cout << "# After constructGlobal_h" << std::endl;
    std::cout << "matTot:" << std::endl;
    dmatTot.print(Sector.dim(), Sector.dim(), queue);
 
    return 0;
}