gpuNUFFT 0.6.3__tar.gz → 0.7.1__tar.gz

{gpuNUFFT-0.6.3 → gpuNUFFT-0.7.1}/CUDA/inc/gpuNUFFT_kernels.hpp

@@ -415,4 +415,6 @@ void performPadding(DType2 *imdata_d, CufftType *gdata_d,
   */
 void precomputeDeapodization(DType *deapo_d, gpuNUFFT::GpuNUFFTInfo *gi_host);
 
+void performUpdateDensityComp(DType2* density_data, DType2* estimation_data, long int n_samples);
+ 
 #endif

{gpuNUFFT-0.6.3 → gpuNUFFT-0.7.1}/CUDA/src/gpu/atomic/CMakeLists.txt

@@ -11,10 +11,11 @@ set(GPU_CU_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/atomic_gpuNUFFT.cu
 					#${CMAKE_CURRENT_SOURCE_DIR}/../std_gpuNUFFT_kernels.cu
 									 )
 if(WIN32)
-    CUDA_ADD_LIBRARY(${GRID_LIB_ATM_NAME} ${GPU_CU_SOURCES}  ${GPU_GPUNUFFT_SOURCES} ${GPUNUFFT_SOURCES} ${GPUNUFFT_INCLUDE})
+    CUDA_ADD_LIBRARY(${GRID_LIB_ATM_NAME} ${GPU_CU_SOURCES}  ${GPU_GPUNUFFT_SOURCES} ${GPUNUFFT_SOURCES} ${GPUNUFFT_INCLUDE} )
 else(WIN32)
-    CUDA_ADD_LIBRARY(${GRID_LIB_ATM_NAME} ${GPU_CU_SOURCES}  ${GPU_GPUNUFFT_SOURCES} ${GPUNUFFT_SOURCES} ${GPUNUFFT_INCLUDE} SHARED)
+    CUDA_ADD_LIBRARY(${GRID_LIB_ATM_NAME} ${GPU_CU_SOURCES}  ${GPU_GPUNUFFT_SOURCES} ${GPUNUFFT_SOURCES} ${GPUNUFFT_INCLUDE}  SHARED)
 endif(WIN32)
 
 CUDA_ADD_CUFFT_TO_TARGET(${GRID_LIB_ATM_NAME})
 CUDA_ADD_CUBLAS_TO_TARGET(${GRID_LIB_ATM_NAME})
+target_link_libraries(${GRID_LIB_ATM_NAME} ${CUDA_curand_LIBRARY})

{gpuNUFFT-0.6.3 → gpuNUFFT-0.7.1}/CUDA/src/gpu/python/CMakeLists.txt

@@ -1,26 +1,29 @@
 cmake_minimum_required(VERSION 3.15)
-find_package(PythonInterp 3.5 REQUIRED)
-find_package(PythonLibs 3.5 REQUIRED)
+find_package(Python3 3.8 REQUIRED COMPONENTS Interpreter Development)
+
 MESSAGE(STATUS "Building Python interface")
+MESSAGE("Pybind11 include dir ${PYBIND11_INCLUDE_DIR}")
+MESSAGE("Python include dir ${Python3_INCLUDE_DIRS}")
+MESSAGE("Found ${Python3_LIBRARIES}")
 
 include_directories(
     ${GPUNUFFT_INC_DIR}
     ${PYBIND11_INCLUDE_DIR}
-    ${PYTHON_INCLUDE_DIR}
+    ${Python3_INCLUDE_DIRS}
     )
 cuda_include_directories(${GPUNUFFT_INC_DIR})
 cuda_add_library(gpuNUFFT  ${GPU_CU_SOURCES}  ${GPU_GPUNUFFT_SOURCES} ${GPUNUFFT_SOURCES} ${GPUNUFFT_INCLUDE} gpuNUFFT_operator_python_factory.cpp ${CMAKE_CURRENT_SOURCE_DIR}/../atomic/atomic_gpuNUFFT.cu SHARED)
 set_target_properties(gpuNUFFT PROPERTIES PREFIX "")
 
+
 if(WIN32)
-    MESSAGE("Pybind11 include dir ${PYBIND11_INCLUDE_DIR}")
-    MESSAGE("Python include dir ${PYTHON_INCLUDE_DIR}")
-    MESSAGE("Found ${PYTHON_LIBRARIES}")
     set_target_properties(gpuNUFFT PROPERTIES SUFFIX ".pyd")
 
-    TARGET_LINK_LIBRARIES(gpuNUFFT ${CUDA_LIBRARIES} ${GRID_LIB_ATM_NAME} ${PYTHON_LIBRARIES})
+    TARGET_LINK_LIBRARIES(gpuNUFFT ${CUDA_LIBRARIES} ${GRID_LIB_ATM_NAME} ${Python3_LIBRARIES})
 elseif(UNIX)
     TARGET_LINK_LIBRARIES(gpuNUFFT ${CUDA_LIBRARIES})
 endif(WIN32)
 CUDA_ADD_CUFFT_TO_TARGET(gpuNUFFT)
 CUDA_ADD_CUBLAS_TO_TARGET(gpuNUFFT)
+target_link_libraries(gpuNUFFT ${CUDA_curand_LIBRARY})
+

{gpuNUFFT-0.6.3 → gpuNUFFT-0.7.1}/CUDA/src/gpu/python/gpuNUFFT_operator_python_factory.cpp

@@ -14,13 +14,16 @@ Carole Lazarus <carole.m.lazarus@gmail.com>
 #include "cufft.h"
 #include "cuda_runtime.h"
 #include <cuda.h>
-#include <cublas.h>
+#include <cublas_v2.h>
+#include <curand.h>
 #include "config.hpp"
 #include "gpuNUFFT_operator_factory.hpp"
 #include <algorithm>  // std::sort
 #include <vector>     // std::vector
 #include <string>
 #include <cuda.h>
+#include <cstdint>
+
 #define CAST_POINTER_VARNAME(x, y)   cast_pointer(x, y, #x)
 
 namespace py = pybind11;
@@ -62,9 +65,10 @@ void warn_pinned_memory(py::array_t<std::complex<DType>> array, const char * nam
         std::cerr<<"WARNING:: The data"<<name<<"is NOT pinned! This will be slow, consider pinning\n";
 }
 
-void allocate_pinned_memory(gpuNUFFT::Array<DType2> *lin_array, unsigned long int size)
+template <typename TType>
+void allocate_pinned_memory(gpuNUFFT::Array<TType> *lin_array, unsigned long int size)
 {
-  DType2 *new_data;
+  TType *new_data;
   cudaMallocHost((void **)&new_data, size);
   lin_array->data = new_data;
 }
@@ -106,7 +110,9 @@ class GpuNUFFTPythonOperator
     bool has_sense_data;
     gpuNUFFT::Dimensions imgDims;
     // sensitivity maps
-    gpuNUFFT::Array<DType2> sensArray, kspace_data, image;
+    gpuNUFFT::GpuArray<DType2> image_gpu;
+    gpuNUFFT::GpuArray<CufftType> kspace_data_gpu;
+    gpuNUFFT::Array<CufftType> sensArray, kspace_data, image;
     void allocate_memory_kspace()
     {
         allocate_pinned_memory(&kspace_data, n_coils*trajectory_length*sizeof(DType2));
@@ -122,8 +128,8 @@ class GpuNUFFTPythonOperator
     
     public:
     GpuNUFFTPythonOperator(py::array_t<DType> kspace_loc, py::array_t<int> image_size, int num_coils,
-    py::array_t<std::complex<DType>> sense_maps,  std::optional<py::array_t<DType>> density_comp, int kernel_width=3,
-    int sector_width=8, int osr=2, bool balance_workload=1) 
+    py::array_t<std::complex<DType>> sense_maps,  py::array_t<DType> density_comp, int kernel_width=3,
+    int sector_width=8, float osr=2, bool balance_workload=1) 
     {
         // k-space coordinates
         py::buffer_info sample_loc = kspace_loc.request();
@@ -134,12 +140,12 @@ class GpuNUFFTPythonOperator
 
         // density compensation weights
         gpuNUFFT::Array<DType> density_compArray;
-        if(density_comp.has_value())
-        {
-            density_compArray = readNumpyArray(density_comp.value());
+        //if(density_comp.has_value())
+        //{
+            density_compArray = readNumpyArray(density_comp);
             density_compArray.dim.length = trajectory_length;
             // No need else as the init is by default with 0 length and density comp is not applied
-        }
+        //}
 
         // image size
         py::buffer_info img_dim = image_size.request();
@@ -157,7 +163,10 @@ class GpuNUFFTPythonOperator
         kspace_data.dim.length = trajectory_length;
         kspace_data.dim.channels = num_coils;
         image.dim = imgDims;
-
+        kspace_data_gpu.dim.length = trajectory_length;
+        kspace_data_gpu.dim.channels = num_coils;
+        image_gpu.dim = imgDims;
+        
         // sensitivity maps
         py::buffer_info sense_maps_buffer = sense_maps.request();
         if (sense_maps_buffer.shape.size()==0)
@@ -176,7 +185,6 @@ class GpuNUFFTPythonOperator
         gpuNUFFTOp = factory.createGpuNUFFTOperator(
             kSpaceTraj, density_compArray, sensArray, kernel_width, sector_width,
             osr, imgDims);
-
         if(has_sense_data == false)
             image.dim.channels = n_coils;
         else
@@ -206,6 +214,29 @@ class GpuNUFFTPythonOperator
             capsule
         );
     }
