From 04ac6b120f2b51368b89be37a984a28442472793 Mon Sep 17 00:00:00 2001
From: Alex Olivas <alex.r.olivas@gmail.com>
Date: Mon, 15 Apr 2024 19:46:06 -0600
Subject: [PATCH] implemented the very basics of the first three classes.

---
 cmake_files/library.cmake            |   4 +-
 cmake_files/tests.cmake              |   4 +
 include/cudapp/cuda_device_prop.hpp  |  89 +++++++++
 include/cudapp/device.hpp            |  26 +--
 include/cudapp/device_manager.hpp    |  31 +--
 include/cudapp/device_properties.hpp |  28 +++
 src/device.cu                        |   4 +-
 src/device_manager.cu                |  27 +--
 src/device_properties.cu             | 274 +++++++++++++++++++++++++++
 tests/test_device.cpp                |   2 +
 tests/test_device_manager.cpp        |  14 +-
 tests/test_device_properties.cpp     |  21 ++
 12 files changed, 483 insertions(+), 41 deletions(-)
 create mode 100644 include/cudapp/cuda_device_prop.hpp
 create mode 100644 include/cudapp/device_properties.hpp
 create mode 100644 src/device_properties.cu
 create mode 100644 tests/test_device_properties.cpp

diff --git a/cmake_files/library.cmake b/cmake_files/library.cmake
index fb60a47..1404670 100644
--- a/cmake_files/library.cmake
+++ b/cmake_files/library.cmake
@@ -1,7 +1,9 @@
 
+
 add_library(cudapp SHARED
         src/device.cu
+        src/device_properties.cu
         src/device_manager.cu
+        ../include/cudapp/cuda_device_prop.hpp
 )
 set_property(TARGET cudapp PROPERTY CUDA_ARCHITECTURES OFF)
-
diff --git a/cmake_files/tests.cmake b/cmake_files/tests.cmake
index 7736aa5..1a6be9c 100644
--- a/cmake_files/tests.cmake
+++ b/cmake_files/tests.cmake
@@ -8,3 +8,7 @@ add_test(test_device bin/test_device)
 add_executable(test_device_manager tests/test_device_manager.cpp)
 target_link_libraries(test_device_manager cudapp)
 add_test(test_device_manager bin/test_device_manager)
