.

CMakeLists.txt

@@ -7,6 +7,7 @@ option(CXX23_STACKTRACE "Enable C++23 stacktrace" OFF)
 enable_language(CXX)
 if(CXX23_STACKTRACE)
     set(CMAKE_CXX_STANDARD 23)
+    add_definitions(-DINCLUDE_CXX23_STACKTRACE)
 else(CXX23_STACKTRACE)
     set(CMAKE_CXX_STANDARD 11)
 endif(CXX23_STACKTRACE)
@@ -36,10 +37,18 @@ if(INCLUDE_CUDA)
     )
 endif(INCLUDE_CUDA)
 
+if(CXX23_STACKTRACE)
+    set(STACKTRACE_HEADERS
+        include/stacktrace.h
+        )
+endif(CXX23_STACKTRACE)
+
 set(SOURCES ${SOURCES_CU} ${SOURCES_CXX})
-set(HEADERS ${HEADERS_CU} ${HEADERS_CXX})
+set(HEADERS ${HEADERS_CU} ${HEADERS_CXX} ${STACKTRACE_HEADERS})
 
 add_library(memproc STATIC ${HEADERS} ${SOURCES})
+target_include_directories(memproc PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+
 if(CXX23_STACKTRACE)
     target_link_libraries(memproc PUBLIC -lstdc++_libbacktrace)
 endif(CXX23_STACKTRACE)
\ No newline at end of file

include/stacktrace.h

+#pragma once 
+
+#include <iostream>
+#include <stacktrace>
+
+void print_stacktrace() 
+{
+    std::cout << std::stacktrace::current() << '\n';
+}
\ No newline at end of file

src/MemoryProcessing.cpp

-#include "../include/MemoryProcessing.h"
+#include "MemoryProcessing.h"
 #include <cstdlib>
 #include <cstring>
 
+#ifdef INCLUDE_CXX23_STACKTRACE
+    #include "stacktrace.h"
+#endif
+
 namespace memproc
 {
     template<>
     bool dealloc<MemType::CPU>(void *&array, size_t &allocated_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         if(allocated_size > 0)
         {
             free(array);
@@ -19,6 +27,10 @@ namespace memproc
     template<>
     bool dealloc<MemType::CPU>(void *&array)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         free(array);
         return true;
     }
@@ -26,6 +38,10 @@ namespace memproc
     template <>
     bool alloc<MemType::CPU>(void *&array, const size_t new_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         array = malloc(new_size);
         memset(array, 0, new_size);
 
@@ -36,6 +52,10 @@ namespace memproc
     template <>
     bool realloc<MemType::CPU>(void *&array, size_t &allocated_size, const size_t new_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         if(new_size > allocated_size)
         {
             if(allocated_size > 0) dealloc<MemType::CPU>(array, allocated_size);
@@ -50,6 +70,10 @@ namespace memproc
     template <>
     bool memcopy<MemType::CPU, MemType::CPU>(void *dst, const void* src, const size_t copy_elem_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         memcpy(dst, src, copy_elem_size);
 
         return true;

src/MemoryProcessing.cu

-#include "../include/MemoryProcessing.cuh"
+#include "MemoryProcessing.cuh"
 #include <cuda.h>
 #include <cuda_runtime_api.h>
 
+#ifdef INCLUDE_CXX23_STACKTRACE
+    #include "stacktrace.h"
+#endif
+
 namespace memproc
 {
     template<>
     bool dealloc<MemType::GPU>(void *&array, size_t &allocated_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         if(allocated_size > 0)
         {
             cudaFree(array);
@@ -19,6 +27,10 @@ namespace memproc
     template<>
     bool dealloc<MemType::GPU>(void *&array)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaFree(array);
         return true;
     }
@@ -26,6 +38,10 @@ namespace memproc
     template <>
     bool alloc<MemType::GPU>(void *&array, const size_t new_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaMalloc ( (void **)&array, new_size);
         cudaMemset(array, 0, new_size);
 
@@ -35,6 +51,10 @@ namespace memproc
     template <>
     bool realloc<MemType::GPU>(void *&array, size_t &allocated_size, const size_t new_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         if(new_size > allocated_size)
         {
             if(allocated_size > 0) dealloc<MemType::GPU>(array, allocated_size);
@@ -49,6 +69,10 @@ namespace memproc
     template <>
     bool memcopy<MemType::GPU, MemType::CPU>(void *dst, const void* src, const size_t copy_elem_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyHostToDevice);
 
         return true;
@@ -57,6 +81,10 @@ namespace memproc
     template <>
     bool memcopy<MemType::CPU, MemType::GPU>(void *dst, const void* src, const size_t copy_elem_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyDeviceToHost);
         return true;
     }
@@ -64,6 +92,10 @@ namespace memproc
     template <>
     bool memcopy<MemType::GPU, MemType::GPU>(void *dst, const void* src, const size_t copy_elem_size)
     {
+    #ifdef INCLUDE_CXX23_STACKTRACE
+        print_stacktrace();
+    #endif
+
         cudaMemcpy ( dst, src, copy_elem_size, cudaMemcpyDeviceToDevice);
         return true;
     }