+
+    void op_direct(uintptr_t in_image, uintptr_t out_kspace, bool interpolate_data)
+    {
+        image_gpu.data = (DType2*) in_image;
+        kspace_data_gpu.data = (CufftType*) out_kspace;
+        if(interpolate_data)
+            gpuNUFFTOp->performForwardGpuNUFFT(image_gpu, kspace_data_gpu, gpuNUFFT::DENSITY_ESTIMATION);
+        else
+            gpuNUFFTOp->performForwardGpuNUFFT(image_gpu, kspace_data_gpu);
+        cudaDeviceSynchronize();
+    }
+
+    void adj_op_direct(uintptr_t in_kspace, uintptr_t out_image, bool grid_data)
+    {
+        kspace_data_gpu.data = (CufftType*) in_kspace;
+        image_gpu.data = (DType2*) out_image;
+        if(grid_data)
+            gpuNUFFTOp->performGpuNUFFTAdj(kspace_data_gpu, image_gpu, gpuNUFFT::DENSITY_ESTIMATION);
+        else
+            gpuNUFFTOp->performGpuNUFFTAdj(kspace_data_gpu, image_gpu);
+        cudaDeviceSynchronize();
+    }
+    
     py::array_t<std::complex<DType>> adj_op(py::array_t<std::complex<DType>> in_kspace, py::array_t<std::complex<DType>> out_image, bool grid_data)
     {
         CAST_POINTER_VARNAME(in_kspace, kspace_data);
@@ -266,6 +297,129 @@ class GpuNUFFTPythonOperator
         has_sense_data = true;
         gpuNUFFTOp->setSens(sensArray);
     }
