Make stdlib mem::allocator more complete. (#1238)

Make stdlib mem::allocator more complete. Fill in some gaps and docstrings. List.to_new_array. Handle overalignment smoothly in list.

lib/std/collections/list.c3

@@ -9,6 +9,8 @@ def ElementTest = fn bool(Type *type, any context);
 const ELEMENT_IS_EQUATABLE = types::is_equatable_type(Type);
 const ELEMENT_IS_POINTER = Type.kindof == POINTER;
 
+macro type_is_overaligned() => Type.alignof > mem::DEFAULT_MEM_ALIGNMENT;
+
 struct List (Printable)
 {
 	usz size;
@@ -17,7 +19,6 @@ struct List (Printable)
 	Type *entries;
 }
 
-
 /**
  * @param initial_capacity "The initial capacity to reserve"
  * @param [&inout] allocator "The allocator to use, defaults to the heap allocator"
@@ -29,7 +30,11 @@ fn List* List.new_init(&self, usz initial_capacity = 16, Allocator allocator = a
 	if (initial_capacity > 0)
 	{
 		initial_capacity = math::next_power_of_2(initial_capacity);
+		$if type_is_overaligned():
 		self.entries = allocator::malloc_aligned(allocator, Type.sizeof * initial_capacity, .alignment = Type[1].alignof)!!;
+		$else
+		self.entries = allocator::malloc(allocator, Type.sizeof * initial_capacity);
+		$endif
 	}
 	else
 	{
@@ -93,7 +98,7 @@ fn String List.to_tstring(&self)
 fn void List.push(&self, Type element) @inline
 {
 	self.ensure_capacity();
-    self.entries[self.size++] = element;
+	self.entries[self.size++] = element;
 }
 
 fn Type! List.pop(&self)
@@ -137,7 +142,21 @@ fn void List.add_all(&self, List* other_list)
 }
 
 
-fn Type[] List.to_new_array(&self, Allocator allocator = allocator::heap())
+/**
+ * IMPORTANT The returned array must be freed using free_aligned.
+ **/
+fn Type[] List.to_new_aligned_array(&self, Allocator allocator = allocator::heap())
+{
+	if (!self.size) return Type[] {};
+	Type[] result = allocator::alloc_array_aligned(allocator, Type, self.size);
+	result[..] = self.entries[:self.size];
+	return result;
+}
+
+/**
+ * @require !type_is_overaligned() : "This function is not available on overaligned types"
+ **/
+macro Type[] List.to_new_array(&self, Allocator allocator = allocator::heap())
 {
 	if (!self.size) return Type[] {};
 	Type[] result = allocator::alloc_array(allocator, Type, self.size);
@@ -147,7 +166,11 @@ fn Type[] List.to_new_array(&self, Allocator allocator = allocator::heap())
 
 fn Type[] List.to_tarray(&self)
 {
+	$if type_is_overaligned():
+	return self.to_new_aligned_array(allocator::temp());
+	$else
 	return self.to_new_array(allocator::temp());
+	$endif;
 }
 
 /**
@@ -253,7 +276,11 @@ fn Type List.get(&self, usz index) @inline
 fn void List.free(&self)
 {
 	if (!self.allocator) return;
+	$if type_is_overaligned():
 	allocator::free_aligned(self.allocator, self.entries);
+	$else
+	allocator::free(self.allocator, self.entries);
+	$endif;
 	self.capacity = 0;
 	self.size = 0;
 	self.entries = null;
@@ -351,7 +378,11 @@ fn void List.reserve(&self, usz min_capacity)
 	if (self.capacity >= min_capacity) return;
 	if (!self.allocator) self.allocator = allocator::heap();
 	min_capacity = math::next_power_of_2(min_capacity);
-	self.entries = allocator::realloc_aligned(self.allocator, self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof) ?? null;
+	$if type_is_overaligned():
+	self.entries = allocator::realloc_aligned(self.allocator, self.entries, Type.sizeof * min_capacity, .alignment = Type[1].alignof)!!;
+	$else
+	self.entries = allocator::realloc(self.allocator, self.entries, Type.sizeof * min_capacity);
+	$endif;
 	self.capacity = min_capacity;
 }
 

lib/std/core/mem.c3

@@ -577,6 +577,15 @@ fn void* malloc(usz size) @builtin @inline @nodiscard
 	return allocator::malloc(allocator::heap(), size);
 }
 
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
+fn void* malloc_aligned(usz size, usz alignment) @builtin @inline @nodiscard
+{
+	return allocator::malloc_aligned(allocator::heap(), size, alignment)!!;
+}
+
 fn void* tmalloc(usz size, usz alignment = 0) @builtin @inline @nodiscard
 {
 	if (!size) return null;
@@ -685,7 +694,7 @@ macro alloc_array($Type, usz elements) @nodiscard
  **/
 macro alloc_array_aligned($Type, usz elements) @nodiscard
 {
-	return allocator::alloc_array(allocator::heap(), $Type, elements);
+	return allocator::alloc_array_aligned(allocator::heap(), $Type, elements);
 }
 
 macro temp_alloc_array($Type, usz elements) @nodiscard
@@ -703,6 +712,10 @@ fn void* calloc(usz size) @builtin @inline @nodiscard
 	return allocator::calloc(allocator::heap(), size);
 }
 
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
 fn void* calloc_aligned(usz size, usz alignment) @builtin @inline @nodiscard
 {
 	return allocator::calloc_aligned(allocator::heap(), size, alignment)!!;

lib/std/core/mem_allocator.c3

@@ -49,7 +49,7 @@ fault AllocationFailure
 
 fn usz alignment_for_allocation(usz alignment) @inline @private
 {
-	return alignment < mem::DEFAULT_MEM_ALIGNMENT ? alignment = mem::DEFAULT_MEM_ALIGNMENT : alignment;
+	return alignment < mem::DEFAULT_MEM_ALIGNMENT ? mem::DEFAULT_MEM_ALIGNMENT : alignment;
 }
 
 macro void* malloc(Allocator allocator, usz size) @nodiscard
@@ -147,6 +147,7 @@ macro void free_aligned(Allocator allocator, void* ptr)
 }
 
 /**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_aligned' instead"
  * @require $vacount < 2 : "Too many arguments."
  * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
  **/
@@ -162,6 +163,7 @@ macro new(Allocator allocator, $Type, ...) @nodiscard
 }
 
 /**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_aligned' instead"
  * @require $vacount < 2 : "Too many arguments."
  * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
  **/
