Merge pull request #75 from ikbuibui/invoke_result

Small Fixes

redGrapes/memory/allocator.hpp

@@ -34,6 +34,7 @@ namespace redGrapes
 
             Block allocate(size_t n_bytes)
             {
+                SPDLOG_TRACE("Allocate {} bytes on worker alloc [{}] ", n_bytes, worker_id);
                 return TaskFreeCtx::worker_alloc_pool.get_alloc(worker_id).allocate(n_bytes);
             }
 

redGrapes/memory/chunked_bump_alloc.hpp

@@ -18,7 +18,7 @@
 #include <cstddef>
 
 #if REDGRAPES_ENABLE_BACKWARDCPP
-#    include <backward.hpp"
+#    include <backward.hpp>
 #endif
 
 namespace redGrapes

redGrapes/resource/resource_user.tpp

@@ -22,25 +22,25 @@ namespace redGrapes
 
     template<typename TTask>
     ResourceUser<TTask>::ResourceUser()
-        : scope_level(TaskCtx<TTask>::scope_depth())
-        , access_list(memory::Allocator())
+        : access_list(memory::Allocator())
         , unique_resources(memory::Allocator())
+        , scope_level(TaskCtx<TTask>::scope_depth())
     {
     }
 
     template<typename TTask>
     ResourceUser<TTask>::ResourceUser(ResourceUser<TTask> const& other)
-        : scope_level(other.scope_level)
-        , access_list(memory::Allocator(), other.access_list)
+        : access_list(memory::Allocator(), other.access_list)
         , unique_resources(memory::Allocator(), other.unique_resources)
+        , scope_level(other.scope_level)
     {
     }
 
     template<typename TTask>
     ResourceUser<TTask>::ResourceUser(std::initializer_list<ResourceAccess<TTask>> list)
-        : scope_level(TaskCtx<TTask>::scope_depth())
-        , access_list(memory::Allocator())
+        : access_list(memory::Allocator())
         , unique_resources(memory::Allocator())
+        , scope_level(TaskCtx<TTask>::scope_depth())
     {
         for(auto& ra : list)
             add_resource_access(ra);

redGrapes/scheduler/event.tpp

@@ -20,17 +20,17 @@ namespace redGrapes
     namespace scheduler
     {
         template<typename TTask>
-        Event<TTask>::Event() : state(1)
+        Event<TTask>::Event() : followers(memory::Allocator())
                               , waker_id(-1)
-                              , followers(memory::Allocator())
+                              , state(1)
         {
         }
 
         template<typename TTask>
         Event<TTask>::Event(Event& other)
-            : state((uint16_t) other.state)
+            : followers(memory::Allocator())
             , waker_id(other.waker_id)
-            , followers(memory::Allocator())
+            , state((uint16_t) other.state)
         {
         }
 

redGrapes/task/future.hpp

@@ -23,11 +23,11 @@ namespace redGrapes
     template<typename T, typename TTask>
     struct Future
     {
-        Future(TTask& task) : task(task), taken(false)
+        Future(TTask& task) : taken(false), task(task)
         {
         }
 
-        Future(Future&& other) : task(other.task), taken(other.taken)
+        Future(Future&& other) : taken(other.taken), task(other.task)
         {
             SPDLOG_TRACE("MOVE future");
             other.taken = true;

redGrapes/task/task.hpp

@@ -19,11 +19,8 @@ namespace redGrapes
 {
 
     template<typename T>
-    concept C_TaskProperty = requires(T taskProp, typename T::Patch patch)
-    {
-        {
-            taskProp.apply_patch(patch)
-        } -> std::same_as<void>;
+    concept C_TaskProperty = requires(T taskProp, typename T::Patch patch) {
+        { taskProp.apply_patch(patch) } -> std::same_as<void>;
     };
 
     template<C_TaskProperty... UserTaskProperties>
@@ -115,10 +112,10 @@ namespace redGrapes
     };
 
     template<typename F, typename TTask>
-    struct FunTask : ResultTask<typename std::result_of<F()>::type, TTask>
+    struct FunTask : ResultTask<typename std::invoke_result_t<F>, TTask>
     {
         FunTask(scheduler::IScheduler<TTask>& scheduler)
-            : ResultTask<typename std::result_of<F()>::type, TTask>(scheduler)
+            : ResultTask<typename std::invoke_result_t<F>, TTask>(scheduler)
         {
         }
 
@@ -128,7 +125,7 @@ namespace redGrapes
         {
         }
 
-        typename std::result_of<F()>::type run_result()
+        typename std::invoke_result_t<F> run_result()
         {
             return (*this->impl)();
         }

redGrapes/task/task_builder.hpp

@@ -44,8 +44,8 @@ namespace redGrapes
     template<typename TTask, typename Callable, typename... Args>
     struct TaskBuilder : TTask::TaskProperties::template Builder<TaskBuilder<TTask, Callable, Args...>>
     {
-        using Impl = typename std::result_of<BindArgs<Callable, Args...>(Callable, Args...)>::type;
-        using Result = typename std::result_of<Callable(Args...)>::type;
+        using Impl = typename std::invoke_result_t<BindArgs<Callable, Args...>, Callable, Args...>;
+        using Result = typename std::invoke_result_t<Callable, Args...>;
 
         std::shared_ptr<TaskSpace<TTask>> space;
         FunTask<Impl, TTask>* task;

redGrapes/util/chunked_list.hpp

@@ -137,9 +137,9 @@ namespace redGrapes
 
             Item()
                 // any item starts uninitialized
-                : iter_offset(1)
+                : storage(TrivialInit_t{})
+                , iter_offset(1)
                 , refcount(0)
-                , storage(TrivialInit_t{})
             {
             }