+
+    py::array_t<DType> estimate_density_comp(int max_iter = 10)
+    {
+        IndType n_samples = kspace_data.count();
+        gpuNUFFT::Array<CufftType> densArray;
+        allocate_pinned_memory(&densArray, n_samples * sizeof(CufftType));
+        densArray.dim.length = n_samples;
+
+        // TODO: Allocate directly on device and set with kernel.
+        for (long int cnt = 0; cnt < n_samples; cnt++)
+        {
+          densArray.data[cnt].x = 1.0;
+          densArray.data[cnt].y = 0.0;
+        }
+
+        gpuNUFFT::GpuArray<DType2> densArray_gpu;
+        densArray_gpu.dim.length = n_samples;
+        allocateDeviceMem(&densArray_gpu.data, n_samples);
+
+        copyToDeviceAsync(densArray.data, densArray_gpu.data, n_samples);
+
+        gpuNUFFT::GpuArray<CufftType> densEstimation_gpu;
+        densEstimation_gpu.dim.length = n_samples;
+        allocateDeviceMem(&densEstimation_gpu.data, n_samples);
+
+        gpuNUFFT::GpuArray<CufftType> image_gpu;
+        image_gpu.dim = imgDims;
+        allocateDeviceMem(&image_gpu.data, imgDims.count());
+
+        if (DEBUG && (cudaDeviceSynchronize() != cudaSuccess))
+          printf("error at adj thread synchronization a: %s\n",
+                 cudaGetErrorString(cudaGetLastError()));
+        for (int cnt = 0; cnt < max_iter; cnt++)
+        {
+          if (DEBUG)
+                printf("### update %i\n", cnt);
+          gpuNUFFTOp->performGpuNUFFTAdj(densArray_gpu, image_gpu,
+                                         gpuNUFFT::DENSITY_ESTIMATION);
+          gpuNUFFTOp->performForwardGpuNUFFT(image_gpu, densEstimation_gpu,
+                                             gpuNUFFT::DENSITY_ESTIMATION);
+          performUpdateDensityComp(densArray_gpu.data, densEstimation_gpu.data, n_samples);
+          if (DEBUG && (cudaDeviceSynchronize() != cudaSuccess))
+                printf("error at adj thread synchronization d: %s\n",
+                       cudaGetErrorString(cudaGetLastError()));
+        }
+        freeDeviceMem(densEstimation_gpu.data);
+        freeDeviceMem(image_gpu.data);
+
+        cudaDeviceSynchronize();
+        // copy only the real part back to cpu
+        DType *tmp_d = (DType *)densArray_gpu.data;
+
+        gpuNUFFT::Array<DType> final_densArray;
+        final_densArray.dim.length = n_samples;
+        allocate_pinned_memory(&final_densArray, n_samples * sizeof(DType));
+        HANDLE_ERROR(cudaMemcpy2DAsync(final_densArray.data, sizeof(DType),
+                                       tmp_d, sizeof(DType2), sizeof(DType),
+                                       n_samples, cudaMemcpyDeviceToHost));
+        cudaDeviceSynchronize();
+        freeDeviceMem(densArray_gpu.data);
+        DType *ptr = reinterpret_cast<DType(&)[0]>(*final_densArray.data);
+        auto capsule = py::capsule(ptr, [](void *ptr) { return; });
+        return py::array_t<DType>({ trajectory_length }, { sizeof(DType) }, ptr,
+                                  capsule);
+    }
+
+    
+
+
+    float get_spectral_radius(int max_iter = 20,float tolerance = 1e-6)
+    {
+        int im_size = image.count();
+
+        gpuNUFFT::GpuArray<DType2> x_gpu;
+        x_gpu.dim = image.dim;
+        allocateDeviceMem(&x_gpu.data, im_size);
+
+        gpuNUFFT::GpuArray<DType2> tmp_kspace_gpu;
+        tmp_kspace_gpu.dim = kspace_data.dim;
+        allocateDeviceMem(&tmp_kspace_gpu.data, kspace_data.count());
+
+        cudaDeviceSynchronize();
+        DType norm_old = 1.0;
+        DType norm_new = 1.0;
+        DType inv_norm = 1.0;
+        // initialisation: create a random complex image.
+        curandGenerator_t generator;
+        curandCreateGenerator(&generator, CURAND_RNG_PSEUDO_XORWOW);
+        curandSetPseudoRandomGeneratorSeed(generator, (int)time(NULL));
+
+        // complex value generator by giving twice the size.
+        curandGenerateUniform(generator, (DType *)x_gpu.data, 2 * im_size);
+        // xold = initialize random x of image size.
+        curandDestroyGenerator(generator);
+        // Create a handle
+        cublasHandle_t handle;
+        cublasCreate(&handle);
+
+        cublasScnrm2(handle, im_size, x_gpu.data, 1, &norm_old);
+        inv_norm = 1.0 / norm_old;
+        cublasCsscal(handle, im_size, &inv_norm, x_gpu.data, 1);
+
+        for (int i = 0; i < max_iter; i++)
+        {
+          // compute x_new = adj_op(op(x_old))
+          gpuNUFFTOp->performForwardGpuNUFFT(x_gpu, tmp_kspace_gpu);
+          gpuNUFFTOp->performGpuNUFFTAdj(tmp_kspace_gpu, x_gpu);
+          // compute ||x_new||
+          cublasScnrm2(handle, im_size, x_gpu.data, 1, &norm_new);
+          // x_new <- x_new/ ||x_new||
+          inv_norm = 1.0 / norm_new;
+
+          cublasCsscal(handle, im_size, &inv_norm, x_gpu.data, 1);
+          if (fabs(norm_new - norm_old) < tolerance)
+          {
+                break;
+          }
+          norm_old = norm_new;
+        }
+        freeTotalDeviceMemory(tmp_kspace_gpu.data, x_gpu.data, NULL);
+        cublasDestroy(handle);
+        return norm_new;
+    }
     ~GpuNUFFTPythonOperator()
     {
         delete gpuNUFFTOp;
@@ -274,12 +428,15 @@ class GpuNUFFTPythonOperator
 
 PYBIND11_MODULE(gpuNUFFT, m) {
     py::class_<GpuNUFFTPythonOperator>(m, "NUFFTOp")
-        .def(py::init<py::array_t<DType>, py::array_t<int>, int, py::array_t<std::complex<DType>>, std::optional<py::array_t<DType>>, int, int, int, bool>(),
+        .def(py::init<py::array_t<DType>, py::array_t<int>, int, py::array_t<std::complex<DType>>, py::array_t<DType>, int, int, float, bool>(),
             py::arg("kspace_loc"), py::arg("image_size"), py::arg("num_coils"), py::arg("sense_maps") = py::none(), py::arg("density_comp") = py::none(), py::arg("kernel_width") = 3, py::arg("sector_width") = 8, py::arg("osr") = 2, py::arg("balance_workload") = true)
         .def("op", &GpuNUFFTPythonOperator::op, py::arg("in_image"), py::arg("out_kspace"), py::arg("interpolate_data") = false)
+        .def("op_direct", &GpuNUFFTPythonOperator::op_direct, py::arg("in_image"), py::arg("out_kspace"), py::arg("interpolate_data") = false)
+        .def("adj_op_direct", &GpuNUFFTPythonOperator::adj_op_direct, py::arg("in_kspace"), py::arg("out_image"), py::arg("grid_data") = false)
         .def("adj_op",  &GpuNUFFTPythonOperator::adj_op, py::arg("in_kspace"), py::arg("out_image"),  py::arg("grid_data") = false)
         .def("clean_memory", &GpuNUFFTPythonOperator::clean_memory)
-        .def("set_smaps", &GpuNUFFTPythonOperator::set_smaps);
-    
+        .def("estimate_density_comp", &GpuNUFFTPythonOperator::estimate_density_comp, py::arg("max_iter") = 10)
+        .def("set_smaps", &GpuNUFFTPythonOperator::set_smaps)
+        .def("get_spectral_radius", &GpuNUFFTPythonOperator::get_spectral_radius, py::arg("max_iter") = 20, py::arg("tolerance") = 1e-6);
 }
-#endif  // GPUNUFFT_OPERATOR_MATLABFACTORY_H_INCLUDED
+#endif  // GPUNUFFT_OPERATOR_PYTHONFACTORY_H_INCLUDED

{gpuNUFFT-0.6.3 → gpuNUFFT-0.7.1}/CUDA/src/gpu/std_gpuNUFFT_kernels.cu

@@ -33,6 +33,25 @@ void bindTo1DTexture(const char* symbol, void* devicePtr, IndType count)
   }
 }
 
