allign the allocations to the given layout.align() (#60)

* allign the allocations to the given layout.align()

Author: gkorland

src/alloc.rs

@@ -12,7 +12,9 @@ unsafe impl GlobalAlloc for RedisAlloc {
     unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
         let use_redis = USE_REDIS_ALLOC.load(SeqCst);
         if use_redis {
-            return raw::RedisModule_Alloc.unwrap()(layout.size()) as *mut u8;
+            // 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)
     }

src/context.rs

@@ -177,7 +177,7 @@ impl Context {
         raw::replicate_verbatim(self.ctx);
     }
 
-    pub fn create_string(&self, s: &str) -> RedisString{
+    pub fn create_string(&self, s: &str) -> RedisString {
         RedisString::create(self.ctx, s)
     }
 }

src/key.rs

@@ -240,7 +240,11 @@ fn read_key(key: *mut raw::RedisModuleKey) -> Result<String, Utf8Error> {
     )
 }
 
-fn hash_get_key(ctx: *mut raw::RedisModuleCtx, key: *mut raw::RedisModuleKey, field: &str) -> Option<RedisString> {
+fn hash_get_key(
+    ctx: *mut raw::RedisModuleCtx,
+    key: *mut raw::RedisModuleKey,
+    field: &str,
+) -> Option<RedisString> {
     let res = raw::hash_get(key, field);
     if res.is_null() {
         None

src/raw.rs

@@ -239,14 +239,27 @@ pub fn string_dma(key: *mut RedisModuleKey, len: *mut size_t, mode: KeyMode) ->
 pub fn hash_get(key: *mut RedisModuleKey, field: &str) -> *mut RedisModuleString {
     let res: *mut RedisModuleString = ptr::null_mut();
     unsafe {
-        RedisModule_HashGet.unwrap()(key, REDISMODULE_HASH_CFIELDS as i32, CString::new(field).unwrap().as_ptr(), &res, 0);
+        RedisModule_HashGet.unwrap()(
+            key,
+            REDISMODULE_HASH_CFIELDS as i32,
+            CString::new(field).unwrap().as_ptr(),
+            &res,
+            0,
+        );
     }
     res
 }
 
 pub fn hash_set(key: *mut RedisModuleKey, field: &str, value: *mut RedisModuleString) -> Status {
     unsafe {
-        RedisModule_HashSet.unwrap()(key, REDISMODULE_HASH_CFIELDS as i32, CString::new(field).unwrap().as_ptr(), value, 0).into()
+        RedisModule_HashSet.unwrap()(
+            key,
+            REDISMODULE_HASH_CFIELDS as i32,
+            CString::new(field).unwrap().as_ptr(),
+            value,
+            0,
+        )
+        .into()
     }
 }
 
@@ -334,6 +347,12 @@ pub fn save_unsigned(rdb: *mut RedisModuleIO, val: u64) {
     unsafe { RedisModule_SaveUnsigned.unwrap()(rdb, val) };
 }
 
-pub fn string_append_buffer(ctx: *mut RedisModuleCtx, s: *mut RedisModuleString, buff: &str) -> Status {
-    unsafe { RedisModule_StringAppendBuffer.unwrap()(ctx, s, buff.as_ptr() as *mut i8, buff.len()).into() }
-}
+pub fn string_append_buffer(
+    ctx: *mut RedisModuleCtx,
+    s: *mut RedisModuleString,
+    buff: &str,
+) -> Status {
+    unsafe {
+        RedisModule_StringAppendBuffer.unwrap()(ctx, s, buff.as_ptr() as *mut i8, buff.len()).into()
+    }
+}

src/redismodule.rs

@@ -72,10 +72,7 @@ pub struct RedisString {
 
 impl RedisString {
     pub fn new(ctx: *mut raw::RedisModuleCtx, inner: *mut raw::RedisModuleString) -> RedisString {
-        RedisString{
-            ctx,
-            inner
-        }
+        RedisString { ctx, inner }
     }
 
     pub fn create(ctx: *mut raw::RedisModuleCtx, s: &str) -> RedisString {
@@ -93,7 +90,7 @@ impl RedisString {
     }
 
     pub fn append(&mut self, s: &str) -> raw::Status {
-        raw::string_append_buffer(self.ctx, self.inner, s) 
+        raw::string_append_buffer(self.ctx, self.inner, s)
     }
 
     pub fn len(&self) -> usize {