cleaner way to use redis allocator

Author: siscia

src/alloc.rs

@@ -1,4 +1,4 @@
-use std::alloc::{GlobalAlloc, Layout, System};
+use std::alloc::{GlobalAlloc, Layout};
 use std::os::raw::c_void;
 use std::sync::atomic::{AtomicBool, Ordering::SeqCst};
 
@@ -10,21 +10,12 @@ static USE_REDIS_ALLOC: AtomicBool = AtomicBool::new(false);
 
 unsafe impl GlobalAlloc for RedisAlloc {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
-        let use_redis = USE_REDIS_ALLOC.load(SeqCst);
-        if use_redis {
-            // complete the requested size to be aligned with the requested layout.align()
-            let size = (layout.size() + layout.align() - 1) & (!(layout.align() - 1));
-            return raw::RedisModule_Alloc.unwrap()(size) as *mut u8;
-        }
-        System.alloc(layout)
+        let size = (layout.size() + layout.align() - 1) & (!(layout.align() - 1));
+        return raw::RedisModule_Alloc.unwrap()(size) as *mut u8;
     }
 
-    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
-        let use_redis = USE_REDIS_ALLOC.load(SeqCst);
-        if use_redis {
-            return raw::RedisModule_Free.unwrap()(ptr as *mut c_void);
-        }
-        System.dealloc(ptr, layout);
+    unsafe fn dealloc(&self, ptr: *mut u8, _layout: Layout) {
+        return raw::RedisModule_Free.unwrap()(ptr as *mut c_void);
     }
 }
 

src/macros.rs

@@ -87,19 +87,24 @@ macro_rules! redis_module {
             _argv: *mut *mut raw::RedisModuleString,
             _argc: c_int,
         ) -> c_int {
-            {
+            let mut name_buffer = [0; 64];
+                  let mut dest = name_buffer.as_mut_ptr();
+            for byte in $module_name.chars() {
+                unsafe {
+                    *dest = byte as i8;
+                    dest = dest.add(1);
+                }
+            }
                 // We use an explicit block here to make sure all memory allocated before we
                 // switch to the Redis allocator will be out of scope and thus deallocated.
-                let module_name = CString::new($module_name).unwrap();
                 let module_version = $module_version as c_int;
 
                 if unsafe { raw::Export_RedisModule_Init(
                     ctx,
-                    module_name.as_ptr(),
+                    name_buffer.as_ptr() as *const std::os::raw::c_char,
                     module_version,
                     raw::REDISMODULE_APIVER_1 as c_int,
                 ) } == raw::Status::Err as c_int { return raw::Status::Err as c_int; }
-            }
 
             if true {
                 redis_module::alloc::use_redis_alloc();