+
+add_executable(test_device_properties tests/test_device_properties.cpp)
+target_link_libraries(test_device_properties cudapp)
+add_test(test_device_properties bin/test_device_properties)
diff --git a/include/cudapp/cuda_device_prop.hpp b/include/cudapp/cuda_device_prop.hpp
new file mode 100644
index 0000000..2327857
--- /dev/null
+++ b/include/cudapp/cuda_device_prop.hpp
@@ -0,0 +1,89 @@
+//
+// Created by olivas on 4/15/24.
+//
+
+#ifndef CUDAPP_CUDA_DEVICE_PROP_HPP
+#define CUDAPP_CUDA_DEVICE_PROP_HPP
+
+#include <array>
+#include <string>
+
+struct cuda_device_prop {
+    std::string name;
+    std::string uuid; // 16 byte unique identifier
+    size_t totalGlobalMem;
+    size_t sharedMemPerBlock;
+    unsigned regsPerBlock;
+    unsigned warpSize;
+    size_t memPitch;
+    unsigned maxThreadsPerBlock;
+    std::array<unsigned, 3> maxThreadsDim;
+    std::array<unsigned, 3> maxGridSize;
+    unsigned clockRate;
+    size_t totalConstMem;
+    unsigned major;
+    unsigned minor;
+    size_t textureAlignment;
+    size_t texturePitchAlignment;
+    unsigned deviceOverlap;
+    unsigned multiProcessorCount;
+    unsigned kernelExecTimeoutEnabled;
+    unsigned integrated;
+    unsigned canMapHostMemory;
+    unsigned computeMode;
+    unsigned maxTexture1D;
+    unsigned maxTexture1DMipmap;
+    unsigned maxTexture1DLinear;
+    std::array<unsigned, 2> maxTexture2D;
+    std::array<unsigned, 2> maxTexture2DMipmap;
+    std::array<unsigned, 3> maxTexture2DLinear;
+    std::array<unsigned, 2> maxTexture2DGather;
+    std::array<unsigned, 3> maxTexture3D;
+    std::array<unsigned, 3> maxTexture3DAlt;
+    unsigned maxTextureCubemap;
+    std::array<unsigned, 2> maxTexture1DLayered;
+    std::array<unsigned, 3> maxTexture2DLayered;
+    std::array<unsigned, 2> maxTextureCubemapLayered;
+    unsigned maxSurface1D;
+    std::array<unsigned, 2> maxSurface2D;
+    std::array<unsigned, 3> maxSurface3D;
+    std::array<unsigned, 2> maxSurface1DLayered;
+    std::array<unsigned, 3> maxSurface2DLayered;
+    unsigned maxSurfaceCubemap;
+    std::array<unsigned, 2> maxSurfaceCubemapLayered;
+    size_t surfaceAlignment;
+    unsigned concurrentKernels;
+    unsigned ECCEnabled;
+    unsigned pciBusID;
+    unsigned pciDeviceID;
+    unsigned pciDomainID;
+    unsigned tccDriver;
+    unsigned asyncEngineCount;
+    unsigned unifiedAddressing;
+    unsigned memoryClockRate;
+    unsigned memoryBusWidth;
+    unsigned l2CacheSize;
+    unsigned persistingL2CacheMaxSize;
+    unsigned maxThreadsPerMultiProcessor;
+    unsigned streamPrioritiesSupported;
+    unsigned globalL1CacheSupported;
+    unsigned localL1CacheSupported;
+    size_t sharedMemPerMultiprocessor;
+    unsigned regsPerMultiprocessor;
+    unsigned managedMemory;
+    unsigned isMultiGpuBoard;
+    unsigned multiGpuBoardGroupID;
+    unsigned singleToDoublePrecisionPerfRatio;
+    unsigned pageableMemoryAccess;
+    unsigned concurrentManagedAccess;
+    unsigned computePreemptionSupported;
+    unsigned canUseHostPointerForRegisteredMem;
+    unsigned cooperativeLaunch;
+    unsigned cooperativeMultiDeviceLaunch;
+    unsigned pageableMemoryAccessUsesHostPageTables;
+    unsigned directManagedMemAccessFromHost;
+    unsigned accessPolicyMaxWindowSize;
+};
+
+
+#endif //CUDAPP_CUDA_DEVICE_PROP_HPP
diff --git a/include/cudapp/device.hpp b/include/cudapp/device.hpp
index 45fd4ee..5f37fcf 100644
--- a/include/cudapp/device.hpp
+++ b/include/cudapp/device.hpp
@@ -1,15 +1,17 @@
 #pragma once
 
-class Device{
-public:
-  Device(int device_number);
-  ~Device();
+namespace cudapp{
+    class Device{
+    public:
+        Device(int device_number);
+        ~Device();
 
-  int multi_processor_count() const { return multi_processor_count_; }
-  size_t total_global_mem() const { return total_global_mem_; }
-  
-private:
-  int device_number_;
-  int multi_processor_count_;
-  size_t total_global_mem_;
-};
+        int multi_processor_count() const { return multi_processor_count_; }
+        size_t total_global_mem() const { return total_global_mem_; }
+
+    private:
+        int device_number_;
+        int multi_processor_count_;
+        size_t total_global_mem_;
+    };
+}
diff --git a/include/cudapp/device_manager.hpp b/include/cudapp/device_manager.hpp
index 594bb0b..d18fb6a 100644
--- a/include/cudapp/device_manager.hpp
+++ b/include/cudapp/device_manager.hpp
@@ -1,15 +1,20 @@
 #pragma once
 
-class DeviceManager{
-public:
-  DeviceManager();
-  ~DeviceManager();
-
-  int multi_processor_count() const { return multi_processor_count_; }
-  size_t total_global_mem() const { return total_global_mem_; }
-  
-private:
-  int device_number_;
-  int multi_processor_count_;
-  size_t total_global_mem_;
-};
+#include <optional>
+
+namespace cudapp{
+    class DeviceManager {
+    public:
+        DeviceManager();
+
+        ~DeviceManager();
+
+        [[nodiscard("this method's job is to return a value.")]]
+        std::optional<unsigned> device_count() const;
+
+        [[nodiscard("this method's job is to return a value.")]]
+        std::optional<unsigned> current_device() const;
+
+    };
+
+}
\ No newline at end of file
diff --git a/include/cudapp/device_properties.hpp b/include/cudapp/device_properties.hpp
new file mode 100644
index 0000000..55fa2d7
--- /dev/null
+++ b/include/cudapp/device_properties.hpp
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <optional>
+
+#include <cudapp/cuda_device_prop.hpp>
+
+namespace cudapp{
+    class DeviceProperties {
+    public:
+
+        DeviceProperties(unsigned device_number);
+
+        ~DeviceProperties();
+
+        void change_device_number(unsigned device_number);
+
+        cuda_device_prop device_properties;
+
+        void pretty_print();
+
+    private:
+
+        unsigned device_number_;
+
+        void set_device_properties(const unsigned device_number);
+    };
+}
+
diff --git a/src/device.cu b/src/device.cu
index f2373c0..a997267 100644
--- a/src/device.cu
+++ b/src/device.cu
@@ -1,7 +1,7 @@
 #include <cudapp/device.hpp>
 #include <cudapp/check_error.cuh>
 
