make uthread internal function override cross platform

async_simple/uthread/internal/thread.cc

@@ -131,16 +131,6 @@ thread_context::thread_context(std::function<void()> func, size_t stack_size)
 
 thread_context::~thread_context() {}
 
-__attribute__((weak))
-void stack_deleter::operator()(char* ptr) const noexcept {
-    delete[] ptr;
-}
-
-__attribute__((weak))
-stack_holder get_stack_holder(unsigned stack_size) {
-    return stack_holder(new char[stack_size]);
-}
-
 stack_holder thread_context::make_stack() {
     return get_stack_holder(stack_size_);
 }

async_simple/uthread/internal/thread.h

@@ -43,6 +43,40 @@ struct stack_deleter {
     void operator()(char* ptr) const noexcept;
 };
 using stack_holder = std::unique_ptr<char[], stack_deleter>;
+using stack_deleter_fn = void (*)(char*) noexcept;
+using stack_allocator_fn = stack_holder (*)(unsigned);
+
+inline void default_stack_deleter(char* ptr) noexcept { delete[] ptr; }
+
+inline stack_holder default_get_stack_holder(unsigned stack_size) {
+    return stack_holder(new char[stack_size]);
+}
+
+inline stack_deleter_fn& get_stack_deleter() noexcept {
+    static stack_deleter_fn fn = &default_stack_deleter;
+    return fn;
+}
+
+inline stack_allocator_fn& get_stack_allocator() noexcept {
+    static stack_allocator_fn fn = &default_get_stack_holder;
+    return fn;
+}
+
+inline void set_stack_deleter(stack_deleter_fn fn) noexcept {
+    get_stack_deleter() = fn ? fn : &default_stack_deleter;
+}
+
+inline void set_stack_allocator(stack_allocator_fn fn) noexcept {
+    get_stack_allocator() = fn ? fn : &default_get_stack_holder;
+}
+
+inline void stack_deleter::operator()(char* ptr) const noexcept {
+    get_stack_deleter()(ptr);
+}
+
+inline stack_holder get_stack_holder(unsigned stack_size) {
+    return get_stack_allocator()(stack_size);
+}
 
 class thread_context {
     const size_t stack_size_;

async_simple/uthread/test/UthreadAllocTest.cpp

@@ -9,34 +9,35 @@
 #include "async_simple/uthread/Uthread.h"
 
 using namespace std;
+using namespace async_simple::uthread::internal;
 
 static std::atomic<unsigned> get_stack_holder_count = 0;
 static std::atomic<unsigned> delete_stack_holder_count = 0;
 
-namespace async_simple {
-namespace uthread {
-namespace internal {
-
-stack_holder get_stack_holder(unsigned stack_size) {
-    get_stack_holder_count++;
-    return stack_holder(new char[stack_size]);
-}
-
-void stack_deleter::operator()(char* ptr) const noexcept {
-    delete_stack_holder_count++;
-    delete[] ptr;
-}
-}
-}
-}
-
 namespace async_simple {
 namespace uthread {
 class UthreadAllocSwapTest : public FUTURE_TESTBASE {
 public:
     UthreadAllocSwapTest() : _executor(4) {}
-    void caseSetUp() override {}
-    void caseTearDown() override {}
+
+    void caseSetUp() override {
+        get_stack_holder_count = 0;
+        delete_stack_holder_count = 0;
+
+        set_stack_allocator([](unsigned stack_size) -> stack_holder {
+            get_stack_holder_count++;
+            return stack_holder(new char[stack_size]);
+        });
+        set_stack_deleter([](char* ptr) noexcept {
+            delete_stack_holder_count++;
+            delete[] ptr;
+        });
+    }
+
+    void caseTearDown() override {
+        set_stack_allocator(nullptr);
+        set_stack_deleter(nullptr);
+    }
 
     template <class Func>
     void delayedTask(Func&& func, std::size_t ms) {