rtl::constructor- wip.

Author: neeraj31285

ReflectionTemplateLib/rtl/CMakeLists.txt

@@ -11,6 +11,8 @@ set(LOCAL_HEADERS
     "${CMAKE_CURRENT_SOURCE_DIR}/rtl_constants.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/rtl_forward_decls.h"
 
+	"${CMAKE_CURRENT_SOURCE_DIR}/rtl_constructor.h"
+	
 	"${CMAKE_CURRENT_SOURCE_DIR}/rtl_function.h"
 	"${CMAKE_CURRENT_SOURCE_DIR}/rtl_function_erased_return.h"
 	"${CMAKE_CURRENT_SOURCE_DIR}/rtl_function_erased_return.hpp"

ReflectionTemplateLib/rtl/dispatch/function_lambda.h

@@ -18,7 +18,6 @@ namespace rtl::dispatch
     template<class...args_t>
     struct function_lambda<fn_void::no, erase::t_ctor, args_t...> : lambda
     {
-        // ditch all std::functions and use fn-pointer directly - what??? Yes!
         using fptr_t = Return(*)(alloc, traits::normal_sign_t<args_t>&&...);
 
         const fptr_t& f_ptr() const {

ReflectionTemplateLib/rtl/rtl_constructor.h

@@ -0,0 +1,51 @@
+/*************************************************************************
+ *                                                                       *
+ *  Reflection Template Library (RTL) - Modern C++ Reflection Framework  *
+ *  https://github.com/ReflectCxx/ReflectionTemplateLibrary-CPP          *
+ *                                                                       *
+ *  Copyright (c) 2025 Neeraj Singh <reflectcxx@outlook.com>             *
+ *  SPDX-License-Identifier: MIT                                         *
+ *                                                                       *
+ *************************************************************************/
+
+
+#pragma once
+
+#include "functor.h"
+#include "RObject.hpp"
+
+namespace rtl
+{
+    template<class ...signature_t>
+    class constructor
+    {
+        using lambda_t = std::function<Return(alloc, signature_t...)>;
+
+        error m_init_err = error::InvalidCaller;
+
+        std::vector<lambda_t> m_hop = {};
+
+        std::vector<const dispatch::functor*> m_functors = {};
+
+        void set_init_error(error p_err);
+
+        GETTER_REF(std::vector<lambda_t>, _hop, m_hop)
+        GETTER_REF(std::vector<const dispatch::functor*>, _overloads, m_functors)
+
+    public:
+
+        enum call_by {
+            value = 0,
+            cref = 1,   //const ref.
+            ncref = 2   //non-const ref.
+        };
+
+        GETTER(rtl::error, _init_error, m_init_err)
+
+        constexpr operator bool() const noexcept;
+
+        template<class ...args_t>
+            requires (sizeof...(args_t) == sizeof...(signature_t))
+        constexpr Return operator()(args_t&&...params) const noexcept;
+    };
+}

ReflectionTemplateLib/rtl/rtl_forward_decls.h

@@ -30,6 +30,9 @@ namespace rtl
     template<class return_t, class ...signature_t>
     class function;
 
+    template<class ...signature_t>
+    class constructor;
+
     template<class return_t, class ...signature_t>
     struct static_method;
 

ReflectionTemplateLib/rtl/rtl_function_erased_return.h

@@ -23,14 +23,14 @@ namespace rtl
 
         using lambda_rt = std::function<std::any(const dispatch::functor&, signature_t...)>;
 
+        error m_init_err = error::InvalidCaller;
+
         std::vector<lambda_rt> m_rhop = {};
 
         std::vector<lambda_vt> m_vhop = {};
 
         std::vector<const dispatch::functor*> m_functors = {};
 
-        error m_init_err = error::InvalidCaller;
-
         void set_init_error(error p_err);
 
         GETTER_REF(std::vector<lambda_rt>, _rhop, m_rhop)

text-benchmark-logs/flat-overhead-analysis.md

@@ -0,0 +1,75 @@
+# RTL Reflection Call Overhead Analysis
+
+## Overview
+
+This document summarizes the flat overhead cost associated with using RTL's reflective call paths across all benchmarked call types. It categorizes overhead into **non-erased** and **erased** call paths and establishes upper and lower bounds observed across the entire test suite.
+
+---
+
+## Non-Erased RTL Calls (Fast Path)
+
+### Summary
+
+Non-erased calls (`rtl::function` / `rtl::method`) exhibit near-zero overhead in all realistic workloads and only minimal overhead in microbenchmarks.
+
+### Overhead Range
+
+* **Best case (real workloads):** Effectively *0 ns* overhead. Measurements match direct calls within noise.
+* **Worst case (scale = 0):**
+
+  * set: ~+0.4 ns overhead
+  * get: ~+1.1 ns overhead
+  * Relative cost: ~1.6×–1.8× direct call cost in pure overhead tests.
+
+### Practical Interpretation
+
+Non-erased RTL calls are effectively *free* for practical purposes and safe even for ultra-hot loops.
+
+---
+
+## Erased RTL Calls (Most Expensive Path)
+
+### Absolute Worst Case (All Benchmarks)
+
+The highest overhead observed occurs in fully erased `get` calls on trivial functions.
+
+* **Fully Erased get:** ~+15–16 ns overhead
+* **Relative:** ~12×–13× slower than direct
+* **Condition:** Function body is trivial (scale = 0)
+
+This is the *maximum possible overhead* identified.
+
+### Typical Hotpath Overhead (Real Workload)
+
+When the function performs meaningful computation (scale ≥ 5):
+
+* **set:** +3–6% overhead
+* **get:** +5–10% overhead
+* **Erased target only:** +1–3% overhead, often nearly at parity with direct
+
+### Practical Interpretation
+
+Erased calls introduce a measurable cost in pure overhead scenarios, but once real work exists, the relative overhead becomes small and predictable.
+
+---
+
+## Flat Overhead Price Card
+
+### Non-Erased RTL
+
+* **Realistic Overhead:** 0–1 ns
+* **Pathological Worst Case:** ~1.2 ns
+* **Use Case:** Safe for ultra-hot loops; equivalent to direct calls and often faster than `std::function`.
+
+### Erased RTL
+
+* **Maximum Overhead Across All Tests:** ~16 ns
+* **Realistic Overhead:** +3–10% per call
+* **Target-Only Erasure:** +1–3%
+* **Use Case:** Suitable for high-performance code unless the function body is trivial.
+
+---
+
+## One-Line Summary
+
+Across all callables, RTL's overhead ranges from **effectively zero** (non-erased) to a **maximum of ~16 ns** (fully erased trivial calls), with real-world workloads sitting comfortably at **+3–10%** overhead for erased calls.