-Device::Device(int device_number):
+cudapp::Device::Device(int device_number):
   device_number_(device_number)
 {
   CHECK_ERROR(cudaSetDeviceFlags(cudaDeviceBlockingSync));
@@ -14,7 +14,7 @@ Device::Device(int device_number):
   multi_processor_count_ = device_properties.multiProcessorCount;
 }
 
-Device::~Device()
+cudapp::Device::~Device()
 {  
   CHECK_ERROR(cudaDeviceReset());
 }
diff --git a/src/device_manager.cu b/src/device_manager.cu
index ee3dc19..da11622 100644
--- a/src/device_manager.cu
+++ b/src/device_manager.cu
@@ -1,20 +1,23 @@
 #include <cudapp/device_manager.hpp>
 #include <cudapp/check_error.cuh>
 
-DeviceManager::DeviceManager()
-{
-  CHECK_ERROR(cudaSetDeviceFlags(cudaDeviceBlockingSync));
-  CHECK_ERROR(cudaSetDevice(device_number_));  
-  std::cerr<<"device_number_ = "<<device_number_<<std::endl;
+using std::optional;
 
-  cudaDeviceProp device_properties;
-  CHECK_ERROR(cudaGetDeviceProperties(&device_properties, device_number_));
-  total_global_mem_ = device_properties.totalGlobalMem;
-  multi_processor_count_ = device_properties.multiProcessorCount;  
+cudapp::DeviceManager::DeviceManager() {}
+
+optional<unsigned>
+cudapp::DeviceManager::device_count() const {
+    int device_count{0};
+    CHECK_ERROR(cudaGetDeviceCount(&device_count));
+    return static_cast<unsigned>(device_count);
 }
 
-DeviceManager::~DeviceManager()
-{  
-  CHECK_ERROR(cudaDeviceReset());
+optional<unsigned>
+cudapp::DeviceManager::current_device() const {
+    int device{0};
+    CHECK_ERROR(cudaGetDevice(&device));
+    return static_cast<unsigned>(device);
 }
 
+cudapp::DeviceManager::~DeviceManager() {}
+
diff --git a/src/device_properties.cu b/src/device_properties.cu
new file mode 100644
index 0000000..0f62d0f
--- /dev/null
+++ b/src/device_properties.cu
@@ -0,0 +1,274 @@
+#include <string>
+#include <array>
+#include <iostream>
+
+#include <cudapp/device_properties.hpp>
+#include <cudapp/check_error.cuh>
+
+#include <cuda.h>
+#include <cuda_runtime_api.h>
+
+using std::optional;
+using std::string;
+using std::array;
+using std::cout;
+using std::endl;
+
+cudapp::DeviceProperties::DeviceProperties(unsigned device_number) :
+        device_number_{device_number} {
+    // check that it's a valid number
+    set_device_properties(device_number_);
+}
+
+void
+cudapp::DeviceProperties::change_device_number(unsigned int device_number) {
+    device_number_ = device_number;
+    set_device_properties(device_number_);
+}
+
+void
+cudapp::DeviceProperties::set_device_properties(unsigned int device_number) {
+    cudaDeviceProp cudevprops;
+    CHECK_ERROR(cudaGetDeviceProperties(&cudevprops, device_number));
+
+    // now cast and translate
+    device_properties.name = string(cudevprops.name);
+    //device_properties.uuid; // 16 byte unique identifier
+    device_properties.totalGlobalMem = static_cast<unsigned>(cudevprops.totalGlobalMem);
+    device_properties.sharedMemPerBlock = static_cast<unsigned>(cudevprops.sharedMemPerBlock);
+    device_properties.regsPerBlock = static_cast<unsigned>(cudevprops.regsPerBlock);
+    device_properties.warpSize = static_cast<unsigned>(cudevprops.warpSize);
+    device_properties.memPitch = static_cast<unsigned>(cudevprops.memPitch);
+    device_properties.maxThreadsPerBlock = static_cast<unsigned>(cudevprops.maxThreadsPerBlock);
+    device_properties.maxThreadsDim[0] = static_cast<unsigned>(cudevprops.maxThreadsDim[0]);
+    device_properties.maxThreadsDim[1] = static_cast<unsigned>(cudevprops.maxThreadsDim[1]);
+    device_properties.maxGridSize[0] = static_cast<unsigned>(cudevprops.maxGridSize[0]);
+    device_properties.maxGridSize[1] = static_cast<unsigned>(cudevprops.maxGridSize[1]);
+    device_properties.clockRate = static_cast<unsigned>(cudevprops.clockRate);
+    device_properties.totalConstMem = static_cast<unsigned>(cudevprops.totalConstMem);
+    device_properties.major = static_cast<unsigned>(cudevprops.major);
+    device_properties.minor = static_cast<unsigned>(cudevprops.minor);
+    device_properties.textureAlignment = static_cast<unsigned>(cudevprops.textureAlignment);
+    device_properties.texturePitchAlignment = static_cast<unsigned>(cudevprops.texturePitchAlignment);
+    device_properties.deviceOverlap = static_cast<unsigned>(cudevprops.deviceOverlap);
+    device_properties.multiProcessorCount = static_cast<unsigned>(cudevprops.multiProcessorCount);
+    device_properties.kernelExecTimeoutEnabled = static_cast<unsigned>(cudevprops.kernelExecTimeoutEnabled);
+    device_properties.integrated = static_cast<unsigned>(cudevprops.integrated);
+    device_properties.canMapHostMemory = static_cast<unsigned>(cudevprops.canMapHostMemory);
+    device_properties.computeMode = static_cast<unsigned>(cudevprops.computeMode);
+    device_properties.maxTexture1D = static_cast<unsigned>(cudevprops.maxTexture1D);
+    device_properties.maxTexture1DMipmap = static_cast<unsigned>(cudevprops.maxTexture1DMipmap);
+    device_properties.maxTexture1DLinear = static_cast<unsigned>(cudevprops.maxTexture1DLinear);
+    device_properties.maxTexture2D[0] = static_cast<unsigned>(cudevprops.maxTexture2D[0]);
+    device_properties.maxTexture2D[1] = static_cast<unsigned>(cudevprops.maxTexture2D[1]);
+    device_properties.maxTexture2DMipmap[0] = static_cast<unsigned>(cudevprops.maxTexture2DMipmap[0]);
+    device_properties.maxTexture2DMipmap[1] = static_cast<unsigned>(cudevprops.maxTexture2DMipmap[1]);
+    device_properties.maxTexture2DLinear[0] = static_cast<unsigned>(cudevprops.maxTexture2DLinear[0]);
+    device_properties.maxTexture2DLinear[1] = static_cast<unsigned>(cudevprops.maxTexture2DLinear[1]);
+    device_properties.maxTexture2DLinear[2] = static_cast<unsigned>(cudevprops.maxTexture2DLinear[2]);
+    device_properties.maxTexture2DGather[0] = static_cast<unsigned>(cudevprops.maxTexture2DGather[0]);
+    device_properties.maxTexture2DGather[1] = static_cast<unsigned>(cudevprops.maxTexture2DGather[1]);
+    device_properties.maxTexture3D[0] = static_cast<unsigned>(cudevprops.maxTexture3D[0]);
+    device_properties.maxTexture3D[1] = static_cast<unsigned>(cudevprops.maxTexture3D[1]);
+    device_properties.maxTexture3D[2] = static_cast<unsigned>(cudevprops.maxTexture3D[2]);
+    device_properties.maxTexture3DAlt[0] = static_cast<unsigned>(cudevprops.maxTexture3DAlt[0]);
+    device_properties.maxTexture3DAlt[1] = static_cast<unsigned>(cudevprops.maxTexture3DAlt[1]);
+    device_properties.maxTexture3DAlt[2] = static_cast<unsigned>(cudevprops.maxTexture3DAlt[2]);
+    device_properties.maxTextureCubemap = static_cast<unsigned>(cudevprops.maxTextureCubemap);
+    device_properties.maxTexture1DLayered[0] = static_cast<unsigned>(cudevprops.maxTexture1DLayered[0]);
+    device_properties.maxTexture1DLayered[1] = static_cast<unsigned>(cudevprops.maxTexture1DLayered[1]);
+    device_properties.maxTexture2DLayered[0] = static_cast<unsigned>(cudevprops.maxTexture2DLayered[0]);
+    device_properties.maxTexture2DLayered[1] = static_cast<unsigned>(cudevprops.maxTexture2DLayered[1]);
+    device_properties.maxTexture2DLayered[2] = static_cast<unsigned>(cudevprops.maxTexture2DLayered[2]);
+    device_properties.maxTextureCubemapLayered[0] = static_cast<unsigned>(cudevprops.maxTextureCubemapLayered[0]);
+    device_properties.maxTextureCubemapLayered[1] = static_cast<unsigned>(cudevprops.maxTextureCubemapLayered[1]);
+    device_properties.maxSurface1D = static_cast<unsigned>(cudevprops.maxSurface1D);
+    device_properties.maxSurface2D[0] = static_cast<unsigned>(cudevprops.maxSurface2D[0]);
+    device_properties.maxSurface2D[1] = static_cast<unsigned>(cudevprops.maxSurface2D[1]);
+    device_properties.maxSurface3D[0] = static_cast<unsigned>(cudevprops.maxSurface3D[0]);
+    device_properties.maxSurface3D[1] = static_cast<unsigned>(cudevprops.maxSurface3D[1]);
+    device_properties.maxSurface3D[2] = static_cast<unsigned>(cudevprops.maxSurface3D[2]);
+    device_properties.maxSurface1DLayered[0] = static_cast<unsigned>(cudevprops.maxSurface1DLayered[0]);
+    device_properties.maxSurface1DLayered[1] = static_cast<unsigned>(cudevprops.maxSurface1DLayered[1]);
+    device_properties.maxSurface2DLayered[0] = static_cast<unsigned>(cudevprops.maxSurface2DLayered[0]);
+    device_properties.maxSurface2DLayered[1] = static_cast<unsigned>(cudevprops.maxSurface2DLayered[1]);
+    device_properties.maxSurface2DLayered[2] = static_cast<unsigned>(cudevprops.maxSurface2DLayered[2]);
+    device_properties.maxSurfaceCubemap = static_cast<unsigned>(cudevprops.maxSurfaceCubemap);
+    device_properties.maxSurfaceCubemapLayered[0] = static_cast<unsigned>(cudevprops.maxSurfaceCubemapLayered[0]);
+    device_properties.maxSurfaceCubemapLayered[1] = static_cast<unsigned>(cudevprops.maxSurfaceCubemapLayered[1]);
+    device_properties.surfaceAlignment = static_cast<unsigned>(cudevprops.surfaceAlignment);
+    device_properties.concurrentKernels = static_cast<unsigned>(cudevprops.concurrentKernels);
+    device_properties.ECCEnabled = static_cast<unsigned>(cudevprops.ECCEnabled);
+    device_properties.pciBusID = static_cast<unsigned>(cudevprops.pciBusID);
+    device_properties.pciDeviceID = static_cast<unsigned>(cudevprops.pciDeviceID);
+    device_properties.pciDomainID = static_cast<unsigned>(cudevprops.pciDomainID);
+    device_properties.tccDriver = static_cast<unsigned>(cudevprops.tccDriver);
+    device_properties.asyncEngineCount = static_cast<unsigned>(cudevprops.asyncEngineCount);
+    device_properties.unifiedAddressing = static_cast<unsigned>(cudevprops.unifiedAddressing);
+    device_properties.memoryClockRate = static_cast<unsigned>(cudevprops.memoryClockRate);
+    device_properties.memoryBusWidth = static_cast<unsigned>(cudevprops.memoryBusWidth);
+    device_properties.l2CacheSize = static_cast<unsigned>(cudevprops.l2CacheSize);
+    device_properties.persistingL2CacheMaxSize = static_cast<unsigned>(cudevprops.persistingL2CacheMaxSize);
+    device_properties.maxThreadsPerMultiProcessor = static_cast<unsigned>(cudevprops.maxThreadsPerMultiProcessor);
+    device_properties.streamPrioritiesSupported = static_cast<unsigned>(cudevprops.streamPrioritiesSupported);
+    device_properties.globalL1CacheSupported = static_cast<unsigned>(cudevprops.globalL1CacheSupported);
+    device_properties.localL1CacheSupported = static_cast<unsigned>(cudevprops.localL1CacheSupported);
+    device_properties.sharedMemPerMultiprocessor = static_cast<unsigned>(cudevprops.sharedMemPerMultiprocessor);
+    device_properties.regsPerMultiprocessor = static_cast<unsigned>(cudevprops.regsPerMultiprocessor);
+    device_properties.managedMemory = static_cast<unsigned>(cudevprops.managedMemory);
+    device_properties.isMultiGpuBoard = static_cast<unsigned>(cudevprops.isMultiGpuBoard);
+    device_properties.multiGpuBoardGroupID = static_cast<unsigned>(cudevprops.multiGpuBoardGroupID);
+    device_properties.singleToDoublePrecisionPerfRatio = static_cast<unsigned>(cudevprops.singleToDoublePrecisionPerfRatio);
+    device_properties.pageableMemoryAccess = static_cast<unsigned>(cudevprops.pageableMemoryAccess);
+    device_properties.concurrentManagedAccess = static_cast<unsigned>(cudevprops.concurrentManagedAccess);
+    device_properties.computePreemptionSupported = static_cast<unsigned>(cudevprops.computePreemptionSupported);
+    device_properties.canUseHostPointerForRegisteredMem = static_cast<unsigned>(cudevprops.canUseHostPointerForRegisteredMem);
+    device_properties.cooperativeLaunch = static_cast<unsigned>(cudevprops.cooperativeLaunch);
+    device_properties.cooperativeMultiDeviceLaunch = static_cast<unsigned>(cudevprops.cooperativeMultiDeviceLaunch);
+    device_properties.pageableMemoryAccessUsesHostPageTables = static_cast<unsigned>(cudevprops.pageableMemoryAccessUsesHostPageTables);
+    device_properties.directManagedMemAccessFromHost = static_cast<unsigned>(cudevprops.directManagedMemAccessFromHost);
+    device_properties.accessPolicyMaxWindowSize = static_cast<unsigned>(cudevprops.accessPolicyMaxWindowSize);
+}
+
+void
+cudapp::DeviceProperties::pretty_print() {
+    // now cast and translate
+    cout << "name = " << device_properties.name << endl;
+    //cout<<device_propertiesuuid; // 16 byte unique identifier
+    cout << "totalGlobalMem = " << device_properties.totalGlobalMem << endl;
+    cout << "sharedMemPerBlock = " << device_properties.sharedMemPerBlock << endl;
+    cout << "regsPerBlock = " << device_properties.regsPerBlock << endl;
+    cout << "warpSize = " << device_properties.warpSize << endl;
+    cout << "memPitch = " << device_properties.memPitch << endl;
+    cout << "maxThreadsPerBlock = " << device_properties.maxThreadsPerBlock << endl;
+    cout << "maxThreadsDim = ("
+         << device_properties.maxThreadsDim[0] << ","
+         << device_properties.maxThreadsDim[1]
+         << ")" << endl;
+    cout << "maxGridSize = ("
+         << device_properties.maxGridSize[0] << ","
+         << device_properties.maxGridSize[1]
+         << ")" << endl;
+    cout << "clockRate= " << device_properties.clockRate << endl;
+    cout << "totalConstMem= " << device_properties.totalConstMem << endl;
+    cout << "major= " << device_properties.major << endl;
+    cout << "minor= " << device_properties.minor << endl;
+    cout << "textureAlignment= " << device_properties.textureAlignment << endl;
+    cout << "texturePitchAlignment= " << device_properties.texturePitchAlignment << endl;
+    cout << "deviceOverlap= " << device_properties.deviceOverlap << endl;
+    cout << "multiProcessorCount= " << device_properties.multiProcessorCount << endl;
+    cout << "kernelExecTimeoutEnabled= " << device_properties.kernelExecTimeoutEnabled << endl;
+    cout << "integrated= " << device_properties.integrated << endl;
+    cout << "canMapHostMemory= " << device_properties.canMapHostMemory << endl;
+    cout << "computeMode= " << device_properties.computeMode << endl;
+    cout << "maxTexture1D= " << device_properties.maxTexture1D << endl;
+    cout << "maxTexture1DMipmap= " << device_properties.maxTexture1DMipmap << endl;
+    cout << "maxTexture1DLinear= " << device_properties.maxTexture1DLinear << endl;
+    cout << "maxTexture2D = ("
+         << device_properties.maxTexture2D[0] << ","
+         << device_properties.maxTexture2D[1]
+         << ")" << endl;
+    cout << "maxTexture2DMipmap = ("
+         << device_properties.maxTexture2DMipmap[0] << ","
+         << device_properties.maxTexture2DMipmap[1]
+         << ")" << endl;
+    cout << "maxTexture2DLinear = ("
+         << device_properties.maxTexture2DLinear[0] << ","
+         << device_properties.maxTexture2DLinear[1] << ","
+         << device_properties.maxTexture2DLinear[2]
+         << ")" << endl;
+    cout << "maxTexture2DGather = ("
+         << device_properties.maxTexture2DGather[0] << ","
+         << device_properties.maxTexture2DGather[1]
+         << ")" << endl;
+    cout << "maxTexture3D = ("
+         << device_properties.maxTexture3D[0] << ","
+         << device_properties.maxTexture3D[1] << ","
+         << device_properties.maxTexture3D[2]
+         << ")" << endl;
+    cout << "maxTexture3DAlt = ("
+         << device_properties.maxTexture3DAlt[0] << ","
+         << device_properties.maxTexture3DAlt[1] << ","
+         << device_properties.maxTexture3DAlt[2]
+         << ")" << endl;
+    cout << "maxTextureCubemap= " << device_properties.maxTextureCubemap << endl;
+    cout << "maxTexture1DLayered = ("
+         << device_properties.maxTexture1DLayered[0] << ","
+         << device_properties.maxTexture1DLayered[1]
+         << ")" << endl;
+    cout << "maxTexture2DLayered = ("
+         << device_properties.maxTexture2DLayered[0] << ","
+         << device_properties.maxTexture2DLayered[1] << ","
+         << device_properties.maxTexture2DLayered[2]
+         << ")" << endl;
+    cout << "maxTextureCubemapLayered = ("
+         << device_properties.maxTextureCubemapLayered[0] << ","
+         << device_properties.maxTextureCubemapLayered[1]
+         << ")" << endl;
+    cout << "maxSurface1D= " << device_properties.maxSurface1D << endl;
+    cout << "maxSurface2D = ("
+         << device_properties.maxSurface2D[0] << ","
+         << device_properties.maxSurface2D[1]
+         << ")" << endl;
+    cout << "maxSurface3D = ("
+         << device_properties.maxSurface3D[0] << ","
+         << device_properties.maxSurface3D[1] << ","
+         << device_properties.maxSurface3D[2]
+         << ")" << endl;
+    cout << "maxSurface1DLayered = ("
+         << device_properties.maxSurface1DLayered[0] << ","
+         << device_properties.maxSurface1DLayered[1]
+         << ")" << endl;
+    cout << "maxSurface2DLayered = ("
+         << device_properties.maxSurface2DLayered[0] << ","
+         << device_properties.maxSurface2DLayered[1] << ","
+         << device_properties.maxSurface2DLayered[2]
+         << ")" << endl;
+    cout << "maxSurfaceCubemap= " << device_properties.maxSurfaceCubemap << endl;
+    cout << "maxSurfaceCubemapLayered = ("
+         << device_properties.maxSurfaceCubemapLayered[0] << ","
+         << device_properties.maxSurfaceCubemapLayered[1]
+         << ")" << endl;
+    cout << "surfaceAlignment= " << device_properties.surfaceAlignment << endl;
+    cout << "concurrentKernels= " << device_properties.concurrentKernels << endl;
+    cout << "ECCEnabled= " << device_properties.ECCEnabled << endl;
+    cout << "pciBusID= " << device_properties.pciBusID << endl;
+    cout << "pciDeviceID= " << device_properties.pciDeviceID << endl;
+    cout << "pciDomainID= " << device_properties.pciDomainID << endl;
+    cout << "tccDriver= " << device_properties.tccDriver << endl;
+    cout << "asyncEngineCount= " << device_properties.asyncEngineCount << endl;
+    cout << "unifiedAddressing= " << device_properties.unifiedAddressing << endl;
+    cout << "memoryClockRate= " << device_properties.memoryClockRate << endl;
+    cout << "memoryBusWidth= " << device_properties.memoryBusWidth << endl;
+    cout << "l2CacheSize= " << device_properties.l2CacheSize << endl;
+    cout << "persistingL2CacheMaxSize= " << device_properties.persistingL2CacheMaxSize << endl;
+    cout << "maxThreadsPerMultiProcessor= " << device_properties.maxThreadsPerMultiProcessor << endl;
+    cout << "streamPrioritiesSupported= " << device_properties.streamPrioritiesSupported << endl;
+    cout << "globalL1CacheSupported= " << device_properties.globalL1CacheSupported << endl;
+    cout << "localL1CacheSupported= " << device_properties.localL1CacheSupported << endl;
+    cout << "sharedMemPerMultiprocessor= " << device_properties.sharedMemPerMultiprocessor << endl;
+    cout << "regsPerMultiprocessor= " << device_properties.regsPerMultiprocessor << endl;
+    cout << "managedMemory= " << device_properties.managedMemory << endl;
+    cout << "isMultiGpuBoard= " << device_properties.isMultiGpuBoard << endl;
+    cout << "multiGpuBoardGroupID= " << device_properties.multiGpuBoardGroupID << endl;
+    cout << "singleToDoublePrecisionPerfRatio= " << device_properties.singleToDoublePrecisionPerfRatio
+         << endl;
+    cout << "pageableMemoryAccess= " << device_properties.pageableMemoryAccess << endl;
+    cout << "concurrentManagedAccess= " << device_properties.concurrentManagedAccess << endl;
+    cout << "computePreemptionSupported= " << device_properties.computePreemptionSupported << endl;
+    cout << "canUseHostPointerForRegisteredMem= "
+         << device_properties.canUseHostPointerForRegisteredMem << endl;
+    cout << "cooperativeLaunch= " << device_properties.cooperativeLaunch << endl;
+    cout << "cooperativeMultiDeviceLaunch= " << device_properties.cooperativeMultiDeviceLaunch
+         << endl;
+    cout << "pageableMemoryAccessUsesHostPageTables= "
+         << device_properties.pageableMemoryAccessUsesHostPageTables << endl;
+    cout << "directManagedMemAccessFromHost= " << device_properties.directManagedMemAccessFromHost
+         << endl;
+    cout << "accessPolicyMaxWindowSize= " << device_properties.accessPolicyMaxWindowSize << endl;
+
+}
+
+
+cudapp::DeviceProperties::~DeviceProperties() {}
+
diff --git a/tests/test_device.cpp b/tests/test_device.cpp
index feef723..65295aa 100644
--- a/tests/test_device.cpp
+++ b/tests/test_device.cpp
@@ -11,6 +11,8 @@
 using std::cerr;
 using std::endl;
 
+using cudapp::Device;
+
 int main(int argc, char *argv[]) {
 
     std::shared_ptr <Device> device(new Device(1));
diff --git a/tests/test_device_manager.cpp b/tests/test_device_manager.cpp
index 8819802..4cd819d 100644
--- a/tests/test_device_manager.cpp
+++ b/tests/test_device_manager.cpp
@@ -9,9 +9,21 @@
 using std::cerr;
 using std::endl;
 
-int main(int argc, char** argv){
+using cudapp::DeviceManager;
 
+int main(int argc, char** argv){
     std::shared_ptr <DeviceManager> device_mgr(new DeviceManager);
+
+    auto device_count = device_mgr->device_count();
+    if(device_count){
+        cerr<<"device_count = "<<*device_count<<endl;
+    }
+
+    auto current_device = device_mgr->current_device();
+    if(current_device){
+        cerr<<"current_device = "<<*current_device<<endl;
+    }
+
 }
 
 
diff --git a/tests/test_device_properties.cpp b/tests/test_device_properties.cpp
new file mode 100644
index 0000000..1ce3f74
--- /dev/null
+++ b/tests/test_device_properties.cpp
@@ -0,0 +1,21 @@
+//
+// Created by olivas on 4/15/24.
+//
+
+#include <iostream>
+#include <cudapp/device_properties.hpp>
+
+using std::cerr;
+using std::endl;
+
+using cudapp::DeviceProperties;
+
+int main(int argc, char** argv){
+    unsigned device_number{0};
+    DeviceProperties device_properties(device_number);
+    device_properties.pretty_print();
+}
+
+
+
+