cumo 0.5.5 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 96a38fa0ad4be223020cef21720e30e9a32fcd2901798279293924df8bfd0f92
-  data.tar.gz: c826e49bea46001d6764c7d0f8ad124e5b6072543eb97a07990a26453dd71bf7
+  metadata.gz: 3ddc7b756681afdf9fccd45652c422d2f67accfd1cf238d1fd05f6827fb5029d
+  data.tar.gz: 47848503fd8a388b7dfee79d2da0e627032fd4d8c8717645da70d8f09770f599
 SHA512:
-  metadata.gz: 1dba1ea3cb5a9c93044d222a9d03c975809c5b03d7925702aa3357a0244752d532cb9421b0632e71808944685c3ca44e7a0fc6032ca8c39d8083c279596dce61
-  data.tar.gz: 81c933a8f07f862b22a0c6be5e397000d4ea9476139203353907ba7de21a7aae418264fa8425b197d6302861a2788d262af2d2ecd2e34100900d2293706439f4
+  metadata.gz: f59ddc27c8f96a5eceec7fb4ae6665d1fae6dd20ef039a83563c0e0f5a76780fd2ab9b5ebbe06e116a3f01cd59c7493eee06dc6c1166a0bb82ba546c43331f03
+  data.tar.gz: 16543c06d74f79089799442abc30741ffb2a26556da953410023b19711fd25e15adb05548f9664c79bf8430a3be9c8f15c0813dccfae4b5e918ffc55a5fc68c0

data/CHANGELOG.md

