summaryrefslogtreecommitdiff
path: root/asl/memory
diff options
context:
space:
mode:
Diffstat (limited to 'asl/memory')
-rw-r--r--asl/memory/BUILD.bazel16
-rw-r--r--asl/memory/allocator.cpp54
-rw-r--r--asl/memory/allocator.hpp58
-rw-r--r--asl/memory/layout.hpp37
-rw-r--r--asl/memory/memory.hpp137
5 files changed, 302 insertions, 0 deletions
diff --git a/asl/memory/BUILD.bazel b/asl/memory/BUILD.bazel
new file mode 100644
index 0000000..0a198bc
--- /dev/null
+++ b/asl/memory/BUILD.bazel
@@ -0,0 +1,16 @@
+cc_library(
+ name = "memory",
+ hdrs = [
+ "allocator.hpp",
+ "layout.hpp",
+ "memory.hpp",
+ ],
+ srcs = [
+ "allocator.cpp",
+ ],
+ deps = [
+ "//asl/base",
+ ],
+ visibility = ["//visibility:public"],
+)
+
diff --git a/asl/memory/allocator.cpp b/asl/memory/allocator.cpp
new file mode 100644
index 0000000..504202d
--- /dev/null
+++ b/asl/memory/allocator.cpp
@@ -0,0 +1,54 @@
+#include "asl/memory/allocator.hpp"
+#include "asl/base/assert.hpp"
+#include "asl/memory/layout.hpp"
+
+#include <cstdlib>
+
+// @Todo zalloc
+// @Todo Cookies
+// @Todo Debug values
+
+void* asl::GlobalHeap::alloc(const layout& layout)
+{
+#if ASL_OS_WINDOWS
+ void* ptr = ::_aligned_malloc(
+ static_cast<size_t>(layout.size),
+ static_cast<size_t>(layout.align));
+#elif ASL_OS_LINUX
+ void* ptr = ::aligned_alloc(
+ static_cast<size_t>(layout.align),
+ static_cast<size_t>(layout.size));
+#endif
+ ASL_ASSERT(ptr != nullptr); // @Todo panic
+ return ptr;
+}
+
+void* asl::GlobalHeap::realloc(void* old_ptr, [[maybe_unused]] const layout& old_layout, const layout& new_layout)
+{
+#if ASL_OS_WINDOWS
+ return ::_aligned_realloc(old_ptr,
+ static_cast<size_t>(new_layout.size),
+ static_cast<size_t>(new_layout.align));
+#elif ASL_OS_LINUX
+ if (new_layout.align <= old_layout.align)
+ {
+ void* new_ptr = ::realloc(old_ptr, static_cast<size_t>(new_layout.size));
+ ASL_ASSERT(new_ptr != nullptr); // @Todo panic
+ return new_ptr;
+ }
+
+ void* new_ptr = alloc(new_layout);
+ asl::memcpy(new_ptr, old_ptr, asl::min(old_layout.size, new_layout.size));
+ dealloc(old_ptr, old_layout);
+ return new_ptr;
+#endif
+}
+
+void asl::GlobalHeap::dealloc(void* ptr, const layout&)
+{
+#if ASL_OS_WINDOWS
+ ::_aligned_free(ptr);
+#elif ASL_OS_LINUX
+ ::free(ptr);
+#endif
+}
diff --git a/asl/memory/allocator.hpp b/asl/memory/allocator.hpp
new file mode 100644
index 0000000..d39fa23
--- /dev/null
+++ b/asl/memory/allocator.hpp
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "asl/base/meta.hpp"
+#include "asl/memory/layout.hpp"
+#include "asl/memory/memory.hpp"
+
+namespace asl
+{
+
+template<typename T>
+concept allocator = moveable<T> && equality_comparable<T> &&
+ requires(T& alloc, layout layout, void* ptr)
+ {
+ { alloc.alloc(layout) } -> same_as<void*>;
+ { alloc.realloc(ptr, layout, layout) } -> same_as<void*>;
+ alloc.dealloc(ptr, layout);
+ };
+
+class GlobalHeap
+{
+public:
+ static void* alloc(const layout&);
+ static void* realloc(void* ptr, const layout& old, const layout& new_layout);
+ static void dealloc(void* ptr, const layout&);
+
+ constexpr bool operator==(const GlobalHeap&) const { return true; }
+};
+static_assert(allocator<GlobalHeap>);
+
+using DefaultAllocator = GlobalHeap;
+
+template<typename T>
+T* alloc_new(allocator auto& a, auto&&... args)
+{
+ void* ptr = a.alloc(layout::of<T>());
+ return construct_at<T>(ptr, ASL_FWD(args)...);
+}
+
+template<typename T>
+void alloc_delete(allocator auto& a, T* ptr)
+{
+ destroy(ptr);
+ a.dealloc(ptr, layout::of<T>());
+}
+
+template<typename T>
+constexpr T* alloc_new_default(auto&&... args)
+{
+ return alloc_new<T>(DefaultAllocator{}, ASL_FWD(args)...);
+}
+
+template<typename T>
+void alloc_delete_default(T* ptr)
+{
+ alloc_delete(DefaultAllocator{}, ptr);
+}
+
+} // namespace asl
diff --git a/asl/memory/layout.hpp b/asl/memory/layout.hpp
new file mode 100644
index 0000000..af867d8
--- /dev/null
+++ b/asl/memory/layout.hpp
@@ -0,0 +1,37 @@
+#pragma once
+
+#include "asl/base/integers.hpp"
+#include "asl/base/meta.hpp"
+
+namespace asl
+{
+
+template<typename T>
+inline constexpr isize_t size_of = static_cast<isize_t>(sizeof(T));
+
+template<typename T>
+inline constexpr isize_t align_of = static_cast<isize_t>(alignof(T));
+
+struct layout
+{
+ isize_t size;
+ isize_t align;
+
+ constexpr bool operator==(const layout&) const = default;
+
+ template<is_object T>
+ static constexpr layout of()
+ {
+ return layout{ size_of<T>, align_of<T> };
+ }
+
+ template<is_object T>
+ static constexpr layout array(isize_t size)
+ {
+ return layout{ size_of<T> * size, align_of<T> };
+ }
+};
+
+} // namespace asl
+
+#define AslOffsetOf(S, M) (static_cast<isize_t>(__builtin_offsetof(S, M)))
diff --git a/asl/memory/memory.hpp b/asl/memory/memory.hpp
new file mode 100644
index 0000000..de8e07d
--- /dev/null
+++ b/asl/memory/memory.hpp
@@ -0,0 +1,137 @@
+#pragma once
+
+#include "asl/base/integers.hpp"
+#include "asl/base/meta.hpp"
+#include "asl/base/utility.hpp"
+#include "asl/memory/layout.hpp"
+
+constexpr void* operator new(size_t, void* ptr)
+{
+ return ptr;
+}
+
+namespace asl
+{
+
+constexpr isize_t memcmp(const void* a, const void* b, isize_t size)
+{
+ return __builtin_memcmp(a, b, static_cast<size_t>(size));
+}
+
+constexpr void memcpy(void* dst, const void* src, isize_t size)
+{
+ __builtin_memcpy(dst, src, static_cast<size_t>(size));
+}
+
+inline void memzero(void* dst, isize_t size)
+{
+ __builtin_memset(dst, 0, static_cast<size_t>(size));
+}
+
+constexpr isize_t strlen(const char* s)
+{
+ return static_cast<isize_t>(__builtin_strlen(s));
+}
+
+template<typename T, typename... Args>
+constexpr T* construct_at(void* ptr, Args&&... args)
+ requires constructible_from<T, Args&&...>
+{
+ return new (ptr) T{ ASL_FWD(args)... };
+}
+
+template<typename T>
+constexpr void destroy(T* data)
+{
+ if constexpr (!trivially_destructible<T>)
+ {
+ data->~T();
+ }
+}
+
+template<typename T>
+constexpr void destroy_n(T* data, isize_t n)
+{
+ if constexpr (!trivially_destructible<T>)
+ {
+ for (isize_t i = 0; i < n; ++i)
+ {
+ destroy(data + i);
+ }
+ }
+}
+
+template<copy_constructible T>
+constexpr void copy_uninit_n(T* to, const T* from, isize_t n)
+{
+ if constexpr (trivially_copy_constructible<T>)
+ {
+ memcpy(to, from, size_of<T> * n);
+ }
+ else
+ {
+ for (isize_t i = 0; i < n; ++i)
+ {
+ // NOLINTNEXTLINE(*-pointer-arithmetic)
+ construct_at<T>(to + i, from[i]);
+ }
+ }
+}
+
+template<copy_assignable T>
+constexpr void copy_assign_n(T* to, const T* from, isize_t n)
+{
+ if constexpr (trivially_copy_constructible<T>)
+ {
+ memcpy(to, from, size_of<T> * n);
+ }
+ else
+ {
+ for (isize_t i = 0; i < n; ++i)
+ {
+ // NOLINTNEXTLINE(*-pointer-arithmetic)
+ to[i] = from[i];
+ }
+ }
+}
+
+template<move_constructible T>
+constexpr void relocate_uninit_n(T* to, T* from, isize_t n)
+{
+ if constexpr (trivially_move_constructible<T>)
+ {
+ static_assert(trivially_destructible<T>);
+ memcpy(to, from, size_of<T> * n);
+ }
+ else
+ {
+ for (isize_t i = 0; i < n; ++i)
+ {
+ // NOLINTNEXTLINE(*-pointer-arithmetic)
+ construct_at<T>(to + i, ASL_MOVE(from[i]));
+ }
+ destroy_n(from, n);
+ }
+}
+
+template<move_assignable T>
+constexpr void relocate_assign_n(T* to, T* from, isize_t n)
+{
+ if constexpr (trivially_move_assignable<T>)
+ {
+ static_assert(trivially_destructible<T>);
+ memcpy(to, from, size_of<T> * n);
+ }
+ else
+ {
+ for (isize_t i = 0; i < n; ++i)
+ {
+ // NOLINTNEXTLINE(*-pointer-arithmetic)
+ to[i] = ASL_MOVE(from[i]);
+ }
+ destroy_n(from, n);
+ }
+}
+
+} // namespace asl
+
generated by cgit (git 2.34.1) at 2025-06-01 19:43:07 +0000