Dump the requested aligment if out of memory while allocating a table.

components/hashglobe/src/lib.rs

@@ -26,17 +26,25 @@ trait Recover<Q: ?Sized> {
     fn replace(&mut self, key: Self::Key) -> Option<Self::Key>;
 }
 
+#[derive(Debug)]
+pub struct AllocationInfo {
+    /// The size we are requesting.
+    size: usize,
+    /// The alignment we are requesting.
+    alignment: usize,
+}
+
 #[derive(Debug)]
 pub struct FailedAllocationError {
     reason: &'static str,
-    /// The size we are allocating, if needed.
+    /// The allocation info we are requesting, if needed.
-    allocation_size: Option<usize>,
+    allocation_info: Option<AllocationInfo>,
 }
 
 impl FailedAllocationError {
     #[inline]
     pub fn new(reason: &'static str) -> Self {
-        Self { reason, allocation_size: None }
+        Self { reason, allocation_info: None }
     }
 }
 
@@ -48,8 +56,10 @@ impl error::Error for FailedAllocationError {
 
 impl fmt::Display for FailedAllocationError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match self.allocation_size {
+        match self.allocation_info {
-            Some(size) => write!(f, "{}, allocation size: {}", self.reason, size),
+            Some(ref info) => {
+                write!(f, "{}, allocation: (size: {}, alignment: {})", self.reason, info.size, info.alignment)
+            },
             None => self.reason.fmt(f),
         }
     }

components/hashglobe/src/table.rs

@@ -778,9 +778,10 @@ impl<K, V> RawTable<K, V> {
         let buffer = alloc(size, alignment);
 
         if buffer.is_null() {
+            use AllocationInfo;
             return Err(FailedAllocationError {
                 reason: "out of memory when allocating RawTable",
-                allocation_size: Some(size),
+                allocation_info: Some(AllocationInfo { size, alignment }),
             });
         }