optimize align calculateion

Author: kelbon

include/kelcoro/common.hpp

@@ -39,8 +39,8 @@ struct retblock_storage {
 
 namespace dd {
 
-constexpr std::size_t hardware_constructive_interference_size = 64;
-constexpr std::size_t hardware_destructive_interference_size = 64;
+constexpr size_t hardware_constructive_interference_size = 64;
+constexpr size_t hardware_destructive_interference_size = 64;
 
 struct not_movable {
   constexpr not_movable() noexcept = default;

include/kelcoro/memory_support.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <atomic>
+#include <bit>
 #include <memory_resource>
 #include <cassert>
 #include <utility>
@@ -63,7 +64,7 @@ struct chunk_from {
     return std::assume_aligned<dd::coroframe_align()>(resource().allocate(sz));
   }
 
-  void deallocate(void* p, std::size_t sz) noexcept {
+  void deallocate(void* p, size_t sz) noexcept {
     resource().deallocate(p, sz);
   }
 };
@@ -74,7 +75,7 @@ struct new_delete_resource {
     // not malloc because of memory alignment requirement
     return new char[sz];
   }
-  static void deallocate(void* p, std::size_t) noexcept {
+  static void deallocate(void* p, size_t) noexcept {
     delete[] static_cast<char*>(p);
   }
 };
@@ -120,7 +121,7 @@ struct polymorphic_resource {
   void* allocate(size_t sz) {
     return passed->allocate(sz, coroframe_align());
   }
-  void deallocate(void* p, std::size_t sz) noexcept {
+  void deallocate(void* p, size_t sz) noexcept {
     passed->deallocate(p, sz, coroframe_align());
   }
 };
@@ -176,6 +177,19 @@ constexpr size_t padding_len(size_t sz) noexcept {
   return (P - sz % P) % P;
 }
 
+template <size_t ALIGN>
+constexpr size_t aligned(size_t size) {
+  if constexpr (ALIGN < 2)
+    return size;
+  // is power of 2
+  if constexpr (std::has_single_bit(ALIGN) == 1) {
+    constexpr size_t mask = ALIGN - 1;
+    return (size + mask) & ~mask;
+  } else {
+    return size + (ALIGN - size % ALIGN) % ALIGN;
+  }
+}
+
 }  // namespace noexport
 
 // inheritor(coroutine promise) may be allocated with 'R'
@@ -187,7 +201,7 @@ struct overload_new_delete {
     if constexpr (std::is_empty_v<R>)
       return (void*)r.allocate(frame_sz);
     else {
-      frame_sz += noexport::padding_len<alignof(R)>(frame_sz);
+      frame_sz = noexport::aligned<alignof(R)>(frame_sz);
       std::byte* p = (std::byte*)r.allocate(frame_sz + sizeof(R));
       new (p + frame_sz) R(std::move(r));
       return p;
@@ -204,20 +218,20 @@ struct overload_new_delete {
 
   template <typename... Args>
     requires(last_is_memory_resource_tag<Args...> && std::is_same_v<R, resource_type_t<Args...>>)
-  static void* operator new(std::size_t frame_sz, Args&&... args) {
+  static void* operator new(size_t frame_sz, Args&&... args) {
     static_assert(std::is_same_v<std::remove_cvref_t<noexport::last_type_t<Args...>>, with_resource<R>>);
     // old-style
     // return do_allocate(frame_sz, (args...[sizeof...(Args) - 1]).resource);
     auto voidify = [](auto& x) { return const_cast<void*>((const void volatile*)std::addressof(x)); };
     void* p = (voidify(args), ...);
     return do_allocate(frame_sz, static_cast<with_resource<R>*>(p)->resource);
   }
-  static void operator delete(void* ptr, std::size_t frame_sz) noexcept {
+  static void operator delete(void* ptr, size_t frame_sz) noexcept {
     if constexpr (std::is_empty_v<R>) {
       R r{};
       r.deallocate(ptr, frame_sz);
     } else {
-      frame_sz += noexport::padding_len<alignof(R)>(frame_sz);
+      frame_sz = noexport::aligned<alignof(R)>(frame_sz);
       R* onframe_resource = (R*)((std::byte*)ptr + frame_sz);
       assert((((uintptr_t)onframe_resource % alignof(R)) == 0));
       if constexpr (std::is_trivially_destructible_v<R>) {

include/kelcoro/stack_memory_resource.hpp

@@ -45,7 +45,6 @@ struct stack_resource {
     }
 
     chunk_header* take_atleast(size_t bytes) noexcept {
-      size_t sz_before = count();
       chunk_header* prev = nullptr;
       chunk_header* c = top;
       while (c) {
@@ -55,8 +54,7 @@ struct stack_resource {
             prev->freelist_next = c->freelist_next;
           else
             top = c->freelist_next;
-          c->freelist_next = nullptr;
-          assert(count() == sz_before - 1);
+          // not needed rly c->freelist_next = nullptr;
           return c;
         }
         prev = c;
@@ -107,7 +105,7 @@ struct stack_resource {
     freelist.push(chunk);
   }
 
-  std::size_t aligned(std::size_t bytes) {
+  size_t aligned(size_t bytes) {
     return bytes + noexport::padding_len<dd::coroframe_align()>(bytes);
   }
 
@@ -168,14 +166,14 @@ struct stack_resource {
     return b;
   }
 
-  void deallocate(void* ptr, size_t len) noexcept {
+  void deallocate(const void* ptr, size_t len) noexcept {
     assert(((uintptr_t)ptr % 16) == 0 && "dealloc not allocated memory");
     len = aligned(len);
     // not in current chunk, must be in some of prev
     // in most cases its literaly previous chunk, but its possible
     // if all memory from chunk deallocated, then allocated > chunk size
     // so prev chunk will be empty
-    while ((byte_t*)ptr != m - len) {
+    while ((const byte_t*)ptr != m - len) {
       assert(ptr <= b || ptr >= e);
       drop_cur_chunk();
     }

tests/test_coroutines.cpp

@@ -50,6 +50,7 @@ inline dd::generator<int> foo() {
 struct r2 : dd::pmr::polymorphic_resource {};
 
 TEST(allocations) {
+  using dd::noexport::aligned;
   using dd::noexport::padding_len;
   static_assert(padding_len<16>(16) == 0);
   static_assert(padding_len<16>(0) == 0);
@@ -60,6 +61,15 @@ TEST(allocations) {
   static_assert(padding_len<4>(1) == 3);
   static_assert(padding_len<4>(4) == 0);
 
+  static_assert(aligned<16>(16) == 16);
+  static_assert(aligned<16>(0) == 0);
+  static_assert(aligned<16>(1) == 16);
+  static_assert(aligned<16>(8) == 16);
+  static_assert(aligned<4>(3) == 4);
+  static_assert(aligned<4>(2) == 4);
+  static_assert(aligned<4>(1) == 4);
+  static_assert(aligned<4>(4) == 4);
+
   #define EXPECT_PROMISE(promise, ... /* coro arg args*/) \
     static_assert(std::is_same_v<std::coroutine_traits<__VA_ARGS__>::promise_type, promise>);
   using namespace dd;
@@ -1093,7 +1103,9 @@ TEST(expected_e) {
       }                                              \
     }
 
-  #define CHECK_ALIGN(sz, pad, expected) static_assert(::dd::noexport::padding_len<pad>(sz) == expected);
+  #define CHECK_ALIGN(sz, align, expected_padding)                             \
+    static_assert(::dd::noexport::padding_len<align>(sz) == expected_padding); \
+    static_assert(::dd::noexport::aligned<align>(sz) == (sz + expected_padding));
 
 CHECK_ALIGN(0, 8, 0);
 CHECK_ALIGN(16, 16, 0);