@@ -1,3 +1,55 @@
+# 0.5.7 (2026/08/13)
+
+Breaking changes:
+
+* `reshape` raises `ArgumentError` instead of `RangeError` for a dimension above `INT_MAX` (PR #183)
+* `parse` accepts only numeric literals and `true`/`false`/`nil`, so `parse("3/4")` raises `ArgumentError` instead of returning `[[0]]` (PR #190)
+
+Fixes:
+
+* Fix segfaults from CUDA handles the process did not create, and from destroying one twice (PR #192)
+* Fix process abort from freeing NArray data with the wrong allocator, including a raise out of GC for `Cumo::RObject` (PR #191)
+* Fix arbitrary code execution in `parse`, which ran `eval` on every token (PR #190)
+* Fix stack buffer overflow in `Cumo::RObject#format` with an element longer than 47 characters (PR #189)
+* Fix a freed chunk returning to the arena of the wrong stream (PR #187)
+* Fix `Malloc` searching the free list with the default stream's index (PR #186)
+* Fix data race on the memory pool chunk graph and on the per-device pool table (PR #185)
+* Fix a SIGFPE on fractional range steps and an out-of-bounds read on newaxis (PR #184)
+* Fix a SIGFPE and a silently corrupt shape from unchecked `reshape` arguments (PR #183)
+* Fix segfault when `store_binary` receives a non-String (PR #182)
+* Fix missing range check on NArray indices, which segfaulted on a negative one (PR #181)
+
+Changes:
+
+* Compile the memory pool test harness in CI, and run it from `rake test` (PR #188)
+
+# 0.5.6 (2026/08/09)
+
+Fixes:
+
+* Fix out-of-tree build failing to create the narray/types object directory
+* Fix segfaults from unchecked String arguments in Driver (#179)
+* Fix out-of-bounds read of include_names in nvrtcCreateProgram (#178)
+* Fix store into a strided view reading a released staging buffer (#177)
+* Fix pinned host memory leak when indexing by an array (#176)
+* Fix segfault in Module#get_global_var reading device memory as a host pointer (#174)
+* Fix freeing pooled memory with cudaFree after disabling the pool (#173)
+* Fix run-ctest failing to start the test binary (#172)
+* Fix process abort when freeing device memory fails (#171)
+* Fix memory pool handing out a tiny chunk for a huge allocation (#170)
+* Fix out-of-bounds read of a shorter sub-narray in store (#169)
+* Fix out-of-bounds device write in store when a sub-narray is too long (#168)
+* Backport: fix na_flatten_dim for multi-dimensional empty arrays (#167)
+* Backport: make qsort loop condition explicit to prevent incorrect optimization (#166)
+* Backport: free previously allocated shape in cumo_na_alloc_shape (#165)
+* Backport: free shape on deallocation regardless of size (#164)
+* Backport: convert max to double in rand method of Cumo::RObject (#163)
+* Backport: use an inline function to prevent double use of macro argument (#162)
+* Fix out-of-bounds stridx access in at() when :new is given (#161)
+* Backport: prevent out-of-bounds access to stridx when orig_dim exceeds ndim (#160)
+* Backport: prevent negative array index in na_get_strides_nadata when ndim is zero (#159)
+* Backport: use correct array index for mod result in divmod macro for Cumo::RObject (#158)
+
 # 0.5.5 (2026/07/11)
 
 Fixes:

data/Rakefile

@@ -12,10 +12,19 @@ end
 require "rake/extensiontask"
 Rake::ExtensionTask.new("cumo")
 
-task :ctest do
-  sh 'cd ext/cumo && ruby extconf.rb && make && make build-ctest && make run-ctest'
+desc 'Build the C++ memory pool test harness without running it (running it needs a GPU)'
+task :build_ctest do
+  sh 'cd ext/cumo && ruby extconf.rb && make build-ctest'
 end
 
+task :ctest => :build_ctest do
+  sh 'cd ext/cumo && make run-ctest'
+end
+
+# Both need a GPU, so CI runs neither. Tie them together so the one place
+# they do run does not skip half of them.
+task :test => :ctest
+
 task :docs do
   dir = "ext/cumo"
   srcs = %w[array.c data.c index.c math.c narray.c rand.c struct.c].map { |s| File.join(dir, "narray", s) }

data/ext/cumo/cuda/driver.c

@@ -3,12 +3,16 @@
 #include <cuda.h>
 #include <cuda_runtime.h>
 #include "cumo/cuda/driver.h"
+#include "cumo/cuda/handle.h"
 
 VALUE cumo_cuda_eDriverError;
 VALUE cumo_cuda_mDriver;
 #define eDriverError cumo_cuda_eDriverError
 #define mDriver cumo_cuda_mDriver
 
+static cumo_cuda_handle_set_t link_states;
+static cumo_cuda_handle_set_t modules;
+
 static void
 check_status(CUresult status)
 {
@@ -100,17 +104,21 @@ cuLinkAddData_without_gvl_cb(void *param)
 static VALUE
 rb_cuLinkAddData(VALUE self, VALUE state, VALUE type, VALUE data, VALUE name)
 {
-    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
     CUjitInputType _type = (CUjitInputType)NUM2INT(type);
-    void* _data = (void *)RSTRING_PTR(data);
+    // The image may be a cubin, so it is taken by length and allowed to hold
+    // NUL bytes; the name is a plain C string cuLinkAddData reports errors with.
+    void* _data = (void *)StringValuePtr(data);
     size_t _size = RSTRING_LEN(data);
-    const char* _name = RSTRING_PTR(data);
+    const char* _name = StringValueCStr(name);
+    CUlinkState _state = (CUlinkState)cumo_cuda_handle_get(&link_states, state, "CUlinkState");
     CUresult status;
 
     struct cuLinkAddDataParam param = {_state, _type, _data, _size, _name, 0, (CUjit_option*)0, (void**)0};
     status = (CUresult)rb_thread_call_without_gvl(cuLinkAddData_without_gvl_cb, &param, NULL, NULL);
     //status = cuLinkAddData(_state, _type, _data, _size, _name, 0, (CUjit_option*)0, (void**)0);
 
+    RB_GC_GUARD(data);
+    RB_GC_GUARD(name);
     check_status(status);
     return Qnil;
 }
@@ -137,15 +145,16 @@ cuLinkAddFile_without_gvl_cb(void *param)
 static VALUE
 rb_cuLinkAddFile(VALUE self, VALUE state, VALUE type, VALUE path)
 {
-    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
     CUjitInputType _type = (CUjitInputType)NUM2INT(type);
-    const char* _path = RSTRING_PTR(path);
+    const char* _path = StringValueCStr(path);
+    CUlinkState _state = (CUlinkState)cumo_cuda_handle_get(&link_states, state, "CUlinkState");
     CUresult status;
 
     struct cuLinkAddFileParam param = {_state, _type, _path, 0, (CUjit_option*)0, (void **)0};
     status = (CUresult)rb_thread_call_without_gvl(cuLinkAddFile_without_gvl_cb, &param, NULL, NULL);
     //status = cuLinkAddFile(_state, _type, _path, 0, (CUjit_option*)0, (void **)0);
 
+    RB_GC_GUARD(path);
     check_status(status);
     return Qnil;
 }
@@ -168,7 +177,7 @@ cuLinkComplete_without_gvl_cb(void *param)
 static VALUE
 rb_cuLinkComplete(VALUE self, VALUE state)
 {
-    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
+    CUlinkState _state = (CUlinkState)cumo_cuda_handle_get(&link_states, state, "CUlinkState");
     void* _cubinOut;
     size_t _sizeOut;
     CUresult status;
@@ -209,6 +218,7 @@ rb_cuLinkCreate(VALUE self)
     //status = cuLinkCreate(0, (CUjit_option*)0, (void**)0, &state);
 
     check_status(status);
+    cumo_cuda_handle_set_add(&link_states, (size_t)state);
     return SIZET2NUM((size_t)state);
 }
 
@@ -228,7 +238,7 @@ cuLinkDestroy_without_gvl_cb(void *param)
 static VALUE
 rb_cuLinkDestroy(VALUE self, VALUE state)
 {
-    CUlinkState _state = (CUlinkState)NUM2SIZET(state);
+    CUlinkState _state = (CUlinkState)cumo_cuda_handle_take(&link_states, state, "CUlinkState");
     CUresult status;
 
     struct cuLinkDestroyParam param = {_state};
@@ -258,14 +268,15 @@ static VALUE
 rb_cuModuleGetFunction(VALUE self, VALUE hmod, VALUE name)
 {
     CUfunction _hfunc;
-    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
-    const char* _name = RSTRING_PTR(name);
+    const char* _name = StringValueCStr(name);
+    CUmodule _hmod = (CUmodule)cumo_cuda_handle_get(&modules, hmod, "CUmodule");
     CUresult status;
 
     struct cuModuleGetFunctionParam param = {&_hfunc, _hmod, _name};
     status = (CUresult)rb_thread_call_without_gvl(cuModuleGetFunction_without_gvl_cb, &param, NULL, NULL);
     //status = cuModuleGetFunction(&_hfunc, _hmod, _name);
 
+    RB_GC_GUARD(name);
     check_status(status);
     return SIZET2NUM((size_t)_hfunc);
 }
@@ -291,16 +302,22 @@ rb_cuModuleGetGlobal(VALUE self, VALUE hmod, VALUE name)
 {
     CUdeviceptr _dptr;
     size_t _bytes;
-    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
-    const char* _name = RSTRING_PTR(name);
+    const char* _name = StringValueCStr(name);
+    CUmodule _hmod = (CUmodule)cumo_cuda_handle_get(&modules, hmod, "CUmodule");
     CUresult status;
+    VALUE ret;
 
     struct cuModuleGetGlobalParam param = {&_dptr, &_bytes, _hmod, _name};
     status = (CUresult)rb_thread_call_without_gvl(cuModuleGetGlobal_without_gvl_cb, &param, NULL, NULL);
     //status = cuModuleGetGlobal(&_dptr, &_bytes, _hmod, _name);
 
+    RB_GC_GUARD(name);
     check_status(status);
-    return rb_str_new((char *)_dptr, _bytes);
+
+    // _dptr addresses device memory, which the host cannot read directly.
+    ret = rb_str_new(NULL, (long)_bytes);
+    check_status(cuMemcpyDtoH(RSTRING_PTR(ret), _dptr, _bytes));
+    return ret;
 }
 
 struct cuModuleLoadParam {
@@ -321,14 +338,16 @@ static VALUE
 rb_cuModuleLoad(VALUE self, VALUE fname)
 {
     CUmodule _module;
-    const char* _fname = RSTRING_PTR(fname);
+    const char* _fname = StringValueCStr(fname);
     CUresult status;
 
     struct cuModuleLoadParam param = {&_module, _fname};
     status = (CUresult)rb_thread_call_without_gvl(cuModuleLoad_without_gvl_cb, &param, NULL, NULL);
     //status = cuModuleLoad(&_module, _fname);
 
+    RB_GC_GUARD(fname);
     check_status(status);
+    cumo_cuda_handle_set_add(&modules, (size_t)_module);
     return SIZET2NUM((size_t)_module);
 }
 
@@ -350,14 +369,17 @@ static VALUE
 rb_cuModuleLoadData(VALUE self, VALUE image)
 {
     CUmodule _module;
-    const void* _image = (void*)RSTRING_PTR(image);
+    // A cubin is binary, so the image is not required to be NUL-free.
+    const void* _image = (void*)StringValuePtr(image);
     CUresult status;
 
     struct cuModuleLoadDataParam param = {&_module, _image};
     status = (CUresult)rb_thread_call_without_gvl(cuModuleLoadData_without_gvl_cb, &param, NULL, NULL);
     //status = cuModuleLoadData(&_module, _image);
 
+    RB_GC_GUARD(image);
     check_status(status);
+    cumo_cuda_handle_set_add(&modules, (size_t)_module);
     return SIZET2NUM((size_t)_module);
 }
 
@@ -377,7 +399,7 @@ cuModuleUnload_without_gvl_cb(void *param)
 static VALUE
 rb_cuModuleUnload(VALUE self, VALUE hmod)
 {
-    CUmodule _hmod = (CUmodule)NUM2SIZET(hmod);
+    CUmodule _hmod = (CUmodule)cumo_cuda_handle_take(&modules, hmod, "CUmodule");
     CUresult status;
 
     struct cuModuleUnloadParam param = {_hmod};
@@ -399,6 +421,9 @@ Init_cumo_cuda_driver()
     mDriver = rb_define_module_under(mCUDA, "Driver");
     eDriverError = rb_define_class_under(mCUDA, "DriverError", rb_eStandardError);
 
+    cumo_cuda_handle_set_init(&link_states);
+    cumo_cuda_handle_set_init(&modules);
+
     rb_define_singleton_method(mDriver, "cuCtxGetCurrent", rb_cuCtxGetCurrent, 0);
     rb_define_singleton_method(mDriver, "cuLinkAddData",   rb_cuLinkAddData,   4);
     rb_define_singleton_method(mDriver, "cuLinkAddFile", rb_cuLinkAddFile, 3);

data/ext/cumo/cuda/memory_pool.cpp

@@ -50,16 +50,21 @@ cumo_cuda_runtime_malloc(size_t size)
 void
 cumo_cuda_runtime_free(char *ptr)
 {
-    if (memory_pool_enabled) {
-        try {
-            // TODO(sonots): Get current CUDA stream and pass it
-            pool.Free(reinterpret_cast<intptr_t>(ptr));
-        } catch (const cumo::internal::CUDARuntimeError& e) {
-            cumo_cuda_runtime_check_status(e.status());
+    // Always offer the pointer to the pool first, whatever memory_pool_enabled
+    // says now: MemoryPool.enable/disable is public, so the state can differ
+    // from what it was at allocation time. Handing a pooled chunk to cudaFree
+    // releases memory the pool still hands out, and fails outright for a chunk
+    // which is not at the head of its buffer.
+    try {
+        if (pool.Free(reinterpret_cast<intptr_t>(ptr))) {
+            return;
         }
-    } else {
-        cumo_cuda_runtime_check_status(cudaFree((void*)ptr));
+    } catch (const cumo::internal::CUDARuntimeError& e) {
+        cumo_cuda_runtime_check_status(e.status());
+        return;
     }
+    // No pool owns it, so it came straight from cudaMallocManaged.
+    cumo_cuda_runtime_check_status(cudaFree((void*)ptr));
 }
 
 /*

data/ext/cumo/cuda/memory_pool_impl.cpp

@@ -1,5 +1,7 @@
 #include "memory_pool_impl.hpp"
 
+#include <cstdio>
+
 #include <ruby.h>
 
 namespace cumo {
@@ -25,9 +27,15 @@ Memory::~Memory() {
         cudaError_t status = cudaFree(ptr_);
         // CUDA driver may shut down before freeing memory inside memory pool.
         // It is okay to simply ignore because CUDA driver automatically frees memory.
-        if (status != cudaErrorCudartUnloading) {
-            CheckStatus(status);
+        if (status == cudaSuccess || status == cudaErrorCudartUnloading) {
+            return;
         }
+        // A destructor is implicitly noexcept, so throwing here would call
+        // std::terminate and abort the process. Report the failure instead:
+        // cudaFree only fails once the context is already unusable, and the
+        // next runtime call reports the same status to the caller anyway.
+        std::fprintf(stderr, "cumo: failed to free %zu bytes of device memory: %s\n",
+                     size_, cudaGetErrorString(status));
     }
 }
 
@@ -63,14 +71,14 @@ void Merge(std::shared_ptr<Chunk>& self, std::shared_ptr<Chunk> remaining) {
 
 void SingleDeviceMemoryPool::AppendToFreeList(size_t size, std::shared_ptr<Chunk>& chunk, cudaStream_t stream_ptr) {
     assert(chunk != nullptr && !chunk->in_use());
-    int bin_index = GetBinIndex(size);
+    size_t bin_index = GetBinIndex(size);
 
     std::lock_guard<std::recursive_mutex> lock{mutex_};
 
     Arena& arena = GetArena(stream_ptr);
     ArenaIndexMap& arena_index_map = GetArenaIndexMap(stream_ptr);
-    int arena_index = std::lower_bound(arena_index_map.begin(), arena_index_map.end(), bin_index) - arena_index_map.begin();
-    int length = static_cast<int>(arena_index_map.size());
+    size_t arena_index = std::lower_bound(arena_index_map.begin(), arena_index_map.end(), bin_index) - arena_index_map.begin();
+    size_t length = arena_index_map.size();
     if (arena_index >= length || arena_index_map.at(arena_index) != bin_index) {
         arena_index_map.insert(arena_index_map.begin() + arena_index, bin_index);
         arena.insert(arena.begin() + arena_index, FreeList{});
@@ -81,7 +89,7 @@ void SingleDeviceMemoryPool::AppendToFreeList(size_t size, std::shared_ptr<Chunk
 
 bool SingleDeviceMemoryPool::RemoveFromFreeList(size_t size, std::shared_ptr<Chunk>& chunk, cudaStream_t stream_ptr) {
     assert(chunk != nullptr && !chunk->in_use());
-    int bin_index = GetBinIndex(size);
+    size_t bin_index = GetBinIndex(size);
 
     std::lock_guard<std::recursive_mutex> lock{mutex_};
 
@@ -90,20 +98,32 @@ bool SingleDeviceMemoryPool::RemoveFromFreeList(size_t size, std::shared_ptr<Chu
     if (arena_index_map.size() == 0) {
         return false;
     }
-    int arena_index = std::lower_bound(arena_index_map.begin(), arena_index_map.end(), bin_index) - arena_index_map.begin();
-    if (static_cast<size_t>(arena_index) == arena_index_map.size()) {
+    size_t arena_index = std::lower_bound(arena_index_map.begin(), arena_index_map.end(), bin_index) - arena_index_map.begin();
+    if (arena_index == arena_index_map.size()) {
         // Bin does not exist for the given chunk size.
         return false;
     }
     if (arena_index_map.at(arena_index) != bin_index) {
         return false;
     }
-    assert(arena.size() > static_cast<size_t>(arena_index));
+    assert(arena.size() > arena_index);
     FreeList& free_list = arena[arena_index];
     return EraseFromFreeList(free_list, chunk);
 }
 
 intptr_t SingleDeviceMemoryPool::Malloc(size_t size, cudaStream_t stream_ptr) {
+    if (size == 0) {
+        // A zero-sized chunk would share its address with the chunk it was
+        // split from, and aliased addresses break the `in_use_` bookkeeping.
+        // cudaMalloc returns a null pointer for a zero-sized request as well.
+        return 0;
+    }
+    if (size > kMaxAllocationSize) {
+        // Rounding up would wrap around in size_t and the pool would then hand
+        // out a chunk far smaller than requested. Such a request can never be
+        // satisfied, so report it as out of memory instead.
+        throw OutOfMemoryError(size, GetTotalBytes());
+    }
     size = GetRoundedSize(size);
     std::shared_ptr<Chunk> chunk = nullptr;
 
@@ -112,9 +132,9 @@ intptr_t SingleDeviceMemoryPool::Malloc(size_t size, cudaStream_t stream_ptr) {
 
         // find best-fit, or a smallest larger allocation
         Arena& arena = GetArena(stream_ptr);
-        int arena_index = GetArenaIndex(size);
-        int arena_length = static_cast<int>(arena.size());
-        for (int i = arena_index; i < arena_length; ++i) {
+        size_t arena_index = GetArenaIndex(size, stream_ptr);
+        size_t arena_length = arena.size();
+        for (size_t i = arena_index; i < arena_length; ++i) {
             FreeList& free_list = arena[i];
             if (free_list.empty()) {
                 continue;
@@ -123,15 +143,22 @@ intptr_t SingleDeviceMemoryPool::Malloc(size_t size, cudaStream_t stream_ptr) {
             // TODO(sonots): compact_index
             break;
         }
-    }
 
-    if (chunk != nullptr) {
-        std::shared_ptr<Chunk> remaining = Split(chunk, size);
-        if (remaining != nullptr) {
-            AppendToFreeList(remaining->size(), remaining, stream_ptr);
+        // Splitting rewrites the prev/next pointers of the neighbouring
+        // chunks, which other threads reach through the free lists, so it has
+        // to happen under the same lock as the search above.
+        if (chunk != nullptr) {
+            std::shared_ptr<Chunk> remaining = Split(chunk, size);
+            if (remaining != nullptr) {
+                AppendToFreeList(remaining->size(), remaining, stream_ptr);
+            }
         }
-    } else {
-        // cudaMalloc if a cache is not found
+    }
+
+    if (chunk == nullptr) {
+        // cudaMalloc if a cache is not found. This stays outside the lock: it
+        // is slow, and a chunk of a fresh allocation has no neighbours for
+        // another thread to reach it through.
         std::shared_ptr<Memory> mem = nullptr;
         try {
             mem = std::make_shared<Memory>(size);
@@ -166,19 +193,45 @@ intptr_t SingleDeviceMemoryPool::Malloc(size_t size, cudaStream_t stream_ptr) {
     return chunk->ptr();
 }
 
-void SingleDeviceMemoryPool::Free(intptr_t ptr, cudaStream_t stream_ptr) {
+bool SingleDeviceMemoryPool::Free(intptr_t ptr) {
     std::shared_ptr<Chunk> chunk = nullptr;
 
-    {
-        std::lock_guard<std::recursive_mutex> lock{mutex_};
+    // The whole body runs under the lock. Walking prev/next and merging is a
+    // read-modify-write of the chunk graph, which is shared: a neighbour can
+    // be split by a concurrent Malloc while this reads its prev/next.
+    //
+    // The lost merge is the part that shows: two threads freeing neighbouring
+    // chunks each look for the other in the free list before the other has
+    // appended itself, so both merges fail and the two chunks stay split for
+    // good. Fragmentation accumulates from there.
+    //
+    // mutex_ is recursive, so the RemoveFromFreeList/AppendToFreeList calls
+    // below can take it again.
+    std::lock_guard<std::recursive_mutex> lock{mutex_};
 
-        chunk = in_use_[ptr];
-        // assert(chunk != nullptr);
-        if (!chunk) return;
+    {
+        // find rather than operator[], which would insert an empty entry for
+        // every pointer this pool does not own.
+        auto it = in_use_.find(ptr);
+        if (it == in_use_.end()) {
+            return false;
+        }
+        chunk = it->second;
+        in_use_.erase(it);
+        if (!chunk) {
+            return false;
+        }
         chunk->set_in_use(false);
-        in_use_.erase(ptr);
     }
 
+    // A chunk belongs to the arena of the stream it was allocated on. That is
+    // what makes reuse safe: the next allocation from that arena is queued on
+    // the same stream as the work that last used the chunk, so the two are
+    // ordered. Returning it to another stream's arena hands it to work with no
+    // such ordering. Malloc and Merge each state the invariant in an assert,
+    // but ruby.h defines NDEBUG, so neither ever runs.
+    const cudaStream_t stream_ptr = chunk->stream_ptr();
+
     if (chunk->next() != nullptr && !chunk->next()->in_use()) {
         if (RemoveFromFreeList(chunk->next()->size(), chunk->next(), stream_ptr)) {
             Merge(chunk, chunk->next());
@@ -191,6 +244,7 @@ void SingleDeviceMemoryPool::Free(intptr_t ptr, cudaStream_t stream_ptr) {
         }
     }
     AppendToFreeList(chunk->size(), chunk, stream_ptr);
+    return true;
 }
 
 void SingleDeviceMemoryPool::CompactIndex(cudaStream_t stream_ptr, bool free) {