+__global__ void updateDensityCompKernel(DType2* density_data, DType2* estimation_data, long int N)
+{
+  long int t = threadIdx.x + blockIdx.x * blockDim.x;
+  while (t < N)
+  {
+    DType2 data_p = density_data[t];
+    DType2 esti_p = estimation_data[t];
+    data_p.x *= rsqrtf(esti_p.x * esti_p.x + esti_p.y * esti_p.y);
+    density_data[t] = data_p;
+    t = t + blockDim.x*gridDim.x;
+  } 
+}
+
+void performUpdateDensityComp(DType2* density_data, DType2* estimation_data, long int n_samples)
+{
+  dim3 block_dim(64, 1, 8);
+  dim3 grid_dim(getOptimalGridDim(n_samples,THREAD_BLOCK_SIZE));
+  updateDensityCompKernel<<<grid_dim,block_dim>>>(density_data, estimation_data, n_samples);
+}
 
 void initTexture(const char* symbol, cudaArray** devicePtr, gpuNUFFT::Array<DType> hostTexture)
 {

gpuNUFFT-0.7.1/MANIFEST.in

@@ -0,0 +1,5 @@
+recursive-include CUDA/src *
+recursive-include CUDA/doc *
+recursive-include CUDA/inc *
+include CUDA/CMakeLists.txt
+

{gpuNUFFT-0.6.3 → gpuNUFFT-0.7.1}/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.1
 Name: gpuNUFFT
-Version: 0.6.3
+Version: 0.7.1
 Summary: gpuNUFFT - An open source GPU Library for 3D Gridding and NUFFT
 License-File: LICENSE

{gpuNUFFT-0.6.3/CUDA/bin → gpuNUFFT-0.7.1}/gpuNUFFT.egg-info/PKG-INFO

@@ -1,5 +1,5 @@
 Metadata-Version: 2.1
 Name: gpuNUFFT
-Version: 0.6.3
+Version: 0.7.1
 Summary: gpuNUFFT - An open source GPU Library for 3D Gridding and NUFFT
 License-File: LICENSE

gpuNUFFT-0.7.1/gpuNUFFT.egg-info/SOURCES.txt

@@ -0,0 +1,56 @@
+LICENSE
+MANIFEST.in
+README.md
+setup.py
+CUDA/CMakeLists.txt
+CUDA/doc/CMakeLists.txt
+CUDA/doc/Doxyfile
+CUDA/doc/mainpage.dox
+CUDA/inc/balanced_gpuNUFFT_operator.hpp
+CUDA/inc/balanced_operator.hpp
+CUDA/inc/balanced_texture_gpuNUFFT_operator.hpp
+CUDA/inc/config.hpp
+CUDA/inc/config.hpp.cmake
+CUDA/inc/cuda_utils.cuh
+CUDA/inc/cuda_utils.hpp
+CUDA/inc/cufft_config.hpp
+CUDA/inc/cufft_config.hpp.cmake
+CUDA/inc/gpuNUFFT_cpu.hpp
+CUDA/inc/gpuNUFFT_kernels.hpp
+CUDA/inc/gpuNUFFT_operator.hpp
+CUDA/inc/gpuNUFFT_operator_factory.hpp
+CUDA/inc/gpuNUFFT_types.hpp
+CUDA/inc/gpuNUFFT_utils.hpp
+CUDA/inc/matlab_helper.h
+CUDA/inc/precomp_kernels.hpp
+CUDA/inc/precomp_utils.hpp
+CUDA/inc/texture_gpuNUFFT_operator.hpp
+CUDA/src/CMakeLists.txt
+CUDA/src/balanced_gpuNUFFT_operator.cpp
+CUDA/src/balanced_texture_gpuNUFFT_operator.cpp
+CUDA/src/gpuNUFFT_operator.cpp
+CUDA/src/gpuNUFFT_operator_factory.cpp
+CUDA/src/gpuNUFFT_utils.cpp
+CUDA/src/texture_gpuNUFFT_operator.cpp
+CUDA/src/cpu/gpuNUFFT_cpu.cpp
+CUDA/src/gpu/CMakeLists.txt
+CUDA/src/gpu/precomp_kernels.cu
+CUDA/src/gpu/std_gpuNUFFT_kernels.cu
+CUDA/src/gpu/atomic/CMakeLists.txt
+CUDA/src/gpu/atomic/atomic_gpuNUFFT.cu
+CUDA/src/gpu/atomic/atomic_gpuNUFFT_kernels.cu
+CUDA/src/gpu/atomic/texture_gpuNUFFT_kernels.cu
+CUDA/src/gpu/matlab/CMakeLists.txt
+CUDA/src/gpu/matlab/gpuNUFFT_adj.cpp
+CUDA/src/gpu/matlab/gpuNUFFT_forw.cpp
+CUDA/src/gpu/matlab/gpuNUFFT_operator_matlabfactory.cpp
+CUDA/src/gpu/matlab/gpuNUFFT_operator_matlabfactory.hpp
+CUDA/src/gpu/matlab/precomputation/CMakeLists.txt
+CUDA/src/gpu/matlab/precomputation/gpuNUFFT_precomp.cpp
+CUDA/src/gpu/python/CMakeLists.txt
+CUDA/src/gpu/python/gpuNUFFT_operator_python_factory.cpp
+gpuNUFFT.egg-info/PKG-INFO
+gpuNUFFT.egg-info/SOURCES.txt
+gpuNUFFT.egg-info/dependency_links.txt
+gpuNUFFT.egg-info/not-zip-safe
+gpuNUFFT.egg-info/top_level.txt

{gpuNUFFT-0.6.3 → gpuNUFFT-0.7.1}/setup.py

@@ -1,6 +1,6 @@
 import os
 import sys
-from setuptools import setup, Extension, find_packages
+from setuptools import setup, Extension, find_namespace_packages
 from setuptools.command.build_ext import build_ext
 from importlib import import_module
 import platform
@@ -21,6 +21,14 @@ class CMakeBuild(build_ext):
     """ Define a cmake build extension.
     """
 
+    @staticmethod
+    def _preinstall(package):
+        """ Pre-install PyPi packages before running cmake.
+        """
+
+        subprocess.check_call(
+            [sys.executable, '-m', 'pip', 'install', package]
+        )
 
 
     def _set_pybind_path(self):
@@ -34,6 +42,8 @@ class CMakeBuild(build_ext):
         # Set preinstall requirements
         preinstall = "pybind11"
 
+        # Preinstall packages
+        self._preinstall(preinstall)
 
         # Set Pybind11 path
         self._set_pybind_path()
@@ -93,9 +103,8 @@ class CMakeBuild(build_ext):
 
 setup(
     name="gpuNUFFT",
-    version="0.6.3",
+    version="0.7.1",
     description="gpuNUFFT - An open source GPU Library for 3D Gridding and NUFFT",
-    package_dir={"": "CUDA/bin"},
     ext_modules=[
         CMakeExtension("gpuNUFFT", sourcedir=os.path.join("CUDA")),
     ],

gpuNUFFT-0.6.3/CUDA/bin/cvp/Gridding3D.cvp

@@ -1,34 +0,0 @@
-<!DOCTYPE cvp>
-<cvp version="4.0" >
- <session>
-  <name>Session1</name>
-  <progpath>"E:/Andi/workspaces/cuda/cuda-test/gridding3D/gridding3D/bin/runGPUUnitTests.exe"</progpath>
-  <workdirpath>E:/Andi/workspaces/cuda/cuda-test/gridding3D/gridding3D/bin</workdirpath>
-  <datetime>16 Aug 2012 16:01:37</datetime>
-  <normalizedcounter>false</normalizedcounter>
-  <device multProcessorCount="2" label="Device_0" id="0" computeCapability="1.1" maxGridDim="65535 65535" GpuOverlap="0" maxPitchMem="2147483647" totalConstMem="65536" name="GeForce 9500M (GF 9400MG + GF 9200MGS)" clockFreq="1100000" L2CacheSize="0" maxRegPerBlock="8192" chip="172" maxThreadPerSM="768" maxShareMemPerBlock="16384" maxBlockDim="512 512 64" MemClockRate="1064000" asyncEngineCount="0" warpSize="32" maxThreadPerBlock="512" MemBandwidth="272384000" textureAlignment="256" >
-   <context totalcountercount="0" invalidcountercount="0" id="0" label="Context_0" truncatedcountercount="0" trace="0" >
-    <run number="2" >branch,divergent_branch,instructions,warp_serialize</run>
-    <run number="3" >cta_launched,gld_incoherent,gld_coherent,gst_incoherent</run>
-    <run number="4" >gst_coherent,local_load,local_store</run>
-    <run number="5" >tex_cache_hit,tex_cache_miss</run>
-   </context>
-  </device>
- </session>
- <session>
-  <name>Session2</name>
-  <progpath>"E:/Andi/workspaces/cuda/cuda-test/gridding3D/gridding3D/bin/runGPUUnitTests.exe"</progpath>
-  <workdirpath>E:/Andi/workspaces/cuda/cuda-test/gridding3D/gridding3D/bin</workdirpath>
-  <datetime>16 Aug 2012 19:25:24</datetime>
-  <normalizedcounter>false</normalizedcounter>
-  <device multProcessorCount="2" label="Device_0" id="0" computeCapability="1.1" maxGridDim="65535 65535" GpuOverlap="0" maxPitchMem="2147483647" totalConstMem="65536" name="GeForce 9500M (GF 9400MG + GF 9200MGS)" clockFreq="1100000" L2CacheSize="0" maxRegPerBlock="8192" chip="172" maxThreadPerSM="768" maxShareMemPerBlock="16384" maxBlockDim="512 512 64" MemClockRate="1064000" asyncEngineCount="0" warpSize="32" maxThreadPerBlock="512" MemBandwidth="272384000" textureAlignment="256" >
-   <context totalcountercount="0" invalidcountercount="0" id="0" label="Context_0" truncatedcountercount="0" trace="0" >
-    <run number="2" >branch,divergent_branch,instructions,warp_serialize</run>
-    <run number="3" >cta_launched,gld_incoherent,gld_coherent,gst_incoherent</run>
-    <run number="4" >gst_coherent,local_load,local_store</run>
-    <run number="5" >tex_cache_hit,tex_cache_miss</run>
-   </context>
-  </device>
- </session>
-</cvp>
-

gpuNUFFT-0.6.3/CUDA/bin/cvp/README

@@ -1,4 +0,0 @@
-USAGE of CUDA Visual Profiler under LINUX
-
-export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/computeprof/bin
-

gpuNUFFT-0.6.3/CUDA/bin/gpuNUFFT.egg-info/SOURCES.txt

@@ -1,9 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-setup.py
-CUDA/bin/gpuNUFFT.egg-info/PKG-INFO
-CUDA/bin/gpuNUFFT.egg-info/SOURCES.txt
-CUDA/bin/gpuNUFFT.egg-info/dependency_links.txt
-CUDA/bin/gpuNUFFT.egg-info/not-zip-safe
-CUDA/bin/gpuNUFFT.egg-info/top_level.txt

gpuNUFFT-0.6.3/CUDA/bin/gtest_options

@@ -1,3 +0,0 @@
-repeat tests: --gtest_repeat=n --gtest_break_on_failure
-select single tests, filter: --gtest_filter=TestGridding.GPUTest_8SectorsKernel3nDataw32
-write output to xml file: --gtest_output="xml:<file name>"  

gpuNUFFT-0.6.3/CUDA/bin/run_cpu_filtered_unit_test.cmd

@@ -1 +0,0 @@
-runUnitTests.exe --gtest_filter=TestGridding.CPUTest_8SectorsKernel3nDataw32 --gtest_repeat=100 --gtest_break_on_failure

gpuNUFFT-0.6.3/CUDA/bin/run_cuda_memcheck

@@ -1,4 +0,0 @@
-export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64;
-
-/usr/local/cuda/bin/cuda-memcheck runGPUUnitTests
- 

gpuNUFFT-0.6.3/CUDA/bin/run_gpu_filtered_unit_test.cmd

@@ -1 +0,0 @@
-runGPUUnitTests.exe --gtest_filter=TestGridding.GPUTest_8SectorsKernel3nDataw32 --gtest_repeat=100 --gtest_break_on_failure

gpuNUFFT-0.6.3/CUDA/build/configure_double_prec

@@ -1 +0,0 @@
-cmake -G "Visual Studio 10" .. -DGPU_DOUBLE_PREC=ON

gpuNUFFT-0.6.3/CUDA/build/configure_single_prec

@@ -1 +0,0 @@
-cmake -G "Visual Studio 10" ..

gpuNUFFT-0.6.3/CUDA/cmake_modules/FindGPUNUFFT.cmake

@@ -1,24 +0,0 @@
-INCLUDE(FindPackageHandleStandardArgs)
-
-IF (NOT DEFINED GPUNUFFT_ROOT_DIR)
-  MESSAGE(FATAL_ERROR "GPUNUFFT_ROOT_DIR not defined!")
-ELSE()
-  MESSAGE("Searching for GPUNUFFT in ${GPUNUFFT_ROOT_DIR}")
-
-  SET(GPUNUFFT_IncludeSearchPaths ${GPUNUFFT_ROOT_DIR}/CUDA/inc ${GPUNUFFT_ROOT_DIR}/inc) #/usr/local/include
-  SET(GPUNUFFT_LibrarySearchPaths ${GPUNUFFT_ROOT_DIR}/CUDA/bin ${GPUNUFFT_ROOT_DIR}/bin) #/usr/local/lib
-
-  FIND_PATH(GPUNUFFT_INCLUDE_DIRS NAMES gpuNUFFT_operator_factory.hpp PATHS ${GPUNUFFT_IncludeSearchPaths})
-
-  FIND_LIBRARY(GPUNUFFT_LIBRARIES NAMES gpuNUFFT gpuNUFFT_ATM_f gpuNUFFT_f  PATHS ${GPUNUFFT_LibrarySearchPaths})
-
-  #Handle the REQUIRED argument and set the < UPPERCASED_NAME > _FOUND variable
-  FIND_PACKAGE_HANDLE_STANDARD_ARGS(GPUNUFFT "Could NOT find GPUNUFFT." GPUNUFFT_LIBRARIES GPUNUFFT_INCLUDE_DIRS)
-  IF(GPUNUFFT_FOUND)
-    FIND_PACKAGE_MESSAGE(
-        GPUNUFFT      
-        "Found GPUNUFFT ${GPUNUFFT_LIBRARIES}"
-        "[${GPUNUFFT_LIBRARIES}][${GPUNUFFT_INCLUDE_DIRS}]")
-    ENDIF(GPUNUFFT_FOUND)
-  MARK_AS_ADVANCED(GPUNUFFT_INCLUDE_DIRS GPUNUFFT_LIBRARIES)
-ENDIF()

gpuNUFFT-0.6.3/CUDA/test/CMakeLists.txt

@@ -1,30 +0,0 @@
-#setup testframework
-MESSAGE("------setting up testframework-------")
-
-set(GTEST_DIR "${CMAKE_SOURCE_DIR}/../../gtest/googletest")
-MESSAGE("GTEST_DIR " ${GTEST_DIR})
-
-include_directories("${GTEST_DIR}/include")
-
-find_library(GTEST_LIB NAMES gtest libgtest HINTS "${GTEST_DIR}/build" "${GTEST_DIR}/build/Debug")
-find_library(GTESTMAIN_LIB NAMES gtest_main libgtest_main HINTS "${GTEST_DIR}/build" "${GTEST_DIR}/build/Debug")
-
-MESSAGE("GTEST_LIB = ${GTEST_LIB}")
-MESSAGE("GTESTMAIN_LIB = ${GTESTMAIN_LIB}")
-
-#gpu test sources
-set(GPU_SOURCES gpu/gpuNUFFT_conv_tests.cpp
-				gpu/gpuNUFFT_2D_conv_tests.cpp
-				gpu/gpuNUFFT_fft_tests.cpp
-				gpu/gpuNUFFT_deapo_tests.cpp
-				gpu/forward/gpuNUFFT_forward_tests.cpp)
-
-#add CPU Tests
-add_subdirectory(cpu)
-
-cuda_add_executable(runGPUATMUnitTests ${GPU_SOURCES} ${GPUNUFFT_SOURCES} ../inc/gpuNUFFT_utils.hpp ../inc/gpuNUFFT_operator_factory.hpp ../inc/gpuNUFFT_operator.hpp ../inc/gpuNUFFT_kernels.hpp)
-if(WIN32)
-	target_link_libraries(runGPUATMUnitTests ${GRID_LIB_ATM_NAME} ${GTEST_LIB} ${GTESTMAIN_LIB})
-else(WIN32)
-	target_link_libraries(runGPUATMUnitTests pthread ${GRID_LIB_ATM_NAME} ${GTEST_LIB} ${GTESTMAIN_LIB})
-endif(WIN32)

gpuNUFFT-0.6.3/CUDA/test/cpu/CMakeLists.txt

@@ -1,16 +0,0 @@
-#setup testframework
-MESSAGE("------ generating cpu tests -------")
-
-#cpu test sources
-set(CPU_SOURCES gpuNUFFT_tests.cpp 
-				gpuNUFFT_kernel_tests.cpp
-				gpuNUFFT_precomputation_tests.cpp
-				gpuNUFFT_operator_factory_tests.cpp
-				../../src/gpuNUFFT_utils.cpp 
-				../../src/cpu/gpuNUFFT_cpu.cpp)
-
-include_directories(${CUDA_INCLUDE_DIRS})
-#add source dir
-add_executable(runUnitTests ${CPU_SOURCES} ${GPUNUFFT_SOURCES} ../../inc/gpuNUFFT_cpu.hpp ../../inc/gpuNUFFT_utils.hpp ../../inc/gpuNUFFT_operator_factory.hpp ../../inc/gpuNUFFT_operator.hpp ../../inc/gpuNUFFT_kernels.hpp)
-target_link_libraries(runUnitTests ${GRID_LIB_ATM_NAME} ${GTEST_LIB} ${GTESTMAIN_LIB})
-set_target_properties(runUnitTests PROPERTIES LINK_FLAGS -lpthread)

gpuNUFFT-0.6.3/CUDA/test/cpu/gpuNUFFT_kernel_tests.cpp

@@ -1,27 +0,0 @@
-#include <limits.h>
-#include "gpuNUFFT_cpu.hpp"
-
-#include "gtest/gtest.h"
-
-#define epsilon 0.0001f
-
-TEST(TestKernel, LoadKernel) {
-	if (DEBUG)
-		printf("start creating kernel...\n");
-	long kernel_entries = calculateGrid3KernelSize();
-	
-	assert(kernel_entries > 0);
-
-	DType *kern = (DType*) calloc(kernel_entries,sizeof(DType));
-	if (kern != NULL)
-	{
-		loadGrid3Kernel(kern,kernel_entries);
-		EXPECT_EQ(1.0f,kern[0]);
-		EXPECT_LT(0.9940f-kern[1],epsilon);
-		EXPECT_LT(0.0621f-kern[401],epsilon);
-		EXPECT_LT(0.0041f-kern[665],epsilon);
-		EXPECT_EQ(0.0f,kern[kernel_entries-1]);
-		free(kern);
-	}
-	EXPECT_EQ(1, 1);
-}