@@ -176,51 +178,109 @@ macro new_try(Allocator allocator, $Type, ...) @nodiscard
 	$endif
 }
 
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ * @require $vacount < 2 : "Too many arguments."
+ * @require $or($vacount == 0, $assignable($vaexpr(0), $Type)) : "The second argument must be an initializer for the type"
+ **/
+macro new_aligned($Type, ...) @nodiscard
+{
+	$if $vacount == 0:
+		return ($Type*)calloc_aligned(allocator, $Type.sizeof, $Type.alignof);
+	$else
+		$Type* val = malloc_aligned(allocator, $Type.sizeof, $Type.alignof);
+		*val = $vaexpr(0);
+		return val;
+	$endif
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT
+ **/
 macro new_with_padding(Allocator allocator, $Type, usz padding) @nodiscard
 {
 	return ($Type*)calloc_try(allocator, $Type.sizeof + padding);
 }
 
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
+ **/
 macro alloc(Allocator allocator, $Type) @nodiscard
 {
 	return ($Type*)malloc(allocator, $Type.sizeof);
 }
 
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_aligned' instead"
+ **/
 macro alloc_try(Allocator allocator, $Type) @nodiscard
 {
 	return ($Type*)malloc_try(allocator, $Type.sizeof);
 }
 
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
+macro alloc_aligned(Allocator allocator, $Type) @nodiscard
+{
+	return ($Type*)malloc_aligned(allocator, $Type.sizeof, $Type.alignof);
+}
+
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT
+ **/
 macro alloc_with_padding(Allocator allocator, $Type, usz padding) @nodiscard
 {
 	return ($Type*)malloc_try(allocator, $Type.sizeof + padding);
 }
 
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_array_aligned' instead"
+ **/
 macro new_array(Allocator allocator, $Type, usz elements) @nodiscard
 {
 	return new_array_try(allocator, $Type, elements)!!;
 }
 
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'new_array_aligned' instead"
+ **/
 macro new_array_try(Allocator allocator, $Type, usz elements) @nodiscard
 {
 	return (($Type*)calloc_try(allocator, $Type.sizeof * elements))[:elements];
 }
 
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
 macro new_array_aligned(Allocator allocator, $Type, usz elements) @nodiscard
 {
 	return (($Type*)calloc_aligned(allocator, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
 }
 
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+ **/
 macro alloc_array(Allocator allocator, $Type, usz elements) @nodiscard
 {
 	return alloc_array_try(allocator, $Type, elements)!!;
 }
 
+/**
+ * Allocate using an aligned allocation. This is necessary for types with a default memory alignment
+ * exceeding DEFAULT_MEM_ALIGNMENT. IMPORTANT! It must be freed using free_aligned.
+ **/
 macro alloc_array_aligned(Allocator allocator, $Type, usz elements) @nodiscard
 {
 	return (($Type*)malloc_aligned(allocator, $Type.sizeof * elements, $Type.alignof))[:elements]!!;
 }
 
+/**
+ * @require $Type.alignof <= mem::DEFAULT_MEM_ALIGNMENT : "Types with alignment exceeding the default must use 'alloc_array_aligned' instead"
+ **/
 macro alloc_array_try(Allocator allocator, $Type, usz elements) @nodiscard
 {
 	return (($Type*)malloc_try(allocator, $Type.sizeof * elements))[:elements];
@@ -344,4 +404,4 @@ fn TempAllocator* temp_allocator_next() @private
 	}
 	usz index = thread_temp_allocator == temp_allocator_pair[0] ? 1 : 0;
 	return thread_temp_allocator = temp_allocator_pair[index];
-}
+}