diff --git a/README.md b/README.md index 3b19850a..f03bbf21 100644 --- a/README.md +++ b/README.md @@ -14,11 +14,11 @@ RTL provides type-safe run-time reflection for C++, combining compile-time guarantees with run-time flexibility. -It enables name-based discovery and invocation of functions, constructors, and object members through a non-intrusive, type-safe reflection system that follows modern C++ idioms. For example, consider the following function – +It enables name-based discovery and invocation of functions, constructors, and object members through a non-intrusive, type-safe reflection system that follows modern C++ idioms. For example, consider the following function: ```c++ std::string complexToStr(float real, float img); ``` -Using RTL, you can discover this function by name and invoke it dynamically – +Using RTL, you can discover this function by name and call it dynamically: ```c++ rtl::function cToStr = cxx::mirror().getFunction("complexToStr") ->argsT() @@ -32,7 +32,7 @@ if(cToStr) { // Function materialized? ⚡ **Performance** -RTL’s reflective calls are comparable to `std::function` for fully type-erased dispatch, and achieve lower call overhead *(just a function-pointer hop)* when argument and return types are known. +RTL’s reflective calls are comparable to `std::function`, and achieve lower overhead when argument and return types are fully specified. ## Design Highlights @@ -42,32 +42,25 @@ RTL’s reflective calls are comparable to `std::function` for fully type-erased * ***Zero-Overhead by Design*** – Metadata can be registered and resolved lazily. Reflection introduces no runtime cost beyond the features explicitly exercised by the user. -* ***Cross-Compiler Consistency*** – Implemented entirely in standard C++20, with no compiler extensions or compiler-specific conditional behavior. +* ***Hot-Loop Ready*** – Typed reflection calls exhibit near-zero overhead and scale like direct calls, making RTL suitable for performance-critical and tight-loop workloads. *([Performance Summary](docs/benchmark_summary.md))* -* ***Tooling-Friendly Architecture*** – Reflection data is encapsulated in a single immutable, lazily-initialized structure that can be shared with external tools and frameworks without compile-time type knowledge – suitable for serializers, debuggers, test frameworks, scripting engines, and editors. - - -[![Design Features](https://img.shields.io/badge/Doc-Design%20Features-blue)](./text-design-docs/DESIGN_PRINCIPLES_AND_FEATURES.md) -[![RTL Syntax & Semantics](https://img.shields.io/badge/Doc-Syntax_&_Semantics-blueviolet)](./text-design-docs/RTL_SYNTAX_AND_SEMANTICS.md) +* ***Tooling-Friendly Architecture*** – Reflection metadata is encapsulated in a single immutable, lazily-initialized structure that can be shared with external tools and frameworks without compile-time type knowledge – suitable for serializers, debuggers, test frameworks, scripting engines, and editors. ## A Quick Preview: Reflection That Looks and Feels Like C++ -First, create an instance of `rtl::CxxMirror` – +First, create an instance of `rtl::CxxMirror`: ```c++ auto cxx_mirror = rtl::CxxMirror({ /* ...register all types here... */ }); ``` -The `cxx_mirror` object provides access to the runtime reflection system. It enables querying, introspection, and instantiation of registered types without requiring compile-time type knowledge at the call site. -It can reside in any translation unit. To make it globally accessible and ensure it is initialized only when needed, a singleton access interface can be used – +The `cxx_mirror` object provides access to the runtime reflection system. It references metadata for all registered entities and supports name-based lookup. The object may reside in any translation unit. To make it globally accessible while ensuring lazy initialization, a singleton access interface can be used: ```c++ // MyReflection.h -namespace rtl { class CxxMirror; } // Forward declaration, no includes here! -struct cxx { static rtl::CxxMirror& mirror(); }; // The Singleton. +namespace rtl { class CxxMirror; } // Forward declaration, no includes here. +struct cxx { static rtl::CxxMirror& mirror(); }; // The singleton interface. ``` -define and register everything in an isolated translation unit – +define and register everything in an isolated translation unit: ```c++ // MyReflection.cpp -#include // Reflection builder interface. - rtl::CxxMirror& cxx::mirror() { static auto cxx_mirror = rtl::CxxMirror({ // Inherently thread safe. // Register free(C-Style) function - @@ -82,48 +75,42 @@ rtl::CxxMirror& cxx::mirror() { return cxx_mirror; } ``` -`cxx_mirror` is an immutable, stack-allocated, value-type object and is safe to copy, but when used as a singleton (as shown above), implicit copies (e.g., `auto mirror = cxx::mirror();`) can unintentionally violate the singleton semantics, so `rtl::CxxMirror` restricts such copy construction. - ### RTL in action: -**[Explore the demo code](https://github.com/ReflectCxx/RTL-Demo)** - -Lookup the `Person` class by its registered name – +Lookup the `Person` class by its registered name: ```c++ std::optional classPerson = cxx::mirror().getRecord("Person"); if (!classPerson) { /* Class not registered. */ } ``` -`rtl::CxxMirror` provides two lookup APIs that return reflection metadata objects: `rtl::Record` for any registered type (class, struct or pod) and `rtl::Function` for non-member functions. +`rtl::CxxMirror` returns two reflection metadata objects: `rtl::Record` for any registered type (class, struct, or POD) and `rtl::Function` for non-member functions. -From `rtl::Record`, registered member functions can be queried as `rtl::Method`. These are metadata descriptors (not callables) and are returned as `std::optional`, which will be empty if the requested entity is not found. +From `rtl::Record`, registered member functions can be obtained as `rtl::Method`. These are metadata descriptors (not callables). Callable entities are materialized by explicitly providing the argument types we intend to pass. -Callables are materialized by explicitly providing the argument types we intend to pass. If the signature is valid, the resulting callable can be invoked safely. -For example, the overloaded constructor `Person(std::string, int)` – +For example, the overloaded constructor `Person(std::string, int)`: ```c++ rtl::constructor personCtor = classPerson->ctorT(); -if (!personCtor) { /* Constructor with expected signature not found. */ } ``` -Or the default constructor – +Or the default constructor: ```c++ rtl::constructor<> personCtor = classPerson->ctorT<>(); ``` -Instances can be created on the `Heap` or `Stack` with automatic lifetime management – +Instances can be created on the `Heap` or `Stack` with automatic lifetime management: ```c++ auto [err, robj] = personCtor(rtl::alloc::Stack, "John", 42); if (err != rtl::error::None) { std::cerr << rtl::to_string(err); } // Construction failed. ``` -The constructed object is returned wrapped in `rtl::RObject`. Heap-allocated objects are internally managed via `std::unique_ptr`, while stack-allocated objects are stored directly in `std::any`. +The constructed object is returned as an `rtl::RObject` in the variable `robj`. -Now, Lookup a member-function by name – +Looking up a member function by name: ```c++ std::optional oGetName = classPerson->getMethod("getName"); if (!oGetName) { /* Member function not registered */ } ``` -And materialize a complete type-aware caller – +And materialize a complete type-aware caller: ```c++ -rtl::method getName = oGetName->targetT() - .argsT().returnT(); -if (!getName) { +rtl::method getName = oGetName->targetT().argsT() + .returnT(); +if (!getName) { // Member function with expected signature not found. std::cerr << rtl::to_string(getName.get_init_err()); } else { @@ -131,46 +118,39 @@ else { std::string nameStr = getName(person)(); // Returns string 'Alex'. } ``` -The above `getName` invocation is effectively a native function-pointer hop, since all types are known at compile time. +The above `getName` invocation is effectively a **native function-pointer hop**, since all types are known at compile time. -If the concrete type `Person` is not accessible at the call site, its member functions can still be invoked by erasing the target type and using `rtl::RObject` instead. The previously constructed instance (`robj`) is passed as the target – +If the concrete type `Person` is not accessible at the call site, its member functions can still be invoked by erasing the target type and using `rtl::RObject` instead. The previously constructed instance (`robj`) is passed as the target: ```c++ -rtl::method getName = oGetName->targetT() - .argsT().returnT(); +rtl::method getName = oGetName->targetT().argsT() + .returnT(); auto [err, ret] = getName(robj)(); // Invoke and receive return as std::optional. if (err == rtl::error::None && ret.has_value()) { - std::cout << ret.value(); + std::string nameStr = ret.value(); } ``` -If the return type is also not known at compile time,`rtl::Return` can be used – +If the return type is also not known at compile time,`rtl::Return` can be used: ```c++ -rtl::method getName = oGetName->targetT() - .argsT().returnT(); +rtl::method getName = oGetName->targetT().argsT().returnT(); + auto [err, ret] = getName(robj)(); // Invoke and receive rtl::RObject as return, wrapping std::string underneath. if (err == rtl::error::None && ret.canViewAs()) { - const std::string& name = ret.view()->get(); - std::cout << name; // Safely view the returned std::string. + std::string nameStr = ret.view()->get(); // Safely view the returned std::string. } ``` +**[Explore the demo code here](https://github.com/ReflectCxx/RTL-Demo)** + ### How RTL Fits Together At a high level, every registered C++ type is encapsulated as an `rtl::Record`. Callable entities (functions, member functions and constructors) are materialized through `rtl::Function`, `rtl::Method` and `rtl::Record`, all of which are discoverable via `rtl::CxxMirror`. -RTL provides the following callable entities, designed to be as lightweight and performant as `std::function` (and in many micro-benchmarks, faster when fully type-aware): - -`rtl::function<>` – Free (non-member) functions +👉 Deep Dive -`rtl::constructor<>` – Constructors - -`rtl::method<>` – Non-const member functions - -`rtl::const_method<>` – Const-qualified member functions - -`rtl::static_method<>` – Static member functions - -These callable types are regular value types: they can be copied, moved, stored in standard containers, and passed around like any other lightweight object. - -When invoked, only type-erased callables return an `rtl::error`, with results provided as `rtl::RObject` *(when both the return and target types are erased)* or as `std::optional` *(when only the target type is erased)*, while fully type-aware callables return `T` directly with no error (by design). +[![Design Traits](https://img.shields.io/badge/Doc-Design%20Traits-blue)](./docs/DESIGN_PRINCIPLES_AND_FEATURES.md) +  +[![RTL Syntax & Semantics](https://img.shields.io/badge/Doc-Syntax_&_Semantics-blueviolet)](./docs/RTL_SYNTAX_AND_SEMANTICS.md) +  +[![Benchmark Summary](https://img.shields.io/badge/Doc-Benchmark%20Summary-teal)](./docs/benchmark_summary.md) ### How to Build (Windows / Linux) ```sh @@ -238,4 +218,4 @@ If you’re interested in advancing practical runtime reflection in C++ and supp ## -***C++ joins the reflection party! – why should Java have all the fun?*** \ No newline at end of file +***C++ joins the reflection party! – why should Java have all the fun?*** diff --git a/docs/DESIGN_PRINCIPLES_AND_FEATURES.md b/docs/DESIGN_PRINCIPLES_AND_FEATURES.md new file mode 100644 index 00000000..436eac68 --- /dev/null +++ b/docs/DESIGN_PRINCIPLES_AND_FEATURES.md @@ -0,0 +1,119 @@ +### 🪶 Registration Model and Metadata Lifetime + +RTL does not use macro-based reflection, implicit static initialization at program startup, or centralized global registries. +All registration is performed lazily and explicitly by user code, and registered metadata persists for the lifetime of the process. + +For every registered type, method, or function, RTL creates a **dedicated dispatch object** that encapsulates: + +* The callable function-pointer +* The associated reflection metadata + +These dispatch objects are defined in: + +``` +rtl/dispatch/function_ptr.h +rtl/dispatch/method_ptr.h +``` + +Each dispatch object is: + +* Created **exactly once per unique registration** +* Stored in a process-lifetime (`static std::list`) +* Reused across all `rtl::CxxMirror` instances + +Repeated registration attempts always resolve to the same existing object. This ensures deterministic behavior – +metadata identity is stable regardless of initialization order or how many translation units register the same type. + +`rtl::CxxMirror` does not own or duplicate this metadata. It encapsulates references to it as a lightweight, ordinary object. Mirrors may be created with different type sets, and the same registration statements can be materialized multiple times. + +For example: + +```cpp +rtl::type().member().method("getName").build(&Person::getName); +``` + +will always yield the same metadata and dispatch object for `Person::getName`. +The lifetime of registered metadata is independent of any individual `rtl::CxxMirror` instance and persists for the duration of the program. + +--- + +### ⚡ Reflective Call Materialization and Performance + +RTL employs a two-phase invocation model. Metadata queries return lightweight descriptors such as `rtl::Function` and `rtl::Method`, which must be explicitly **materialized** into callable entity by specifying the expected signature. + +This deferred materialization acts as a compile-time contract: the user declares the argument and return types they intend to use, and RTL validates and prepares an optimized invocation path accordingly. + +Performance depends on how much type information is provided: + +* Fully specified signatures compile to **direct function-pointer calls**, faster than `std::function`. +* Type-erased signatures invoke through a lightweight dispatch layer whose performance **is comparable** to `std::function` under real workloads. + +By requiring explicit materialization, RTL produces lightweight, reusable callable entity that behave like ordinary value-type objects and can be stored in standard containers. + +At call time, RTL performs no dynamic allocations, no RTTI lookups, no `void*` stuff, and no hidden metadata traversals. The runtime cost is explicit, minimal, and comparable to what a developer would implement manually for equivalent type safety and flexibility. + +--- + +### 🛡 Exception-Free Guarantee + +RTL is designed to be exception-free. In practice, any exceptions that occur are almost always introduced by user code and merely propagate through RTL. + +For all predictable failure cases, RTL reports errors through explicit error codes(`rtl::error`) rather than throwing exceptions. Critical assumptions are validated before execution, ensuring that failure conditions are detected early and handled in a controlled manner. + +This design promotes predictable behavior and avoids unexpected control flow during reflective operations. + +> *Exception-handling behavior has not yet been exhaustively stress-tested across all edge cases, but the system is architected to avoid exception-based control flow by design.* + +--- + +### 🎁 Smart Pointer Handling + +RTL supports working with objects managed by `std::unique_ptr` and `std::shared_ptr` in a manner consistent with standard C++ usage. + +Heap-allocated objects created through RTL are internally managed using smart pointers to ensure safe ownership and lifetime control. These details are not imposed on the user: reflected objects can be accessed either through their smart-pointer representation or through views of the underlying type `T`. + +When cloning or transferring reflected objects, RTL preserves the ownership semantics of the original type: + +* Objects intended to be shared can be accessed through shared ownership. +* Uniquely owned objects retain their uniqueness. +* Copyable values can be duplicated to produce independent instances. + +This design allows developers to work with reflected objects using the same ownership and lifetime expectations they would apply in ordinary C++ code, without requiring special handling for reflection-specific wrappers. + +Reflection semantics are aligned with standard C++ object semantics, ensuring consistent behavior regardless of whether an object is accessed directly or through a smart pointer. + +--- + +### 💡 Tooling-Friendly Architecture + +**RTL** separates the *generation* of reflection metadata from its *consumption*. This makes it ideal not just for runtime introspection, but also for external tools like: + +* Code generators +* Serialization pipelines +* Game or UI editors +* Live scripting or plugin systems + +#### ✨ The Mirror & The Reflection + +> *A client system hands off a `rtl::CxxMirror` to RTL — and RTL sees its reflection.* + +The mirror is a **single object**, typically returned from a function like: + +```cpp +extern const rtl::CxxMirror& MyReflection(); +``` + +This function is: + +* **Externally linkable** — can live in any translation unit or even dynamic module +* **Lazy** — doesn’t require metadata unless explicitly accessed +* **Pure** — returns a complete, immutable view of reflection metadata + +#### 📎 Why This Matters for Tooling + +This design turns RTL into a **pluggable, runtime-agnostic consumer** of metadata. You can: + +* Reflect types from external libraries +* Link in auto-generated metadata modules +* Expose your reflection system to scripts or tools without tight coupling +* Swap different `rtl::CxxMirror` sources depending on build mode (dev/editor/runtime) \ No newline at end of file diff --git a/docs/RTL_SYNTAX_AND_SEMANTICS.md b/docs/RTL_SYNTAX_AND_SEMANTICS.md new file mode 100644 index 00000000..3f16e07b --- /dev/null +++ b/docs/RTL_SYNTAX_AND_SEMANTICS.md @@ -0,0 +1,735 @@ +# RTL: Syntax & Semantics 🔍 + +RTL makes C++ reflection feel like a natural extension of the language. Let’s explore its syntax and the semantics it unlocks. + +### 📖 Index + +1. [The `rtl::CxxMirror`](#the-rtlcxxmirror) +2. [Getting Started with Registration](#getting-started-with-registration) +3. [Querying the Metadata](#querying-the-metadata) +4. [The `rtl::RObject`](#the-rtlrobject) +5. [The `rtl::view`](#the-rtlview) +6. [Reflective Invocations with RTL](#reflective-invocations-with-rtl) + - [`rtl::constructor`](#rtlconstructor) + - [`rtl::function` – Type Aware](#rtlfunction--type-aware) + - [`rtl::function` – Type Erased](#rtlfunction--type-erased) + - [`rtl::method` – Type Aware](#rtlmethod--type-aware) + - [`rtl::method` – Type Erased](#rtlmethod--type-erased) +7. [Perfect Forwarding](#perfect-forwarding) +8. [Error Taxonomy](#error-taxonomy) + +--- + +## The `rtl::CxxMirror` + +`rtl::CxxMirror` is the runtime entry point for querying reflection metadata registered with RTL. +It aggregates references to metadata descriptors produced by `rtl::type()...build();` registration expressions and exposes them through a unified lookup interface. + +```cpp +auto cxx_mirror = rtl::CxxMirror({ + // registration expressions +}); +``` + +Each registration expression contributes references to metadata objects that are lazily created on first use. +`rtl::CxxMirror` **does not own** this metadata and never duplicates it; it merely provides structured access to already-registered entities. + +Through the mirror, all registered types, functions, and methods can be queried, inspected, and materialized at runtime. The mirror itself is a lightweight facade and does not introduce centralized global state. + +#### Managing `rtl::CxxMirror` + +* **No hidden global state** – `rtl::CxxMirror` is dispensable by design. You may use a single global mirror, multiple mirrors, or construct mirrors on demand. All mirrors reference the same underlying metadata cache. + +* **Duplicate registration is benign** – Re-registering the same function pointer or type is safe. If matching metadata already exists, RTL reuses it; no duplicate entries are created. + +* **Thread-safe by construction** – Metadata registration and access are internally synchronized. Thread safety is guaranteed regardless of how many mirrors exist or where they are constructed. + +* **Registration cost is one-time** – Each registration performs: + * a synchronized lookup in the metadata cache + * conditional insertion if no match exists + + This cost is incurred only during registration and is negligible for normal initialization paths. Repeated registration in hot paths should be avoided. + +👉 Bottom Line +> *`rtl::CxxMirror` is a lightweight, non-owning access layer over RTL’s metadata. Its lifetime and multiplicity are entirely user-controlled, and its overhead is limited to initialization-time lookups.* + +--- + +## Getting Started with Registration + +Registration in RTL follows a builder-style composition pattern. Individual components are chained together to describe the reflected entity, and `.build()` finalizes the registration. The builder interface is exposed via the `rtl_builder.h` header. + +### Non-Member Functions + +```cpp +rtl::type().ns("ext").function("fn-name").build(fn-ptr); +``` + +* `ns("ext")` – Specifies the namespace under which the function is registered. + Omitting `.ns()` or passing an empty string (`.ns("")`) registers the function under `rtl::global`. This is not a declared C++ namespace; rather, it is a logical, string-based grouping used to prevent naming conflicts. + +* `function("fn-name")` – Declares the function by name. + If multiple overloads exist, the template parameter (`function<...>(..)`) disambiguates the selected overload. + +* `.build(fn-ptr)` – Supplies the function-pointer and completes the registration. + +### Handling Overloads + +If multiple overloads exist, the signature must be specified as a template argument. Otherwise, the compiler cannot resolve the intended function-pointer. + +For example: + +```cpp +namespace ext { + bool sendMessage(const char*); + void sendMessage(int, std::string); +} +``` +```c++ +rtl::type().ns("ext").function("sendMessage").build(ext::sendMessage); +rtl::type().ns("ext").function("sendMessage").build(ext::sendMessage); +``` + +### PODs / Classes / Structs + +```cpp +rtl::type().ns("ext").record("type-name").build(); +``` + +* Registers a type by name and associates it with the specified namespace. +* This type (`T`) registration is **mandatory** for any of its members to be registered. The order of registration does not matter. +* The default, copy, and move constructors, along with the destructor, are registered automatically. Explicit registration of these special members is disallowed and will result in a compile-time error. + +### Constructors + +```cpp +rtl::type().member().constructor<...>().build(); +``` + +* `.member()`: enters the scope of `T` (POD/class/struct). +* `.constructor<...>()`: registers a user-defined constructor. The template parameter `<..signature..>` must be provided since no function-pointer is available for type deduction, and this also disambiguates overloads. + +### Member Functions + +```cpp +rtl::type().member().method<...>("method-name").build(&T::f); +``` + +* `.method<...>(..)`: registers a non-const member function. The template parameter `<..signature..>` disambiguates overloads. +* Variants exist for const (`.methodConst`) and static (`.methodStatic`) methods. + +👉 Note +> *The `function<..signature..>` and `method<..signature..>` template parameters are primarily for overload resolution. They tell RTL exactly which overload of a function or method you mean to register.* + +--- + +## Querying the Metadata + +Once the Mirror is initialized with metadata references, it can be queried for registered entities and used to introspect types at runtime through RTL’s access interface, which is exposed via the `rtl_access.h` header. + +`rtl::CxxMirror` provides lookup APIs that return reflection metadata objects. +Registered types (`class`, `struct`, or POD) are queried as `rtl::Record`, while non-member functions are queried as `rtl::Function`. +For example: + +```cpp +// Function without a namespace +std::optional popMessage = cxx::mirror().getFunction("popMessage"); + +// Function registered with a namespace, e.g. "ext" +std::optional sendMessage = cxx::mirror().getFunction("ext", "sendMessage"); +``` + +These metadata are returned wrapped in `std::optional`, which is empty if the requested entity is not found by the name specified. + +```cpp +// Querying a type without a namespace +std::optional classPerson = cxx::mirror().getRecord("Person"); + +// Querying a type with a namespace, e.g. "model" +std::optional classPerson = cxx::mirror().getRecord("model", "Person"); +``` + +* If a type or function is registered without a namespace, it must be queried without specifying a namespace. +* If a type or function is registered with a namespace, it must be queried using the same namespace. + +`rtl::Record` represents any registered C++ type, including user-defined `class` and `struct` types, as well as POD types. +The term **Record** follows the naming convention used in the **LLVM** project (e.g. `CXXRecordDecl`). + +All registered member functions of a type can be obtained from its corresponding `rtl::Record` as `rtl::Method` objects. +For POD types such as `char`, the type can still be registered as an `rtl::Record`. +In this case, only the implicitly supported special members (copy/move constructors and the destructor) are available. +POD types do not have member functions. + +`rtl::CxxMirror` also provides an overload of `getRecord()` that accepts an `std::uintptr_t` instead of a string identifier. +This ID can be generated using `rtl::traits::uid`, where `T` is a compile time known type. +The generated ID may be cached and reused for runtime lookups without requiring a namespace or string-based queries. + +The `rtl::Method` and `rtl::Function` metadata objects can be further queried to determine whether a specific call signature is valid for a given function or method. This allows callers to validate argument compatibility before attempting materialization or invocation. + +```c++ +// Obtain metadata for the registered function. +std::optional sendMessage = cxx::mirror().getFunction("ext", "sendMessage"); + +// Query supported call signatures. +bool isSignature0 = sendMessage->hasSignature(); // true +bool isSignature1 = sendMessage->hasSignature(); // true +bool isSignature2 = sendMessage->hasSignature<>(); // false (no parameters) +``` +--- + +## The `rtl::RObject` + +`rtl::RObject` exists to wrap values or objects of any type in a type-erased form while providing safe access interfaces. +It can be returned from reflective function calls, method calls, and constructor calls. +It can also be created directly from a known value or object. + +Objects constructed on the **Heap** via a reflective constructor call are returned as an `rtl::RObject` and are internally managed using `std::unique_ptr` for automatic lifetime management. + +Objects returned from reflective function or method calls, as well as values directly wrapped in an `rtl::RObject`, are stored on the **Stack** using `std::any`. + +#### Accessing Values from `rtl::RObject`: + +When working with `rtl::RObject`, the following interfaces provide safe access to the stored value: + +| Function | Purpose | +| ------------------ | ---------------------------------------------------------------------- | +| `isEmpty()` | Checks whether the object contains a value. | +| `canViewAs()` | Returns `true` if the stored type is `T` or safely convertible to `T`. | +| `view()` | Returns a typed view of the stored value, or an empty `std::optional`. | +| `view()->get()` | Accesses the stored value as a `const T&`. | + +👉 Tip + +> *Use `.canViewAs()` for a lightweight boolean check when branching, and `.view()` when you need to access the value.* + +### Move Semantics with `rtl::RObject` + +`rtl::RObject` is a **move-only** type. Copying is disallowed, and ownership transfer is performed exclusively through move semantics. +The behavior differs internally based on whether the underlying object is stored on the **Stack** or on the **Heap**, without any impact on the public interface or user-visible behavior. + +#### Stack-Allocated Objects: + +When an object is created on **Stack**, the underlying instance is stored directly inside `rtl::RObject` using `std::any`. + +```cpp +rtl::RObject obj1 = rtl::RObject(std::string_view("Hello")); // No internal heap allocation, stored on the stack. +rtl::RObject obj2 = std::move(obj1); +``` + +**Behavior:** + +* The reflected type’s **move constructor** is invoked. +* Ownership transfers to `obj2`. +* The moved-from object (`obj1`) becomes empty. +* No duplication occurs. + +👉 Mental Note +> *Stack move semantics invoke the reflected type’s move constructor.* + +`rtl::RObject` itself does not perform heap allocation when wrapping stack-stored values. Any dynamic allocation that occurs is solely an implementation detail of `std::any`. By leveraging `std::any`, RTL provides controlled, type-erased storage with retained runtime type information as a safe alternative to `void*`, enforcing validated access and well-defined semantics while avoiding unchecked casts and undefined behavior. + +#### Heap-Allocated Objects: + +Objects on the **Heap** can only be created through a reflective constructor call. The returned instance is managed internally using `std::unique_ptr`. +Moving such an `rtl::RObject` transfers ownership of the pointer. + +**Behavior:** + +* The internal `std::unique_ptr` is moved. +* The reflected type’s move constructor is **not** invoked. +* Ownership transfers to the destination object. +* The moved-from object becomes empty. +* The underlying heap object remains valid until the final owner is destroyed. + +👉 Mental Note +> *Heap move semantics transfer the `unique_ptr` without moving the underlying object.* + +Across both **Stack** and **Heap** moves: + +* The moved-from `rtl::RObject` becomes empty. +* The destination `rtl::RObject` becomes the sole owner. +* Object destruction occurs exactly once. +* Cloning or invoking a moved-from object results in `rtl::error::EmptyRObject`. + +**Summary:** + +When an `rtl::RObject` is moved, RTL either: + +* Invokes the reflected type’s move constructor (**Stack** allocation), or +* Transfers ownership of the internal `std::unique_ptr` (**Heap** allocation). + +In both cases, the source object is invalidated and ownership remains well-defined. + +--- + +## The `rtl::view` + +`rtl::view` is a lightweight, immutable handle that provides safe, read-only access to a value stored inside an `rtl::RObject`. + +It exists to bridge the gap between: + +* type-erased storage (`rtl::RObject`), and +* typed access (`const T&`). + +A `rtl::view` never exposes ownership. It only exposes **observation**. + +#### Properties: + +* **Read-only** – A `rtl::view` only provides access as `const T&`. +* **Non-owning abstraction** – Whether the underlying value is owned or referenced is intentionally hidden. +* **Non-copyable and non-movable** – A `rtl::view` cannot be copied or moved and must be consumed immediately. +* **Lifetime-bound** – A `rtl::view` is only valid as long as the originating `rtl::RObject` remains alive. Using a `rtl::view` after the `rtl::RObject` is destroyed results in undefined behavior. + +#### Access Pattern: + +```cpp +auto view = robj.view(); +if (view) { + const T& value = view->get(); +} +``` + +This contract is uniform across all reflected types, including PODs, user-defined types, and standard library wrappers and smart pointers. + +👉 Ongoing + +> *RTL is designed to support seamless and transparent access to standard library wrapper types (such as `std::optional`, `std::variant`, `std::weak_ptr`, and others) while preserving their native semantics. At present, this behavior is fully implemented and validated only for `std::shared_ptr` and `std::unique_ptr`.* + +### Smart Pointer Semantics with `rtl::view` + +RTL treats smart pointers as **first-class reflected values** while preserving their native ownership rules. +No implicit deep copies are ever performed. + +#### `std::shared_ptr`: + +When an `rtl::RObject` reflects a `std::shared_ptr`, it can be viewed either as `T` directly or as `std::shared_ptr`. + +While viewing directly as `T`, a `const T&` access is provided. The user may either observe the value or create copies, depending on what liberties are provided by `T`’s copy semantics. + +```cpp +rtl::RObject robj = rtl::reflect(std::make_shared(20438)); // std::shared_ptr is on Stack. + +if (robj.canViewAs()) { // true + int viewCpy = robj.view(); // Creates a copy of int. + const int& viewCRef = robj.view(); // References the underlying value. +} +``` + +The same object can also be accessed as `std::shared_ptr`, in which case native shared ownership semantics are preserved: + +```cpp +if (robj.canViewAs>()) { // true + auto view = robj.view>(); + { + const std::shared_ptr& sptrRef = view->get(); + bool hasSingleOwner = (sptrRef.use_count() == 1); // true + } { + std::shared_ptr sptrCpy = view->get(); + bool hasTwoOwners = (sptrCpy.use_count() == 2); // true + } + // After temporary copies go out of scope, ownership returns to robj alone. + bool backToSingleOwner = (view->get().use_count() == 1); // true (robj is still alive) +} +``` + +Accessing a reflected `std::shared_ptr` through `rtl::RObject` preserves native shared ownership semantics: observing it does not change the reference count, and copying it produces a shallow, ref-counted copy exactly as in normal C++. + +#### `std::unique_ptr`: + +The behavior of `std::unique_ptr` differs from `std::shared_ptr` only in its ownership model. + +When an `rtl::RObject` reflects a `std::unique_ptr`, it can likewise be viewed as `T` directly or as `std::unique_ptr`. Viewing it as `T` provides the same `const T&` access as described earlier, and the user may observe or copy the value according to `T`’s copy semantics. + +However, unlike `std::shared_ptr`, a reflected `std::unique_ptr` does **not** permit ownership transfer through a view: + +```c++ + +// This is NOT allowed, std::unique_ptr is move-only +auto view = robj.view>(); +std::unique_ptr uptrCpy = view->get(); // ERROR: cannot copy unique_ptr + +// the pointee can be accessed +if (robj.canViewAs()) { + int value = robj.view()->get(); // Creates a copy of int. +} + +``` + +* Access is always provided as `const std::unique_ptr&`. +* No move operation is possible through `rtl::view`. +* Ownership remains exclusively with the `rtl::RObject`. +* The pointee can still be accessed safely via `view()`. + +In other words, within RTL: + +* `std::shared_ptr` exposes shared-ownership semantics because it is copy-constructible and reference-counted. +* `std::unique_ptr` is treated as an exclusive-ownership wrapper whose lifetime is managed entirely by `rtl::RObject`, because it is not copy-constructible and represents unique ownership. + +--- + +## Reflective Invocations with RTL + +`rtl::Method` and `rtl::Function` are metadata descriptors. Functions and methods cannot be directly called through these objects. Instead, RTL uses a materialization model to produce callable entities. + +Callable entities are materialized by explicitly specifying the argument and return types. This design avoids a single, fully type-erased invocation path for all use cases. By requiring the user to declare the intended call signature, RTL can validate the request and select an invocation path optimized for the available type information. + +When full type information is provided, materialized callables compile to **direct function-pointer** calls with near-zero overhead. When type erasure is required (for example, for an unknown return or target type), invocation proceeds through a lightweight dispatch layer with performance **comparable** to `std::function`. + +👉 The Idea +> *In RTL, materialization makes the performance–flexibility trade-off explicit at each call site.* + +Every type-erased reflective call returns either `std::pair` or `std::pair>`. + +* `rtl::error` indicates whether the call was successful (`rtl::error::None`) or if an error occurred. +* `rtl::RObject` or `std::optional` contains the return value if the function returns something, or is empty if the function returns `void`. + +Fully type-specified callables do not return an error code (except constructors). Once materialized successfully, they are guaranteed to be safe to call. + +RTL provides the following callable entities: + +### `rtl::constructor` + +Constructors can be materialized directly from an `rtl::Record`. +For example, an overloaded constructor can be materialized as follows: + +```cpp +// classPerson is of type std::optional. +rtl::constructor personCtor = classPerson->ctorT(); +if (personCtor) { // Constructor successfully materialized + auto [err, person] = personCtor(rtl::alloc::Stack, "Waldo", 42); // Safe to call. +} +``` + +If no constructor is registered with the specified signature, the callable is not initialized. Calling it without validation does not throw an exception; instead, it returns `rtl::error::SignatureMismatch` in the `err` variable. + +A default constructor can be materialized as follows: + +```cpp +rtl::constructor<> personCtor = classPerson->ctorT(); +// No validation required +auto [err, person] = personCtor(rtl::alloc::Heap); // Safe to call. +``` + +The default constructor for a type `T` is implicitly registered when the type is registered using `rtl::type().record()`. It is guaranteed to be materializable and safe to call. If the default constructor is not publicly accessible or is deleted, +`rtl::error::TypeNotDefaultConstructible` is returned in the `err` variable. + +Objects can be constructed by specifying `rtl::alloc::Stack` or `rtl::alloc::Heap` as the first parameter. The constructed object is returned as an `rtl::RObject`, which type-erases the underlying object. + +* `Heap` allocated objects are managed using `std::unique_ptr`. +* `Stack` allocated objects are stored directly in `std::any`. + +### `rtl::function` – Type Aware + +Non-member functions can be materialized from an `rtl::Function`: + +```c++ +rtl::function cToStr = cxx::mirror().getFunction("complexToStr") + ->argsT() + .returnT(); +if(cToStr) { // Function successfully materialized + std::string result = cToStr(61, 35); +} +else { + std::cerr << rtl::to_string(cToStr.get_init_err()); +} +``` + +Here, the return type and argument types are fully specified at compile time. +This allows RTL to resolve the function pointer by signature and provide it wrapped in a thin callable layer that effectively reduces to a single **function-pointer hop** at runtime. The overhead is comparable to a native C-style function pointer call. + +The materialized `rtl::function` must be validated before invocation. Calling it without validation may result in undefined behavior. +If materialization fails, the error can be retrieved using `get_init_err()`. +Possible error values include: + +* `rtl::error::InvalidCaller` +* `rtl::error::SignatureMismatch` +* `rtl::error::ReturnTypeMismatch` + +### `rtl::function` – Type Erased + +If the return type is not known at compile time, `rtl::Return` can be used as the return type. +In this case, the `.returnT()` template parameter can be omitted, and `rtl::Return` will be selected automatically. + +```c++ +rtl::function cToStr = cxx::mirror().getFunction("complexToStr") + ->argsT() + .returnT(); +auto [err, ret] = cToStr(61, 35); +if(err != rtl::error::None && ret.canViewAs()) { + std::string resultStr = ret.view()->get(); // Safely view the returned std::string. +} +else { + std::cerr << rtl::to_string(err); +} +``` + +Validation of the materialized `rtl::function` is optional in this case. Calling it without validation does not result in undefined behavior; instead, an appropriate `rtl::error` is returned. If the callable was not successfully materialized, invoking it returns the same error as `get_init_err()` on the callable, typically `rtl::error::SignatureMismatch`. + +If materialization succeeds but the call fails, possible error values include: + +* `rtl::error::InvalidCaller` +* `rtl::error::RefBindingMismatch` +* `rtl::error::ExplicitRefBindingRequired` + +👉 Mental Note +> *Fully type-specified callables must be validated before invocation to avoid undefined behavior; type-erased callables are safe to invoke without prior validation and report errors at runtime.* + +### `rtl::method` – Type Aware + +To materialize a member function, the corresponding `rtl::Method` metadata must first be obtained. +This requires querying the `rtl::CxxMirror` for the desired `class` or `struct` as an `rtl::Record`. + +```c++ +std::optional classPerson = cxx::mirror().getRecord("Person"); +if (!classPerson) { /* Type not registered. */ } + +// From rtl::Record, fetch the desired member-function metadata +std::optional oGetName = classPerson->getMethod("getName"); +if (!oGetName) { /* Member function not registered */ } +``` + +Once the `rtl::Method` is available, member functions can be materialized from it. + +```c++ +rtl::method getName = oGetName->targetT().argsT() + .returnT(); +if (!getName) { // Member-function with expected signature not found. + std::cerr << rtl::to_string(getName.get_init_err()); +} +else { + Person person("Alex", 23); + std::string nameStr = getName(person)(); // Returns string 'Alex'. +} +``` + +#### `rtl::const_method`: + +The `rtl::method` can only invoke non-`const` member functions. To invoke a `const` qualified member function, `rtl::const_method` must be used. + +An `rtl::const_method` is materialized by specifying a `const` target type in the `.targetT<>()` call: +```c++ +rtl::const_method getName = oGetName->targetT().argsT() + .returnT(); +if (getName) { + const Person person("Alex", 23); + std::string nameStr = getName(person)(); // Returns string 'Alex'. +} +``` + +Here, the target type is marked `const` via the template argument to `.targetT()`. As a result, `rtl::const_method` only accepts a `const Person` object as its invocation target. + +#### `rtl::static_method`: + +To invoke a `static` member function, `rtl::static_method` is used. Static methods do not require a target object, so the `.targetT()` call is omitted: + +```c++ +// Assume Person::getName() is a static function registered under the same name. +rtl::static_method getName = oGetName->argsT().returnT(); +if (getName) { + std::string nameStr = getName()(); // Returns a default std::string. +} +``` + +When the return type, target type, and argument types are fully specified, these materialized callables reduce to a **direct function-pointer** invocation at runtime. + +If materialization fails, calling `rtl::method`, `rtl::const_method`, or `rtl::static_method` without validation results in undefined behavior. +The initialization error can be retrieved using `get_init_err()`. + +Possible error values include: + +* `rtl::error::InvalidCaller` +* `rtl::error::SignatureMismatch` +* `rtl::error::ReturnTypeMismatch` +* `rtl::error::InvalidNonStaticMethodCaller` + +`rtl::error::InvalidNonStaticMethodCaller` is returned when a non-static member function is materialized without specifying a target type using `.targetT<>()`, causing it to be treated as a static function. + +### `rtl::method` – Type Erased + +When the concrete target type is not available at compile time, `rtl::method` can be materialized without specifying a target type. +Calling `.targetT()` without a template parameter defaults the target type to `rtl::RObject`. + +```c++ + +// Materializing a default constructor +rtl::constructor<> personCtor = classPerson->ctorT(); + +// No validation required +auto [err, personObj] = personCtor(rtl::alloc::Stack); // Safe to call + +rtl::method getName = oGetName->targetT().argsT() + .returnT(); +auto [err0, ret] = getName(personObj)(); // Invoke and receive return as std::optional. +if (err0 == rtl::error::None && ret.has_value()) { + std::string nameStr = ret.value(); +} +``` +In this case, the typed return value is wrapped in `std::optional`. If the member function returns `void`, the optional is empty. + +Along with the target type, the return type can also be erased. Leaving the `.returnT()` template parameter empty defaults the return type to `rtl::Return`. + +```c++ + +rtl::method getName = oGetName->targetT().argsT().returnT(); + +auto [err0, ret] = getName(personObj)(); // Invoke and receive return as rtl::RObject. +if (err0 == rtl::error::None && ret.canViewAs()) { + std::string nameStr = ret.view()->get(); // Safely view the returned std::string. +} +``` + +And finally, If the target type is known but the return type is erased: + +```c++ +rtl::method getName = oGetName->targetT().argsT().returnT(); +``` +For static methods, `rtl::static_method` is used and `.targetT()` is omitted: + +```c++ +rtl::static_method getName = oGetName->argsT().returnT(); +``` + +All of these variants follow the same invocation semantics. The only difference is the return representation: + +* Known return types are returned as `std::optional` +* Erased return types are returned as `rtl::RObject` + +#### `const` and non-`const` Member Functions with Type-Erased Targets: + +There is no separate callable entity such as `rtl::const_method` for type-erased invocation of `const`-qualified member function overloads. +The same `rtl::method` is used for both `const` and non-`const` member functions. +To invoke a `const` member function, the target must be passed as a `const` reference: + +```c++ +auto [err, ret] = getName(std::cref(personObj))(); +``` +This call will succeed only if a `const`-qualified overload of `Person::getName()` exists. If it does not, the call returns `rtl::error::ConstOverloadMissing`. + +If only a `const` overload exists and a non-`const` target is provided, the call returns `rtl::error::NonConstOverloadMissing`. + +When both `const` and non-`const` overloads are registered, the following rules apply: + +* Passing a non-`const` target binds to the non-`const` overload. +* Passing a `const` target (`std::cref(personObj)`) binds to the `const` overload. + +👉 Note +> *RTL does not perform automatic `const`/non-`const` overload resolution. The intended overload must be selected explicitly by the user through the target’s `const` qualification.* + +As with `rtl::function`, validation of the materialized `rtl::method` is optional in this case. +Calling it without validation does not result in undefined behavior; instead, an appropriate `rtl::error` is returned. If the callable was not successfully materialized, invoking it returns the same error as `get_init_err()` on the callable, typically `rtl::error::SignatureMismatch`. + +If materialization succeeds but the call fails, possible error values include: + +* `rtl::error::InvalidCaller` +* `rtl::error::ConstOverloadMissing` +* `rtl::error::NonConstOverloadMissing` +* `rtl::error::RefBindingMismatch` +* `rtl::error::ExplicitRefBindingRequired` +* `rtl::error::EmptyRObject` + +--- + +## Perfect Forwarding + +When multiple reference-based overloads of the same function signature exist, for example: + +```c++ +std::string reverse(std::string); // (1) by value +std::string reverse(std::string&); // (2) lvalue ref +std::string reverse(const std::string&); // (3) const lvalue ref +std::string reverse(std::string&&); // (4) rvalue ref + +``` + +In standard C++, invoking `reverse` by name with such an overload set results in a compile-time ambiguity error. +This occurs because the pass-by-value overload conflicts with every reference-based overload, and overload resolution cannot establish a single best match. + +If these functions are not invoked by name, but instead referenced through explicitly typed function-pointers, each overload can be selected unambiguously: + +```c++ +auto fptr0 = static_cast(reverseString); +auto fptr1 = static_cast(reverseString); +auto fptr3 = static_cast(reverseString); +auto fptr2 = static_cast(reverseString); +``` +Here, the explicit function-pointer type fully specifies the intended overload, bypassing overload resolution ambiguity. +Since RTL requires only a distinct function-pointer to register a function or method, all of the above overloads can be registered without ambiguity. + +During invocation, where the compiler would reject a direct call due to pass-by-value overload ambiguity, RTL instead deterministically defaults to the **pass-by-value** overload unless a more specific intent is explicitly expressed by the user. + +Meaning, if all such overloads are registered and an `rtl::function` is materialized and invoked, the call will unambiguously bind to the **pass-by-value** overload. + +This behavior follows directly from the fact that RTL invocation is equivalent to calling through a fully specified function-pointer, which is explicitly permitted by standard C++. + +#### Reference Binding: + +Each overload shown above can be invoked by explicitly providing the intended call signature as a template parameter to `bind<>()`. RTL then perfect-forwards the arguments to the selected overload: + +```c++ +rtl::function reverseStr = cxx::mirror().getFunction("reverseString") + .argsT().returnT(); + +auto [err0, ret0] = reverseStr("Hello"); // calls by-value overload (1) +auto [err1, ret1] = reverseStr.bind()("Hello"); // calls lvalue-ref overload (2) +auto [err2, ret2] = reverseStr.bind()("Hello"); // calls const lvalue-ref overload (3) +auto [err3, ret3] = reverseStr.bind()("Hello"); // calls rvalue-ref overload (4) +``` + +If no pass-by-value overload is registered, explicit binding is required to invoke the desired overload. Otherwise, the call results in `rtl::error::ExplicitRefBindingRequired`. + +Now consider a case where only overloads (2) and (3) are registered: + +```c++ +std::string reverse(std::string&); // (2) +std::string reverse(const std::string&); // (3) +``` + +Both overloads can be invoked explicitly using `bind<>()`. However, if the user attempts to bind a signature that has not been registered, for example: + +```c++ +auto [err, ret] = reverseStr.bind()("Hello"); +``` + +the invocation fails with `rtl::error::RefBindingMismatch`, as no rvalue-reference overload exists in the registered overload set. Now consider the case where only overload (3) is registered: + +```c++ +std::string reverse(const std::string&); // (3) +``` + +In this case, no explicit binding is required, as there is no overload ambiguity and the function guarantees that the argument will not be modified. If only overload (2) or only overload (4) is registered: + +```c++ +std::string reverse(std::string&); // (2) +std::string reverse(std::string&&); // (4) +``` + +explicit binding is required, even when these overloads exist in isolation. This is because both signatures permit mutation of the argument, and RTL requires such intent to be expressed explicitly by the user. + +👉 Rationale +> *RTL’s philosophy is to make mutating calls loud and explicit, as reflection inherently hides type information.* + +--- + +## Error Taxonomy + +The table below lists RTL errors with brief, intent-focused descriptions, providing a direct mapping from failure conditions to their semantic meaning. + +| Error | semantic meaning | +| ------------------------------ | ------------------------------------------------------------------------------- | +| `None` | Operation completed successfully; no error occurred. | +| `EmptyRObject` | The `RObject` is empty, typically due to a move or invalidation. | +| `InvalidCaller` | The callable was never successfully materialized or is otherwise invalid. | +| `SignatureMismatch` | No registered overload matches the requested call signature. | +| `TargetTypeMismatch` | The bound target object type is incompatible with the method’s expected target. | +| `ReturnTypeMismatch` | The specified return type does not match the function’s actual return type. | +| `RefBindingMismatch` | Reference qualifiers of the arguments do not match any registered overload. | +| `ExplicitRefBindingRequired` | Overload set allows mutation; binding intent must be stated explicitly. | +| `InvalidNonStaticMethodCaller` | A non-static method was invoked without providing a valid target object. | +| `ConstOverloadMissing` | A const-qualified overload does not exist for the given invocation. | +| `NonConstOverloadMissing` | A non-const overload does not exist as explicitly requested. | +| `InvalidCallOnConstTarget` | A non-const method was invoked on an object reflecting const state. | +| `TypeNotCopyConstructible` | The reflected type cannot be copy-constructed due to access or deletion. | +| `TypeNotDefaultConstructible` | The reflected type cannot be default-constructed. | + +--- +***More to come...*** diff --git a/text-benchmark-logs/benchmark_runs_string.log b/docs/benchmark_runs_string.log similarity index 56% rename from text-benchmark-logs/benchmark_runs_string.log rename to docs/benchmark_runs_string.log index 8411fb33..2cbe9a25 100644 --- a/text-benchmark-logs/benchmark_runs_string.log +++ b/docs/benchmark_runs_string.log @@ -2,116 +2,116 @@ Starting benchmark runs... Binary: ./bin/RTLBenchmarkApp Log: ./benchmark_runs.log =================================== -[2025-11-04 12:16:26] >>> Run 1: workload scale = 0 +[2026-01-19 23:00:30] >>> Run 1: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T12:16:26+05:30 +2026-01-19T23:00:30+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3710.04 MHz CPU s) +Run on (16 X 1167.28 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 0.72, 1.01, 0.81 +Load Average: 0.83, 0.71, 0.51 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 10.7 ns 10.7 ns 63153409 +bm_call::direct__Function::set_string 9.81 ns 9.81 ns 71490262 -bm_call::via_function_ptr__Function::set_string 11.0 ns 11.0 ns 62273630 -bm_call::via_function_ptr____Method::set_string 11.1 ns 11.1 ns 62565849 +bm_call::via_function_ptr__Function::set_string 10.6 ns 10.6 ns 66175516 +bm_call::via_function_ptr____Method::set_string 10.5 ns 10.5 ns 65825819 -bm_std::function_calls__Function::set_string 11.3 ns 11.3 ns 60820859 -bm_std::function_calls____Method::set_string 11.3 ns 11.2 ns 62223001 +bm_std::function_calls__Function::set_string 10.7 ns 10.7 ns 65252218 +bm_std::function_calls____Method::set_string 10.6 ns 10.6 ns 66308995 -bm_rtl::function_calls__Function::set_string 11.8 ns 11.8 ns 62334625 -bm_rtl::method_calls______Method::set_string 11.7 ns 11.7 ns 58038245 +bm_rtl::function_calls__Function::set_string 10.2 ns 10.2 ns 70267504 +bm_rtl::method_calls______Method::set_string 10.5 ns 10.5 ns 66588972 -bm_rtl::function__ErasedReturnType::set_string 13.6 ns 13.6 ns 51307142 -bm_rtl::method____ErasedReturnType::set_string 14.5 ns 14.5 ns 49013292 -bm_rtl::method____ErasedTargetType::set_string 14.4 ns 14.4 ns 48282886 -bm_rtl::method____ErasedTargetAndReturnType::set_string 14.3 ns 14.3 ns 48290341 +bm_rtl::function__ErasedReturnType::set_string 14.2 ns 14.2 ns 49256488 +bm_rtl::method____ErasedReturnType::set_string 13.6 ns 13.6 ns 51807316 +bm_rtl::method____ErasedTargetType::set_string 14.5 ns 14.5 ns 48461435 +bm_rtl::method____ErasedTargetAndReturnType::set_string 15.3 ns 15.3 ns 45341839 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 12.3 ns 12.3 ns 56910624 +bm_call::direct__Function::get_string 12.8 ns 12.8 ns 55715198 -bm_call::via_function_ptr__Function::get_string 13.3 ns 13.3 ns 54725237 -bm_call::via_function_ptr____Method::get_string 13.5 ns 13.5 ns 51174087 +bm_call::via_function_ptr__Function::get_string 12.7 ns 12.7 ns 55284583 +bm_call::via_function_ptr____Method::get_string 12.4 ns 12.4 ns 56197664 -bm_std::function_calls__Function::get_string 13.4 ns 13.4 ns 51284624 -bm_std::function_calls____Method::get_string 13.4 ns 13.4 ns 53332275 +bm_std::function_calls__Function::get_string 12.5 ns 12.5 ns 56330937 +bm_std::function_calls____Method::get_string 13.1 ns 13.1 ns 53156802 -bm_rtl::function_calls__Function::get_string 12.9 ns 12.9 ns 51676343 -bm_rtl::method_calls______Method::get_string 13.0 ns 13.0 ns 53310944 +bm_rtl::function_calls__Function::get_string 12.1 ns 12.1 ns 57911838 +bm_rtl::method_calls______Method::get_string 12.5 ns 12.5 ns 55429760 -bm_rtl::function__ErasedReturnType::get_string 33.5 ns 33.5 ns 21875285 -bm_rtl::method____ErasedReturnType::get_string 33.8 ns 33.8 ns 20417210 -bm_rtl::method____ErasedTargetType::get_string 23.0 ns 23.0 ns 31547854 -bm_rtl::method____ErasedTargetAndReturnType::get_string 34.6 ns 34.6 ns 20062476 +bm_rtl::function__ErasedReturnType::get_string 30.0 ns 30.0 ns 23256364 +bm_rtl::method____ErasedReturnType::get_string 30.8 ns 30.8 ns 22557648 +bm_rtl::method____ErasedTargetType::get_string 25.1 ns 25.1 ns 27722734 +bm_rtl::method____ErasedTargetAndReturnType::get_string 32.1 ns 32.1 ns 21698776 ----------------------------------- -[2025-11-04 12:16:45] >>> Run 2: workload scale = 0 +[2026-01-19 23:00:49] >>> Run 2: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T12:16:45+05:30 +2026-01-19T23:00:49+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3859.55 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.03, 1.06, 0.83 +Load Average: 0.88, 0.73, 0.52 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 10.8 ns 10.8 ns 59543169 +bm_call::direct__Function::set_string 9.74 ns 9.74 ns 71535521 -bm_call::via_function_ptr__Function::set_string 11.3 ns 11.3 ns 63603473 -bm_call::via_function_ptr____Method::set_string 11.4 ns 11.4 ns 60018727 +bm_call::via_function_ptr__Function::set_string 10.5 ns 10.5 ns 66143823 +bm_call::via_function_ptr____Method::set_string 10.7 ns 10.7 ns 65023900 -bm_std::function_calls__Function::set_string 11.6 ns 11.6 ns 61482058 -bm_std::function_calls____Method::set_string 11.4 ns 11.4 ns 60456156 +bm_std::function_calls__Function::set_string 10.6 ns 10.6 ns 65354399 +bm_std::function_calls____Method::set_string 10.5 ns 10.5 ns 65453839 -bm_rtl::function_calls__Function::set_string 11.2 ns 11.2 ns 62862118 -bm_rtl::method_calls______Method::set_string 11.8 ns 11.8 ns 58169006 +bm_rtl::function_calls__Function::set_string 10.1 ns 10.1 ns 69712198 +bm_rtl::method_calls______Method::set_string 10.4 ns 10.4 ns 66905737 -bm_rtl::function__ErasedReturnType::set_string 13.8 ns 13.8 ns 49964913 -bm_rtl::method____ErasedReturnType::set_string 14.1 ns 14.1 ns 49075849 -bm_rtl::method____ErasedTargetType::set_string 14.7 ns 14.7 ns 47435229 -bm_rtl::method____ErasedTargetAndReturnType::set_string 14.4 ns 14.4 ns 48401256 +bm_rtl::function__ErasedReturnType::set_string 14.2 ns 14.2 ns 49078487 +bm_rtl::method____ErasedReturnType::set_string 13.8 ns 13.8 ns 50624940 +bm_rtl::method____ErasedTargetType::set_string 14.6 ns 14.6 ns 48083655 +bm_rtl::method____ErasedTargetAndReturnType::set_string 15.1 ns 15.1 ns 46102091 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 12.7 ns 12.7 ns 54462134 +bm_call::direct__Function::get_string 12.8 ns 12.8 ns 55815763 -bm_call::via_function_ptr__Function::get_string 12.9 ns 12.9 ns 55248821 -bm_call::via_function_ptr____Method::get_string 12.9 ns 12.9 ns 54718885 +bm_call::via_function_ptr__Function::get_string 12.6 ns 12.6 ns 55774749 +bm_call::via_function_ptr____Method::get_string 12.6 ns 12.6 ns 56928113 -bm_std::function_calls__Function::get_string 13.0 ns 13.0 ns 53924949 -bm_std::function_calls____Method::get_string 12.9 ns 12.9 ns 53432887 +bm_std::function_calls__Function::get_string 12.7 ns 12.7 ns 55895179 +bm_std::function_calls____Method::get_string 13.1 ns 13.1 ns 52615650 -bm_rtl::function_calls__Function::get_string 12.6 ns 12.6 ns 55170671 -bm_rtl::method_calls______Method::get_string 12.8 ns 12.8 ns 54845579 +bm_rtl::function_calls__Function::get_string 12.1 ns 12.1 ns 57938812 +bm_rtl::method_calls______Method::get_string 12.5 ns 12.5 ns 55570876 -bm_rtl::function__ErasedReturnType::get_string 31.9 ns 31.8 ns 21982235 -bm_rtl::method____ErasedReturnType::get_string 32.3 ns 32.3 ns 21861314 -bm_rtl::method____ErasedTargetType::get_string 21.5 ns 21.5 ns 32708463 -bm_rtl::method____ErasedTargetAndReturnType::get_string 32.9 ns 32.9 ns 21076858 +bm_rtl::function__ErasedReturnType::get_string 30.1 ns 30.1 ns 23389099 +bm_rtl::method____ErasedReturnType::get_string 30.9 ns 30.9 ns 22546410 +bm_rtl::method____ErasedTargetType::get_string 25.3 ns 25.3 ns 27502524 +bm_rtl::method____ErasedTargetAndReturnType::get_string 32.2 ns 32.2 ns 21576033 ----------------------------------- -[2025-11-04 12:17:05] >>> Run 3: workload scale = 0 +[2026-01-19 23:01:08] >>> Run 3: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T12:17:05+05:30 +2026-01-19T23:01:08+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -119,1478 +119,1478 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 1.05, 0.83 +Load Average: 0.99, 0.76, 0.54 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 10.6 ns 10.6 ns 64487293 +bm_call::direct__Function::set_string 9.77 ns 9.76 ns 71887826 -bm_call::via_function_ptr__Function::set_string 10.9 ns 10.9 ns 64347447 -bm_call::via_function_ptr____Method::set_string 10.9 ns 10.9 ns 63847988 +bm_call::via_function_ptr__Function::set_string 10.7 ns 10.7 ns 66604739 +bm_call::via_function_ptr____Method::set_string 10.8 ns 10.7 ns 65976848 -bm_std::function_calls__Function::set_string 11.2 ns 11.2 ns 61218687 -bm_std::function_calls____Method::set_string 11.3 ns 11.3 ns 61153450 +bm_std::function_calls__Function::set_string 10.7 ns 10.7 ns 66028009 +bm_std::function_calls____Method::set_string 10.6 ns 10.6 ns 66566271 -bm_rtl::function_calls__Function::set_string 11.1 ns 11.1 ns 61892878 -bm_rtl::method_calls______Method::set_string 11.3 ns 11.3 ns 61658245 +bm_rtl::function_calls__Function::set_string 10.2 ns 10.2 ns 69416123 +bm_rtl::method_calls______Method::set_string 10.5 ns 10.5 ns 67401327 -bm_rtl::function__ErasedReturnType::set_string 13.3 ns 13.3 ns 52552206 -bm_rtl::method____ErasedReturnType::set_string 13.9 ns 13.9 ns 50430274 -bm_rtl::method____ErasedTargetType::set_string 14.4 ns 14.4 ns 47389596 -bm_rtl::method____ErasedTargetAndReturnType::set_string 14.7 ns 14.7 ns 47109221 +bm_rtl::function__ErasedReturnType::set_string 14.1 ns 14.1 ns 49227860 +bm_rtl::method____ErasedReturnType::set_string 13.6 ns 13.6 ns 52058823 +bm_rtl::method____ErasedTargetType::set_string 14.9 ns 14.9 ns 47060682 +bm_rtl::method____ErasedTargetAndReturnType::set_string 15.1 ns 15.1 ns 46447515 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 12.6 ns 12.6 ns 55992884 +bm_call::direct__Function::get_string 12.8 ns 12.8 ns 54718500 -bm_call::via_function_ptr__Function::get_string 12.9 ns 12.9 ns 51161238 -bm_call::via_function_ptr____Method::get_string 12.9 ns 12.9 ns 55017241 +bm_call::via_function_ptr__Function::get_string 12.6 ns 12.6 ns 55763290 +bm_call::via_function_ptr____Method::get_string 12.4 ns 12.4 ns 56477323 -bm_std::function_calls__Function::get_string 13.5 ns 13.5 ns 53286324 -bm_std::function_calls____Method::get_string 13.3 ns 13.3 ns 52908638 +bm_std::function_calls__Function::get_string 12.6 ns 12.6 ns 55878651 +bm_std::function_calls____Method::get_string 13.2 ns 13.1 ns 54078767 -bm_rtl::function_calls__Function::get_string 12.6 ns 12.6 ns 54243132 -bm_rtl::method_calls______Method::get_string 13.2 ns 13.2 ns 54944142 +bm_rtl::function_calls__Function::get_string 12.1 ns 12.1 ns 57732783 +bm_rtl::method_calls______Method::get_string 12.2 ns 12.2 ns 56825956 -bm_rtl::function__ErasedReturnType::get_string 33.1 ns 33.1 ns 20589263 -bm_rtl::method____ErasedReturnType::get_string 32.9 ns 32.9 ns 21653434 -bm_rtl::method____ErasedTargetType::get_string 23.6 ns 23.6 ns 32185719 -bm_rtl::method____ErasedTargetAndReturnType::get_string 34.2 ns 34.2 ns 20567080 +bm_rtl::function__ErasedReturnType::get_string 30.1 ns 30.1 ns 23149525 +bm_rtl::method____ErasedReturnType::get_string 30.8 ns 30.8 ns 22499692 +bm_rtl::method____ErasedTargetType::get_string 24.9 ns 24.9 ns 27926147 +bm_rtl::method____ErasedTargetAndReturnType::get_string 32.0 ns 32.0 ns 21748751 ----------------------------------- -[2025-11-04 12:17:24] >>> Run 4: workload scale = 0 +[2026-01-19 23:01:27] >>> Run 4: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T12:17:24+05:30 +2026-01-19T23:01:27+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4288.87 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.09, 1.07, 0.84 +Load Average: 0.99, 0.78, 0.55 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 11.1 ns 11.1 ns 66290824 +bm_call::direct__Function::set_string 9.79 ns 9.79 ns 71522140 -bm_call::via_function_ptr__Function::set_string 11.0 ns 11.0 ns 60341873 -bm_call::via_function_ptr____Method::set_string 11.6 ns 11.6 ns 61663734 +bm_call::via_function_ptr__Function::set_string 10.6 ns 10.6 ns 66283611 +bm_call::via_function_ptr____Method::set_string 10.7 ns 10.7 ns 64284489 -bm_std::function_calls__Function::set_string 11.6 ns 11.6 ns 62238534 -bm_std::function_calls____Method::set_string 11.4 ns 11.4 ns 62096594 +bm_std::function_calls__Function::set_string 10.7 ns 10.7 ns 66729049 +bm_std::function_calls____Method::set_string 10.5 ns 10.5 ns 65897765 -bm_rtl::function_calls__Function::set_string 11.3 ns 11.3 ns 61460234 -bm_rtl::method_calls______Method::set_string 11.6 ns 11.6 ns 60712083 +bm_rtl::function_calls__Function::set_string 10.3 ns 10.3 ns 66838298 +bm_rtl::method_calls______Method::set_string 10.5 ns 10.5 ns 66750769 -bm_rtl::function__ErasedReturnType::set_string 13.3 ns 13.3 ns 52213654 -bm_rtl::method____ErasedReturnType::set_string 14.2 ns 14.2 ns 48504898 -bm_rtl::method____ErasedTargetType::set_string 14.7 ns 14.7 ns 47578516 -bm_rtl::method____ErasedTargetAndReturnType::set_string 14.7 ns 14.7 ns 48196113 +bm_rtl::function__ErasedReturnType::set_string 14.1 ns 14.1 ns 49234894 +bm_rtl::method____ErasedReturnType::set_string 13.6 ns 13.5 ns 51084203 +bm_rtl::method____ErasedTargetType::set_string 14.8 ns 14.8 ns 46993007 +bm_rtl::method____ErasedTargetAndReturnType::set_string 15.0 ns 15.0 ns 46202093 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 12.4 ns 12.4 ns 56590796 +bm_call::direct__Function::get_string 12.8 ns 12.8 ns 55437558 -bm_call::via_function_ptr__Function::get_string 12.7 ns 12.7 ns 55116932 -bm_call::via_function_ptr____Method::get_string 12.8 ns 12.8 ns 53240632 +bm_call::via_function_ptr__Function::get_string 12.5 ns 12.5 ns 56136811 +bm_call::via_function_ptr____Method::get_string 12.3 ns 12.3 ns 56979768 -bm_std::function_calls__Function::get_string 13.0 ns 13.0 ns 52948776 -bm_std::function_calls____Method::get_string 12.9 ns 12.9 ns 54392848 +bm_std::function_calls__Function::get_string 12.6 ns 12.6 ns 56259152 +bm_std::function_calls____Method::get_string 13.1 ns 13.1 ns 53971590 -bm_rtl::function_calls__Function::get_string 12.6 ns 12.6 ns 55104443 -bm_rtl::method_calls______Method::get_string 12.7 ns 12.7 ns 54425465 +bm_rtl::function_calls__Function::get_string 12.1 ns 12.1 ns 57898696 +bm_rtl::method_calls______Method::get_string 12.4 ns 12.4 ns 56814167 -bm_rtl::function__ErasedReturnType::get_string 31.6 ns 31.6 ns 22273160 -bm_rtl::method____ErasedReturnType::get_string 32.1 ns 32.1 ns 21839814 -bm_rtl::method____ErasedTargetType::get_string 22.2 ns 22.2 ns 31167600 -bm_rtl::method____ErasedTargetAndReturnType::get_string 32.7 ns 32.7 ns 21437578 +bm_rtl::function__ErasedReturnType::get_string 30.0 ns 30.0 ns 23184768 +bm_rtl::method____ErasedReturnType::get_string 31.0 ns 31.0 ns 22508828 +bm_rtl::method____ErasedTargetType::get_string 24.9 ns 24.9 ns 27847260 +bm_rtl::method____ErasedTargetAndReturnType::get_string 31.8 ns 31.8 ns 21567547 ----------------------------------- -[2025-11-04 12:17:43] >>> Run 5: workload scale = 0 +[2026-01-19 23:01:47] >>> Run 5: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T12:17:43+05:30 +2026-01-19T23:01:47+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2364.75 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.13, 1.08, 0.85 +Load Average: 1.00, 0.79, 0.56 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 10.6 ns 10.6 ns 65062380 +bm_call::direct__Function::set_string 9.71 ns 9.71 ns 71721418 -bm_call::via_function_ptr__Function::set_string 10.8 ns 10.8 ns 64248959 -bm_call::via_function_ptr____Method::set_string 11.0 ns 11.0 ns 62551535 +bm_call::via_function_ptr__Function::set_string 10.5 ns 10.5 ns 66177847 +bm_call::via_function_ptr____Method::set_string 10.6 ns 10.6 ns 65397237 -bm_std::function_calls__Function::set_string 11.2 ns 11.2 ns 60406745 -bm_std::function_calls____Method::set_string 11.3 ns 11.3 ns 62448796 +bm_std::function_calls__Function::set_string 10.7 ns 10.7 ns 65548379 +bm_std::function_calls____Method::set_string 10.5 ns 10.5 ns 66242899 -bm_rtl::function_calls__Function::set_string 11.2 ns 11.2 ns 62675614 -bm_rtl::method_calls______Method::set_string 11.3 ns 11.3 ns 61733399 +bm_rtl::function_calls__Function::set_string 10.2 ns 10.2 ns 69346305 +bm_rtl::method_calls______Method::set_string 10.5 ns 10.5 ns 66803592 -bm_rtl::function__ErasedReturnType::set_string 13.3 ns 13.3 ns 52161573 -bm_rtl::method____ErasedReturnType::set_string 14.3 ns 14.3 ns 48854344 -bm_rtl::method____ErasedTargetType::set_string 14.5 ns 14.5 ns 47526683 -bm_rtl::method____ErasedTargetAndReturnType::set_string 14.4 ns 14.4 ns 48356248 +bm_rtl::function__ErasedReturnType::set_string 14.2 ns 14.2 ns 49742575 +bm_rtl::method____ErasedReturnType::set_string 13.5 ns 13.5 ns 51315601 +bm_rtl::method____ErasedTargetType::set_string 14.6 ns 14.6 ns 48287521 +bm_rtl::method____ErasedTargetAndReturnType::set_string 15.1 ns 15.1 ns 46820399 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 12.4 ns 12.4 ns 57334137 +bm_call::direct__Function::get_string 12.7 ns 12.7 ns 53727435 -bm_call::via_function_ptr__Function::get_string 12.7 ns 12.7 ns 54933363 -bm_call::via_function_ptr____Method::get_string 12.8 ns 12.8 ns 53994926 +bm_call::via_function_ptr__Function::get_string 12.5 ns 12.5 ns 56306509 +bm_call::via_function_ptr____Method::get_string 12.5 ns 12.5 ns 55548656 -bm_std::function_calls__Function::get_string 12.9 ns 12.9 ns 53790025 -bm_std::function_calls____Method::get_string 12.9 ns 12.9 ns 54509865 +bm_std::function_calls__Function::get_string 12.5 ns 12.5 ns 56331555 +bm_std::function_calls____Method::get_string 13.2 ns 13.2 ns 53912395 -bm_rtl::function_calls__Function::get_string 12.6 ns 12.6 ns 55782606 -bm_rtl::method_calls______Method::get_string 12.8 ns 12.8 ns 54696995 +bm_rtl::function_calls__Function::get_string 12.1 ns 12.1 ns 57788395 +bm_rtl::method_calls______Method::get_string 12.4 ns 12.4 ns 55455755 -bm_rtl::function__ErasedReturnType::get_string 31.7 ns 31.7 ns 22095198 -bm_rtl::method____ErasedReturnType::get_string 32.4 ns 32.3 ns 21713225 -bm_rtl::method____ErasedTargetType::get_string 22.2 ns 22.2 ns 31569734 -bm_rtl::method____ErasedTargetAndReturnType::get_string 33.1 ns 33.1 ns 21257867 +bm_rtl::function__ErasedReturnType::get_string 29.9 ns 29.9 ns 23344757 +bm_rtl::method____ErasedReturnType::get_string 30.7 ns 30.7 ns 22917165 +bm_rtl::method____ErasedTargetType::get_string 24.7 ns 24.7 ns 28207240 +bm_rtl::method____ErasedTargetAndReturnType::get_string 31.5 ns 31.5 ns 21664753 ----------------------------------- -[2025-11-04 12:18:02] >>> Run 1: workload scale = 1 +[2026-01-19 23:02:06] >>> Run 1: workload scale = 1 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 1 iterations ============================================= -2025-11-04T12:18:02+05:30 +2026-01-19T23:02:06+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2640.13 MHz CPU s) +Run on (16 X 822.243 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.09, 1.07, 0.85 +Load Average: 1.00, 0.81, 0.57 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 24.9 ns 24.9 ns 28022770 +bm_call::direct__Function::set_string 22.9 ns 22.9 ns 30455310 -bm_call::via_function_ptr__Function::set_string 25.9 ns 25.9 ns 26967330 -bm_call::via_function_ptr____Method::set_string 25.9 ns 25.9 ns 27132859 +bm_call::via_function_ptr__Function::set_string 23.3 ns 23.3 ns 29973903 +bm_call::via_function_ptr____Method::set_string 24.4 ns 24.4 ns 28682167 -bm_std::function_calls__Function::set_string 26.4 ns 26.4 ns 26707120 -bm_std::function_calls____Method::set_string 27.0 ns 27.0 ns 25364124 +bm_std::function_calls__Function::set_string 24.4 ns 24.4 ns 28786177 +bm_std::function_calls____Method::set_string 24.1 ns 24.1 ns 29498356 -bm_rtl::function_calls__Function::set_string 26.5 ns 26.5 ns 26552439 -bm_rtl::method_calls______Method::set_string 26.6 ns 26.6 ns 26210950 +bm_rtl::function_calls__Function::set_string 23.5 ns 23.5 ns 29535454 +bm_rtl::method_calls______Method::set_string 24.1 ns 24.1 ns 28929366 -bm_rtl::function__ErasedReturnType::set_string 28.3 ns 28.3 ns 24736980 -bm_rtl::method____ErasedReturnType::set_string 30.2 ns 30.2 ns 23375542 -bm_rtl::method____ErasedTargetType::set_string 30.6 ns 30.6 ns 22925732 -bm_rtl::method____ErasedTargetAndReturnType::set_string 30.2 ns 30.2 ns 23200080 +bm_rtl::function__ErasedReturnType::set_string 27.7 ns 27.7 ns 25356353 +bm_rtl::method____ErasedReturnType::set_string 28.0 ns 28.0 ns 25219914 +bm_rtl::method____ErasedTargetType::set_string 28.7 ns 28.7 ns 24158357 +bm_rtl::method____ErasedTargetAndReturnType::set_string 29.2 ns 29.2 ns 24256140 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 48.3 ns 48.3 ns 15089307 +bm_call::direct__Function::get_string 45.3 ns 45.3 ns 15459028 -bm_call::via_function_ptr__Function::get_string 46.2 ns 46.2 ns 14395666 -bm_call::via_function_ptr____Method::get_string 46.4 ns 46.4 ns 15068891 +bm_call::via_function_ptr__Function::get_string 44.7 ns 44.6 ns 15646357 +bm_call::via_function_ptr____Method::get_string 45.3 ns 45.3 ns 15492658 -bm_std::function_calls__Function::get_string 47.4 ns 47.4 ns 14709171 -bm_std::function_calls____Method::get_string 47.0 ns 47.0 ns 14929156 +bm_std::function_calls__Function::get_string 45.6 ns 45.6 ns 15370690 +bm_std::function_calls____Method::get_string 46.9 ns 46.9 ns 14968996 -bm_rtl::function_calls__Function::get_string 47.2 ns 47.2 ns 14911798 -bm_rtl::method_calls______Method::get_string 47.4 ns 47.3 ns 14890050 +bm_rtl::function_calls__Function::get_string 45.2 ns 45.2 ns 15494849 +bm_rtl::method_calls______Method::get_string 45.7 ns 45.7 ns 15233822 -bm_rtl::function__ErasedReturnType::get_string 73.3 ns 73.3 ns 9416841 -bm_rtl::method____ErasedReturnType::get_string 74.4 ns 74.4 ns 9461511 -bm_rtl::method____ErasedTargetType::get_string 51.9 ns 51.8 ns 13545805 -bm_rtl::method____ErasedTargetAndReturnType::get_string 76.1 ns 76.1 ns 9115088 +bm_rtl::function__ErasedReturnType::get_string 59.8 ns 59.8 ns 11773379 +bm_rtl::method____ErasedReturnType::get_string 61.2 ns 61.2 ns 11420534 +bm_rtl::method____ErasedTargetType::get_string 51.6 ns 51.6 ns 13552861 +bm_rtl::method____ErasedTargetAndReturnType::get_string 61.9 ns 61.9 ns 11233344 ----------------------------------- -[2025-11-04 12:18:25] >>> Run 2: workload scale = 1 +[2026-01-19 23:02:28] >>> Run 2: workload scale = 1 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 1 iterations ============================================= -2025-11-04T12:18:25+05:30 +2026-01-19T23:02:28+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3955.49 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.19, 1.10, 0.87 +Load Average: 1.00, 0.82, 0.58 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 26.2 ns 26.2 ns 27125007 +bm_call::direct__Function::set_string 22.9 ns 22.9 ns 30573465 -bm_call::via_function_ptr__Function::set_string 27.0 ns 27.0 ns 25958094 -bm_call::via_function_ptr____Method::set_string 27.6 ns 27.6 ns 25196375 +bm_call::via_function_ptr__Function::set_string 23.3 ns 23.3 ns 30164807 +bm_call::via_function_ptr____Method::set_string 24.3 ns 24.3 ns 28476945 -bm_std::function_calls__Function::set_string 26.5 ns 26.5 ns 25360125 -bm_std::function_calls____Method::set_string 26.9 ns 26.9 ns 26002489 +bm_std::function_calls__Function::set_string 24.4 ns 24.4 ns 28790697 +bm_std::function_calls____Method::set_string 23.9 ns 23.9 ns 29364194 -bm_rtl::function_calls__Function::set_string 27.6 ns 27.6 ns 26475578 -bm_rtl::method_calls______Method::set_string 27.4 ns 27.4 ns 26001742 +bm_rtl::function_calls__Function::set_string 23.7 ns 23.7 ns 29697609 +bm_rtl::method_calls______Method::set_string 24.2 ns 24.2 ns 29116922 -bm_rtl::function__ErasedReturnType::set_string 29.0 ns 29.0 ns 24504219 -bm_rtl::method____ErasedReturnType::set_string 30.8 ns 30.8 ns 22220233 -bm_rtl::method____ErasedTargetType::set_string 32.1 ns 32.1 ns 22030367 -bm_rtl::method____ErasedTargetAndReturnType::set_string 31.5 ns 31.5 ns 21595468 +bm_rtl::function__ErasedReturnType::set_string 27.7 ns 27.7 ns 25144828 +bm_rtl::method____ErasedReturnType::set_string 27.7 ns 27.7 ns 25387533 +bm_rtl::method____ErasedTargetType::set_string 28.5 ns 28.5 ns 24641155 +bm_rtl::method____ErasedTargetAndReturnType::set_string 28.8 ns 28.8 ns 24383208 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 48.9 ns 48.9 ns 14300718 +bm_call::direct__Function::get_string 45.0 ns 45.0 ns 15538373 -bm_call::via_function_ptr__Function::get_string 47.1 ns 47.0 ns 14990892 -bm_call::via_function_ptr____Method::get_string 50.2 ns 50.2 ns 12790209 +bm_call::via_function_ptr__Function::get_string 44.7 ns 44.7 ns 15574842 +bm_call::via_function_ptr____Method::get_string 45.1 ns 45.1 ns 15547513 -bm_std::function_calls__Function::get_string 51.9 ns 51.9 ns 13535943 -bm_std::function_calls____Method::get_string 51.0 ns 51.0 ns 13266104 +bm_std::function_calls__Function::get_string 45.3 ns 45.3 ns 15505394 +bm_std::function_calls____Method::get_string 45.9 ns 45.9 ns 15301532 -bm_rtl::function_calls__Function::get_string 52.0 ns 52.0 ns 13086597 -bm_rtl::method_calls______Method::get_string 52.3 ns 52.3 ns 13161774 +bm_rtl::function_calls__Function::get_string 45.6 ns 45.6 ns 15359388 +bm_rtl::method_calls______Method::get_string 45.1 ns 45.1 ns 15555156 -bm_rtl::function__ErasedReturnType::get_string 75.2 ns 75.1 ns 9107436 -bm_rtl::method____ErasedReturnType::get_string 75.1 ns 75.1 ns 9267100 -bm_rtl::method____ErasedTargetType::get_string 55.1 ns 55.1 ns 12320961 -bm_rtl::method____ErasedTargetAndReturnType::get_string 75.8 ns 75.8 ns 8943782 +bm_rtl::function__ErasedReturnType::get_string 60.2 ns 60.2 ns 11620355 +bm_rtl::method____ErasedReturnType::get_string 61.8 ns 61.8 ns 11321576 +bm_rtl::method____ErasedTargetType::get_string 51.9 ns 51.9 ns 13385317 +bm_rtl::method____ErasedTargetAndReturnType::get_string 62.2 ns 62.2 ns 11353544 ----------------------------------- -[2025-11-04 12:18:45] >>> Run 3: workload scale = 1 +[2026-01-19 23:02:50] >>> Run 3: workload scale = 1 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 1 iterations ============================================= -2025-11-04T12:18:45+05:30 +2026-01-19T23:02:50+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3021.55 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.42, 1.16, 0.89 +Load Average: 1.00, 0.83, 0.59 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 25.8 ns 25.8 ns 26976208 +bm_call::direct__Function::set_string 22.9 ns 22.9 ns 30171191 -bm_call::via_function_ptr__Function::set_string 26.2 ns 26.2 ns 26667714 -bm_call::via_function_ptr____Method::set_string 25.9 ns 25.9 ns 26622049 +bm_call::via_function_ptr__Function::set_string 23.3 ns 23.3 ns 30353005 +bm_call::via_function_ptr____Method::set_string 24.1 ns 24.1 ns 28744923 -bm_std::function_calls__Function::set_string 26.5 ns 26.5 ns 26580719 -bm_std::function_calls____Method::set_string 26.5 ns 26.5 ns 26123278 +bm_std::function_calls__Function::set_string 24.3 ns 24.3 ns 28783840 +bm_std::function_calls____Method::set_string 23.9 ns 23.9 ns 29180247 -bm_rtl::function_calls__Function::set_string 26.5 ns 26.5 ns 26879045 -bm_rtl::method_calls______Method::set_string 26.9 ns 26.9 ns 25596201 +bm_rtl::function_calls__Function::set_string 23.5 ns 23.5 ns 29891004 +bm_rtl::method_calls______Method::set_string 23.9 ns 23.9 ns 28932461 -bm_rtl::function__ErasedReturnType::set_string 28.5 ns 28.5 ns 24501028 -bm_rtl::method____ErasedReturnType::set_string 29.4 ns 29.4 ns 23746741 -bm_rtl::method____ErasedTargetType::set_string 30.3 ns 30.3 ns 23247708 -bm_rtl::method____ErasedTargetAndReturnType::set_string 29.8 ns 29.7 ns 23353452 +bm_rtl::function__ErasedReturnType::set_string 27.7 ns 27.7 ns 25245560 +bm_rtl::method____ErasedReturnType::set_string 27.6 ns 27.6 ns 24913705 +bm_rtl::method____ErasedTargetType::set_string 28.9 ns 28.9 ns 24395606 +bm_rtl::method____ErasedTargetAndReturnType::set_string 28.9 ns 28.9 ns 23972582 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 50.2 ns 50.2 ns 13814456 +bm_call::direct__Function::get_string 46.3 ns 46.3 ns 15148491 -bm_call::via_function_ptr__Function::get_string 50.3 ns 50.3 ns 13214574 -bm_call::via_function_ptr____Method::get_string 50.3 ns 50.3 ns 13867447 +bm_call::via_function_ptr__Function::get_string 45.8 ns 45.8 ns 15294280 +bm_call::via_function_ptr____Method::get_string 46.0 ns 46.0 ns 15228762 -bm_std::function_calls__Function::get_string 51.4 ns 51.4 ns 13700559 -bm_std::function_calls____Method::get_string 50.8 ns 50.8 ns 12953501 +bm_std::function_calls__Function::get_string 47.0 ns 47.0 ns 14879735 +bm_std::function_calls____Method::get_string 47.1 ns 47.1 ns 14831304 -bm_rtl::function_calls__Function::get_string 51.3 ns 51.2 ns 13527958 -bm_rtl::method_calls______Method::get_string 51.4 ns 51.4 ns 13420354 +bm_rtl::function_calls__Function::get_string 46.6 ns 46.6 ns 15034283 +bm_rtl::method_calls______Method::get_string 46.6 ns 46.6 ns 15014229 -bm_rtl::function__ErasedReturnType::get_string 72.1 ns 72.1 ns 9577905 -bm_rtl::method____ErasedReturnType::get_string 73.4 ns 73.4 ns 9418802 -bm_rtl::method____ErasedTargetType::get_string 52.8 ns 52.8 ns 12881319 -bm_rtl::method____ErasedTargetAndReturnType::get_string 75.1 ns 75.1 ns 9268764 +bm_rtl::function__ErasedReturnType::get_string 60.7 ns 60.7 ns 11616969 +bm_rtl::method____ErasedReturnType::get_string 62.3 ns 62.3 ns 11216128 +bm_rtl::method____ErasedTargetType::get_string 52.1 ns 52.1 ns 13440738 +bm_rtl::method____ErasedTargetAndReturnType::get_string 63.0 ns 62.9 ns 11210745 ----------------------------------- -[2025-11-04 12:19:05] >>> Run 1: workload scale = 5 +[2026-01-19 23:03:13] >>> Run 1: workload scale = 5 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 5 iterations ============================================= -2025-11-04T12:19:05+05:30 +2026-01-19T23:03:13+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1832.76 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.51, 1.19, 0.91 +Load Average: 1.00, 0.85, 0.60 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 109 ns 109 ns 6356905 +bm_call::direct__Function::set_string 114 ns 114 ns 6150689 -bm_call::via_function_ptr__Function::set_string 110 ns 110 ns 6362958 -bm_call::via_function_ptr____Method::set_string 110 ns 110 ns 6337180 +bm_call::via_function_ptr__Function::set_string 115 ns 115 ns 6120408 +bm_call::via_function_ptr____Method::set_string 114 ns 114 ns 6096091 -bm_std::function_calls__Function::set_string 112 ns 112 ns 6271505 -bm_std::function_calls____Method::set_string 111 ns 111 ns 6267824 +bm_std::function_calls__Function::set_string 115 ns 115 ns 6153189 +bm_std::function_calls____Method::set_string 114 ns 114 ns 6142978 -bm_rtl::function_calls__Function::set_string 111 ns 111 ns 6287188 -bm_rtl::method_calls______Method::set_string 111 ns 111 ns 6263824 +bm_rtl::function_calls__Function::set_string 114 ns 114 ns 6186381 +bm_rtl::method_calls______Method::set_string 114 ns 114 ns 6147215 -bm_rtl::function__ErasedReturnType::set_string 114 ns 114 ns 6107867 -bm_rtl::method____ErasedReturnType::set_string 114 ns 114 ns 6126524 -bm_rtl::method____ErasedTargetType::set_string 115 ns 115 ns 6078615 -bm_rtl::method____ErasedTargetAndReturnType::set_string 114 ns 114 ns 6060333 +bm_rtl::function__ErasedReturnType::set_string 117 ns 117 ns 6004976 +bm_rtl::method____ErasedReturnType::set_string 116 ns 116 ns 6002059 +bm_rtl::method____ErasedTargetType::set_string 118 ns 118 ns 5952044 +bm_rtl::method____ErasedTargetAndReturnType::set_string 118 ns 118 ns 5904788 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 211 ns 211 ns 3302773 +bm_call::direct__Function::get_string 185 ns 185 ns 3776514 -bm_call::via_function_ptr__Function::get_string 212 ns 212 ns 3300130 -bm_call::via_function_ptr____Method::get_string 213 ns 213 ns 3269215 +bm_call::via_function_ptr__Function::get_string 185 ns 185 ns 3774660 +bm_call::via_function_ptr____Method::get_string 191 ns 191 ns 3675448 -bm_std::function_calls__Function::get_string 212 ns 212 ns 3289700 -bm_std::function_calls____Method::get_string 212 ns 212 ns 3283718 +bm_std::function_calls__Function::get_string 186 ns 186 ns 3765692 +bm_std::function_calls____Method::get_string 189 ns 189 ns 3699608 -bm_rtl::function_calls__Function::get_string 213 ns 213 ns 3282782 -bm_rtl::method_calls______Method::get_string 214 ns 214 ns 3260274 +bm_rtl::function_calls__Function::get_string 185 ns 185 ns 3767600 +bm_rtl::method_calls______Method::get_string 188 ns 188 ns 3713718 -bm_rtl::function__ErasedReturnType::get_string 267 ns 267 ns 2625824 -bm_rtl::method____ErasedReturnType::get_string 268 ns 268 ns 2609629 -bm_rtl::method____ErasedTargetType::get_string 218 ns 218 ns 3204239 -bm_rtl::method____ErasedTargetAndReturnType::get_string 269 ns 269 ns 2603345 +bm_rtl::function__ErasedReturnType::get_string 200 ns 200 ns 3517235 +bm_rtl::method____ErasedReturnType::get_string 201 ns 201 ns 3490550 +bm_rtl::method____ErasedTargetType::get_string 194 ns 194 ns 3621561 +bm_rtl::method____ErasedTargetAndReturnType::get_string 201 ns 201 ns 3473829 ----------------------------------- -[2025-11-04 12:19:24] >>> Run 2: workload scale = 5 +[2026-01-19 23:03:32] >>> Run 2: workload scale = 5 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 5 iterations ============================================= -2025-11-04T12:19:24+05:30 +2026-01-19T23:03:32+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4801.49 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.40, 1.18, 0.92 +Load Average: 1.00, 0.86, 0.61 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 110 ns 110 ns 6254342 +bm_call::direct__Function::set_string 115 ns 115 ns 6101534 -bm_call::via_function_ptr__Function::set_string 111 ns 111 ns 6127808 -bm_call::via_function_ptr____Method::set_string 110 ns 110 ns 6215491 +bm_call::via_function_ptr__Function::set_string 114 ns 114 ns 6087851 +bm_call::via_function_ptr____Method::set_string 114 ns 114 ns 6121086 -bm_std::function_calls__Function::set_string 112 ns 112 ns 6194003 -bm_std::function_calls____Method::set_string 112 ns 112 ns 6253000 +bm_std::function_calls__Function::set_string 115 ns 115 ns 6129096 +bm_std::function_calls____Method::set_string 115 ns 115 ns 6110410 -bm_rtl::function_calls__Function::set_string 111 ns 111 ns 6277966 -bm_rtl::method_calls______Method::set_string 110 ns 110 ns 6335238 +bm_rtl::function_calls__Function::set_string 114 ns 114 ns 6138724 +bm_rtl::method_calls______Method::set_string 114 ns 114 ns 6128080 -bm_rtl::function__ErasedReturnType::set_string 113 ns 113 ns 6173358 -bm_rtl::method____ErasedReturnType::set_string 113 ns 113 ns 6189036 -bm_rtl::method____ErasedTargetType::set_string 114 ns 114 ns 6088778 -bm_rtl::method____ErasedTargetAndReturnType::set_string 114 ns 114 ns 6097107 +bm_rtl::function__ErasedReturnType::set_string 121 ns 121 ns 5790978 +bm_rtl::method____ErasedReturnType::set_string 121 ns 121 ns 5753753 +bm_rtl::method____ErasedTargetType::set_string 123 ns 123 ns 5694073 +bm_rtl::method____ErasedTargetAndReturnType::set_string 121 ns 121 ns 5768724 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 190 ns 190 ns 3679128 +bm_call::direct__Function::get_string 211 ns 211 ns 3322602 -bm_call::via_function_ptr__Function::get_string 190 ns 190 ns 3672961 -bm_call::via_function_ptr____Method::get_string 190 ns 190 ns 3680081 +bm_call::via_function_ptr__Function::get_string 212 ns 212 ns 3302320 +bm_call::via_function_ptr____Method::get_string 214 ns 214 ns 3267708 -bm_std::function_calls__Function::get_string 189 ns 189 ns 3685674 -bm_std::function_calls____Method::get_string 189 ns 189 ns 3697261 +bm_std::function_calls__Function::get_string 212 ns 212 ns 3300344 +bm_std::function_calls____Method::get_string 213 ns 213 ns 3296294 -bm_rtl::function_calls__Function::get_string 190 ns 190 ns 3690621 -bm_rtl::method_calls______Method::get_string 190 ns 190 ns 3685585 +bm_rtl::function_calls__Function::get_string 211 ns 211 ns 3312103 +bm_rtl::method_calls______Method::get_string 212 ns 212 ns 3289616 -bm_rtl::function__ErasedReturnType::get_string 242 ns 242 ns 2896462 -bm_rtl::method____ErasedReturnType::get_string 240 ns 240 ns 2919692 -bm_rtl::method____ErasedTargetType::get_string 195 ns 195 ns 3598721 -bm_rtl::method____ErasedTargetAndReturnType::get_string 242 ns 242 ns 2896405 +bm_rtl::function__ErasedReturnType::get_string 224 ns 224 ns 3138855 +bm_rtl::method____ErasedReturnType::get_string 224 ns 224 ns 3109100 +bm_rtl::method____ErasedTargetType::get_string 220 ns 220 ns 3186412 +bm_rtl::method____ErasedTargetAndReturnType::get_string 224 ns 224 ns 3125628 ----------------------------------- -[2025-11-04 12:19:44] >>> Run 3: workload scale = 5 +[2026-01-19 23:03:51] >>> Run 3: workload scale = 5 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 5 iterations ============================================= -2025-11-04T12:19:44+05:30 +2026-01-19T23:03:51+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2019.39 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.28, 1.17, 0.92 +Load Average: 1.00, 0.87, 0.62 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 109 ns 109 ns 6366490 +bm_call::direct__Function::set_string 114 ns 114 ns 6132649 -bm_call::via_function_ptr__Function::set_string 110 ns 110 ns 6364151 -bm_call::via_function_ptr____Method::set_string 110 ns 110 ns 6358758 +bm_call::via_function_ptr__Function::set_string 114 ns 114 ns 6142191 +bm_call::via_function_ptr____Method::set_string 114 ns 114 ns 6141152 -bm_std::function_calls__Function::set_string 111 ns 111 ns 6296215 -bm_std::function_calls____Method::set_string 111 ns 111 ns 6318768 +bm_std::function_calls__Function::set_string 115 ns 115 ns 6068904 +bm_std::function_calls____Method::set_string 115 ns 115 ns 6098069 -bm_rtl::function_calls__Function::set_string 110 ns 110 ns 6318789 -bm_rtl::method_calls______Method::set_string 110 ns 110 ns 6326380 +bm_rtl::function_calls__Function::set_string 113 ns 113 ns 6166440 +bm_rtl::method_calls______Method::set_string 114 ns 114 ns 6132392 -bm_rtl::function__ErasedReturnType::set_string 113 ns 113 ns 6147018 -bm_rtl::method____ErasedReturnType::set_string 113 ns 113 ns 6162989 -bm_rtl::method____ErasedTargetType::set_string 115 ns 115 ns 5940721 -bm_rtl::method____ErasedTargetAndReturnType::set_string 114 ns 114 ns 6084423 +bm_rtl::function__ErasedReturnType::set_string 117 ns 117 ns 5984139 +bm_rtl::method____ErasedReturnType::set_string 117 ns 117 ns 6008851 +bm_rtl::method____ErasedTargetType::set_string 118 ns 118 ns 5935050 +bm_rtl::method____ErasedTargetAndReturnType::set_string 119 ns 119 ns 5906698 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 191 ns 191 ns 3678026 +bm_call::direct__Function::get_string 214 ns 214 ns 3274422 -bm_call::via_function_ptr__Function::get_string 191 ns 191 ns 3666456 -bm_call::via_function_ptr____Method::get_string 191 ns 191 ns 3666182 +bm_call::via_function_ptr__Function::get_string 214 ns 214 ns 3221626 +bm_call::via_function_ptr____Method::get_string 217 ns 217 ns 3219416 -bm_std::function_calls__Function::get_string 190 ns 190 ns 3676735 -bm_std::function_calls____Method::get_string 190 ns 190 ns 3679305 +bm_std::function_calls__Function::get_string 215 ns 215 ns 3258831 +bm_std::function_calls____Method::get_string 216 ns 215 ns 3248424 -bm_rtl::function_calls__Function::get_string 191 ns 190 ns 3683024 -bm_rtl::method_calls______Method::get_string 191 ns 191 ns 3674662 +bm_rtl::function_calls__Function::get_string 215 ns 215 ns 3128220 +bm_rtl::method_calls______Method::get_string 215 ns 215 ns 3238895 -bm_rtl::function__ErasedReturnType::get_string 242 ns 242 ns 2882786 -bm_rtl::method____ErasedReturnType::get_string 241 ns 241 ns 2911958 -bm_rtl::method____ErasedTargetType::get_string 196 ns 196 ns 3581200 -bm_rtl::method____ErasedTargetAndReturnType::get_string 243 ns 243 ns 2882409 +bm_rtl::function__ErasedReturnType::get_string 225 ns 225 ns 3133131 +bm_rtl::method____ErasedReturnType::get_string 225 ns 225 ns 3107999 +bm_rtl::method____ErasedTargetType::get_string 222 ns 222 ns 3153094 +bm_rtl::method____ErasedTargetAndReturnType::get_string 225 ns 225 ns 3109784 ----------------------------------- -[2025-11-04 12:20:03] >>> Run 1: workload scale = 10 +[2026-01-19 23:04:11] >>> Run 1: workload scale = 10 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 10 iterations ============================================= -2025-11-04T12:20:03+05:30 +2026-01-19T23:04:11+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3993.12 MHz CPU s) +Run on (16 X 800.325 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.20, 1.16, 0.92 +Load Average: 1.00, 0.88, 0.63 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 187 ns 187 ns 3726311 +bm_call::direct__Function::set_string 184 ns 184 ns 3777733 -bm_call::via_function_ptr__Function::set_string 188 ns 188 ns 3744673 -bm_call::via_function_ptr____Method::set_string 188 ns 188 ns 3735227 +bm_call::via_function_ptr__Function::set_string 184 ns 184 ns 3785782 +bm_call::via_function_ptr____Method::set_string 184 ns 184 ns 3807719 -bm_std::function_calls__Function::set_string 188 ns 188 ns 3718232 -bm_std::function_calls____Method::set_string 188 ns 188 ns 3712163 +bm_std::function_calls__Function::set_string 184 ns 184 ns 3814668 +bm_std::function_calls____Method::set_string 184 ns 184 ns 3809985 -bm_rtl::function_calls__Function::set_string 188 ns 188 ns 3719395 -bm_rtl::method_calls______Method::set_string 188 ns 188 ns 3708975 +bm_rtl::function_calls__Function::set_string 184 ns 184 ns 3817093 +bm_rtl::method_calls______Method::set_string 184 ns 184 ns 3818075 -bm_rtl::function__ErasedReturnType::set_string 192 ns 192 ns 3644143 -bm_rtl::method____ErasedReturnType::set_string 192 ns 192 ns 3646885 -bm_rtl::method____ErasedTargetType::set_string 193 ns 193 ns 3651118 -bm_rtl::method____ErasedTargetAndReturnType::set_string 194 ns 194 ns 3617474 +bm_rtl::function__ErasedReturnType::set_string 189 ns 189 ns 3698101 +bm_rtl::method____ErasedReturnType::set_string 188 ns 188 ns 3734841 +bm_rtl::method____ErasedTargetType::set_string 189 ns 189 ns 3697316 +bm_rtl::method____ErasedTargetAndReturnType::set_string 188 ns 188 ns 3720922 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 358 ns 358 ns 1956467 +bm_call::direct__Function::get_string 299 ns 299 ns 2330036 -bm_call::via_function_ptr__Function::get_string 349 ns 349 ns 2006340 -bm_call::via_function_ptr____Method::get_string 351 ns 351 ns 2002609 +bm_call::via_function_ptr__Function::get_string 298 ns 298 ns 2348216 +bm_call::via_function_ptr____Method::get_string 298 ns 298 ns 2337354 -bm_std::function_calls__Function::get_string 348 ns 348 ns 2008102 -bm_std::function_calls____Method::get_string 349 ns 349 ns 2011577 +bm_std::function_calls__Function::get_string 299 ns 299 ns 2334440 +bm_std::function_calls____Method::get_string 299 ns 299 ns 2335303 -bm_rtl::function_calls__Function::get_string 348 ns 348 ns 2010126 -bm_rtl::method_calls______Method::get_string 349 ns 349 ns 2004066 +bm_rtl::function_calls__Function::get_string 297 ns 297 ns 2353177 +bm_rtl::method_calls______Method::get_string 299 ns 299 ns 2342282 -bm_rtl::function__ErasedReturnType::get_string 426 ns 426 ns 1643422 -bm_rtl::method____ErasedReturnType::get_string 430 ns 430 ns 1629089 -bm_rtl::method____ErasedTargetType::get_string 353 ns 353 ns 1979505 -bm_rtl::method____ErasedTargetAndReturnType::get_string 429 ns 428 ns 1635028 +bm_rtl::function__ErasedReturnType::get_string 311 ns 311 ns 2252004 +bm_rtl::method____ErasedReturnType::get_string 313 ns 313 ns 2236406 +bm_rtl::method____ErasedTargetType::get_string 305 ns 305 ns 2299083 +bm_rtl::method____ErasedTargetAndReturnType::get_string 312 ns 312 ns 2244346 ----------------------------------- -[2025-11-04 12:20:25] >>> Run 2: workload scale = 10 +[2026-01-19 23:04:32] >>> Run 2: workload scale = 10 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 10 iterations ============================================= -2025-11-04T12:20:25+05:30 +2026-01-19T23:04:32+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2840.4 MHz CPU s) +Run on (16 X 4758.38 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.13, 1.14, 0.92 +Load Average: 1.00, 0.89, 0.64 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 177 ns 177 ns 3940952 +bm_call::direct__Function::set_string 184 ns 184 ns 3819930 -bm_call::via_function_ptr__Function::set_string 178 ns 178 ns 3934929 -bm_call::via_function_ptr____Method::set_string 178 ns 178 ns 3932855 +bm_call::via_function_ptr__Function::set_string 177 ns 177 ns 3948053 +bm_call::via_function_ptr____Method::set_string 177 ns 177 ns 3922201 -bm_std::function_calls__Function::set_string 179 ns 178 ns 3927235 -bm_std::function_calls____Method::set_string 183 ns 183 ns 3673773 +bm_std::function_calls__Function::set_string 178 ns 178 ns 3939696 +bm_std::function_calls____Method::set_string 178 ns 178 ns 3950022 -bm_rtl::function_calls__Function::set_string 180 ns 180 ns 3868708 -bm_rtl::method_calls______Method::set_string 180 ns 180 ns 3907622 +bm_rtl::function_calls__Function::set_string 177 ns 177 ns 3928694 +bm_rtl::method_calls______Method::set_string 178 ns 177 ns 3953717 -bm_rtl::function__ErasedReturnType::set_string 183 ns 183 ns 3861068 -bm_rtl::method____ErasedReturnType::set_string 180 ns 180 ns 3885727 -bm_rtl::method____ErasedTargetType::set_string 183 ns 183 ns 3796810 -bm_rtl::method____ErasedTargetAndReturnType::set_string 183 ns 183 ns 3820688 +bm_rtl::function__ErasedReturnType::set_string 180 ns 180 ns 3888139 +bm_rtl::method____ErasedReturnType::set_string 180 ns 180 ns 3885087 +bm_rtl::method____ErasedTargetType::set_string 183 ns 183 ns 3845699 +bm_rtl::method____ErasedTargetAndReturnType::set_string 181 ns 181 ns 3875406 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 319 ns 319 ns 2203411 +bm_call::direct__Function::get_string 294 ns 294 ns 2384603 -bm_call::via_function_ptr__Function::get_string 310 ns 310 ns 2263612 -bm_call::via_function_ptr____Method::get_string 312 ns 312 ns 2254295 +bm_call::via_function_ptr__Function::get_string 293 ns 293 ns 2393415 +bm_call::via_function_ptr____Method::get_string 293 ns 293 ns 2391860 -bm_std::function_calls__Function::get_string 311 ns 311 ns 2247231 -bm_std::function_calls____Method::get_string 310 ns 310 ns 2274352 +bm_std::function_calls__Function::get_string 294 ns 294 ns 2382741 +bm_std::function_calls____Method::get_string 293 ns 293 ns 2385674 -bm_rtl::function_calls__Function::get_string 314 ns 314 ns 2259091 -bm_rtl::method_calls______Method::get_string 315 ns 315 ns 2266882 +bm_rtl::function_calls__Function::get_string 292 ns 292 ns 2397954 +bm_rtl::method_calls______Method::get_string 293 ns 293 ns 2395882 -bm_rtl::function__ErasedReturnType::get_string 381 ns 381 ns 1843706 -bm_rtl::method____ErasedReturnType::get_string 382 ns 382 ns 1846973 -bm_rtl::method____ErasedTargetType::get_string 316 ns 316 ns 2213949 -bm_rtl::method____ErasedTargetAndReturnType::get_string 381 ns 381 ns 1843965 +bm_rtl::function__ErasedReturnType::get_string 307 ns 307 ns 2281723 +bm_rtl::method____ErasedReturnType::get_string 309 ns 309 ns 2272152 +bm_rtl::method____ErasedTargetType::get_string 299 ns 299 ns 2340064 +bm_rtl::method____ErasedTargetAndReturnType::get_string 307 ns 307 ns 2281982 ----------------------------------- -[2025-11-04 12:20:47] >>> Run 3: workload scale = 10 +[2026-01-19 23:04:53] >>> Run 3: workload scale = 10 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 10 iterations ============================================= -2025-11-04T12:20:47+05:30 +2026-01-19T23:04:53+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2572.05 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.25, 1.17, 0.93 +Load Average: 1.11, 0.93, 0.66 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 178 ns 178 ns 3900950 +bm_call::direct__Function::set_string 183 ns 183 ns 3824216 -bm_call::via_function_ptr__Function::set_string 180 ns 180 ns 3879189 -bm_call::via_function_ptr____Method::set_string 179 ns 179 ns 3834422 +bm_call::via_function_ptr__Function::set_string 178 ns 178 ns 3959660 +bm_call::via_function_ptr____Method::set_string 177 ns 177 ns 3948511 -bm_std::function_calls__Function::set_string 179 ns 179 ns 3920381 -bm_std::function_calls____Method::set_string 180 ns 180 ns 3891620 +bm_std::function_calls__Function::set_string 177 ns 177 ns 3967769 +bm_std::function_calls____Method::set_string 179 ns 179 ns 3900356 -bm_rtl::function_calls__Function::set_string 181 ns 181 ns 3872767 -bm_rtl::method_calls______Method::set_string 180 ns 180 ns 3910455 +bm_rtl::function_calls__Function::set_string 178 ns 178 ns 3918698 +bm_rtl::method_calls______Method::set_string 179 ns 179 ns 3899680 -bm_rtl::function__ErasedReturnType::set_string 182 ns 182 ns 3832558 -bm_rtl::method____ErasedReturnType::set_string 181 ns 181 ns 3885287 -bm_rtl::method____ErasedTargetType::set_string 185 ns 185 ns 3776004 -bm_rtl::method____ErasedTargetAndReturnType::set_string 183 ns 183 ns 3823404 +bm_rtl::function__ErasedReturnType::set_string 181 ns 181 ns 3851517 +bm_rtl::method____ErasedReturnType::set_string 180 ns 180 ns 3878815 +bm_rtl::method____ErasedTargetType::set_string 181 ns 181 ns 3889425 +bm_rtl::method____ErasedTargetAndReturnType::set_string 181 ns 181 ns 3881658 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 320 ns 320 ns 2191852 +bm_call::direct__Function::get_string 296 ns 296 ns 2366399 -bm_call::via_function_ptr__Function::get_string 311 ns 311 ns 2255298 -bm_call::via_function_ptr____Method::get_string 314 ns 314 ns 2234056 +bm_call::via_function_ptr__Function::get_string 295 ns 295 ns 2374439 +bm_call::via_function_ptr____Method::get_string 294 ns 294 ns 2384224 -bm_std::function_calls__Function::get_string 313 ns 313 ns 2230322 -bm_std::function_calls____Method::get_string 313 ns 313 ns 2216167 +bm_std::function_calls__Function::get_string 295 ns 295 ns 2364076 +bm_std::function_calls____Method::get_string 294 ns 294 ns 2370526 -bm_rtl::function_calls__Function::get_string 355 ns 355 ns 2009288 -bm_rtl::method_calls______Method::get_string 323 ns 323 ns 1912946 +bm_rtl::function_calls__Function::get_string 294 ns 294 ns 2385620 +bm_rtl::method_calls______Method::get_string 293 ns 293 ns 2389281 -bm_rtl::function__ErasedReturnType::get_string 384 ns 384 ns 1824265 -bm_rtl::method____ErasedReturnType::get_string 384 ns 384 ns 1808329 -bm_rtl::method____ErasedTargetType::get_string 321 ns 321 ns 2143924 -bm_rtl::method____ErasedTargetAndReturnType::get_string 385 ns 385 ns 1808807 +bm_rtl::function__ErasedReturnType::get_string 307 ns 307 ns 2278302 +bm_rtl::method____ErasedReturnType::get_string 308 ns 308 ns 2271193 +bm_rtl::method____ErasedTargetType::get_string 299 ns 299 ns 2343702 +bm_rtl::method____ErasedTargetAndReturnType::get_string 306 ns 306 ns 2283153 ----------------------------------- -[2025-11-04 12:21:09] >>> Run 1: workload scale = 15 +[2026-01-19 23:05:15] >>> Run 1: workload scale = 15 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 15 iterations ============================================= -2025-11-04T12:21:09+05:30 +2026-01-19T23:05:15+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4900 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.18, 1.16, 0.94 +Load Average: 1.08, 0.93, 0.67 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 208 ns 208 ns 3354887 +bm_call::direct__Function::set_string 226 ns 226 ns 3089610 -bm_call::via_function_ptr__Function::set_string 209 ns 209 ns 3348189 -bm_call::via_function_ptr____Method::set_string 214 ns 214 ns 3338144 +bm_call::via_function_ptr__Function::set_string 222 ns 222 ns 3153870 +bm_call::via_function_ptr____Method::set_string 221 ns 221 ns 3175215 -bm_std::function_calls__Function::set_string 210 ns 210 ns 3356079 -bm_std::function_calls____Method::set_string 209 ns 209 ns 3352077 +bm_std::function_calls__Function::set_string 223 ns 223 ns 3117008 +bm_std::function_calls____Method::set_string 220 ns 220 ns 3173515 -bm_rtl::function_calls__Function::set_string 211 ns 211 ns 3317584 -bm_rtl::method_calls______Method::set_string 209 ns 209 ns 3338550 +bm_rtl::function_calls__Function::set_string 220 ns 220 ns 3194400 +bm_rtl::method_calls______Method::set_string 220 ns 220 ns 3140247 -bm_rtl::function__ErasedReturnType::set_string 212 ns 212 ns 3325113 -bm_rtl::method____ErasedReturnType::set_string 216 ns 216 ns 3217407 -bm_rtl::method____ErasedTargetType::set_string 212 ns 212 ns 3296378 -bm_rtl::method____ErasedTargetAndReturnType::set_string 210 ns 210 ns 3347149 +bm_rtl::function__ErasedReturnType::set_string 222 ns 222 ns 3147549 +bm_rtl::method____ErasedReturnType::set_string 225 ns 225 ns 3142824 +bm_rtl::method____ErasedTargetType::set_string 224 ns 224 ns 3124349 +bm_rtl::method____ErasedTargetAndReturnType::set_string 222 ns 222 ns 3152685 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 383 ns 383 ns 1835016 +bm_call::direct__Function::get_string 409 ns 409 ns 1709662 -bm_call::via_function_ptr__Function::get_string 381 ns 381 ns 1842308 -bm_call::via_function_ptr____Method::get_string 383 ns 383 ns 1831574 +bm_call::via_function_ptr__Function::get_string 408 ns 408 ns 1719343 +bm_call::via_function_ptr____Method::get_string 408 ns 408 ns 1714648 -bm_std::function_calls__Function::get_string 395 ns 395 ns 1761881 -bm_std::function_calls____Method::get_string 387 ns 387 ns 1804570 +bm_std::function_calls__Function::get_string 409 ns 409 ns 1709610 +bm_std::function_calls____Method::get_string 410 ns 410 ns 1708052 -bm_rtl::function_calls__Function::get_string 383 ns 383 ns 1817991 -bm_rtl::method_calls______Method::get_string 385 ns 385 ns 1823692 +bm_rtl::function_calls__Function::get_string 407 ns 407 ns 1684885 +bm_rtl::method_calls______Method::get_string 407 ns 407 ns 1716993 -bm_rtl::function__ErasedReturnType::get_string 461 ns 461 ns 1524833 -bm_rtl::method____ErasedReturnType::get_string 463 ns 463 ns 1511457 -bm_rtl::method____ErasedTargetType::get_string 390 ns 390 ns 1795845 -bm_rtl::method____ErasedTargetAndReturnType::get_string 462 ns 462 ns 1515668 +bm_rtl::function__ErasedReturnType::get_string 420 ns 420 ns 1665371 +bm_rtl::method____ErasedReturnType::get_string 420 ns 420 ns 1663095 +bm_rtl::method____ErasedTargetType::get_string 416 ns 416 ns 1683688 +bm_rtl::method____ErasedTargetAndReturnType::get_string 422 ns 422 ns 1657701 ----------------------------------- -[2025-11-04 12:21:31] >>> Run 2: workload scale = 15 +[2026-01-19 23:05:38] >>> Run 2: workload scale = 15 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 15 iterations ============================================= -2025-11-04T12:21:31+05:30 +2026-01-19T23:05:38+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3073.18 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.19, 1.16, 0.94 +Load Average: 1.05, 0.94, 0.67 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 210 ns 210 ns 3340652 +bm_call::direct__Function::set_string 215 ns 215 ns 3251791 -bm_call::via_function_ptr__Function::set_string 211 ns 211 ns 3324856 -bm_call::via_function_ptr____Method::set_string 211 ns 211 ns 3310404 +bm_call::via_function_ptr__Function::set_string 215 ns 215 ns 3250360 +bm_call::via_function_ptr____Method::set_string 216 ns 216 ns 3245971 -bm_std::function_calls__Function::set_string 212 ns 212 ns 3308725 -bm_std::function_calls____Method::set_string 212 ns 212 ns 3287037 +bm_std::function_calls__Function::set_string 215 ns 215 ns 3263158 +bm_std::function_calls____Method::set_string 216 ns 216 ns 3214634 -bm_rtl::function_calls__Function::set_string 212 ns 212 ns 3314574 -bm_rtl::method_calls______Method::set_string 212 ns 212 ns 3283145 +bm_rtl::function_calls__Function::set_string 217 ns 217 ns 3235199 +bm_rtl::method_calls______Method::set_string 216 ns 216 ns 3255549 -bm_rtl::function__ErasedReturnType::set_string 211 ns 211 ns 3341051 -bm_rtl::method____ErasedReturnType::set_string 214 ns 214 ns 3259385 -bm_rtl::method____ErasedTargetType::set_string 212 ns 212 ns 3304041 -bm_rtl::method____ErasedTargetAndReturnType::set_string 226 ns 226 ns 3085668 +bm_rtl::function__ErasedReturnType::set_string 219 ns 219 ns 3205308 +bm_rtl::method____ErasedReturnType::set_string 217 ns 217 ns 3223213 +bm_rtl::method____ErasedTargetType::set_string 218 ns 218 ns 3198103 +bm_rtl::method____ErasedTargetAndReturnType::set_string 219 ns 219 ns 3208427 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 382 ns 382 ns 1626037 +bm_call::direct__Function::get_string 389 ns 389 ns 1801150 -bm_call::via_function_ptr__Function::get_string 381 ns 381 ns 1835546 -bm_call::via_function_ptr____Method::get_string 383 ns 383 ns 1828808 +bm_call::via_function_ptr__Function::get_string 367 ns 367 ns 1906149 +bm_call::via_function_ptr____Method::get_string 366 ns 366 ns 1911347 -bm_std::function_calls__Function::get_string 387 ns 387 ns 1822200 -bm_std::function_calls____Method::get_string 393 ns 393 ns 1800319 +bm_std::function_calls__Function::get_string 367 ns 367 ns 1907044 +bm_std::function_calls____Method::get_string 368 ns 368 ns 1906042 -bm_rtl::function_calls__Function::get_string 386 ns 386 ns 1800817 -bm_rtl::method_calls______Method::get_string 384 ns 384 ns 1823455 +bm_rtl::function_calls__Function::get_string 365 ns 365 ns 1917571 +bm_rtl::method_calls______Method::get_string 366 ns 366 ns 1913051 -bm_rtl::function__ErasedReturnType::get_string 462 ns 462 ns 1519511 -bm_rtl::method____ErasedReturnType::get_string 464 ns 464 ns 1504120 -bm_rtl::method____ErasedTargetType::get_string 393 ns 393 ns 1794253 -bm_rtl::method____ErasedTargetAndReturnType::get_string 462 ns 462 ns 1497097 +bm_rtl::function__ErasedReturnType::get_string 379 ns 379 ns 1842696 +bm_rtl::method____ErasedReturnType::get_string 380 ns 380 ns 1841381 +bm_rtl::method____ErasedTargetType::get_string 372 ns 372 ns 1878324 +bm_rtl::method____ErasedTargetAndReturnType::get_string 381 ns 381 ns 1818358 ----------------------------------- -[2025-11-04 12:21:54] >>> Run 3: workload scale = 15 +[2026-01-19 23:06:00] >>> Run 3: workload scale = 15 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 15 iterations ============================================= -2025-11-04T12:21:54+05:30 +2026-01-19T23:06:00+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2736.79 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.14, 1.15, 0.95 +Load Average: 1.04, 0.95, 0.68 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 212 ns 212 ns 3300818 +bm_call::direct__Function::set_string 215 ns 215 ns 3253799 -bm_call::via_function_ptr__Function::set_string 213 ns 213 ns 3277311 -bm_call::via_function_ptr____Method::set_string 212 ns 212 ns 3300103 +bm_call::via_function_ptr__Function::set_string 216 ns 216 ns 3249440 +bm_call::via_function_ptr____Method::set_string 217 ns 217 ns 3227746 -bm_std::function_calls__Function::set_string 212 ns 212 ns 3272237 -bm_std::function_calls____Method::set_string 212 ns 212 ns 3299601 +bm_std::function_calls__Function::set_string 213 ns 213 ns 3296572 +bm_std::function_calls____Method::set_string 213 ns 213 ns 3277342 -bm_rtl::function_calls__Function::set_string 219 ns 219 ns 3298106 -bm_rtl::method_calls______Method::set_string 217 ns 217 ns 3175023 +bm_rtl::function_calls__Function::set_string 213 ns 213 ns 3280935 +bm_rtl::method_calls______Method::set_string 214 ns 214 ns 3268047 -bm_rtl::function__ErasedReturnType::set_string 228 ns 228 ns 3138094 -bm_rtl::method____ErasedReturnType::set_string 225 ns 225 ns 3093211 -bm_rtl::method____ErasedTargetType::set_string 222 ns 222 ns 3260985 -bm_rtl::method____ErasedTargetAndReturnType::set_string 225 ns 225 ns 3014027 +bm_rtl::function__ErasedReturnType::set_string 216 ns 216 ns 3252538 +bm_rtl::method____ErasedReturnType::set_string 228 ns 228 ns 3254612 +bm_rtl::method____ErasedTargetType::set_string 230 ns 230 ns 3064649 +bm_rtl::method____ErasedTargetAndReturnType::set_string 230 ns 230 ns 3026544 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 409 ns 409 ns 1704362 +bm_call::direct__Function::get_string 418 ns 418 ns 1679672 -bm_call::via_function_ptr__Function::get_string 400 ns 400 ns 1816140 -bm_call::via_function_ptr____Method::get_string 396 ns 396 ns 1710091 +bm_call::via_function_ptr__Function::get_string 413 ns 413 ns 1674254 +bm_call::via_function_ptr____Method::get_string 413 ns 413 ns 1696505 -bm_std::function_calls__Function::get_string 396 ns 396 ns 1764724 -bm_std::function_calls____Method::get_string 413 ns 413 ns 1719759 +bm_std::function_calls__Function::get_string 416 ns 416 ns 1684761 +bm_std::function_calls____Method::get_string 416 ns 416 ns 1682074 -bm_rtl::function_calls__Function::get_string 401 ns 401 ns 1722218 -bm_rtl::method_calls______Method::get_string 396 ns 395 ns 1730519 +bm_rtl::function_calls__Function::get_string 412 ns 412 ns 1697759 +bm_rtl::method_calls______Method::get_string 412 ns 412 ns 1692481 -bm_rtl::function__ErasedReturnType::get_string 494 ns 494 ns 1440837 -bm_rtl::method____ErasedReturnType::get_string 475 ns 475 ns 1396097 -bm_rtl::method____ErasedTargetType::get_string 394 ns 394 ns 1749298 -bm_rtl::method____ErasedTargetAndReturnType::get_string 462 ns 462 ns 1464101 +bm_rtl::function__ErasedReturnType::get_string 424 ns 424 ns 1652039 +bm_rtl::method____ErasedReturnType::get_string 424 ns 424 ns 1649284 +bm_rtl::method____ErasedTargetType::get_string 419 ns 419 ns 1667856 +bm_rtl::method____ErasedTargetAndReturnType::get_string 424 ns 424 ns 1650836 ----------------------------------- -[2025-11-04 12:22:17] >>> Run 1: workload scale = 20 +[2026-01-19 23:06:24] >>> Run 1: workload scale = 20 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 20 iterations ============================================= -2025-11-04T12:22:17+05:30 +2026-01-19T23:06:24+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4443.83 MHz CPU s) +Run on (16 X 4849.08 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.39, 1.20, 0.97 +Load Average: 1.02, 0.95, 0.69 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 300 ns 300 ns 2364526 +bm_call::direct__Function::set_string 291 ns 291 ns 2418278 -bm_call::via_function_ptr__Function::set_string 308 ns 308 ns 2261139 -bm_call::via_function_ptr____Method::set_string 305 ns 305 ns 2314184 +bm_call::via_function_ptr__Function::set_string 292 ns 292 ns 2424822 +bm_call::via_function_ptr____Method::set_string 286 ns 286 ns 2402039 -bm_std::function_calls__Function::set_string 304 ns 304 ns 2341024 -bm_std::function_calls____Method::set_string 289 ns 289 ns 2389222 +bm_std::function_calls__Function::set_string 287 ns 287 ns 2465734 +bm_std::function_calls____Method::set_string 291 ns 291 ns 2441376 -bm_rtl::function_calls__Function::set_string 332 ns 332 ns 2175216 -bm_rtl::method_calls______Method::set_string 322 ns 322 ns 2088936 +bm_rtl::function_calls__Function::set_string 311 ns 311 ns 2236358 +bm_rtl::method_calls______Method::set_string 311 ns 311 ns 2265730 -bm_rtl::function__ErasedReturnType::set_string 323 ns 322 ns 2146160 -bm_rtl::method____ErasedReturnType::set_string 333 ns 333 ns 2191564 -bm_rtl::method____ErasedTargetType::set_string 303 ns 303 ns 2332242 -bm_rtl::method____ErasedTargetAndReturnType::set_string 326 ns 326 ns 2345345 +bm_rtl::function__ErasedReturnType::set_string 311 ns 311 ns 2245428 +bm_rtl::method____ErasedReturnType::set_string 308 ns 308 ns 2264057 +bm_rtl::method____ErasedTargetType::set_string 311 ns 310 ns 2257890 +bm_rtl::method____ErasedTargetAndReturnType::set_string 311 ns 311 ns 2244261 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 566 ns 566 ns 1251288 +bm_call::direct__Function::get_string 590 ns 590 ns 1182058 -bm_call::via_function_ptr__Function::get_string 548 ns 548 ns 1233039 -bm_call::via_function_ptr____Method::get_string 540 ns 540 ns 1272200 +bm_call::via_function_ptr__Function::get_string 590 ns 590 ns 1185424 +bm_call::via_function_ptr____Method::get_string 590 ns 590 ns 1185900 -bm_std::function_calls__Function::get_string 541 ns 541 ns 1268122 -bm_std::function_calls____Method::get_string 543 ns 543 ns 1234772 +bm_std::function_calls__Function::get_string 593 ns 593 ns 1177543 +bm_std::function_calls____Method::get_string 596 ns 596 ns 1179929 -bm_rtl::function_calls__Function::get_string 543 ns 543 ns 1288268 -bm_rtl::method_calls______Method::get_string 546 ns 546 ns 1267151 +bm_rtl::function_calls__Function::get_string 589 ns 589 ns 1182819 +bm_rtl::method_calls______Method::get_string 589 ns 589 ns 1187964 -bm_rtl::function__ErasedReturnType::get_string 659 ns 659 ns 1057558 -bm_rtl::method____ErasedReturnType::get_string 662 ns 662 ns 1022937 -bm_rtl::method____ErasedTargetType::get_string 562 ns 562 ns 1212939 -bm_rtl::method____ErasedTargetAndReturnType::get_string 666 ns 666 ns 1049185 +bm_rtl::function__ErasedReturnType::get_string 606 ns 606 ns 1157909 +bm_rtl::method____ErasedReturnType::get_string 607 ns 607 ns 1159297 +bm_rtl::method____ErasedTargetType::get_string 600 ns 600 ns 1160673 +bm_rtl::method____ErasedTargetAndReturnType::get_string 608 ns 608 ns 1153514 ----------------------------------- -[2025-11-04 12:22:37] >>> Run 2: workload scale = 20 +[2026-01-19 23:06:43] >>> Run 2: workload scale = 20 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 20 iterations ============================================= -2025-11-04T12:22:37+05:30 +2026-01-19T23:06:43+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1913.44 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.41, 1.22, 0.98 +Load Average: 1.02, 0.95, 0.70 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 295 ns 295 ns 2334833 +bm_call::direct__Function::set_string 283 ns 283 ns 2496763 -bm_call::via_function_ptr__Function::set_string 300 ns 300 ns 2352180 -bm_call::via_function_ptr____Method::set_string 301 ns 301 ns 2293720 +bm_call::via_function_ptr__Function::set_string 284 ns 284 ns 2467014 +bm_call::via_function_ptr____Method::set_string 282 ns 282 ns 2495436 -bm_std::function_calls__Function::set_string 296 ns 296 ns 2395257 -bm_std::function_calls____Method::set_string 301 ns 301 ns 2276040 +bm_std::function_calls__Function::set_string 286 ns 286 ns 2441347 +bm_std::function_calls____Method::set_string 280 ns 280 ns 2487991 -bm_rtl::function_calls__Function::set_string 297 ns 297 ns 2345901 -bm_rtl::method_calls______Method::set_string 296 ns 296 ns 2355417 +bm_rtl::function_calls__Function::set_string 283 ns 283 ns 2469977 +bm_rtl::method_calls______Method::set_string 284 ns 284 ns 2497314 -bm_rtl::function__ErasedReturnType::set_string 295 ns 295 ns 2377750 -bm_rtl::method____ErasedReturnType::set_string 294 ns 294 ns 2351079 -bm_rtl::method____ErasedTargetType::set_string 295 ns 295 ns 2383689 -bm_rtl::method____ErasedTargetAndReturnType::set_string 296 ns 296 ns 2374165 +bm_rtl::function__ErasedReturnType::set_string 281 ns 281 ns 2483595 +bm_rtl::method____ErasedReturnType::set_string 285 ns 285 ns 2441698 +bm_rtl::method____ErasedTargetType::set_string 285 ns 285 ns 2457468 +bm_rtl::method____ErasedTargetAndReturnType::set_string 284 ns 284 ns 2472081 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 536 ns 536 ns 1301506 +bm_call::direct__Function::get_string 513 ns 513 ns 1363089 -bm_call::via_function_ptr__Function::get_string 535 ns 535 ns 1316754 -bm_call::via_function_ptr____Method::get_string 534 ns 534 ns 1293290 +bm_call::via_function_ptr__Function::get_string 513 ns 513 ns 1359811 +bm_call::via_function_ptr____Method::get_string 515 ns 515 ns 1353957 -bm_std::function_calls__Function::get_string 537 ns 536 ns 1307063 -bm_std::function_calls____Method::get_string 540 ns 540 ns 1284540 +bm_std::function_calls__Function::get_string 522 ns 522 ns 1339690 +bm_std::function_calls____Method::get_string 516 ns 516 ns 1344580 -bm_rtl::function_calls__Function::get_string 536 ns 536 ns 1287766 -bm_rtl::method_calls______Method::get_string 539 ns 539 ns 1301959 +bm_rtl::function_calls__Function::get_string 513 ns 513 ns 1367161 +bm_rtl::method_calls______Method::get_string 513 ns 513 ns 1369286 -bm_rtl::function__ErasedReturnType::get_string 641 ns 641 ns 1085182 -bm_rtl::method____ErasedReturnType::get_string 645 ns 645 ns 1084685 -bm_rtl::method____ErasedTargetType::get_string 546 ns 546 ns 1273493 -bm_rtl::method____ErasedTargetAndReturnType::get_string 649 ns 649 ns 1072660 +bm_rtl::function__ErasedReturnType::get_string 530 ns 530 ns 1302691 +bm_rtl::method____ErasedReturnType::get_string 539 ns 539 ns 1297240 +bm_rtl::method____ErasedTargetType::get_string 534 ns 534 ns 1314364 +bm_rtl::method____ErasedTargetAndReturnType::get_string 541 ns 541 ns 1294039 ----------------------------------- -[2025-11-04 12:22:57] >>> Run 3: workload scale = 20 +[2026-01-19 23:07:03] >>> Run 3: workload scale = 20 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 20 iterations ============================================= -2025-11-04T12:22:57+05:30 +2026-01-19T23:07:03+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3817.78 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.29, 1.21, 0.98 +Load Average: 1.01, 0.96, 0.71 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 288 ns 288 ns 2443622 +bm_call::direct__Function::set_string 280 ns 280 ns 2516712 -bm_call::via_function_ptr__Function::set_string 291 ns 291 ns 2423578 -bm_call::via_function_ptr____Method::set_string 295 ns 295 ns 2407524 +bm_call::via_function_ptr__Function::set_string 281 ns 281 ns 2482011 +bm_call::via_function_ptr____Method::set_string 279 ns 279 ns 2503584 -bm_std::function_calls__Function::set_string 294 ns 294 ns 2344270 -bm_std::function_calls____Method::set_string 291 ns 291 ns 2396174 +bm_std::function_calls__Function::set_string 281 ns 281 ns 2480554 +bm_std::function_calls____Method::set_string 281 ns 281 ns 2518718 -bm_rtl::function_calls__Function::set_string 293 ns 293 ns 2412280 -bm_rtl::method_calls______Method::set_string 294 ns 294 ns 2426574 +bm_rtl::function_calls__Function::set_string 281 ns 281 ns 2502456 +bm_rtl::method_calls______Method::set_string 281 ns 281 ns 2500633 -bm_rtl::function__ErasedReturnType::set_string 295 ns 295 ns 2377689 -bm_rtl::method____ErasedReturnType::set_string 293 ns 293 ns 2394389 -bm_rtl::method____ErasedTargetType::set_string 297 ns 297 ns 2344509 -bm_rtl::method____ErasedTargetAndReturnType::set_string 300 ns 300 ns 2352884 +bm_rtl::function__ErasedReturnType::set_string 284 ns 283 ns 2477449 +bm_rtl::method____ErasedReturnType::set_string 281 ns 281 ns 2487763 +bm_rtl::method____ErasedTargetType::set_string 289 ns 289 ns 2443654 +bm_rtl::method____ErasedTargetAndReturnType::set_string 283 ns 283 ns 2474642 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 536 ns 536 ns 1295414 +bm_call::direct__Function::get_string 512 ns 512 ns 1370543 -bm_call::via_function_ptr__Function::get_string 541 ns 541 ns 1233897 -bm_call::via_function_ptr____Method::get_string 541 ns 541 ns 1288959 +bm_call::via_function_ptr__Function::get_string 512 ns 511 ns 1372544 +bm_call::via_function_ptr____Method::get_string 512 ns 512 ns 1356469 -bm_std::function_calls__Function::get_string 547 ns 547 ns 1262440 -bm_std::function_calls____Method::get_string 566 ns 566 ns 1227613 +bm_std::function_calls__Function::get_string 513 ns 513 ns 1363349 +bm_std::function_calls____Method::get_string 514 ns 514 ns 1365830 -bm_rtl::function_calls__Function::get_string 548 ns 548 ns 1275405 -bm_rtl::method_calls______Method::get_string 548 ns 548 ns 1245585 +bm_rtl::function_calls__Function::get_string 512 ns 512 ns 1370684 +bm_rtl::method_calls______Method::get_string 511 ns 511 ns 1372313 -bm_rtl::function__ErasedReturnType::get_string 653 ns 653 ns 1046627 -bm_rtl::method____ErasedReturnType::get_string 650 ns 650 ns 1059528 -bm_rtl::method____ErasedTargetType::get_string 552 ns 552 ns 1244640 -bm_rtl::method____ErasedTargetAndReturnType::get_string 654 ns 654 ns 1067972 +bm_rtl::function__ErasedReturnType::get_string 527 ns 527 ns 1327641 +bm_rtl::method____ErasedReturnType::get_string 527 ns 527 ns 1313459 +bm_rtl::method____ErasedTargetType::get_string 525 ns 525 ns 1335873 +bm_rtl::method____ErasedTargetAndReturnType::get_string 530 ns 530 ns 1321480 ----------------------------------- -[2025-11-04 12:23:16] >>> Run 1: workload scale = 25 +[2026-01-19 23:07:22] >>> Run 1: workload scale = 25 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 25 iterations ============================================= -2025-11-04T12:23:16+05:30 +2026-01-19T23:07:22+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2745.05 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.21, 1.19, 0.99 +Load Average: 1.01, 0.96, 0.72 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 321 ns 321 ns 2145052 +bm_call::direct__Function::set_string 352 ns 352 ns 1986306 -bm_call::via_function_ptr__Function::set_string 321 ns 321 ns 2172662 -bm_call::via_function_ptr____Method::set_string 320 ns 320 ns 2190165 +bm_call::via_function_ptr__Function::set_string 355 ns 354 ns 1970032 +bm_call::via_function_ptr____Method::set_string 355 ns 355 ns 1975489 -bm_std::function_calls__Function::set_string 319 ns 319 ns 2215014 -bm_std::function_calls____Method::set_string 319 ns 319 ns 2192899 +bm_std::function_calls__Function::set_string 362 ns 362 ns 1947671 +bm_std::function_calls____Method::set_string 348 ns 348 ns 2015214 -bm_rtl::function_calls__Function::set_string 326 ns 326 ns 2167253 -bm_rtl::method_calls______Method::set_string 323 ns 323 ns 2146891 +bm_rtl::function_calls__Function::set_string 356 ns 356 ns 1960779 +bm_rtl::method_calls______Method::set_string 356 ns 356 ns 1970573 -bm_rtl::function__ErasedReturnType::set_string 331 ns 331 ns 2128543 -bm_rtl::method____ErasedReturnType::set_string 330 ns 330 ns 2161480 -bm_rtl::method____ErasedTargetType::set_string 329 ns 329 ns 2093144 -bm_rtl::method____ErasedTargetAndReturnType::set_string 328 ns 328 ns 2128289 +bm_rtl::function__ErasedReturnType::set_string 355 ns 355 ns 1967083 +bm_rtl::method____ErasedReturnType::set_string 363 ns 363 ns 1931290 +bm_rtl::method____ErasedTargetType::set_string 357 ns 357 ns 1956980 +bm_rtl::method____ErasedTargetAndReturnType::set_string 357 ns 357 ns 1961696 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 669 ns 668 ns 937516 +bm_call::direct__Function::get_string 741 ns 741 ns 946428 -bm_call::via_function_ptr__Function::get_string 664 ns 664 ns 1042010 -bm_call::via_function_ptr____Method::get_string 666 ns 666 ns 1047814 +bm_call::via_function_ptr__Function::get_string 744 ns 744 ns 939247 +bm_call::via_function_ptr____Method::get_string 749 ns 748 ns 934680 -bm_std::function_calls__Function::get_string 668 ns 668 ns 1021621 -bm_std::function_calls____Method::get_string 668 ns 668 ns 1017963 +bm_std::function_calls__Function::get_string 761 ns 761 ns 920792 +bm_std::function_calls____Method::get_string 752 ns 752 ns 931714 -bm_rtl::function_calls__Function::get_string 669 ns 669 ns 1037708 -bm_rtl::method_calls______Method::get_string 665 ns 665 ns 1047174 +bm_rtl::function_calls__Function::get_string 745 ns 745 ns 931761 +bm_rtl::method_calls______Method::get_string 745 ns 745 ns 936980 -bm_rtl::function__ErasedReturnType::get_string 793 ns 793 ns 883503 -bm_rtl::method____ErasedReturnType::get_string 795 ns 795 ns 871865 -bm_rtl::method____ErasedTargetType::get_string 680 ns 680 ns 1021801 -bm_rtl::method____ErasedTargetAndReturnType::get_string 801 ns 801 ns 874189 +bm_rtl::function__ErasedReturnType::get_string 765 ns 765 ns 915979 +bm_rtl::method____ErasedReturnType::get_string 776 ns 776 ns 902448 +bm_rtl::method____ErasedTargetType::get_string 768 ns 768 ns 910555 +bm_rtl::method____ErasedTargetAndReturnType::get_string 781 ns 781 ns 895862 ----------------------------------- -[2025-11-04 12:23:37] >>> Run 2: workload scale = 25 +[2026-01-19 23:07:43] >>> Run 2: workload scale = 25 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 25 iterations ============================================= -2025-11-04T12:23:37+05:30 +2026-01-19T23:07:43+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3126.6 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.22, 1.19, 0.99 +Load Average: 1.00, 0.97, 0.72 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 320 ns 320 ns 2189231 +bm_call::direct__Function::set_string 352 ns 352 ns 1982071 -bm_call::via_function_ptr__Function::set_string 342 ns 342 ns 2163509 -bm_call::via_function_ptr____Method::set_string 365 ns 365 ns 1916223 +bm_call::via_function_ptr__Function::set_string 355 ns 355 ns 1970296 +bm_call::via_function_ptr____Method::set_string 356 ns 356 ns 1963515 -bm_std::function_calls__Function::set_string 361 ns 361 ns 1905923 -bm_std::function_calls____Method::set_string 356 ns 356 ns 1958867 +bm_std::function_calls__Function::set_string 342 ns 342 ns 2044461 +bm_std::function_calls____Method::set_string 344 ns 344 ns 2043629 -bm_rtl::function_calls__Function::set_string 359 ns 359 ns 1907278 -bm_rtl::method_calls______Method::set_string 354 ns 354 ns 1909265 +bm_rtl::function_calls__Function::set_string 345 ns 345 ns 2032898 +bm_rtl::method_calls______Method::set_string 345 ns 345 ns 2030104 -bm_rtl::function__ErasedReturnType::set_string 364 ns 363 ns 1935027 -bm_rtl::method____ErasedReturnType::set_string 360 ns 360 ns 1957560 -bm_rtl::method____ErasedTargetType::set_string 362 ns 362 ns 1941976 -bm_rtl::method____ErasedTargetAndReturnType::set_string 332 ns 332 ns 2099239 +bm_rtl::function__ErasedReturnType::set_string 347 ns 347 ns 2003550 +bm_rtl::method____ErasedReturnType::set_string 347 ns 347 ns 2018317 +bm_rtl::method____ErasedTargetType::set_string 348 ns 348 ns 2001122 +bm_rtl::method____ErasedTargetAndReturnType::set_string 357 ns 357 ns 1968473 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 680 ns 680 ns 1030475 +bm_call::direct__Function::get_string 735 ns 735 ns 949993 -bm_call::via_function_ptr__Function::get_string 668 ns 667 ns 1005079 -bm_call::via_function_ptr____Method::get_string 668 ns 668 ns 1048120 +bm_call::via_function_ptr__Function::get_string 737 ns 737 ns 948580 +bm_call::via_function_ptr____Method::get_string 743 ns 743 ns 940417 -bm_std::function_calls__Function::get_string 670 ns 670 ns 1049568 -bm_std::function_calls____Method::get_string 666 ns 666 ns 1053000 +bm_std::function_calls__Function::get_string 742 ns 742 ns 942789 +bm_std::function_calls____Method::get_string 759 ns 759 ns 924306 -bm_rtl::function_calls__Function::get_string 665 ns 665 ns 1055481 -bm_rtl::method_calls______Method::get_string 665 ns 665 ns 1058130 +bm_rtl::function_calls__Function::get_string 739 ns 739 ns 948214 +bm_rtl::method_calls______Method::get_string 739 ns 739 ns 947757 -bm_rtl::function__ErasedReturnType::get_string 788 ns 788 ns 887250 -bm_rtl::method____ErasedReturnType::get_string 793 ns 793 ns 890800 -bm_rtl::method____ErasedTargetType::get_string 698 ns 698 ns 1004244 -bm_rtl::method____ErasedTargetAndReturnType::get_string 794 ns 794 ns 884426 +bm_rtl::function__ErasedReturnType::get_string 763 ns 763 ns 912115 +bm_rtl::method____ErasedReturnType::get_string 763 ns 763 ns 917643 +bm_rtl::method____ErasedTargetType::get_string 761 ns 761 ns 920593 +bm_rtl::method____ErasedTargetAndReturnType::get_string 767 ns 767 ns 913033 ----------------------------------- -[2025-11-04 12:23:57] >>> Run 3: workload scale = 25 +[2026-01-19 23:08:04] >>> Run 3: workload scale = 25 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 25 iterations ============================================= -2025-11-04T12:23:57+05:30 +2026-01-19T23:08:04+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 800.525 MHz CPU s) +Run on (16 X 4239.17 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.44, 1.25, 1.02 +Load Average: 1.00, 0.97, 0.73 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 318 ns 318 ns 2197752 +bm_call::direct__Function::set_string 318 ns 318 ns 2209791 -bm_call::via_function_ptr__Function::set_string 322 ns 322 ns 2162163 -bm_call::via_function_ptr____Method::set_string 345 ns 345 ns 2174209 +bm_call::via_function_ptr__Function::set_string 320 ns 320 ns 2194462 +bm_call::via_function_ptr____Method::set_string 318 ns 318 ns 2200705 -bm_std::function_calls__Function::set_string 354 ns 354 ns 1984909 -bm_std::function_calls____Method::set_string 353 ns 353 ns 1979871 +bm_std::function_calls__Function::set_string 330 ns 330 ns 2105129 +bm_std::function_calls____Method::set_string 317 ns 317 ns 2214509 -bm_rtl::function_calls__Function::set_string 358 ns 357 ns 1969102 -bm_rtl::method_calls______Method::set_string 357 ns 357 ns 1963100 +bm_rtl::function_calls__Function::set_string 320 ns 320 ns 2196336 +bm_rtl::method_calls______Method::set_string 319 ns 319 ns 2193113 -bm_rtl::function__ErasedReturnType::set_string 356 ns 356 ns 1956769 -bm_rtl::method____ErasedReturnType::set_string 359 ns 359 ns 1953417 -bm_rtl::method____ErasedTargetType::set_string 363 ns 363 ns 1961373 -bm_rtl::method____ErasedTargetAndReturnType::set_string 360 ns 360 ns 1947329 +bm_rtl::function__ErasedReturnType::set_string 326 ns 326 ns 2153096 +bm_rtl::method____ErasedReturnType::set_string 334 ns 334 ns 2109094 +bm_rtl::method____ErasedTargetType::set_string 327 ns 327 ns 2126213 +bm_rtl::method____ErasedTargetAndReturnType::set_string 329 ns 329 ns 2135549 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 748 ns 748 ns 924341 +bm_call::direct__Function::get_string 676 ns 676 ns 1033968 -bm_call::via_function_ptr__Function::get_string 747 ns 747 ns 925487 -bm_call::via_function_ptr____Method::get_string 746 ns 746 ns 928898 +bm_call::via_function_ptr__Function::get_string 684 ns 684 ns 1024490 +bm_call::via_function_ptr____Method::get_string 699 ns 699 ns 1001694 -bm_std::function_calls__Function::get_string 749 ns 749 ns 925990 -bm_std::function_calls____Method::get_string 749 ns 749 ns 929901 +bm_std::function_calls__Function::get_string 696 ns 696 ns 1007881 +bm_std::function_calls____Method::get_string 686 ns 686 ns 1022139 -bm_rtl::function_calls__Function::get_string 746 ns 746 ns 915844 -bm_rtl::method_calls______Method::get_string 750 ns 750 ns 928817 +bm_rtl::function_calls__Function::get_string 682 ns 681 ns 1029656 +bm_rtl::method_calls______Method::get_string 680 ns 680 ns 1029375 -bm_rtl::function__ErasedReturnType::get_string 901 ns 901 ns 776868 -bm_rtl::method____ErasedReturnType::get_string 897 ns 897 ns 773498 -bm_rtl::method____ErasedTargetType::get_string 757 ns 757 ns 925383 -bm_rtl::method____ErasedTargetAndReturnType::get_string 897 ns 897 ns 778280 +bm_rtl::function__ErasedReturnType::get_string 691 ns 691 ns 1004599 +bm_rtl::method____ErasedReturnType::get_string 711 ns 711 ns 984643 +bm_rtl::method____ErasedTargetType::get_string 716 ns 715 ns 978554 +bm_rtl::method____ErasedTargetAndReturnType::get_string 715 ns 715 ns 978719 ----------------------------------- -[2025-11-04 12:24:18] >>> Run 1: workload scale = 30 +[2026-01-19 23:08:24] >>> Run 1: workload scale = 30 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 30 iterations ============================================= -2025-11-04T12:24:18+05:30 +2026-01-19T23:08:24+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4153.56 MHz CPU s) +Run on (16 X 2476.53 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.32, 1.23, 1.01 +Load Average: 1.00, 0.97, 0.74 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 374 ns 373 ns 1873476 +bm_call::direct__Function::set_string 396 ns 396 ns 1770525 -bm_call::via_function_ptr__Function::set_string 376 ns 376 ns 1863509 -bm_call::via_function_ptr____Method::set_string 374 ns 374 ns 1863221 +bm_call::via_function_ptr__Function::set_string 394 ns 394 ns 1782096 +bm_call::via_function_ptr____Method::set_string 395 ns 395 ns 1773848 -bm_std::function_calls__Function::set_string 373 ns 373 ns 1871738 -bm_std::function_calls____Method::set_string 376 ns 376 ns 1865547 +bm_std::function_calls__Function::set_string 400 ns 399 ns 1754344 +bm_std::function_calls____Method::set_string 401 ns 401 ns 1730094 -bm_rtl::function_calls__Function::set_string 376 ns 376 ns 1865067 -bm_rtl::method_calls______Method::set_string 377 ns 377 ns 1858187 +bm_rtl::function_calls__Function::set_string 401 ns 401 ns 1739081 +bm_rtl::method_calls______Method::set_string 401 ns 401 ns 1745860 -bm_rtl::function__ErasedReturnType::set_string 380 ns 380 ns 1837243 -bm_rtl::method____ErasedReturnType::set_string 386 ns 386 ns 1822783 -bm_rtl::method____ErasedTargetType::set_string 412 ns 412 ns 1701170 -bm_rtl::method____ErasedTargetAndReturnType::set_string 414 ns 413 ns 1700118 +bm_rtl::function__ErasedReturnType::set_string 403 ns 403 ns 1745498 +bm_rtl::method____ErasedReturnType::set_string 394 ns 394 ns 1778868 +bm_rtl::method____ErasedTargetType::set_string 398 ns 398 ns 1764951 +bm_rtl::method____ErasedTargetAndReturnType::set_string 395 ns 395 ns 1776625 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 956 ns 956 ns 728821 +bm_call::direct__Function::get_string 928 ns 928 ns 754696 -bm_call::via_function_ptr__Function::get_string 956 ns 956 ns 729173 -bm_call::via_function_ptr____Method::get_string 955 ns 954 ns 732604 +bm_call::via_function_ptr__Function::get_string 929 ns 929 ns 753468 +bm_call::via_function_ptr____Method::get_string 928 ns 928 ns 754762 -bm_std::function_calls__Function::get_string 963 ns 963 ns 720513 -bm_std::function_calls____Method::get_string 970 ns 970 ns 720651 +bm_std::function_calls__Function::get_string 933 ns 933 ns 742321 +bm_std::function_calls____Method::get_string 932 ns 932 ns 751071 -bm_rtl::function_calls__Function::get_string 962 ns 962 ns 724222 -bm_rtl::method_calls______Method::get_string 964 ns 964 ns 720737 +bm_rtl::function_calls__Function::get_string 931 ns 930 ns 753258 +bm_rtl::method_calls______Method::get_string 928 ns 928 ns 753388 -bm_rtl::function__ErasedReturnType::get_string 1167 ns 1166 ns 598228 -bm_rtl::method____ErasedReturnType::get_string 1177 ns 1177 ns 594646 -bm_rtl::method____ErasedTargetType::get_string 982 ns 982 ns 710920 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1181 ns 1181 ns 590085 +bm_rtl::function__ErasedReturnType::get_string 966 ns 966 ns 724498 +bm_rtl::method____ErasedReturnType::get_string 947 ns 946 ns 732009 +bm_rtl::method____ErasedTargetType::get_string 952 ns 952 ns 735704 +bm_rtl::method____ErasedTargetAndReturnType::get_string 950 ns 950 ns 736736 ----------------------------------- -[2025-11-04 12:24:39] >>> Run 2: workload scale = 30 +[2026-01-19 23:08:45] >>> Run 2: workload scale = 30 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 30 iterations ============================================= -2025-11-04T12:24:39+05:30 +2026-01-19T23:08:45+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2855.26 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.23, 1.22, 1.01 +Load Average: 1.00, 0.97, 0.74 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 400 ns 400 ns 1746516 +bm_call::direct__Function::set_string 399 ns 399 ns 1758978 -bm_call::via_function_ptr__Function::set_string 401 ns 401 ns 1746207 -bm_call::via_function_ptr____Method::set_string 401 ns 401 ns 1755755 +bm_call::via_function_ptr__Function::set_string 399 ns 399 ns 1760800 +bm_call::via_function_ptr____Method::set_string 397 ns 397 ns 1751423 -bm_std::function_calls__Function::set_string 402 ns 402 ns 1742386 -bm_std::function_calls____Method::set_string 403 ns 403 ns 1743721 +bm_std::function_calls__Function::set_string 401 ns 401 ns 1756623 +bm_std::function_calls____Method::set_string 398 ns 398 ns 1748346 -bm_rtl::function_calls__Function::set_string 406 ns 406 ns 1726824 -bm_rtl::method_calls______Method::set_string 401 ns 401 ns 1734713 +bm_rtl::function_calls__Function::set_string 397 ns 397 ns 1758430 +bm_rtl::method_calls______Method::set_string 399 ns 399 ns 1754744 -bm_rtl::function__ErasedReturnType::set_string 408 ns 408 ns 1720118 -bm_rtl::method____ErasedReturnType::set_string 407 ns 407 ns 1718166 -bm_rtl::method____ErasedTargetType::set_string 410 ns 410 ns 1711945 -bm_rtl::method____ErasedTargetAndReturnType::set_string 381 ns 381 ns 1768747 +bm_rtl::function__ErasedReturnType::set_string 401 ns 401 ns 1755050 +bm_rtl::method____ErasedReturnType::set_string 394 ns 394 ns 1782942 +bm_rtl::method____ErasedTargetType::set_string 409 ns 409 ns 1722123 +bm_rtl::method____ErasedTargetAndReturnType::set_string 385 ns 385 ns 1768735 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 881 ns 881 ns 787730 +bm_call::direct__Function::get_string 857 ns 857 ns 817452 -bm_call::via_function_ptr__Function::get_string 874 ns 874 ns 796785 -bm_call::via_function_ptr____Method::get_string 872 ns 872 ns 793060 +bm_call::via_function_ptr__Function::get_string 859 ns 859 ns 815751 +bm_call::via_function_ptr____Method::get_string 856 ns 856 ns 817710 -bm_std::function_calls__Function::get_string 891 ns 890 ns 784802 -bm_std::function_calls____Method::get_string 889 ns 889 ns 780768 +bm_std::function_calls__Function::get_string 870 ns 870 ns 804960 +bm_std::function_calls____Method::get_string 869 ns 868 ns 797056 -bm_rtl::function_calls__Function::get_string 883 ns 883 ns 789722 -bm_rtl::method_calls______Method::get_string 887 ns 887 ns 786262 +bm_rtl::function_calls__Function::get_string 858 ns 858 ns 816875 +bm_rtl::method_calls______Method::get_string 857 ns 857 ns 817853 -bm_rtl::function__ErasedReturnType::get_string 1083 ns 1083 ns 643370 -bm_rtl::method____ErasedReturnType::get_string 1089 ns 1089 ns 643122 -bm_rtl::method____ErasedTargetType::get_string 912 ns 912 ns 752875 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1095 ns 1095 ns 640973 +bm_rtl::function__ErasedReturnType::get_string 902 ns 902 ns 776365 +bm_rtl::method____ErasedReturnType::get_string 885 ns 885 ns 791981 +bm_rtl::method____ErasedTargetType::get_string 891 ns 891 ns 781450 +bm_rtl::method____ErasedTargetAndReturnType::get_string 882 ns 882 ns 793685 ----------------------------------- -[2025-11-04 12:25:01] >>> Run 3: workload scale = 30 +[2026-01-19 23:09:07] >>> Run 3: workload scale = 30 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 30 iterations ============================================= -2025-11-04T12:25:01+05:30 +2026-01-19T23:09:07+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4282.06 MHz CPU s) +Run on (16 X 4883.24 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.15, 1.20, 1.01 +Load Average: 1.00, 0.98, 0.75 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 374 ns 374 ns 1885971 +bm_call::direct__Function::set_string 368 ns 368 ns 1907536 -bm_call::via_function_ptr__Function::set_string 375 ns 375 ns 1873368 -bm_call::via_function_ptr____Method::set_string 373 ns 373 ns 1868671 +bm_call::via_function_ptr__Function::set_string 367 ns 367 ns 1908381 +bm_call::via_function_ptr____Method::set_string 365 ns 365 ns 1910674 -bm_std::function_calls__Function::set_string 377 ns 377 ns 1860537 -bm_std::function_calls____Method::set_string 378 ns 378 ns 1854349 +bm_std::function_calls__Function::set_string 367 ns 367 ns 1896507 +bm_std::function_calls____Method::set_string 382 ns 382 ns 1831001 -bm_rtl::function_calls__Function::set_string 376 ns 376 ns 1861382 -bm_rtl::method_calls______Method::set_string 376 ns 376 ns 1858131 +bm_rtl::function_calls__Function::set_string 382 ns 381 ns 1831892 +bm_rtl::method_calls______Method::set_string 380 ns 380 ns 1825582 -bm_rtl::function__ErasedReturnType::set_string 383 ns 383 ns 1839310 -bm_rtl::method____ErasedReturnType::set_string 383 ns 383 ns 1832865 -bm_rtl::method____ErasedTargetType::set_string 389 ns 389 ns 1823647 -bm_rtl::method____ErasedTargetAndReturnType::set_string 393 ns 393 ns 1743924 +bm_rtl::function__ErasedReturnType::set_string 380 ns 380 ns 1837083 +bm_rtl::method____ErasedReturnType::set_string 370 ns 370 ns 1887118 +bm_rtl::method____ErasedTargetType::set_string 374 ns 374 ns 1875803 +bm_rtl::method____ErasedTargetAndReturnType::set_string 371 ns 371 ns 1887326 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 897 ns 897 ns 777617 +bm_call::direct__Function::get_string 860 ns 859 ns 816446 -bm_call::via_function_ptr__Function::get_string 891 ns 891 ns 792904 -bm_call::via_function_ptr____Method::get_string 883 ns 883 ns 752790 +bm_call::via_function_ptr__Function::get_string 861 ns 861 ns 813585 +bm_call::via_function_ptr____Method::get_string 860 ns 860 ns 813318 -bm_std::function_calls__Function::get_string 897 ns 897 ns 769458 -bm_std::function_calls____Method::get_string 893 ns 893 ns 783150 +bm_std::function_calls__Function::get_string 862 ns 862 ns 810967 +bm_std::function_calls____Method::get_string 861 ns 861 ns 813011 -bm_rtl::function_calls__Function::get_string 881 ns 881 ns 783511 -bm_rtl::method_calls______Method::get_string 892 ns 892 ns 785936 +bm_rtl::function_calls__Function::get_string 861 ns 861 ns 814070 +bm_rtl::method_calls______Method::get_string 860 ns 860 ns 814315 -bm_rtl::function__ErasedReturnType::get_string 1126 ns 1125 ns 633797 -bm_rtl::method____ErasedReturnType::get_string 1137 ns 1137 ns 602780 -bm_rtl::method____ErasedTargetType::get_string 932 ns 931 ns 758769 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1108 ns 1108 ns 602980 +bm_rtl::function__ErasedReturnType::get_string 896 ns 896 ns 780048 +bm_rtl::method____ErasedReturnType::get_string 882 ns 882 ns 797878 +bm_rtl::method____ErasedTargetType::get_string 883 ns 883 ns 793282 +bm_rtl::method____ErasedTargetAndReturnType::get_string 879 ns 879 ns 790735 ----------------------------------- -[2025-11-04 12:25:22] >>> Run 1: workload scale = 35 +[2026-01-19 23:09:28] >>> Run 1: workload scale = 35 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 35 iterations ============================================= -2025-11-04T12:25:22+05:30 +2026-01-19T23:09:28+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2237.04 MHz CPU s) +Run on (16 X 801.76 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.10, 1.18, 1.01 +Load Average: 1.00, 0.98, 0.76 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 750 ns 750 ns 924083 +bm_call::direct__Function::set_string 705 ns 705 ns 985733 -bm_call::via_function_ptr__Function::set_string 757 ns 757 ns 920347 -bm_call::via_function_ptr____Method::set_string 771 ns 771 ns 912619 +bm_call::via_function_ptr__Function::set_string 701 ns 701 ns 1000348 +bm_call::via_function_ptr____Method::set_string 701 ns 701 ns 1000636 -bm_std::function_calls__Function::set_string 780 ns 780 ns 883371 -bm_std::function_calls____Method::set_string 781 ns 780 ns 898678 +bm_std::function_calls__Function::set_string 721 ns 720 ns 967545 +bm_std::function_calls____Method::set_string 708 ns 708 ns 991569 -bm_rtl::function_calls__Function::set_string 787 ns 787 ns 862899 -bm_rtl::method_calls______Method::set_string 796 ns 796 ns 914393 +bm_rtl::function_calls__Function::set_string 700 ns 700 ns 1001086 +bm_rtl::method_calls______Method::set_string 700 ns 700 ns 998814 -bm_rtl::function__ErasedReturnType::set_string 775 ns 775 ns 874764 -bm_rtl::method____ErasedReturnType::set_string 776 ns 776 ns 907678 -bm_rtl::method____ErasedTargetType::set_string 790 ns 789 ns 866660 -bm_rtl::method____ErasedTargetAndReturnType::set_string 805 ns 805 ns 869127 +bm_rtl::function__ErasedReturnType::set_string 714 ns 714 ns 974752 +bm_rtl::method____ErasedReturnType::set_string 728 ns 728 ns 959111 +bm_rtl::method____ErasedTargetType::set_string 719 ns 719 ns 975492 +bm_rtl::method____ErasedTargetAndReturnType::set_string 723 ns 723 ns 969915 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1383 ns 1383 ns 499739 +bm_call::direct__Function::get_string 1284 ns 1284 ns 545119 -bm_call::via_function_ptr__Function::get_string 1315 ns 1315 ns 524654 -bm_call::via_function_ptr____Method::get_string 1326 ns 1326 ns 513208 +bm_call::via_function_ptr__Function::get_string 1286 ns 1286 ns 544229 +bm_call::via_function_ptr____Method::get_string 1287 ns 1287 ns 544270 -bm_std::function_calls__Function::get_string 1309 ns 1309 ns 531060 -bm_std::function_calls____Method::get_string 1331 ns 1331 ns 534228 +bm_std::function_calls__Function::get_string 1297 ns 1296 ns 539804 +bm_std::function_calls____Method::get_string 1283 ns 1283 ns 545848 -bm_rtl::function_calls__Function::get_string 1326 ns 1326 ns 514575 -bm_rtl::method_calls______Method::get_string 1326 ns 1326 ns 525314 +bm_rtl::function_calls__Function::get_string 1284 ns 1284 ns 544814 +bm_rtl::method_calls______Method::get_string 1284 ns 1284 ns 544804 -bm_rtl::function__ErasedReturnType::get_string 1549 ns 1549 ns 447415 -bm_rtl::method____ErasedReturnType::get_string 1543 ns 1543 ns 452767 -bm_rtl::method____ErasedTargetType::get_string 1352 ns 1351 ns 524647 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1562 ns 1562 ns 434293 +bm_rtl::function__ErasedReturnType::get_string 1325 ns 1325 ns 528647 +bm_rtl::method____ErasedReturnType::get_string 1334 ns 1333 ns 525192 +bm_rtl::method____ErasedTargetType::get_string 1337 ns 1337 ns 523963 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1335 ns 1335 ns 524821 ----------------------------------- -[2025-11-04 12:25:40] >>> Run 2: workload scale = 35 +[2026-01-19 23:09:46] >>> Run 2: workload scale = 35 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 35 iterations ============================================= -2025-11-04T12:25:40+05:30 +2026-01-19T23:09:46+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3670.17 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.22, 1.21, 1.02 +Load Average: 1.00, 0.98, 0.76 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 743 ns 743 ns 909759 +bm_call::direct__Function::set_string 705 ns 705 ns 986633 -bm_call::via_function_ptr__Function::set_string 740 ns 740 ns 930090 -bm_call::via_function_ptr____Method::set_string 744 ns 744 ns 933324 +bm_call::via_function_ptr__Function::set_string 704 ns 704 ns 987788 +bm_call::via_function_ptr____Method::set_string 704 ns 704 ns 997143 -bm_std::function_calls__Function::set_string 743 ns 743 ns 913502 -bm_std::function_calls____Method::set_string 758 ns 758 ns 931457 +bm_std::function_calls__Function::set_string 706 ns 706 ns 997719 +bm_std::function_calls____Method::set_string 709 ns 709 ns 986989 -bm_rtl::function_calls__Function::set_string 767 ns 767 ns 910065 -bm_rtl::method_calls______Method::set_string 743 ns 743 ns 931388 +bm_rtl::function_calls__Function::set_string 701 ns 701 ns 987483 +bm_rtl::method_calls______Method::set_string 703 ns 703 ns 997777 -bm_rtl::function__ErasedReturnType::set_string 775 ns 775 ns 921081 -bm_rtl::method____ErasedReturnType::set_string 761 ns 761 ns 915625 -bm_rtl::method____ErasedTargetType::set_string 756 ns 756 ns 913038 -bm_rtl::method____ErasedTargetAndReturnType::set_string 771 ns 771 ns 901263 +bm_rtl::function__ErasedReturnType::set_string 711 ns 711 ns 986143 +bm_rtl::method____ErasedReturnType::set_string 712 ns 712 ns 981320 +bm_rtl::method____ErasedTargetType::set_string 729 ns 729 ns 953478 +bm_rtl::method____ErasedTargetAndReturnType::set_string 721 ns 721 ns 972637 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1357 ns 1357 ns 502661 +bm_call::direct__Function::get_string 1292 ns 1292 ns 542071 -bm_call::via_function_ptr__Function::get_string 1408 ns 1408 ns 503040 -bm_call::via_function_ptr____Method::get_string 1446 ns 1446 ns 478290 +bm_call::via_function_ptr__Function::get_string 1295 ns 1295 ns 540984 +bm_call::via_function_ptr____Method::get_string 1295 ns 1295 ns 541118 -bm_std::function_calls__Function::get_string 1373 ns 1373 ns 498957 -bm_std::function_calls____Method::get_string 1398 ns 1398 ns 502891 +bm_std::function_calls__Function::get_string 1295 ns 1295 ns 540968 +bm_std::function_calls____Method::get_string 1292 ns 1292 ns 539948 -bm_rtl::function_calls__Function::get_string 1395 ns 1395 ns 488686 -bm_rtl::method_calls______Method::get_string 1382 ns 1382 ns 497336 +bm_rtl::function_calls__Function::get_string 1292 ns 1292 ns 541902 +bm_rtl::method_calls______Method::get_string 1294 ns 1294 ns 541265 -bm_rtl::function__ErasedReturnType::get_string 1560 ns 1560 ns 425909 -bm_rtl::method____ErasedReturnType::get_string 1542 ns 1542 ns 450811 -bm_rtl::method____ErasedTargetType::get_string 1337 ns 1337 ns 521375 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1552 ns 1552 ns 447731 +bm_rtl::function__ErasedReturnType::get_string 1327 ns 1327 ns 527659 +bm_rtl::method____ErasedReturnType::get_string 1329 ns 1329 ns 527155 +bm_rtl::method____ErasedTargetType::get_string 1331 ns 1331 ns 525723 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1328 ns 1328 ns 527175 ----------------------------------- -[2025-11-04 12:25:58] >>> Run 3: workload scale = 35 +[2026-01-19 23:10:03] >>> Run 3: workload scale = 35 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 35 iterations ============================================= -2025-11-04T12:25:58+05:30 +2026-01-19T23:10:03+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4129.78 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.23, 1.21, 1.02 +Load Average: 1.00, 0.98, 0.77 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 699 ns 699 ns 970616 +bm_call::direct__Function::set_string 711 ns 711 ns 981009 -bm_call::via_function_ptr__Function::set_string 733 ns 732 ns 992416 -bm_call::via_function_ptr____Method::set_string 743 ns 743 ns 951176 +bm_call::via_function_ptr__Function::set_string 706 ns 706 ns 991650 +bm_call::via_function_ptr____Method::set_string 707 ns 707 ns 993046 -bm_std::function_calls__Function::set_string 719 ns 718 ns 953330 -bm_std::function_calls____Method::set_string 722 ns 722 ns 981699 +bm_std::function_calls__Function::set_string 711 ns 711 ns 987427 +bm_std::function_calls____Method::set_string 722 ns 722 ns 965591 -bm_rtl::function_calls__Function::set_string 716 ns 716 ns 988945 -bm_rtl::method_calls______Method::set_string 711 ns 711 ns 992867 +bm_rtl::function_calls__Function::set_string 718 ns 718 ns 980439 +bm_rtl::method_calls______Method::set_string 716 ns 716 ns 981915 -bm_rtl::function__ErasedReturnType::set_string 729 ns 728 ns 961326 -bm_rtl::method____ErasedReturnType::set_string 762 ns 762 ns 954194 -bm_rtl::method____ErasedTargetType::set_string 768 ns 768 ns 893804 -bm_rtl::method____ErasedTargetAndReturnType::set_string 737 ns 736 ns 929658 +bm_rtl::function__ErasedReturnType::set_string 732 ns 732 ns 955957 +bm_rtl::method____ErasedReturnType::set_string 729 ns 729 ns 960114 +bm_rtl::method____ErasedTargetType::set_string 732 ns 732 ns 954898 +bm_rtl::method____ErasedTargetAndReturnType::set_string 732 ns 732 ns 955316 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1318 ns 1317 ns 529166 +bm_call::direct__Function::get_string 1294 ns 1294 ns 541024 -bm_call::via_function_ptr__Function::get_string 1321 ns 1321 ns 530054 -bm_call::via_function_ptr____Method::get_string 1316 ns 1316 ns 531188 +bm_call::via_function_ptr__Function::get_string 1294 ns 1294 ns 541047 +bm_call::via_function_ptr____Method::get_string 1295 ns 1295 ns 540770 -bm_std::function_calls__Function::get_string 1319 ns 1319 ns 531843 -bm_std::function_calls____Method::get_string 1321 ns 1321 ns 532253 +bm_std::function_calls__Function::get_string 1291 ns 1291 ns 542197 +bm_std::function_calls____Method::get_string 1293 ns 1293 ns 541524 -bm_rtl::function_calls__Function::get_string 1319 ns 1319 ns 531646 -bm_rtl::method_calls______Method::get_string 1319 ns 1319 ns 528183 +bm_rtl::function_calls__Function::get_string 1293 ns 1293 ns 541127 +bm_rtl::method_calls______Method::get_string 1295 ns 1294 ns 540828 -bm_rtl::function__ErasedReturnType::get_string 1615 ns 1614 ns 444285 -bm_rtl::method____ErasedReturnType::get_string 1592 ns 1592 ns 436514 -bm_rtl::method____ErasedTargetType::get_string 1407 ns 1407 ns 496278 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1624 ns 1624 ns 430770 +bm_rtl::function__ErasedReturnType::get_string 1331 ns 1331 ns 526054 +bm_rtl::method____ErasedReturnType::get_string 1324 ns 1324 ns 528304 +bm_rtl::method____ErasedTargetType::get_string 1328 ns 1327 ns 527006 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1326 ns 1325 ns 528118 ----------------------------------- -[2025-11-04 12:26:16] >>> Run 1: workload scale = 40 +[2026-01-19 23:10:21] >>> Run 1: workload scale = 40 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 40 iterations ============================================= -2025-11-04T12:26:16+05:30 +2026-01-19T23:10:21+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1742.32 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.30, 1.23, 1.03 +Load Average: 1.00, 0.98, 0.77 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 786 ns 785 ns 874794 +bm_call::direct__Function::set_string 782 ns 782 ns 891703 -bm_call::via_function_ptr__Function::set_string 789 ns 789 ns 874362 -bm_call::via_function_ptr____Method::set_string 790 ns 790 ns 883497 +bm_call::via_function_ptr__Function::set_string 773 ns 772 ns 906560 +bm_call::via_function_ptr____Method::set_string 773 ns 773 ns 907685 -bm_std::function_calls__Function::set_string 786 ns 786 ns 884943 -bm_std::function_calls____Method::set_string 790 ns 790 ns 870155 +bm_std::function_calls__Function::set_string 786 ns 786 ns 892166 +bm_std::function_calls____Method::set_string 794 ns 794 ns 882725 -bm_rtl::function_calls__Function::set_string 790 ns 790 ns 878262 -bm_rtl::method_calls______Method::set_string 791 ns 791 ns 871008 +bm_rtl::function_calls__Function::set_string 773 ns 773 ns 906587 +bm_rtl::method_calls______Method::set_string 773 ns 773 ns 905399 -bm_rtl::function__ErasedReturnType::set_string 793 ns 793 ns 881206 -bm_rtl::method____ErasedReturnType::set_string 794 ns 794 ns 876546 -bm_rtl::method____ErasedTargetType::set_string 792 ns 792 ns 872609 -bm_rtl::method____ErasedTargetAndReturnType::set_string 794 ns 794 ns 875157 +bm_rtl::function__ErasedReturnType::set_string 781 ns 781 ns 895361 +bm_rtl::method____ErasedReturnType::set_string 802 ns 802 ns 871618 +bm_rtl::method____ErasedTargetType::set_string 807 ns 807 ns 868612 +bm_rtl::method____ErasedTargetAndReturnType::set_string 798 ns 798 ns 875806 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1478 ns 1478 ns 473478 +bm_call::direct__Function::get_string 1386 ns 1386 ns 504769 -bm_call::via_function_ptr__Function::get_string 1469 ns 1469 ns 473069 -bm_call::via_function_ptr____Method::get_string 1468 ns 1468 ns 473326 +bm_call::via_function_ptr__Function::get_string 1388 ns 1388 ns 504508 +bm_call::via_function_ptr____Method::get_string 1389 ns 1389 ns 503908 -bm_std::function_calls__Function::get_string 1471 ns 1470 ns 473822 -bm_std::function_calls____Method::get_string 1473 ns 1473 ns 472376 +bm_std::function_calls__Function::get_string 1393 ns 1392 ns 502344 +bm_std::function_calls____Method::get_string 1401 ns 1401 ns 499474 -bm_rtl::function_calls__Function::get_string 1473 ns 1473 ns 473798 -bm_rtl::method_calls______Method::get_string 1470 ns 1470 ns 476866 +bm_rtl::function_calls__Function::get_string 1388 ns 1388 ns 504285 +bm_rtl::method_calls______Method::get_string 1389 ns 1389 ns 503768 -bm_rtl::function__ErasedReturnType::get_string 1821 ns 1821 ns 385183 -bm_rtl::method____ErasedReturnType::get_string 1816 ns 1816 ns 385499 -bm_rtl::method____ErasedTargetType::get_string 1489 ns 1489 ns 469694 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1821 ns 1821 ns 382024 +bm_rtl::function__ErasedReturnType::get_string 1432 ns 1431 ns 489025 +bm_rtl::method____ErasedReturnType::get_string 1441 ns 1441 ns 485874 +bm_rtl::method____ErasedTargetType::get_string 1437 ns 1437 ns 487198 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1429 ns 1429 ns 489805 ----------------------------------- -[2025-11-04 12:26:34] >>> Run 2: workload scale = 40 +[2026-01-19 23:10:39] >>> Run 2: workload scale = 40 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 40 iterations ============================================= -2025-11-04T12:26:34+05:30 +2026-01-19T23:10:39+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1593.45 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.23, 1.22, 1.03 +Load Average: 1.00, 0.99, 0.78 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 785 ns 785 ns 883374 +bm_call::direct__Function::set_string 785 ns 785 ns 888235 -bm_call::via_function_ptr__Function::set_string 796 ns 796 ns 886782 -bm_call::via_function_ptr____Method::set_string 794 ns 794 ns 877309 +bm_call::via_function_ptr__Function::set_string 783 ns 783 ns 895909 +bm_call::via_function_ptr____Method::set_string 784 ns 784 ns 892181 -bm_std::function_calls__Function::set_string 794 ns 794 ns 873699 -bm_std::function_calls____Method::set_string 796 ns 796 ns 872066 +bm_std::function_calls__Function::set_string 808 ns 807 ns 867107 +bm_std::function_calls____Method::set_string 791 ns 791 ns 886305 -bm_rtl::function_calls__Function::set_string 793 ns 793 ns 885099 -bm_rtl::method_calls______Method::set_string 816 ns 816 ns 841390 +bm_rtl::function_calls__Function::set_string 785 ns 784 ns 895366 +bm_rtl::method_calls______Method::set_string 785 ns 785 ns 893743 -bm_rtl::function__ErasedReturnType::set_string 802 ns 802 ns 847247 -bm_rtl::method____ErasedReturnType::set_string 802 ns 802 ns 858644 -bm_rtl::method____ErasedTargetType::set_string 798 ns 797 ns 870491 -bm_rtl::method____ErasedTargetAndReturnType::set_string 797 ns 797 ns 870936 +bm_rtl::function__ErasedReturnType::set_string 789 ns 789 ns 884109 +bm_rtl::method____ErasedReturnType::set_string 799 ns 799 ns 877237 +bm_rtl::method____ErasedTargetType::set_string 796 ns 796 ns 878299 +bm_rtl::method____ErasedTargetAndReturnType::set_string 795 ns 795 ns 880145 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1507 ns 1507 ns 461478 +bm_call::direct__Function::get_string 1390 ns 1390 ns 503885 -bm_call::via_function_ptr__Function::get_string 1507 ns 1507 ns 461730 -bm_call::via_function_ptr____Method::get_string 1507 ns 1507 ns 464680 +bm_call::via_function_ptr__Function::get_string 1392 ns 1392 ns 503087 +bm_call::via_function_ptr____Method::get_string 1393 ns 1393 ns 502484 -bm_std::function_calls__Function::get_string 1507 ns 1507 ns 463574 -bm_std::function_calls____Method::get_string 1520 ns 1520 ns 464089 +bm_std::function_calls__Function::get_string 1403 ns 1402 ns 499273 +bm_std::function_calls____Method::get_string 1397 ns 1396 ns 501051 -bm_rtl::function_calls__Function::get_string 1504 ns 1503 ns 458070 -bm_rtl::method_calls______Method::get_string 1517 ns 1517 ns 463656 +bm_rtl::function_calls__Function::get_string 1392 ns 1392 ns 503291 +bm_rtl::method_calls______Method::get_string 1394 ns 1394 ns 502404 -bm_rtl::function__ErasedReturnType::get_string 1837 ns 1837 ns 382222 -bm_rtl::method____ErasedReturnType::get_string 1840 ns 1840 ns 381090 -bm_rtl::method____ErasedTargetType::get_string 1521 ns 1521 ns 454047 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1841 ns 1840 ns 381784 +bm_rtl::function__ErasedReturnType::get_string 1429 ns 1429 ns 489928 +bm_rtl::method____ErasedReturnType::get_string 1443 ns 1443 ns 485194 +bm_rtl::method____ErasedTargetType::get_string 1444 ns 1444 ns 484882 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1445 ns 1444 ns 484828 ----------------------------------- -[2025-11-04 12:26:52] >>> Run 3: workload scale = 40 +[2026-01-19 23:10:57] >>> Run 3: workload scale = 40 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 40 iterations ============================================= -2025-11-04T12:26:52+05:30 +2026-01-19T23:10:57+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1598,152 +1598,152 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.16, 1.20, 1.03 +Load Average: 1.00, 0.99, 0.78 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 765 ns 765 ns 900609 +bm_call::direct__Function::set_string 793 ns 792 ns 877198 -bm_call::via_function_ptr__Function::set_string 773 ns 773 ns 902357 -bm_call::via_function_ptr____Method::set_string 775 ns 775 ns 895698 +bm_call::via_function_ptr__Function::set_string 781 ns 781 ns 897556 +bm_call::via_function_ptr____Method::set_string 782 ns 782 ns 895656 -bm_std::function_calls__Function::set_string 769 ns 769 ns 884989 -bm_std::function_calls____Method::set_string 770 ns 770 ns 905215 +bm_std::function_calls__Function::set_string 808 ns 808 ns 867700 +bm_std::function_calls____Method::set_string 794 ns 793 ns 881778 -bm_rtl::function_calls__Function::set_string 781 ns 781 ns 893172 -bm_rtl::method_calls______Method::set_string 785 ns 785 ns 871377 +bm_rtl::function_calls__Function::set_string 783 ns 783 ns 894163 +bm_rtl::method_calls______Method::set_string 782 ns 782 ns 896569 -bm_rtl::function__ErasedReturnType::set_string 796 ns 796 ns 876191 -bm_rtl::method____ErasedReturnType::set_string 795 ns 795 ns 870611 -bm_rtl::method____ErasedTargetType::set_string 786 ns 786 ns 875116 -bm_rtl::method____ErasedTargetAndReturnType::set_string 793 ns 793 ns 853059 +bm_rtl::function__ErasedReturnType::set_string 788 ns 787 ns 889379 +bm_rtl::method____ErasedReturnType::set_string 804 ns 803 ns 873015 +bm_rtl::method____ErasedTargetType::set_string 789 ns 789 ns 886401 +bm_rtl::method____ErasedTargetAndReturnType::set_string 800 ns 800 ns 875673 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1482 ns 1482 ns 471648 +bm_call::direct__Function::get_string 1391 ns 1391 ns 503452 -bm_call::via_function_ptr__Function::get_string 1478 ns 1477 ns 472419 -bm_call::via_function_ptr____Method::get_string 1487 ns 1487 ns 474564 +bm_call::via_function_ptr__Function::get_string 1393 ns 1393 ns 502459 +bm_call::via_function_ptr____Method::get_string 1395 ns 1395 ns 502068 -bm_std::function_calls__Function::get_string 1479 ns 1479 ns 467774 -bm_std::function_calls____Method::get_string 1468 ns 1468 ns 475985 +bm_std::function_calls__Function::get_string 1409 ns 1409 ns 497129 +bm_std::function_calls____Method::get_string 1397 ns 1397 ns 501255 -bm_rtl::function_calls__Function::get_string 1477 ns 1477 ns 471129 -bm_rtl::method_calls______Method::get_string 1484 ns 1483 ns 471432 +bm_rtl::function_calls__Function::get_string 1392 ns 1392 ns 502897 +bm_rtl::method_calls______Method::get_string 1394 ns 1394 ns 502374 -bm_rtl::function__ErasedReturnType::get_string 1830 ns 1829 ns 379477 -bm_rtl::method____ErasedReturnType::get_string 1833 ns 1833 ns 381079 -bm_rtl::method____ErasedTargetType::get_string 1499 ns 1499 ns 460559 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1837 ns 1837 ns 375044 +bm_rtl::function__ErasedReturnType::get_string 1429 ns 1429 ns 489871 +bm_rtl::method____ErasedReturnType::get_string 1445 ns 1445 ns 484141 +bm_rtl::method____ErasedTargetType::get_string 1447 ns 1447 ns 483724 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1446 ns 1446 ns 483729 ----------------------------------- -[2025-11-04 12:27:10] >>> Run 1: workload scale = 45 +[2026-01-19 23:11:16] >>> Run 1: workload scale = 45 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 45 iterations ============================================= -2025-11-04T12:27:10+05:30 +2026-01-19T23:11:16+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2727.08 MHz CPU s) +Run on (16 X 800.791 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.12, 1.19, 1.03 +Load Average: 1.00, 0.99, 0.79 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 859 ns 859 ns 811645 +bm_call::direct__Function::set_string 870 ns 870 ns 802924 -bm_call::via_function_ptr__Function::set_string 868 ns 868 ns 810851 -bm_call::via_function_ptr____Method::set_string 865 ns 865 ns 807435 +bm_call::via_function_ptr__Function::set_string 858 ns 858 ns 815437 +bm_call::via_function_ptr____Method::set_string 859 ns 859 ns 815933 -bm_std::function_calls__Function::set_string 864 ns 863 ns 780880 -bm_std::function_calls____Method::set_string 872 ns 872 ns 806447 +bm_std::function_calls__Function::set_string 874 ns 874 ns 798507 +bm_std::function_calls____Method::set_string 885 ns 885 ns 793864 -bm_rtl::function_calls__Function::set_string 866 ns 865 ns 809246 -bm_rtl::method_calls______Method::set_string 857 ns 857 ns 818472 +bm_rtl::function_calls__Function::set_string 873 ns 873 ns 797727 +bm_rtl::method_calls______Method::set_string 876 ns 875 ns 802078 -bm_rtl::function__ErasedReturnType::set_string 880 ns 880 ns 787509 -bm_rtl::method____ErasedReturnType::set_string 876 ns 876 ns 795235 -bm_rtl::method____ErasedTargetType::set_string 866 ns 866 ns 790561 -bm_rtl::method____ErasedTargetAndReturnType::set_string 880 ns 880 ns 799653 +bm_rtl::function__ErasedReturnType::set_string 883 ns 883 ns 791520 +bm_rtl::method____ErasedReturnType::set_string 870 ns 869 ns 807324 +bm_rtl::method____ErasedTargetType::set_string 878 ns 878 ns 797789 +bm_rtl::method____ErasedTargetAndReturnType::set_string 872 ns 872 ns 799885 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1656 ns 1656 ns 423691 +bm_call::direct__Function::get_string 1584 ns 1584 ns 442078 -bm_call::via_function_ptr__Function::get_string 1645 ns 1645 ns 412059 -bm_call::via_function_ptr____Method::get_string 1651 ns 1651 ns 421852 +bm_call::via_function_ptr__Function::get_string 1585 ns 1584 ns 441731 +bm_call::via_function_ptr____Method::get_string 1582 ns 1582 ns 442494 -bm_std::function_calls__Function::get_string 1674 ns 1674 ns 417578 -bm_std::function_calls____Method::get_string 1656 ns 1656 ns 425072 +bm_std::function_calls__Function::get_string 1576 ns 1576 ns 444173 +bm_std::function_calls____Method::get_string 1577 ns 1577 ns 443790 -bm_rtl::function_calls__Function::get_string 1631 ns 1631 ns 426111 -bm_rtl::method_calls______Method::get_string 1724 ns 1724 ns 420215 +bm_rtl::function_calls__Function::get_string 1580 ns 1580 ns 442964 +bm_rtl::method_calls______Method::get_string 1581 ns 1581 ns 442876 -bm_rtl::function__ErasedReturnType::get_string 2239 ns 2239 ns 319096 -bm_rtl::method____ErasedReturnType::get_string 2118 ns 2117 ns 319400 -bm_rtl::method____ErasedTargetType::get_string 1635 ns 1634 ns 419574 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2082 ns 2081 ns 341195 +bm_rtl::function__ErasedReturnType::get_string 1600 ns 1600 ns 437508 +bm_rtl::method____ErasedReturnType::get_string 1595 ns 1595 ns 439061 +bm_rtl::method____ErasedTargetType::get_string 1595 ns 1595 ns 438882 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1597 ns 1597 ns 438309 ----------------------------------- -[2025-11-04 12:27:29] >>> Run 2: workload scale = 45 +[2026-01-19 23:11:34] >>> Run 2: workload scale = 45 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 45 iterations ============================================= -2025-11-04T12:27:29+05:30 +2026-01-19T23:11:34+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4086.01 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.17, 1.19, 1.03 +Load Average: 1.00, 0.99, 0.79 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 879 ns 879 ns 763667 +bm_call::direct__Function::set_string 872 ns 872 ns 801839 -bm_call::via_function_ptr__Function::set_string 899 ns 899 ns 800493 -bm_call::via_function_ptr____Method::set_string 874 ns 874 ns 784385 +bm_call::via_function_ptr__Function::set_string 862 ns 862 ns 811605 +bm_call::via_function_ptr____Method::set_string 864 ns 864 ns 811446 -bm_std::function_calls__Function::set_string 917 ns 916 ns 791343 -bm_std::function_calls____Method::set_string 895 ns 894 ns 722973 +bm_std::function_calls__Function::set_string 869 ns 868 ns 804505 +bm_std::function_calls____Method::set_string 861 ns 861 ns 812636 -bm_rtl::function_calls__Function::set_string 901 ns 901 ns 809623 -bm_rtl::method_calls______Method::set_string 886 ns 886 ns 772267 +bm_rtl::function_calls__Function::set_string 865 ns 865 ns 807848 +bm_rtl::method_calls______Method::set_string 865 ns 865 ns 809801 -bm_rtl::function__ErasedReturnType::set_string 869 ns 869 ns 807341 -bm_rtl::method____ErasedReturnType::set_string 869 ns 869 ns 806497 -bm_rtl::method____ErasedTargetType::set_string 868 ns 868 ns 808556 -bm_rtl::method____ErasedTargetAndReturnType::set_string 869 ns 869 ns 807730 +bm_rtl::function__ErasedReturnType::set_string 859 ns 859 ns 814420 +bm_rtl::method____ErasedReturnType::set_string 855 ns 855 ns 820098 +bm_rtl::method____ErasedTargetType::set_string 866 ns 866 ns 808728 +bm_rtl::method____ErasedTargetAndReturnType::set_string 861 ns 861 ns 810431 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1570 ns 1570 ns 445252 +bm_call::direct__Function::get_string 1584 ns 1584 ns 441922 -bm_call::via_function_ptr__Function::get_string 1566 ns 1566 ns 446490 -bm_call::via_function_ptr____Method::get_string 1564 ns 1564 ns 447557 +bm_call::via_function_ptr__Function::get_string 1591 ns 1591 ns 439923 +bm_call::via_function_ptr____Method::get_string 1580 ns 1580 ns 442731 -bm_std::function_calls__Function::get_string 1565 ns 1565 ns 447484 -bm_std::function_calls____Method::get_string 1567 ns 1567 ns 447153 +bm_std::function_calls__Function::get_string 1578 ns 1578 ns 444219 +bm_std::function_calls____Method::get_string 1577 ns 1577 ns 443864 -bm_rtl::function_calls__Function::get_string 1560 ns 1560 ns 449067 -bm_rtl::method_calls______Method::get_string 1558 ns 1558 ns 449923 +bm_rtl::function_calls__Function::get_string 1589 ns 1589 ns 440690 +bm_rtl::method_calls______Method::get_string 1583 ns 1582 ns 442763 -bm_rtl::function__ErasedReturnType::get_string 2038 ns 2038 ns 342820 -bm_rtl::method____ErasedReturnType::get_string 2039 ns 2039 ns 343146 -bm_rtl::method____ErasedTargetType::get_string 1573 ns 1573 ns 445077 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2045 ns 2045 ns 342394 +bm_rtl::function__ErasedReturnType::get_string 1591 ns 1591 ns 439944 +bm_rtl::method____ErasedReturnType::get_string 1592 ns 1592 ns 439921 +bm_rtl::method____ErasedTargetType::get_string 1591 ns 1591 ns 439971 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1598 ns 1598 ns 435789 ----------------------------------- -[2025-11-04 12:27:48] >>> Run 3: workload scale = 45 +[2026-01-19 23:11:52] >>> Run 3: workload scale = 45 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 45 iterations ============================================= -2025-11-04T12:27:48+05:30 +2026-01-19T23:11:52+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1751,50 +1751,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.25, 1.21, 1.04 +Load Average: 1.00, 0.99, 0.80 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 861 ns 861 ns 814704 +bm_call::direct__Function::set_string 869 ns 868 ns 803084 -bm_call::via_function_ptr__Function::set_string 857 ns 857 ns 817829 -bm_call::via_function_ptr____Method::set_string 858 ns 858 ns 813922 +bm_call::via_function_ptr__Function::set_string 871 ns 871 ns 804343 +bm_call::via_function_ptr____Method::set_string 871 ns 871 ns 804572 -bm_std::function_calls__Function::set_string 863 ns 863 ns 813055 -bm_std::function_calls____Method::set_string 857 ns 857 ns 812189 +bm_std::function_calls__Function::set_string 870 ns 870 ns 804950 +bm_std::function_calls____Method::set_string 884 ns 884 ns 791010 -bm_rtl::function_calls__Function::set_string 860 ns 860 ns 815403 -bm_rtl::method_calls______Method::set_string 855 ns 855 ns 817960 +bm_rtl::function_calls__Function::set_string 886 ns 886 ns 793192 +bm_rtl::method_calls______Method::set_string 885 ns 885 ns 792897 -bm_rtl::function__ErasedReturnType::set_string 863 ns 863 ns 811827 -bm_rtl::method____ErasedReturnType::set_string 864 ns 864 ns 812329 -bm_rtl::method____ErasedTargetType::set_string 859 ns 859 ns 811367 -bm_rtl::method____ErasedTargetAndReturnType::set_string 872 ns 872 ns 806139 +bm_rtl::function__ErasedReturnType::set_string 879 ns 879 ns 799665 +bm_rtl::method____ErasedReturnType::set_string 868 ns 868 ns 807084 +bm_rtl::method____ErasedTargetType::set_string 876 ns 876 ns 797585 +bm_rtl::method____ErasedTargetAndReturnType::set_string 869 ns 869 ns 806557 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1579 ns 1579 ns 443558 +bm_call::direct__Function::get_string 1652 ns 1652 ns 423648 -bm_call::via_function_ptr__Function::get_string 1567 ns 1566 ns 447638 -bm_call::via_function_ptr____Method::get_string 1561 ns 1561 ns 448644 +bm_call::via_function_ptr__Function::get_string 1652 ns 1652 ns 423806 +bm_call::via_function_ptr____Method::get_string 1668 ns 1667 ns 419958 -bm_std::function_calls__Function::get_string 1578 ns 1578 ns 443746 -bm_std::function_calls____Method::get_string 1579 ns 1579 ns 442695 +bm_std::function_calls__Function::get_string 1649 ns 1649 ns 424602 +bm_std::function_calls____Method::get_string 1649 ns 1649 ns 424942 -bm_rtl::function_calls__Function::get_string 1560 ns 1560 ns 448822 -bm_rtl::method_calls______Method::get_string 1567 ns 1567 ns 447470 +bm_rtl::function_calls__Function::get_string 1661 ns 1661 ns 421345 +bm_rtl::method_calls______Method::get_string 1659 ns 1659 ns 417122 -bm_rtl::function__ErasedReturnType::get_string 2039 ns 2039 ns 343449 -bm_rtl::method____ErasedReturnType::get_string 2043 ns 2043 ns 343320 -bm_rtl::method____ErasedTargetType::get_string 1578 ns 1578 ns 443800 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2048 ns 2048 ns 342248 +bm_rtl::function__ErasedReturnType::get_string 1675 ns 1674 ns 418135 +bm_rtl::method____ErasedReturnType::get_string 1666 ns 1665 ns 421033 +bm_rtl::method____ErasedTargetType::get_string 1669 ns 1668 ns 419528 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1671 ns 1671 ns 419526 ----------------------------------- -[2025-11-04 12:28:06] >>> Run 1: workload scale = 50 +[2026-01-19 23:12:11] >>> Run 1: workload scale = 50 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 50 iterations ============================================= -2025-11-04T12:28:06+05:30 +2026-01-19T23:12:11+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1802,50 +1802,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.26, 1.21, 1.04 +Load Average: 1.00, 0.99, 0.80 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 926 ns 926 ns 751413 +bm_call::direct__Function::set_string 941 ns 941 ns 742656 -bm_call::via_function_ptr__Function::set_string 915 ns 915 ns 767518 -bm_call::via_function_ptr____Method::set_string 919 ns 919 ns 763863 +bm_call::via_function_ptr__Function::set_string 932 ns 932 ns 750908 +bm_call::via_function_ptr____Method::set_string 932 ns 932 ns 751864 -bm_std::function_calls__Function::set_string 937 ns 937 ns 751780 -bm_std::function_calls____Method::set_string 936 ns 936 ns 746176 +bm_std::function_calls__Function::set_string 940 ns 940 ns 744365 +bm_std::function_calls____Method::set_string 944 ns 944 ns 744594 -bm_rtl::function_calls__Function::set_string 920 ns 920 ns 758837 -bm_rtl::method_calls______Method::set_string 917 ns 917 ns 767318 +bm_rtl::function_calls__Function::set_string 931 ns 931 ns 752321 +bm_rtl::method_calls______Method::set_string 931 ns 930 ns 752576 -bm_rtl::function__ErasedReturnType::set_string 933 ns 933 ns 750999 -bm_rtl::method____ErasedReturnType::set_string 929 ns 929 ns 755410 -bm_rtl::method____ErasedTargetType::set_string 928 ns 928 ns 756971 -bm_rtl::method____ErasedTargetAndReturnType::set_string 936 ns 936 ns 747793 +bm_rtl::function__ErasedReturnType::set_string 933 ns 933 ns 751301 +bm_rtl::method____ErasedReturnType::set_string 933 ns 933 ns 749838 +bm_rtl::method____ErasedTargetType::set_string 947 ns 947 ns 743833 +bm_rtl::method____ErasedTargetAndReturnType::set_string 932 ns 932 ns 750030 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1788 ns 1788 ns 391424 +bm_call::direct__Function::get_string 1826 ns 1826 ns 383413 -bm_call::via_function_ptr__Function::get_string 1786 ns 1786 ns 389634 -bm_call::via_function_ptr____Method::get_string 1783 ns 1782 ns 392565 +bm_call::via_function_ptr__Function::get_string 1825 ns 1825 ns 381343 +bm_call::via_function_ptr____Method::get_string 1841 ns 1841 ns 380366 -bm_std::function_calls__Function::get_string 1790 ns 1790 ns 391537 -bm_std::function_calls____Method::get_string 1784 ns 1784 ns 392494 +bm_std::function_calls__Function::get_string 1829 ns 1829 ns 383133 +bm_std::function_calls____Method::get_string 1829 ns 1828 ns 382798 -bm_rtl::function_calls__Function::get_string 1702 ns 1702 ns 412018 -bm_rtl::method_calls______Method::get_string 1698 ns 1698 ns 412199 +bm_rtl::function_calls__Function::get_string 1826 ns 1826 ns 384168 +bm_rtl::method_calls______Method::get_string 1825 ns 1825 ns 383462 -bm_rtl::function__ErasedReturnType::get_string 2253 ns 2253 ns 311171 -bm_rtl::method____ErasedReturnType::get_string 2246 ns 2246 ns 311656 -bm_rtl::method____ErasedTargetType::get_string 1715 ns 1715 ns 408229 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2250 ns 2250 ns 310623 +bm_rtl::function__ErasedReturnType::get_string 1845 ns 1845 ns 380179 +bm_rtl::method____ErasedReturnType::get_string 1844 ns 1844 ns 379553 +bm_rtl::method____ErasedTargetType::get_string 1846 ns 1846 ns 379999 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1844 ns 1844 ns 379675 ----------------------------------- -[2025-11-04 12:28:25] >>> Run 2: workload scale = 50 +[2026-01-19 23:12:30] >>> Run 2: workload scale = 50 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 50 iterations ============================================= -2025-11-04T12:28:25+05:30 +2026-01-19T23:12:30+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1853,50 +1853,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.19, 1.20, 1.04 +Load Average: 1.00, 1.00, 0.81 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 926 ns 926 ns 740549 +bm_call::direct__Function::set_string 933 ns 933 ns 747023 -bm_call::via_function_ptr__Function::set_string 916 ns 916 ns 770299 -bm_call::via_function_ptr____Method::set_string 916 ns 916 ns 762809 +bm_call::via_function_ptr__Function::set_string 926 ns 926 ns 756314 +bm_call::via_function_ptr____Method::set_string 926 ns 926 ns 755547 -bm_std::function_calls__Function::set_string 938 ns 938 ns 745627 -bm_std::function_calls____Method::set_string 935 ns 935 ns 750822 +bm_std::function_calls__Function::set_string 938 ns 938 ns 747825 +bm_std::function_calls____Method::set_string 940 ns 940 ns 745786 -bm_rtl::function_calls__Function::set_string 918 ns 918 ns 763866 -bm_rtl::method_calls______Method::set_string 917 ns 917 ns 765743 +bm_rtl::function_calls__Function::set_string 925 ns 925 ns 756240 +bm_rtl::method_calls______Method::set_string 927 ns 927 ns 756178 -bm_rtl::function__ErasedReturnType::set_string 932 ns 932 ns 751226 -bm_rtl::method____ErasedReturnType::set_string 935 ns 935 ns 746666 -bm_rtl::method____ErasedTargetType::set_string 931 ns 931 ns 751925 -bm_rtl::method____ErasedTargetAndReturnType::set_string 943 ns 943 ns 743274 +bm_rtl::function__ErasedReturnType::set_string 933 ns 933 ns 749774 +bm_rtl::method____ErasedReturnType::set_string 935 ns 935 ns 749882 +bm_rtl::method____ErasedTargetType::set_string 941 ns 941 ns 745341 +bm_rtl::method____ErasedTargetAndReturnType::set_string 937 ns 937 ns 746139 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1704 ns 1704 ns 411061 +bm_call::direct__Function::get_string 1726 ns 1726 ns 405922 -bm_call::via_function_ptr__Function::get_string 1701 ns 1701 ns 411864 -bm_call::via_function_ptr____Method::get_string 1696 ns 1696 ns 412619 +bm_call::via_function_ptr__Function::get_string 1726 ns 1726 ns 405314 +bm_call::via_function_ptr____Method::get_string 1728 ns 1728 ns 405268 -bm_std::function_calls__Function::get_string 1699 ns 1699 ns 411971 -bm_std::function_calls____Method::get_string 1698 ns 1698 ns 412360 +bm_std::function_calls__Function::get_string 1727 ns 1727 ns 405436 +bm_std::function_calls____Method::get_string 1735 ns 1735 ns 403964 -bm_rtl::function_calls__Function::get_string 1695 ns 1694 ns 413307 -bm_rtl::method_calls______Method::get_string 1694 ns 1694 ns 413337 +bm_rtl::function_calls__Function::get_string 1723 ns 1722 ns 406561 +bm_rtl::method_calls______Method::get_string 1727 ns 1726 ns 405472 -bm_rtl::function__ErasedReturnType::get_string 2245 ns 2245 ns 311139 -bm_rtl::method____ErasedReturnType::get_string 2240 ns 2240 ns 312685 -bm_rtl::method____ErasedTargetType::get_string 1709 ns 1709 ns 409763 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2243 ns 2243 ns 311738 +bm_rtl::function__ErasedReturnType::get_string 1756 ns 1756 ns 396426 +bm_rtl::method____ErasedReturnType::get_string 1757 ns 1756 ns 398483 +bm_rtl::method____ErasedTargetType::get_string 1756 ns 1756 ns 399103 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1759 ns 1758 ns 397872 ----------------------------------- -[2025-11-04 12:28:44] >>> Run 3: workload scale = 50 +[2026-01-19 23:12:48] >>> Run 3: workload scale = 50 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 50 iterations ============================================= -2025-11-04T12:28:44+05:30 +2026-01-19T23:12:48+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1904,611 +1904,611 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.14, 1.19, 1.04 +Load Average: 1.00, 1.00, 0.81 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 917 ns 917 ns 757756 +bm_call::direct__Function::set_string 943 ns 943 ns 743159 -bm_call::via_function_ptr__Function::set_string 906 ns 906 ns 777002 -bm_call::via_function_ptr____Method::set_string 908 ns 907 ns 772247 +bm_call::via_function_ptr__Function::set_string 929 ns 929 ns 756283 +bm_call::via_function_ptr____Method::set_string 934 ns 934 ns 755878 -bm_std::function_calls__Function::set_string 931 ns 931 ns 745509 -bm_std::function_calls____Method::set_string 928 ns 928 ns 754015 +bm_std::function_calls__Function::set_string 949 ns 949 ns 738684 +bm_std::function_calls____Method::set_string 950 ns 950 ns 735773 -bm_rtl::function_calls__Function::set_string 916 ns 916 ns 766789 -bm_rtl::method_calls______Method::set_string 909 ns 909 ns 770952 +bm_rtl::function_calls__Function::set_string 936 ns 936 ns 749057 +bm_rtl::method_calls______Method::set_string 931 ns 931 ns 749496 -bm_rtl::function__ErasedReturnType::set_string 931 ns 931 ns 751400 -bm_rtl::method____ErasedReturnType::set_string 927 ns 927 ns 746782 -bm_rtl::method____ErasedTargetType::set_string 925 ns 925 ns 757055 -bm_rtl::method____ErasedTargetAndReturnType::set_string 930 ns 930 ns 753039 +bm_rtl::function__ErasedReturnType::set_string 931 ns 931 ns 751200 +bm_rtl::method____ErasedReturnType::set_string 942 ns 942 ns 750312 +bm_rtl::method____ErasedTargetType::set_string 946 ns 946 ns 734994 +bm_rtl::method____ErasedTargetAndReturnType::set_string 949 ns 949 ns 738347 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1705 ns 1705 ns 410944 +bm_call::direct__Function::get_string 1729 ns 1729 ns 404989 -bm_call::via_function_ptr__Function::get_string 1705 ns 1705 ns 411331 -bm_call::via_function_ptr____Method::get_string 1699 ns 1698 ns 412291 +bm_call::via_function_ptr__Function::get_string 1731 ns 1731 ns 404924 +bm_call::via_function_ptr____Method::get_string 1731 ns 1730 ns 404859 -bm_std::function_calls__Function::get_string 1701 ns 1701 ns 411580 -bm_std::function_calls____Method::get_string 1695 ns 1694 ns 410757 +bm_std::function_calls__Function::get_string 1738 ns 1738 ns 404856 +bm_std::function_calls____Method::get_string 1744 ns 1744 ns 403238 -bm_rtl::function_calls__Function::get_string 1697 ns 1697 ns 412312 -bm_rtl::method_calls______Method::get_string 1699 ns 1699 ns 412540 +bm_rtl::function_calls__Function::get_string 1729 ns 1729 ns 405316 +bm_rtl::method_calls______Method::get_string 1728 ns 1727 ns 405900 -bm_rtl::function__ErasedReturnType::get_string 2241 ns 2241 ns 312288 -bm_rtl::method____ErasedReturnType::get_string 2246 ns 2246 ns 312211 -bm_rtl::method____ErasedTargetType::get_string 1710 ns 1709 ns 409508 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2248 ns 2248 ns 311951 +bm_rtl::function__ErasedReturnType::get_string 1740 ns 1740 ns 401698 +bm_rtl::method____ErasedReturnType::get_string 1744 ns 1744 ns 402000 +bm_rtl::method____ErasedTargetType::get_string 1743 ns 1743 ns 401434 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1743 ns 1743 ns 401534 ----------------------------------- -[2025-11-04 12:29:03] >>> Run 1: workload scale = 58 +[2026-01-19 23:13:07] >>> Run 1: workload scale = 58 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 58 iterations ============================================= -2025-11-04T12:29:03+05:30 +2026-01-19T23:13:07+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 800 MHz CPU s) +Run on (16 X 1208.8 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.10, 1.18, 1.04 +Load Average: 1.00, 1.00, 0.82 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1031 ns 1031 ns 675248 +bm_call::direct__Function::set_string 1036 ns 1036 ns 673890 -bm_call::via_function_ptr__Function::set_string 1026 ns 1026 ns 682545 -bm_call::via_function_ptr____Method::set_string 1027 ns 1027 ns 684770 +bm_call::via_function_ptr__Function::set_string 1034 ns 1034 ns 677703 +bm_call::via_function_ptr____Method::set_string 1035 ns 1035 ns 677912 -bm_std::function_calls__Function::set_string 1034 ns 1034 ns 676829 -bm_std::function_calls____Method::set_string 1035 ns 1035 ns 675698 +bm_std::function_calls__Function::set_string 1038 ns 1038 ns 673043 +bm_std::function_calls____Method::set_string 1049 ns 1049 ns 670179 -bm_rtl::function_calls__Function::set_string 1027 ns 1027 ns 682713 -bm_rtl::method_calls______Method::set_string 1043 ns 1043 ns 670770 +bm_rtl::function_calls__Function::set_string 1043 ns 1043 ns 671982 +bm_rtl::method_calls______Method::set_string 1044 ns 1044 ns 669684 -bm_rtl::function__ErasedReturnType::set_string 1033 ns 1033 ns 678708 -bm_rtl::method____ErasedReturnType::set_string 1030 ns 1030 ns 679008 -bm_rtl::method____ErasedTargetType::set_string 1030 ns 1030 ns 681699 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1032 ns 1031 ns 680008 +bm_rtl::function__ErasedReturnType::set_string 1052 ns 1052 ns 665822 +bm_rtl::method____ErasedReturnType::set_string 1052 ns 1052 ns 665002 +bm_rtl::method____ErasedTargetType::set_string 1054 ns 1054 ns 665921 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1051 ns 1050 ns 666979 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2019 ns 2019 ns 347188 +bm_call::direct__Function::get_string 2135 ns 2134 ns 328156 -bm_call::via_function_ptr__Function::get_string 2013 ns 2013 ns 347842 -bm_call::via_function_ptr____Method::get_string 2010 ns 2010 ns 348147 +bm_call::via_function_ptr__Function::get_string 2135 ns 2135 ns 326430 +bm_call::via_function_ptr____Method::get_string 2138 ns 2137 ns 327594 -bm_std::function_calls__Function::get_string 2017 ns 2017 ns 345495 -bm_std::function_calls____Method::get_string 2013 ns 2013 ns 347790 +bm_std::function_calls__Function::get_string 2134 ns 2134 ns 328582 +bm_std::function_calls____Method::get_string 2130 ns 2130 ns 328683 -bm_rtl::function_calls__Function::get_string 2012 ns 2012 ns 348405 -bm_rtl::method_calls______Method::get_string 2004 ns 2004 ns 349276 +bm_rtl::function_calls__Function::get_string 2137 ns 2137 ns 328106 +bm_rtl::method_calls______Method::get_string 2136 ns 2136 ns 327721 -bm_rtl::function__ErasedReturnType::get_string 2618 ns 2618 ns 267985 -bm_rtl::method____ErasedReturnType::get_string 2615 ns 2615 ns 267741 -bm_rtl::method____ErasedTargetType::get_string 2027 ns 2027 ns 345609 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2617 ns 2617 ns 266663 +bm_rtl::function__ErasedReturnType::get_string 2174 ns 2174 ns 322539 +bm_rtl::method____ErasedReturnType::get_string 2155 ns 2155 ns 324740 +bm_rtl::method____ErasedTargetType::get_string 2169 ns 2169 ns 322686 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2156 ns 2156 ns 324664 ----------------------------------- -[2025-11-04 12:29:22] >>> Run 2: workload scale = 58 +[2026-01-19 23:13:26] >>> Run 2: workload scale = 58 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 58 iterations ============================================= -2025-11-04T12:29:22+05:30 +2026-01-19T23:13:26+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 973.131 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.07, 1.16, 1.04 +Load Average: 1.00, 1.00, 0.82 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1028 ns 1028 ns 677855 +bm_call::direct__Function::set_string 1035 ns 1034 ns 674626 -bm_call::via_function_ptr__Function::set_string 1030 ns 1030 ns 679335 -bm_call::via_function_ptr____Method::set_string 1030 ns 1030 ns 680947 +bm_call::via_function_ptr__Function::set_string 1043 ns 1043 ns 669988 +bm_call::via_function_ptr____Method::set_string 1043 ns 1043 ns 672110 -bm_std::function_calls__Function::set_string 1027 ns 1027 ns 684721 -bm_std::function_calls____Method::set_string 1026 ns 1026 ns 681824 +bm_std::function_calls__Function::set_string 1037 ns 1037 ns 677404 +bm_std::function_calls____Method::set_string 1034 ns 1034 ns 679051 -bm_rtl::function_calls__Function::set_string 1029 ns 1029 ns 678759 -bm_rtl::method_calls______Method::set_string 1029 ns 1029 ns 681165 +bm_rtl::function_calls__Function::set_string 1042 ns 1042 ns 671296 +bm_rtl::method_calls______Method::set_string 1041 ns 1041 ns 672638 -bm_rtl::function__ErasedReturnType::set_string 1034 ns 1034 ns 677875 -bm_rtl::method____ErasedReturnType::set_string 1035 ns 1035 ns 676821 -bm_rtl::method____ErasedTargetType::set_string 1030 ns 1030 ns 680401 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1033 ns 1033 ns 678651 +bm_rtl::function__ErasedReturnType::set_string 1046 ns 1046 ns 669870 +bm_rtl::method____ErasedReturnType::set_string 1045 ns 1045 ns 669132 +bm_rtl::method____ErasedTargetType::set_string 1056 ns 1056 ns 663154 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1044 ns 1044 ns 669553 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2008 ns 2007 ns 348680 +bm_call::direct__Function::get_string 2044 ns 2044 ns 342513 -bm_call::via_function_ptr__Function::get_string 2012 ns 2012 ns 348322 -bm_call::via_function_ptr____Method::get_string 2007 ns 2007 ns 348814 +bm_call::via_function_ptr__Function::get_string 2042 ns 2042 ns 342924 +bm_call::via_function_ptr____Method::get_string 2046 ns 2045 ns 341909 -bm_std::function_calls__Function::get_string 2004 ns 2004 ns 349186 -bm_std::function_calls____Method::get_string 2002 ns 2002 ns 348243 +bm_std::function_calls__Function::get_string 2048 ns 2047 ns 341946 +bm_std::function_calls____Method::get_string 2050 ns 2050 ns 341378 -bm_rtl::function_calls__Function::get_string 2007 ns 2007 ns 348882 -bm_rtl::method_calls______Method::get_string 2004 ns 2004 ns 349758 +bm_rtl::function_calls__Function::get_string 2042 ns 2042 ns 342913 +bm_rtl::method_calls______Method::get_string 2044 ns 2044 ns 342229 -bm_rtl::function__ErasedReturnType::get_string 2604 ns 2604 ns 268928 -bm_rtl::method____ErasedReturnType::get_string 2612 ns 2612 ns 268364 -bm_rtl::method____ErasedTargetType::get_string 2016 ns 2016 ns 347257 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2614 ns 2614 ns 268179 +bm_rtl::function__ErasedReturnType::get_string 2072 ns 2072 ns 337809 +bm_rtl::method____ErasedReturnType::get_string 2073 ns 2073 ns 338112 +bm_rtl::method____ErasedTargetType::get_string 2070 ns 2070 ns 338166 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2074 ns 2074 ns 337414 ----------------------------------- -[2025-11-04 12:29:41] >>> Run 3: workload scale = 58 +[2026-01-19 23:13:46] >>> Run 3: workload scale = 58 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 58 iterations ============================================= -2025-11-04T12:29:41+05:30 +2026-01-19T23:13:46+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2968.51 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.05, 1.15, 1.04 +Load Average: 1.00, 1.00, 0.83 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1040 ns 1040 ns 671097 +bm_call::direct__Function::set_string 1044 ns 1044 ns 670022 -bm_call::via_function_ptr__Function::set_string 1033 ns 1033 ns 676942 -bm_call::via_function_ptr____Method::set_string 1030 ns 1030 ns 678677 +bm_call::via_function_ptr__Function::set_string 1052 ns 1052 ns 665303 +bm_call::via_function_ptr____Method::set_string 1053 ns 1053 ns 664751 -bm_std::function_calls__Function::set_string 1038 ns 1038 ns 674691 -bm_std::function_calls____Method::set_string 1037 ns 1037 ns 675090 +bm_std::function_calls__Function::set_string 1035 ns 1035 ns 677148 +bm_std::function_calls____Method::set_string 1035 ns 1035 ns 676481 -bm_rtl::function_calls__Function::set_string 1026 ns 1026 ns 678381 -bm_rtl::method_calls______Method::set_string 1032 ns 1032 ns 679923 +bm_rtl::function_calls__Function::set_string 1044 ns 1044 ns 670259 +bm_rtl::method_calls______Method::set_string 1045 ns 1045 ns 669178 -bm_rtl::function__ErasedReturnType::set_string 1033 ns 1033 ns 675492 -bm_rtl::method____ErasedReturnType::set_string 1037 ns 1037 ns 674332 -bm_rtl::method____ErasedTargetType::set_string 1033 ns 1033 ns 680263 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1035 ns 1035 ns 675409 +bm_rtl::function__ErasedReturnType::set_string 1045 ns 1045 ns 671882 +bm_rtl::method____ErasedReturnType::set_string 1050 ns 1050 ns 666690 +bm_rtl::method____ErasedTargetType::set_string 1050 ns 1050 ns 666725 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1052 ns 1052 ns 664907 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2011 ns 2011 ns 348434 +bm_call::direct__Function::get_string 2120 ns 2120 ns 330220 -bm_call::via_function_ptr__Function::get_string 2005 ns 2005 ns 349051 -bm_call::via_function_ptr____Method::get_string 2007 ns 2006 ns 349321 +bm_call::via_function_ptr__Function::get_string 2121 ns 2121 ns 330103 +bm_call::via_function_ptr____Method::get_string 2122 ns 2122 ns 329772 -bm_std::function_calls__Function::get_string 2007 ns 2007 ns 348916 -bm_std::function_calls____Method::get_string 2012 ns 2012 ns 348275 +bm_std::function_calls__Function::get_string 2121 ns 2121 ns 329881 +bm_std::function_calls____Method::get_string 2131 ns 2131 ns 328635 -bm_rtl::function_calls__Function::get_string 2002 ns 2002 ns 349353 -bm_rtl::method_calls______Method::get_string 1998 ns 1998 ns 350484 +bm_rtl::function_calls__Function::get_string 2120 ns 2120 ns 330342 +bm_rtl::method_calls______Method::get_string 2121 ns 2121 ns 329984 -bm_rtl::function__ErasedReturnType::get_string 2604 ns 2604 ns 267612 -bm_rtl::method____ErasedReturnType::get_string 2604 ns 2604 ns 268910 -bm_rtl::method____ErasedTargetType::get_string 2018 ns 2018 ns 345292 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2607 ns 2607 ns 268415 +bm_rtl::function__ErasedReturnType::get_string 2148 ns 2147 ns 326030 +bm_rtl::method____ErasedReturnType::get_string 2138 ns 2138 ns 327419 +bm_rtl::method____ErasedTargetType::get_string 2140 ns 2140 ns 327116 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2143 ns 2143 ns 326651 ----------------------------------- -[2025-11-04 12:30:00] >>> Run 1: workload scale = 66 +[2026-01-19 23:14:05] >>> Run 1: workload scale = 66 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 66 iterations ============================================= -2025-11-04T12:30:00+05:30 +2026-01-19T23:14:05+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2220.56 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 1.14, 1.03 +Load Average: 1.00, 1.00, 0.83 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1634 ns 1633 ns 428902 +bm_call::direct__Function::set_string 1644 ns 1644 ns 425244 -bm_call::via_function_ptr__Function::set_string 1630 ns 1629 ns 429772 -bm_call::via_function_ptr____Method::set_string 1631 ns 1631 ns 430681 +bm_call::via_function_ptr__Function::set_string 1646 ns 1645 ns 425948 +bm_call::via_function_ptr____Method::set_string 1644 ns 1644 ns 425773 -bm_std::function_calls__Function::set_string 1631 ns 1631 ns 428808 -bm_std::function_calls____Method::set_string 1635 ns 1635 ns 428582 +bm_std::function_calls__Function::set_string 1643 ns 1643 ns 425435 +bm_std::function_calls____Method::set_string 1645 ns 1644 ns 425697 -bm_rtl::function_calls__Function::set_string 1630 ns 1630 ns 429178 -bm_rtl::method_calls______Method::set_string 1633 ns 1632 ns 428391 +bm_rtl::function_calls__Function::set_string 1646 ns 1646 ns 425217 +bm_rtl::method_calls______Method::set_string 1646 ns 1645 ns 424786 -bm_rtl::function__ErasedReturnType::set_string 1636 ns 1636 ns 424931 -bm_rtl::method____ErasedReturnType::set_string 1639 ns 1639 ns 426912 -bm_rtl::method____ErasedTargetType::set_string 1637 ns 1637 ns 427969 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1637 ns 1637 ns 427833 +bm_rtl::function__ErasedReturnType::set_string 1650 ns 1650 ns 424522 +bm_rtl::method____ErasedReturnType::set_string 1649 ns 1648 ns 424894 +bm_rtl::method____ErasedTargetType::set_string 1656 ns 1656 ns 422916 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1647 ns 1647 ns 425320 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2782 ns 2782 ns 251867 +bm_call::direct__Function::get_string 2773 ns 2773 ns 252410 -bm_call::via_function_ptr__Function::get_string 2777 ns 2777 ns 252122 -bm_call::via_function_ptr____Method::get_string 2783 ns 2783 ns 251687 +bm_call::via_function_ptr__Function::get_string 2773 ns 2773 ns 251796 +bm_call::via_function_ptr____Method::get_string 2777 ns 2777 ns 252131 -bm_std::function_calls__Function::get_string 2790 ns 2790 ns 250927 -bm_std::function_calls____Method::get_string 2781 ns 2781 ns 252071 +bm_std::function_calls__Function::get_string 2772 ns 2772 ns 252502 +bm_std::function_calls____Method::get_string 2772 ns 2771 ns 252584 -bm_rtl::function_calls__Function::get_string 2783 ns 2782 ns 251500 -bm_rtl::method_calls______Method::get_string 2781 ns 2781 ns 252113 +bm_rtl::function_calls__Function::get_string 2773 ns 2773 ns 252563 +bm_rtl::method_calls______Method::get_string 2774 ns 2773 ns 252472 -bm_rtl::function__ErasedReturnType::get_string 3385 ns 3384 ns 206887 -bm_rtl::method____ErasedReturnType::get_string 3389 ns 3389 ns 206881 -bm_rtl::method____ErasedTargetType::get_string 2796 ns 2796 ns 250294 -bm_rtl::method____ErasedTargetAndReturnType::get_string 3391 ns 3391 ns 206588 +bm_rtl::function__ErasedReturnType::get_string 2792 ns 2791 ns 250676 +bm_rtl::method____ErasedReturnType::get_string 2792 ns 2791 ns 250735 +bm_rtl::method____ErasedTargetType::get_string 2785 ns 2785 ns 251378 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2794 ns 2794 ns 250478 ----------------------------------- -[2025-11-04 12:30:22] >>> Run 2: workload scale = 66 +[2026-01-19 23:14:26] >>> Run 2: workload scale = 66 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 66 iterations ============================================= -2025-11-04T12:30:22+05:30 +2026-01-19T23:14:26+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3530.37 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 1.13, 1.03 +Load Average: 1.00, 1.00, 0.83 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1622 ns 1622 ns 430852 +bm_call::direct__Function::set_string 1668 ns 1667 ns 419315 -bm_call::via_function_ptr__Function::set_string 1623 ns 1623 ns 431449 -bm_call::via_function_ptr____Method::set_string 1621 ns 1621 ns 431436 +bm_call::via_function_ptr__Function::set_string 1664 ns 1664 ns 420753 +bm_call::via_function_ptr____Method::set_string 1664 ns 1664 ns 420532 -bm_std::function_calls__Function::set_string 1625 ns 1625 ns 430362 -bm_std::function_calls____Method::set_string 1625 ns 1625 ns 431010 +bm_std::function_calls__Function::set_string 1680 ns 1680 ns 416510 +bm_std::function_calls____Method::set_string 1680 ns 1680 ns 416744 -bm_rtl::function_calls__Function::set_string 1624 ns 1624 ns 430846 -bm_rtl::method_calls______Method::set_string 1624 ns 1624 ns 431257 +bm_rtl::function_calls__Function::set_string 1688 ns 1687 ns 415205 +bm_rtl::method_calls______Method::set_string 1687 ns 1687 ns 414846 -bm_rtl::function__ErasedReturnType::set_string 1630 ns 1630 ns 428687 -bm_rtl::method____ErasedReturnType::set_string 1629 ns 1629 ns 429973 -bm_rtl::method____ErasedTargetType::set_string 1626 ns 1625 ns 430676 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1629 ns 1629 ns 430277 +bm_rtl::function__ErasedReturnType::set_string 1664 ns 1664 ns 420397 +bm_rtl::method____ErasedReturnType::set_string 1668 ns 1668 ns 419490 +bm_rtl::method____ErasedTargetType::set_string 1664 ns 1664 ns 420688 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1676 ns 1676 ns 417822 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2765 ns 2765 ns 253039 +bm_call::direct__Function::get_string 2882 ns 2882 ns 242896 -bm_call::via_function_ptr__Function::get_string 2763 ns 2763 ns 253401 -bm_call::via_function_ptr____Method::get_string 2763 ns 2763 ns 253536 +bm_call::via_function_ptr__Function::get_string 2884 ns 2883 ns 242700 +bm_call::via_function_ptr____Method::get_string 2880 ns 2879 ns 243154 -bm_std::function_calls__Function::get_string 2765 ns 2765 ns 253255 -bm_std::function_calls____Method::get_string 2761 ns 2761 ns 253706 +bm_std::function_calls__Function::get_string 2874 ns 2873 ns 243477 +bm_std::function_calls____Method::get_string 2857 ns 2856 ns 244960 -bm_rtl::function_calls__Function::get_string 2763 ns 2763 ns 253459 -bm_rtl::method_calls______Method::get_string 2758 ns 2758 ns 253800 +bm_rtl::function_calls__Function::get_string 2877 ns 2876 ns 243281 +bm_rtl::method_calls______Method::get_string 2877 ns 2877 ns 243243 -bm_rtl::function__ErasedReturnType::get_string 3375 ns 3375 ns 207380 -bm_rtl::method____ErasedReturnType::get_string 3368 ns 3368 ns 207775 -bm_rtl::method____ErasedTargetType::get_string 2782 ns 2782 ns 251728 -bm_rtl::method____ErasedTargetAndReturnType::get_string 3368 ns 3368 ns 207848 +bm_rtl::function__ErasedReturnType::get_string 2876 ns 2876 ns 243445 +bm_rtl::method____ErasedReturnType::get_string 2862 ns 2862 ns 244590 +bm_rtl::method____ErasedTargetType::get_string 2855 ns 2855 ns 245189 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2858 ns 2858 ns 244872 ----------------------------------- -[2025-11-04 12:30:42] >>> Run 3: workload scale = 66 +[2026-01-19 23:14:47] >>> Run 3: workload scale = 66 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 66 iterations ============================================= -2025-11-04T12:30:42+05:30 +2026-01-19T23:14:47+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3341.01 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 1.12, 1.03 +Load Average: 1.00, 1.00, 0.84 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1625 ns 1625 ns 430251 +bm_call::direct__Function::set_string 1664 ns 1664 ns 419877 -bm_call::via_function_ptr__Function::set_string 1626 ns 1626 ns 431687 -bm_call::via_function_ptr____Method::set_string 1626 ns 1625 ns 430629 +bm_call::via_function_ptr__Function::set_string 1661 ns 1661 ns 421577 +bm_call::via_function_ptr____Method::set_string 1659 ns 1659 ns 420994 -bm_std::function_calls__Function::set_string 1626 ns 1626 ns 430290 -bm_std::function_calls____Method::set_string 1629 ns 1629 ns 429636 +bm_std::function_calls__Function::set_string 1655 ns 1655 ns 422552 +bm_std::function_calls____Method::set_string 1657 ns 1656 ns 423207 -bm_rtl::function_calls__Function::set_string 1626 ns 1626 ns 430275 -bm_rtl::method_calls______Method::set_string 1627 ns 1627 ns 429935 +bm_rtl::function_calls__Function::set_string 1655 ns 1655 ns 422801 +bm_rtl::method_calls______Method::set_string 1656 ns 1655 ns 422724 -bm_rtl::function__ErasedReturnType::set_string 1640 ns 1640 ns 426127 -bm_rtl::method____ErasedReturnType::set_string 1643 ns 1643 ns 426224 -bm_rtl::method____ErasedTargetType::set_string 1640 ns 1640 ns 427764 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1643 ns 1643 ns 426215 +bm_rtl::function__ErasedReturnType::set_string 1656 ns 1656 ns 422506 +bm_rtl::method____ErasedReturnType::set_string 1655 ns 1655 ns 423293 +bm_rtl::method____ErasedTargetType::set_string 1660 ns 1659 ns 421827 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1664 ns 1664 ns 420188 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2773 ns 2773 ns 252463 +bm_call::direct__Function::get_string 2781 ns 2781 ns 251706 -bm_call::via_function_ptr__Function::get_string 2767 ns 2767 ns 252937 -bm_call::via_function_ptr____Method::get_string 2768 ns 2768 ns 252976 +bm_call::via_function_ptr__Function::get_string 2782 ns 2782 ns 251750 +bm_call::via_function_ptr____Method::get_string 2785 ns 2785 ns 251488 -bm_std::function_calls__Function::get_string 2772 ns 2772 ns 252487 -bm_std::function_calls____Method::get_string 2770 ns 2770 ns 252793 +bm_std::function_calls__Function::get_string 2782 ns 2782 ns 251453 +bm_std::function_calls____Method::get_string 2788 ns 2788 ns 250872 -bm_rtl::function_calls__Function::get_string 2767 ns 2767 ns 253164 -bm_rtl::method_calls______Method::get_string 2770 ns 2770 ns 252709 +bm_rtl::function_calls__Function::get_string 2780 ns 2780 ns 251731 +bm_rtl::method_calls______Method::get_string 2784 ns 2784 ns 251526 -bm_rtl::function__ErasedReturnType::get_string 3376 ns 3375 ns 207460 -bm_rtl::method____ErasedReturnType::get_string 3382 ns 3382 ns 207067 -bm_rtl::method____ErasedTargetType::get_string 2803 ns 2802 ns 249785 -bm_rtl::method____ErasedTargetAndReturnType::get_string 3384 ns 3384 ns 207041 +bm_rtl::function__ErasedReturnType::get_string 2790 ns 2790 ns 250718 +bm_rtl::method____ErasedReturnType::get_string 2795 ns 2795 ns 250540 +bm_rtl::method____ErasedTargetType::get_string 2788 ns 2787 ns 251050 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2793 ns 2793 ns 250457 ----------------------------------- -[2025-11-04 12:31:03] >>> Run 1: workload scale = 74 +[2026-01-19 23:15:07] >>> Run 1: workload scale = 74 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 74 iterations ============================================= -2025-11-04T12:31:03+05:30 +2026-01-19T23:15:07+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4041.98 MHz CPU s) +Run on (16 X 2068.8 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 1.11, 1.03 +Load Average: 1.00, 1.00, 0.84 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1716 ns 1715 ns 408274 +bm_call::direct__Function::set_string 1728 ns 1728 ns 403699 -bm_call::via_function_ptr__Function::set_string 1712 ns 1712 ns 409361 -bm_call::via_function_ptr____Method::set_string 1713 ns 1713 ns 405493 +bm_call::via_function_ptr__Function::set_string 1728 ns 1728 ns 405095 +bm_call::via_function_ptr____Method::set_string 1730 ns 1730 ns 404936 -bm_std::function_calls__Function::set_string 1718 ns 1717 ns 407832 -bm_std::function_calls____Method::set_string 1715 ns 1715 ns 408119 +bm_std::function_calls__Function::set_string 1717 ns 1717 ns 407293 +bm_std::function_calls____Method::set_string 1719 ns 1719 ns 407683 -bm_rtl::function_calls__Function::set_string 1713 ns 1713 ns 408560 -bm_rtl::method_calls______Method::set_string 1709 ns 1709 ns 409044 +bm_rtl::function_calls__Function::set_string 1715 ns 1715 ns 408399 +bm_rtl::method_calls______Method::set_string 1716 ns 1716 ns 408228 -bm_rtl::function__ErasedReturnType::set_string 1711 ns 1710 ns 408836 -bm_rtl::method____ErasedReturnType::set_string 1713 ns 1713 ns 408499 -bm_rtl::method____ErasedTargetType::set_string 1707 ns 1707 ns 409755 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1708 ns 1708 ns 409164 +bm_rtl::function__ErasedReturnType::set_string 1728 ns 1727 ns 405282 +bm_rtl::method____ErasedReturnType::set_string 1732 ns 1732 ns 404288 +bm_rtl::method____ErasedTargetType::set_string 1728 ns 1728 ns 405001 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1744 ns 1744 ns 401021 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3084 ns 3084 ns 226877 +bm_call::direct__Function::get_string 3057 ns 3057 ns 229029 -bm_call::via_function_ptr__Function::get_string 3082 ns 3082 ns 227143 -bm_call::via_function_ptr____Method::get_string 3083 ns 3083 ns 227251 +bm_call::via_function_ptr__Function::get_string 3059 ns 3059 ns 228889 +bm_call::via_function_ptr____Method::get_string 3059 ns 3059 ns 228980 -bm_std::function_calls__Function::get_string 3085 ns 3085 ns 226897 -bm_std::function_calls____Method::get_string 3086 ns 3085 ns 226916 +bm_std::function_calls__Function::get_string 3064 ns 3064 ns 228677 +bm_std::function_calls____Method::get_string 3067 ns 3066 ns 228268 -bm_rtl::function_calls__Function::get_string 3085 ns 3085 ns 226921 -bm_rtl::method_calls______Method::get_string 3073 ns 3073 ns 227717 +bm_rtl::function_calls__Function::get_string 3058 ns 3057 ns 228868 +bm_rtl::method_calls______Method::get_string 3058 ns 3058 ns 228956 -bm_rtl::function__ErasedReturnType::get_string 3715 ns 3715 ns 188463 -bm_rtl::method____ErasedReturnType::get_string 3719 ns 3719 ns 188241 -bm_rtl::method____ErasedTargetType::get_string 3088 ns 3088 ns 226725 -bm_rtl::method____ErasedTargetAndReturnType::get_string 3718 ns 3718 ns 188254 +bm_rtl::function__ErasedReturnType::get_string 3100 ns 3100 ns 226068 +bm_rtl::method____ErasedReturnType::get_string 3089 ns 3088 ns 226605 +bm_rtl::method____ErasedTargetType::get_string 3092 ns 3092 ns 226468 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3091 ns 3090 ns 226632 ----------------------------------- -[2025-11-04 12:31:25] >>> Run 2: workload scale = 74 +[2026-01-19 23:15:29] >>> Run 2: workload scale = 74 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 74 iterations ============================================= -2025-11-04T12:31:25+05:30 +2026-01-19T23:15:29+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 800 MHz CPU s) +Run on (16 X 2971.96 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 1.11, 1.03 +Load Average: 1.00, 1.00, 0.85 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1704 ns 1704 ns 411933 +bm_call::direct__Function::set_string 1717 ns 1717 ns 407373 -bm_call::via_function_ptr__Function::set_string 1699 ns 1699 ns 412511 -bm_call::via_function_ptr____Method::set_string 1702 ns 1702 ns 411047 +bm_call::via_function_ptr__Function::set_string 1717 ns 1717 ns 407868 +bm_call::via_function_ptr____Method::set_string 1716 ns 1716 ns 407960 -bm_std::function_calls__Function::set_string 1702 ns 1702 ns 411998 -bm_std::function_calls____Method::set_string 1702 ns 1702 ns 411072 +bm_std::function_calls__Function::set_string 1728 ns 1728 ns 405438 +bm_std::function_calls____Method::set_string 1719 ns 1719 ns 407465 -bm_rtl::function_calls__Function::set_string 1698 ns 1698 ns 409485 -bm_rtl::method_calls______Method::set_string 1702 ns 1702 ns 411717 +bm_rtl::function_calls__Function::set_string 1717 ns 1717 ns 407801 +bm_rtl::method_calls______Method::set_string 1718 ns 1717 ns 407906 -bm_rtl::function__ErasedReturnType::set_string 1705 ns 1705 ns 409692 -bm_rtl::method____ErasedReturnType::set_string 1708 ns 1708 ns 408834 -bm_rtl::method____ErasedTargetType::set_string 1709 ns 1709 ns 410268 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1708 ns 1708 ns 409422 +bm_rtl::function__ErasedReturnType::set_string 1727 ns 1727 ns 405269 +bm_rtl::method____ErasedReturnType::set_string 1732 ns 1732 ns 403650 +bm_rtl::method____ErasedTargetType::set_string 1724 ns 1724 ns 406393 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1724 ns 1724 ns 405598 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3072 ns 3072 ns 228015 +bm_call::direct__Function::get_string 3054 ns 3054 ns 229183 -bm_call::via_function_ptr__Function::get_string 3069 ns 3068 ns 228059 -bm_call::via_function_ptr____Method::get_string 3074 ns 3074 ns 227965 +bm_call::via_function_ptr__Function::get_string 3059 ns 3058 ns 228889 +bm_call::via_function_ptr____Method::get_string 3057 ns 3057 ns 229051 -bm_std::function_calls__Function::get_string 3066 ns 3066 ns 228246 -bm_std::function_calls____Method::get_string 3070 ns 3070 ns 228340 +bm_std::function_calls__Function::get_string 3064 ns 3064 ns 228533 +bm_std::function_calls____Method::get_string 3057 ns 3057 ns 229042 -bm_rtl::function_calls__Function::get_string 3066 ns 3066 ns 228209 -bm_rtl::method_calls______Method::get_string 3073 ns 3073 ns 228131 +bm_rtl::function_calls__Function::get_string 3058 ns 3058 ns 229069 +bm_rtl::method_calls______Method::get_string 3058 ns 3058 ns 228955 -bm_rtl::function__ErasedReturnType::get_string 3716 ns 3715 ns 188572 -bm_rtl::method____ErasedReturnType::get_string 3720 ns 3720 ns 188419 -bm_rtl::method____ErasedTargetType::get_string 3085 ns 3085 ns 226900 -bm_rtl::method____ErasedTargetAndReturnType::get_string 3717 ns 3717 ns 187844 +bm_rtl::function__ErasedReturnType::get_string 3090 ns 3090 ns 226512 +bm_rtl::method____ErasedReturnType::get_string 3100 ns 3099 ns 225959 +bm_rtl::method____ErasedTargetType::get_string 3090 ns 3090 ns 226608 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3113 ns 3113 ns 225676 ----------------------------------- -[2025-11-04 12:31:46] >>> Run 3: workload scale = 74 +[2026-01-19 23:15:50] >>> Run 3: workload scale = 74 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 74 iterations ============================================= -2025-11-04T12:31:46+05:30 +2026-01-19T23:15:50+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1641.19 MHz CPU s) +Run on (16 X 1226.86 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 1.10, 1.02 +Load Average: 1.00, 1.00, 0.85 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1708 ns 1708 ns 409543 +bm_call::direct__Function::set_string 1747 ns 1747 ns 394391 -bm_call::via_function_ptr__Function::set_string 1707 ns 1707 ns 411072 -bm_call::via_function_ptr____Method::set_string 1705 ns 1704 ns 409726 +bm_call::via_function_ptr__Function::set_string 1736 ns 1735 ns 403290 +bm_call::via_function_ptr____Method::set_string 1732 ns 1732 ns 404263 -bm_std::function_calls__Function::set_string 1710 ns 1710 ns 409640 -bm_std::function_calls____Method::set_string 1706 ns 1706 ns 410029 +bm_std::function_calls__Function::set_string 1732 ns 1732 ns 404399 +bm_std::function_calls____Method::set_string 1742 ns 1742 ns 401864 -bm_rtl::function_calls__Function::set_string 1707 ns 1707 ns 409382 -bm_rtl::method_calls______Method::set_string 1704 ns 1704 ns 410793 +bm_rtl::function_calls__Function::set_string 1740 ns 1739 ns 402145 +bm_rtl::method_calls______Method::set_string 1741 ns 1741 ns 401844 -bm_rtl::function__ErasedReturnType::set_string 1712 ns 1712 ns 409380 -bm_rtl::method____ErasedReturnType::set_string 1714 ns 1714 ns 406447 -bm_rtl::method____ErasedTargetType::set_string 1706 ns 1706 ns 409968 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1712 ns 1712 ns 409490 +bm_rtl::function__ErasedReturnType::set_string 1747 ns 1746 ns 400854 +bm_rtl::method____ErasedReturnType::set_string 1736 ns 1736 ns 403429 +bm_rtl::method____ErasedTargetType::set_string 1737 ns 1737 ns 403093 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1739 ns 1738 ns 402717 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3068 ns 3068 ns 228115 +bm_call::direct__Function::get_string 3176 ns 3176 ns 220460 -bm_call::via_function_ptr__Function::get_string 3075 ns 3075 ns 228097 -bm_call::via_function_ptr____Method::get_string 3071 ns 3071 ns 228102 +bm_call::via_function_ptr__Function::get_string 3177 ns 3176 ns 220349 +bm_call::via_function_ptr____Method::get_string 3179 ns 3178 ns 220255 -bm_std::function_calls__Function::get_string 3073 ns 3072 ns 228116 -bm_std::function_calls____Method::get_string 3073 ns 3072 ns 227749 +bm_std::function_calls__Function::get_string 3176 ns 3176 ns 220394 +bm_std::function_calls____Method::get_string 3177 ns 3176 ns 220423 -bm_rtl::function_calls__Function::get_string 3074 ns 3074 ns 227707 -bm_rtl::method_calls______Method::get_string 3071 ns 3071 ns 228043 +bm_rtl::function_calls__Function::get_string 3177 ns 3177 ns 220295 +bm_rtl::method_calls______Method::get_string 3181 ns 3181 ns 220150 -bm_rtl::function__ErasedReturnType::get_string 3716 ns 3716 ns 187872 -bm_rtl::method____ErasedReturnType::get_string 3717 ns 3717 ns 188232 -bm_rtl::method____ErasedTargetType::get_string 3092 ns 3092 ns 225613 -bm_rtl::method____ErasedTargetAndReturnType::get_string 3722 ns 3722 ns 188133 +bm_rtl::function__ErasedReturnType::get_string 3210 ns 3210 ns 218065 +bm_rtl::method____ErasedReturnType::get_string 3205 ns 3205 ns 218381 +bm_rtl::method____ErasedTargetType::get_string 3196 ns 3196 ns 219058 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3204 ns 3204 ns 218448 ----------------------------------- -[2025-11-04 12:32:08] >>> Run 1: workload scale = 82 +[2026-01-19 23:16:11] >>> Run 1: workload scale = 82 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 82 iterations ============================================= -2025-11-04T12:32:08+05:30 +2026-01-19T23:16:11+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3729.3 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 1.09, 1.02 +Load Average: 1.00, 1.00, 0.85 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1767 ns 1766 ns 395242 +bm_call::direct__Function::set_string 1794 ns 1794 ns 389505 -bm_call::via_function_ptr__Function::set_string 1772 ns 1772 ns 394957 -bm_call::via_function_ptr____Method::set_string 1772 ns 1772 ns 394786 +bm_call::via_function_ptr__Function::set_string 1790 ns 1790 ns 390845 +bm_call::via_function_ptr____Method::set_string 1790 ns 1790 ns 390651 -bm_std::function_calls__Function::set_string 1771 ns 1771 ns 395414 -bm_std::function_calls____Method::set_string 1776 ns 1776 ns 395160 +bm_std::function_calls__Function::set_string 1809 ns 1808 ns 387130 +bm_std::function_calls____Method::set_string 1812 ns 1812 ns 386533 -bm_rtl::function_calls__Function::set_string 1774 ns 1774 ns 394773 -bm_rtl::method_calls______Method::set_string 1780 ns 1780 ns 393690 +bm_rtl::function_calls__Function::set_string 1784 ns 1784 ns 392616 +bm_rtl::method_calls______Method::set_string 1784 ns 1784 ns 392461 -bm_rtl::function__ErasedReturnType::set_string 1778 ns 1778 ns 393159 -bm_rtl::method____ErasedReturnType::set_string 1782 ns 1782 ns 393163 -bm_rtl::method____ErasedTargetType::set_string 1781 ns 1781 ns 392715 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1782 ns 1782 ns 392482 +bm_rtl::function__ErasedReturnType::set_string 1797 ns 1796 ns 389855 +bm_rtl::method____ErasedReturnType::set_string 1803 ns 1802 ns 388490 +bm_rtl::method____ErasedTargetType::set_string 1792 ns 1792 ns 390157 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1795 ns 1795 ns 390045 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3335 ns 3335 ns 209233 +bm_call::direct__Function::get_string 3375 ns 3375 ns 207424 -bm_call::via_function_ptr__Function::get_string 3338 ns 3338 ns 209626 -bm_call::via_function_ptr____Method::get_string 3337 ns 3337 ns 209562 +bm_call::via_function_ptr__Function::get_string 3374 ns 3374 ns 207361 +bm_call::via_function_ptr____Method::get_string 3377 ns 3376 ns 207215 -bm_std::function_calls__Function::get_string 3333 ns 3333 ns 210286 -bm_std::function_calls____Method::get_string 3337 ns 3337 ns 209884 +bm_std::function_calls__Function::get_string 3415 ns 3414 ns 204995 +bm_std::function_calls____Method::get_string 3412 ns 3412 ns 205212 -bm_rtl::function_calls__Function::get_string 3338 ns 3338 ns 209988 -bm_rtl::method_calls______Method::get_string 3336 ns 3336 ns 209984 +bm_rtl::function_calls__Function::get_string 3372 ns 3372 ns 207524 +bm_rtl::method_calls______Method::get_string 3376 ns 3375 ns 207464 -bm_rtl::function__ErasedReturnType::get_string 4070 ns 4069 ns 172155 -bm_rtl::method____ErasedReturnType::get_string 4068 ns 4067 ns 172083 -bm_rtl::method____ErasedTargetType::get_string 3352 ns 3351 ns 209120 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4069 ns 4068 ns 172041 +bm_rtl::function__ErasedReturnType::get_string 3383 ns 3383 ns 206960 +bm_rtl::method____ErasedReturnType::get_string 3390 ns 3389 ns 206533 +bm_rtl::method____ErasedTargetType::get_string 3388 ns 3388 ns 206603 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3394 ns 3394 ns 206249 ----------------------------------- -[2025-11-04 12:32:30] >>> Run 2: workload scale = 82 +[2026-01-19 23:16:33] >>> Run 2: workload scale = 82 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 82 iterations ============================================= -2025-11-04T12:32:30+05:30 +2026-01-19T23:16:33+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3961.21 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.07, 1.10, 1.02 +Load Average: 1.00, 1.00, 0.86 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1776 ns 1776 ns 393592 +bm_call::direct__Function::set_string 1789 ns 1788 ns 390994 -bm_call::via_function_ptr__Function::set_string 1777 ns 1777 ns 394043 -bm_call::via_function_ptr____Method::set_string 1779 ns 1779 ns 393918 +bm_call::via_function_ptr__Function::set_string 1785 ns 1784 ns 392122 +bm_call::via_function_ptr____Method::set_string 1785 ns 1785 ns 392243 -bm_std::function_calls__Function::set_string 1773 ns 1773 ns 395185 -bm_std::function_calls____Method::set_string 1773 ns 1773 ns 394879 +bm_std::function_calls__Function::set_string 1790 ns 1790 ns 390820 +bm_std::function_calls____Method::set_string 1790 ns 1790 ns 391136 -bm_rtl::function_calls__Function::set_string 1778 ns 1778 ns 393670 -bm_rtl::method_calls______Method::set_string 1778 ns 1778 ns 393972 +bm_rtl::function_calls__Function::set_string 1787 ns 1787 ns 392034 +bm_rtl::method_calls______Method::set_string 1788 ns 1787 ns 391689 -bm_rtl::function__ErasedReturnType::set_string 1787 ns 1787 ns 391688 -bm_rtl::method____ErasedReturnType::set_string 1787 ns 1787 ns 391402 -bm_rtl::method____ErasedTargetType::set_string 1783 ns 1783 ns 391780 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1785 ns 1785 ns 391770 +bm_rtl::function__ErasedReturnType::set_string 1798 ns 1798 ns 389411 +bm_rtl::method____ErasedReturnType::set_string 1796 ns 1796 ns 389638 +bm_rtl::method____ErasedTargetType::set_string 1813 ns 1813 ns 386506 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1794 ns 1794 ns 390498 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3332 ns 3332 ns 209745 +bm_call::direct__Function::get_string 3369 ns 3369 ns 207893 -bm_call::via_function_ptr__Function::get_string 3332 ns 3331 ns 210115 -bm_call::via_function_ptr____Method::get_string 3333 ns 3333 ns 209826 +bm_call::via_function_ptr__Function::get_string 3368 ns 3368 ns 207860 +bm_call::via_function_ptr____Method::get_string 3371 ns 3370 ns 207743 -bm_std::function_calls__Function::get_string 3326 ns 3326 ns 210463 -bm_std::function_calls____Method::get_string 3327 ns 3327 ns 210290 +bm_std::function_calls__Function::get_string 3368 ns 3368 ns 207977 +bm_std::function_calls____Method::get_string 3370 ns 3369 ns 207658 -bm_rtl::function_calls__Function::get_string 3326 ns 3325 ns 210512 -bm_rtl::method_calls______Method::get_string 3325 ns 3325 ns 210556 +bm_rtl::function_calls__Function::get_string 3366 ns 3366 ns 207915 +bm_rtl::method_calls______Method::get_string 3368 ns 3367 ns 207876 -bm_rtl::function__ErasedReturnType::get_string 4044 ns 4044 ns 173233 -bm_rtl::method____ErasedReturnType::get_string 4042 ns 4042 ns 173222 -bm_rtl::method____ErasedTargetType::get_string 3339 ns 3339 ns 209665 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4043 ns 4043 ns 173090 +bm_rtl::function__ErasedReturnType::get_string 3394 ns 3393 ns 206327 +bm_rtl::method____ErasedReturnType::get_string 3395 ns 3395 ns 206213 +bm_rtl::method____ErasedTargetType::get_string 3388 ns 3388 ns 206518 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3398 ns 3397 ns 206045 ----------------------------------- -[2025-11-04 12:32:52] >>> Run 3: workload scale = 82 +[2026-01-19 23:16:55] >>> Run 3: workload scale = 82 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 82 iterations ============================================= -2025-11-04T12:32:52+05:30 +2026-01-19T23:16:55+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2516,50 +2516,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 1.09, 1.02 +Load Average: 1.00, 1.00, 0.86 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1784 ns 1783 ns 392280 +bm_call::direct__Function::set_string 1811 ns 1810 ns 386087 -bm_call::via_function_ptr__Function::set_string 1786 ns 1786 ns 392452 -bm_call::via_function_ptr____Method::set_string 1789 ns 1789 ns 391699 +bm_call::via_function_ptr__Function::set_string 1809 ns 1809 ns 387440 +bm_call::via_function_ptr____Method::set_string 1812 ns 1811 ns 386622 -bm_std::function_calls__Function::set_string 1794 ns 1794 ns 390359 -bm_std::function_calls____Method::set_string 1804 ns 1804 ns 388507 +bm_std::function_calls__Function::set_string 1802 ns 1802 ns 388402 +bm_std::function_calls____Method::set_string 1799 ns 1799 ns 388973 -bm_rtl::function_calls__Function::set_string 1811 ns 1811 ns 387372 -bm_rtl::method_calls______Method::set_string 1808 ns 1808 ns 387531 +bm_rtl::function_calls__Function::set_string 1798 ns 1797 ns 389077 +bm_rtl::method_calls______Method::set_string 1799 ns 1798 ns 389305 -bm_rtl::function__ErasedReturnType::set_string 1782 ns 1782 ns 392864 -bm_rtl::method____ErasedReturnType::set_string 1785 ns 1785 ns 392227 -bm_rtl::method____ErasedTargetType::set_string 1780 ns 1780 ns 393273 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1780 ns 1780 ns 393240 +bm_rtl::function__ErasedReturnType::set_string 1805 ns 1805 ns 387952 +bm_rtl::method____ErasedReturnType::set_string 1805 ns 1805 ns 387977 +bm_rtl::method____ErasedTargetType::set_string 1807 ns 1807 ns 387510 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1814 ns 1813 ns 386017 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3362 ns 3362 ns 208152 +bm_call::direct__Function::get_string 3502 ns 3501 ns 199872 -bm_call::via_function_ptr__Function::get_string 3366 ns 3366 ns 207975 -bm_call::via_function_ptr____Method::get_string 3368 ns 3368 ns 207809 +bm_call::via_function_ptr__Function::get_string 3502 ns 3502 ns 199921 +bm_call::via_function_ptr____Method::get_string 3502 ns 3501 ns 199939 -bm_std::function_calls__Function::get_string 3362 ns 3361 ns 208229 -bm_std::function_calls____Method::get_string 3347 ns 3347 ns 209205 +bm_std::function_calls__Function::get_string 3501 ns 3501 ns 199951 +bm_std::function_calls____Method::get_string 3508 ns 3508 ns 199587 -bm_rtl::function_calls__Function::get_string 3361 ns 3361 ns 208356 -bm_rtl::method_calls______Method::get_string 3349 ns 3349 ns 208934 +bm_rtl::function_calls__Function::get_string 3501 ns 3501 ns 199876 +bm_rtl::method_calls______Method::get_string 3503 ns 3502 ns 199842 -bm_rtl::function__ErasedReturnType::get_string 4051 ns 4051 ns 172849 -bm_rtl::method____ErasedReturnType::get_string 4051 ns 4051 ns 172829 -bm_rtl::method____ErasedTargetType::get_string 3368 ns 3367 ns 207905 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4048 ns 4048 ns 172912 +bm_rtl::function__ErasedReturnType::get_string 3519 ns 3519 ns 199068 +bm_rtl::method____ErasedReturnType::get_string 3516 ns 3516 ns 199083 +bm_rtl::method____ErasedTargetType::get_string 3517 ns 3517 ns 199293 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3519 ns 3518 ns 199016 ----------------------------------- -[2025-11-04 12:33:14] >>> Run 1: workload scale = 90 +[2026-01-19 23:17:17] >>> Run 1: workload scale = 90 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 90 iterations ============================================= -2025-11-04T12:33:14+05:30 +2026-01-19T23:17:17+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2567,50 +2567,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.03, 1.08, 1.02 +Load Average: 1.00, 1.00, 0.87 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1850 ns 1850 ns 379224 +bm_call::direct__Function::set_string 1863 ns 1863 ns 375638 -bm_call::via_function_ptr__Function::set_string 1850 ns 1850 ns 378200 -bm_call::via_function_ptr____Method::set_string 1852 ns 1852 ns 378223 +bm_call::via_function_ptr__Function::set_string 1857 ns 1857 ns 376944 +bm_call::via_function_ptr____Method::set_string 1859 ns 1859 ns 376768 -bm_std::function_calls__Function::set_string 1853 ns 1853 ns 377629 -bm_std::function_calls____Method::set_string 1853 ns 1852 ns 377833 +bm_std::function_calls__Function::set_string 1879 ns 1879 ns 371755 +bm_std::function_calls____Method::set_string 1867 ns 1866 ns 374396 -bm_rtl::function_calls__Function::set_string 1853 ns 1852 ns 378253 -bm_rtl::method_calls______Method::set_string 1855 ns 1855 ns 377285 +bm_rtl::function_calls__Function::set_string 1858 ns 1858 ns 376844 +bm_rtl::method_calls______Method::set_string 1858 ns 1858 ns 376799 -bm_rtl::function__ErasedReturnType::set_string 1866 ns 1865 ns 375269 -bm_rtl::method____ErasedReturnType::set_string 1872 ns 1872 ns 374394 -bm_rtl::method____ErasedTargetType::set_string 1865 ns 1864 ns 375297 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1870 ns 1869 ns 375229 +bm_rtl::function__ErasedReturnType::set_string 1876 ns 1876 ns 373607 +bm_rtl::method____ErasedReturnType::set_string 1886 ns 1886 ns 370976 +bm_rtl::method____ErasedTargetType::set_string 1873 ns 1872 ns 373713 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1873 ns 1873 ns 374113 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3621 ns 3621 ns 193229 +bm_call::direct__Function::get_string 3659 ns 3658 ns 191514 -bm_call::via_function_ptr__Function::get_string 3620 ns 3620 ns 193390 -bm_call::via_function_ptr____Method::get_string 3619 ns 3619 ns 193491 +bm_call::via_function_ptr__Function::get_string 3651 ns 3650 ns 191687 +bm_call::via_function_ptr____Method::get_string 3651 ns 3650 ns 191718 -bm_std::function_calls__Function::get_string 3627 ns 3627 ns 193051 -bm_std::function_calls____Method::get_string 3629 ns 3629 ns 192921 +bm_std::function_calls__Function::get_string 3662 ns 3661 ns 191309 +bm_std::function_calls____Method::get_string 3655 ns 3655 ns 191385 -bm_rtl::function_calls__Function::get_string 3626 ns 3626 ns 193080 -bm_rtl::method_calls______Method::get_string 3630 ns 3630 ns 192853 +bm_rtl::function_calls__Function::get_string 3648 ns 3648 ns 191878 +bm_rtl::method_calls______Method::get_string 3651 ns 3651 ns 191753 -bm_rtl::function__ErasedReturnType::get_string 4345 ns 4345 ns 161148 -bm_rtl::method____ErasedReturnType::get_string 4348 ns 4348 ns 160982 -bm_rtl::method____ErasedTargetType::get_string 3658 ns 3658 ns 191325 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4350 ns 4350 ns 160848 +bm_rtl::function__ErasedReturnType::get_string 3688 ns 3688 ns 189767 +bm_rtl::method____ErasedReturnType::get_string 3685 ns 3685 ns 190062 +bm_rtl::method____ErasedTargetType::get_string 3685 ns 3685 ns 189945 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3693 ns 3692 ns 189633 ----------------------------------- -[2025-11-04 12:33:36] >>> Run 2: workload scale = 90 +[2026-01-19 23:17:39] >>> Run 2: workload scale = 90 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 90 iterations ============================================= -2025-11-04T12:33:36+05:30 +2026-01-19T23:17:39+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2618,50 +2618,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 1.07, 1.02 +Load Average: 1.00, 1.00, 0.87 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1850 ns 1850 ns 378250 +bm_call::direct__Function::set_string 1901 ns 1901 ns 368162 -bm_call::via_function_ptr__Function::set_string 1851 ns 1851 ns 378198 -bm_call::via_function_ptr____Method::set_string 1853 ns 1852 ns 377792 +bm_call::via_function_ptr__Function::set_string 1900 ns 1900 ns 368222 +bm_call::via_function_ptr____Method::set_string 1903 ns 1903 ns 368462 -bm_std::function_calls__Function::set_string 1862 ns 1862 ns 376203 -bm_std::function_calls____Method::set_string 1859 ns 1859 ns 376918 +bm_std::function_calls__Function::set_string 1933 ns 1933 ns 362276 +bm_std::function_calls____Method::set_string 1932 ns 1932 ns 362124 -bm_rtl::function_calls__Function::set_string 1864 ns 1864 ns 375389 -bm_rtl::method_calls______Method::set_string 1864 ns 1864 ns 375592 +bm_rtl::function_calls__Function::set_string 1882 ns 1882 ns 371779 +bm_rtl::method_calls______Method::set_string 1881 ns 1881 ns 372490 -bm_rtl::function__ErasedReturnType::set_string 1877 ns 1877 ns 373174 -bm_rtl::method____ErasedReturnType::set_string 1877 ns 1877 ns 373198 -bm_rtl::method____ErasedTargetType::set_string 1871 ns 1870 ns 374468 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1876 ns 1876 ns 373838 +bm_rtl::function__ErasedReturnType::set_string 1884 ns 1884 ns 371491 +bm_rtl::method____ErasedReturnType::set_string 1884 ns 1884 ns 371247 +bm_rtl::method____ErasedTargetType::set_string 1886 ns 1886 ns 371278 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1902 ns 1901 ns 368129 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3626 ns 3625 ns 193072 +bm_call::direct__Function::get_string 3778 ns 3777 ns 185389 -bm_call::via_function_ptr__Function::get_string 3623 ns 3623 ns 193302 -bm_call::via_function_ptr____Method::get_string 3622 ns 3622 ns 193279 +bm_call::via_function_ptr__Function::get_string 3756 ns 3756 ns 186385 +bm_call::via_function_ptr____Method::get_string 3781 ns 3780 ns 185102 -bm_std::function_calls__Function::get_string 3630 ns 3630 ns 192894 -bm_std::function_calls____Method::get_string 3637 ns 3637 ns 192511 +bm_std::function_calls__Function::get_string 3739 ns 3739 ns 187219 +bm_std::function_calls____Method::get_string 3732 ns 3731 ns 187576 -bm_rtl::function_calls__Function::get_string 3632 ns 3632 ns 192793 -bm_rtl::method_calls______Method::get_string 3629 ns 3629 ns 192875 +bm_rtl::function_calls__Function::get_string 3755 ns 3754 ns 186509 +bm_rtl::method_calls______Method::get_string 3779 ns 3778 ns 185306 -bm_rtl::function__ErasedReturnType::get_string 4396 ns 4395 ns 159101 -bm_rtl::method____ErasedReturnType::get_string 4380 ns 4380 ns 159765 -bm_rtl::method____ErasedTargetType::get_string 3663 ns 3663 ns 191171 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4382 ns 4382 ns 159762 +bm_rtl::function__ErasedReturnType::get_string 3763 ns 3763 ns 186150 +bm_rtl::method____ErasedReturnType::get_string 3754 ns 3754 ns 186567 +bm_rtl::method____ErasedTargetType::get_string 3752 ns 3752 ns 186761 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3757 ns 3757 ns 186314 ----------------------------------- -[2025-11-04 12:33:58] >>> Run 3: workload scale = 90 +[2026-01-19 23:18:01] >>> Run 3: workload scale = 90 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 90 iterations ============================================= -2025-11-04T12:33:58+05:30 +2026-01-19T23:18:01+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2669,101 +2669,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 1.07, 1.02 +Load Average: 1.00, 1.00, 0.88 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1867 ns 1867 ns 374901 +bm_call::direct__Function::set_string 1920 ns 1919 ns 364839 -bm_call::via_function_ptr__Function::set_string 1869 ns 1869 ns 374808 -bm_call::via_function_ptr____Method::set_string 1868 ns 1868 ns 374856 +bm_call::via_function_ptr__Function::set_string 1916 ns 1916 ns 365320 +bm_call::via_function_ptr____Method::set_string 1916 ns 1915 ns 365777 -bm_std::function_calls__Function::set_string 1871 ns 1871 ns 374208 -bm_std::function_calls____Method::set_string 1860 ns 1860 ns 375819 +bm_std::function_calls__Function::set_string 1902 ns 1902 ns 368265 +bm_std::function_calls____Method::set_string 1899 ns 1899 ns 368618 -bm_rtl::function_calls__Function::set_string 1873 ns 1873 ns 374232 -bm_rtl::method_calls______Method::set_string 1866 ns 1866 ns 375267 +bm_rtl::function_calls__Function::set_string 1903 ns 1902 ns 368541 +bm_rtl::method_calls______Method::set_string 1910 ns 1910 ns 367711 -bm_rtl::function__ErasedReturnType::set_string 1885 ns 1885 ns 371538 -bm_rtl::method____ErasedReturnType::set_string 1899 ns 1899 ns 368497 -bm_rtl::method____ErasedTargetType::set_string 1882 ns 1882 ns 372145 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1896 ns 1896 ns 369384 +bm_rtl::function__ErasedReturnType::set_string 1877 ns 1877 ns 372914 +bm_rtl::method____ErasedReturnType::set_string 1886 ns 1885 ns 371486 +bm_rtl::method____ErasedTargetType::set_string 1888 ns 1887 ns 370679 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1897 ns 1897 ns 368599 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3811 ns 3811 ns 183639 +bm_call::direct__Function::get_string 3692 ns 3692 ns 189447 -bm_call::via_function_ptr__Function::get_string 3811 ns 3811 ns 183675 -bm_call::via_function_ptr____Method::get_string 3809 ns 3808 ns 183773 +bm_call::via_function_ptr__Function::get_string 3689 ns 3688 ns 189708 +bm_call::via_function_ptr____Method::get_string 3689 ns 3689 ns 189672 -bm_std::function_calls__Function::get_string 3821 ns 3821 ns 183176 -bm_std::function_calls____Method::get_string 3822 ns 3821 ns 183277 +bm_std::function_calls__Function::get_string 3695 ns 3694 ns 189731 +bm_std::function_calls____Method::get_string 3694 ns 3694 ns 189470 -bm_rtl::function_calls__Function::get_string 3817 ns 3816 ns 183495 -bm_rtl::method_calls______Method::get_string 3820 ns 3820 ns 183226 +bm_rtl::function_calls__Function::get_string 3689 ns 3689 ns 189854 +bm_rtl::method_calls______Method::get_string 3692 ns 3692 ns 189660 -bm_rtl::function__ErasedReturnType::get_string 4565 ns 4565 ns 153385 -bm_rtl::method____ErasedReturnType::get_string 4539 ns 4539 ns 154235 -bm_rtl::method____ErasedTargetType::get_string 3844 ns 3843 ns 182098 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4541 ns 4540 ns 154162 +bm_rtl::function__ErasedReturnType::get_string 3685 ns 3685 ns 190024 +bm_rtl::method____ErasedReturnType::get_string 3686 ns 3686 ns 189881 +bm_rtl::method____ErasedTargetType::get_string 3686 ns 3685 ns 189939 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3678 ns 3678 ns 190331 ----------------------------------- -[2025-11-04 12:34:21] >>> Run 1: workload scale = 100 +[2026-01-19 23:18:24] >>> Run 1: workload scale = 100 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 100 iterations ============================================= -2025-11-04T12:34:21+05:30 +2026-01-19T23:18:24+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 954.973 MHz CPU s) +Run on (16 X 953.464 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 1.06, 1.01 +Load Average: 1.00, 1.00, 0.88 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1961 ns 1961 ns 357857 +bm_call::direct__Function::set_string 1983 ns 1983 ns 352153 -bm_call::via_function_ptr__Function::set_string 1962 ns 1962 ns 356890 -bm_call::via_function_ptr____Method::set_string 1964 ns 1964 ns 356347 +bm_call::via_function_ptr__Function::set_string 1982 ns 1982 ns 353132 +bm_call::via_function_ptr____Method::set_string 1982 ns 1982 ns 352949 -bm_std::function_calls__Function::set_string 1981 ns 1980 ns 353093 -bm_std::function_calls____Method::set_string 1980 ns 1980 ns 353920 +bm_std::function_calls__Function::set_string 2006 ns 2006 ns 349040 +bm_std::function_calls____Method::set_string 1988 ns 1988 ns 351879 -bm_rtl::function_calls__Function::set_string 1986 ns 1985 ns 352760 -bm_rtl::method_calls______Method::set_string 1960 ns 1960 ns 357367 +bm_rtl::function_calls__Function::set_string 1983 ns 1982 ns 353365 +bm_rtl::method_calls______Method::set_string 1983 ns 1982 ns 353211 -bm_rtl::function__ErasedReturnType::set_string 1966 ns 1966 ns 355968 -bm_rtl::method____ErasedReturnType::set_string 1966 ns 1966 ns 356507 -bm_rtl::method____ErasedTargetType::set_string 1965 ns 1965 ns 356382 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1969 ns 1969 ns 355503 +bm_rtl::function__ErasedReturnType::set_string 1999 ns 1999 ns 350179 +bm_rtl::method____ErasedReturnType::set_string 2021 ns 2021 ns 344890 +bm_rtl::method____ErasedTargetType::set_string 1999 ns 1999 ns 350645 +bm_rtl::method____ErasedTargetAndReturnType::set_string 2003 ns 2002 ns 349382 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 4122 ns 4122 ns 169805 +bm_call::direct__Function::get_string 3946 ns 3945 ns 177472 -bm_call::via_function_ptr__Function::get_string 4123 ns 4122 ns 169776 -bm_call::via_function_ptr____Method::get_string 3985 ns 3985 ns 171499 +bm_call::via_function_ptr__Function::get_string 3949 ns 3948 ns 177365 +bm_call::via_function_ptr____Method::get_string 3954 ns 3954 ns 177081 -bm_std::function_calls__Function::get_string 3952 ns 3951 ns 176989 -bm_std::function_calls____Method::get_string 3953 ns 3952 ns 177118 +bm_std::function_calls__Function::get_string 3948 ns 3948 ns 177318 +bm_std::function_calls____Method::get_string 3946 ns 3945 ns 177368 -bm_rtl::function_calls__Function::get_string 3957 ns 3957 ns 176932 -bm_rtl::method_calls______Method::get_string 3957 ns 3957 ns 176974 +bm_rtl::function_calls__Function::get_string 3949 ns 3949 ns 177379 +bm_rtl::method_calls______Method::get_string 3951 ns 3951 ns 177153 -bm_rtl::function__ErasedReturnType::get_string 4745 ns 4744 ns 147638 -bm_rtl::method____ErasedReturnType::get_string 4746 ns 4746 ns 147454 -bm_rtl::method____ErasedTargetType::get_string 3978 ns 3978 ns 175930 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4745 ns 4745 ns 147401 +bm_rtl::function__ErasedReturnType::get_string 3963 ns 3963 ns 176629 +bm_rtl::method____ErasedReturnType::get_string 3974 ns 3974 ns 176103 +bm_rtl::method____ErasedTargetType::get_string 3959 ns 3959 ns 176758 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3972 ns 3972 ns 176227 ----------------------------------- -[2025-11-04 12:34:44] >>> Run 2: workload scale = 100 +[2026-01-19 23:18:46] >>> Run 2: workload scale = 100 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 100 iterations ============================================= -2025-11-04T12:34:44+05:30 +2026-01-19T23:18:46+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2771,50 +2771,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 1.06, 1.01 +Load Average: 1.00, 1.00, 0.88 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1934 ns 1934 ns 361337 +bm_call::direct__Function::set_string 1963 ns 1962 ns 356872 -bm_call::via_function_ptr__Function::set_string 1940 ns 1940 ns 360781 -bm_call::via_function_ptr____Method::set_string 1936 ns 1936 ns 361609 +bm_call::via_function_ptr__Function::set_string 1965 ns 1965 ns 356959 +bm_call::via_function_ptr____Method::set_string 1961 ns 1961 ns 356856 -bm_std::function_calls__Function::set_string 1937 ns 1936 ns 360705 -bm_std::function_calls____Method::set_string 1942 ns 1942 ns 361593 +bm_std::function_calls__Function::set_string 1965 ns 1965 ns 356972 +bm_std::function_calls____Method::set_string 1985 ns 1985 ns 353072 -bm_rtl::function_calls__Function::set_string 1944 ns 1944 ns 360392 -bm_rtl::method_calls______Method::set_string 1945 ns 1945 ns 359927 +bm_rtl::function_calls__Function::set_string 1977 ns 1977 ns 353606 +bm_rtl::method_calls______Method::set_string 1979 ns 1979 ns 352091 -bm_rtl::function__ErasedReturnType::set_string 1952 ns 1952 ns 358537 -bm_rtl::method____ErasedReturnType::set_string 1958 ns 1958 ns 357397 -bm_rtl::method____ErasedTargetType::set_string 1963 ns 1963 ns 357730 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1972 ns 1972 ns 354598 +bm_rtl::function__ErasedReturnType::set_string 1999 ns 1999 ns 349499 +bm_rtl::method____ErasedReturnType::set_string 1979 ns 1979 ns 354224 +bm_rtl::method____ErasedTargetType::set_string 1980 ns 1980 ns 353401 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1982 ns 1982 ns 353521 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 4096 ns 4096 ns 170858 +bm_call::direct__Function::get_string 3952 ns 3951 ns 177102 -bm_call::via_function_ptr__Function::get_string 4094 ns 4093 ns 170965 -bm_call::via_function_ptr____Method::get_string 4092 ns 4092 ns 171123 +bm_call::via_function_ptr__Function::get_string 3953 ns 3952 ns 176786 +bm_call::via_function_ptr____Method::get_string 3958 ns 3958 ns 176907 -bm_std::function_calls__Function::get_string 4098 ns 4098 ns 170793 -bm_std::function_calls____Method::get_string 4103 ns 4103 ns 170634 +bm_std::function_calls__Function::get_string 3942 ns 3941 ns 177129 +bm_std::function_calls____Method::get_string 3954 ns 3953 ns 177506 -bm_rtl::function_calls__Function::get_string 4102 ns 4102 ns 170611 -bm_rtl::method_calls______Method::get_string 4102 ns 4102 ns 170566 +bm_rtl::function_calls__Function::get_string 3951 ns 3951 ns 177178 +bm_rtl::method_calls______Method::get_string 3958 ns 3958 ns 177075 -bm_rtl::function__ErasedReturnType::get_string 4891 ns 4891 ns 143266 -bm_rtl::method____ErasedReturnType::get_string 4896 ns 4895 ns 142971 -bm_rtl::method____ErasedTargetType::get_string 4128 ns 4128 ns 169566 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4896 ns 4896 ns 142983 +bm_rtl::function__ErasedReturnType::get_string 3973 ns 3972 ns 176053 +bm_rtl::method____ErasedReturnType::get_string 3968 ns 3967 ns 176677 +bm_rtl::method____ErasedTargetType::get_string 3960 ns 3959 ns 177029 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3963 ns 3963 ns 176044 ----------------------------------- -[2025-11-04 12:35:07] >>> Run 3: workload scale = 100 +[2026-01-19 23:19:09] >>> Run 3: workload scale = 100 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 100 iterations ============================================= -2025-11-04T12:35:07+05:30 +2026-01-19T23:19:09+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2822,101 +2822,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 1.05, 1.01 +Load Average: 1.00, 1.00, 0.89 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1977 ns 1977 ns 353596 +bm_call::direct__Function::set_string 1968 ns 1968 ns 355257 -bm_call::via_function_ptr__Function::set_string 1985 ns 1984 ns 353779 -bm_call::via_function_ptr____Method::set_string 1989 ns 1989 ns 352715 +bm_call::via_function_ptr__Function::set_string 1966 ns 1965 ns 355344 +bm_call::via_function_ptr____Method::set_string 1966 ns 1966 ns 356102 -bm_std::function_calls__Function::set_string 2003 ns 2003 ns 350400 -bm_std::function_calls____Method::set_string 2008 ns 2008 ns 349132 +bm_std::function_calls__Function::set_string 1975 ns 1975 ns 354670 +bm_std::function_calls____Method::set_string 1975 ns 1975 ns 354660 -bm_rtl::function_calls__Function::set_string 2006 ns 2006 ns 349311 -bm_rtl::method_calls______Method::set_string 2011 ns 2011 ns 349247 +bm_rtl::function_calls__Function::set_string 1968 ns 1968 ns 356032 +bm_rtl::method_calls______Method::set_string 1968 ns 1968 ns 355469 -bm_rtl::function__ErasedReturnType::set_string 2000 ns 1999 ns 350105 -bm_rtl::method____ErasedReturnType::set_string 2000 ns 2000 ns 350108 -bm_rtl::method____ErasedTargetType::set_string 2002 ns 2002 ns 349732 -bm_rtl::method____ErasedTargetAndReturnType::set_string 2002 ns 2002 ns 349713 +bm_rtl::function__ErasedReturnType::set_string 1985 ns 1985 ns 352756 +bm_rtl::method____ErasedReturnType::set_string 1986 ns 1986 ns 352599 +bm_rtl::method____ErasedTargetType::set_string 2008 ns 2008 ns 348721 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1985 ns 1984 ns 353073 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3976 ns 3976 ns 175636 +bm_call::direct__Function::get_string 3957 ns 3957 ns 176887 -bm_call::via_function_ptr__Function::get_string 3977 ns 3977 ns 176258 -bm_call::via_function_ptr____Method::get_string 3969 ns 3968 ns 176389 +bm_call::via_function_ptr__Function::get_string 3961 ns 3960 ns 176806 +bm_call::via_function_ptr____Method::get_string 3961 ns 3961 ns 176756 -bm_std::function_calls__Function::get_string 4001 ns 4001 ns 175249 -bm_std::function_calls____Method::get_string 3993 ns 3993 ns 175269 +bm_std::function_calls__Function::get_string 3953 ns 3953 ns 176961 +bm_std::function_calls____Method::get_string 3954 ns 3953 ns 177120 -bm_rtl::function_calls__Function::get_string 4006 ns 4006 ns 174915 -bm_rtl::method_calls______Method::get_string 3975 ns 3975 ns 176077 +bm_rtl::function_calls__Function::get_string 3958 ns 3958 ns 176943 +bm_rtl::method_calls______Method::get_string 3960 ns 3959 ns 176821 -bm_rtl::function__ErasedReturnType::get_string 4735 ns 4735 ns 147503 -bm_rtl::method____ErasedReturnType::get_string 4744 ns 4744 ns 147790 -bm_rtl::method____ErasedTargetType::get_string 3979 ns 3979 ns 175845 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4745 ns 4745 ns 147593 +bm_rtl::function__ErasedReturnType::get_string 3978 ns 3978 ns 176017 +bm_rtl::method____ErasedReturnType::get_string 3982 ns 3982 ns 175814 +bm_rtl::method____ErasedTargetType::get_string 3973 ns 3972 ns 176287 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3982 ns 3981 ns 175813 ----------------------------------- -[2025-11-04 12:35:30] >>> Run 1: workload scale = 120 +[2026-01-19 23:19:32] >>> Run 1: workload scale = 120 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 120 iterations ============================================= -2025-11-04T12:35:30+05:30 +2026-01-19T23:19:32+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 800 MHz CPU s) +Run on (16 X 2306.47 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 1.05, 1.01 +Load Average: 1.00, 1.00, 0.89 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 2145 ns 2145 ns 326478 +bm_call::direct__Function::set_string 2159 ns 2159 ns 324744 -bm_call::via_function_ptr__Function::set_string 2145 ns 2145 ns 326264 -bm_call::via_function_ptr____Method::set_string 2148 ns 2148 ns 325609 +bm_call::via_function_ptr__Function::set_string 2155 ns 2154 ns 324974 +bm_call::via_function_ptr____Method::set_string 2157 ns 2157 ns 324813 -bm_std::function_calls__Function::set_string 2150 ns 2149 ns 325379 -bm_std::function_calls____Method::set_string 2146 ns 2146 ns 326018 +bm_std::function_calls__Function::set_string 2160 ns 2160 ns 324000 +bm_std::function_calls____Method::set_string 2165 ns 2165 ns 323682 -bm_rtl::function_calls__Function::set_string 2151 ns 2151 ns 325875 -bm_rtl::method_calls______Method::set_string 2152 ns 2152 ns 325215 +bm_rtl::function_calls__Function::set_string 2155 ns 2155 ns 324669 +bm_rtl::method_calls______Method::set_string 2156 ns 2155 ns 324478 -bm_rtl::function__ErasedReturnType::set_string 2161 ns 2161 ns 324202 -bm_rtl::method____ErasedReturnType::set_string 2162 ns 2162 ns 324182 -bm_rtl::method____ErasedTargetType::set_string 2157 ns 2157 ns 324788 -bm_rtl::method____ErasedTargetAndReturnType::set_string 2162 ns 2161 ns 324038 +bm_rtl::function__ErasedReturnType::set_string 2176 ns 2175 ns 320756 +bm_rtl::method____ErasedReturnType::set_string 2174 ns 2174 ns 321889 +bm_rtl::method____ErasedTargetType::set_string 2200 ns 2200 ns 317433 +bm_rtl::method____ErasedTargetAndReturnType::set_string 2176 ns 2176 ns 321629 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 4617 ns 4617 ns 151631 +bm_call::direct__Function::get_string 4621 ns 4621 ns 151211 -bm_call::via_function_ptr__Function::get_string 4617 ns 4617 ns 151639 -bm_call::via_function_ptr____Method::get_string 4617 ns 4616 ns 151716 +bm_call::via_function_ptr__Function::get_string 4626 ns 4626 ns 151508 +bm_call::via_function_ptr____Method::get_string 4622 ns 4622 ns 151424 -bm_std::function_calls__Function::get_string 4627 ns 4626 ns 151346 -bm_std::function_calls____Method::get_string 4619 ns 4619 ns 151470 +bm_std::function_calls__Function::get_string 4632 ns 4632 ns 151238 +bm_std::function_calls____Method::get_string 4626 ns 4625 ns 151353 -bm_rtl::function_calls__Function::get_string 4620 ns 4620 ns 151567 -bm_rtl::method_calls______Method::get_string 4620 ns 4620 ns 151462 +bm_rtl::function_calls__Function::get_string 4619 ns 4618 ns 151221 +bm_rtl::method_calls______Method::get_string 4625 ns 4625 ns 151564 -bm_rtl::function__ErasedReturnType::get_string 5616 ns 5616 ns 124617 -bm_rtl::method____ErasedReturnType::get_string 5608 ns 5608 ns 124657 -bm_rtl::method____ErasedTargetType::get_string 4645 ns 4644 ns 150774 -bm_rtl::method____ErasedTargetAndReturnType::get_string 5612 ns 5612 ns 124546 +bm_rtl::function__ErasedReturnType::get_string 4645 ns 4644 ns 150711 +bm_rtl::method____ErasedReturnType::get_string 4655 ns 4655 ns 150667 +bm_rtl::method____ErasedTargetType::get_string 4641 ns 4640 ns 150806 +bm_rtl::method____ErasedTargetAndReturnType::get_string 4651 ns 4651 ns 150168 ----------------------------------- -[2025-11-04 12:35:52] >>> Run 2: workload scale = 120 +[2026-01-19 23:19:55] >>> Run 2: workload scale = 120 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 120 iterations ============================================= -2025-11-04T12:35:52+05:30 +2026-01-19T23:19:55+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2924,50 +2924,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.06, 1.06, 1.01 +Load Average: 1.00, 1.00, 0.90 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 2145 ns 2145 ns 326686 +bm_call::direct__Function::set_string 2246 ns 2245 ns 311778 -bm_call::via_function_ptr__Function::set_string 2143 ns 2143 ns 327072 -bm_call::via_function_ptr____Method::set_string 2142 ns 2142 ns 326938 +bm_call::via_function_ptr__Function::set_string 2244 ns 2244 ns 312238 +bm_call::via_function_ptr____Method::set_string 2243 ns 2243 ns 312122 -bm_std::function_calls__Function::set_string 2152 ns 2152 ns 325170 -bm_std::function_calls____Method::set_string 2149 ns 2149 ns 326018 +bm_std::function_calls__Function::set_string 2162 ns 2162 ns 323973 +bm_std::function_calls____Method::set_string 2164 ns 2164 ns 323396 -bm_rtl::function_calls__Function::set_string 2153 ns 2153 ns 325215 -bm_rtl::method_calls______Method::set_string 2150 ns 2150 ns 325278 +bm_rtl::function_calls__Function::set_string 2220 ns 2219 ns 315305 +bm_rtl::method_calls______Method::set_string 2221 ns 2220 ns 315210 -bm_rtl::function__ErasedReturnType::set_string 2165 ns 2164 ns 323427 -bm_rtl::method____ErasedReturnType::set_string 2189 ns 2189 ns 319619 -bm_rtl::method____ErasedTargetType::set_string 2171 ns 2170 ns 322824 -bm_rtl::method____ErasedTargetAndReturnType::set_string 2181 ns 2181 ns 320945 +bm_rtl::function__ErasedReturnType::set_string 2188 ns 2188 ns 320033 +bm_rtl::method____ErasedReturnType::set_string 2191 ns 2190 ns 319572 +bm_rtl::method____ErasedTargetType::set_string 2176 ns 2175 ns 321473 +bm_rtl::method____ErasedTargetAndReturnType::set_string 2208 ns 2207 ns 316933 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 4793 ns 4792 ns 146051 +bm_call::direct__Function::get_string 4619 ns 4619 ns 151620 -bm_call::via_function_ptr__Function::get_string 4795 ns 4794 ns 146001 -bm_call::via_function_ptr____Method::get_string 4792 ns 4792 ns 146108 +bm_call::via_function_ptr__Function::get_string 4637 ns 4636 ns 150938 +bm_call::via_function_ptr____Method::get_string 4622 ns 4622 ns 151513 -bm_std::function_calls__Function::get_string 4649 ns 4649 ns 145872 -bm_std::function_calls____Method::get_string 4627 ns 4627 ns 150967 +bm_std::function_calls__Function::get_string 4621 ns 4621 ns 151473 +bm_std::function_calls____Method::get_string 4630 ns 4630 ns 151236 -bm_rtl::function_calls__Function::get_string 4631 ns 4631 ns 151175 -bm_rtl::method_calls______Method::get_string 4632 ns 4632 ns 151161 +bm_rtl::function_calls__Function::get_string 4637 ns 4636 ns 151049 +bm_rtl::method_calls______Method::get_string 4620 ns 4619 ns 151561 -bm_rtl::function__ErasedReturnType::get_string 5685 ns 5684 ns 123111 -bm_rtl::method____ErasedReturnType::get_string 5630 ns 5629 ns 124248 -bm_rtl::method____ErasedTargetType::get_string 4674 ns 4674 ns 149772 -bm_rtl::method____ErasedTargetAndReturnType::get_string 5637 ns 5637 ns 124261 +bm_rtl::function__ErasedReturnType::get_string 4650 ns 4650 ns 150571 +bm_rtl::method____ErasedReturnType::get_string 4648 ns 4647 ns 150593 +bm_rtl::method____ErasedTargetType::get_string 4641 ns 4640 ns 150876 +bm_rtl::method____ErasedTargetAndReturnType::get_string 4650 ns 4650 ns 150607 ----------------------------------- -[2025-11-04 12:36:15] >>> Run 3: workload scale = 120 +[2026-01-19 23:20:19] >>> Run 3: workload scale = 120 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 120 iterations ============================================= -2025-11-04T12:36:15+05:30 +2026-01-19T23:20:19+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2975,50 +2975,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 1.05, 1.01 +Load Average: 1.00, 1.00, 0.90 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 2157 ns 2157 ns 324031 +bm_call::direct__Function::set_string 2156 ns 2156 ns 324715 -bm_call::via_function_ptr__Function::set_string 2157 ns 2157 ns 323762 -bm_call::via_function_ptr____Method::set_string 2158 ns 2158 ns 324457 +bm_call::via_function_ptr__Function::set_string 2156 ns 2155 ns 324995 +bm_call::via_function_ptr____Method::set_string 2155 ns 2154 ns 325332 -bm_std::function_calls__Function::set_string 2168 ns 2168 ns 323051 -bm_std::function_calls____Method::set_string 2169 ns 2169 ns 322789 +bm_std::function_calls__Function::set_string 2184 ns 2184 ns 320585 +bm_std::function_calls____Method::set_string 2162 ns 2161 ns 324033 -bm_rtl::function_calls__Function::set_string 2164 ns 2164 ns 324068 -bm_rtl::method_calls______Method::set_string 2162 ns 2162 ns 323716 +bm_rtl::function_calls__Function::set_string 2154 ns 2153 ns 325083 +bm_rtl::method_calls______Method::set_string 2154 ns 2154 ns 324786 -bm_rtl::function__ErasedReturnType::set_string 2178 ns 2177 ns 322027 -bm_rtl::method____ErasedReturnType::set_string 2179 ns 2179 ns 321347 -bm_rtl::method____ErasedTargetType::set_string 2180 ns 2180 ns 321745 -bm_rtl::method____ErasedTargetAndReturnType::set_string 2180 ns 2180 ns 321062 +bm_rtl::function__ErasedReturnType::set_string 2176 ns 2176 ns 321714 +bm_rtl::method____ErasedReturnType::set_string 2204 ns 2204 ns 317451 +bm_rtl::method____ErasedTargetType::set_string 2176 ns 2176 ns 321731 +bm_rtl::method____ErasedTargetAndReturnType::set_string 2179 ns 2179 ns 321077 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 4636 ns 4636 ns 151263 +bm_call::direct__Function::get_string 4620 ns 4620 ns 151475 -bm_call::via_function_ptr__Function::get_string 4632 ns 4631 ns 151234 -bm_call::via_function_ptr____Method::get_string 4627 ns 4627 ns 150946 +bm_call::via_function_ptr__Function::get_string 4620 ns 4619 ns 151555 +bm_call::via_function_ptr____Method::get_string 4626 ns 4625 ns 151381 -bm_std::function_calls__Function::get_string 4643 ns 4642 ns 151075 -bm_std::function_calls____Method::get_string 4633 ns 4633 ns 151103 +bm_std::function_calls__Function::get_string 4628 ns 4628 ns 151209 +bm_std::function_calls____Method::get_string 4618 ns 4619 ns 151486 -bm_rtl::function_calls__Function::get_string 4647 ns 4647 ns 150930 -bm_rtl::method_calls______Method::get_string 4634 ns 4634 ns 151052 +bm_rtl::function_calls__Function::get_string 4621 ns 4621 ns 151490 +bm_rtl::method_calls______Method::get_string 4619 ns 4619 ns 151593 -bm_rtl::function__ErasedReturnType::get_string 5627 ns 5626 ns 124604 -bm_rtl::method____ErasedReturnType::get_string 5618 ns 5618 ns 124566 -bm_rtl::method____ErasedTargetType::get_string 4667 ns 4667 ns 150194 -bm_rtl::method____ErasedTargetAndReturnType::get_string 5622 ns 5622 ns 124669 +bm_rtl::function__ErasedReturnType::get_string 4647 ns 4647 ns 150680 +bm_rtl::method____ErasedReturnType::get_string 4654 ns 4655 ns 150375 +bm_rtl::method____ErasedTargetType::get_string 4648 ns 4647 ns 150602 +bm_rtl::method____ErasedTargetAndReturnType::get_string 4657 ns 4657 ns 150364 ----------------------------------- -[2025-11-04 12:36:37] >>> Run 1: workload scale = 150 +[2026-01-19 23:20:43] >>> Run 1: workload scale = 150 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 150 iterations ============================================= -2025-11-04T12:36:37+05:30 +2026-01-19T23:20:43+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -3026,50 +3026,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.08, 1.06, 1.01 +Load Average: 1.00, 1.00, 0.91 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 3511 ns 3511 ns 199591 +bm_call::direct__Function::set_string 3535 ns 3535 ns 197933 -bm_call::via_function_ptr__Function::set_string 3504 ns 3504 ns 199578 -bm_call::via_function_ptr____Method::set_string 3513 ns 3512 ns 199781 +bm_call::via_function_ptr__Function::set_string 3532 ns 3532 ns 198392 +bm_call::via_function_ptr____Method::set_string 3533 ns 3533 ns 198165 -bm_std::function_calls__Function::set_string 3518 ns 3518 ns 199107 -bm_std::function_calls____Method::set_string 3521 ns 3521 ns 199095 +bm_std::function_calls__Function::set_string 3543 ns 3543 ns 197567 +bm_std::function_calls____Method::set_string 3578 ns 3578 ns 195738 -bm_rtl::function_calls__Function::set_string 3519 ns 3518 ns 199087 -bm_rtl::method_calls______Method::set_string 3525 ns 3525 ns 198202 +bm_rtl::function_calls__Function::set_string 3562 ns 3562 ns 196466 +bm_rtl::method_calls______Method::set_string 3562 ns 3563 ns 196443 -bm_rtl::function__ErasedReturnType::set_string 3531 ns 3530 ns 198334 -bm_rtl::method____ErasedReturnType::set_string 3544 ns 3543 ns 197580 -bm_rtl::method____ErasedTargetType::set_string 3538 ns 3537 ns 198133 -bm_rtl::method____ErasedTargetAndReturnType::set_string 3545 ns 3544 ns 197480 +bm_rtl::function__ErasedReturnType::set_string 3619 ns 3620 ns 193386 +bm_rtl::method____ErasedReturnType::set_string 3642 ns 3642 ns 192226 +bm_rtl::method____ErasedTargetType::set_string 3564 ns 3564 ns 196370 +bm_rtl::method____ErasedTargetAndReturnType::set_string 3646 ns 3646 ns 192007 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 6774 ns 6772 ns 103350 +bm_call::direct__Function::get_string 6783 ns 6783 ns 103274 -bm_call::via_function_ptr__Function::get_string 6773 ns 6772 ns 103343 -bm_call::via_function_ptr____Method::get_string 6772 ns 6772 ns 103373 +bm_call::via_function_ptr__Function::get_string 6798 ns 6799 ns 102812 +bm_call::via_function_ptr____Method::get_string 6800 ns 6800 ns 102962 -bm_std::function_calls__Function::get_string 6784 ns 6783 ns 103220 -bm_std::function_calls____Method::get_string 6780 ns 6780 ns 103259 +bm_std::function_calls__Function::get_string 6784 ns 6784 ns 103177 +bm_std::function_calls____Method::get_string 6783 ns 6783 ns 103199 -bm_rtl::function_calls__Function::get_string 6779 ns 6778 ns 103272 -bm_rtl::method_calls______Method::get_string 6782 ns 6781 ns 103246 +bm_rtl::function_calls__Function::get_string 6796 ns 6797 ns 103001 +bm_rtl::method_calls______Method::get_string 6798 ns 6798 ns 102869 -bm_rtl::function__ErasedReturnType::get_string 7997 ns 7997 ns 87528 -bm_rtl::method____ErasedReturnType::get_string 7989 ns 7986 ns 87655 -bm_rtl::method____ErasedTargetType::get_string 6792 ns 6791 ns 103053 -bm_rtl::method____ErasedTargetAndReturnType::get_string 7992 ns 7989 ns 87557 +bm_rtl::function__ErasedReturnType::get_string 6878 ns 6878 ns 101790 +bm_rtl::method____ErasedReturnType::get_string 6825 ns 6825 ns 102576 +bm_rtl::method____ErasedTargetType::get_string 6800 ns 6800 ns 102981 +bm_rtl::method____ErasedTargetAndReturnType::get_string 6892 ns 6893 ns 101517 ----------------------------------- -[2025-11-04 12:36:58] >>> Run 2: workload scale = 150 +[2026-01-19 23:21:03] >>> Run 2: workload scale = 150 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 150 iterations ============================================= -2025-11-04T12:36:58+05:30 +2026-01-19T23:21:03+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -3077,50 +3077,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.06, 1.06, 1.01 +Load Average: 1.00, 1.00, 0.91 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 3549 ns 3548 ns 197190 +bm_call::direct__Function::set_string 3596 ns 3596 ns 194415 -bm_call::via_function_ptr__Function::set_string 3550 ns 3550 ns 197298 -bm_call::via_function_ptr____Method::set_string 3545 ns 3545 ns 197213 +bm_call::via_function_ptr__Function::set_string 3595 ns 3595 ns 194577 +bm_call::via_function_ptr____Method::set_string 3595 ns 3595 ns 194709 -bm_std::function_calls__Function::set_string 3557 ns 3556 ns 197059 -bm_std::function_calls____Method::set_string 3547 ns 3547 ns 197291 +bm_std::function_calls__Function::set_string 3570 ns 3570 ns 195823 +bm_std::function_calls____Method::set_string 3567 ns 3567 ns 196258 -bm_rtl::function_calls__Function::set_string 3550 ns 3550 ns 197117 -bm_rtl::method_calls______Method::set_string 3555 ns 3554 ns 197038 +bm_rtl::function_calls__Function::set_string 3558 ns 3558 ns 196659 +bm_rtl::method_calls______Method::set_string 3560 ns 3560 ns 196795 -bm_rtl::function__ErasedReturnType::set_string 3568 ns 3567 ns 196518 -bm_rtl::method____ErasedReturnType::set_string 3571 ns 3570 ns 195914 -bm_rtl::method____ErasedTargetType::set_string 3563 ns 3563 ns 196195 -bm_rtl::method____ErasedTargetAndReturnType::set_string 3567 ns 3566 ns 196254 +bm_rtl::function__ErasedReturnType::set_string 3577 ns 3577 ns 195584 +bm_rtl::method____ErasedReturnType::set_string 3581 ns 3580 ns 195594 +bm_rtl::method____ErasedTargetType::set_string 3582 ns 3583 ns 195321 +bm_rtl::method____ErasedTargetAndReturnType::set_string 3621 ns 3622 ns 193209 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 6601 ns 6600 ns 106086 +bm_call::direct__Function::get_string 6610 ns 6611 ns 105907 -bm_call::via_function_ptr__Function::get_string 6598 ns 6597 ns 106016 -bm_call::via_function_ptr____Method::get_string 6598 ns 6597 ns 106208 +bm_call::via_function_ptr__Function::get_string 6624 ns 6624 ns 105696 +bm_call::via_function_ptr____Method::get_string 6622 ns 6622 ns 105724 -bm_std::function_calls__Function::get_string 6607 ns 6606 ns 105997 -bm_std::function_calls____Method::get_string 6609 ns 6608 ns 105976 +bm_std::function_calls__Function::get_string 6615 ns 6616 ns 105759 +bm_std::function_calls____Method::get_string 6628 ns 6627 ns 105578 -bm_rtl::function_calls__Function::get_string 6606 ns 6605 ns 105996 -bm_rtl::method_calls______Method::get_string 6601 ns 6600 ns 106125 +bm_rtl::function_calls__Function::get_string 6618 ns 6619 ns 105749 +bm_rtl::method_calls______Method::get_string 6619 ns 6619 ns 105730 -bm_rtl::function__ErasedReturnType::get_string 7820 ns 7818 ns 89497 -bm_rtl::method____ErasedReturnType::get_string 7813 ns 7812 ns 89600 -bm_rtl::method____ErasedTargetType::get_string 6614 ns 6613 ns 105770 -bm_rtl::method____ErasedTargetAndReturnType::get_string 7815 ns 7814 ns 89559 +bm_rtl::function__ErasedReturnType::get_string 6639 ns 6639 ns 105406 +bm_rtl::method____ErasedReturnType::get_string 6631 ns 6632 ns 105574 +bm_rtl::method____ErasedTargetType::get_string 6627 ns 6628 ns 105646 +bm_rtl::method____ErasedTargetAndReturnType::get_string 6630 ns 6630 ns 105509 ----------------------------------- -[2025-11-04 12:37:18] >>> Run 3: workload scale = 150 +[2026-01-19 23:21:24] >>> Run 3: workload scale = 150 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 150 iterations ============================================= -2025-11-04T12:37:18+05:30 +2026-01-19T23:21:24+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -3128,40 +3128,40 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 1.05, 1.01 +Load Average: 1.00, 1.00, 0.91 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 3521 ns 3520 ns 198831 +bm_call::direct__Function::set_string 3514 ns 3514 ns 199066 -bm_call::via_function_ptr__Function::set_string 3519 ns 3519 ns 199065 -bm_call::via_function_ptr____Method::set_string 3520 ns 3519 ns 198988 +bm_call::via_function_ptr__Function::set_string 3515 ns 3514 ns 199130 +bm_call::via_function_ptr____Method::set_string 3514 ns 3514 ns 199175 -bm_std::function_calls__Function::set_string 3529 ns 3528 ns 198384 -bm_std::function_calls____Method::set_string 3535 ns 3534 ns 198140 +bm_std::function_calls__Function::set_string 3526 ns 3526 ns 198508 +bm_std::function_calls____Method::set_string 3524 ns 3524 ns 198536 -bm_rtl::function_calls__Function::set_string 3529 ns 3529 ns 198462 -bm_rtl::method_calls______Method::set_string 3528 ns 3528 ns 198319 +bm_rtl::function_calls__Function::set_string 3516 ns 3516 ns 199092 +bm_rtl::method_calls______Method::set_string 3518 ns 3518 ns 198918 -bm_rtl::function__ErasedReturnType::set_string 3537 ns 3536 ns 197784 -bm_rtl::method____ErasedReturnType::set_string 3544 ns 3543 ns 197602 -bm_rtl::method____ErasedTargetType::set_string 3544 ns 3543 ns 197518 -bm_rtl::method____ErasedTargetAndReturnType::set_string 3547 ns 3546 ns 197510 +bm_rtl::function__ErasedReturnType::set_string 3539 ns 3539 ns 197865 +bm_rtl::method____ErasedReturnType::set_string 3540 ns 3540 ns 197836 +bm_rtl::method____ErasedTargetType::set_string 3579 ns 3579 ns 195608 +bm_rtl::method____ErasedTargetAndReturnType::set_string 3537 ns 3538 ns 198024 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 6791 ns 6789 ns 103143 +bm_call::direct__Function::get_string 6601 ns 6600 ns 106079 -bm_call::via_function_ptr__Function::get_string 6789 ns 6788 ns 103109 -bm_call::via_function_ptr____Method::get_string 6789 ns 6787 ns 103031 +bm_call::via_function_ptr__Function::get_string 6610 ns 6611 ns 105837 +bm_call::via_function_ptr____Method::get_string 6611 ns 6612 ns 105817 -bm_std::function_calls__Function::get_string 6785 ns 6783 ns 103175 -bm_std::function_calls____Method::get_string 6783 ns 6782 ns 103233 +bm_std::function_calls__Function::get_string 6605 ns 6603 ns 106033 +bm_std::function_calls____Method::get_string 6604 ns 6603 ns 105956 -bm_rtl::function_calls__Function::get_string 6792 ns 6791 ns 103075 -bm_rtl::method_calls______Method::get_string 6796 ns 6795 ns 103017 +bm_rtl::function_calls__Function::get_string 6609 ns 6609 ns 106000 +bm_rtl::method_calls______Method::get_string 6610 ns 6609 ns 105922 -bm_rtl::function__ErasedReturnType::get_string 7988 ns 7987 ns 87673 -bm_rtl::method____ErasedReturnType::get_string 7989 ns 7985 ns 87691 -bm_rtl::method____ErasedTargetType::get_string 6797 ns 6796 ns 103050 -bm_rtl::method____ErasedTargetAndReturnType::get_string 7990 ns 7988 ns 87626 +bm_rtl::function__ErasedReturnType::get_string 6632 ns 6632 ns 105525 +bm_rtl::method____ErasedReturnType::get_string 6634 ns 6633 ns 105489 +bm_rtl::method____ErasedTargetType::get_string 6622 ns 6622 ns 105723 +bm_rtl::method____ErasedTargetAndReturnType::get_string 6631 ns 6631 ns 105505 ----------------------------------- All benchmarks completed. diff --git a/text-benchmark-logs/benchmark_runs_string_view.log b/docs/benchmark_runs_string_view.log similarity index 60% rename from text-benchmark-logs/benchmark_runs_string_view.log rename to docs/benchmark_runs_string_view.log index 0399b902..ceb8d40a 100644 --- a/text-benchmark-logs/benchmark_runs_string_view.log +++ b/docs/benchmark_runs_string_view.log @@ -2,116 +2,116 @@ Starting benchmark runs... Binary: ./bin/RTLBenchmarkApp Log: ./benchmark_runs.log =================================== -[2025-11-04 11:28:24] >>> Run 1: workload scale = 0 +[2026-01-19 22:16:59] >>> Run 1: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T11:28:24+05:30 +2026-01-19T22:16:59+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 800 MHz CPU s) +Run on (16 X 2685.07 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 0.38, 0.13, 0.04 +Load Average: 0.63, 0.46, 0.19 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- bm_call::direct__Function::set_string 0.614 ns 0.614 ns 1000000000 -bm_call::via_function_ptr__Function::set_string 1.02 ns 1.02 ns 683678776 -bm_call::via_function_ptr____Method::set_string 1.23 ns 1.23 ns 569885030 +bm_call::via_function_ptr__Function::set_string 1.02 ns 1.02 ns 683568677 +bm_call::via_function_ptr____Method::set_string 1.23 ns 1.23 ns 576541050 -bm_std::function_calls__Function::set_string 1.23 ns 1.23 ns 562884499 -bm_std::function_calls____Method::set_string 1.64 ns 1.64 ns 426729520 +bm_std::function_calls__Function::set_string 1.23 ns 1.23 ns 569030602 +bm_std::function_calls____Method::set_string 1.52 ns 1.52 ns 467624796 -bm_rtl::function_calls__Function::set_string 1.02 ns 1.02 ns 683865607 -bm_rtl::method_calls______Method::set_string 1.62 ns 1.62 ns 430515116 +bm_rtl::function_calls__Function::set_string 1.02 ns 1.02 ns 684146847 +bm_rtl::method_calls______Method::set_string 1.43 ns 1.43 ns 488587084 -bm_rtl::function__ErasedReturnType::set_string 3.04 ns 3.04 ns 230360121 -bm_rtl::method____ErasedReturnType::set_string 4.04 ns 4.04 ns 172858129 -bm_rtl::method____ErasedTargetType::set_string 4.26 ns 4.26 ns 166388092 -bm_rtl::method____ErasedTargetAndReturnType::set_string 4.74 ns 4.74 ns 149410247 +bm_rtl::function__ErasedReturnType::set_string 2.82 ns 2.82 ns 249372110 +bm_rtl::method____ErasedReturnType::set_string 3.31 ns 3.31 ns 212147428 +bm_rtl::method____ErasedTargetType::set_string 3.89 ns 3.89 ns 180614166 +bm_rtl::method____ErasedTargetAndReturnType::set_string 4.54 ns 4.54 ns 155811336 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1.48 ns 1.48 ns 466378476 +bm_call::direct__Function::get_string 1.44 ns 1.44 ns 488611796 -bm_call::via_function_ptr__Function::get_string 2.58 ns 2.58 ns 270570089 -bm_call::via_function_ptr____Method::get_string 2.59 ns 2.59 ns 269322401 +bm_call::via_function_ptr__Function::get_string 2.66 ns 2.66 ns 263520027 +bm_call::via_function_ptr____Method::get_string 2.46 ns 2.46 ns 285111058 -bm_std::function_calls__Function::get_string 2.76 ns 2.76 ns 251347073 -bm_std::function_calls____Method::get_string 3.27 ns 3.27 ns 217804162 +bm_std::function_calls__Function::get_string 2.46 ns 2.46 ns 285121216 +bm_std::function_calls____Method::get_string 3.20 ns 3.20 ns 219769186 -bm_rtl::function_calls__Function::get_string 2.58 ns 2.58 ns 270312043 -bm_rtl::method_calls______Method::get_string 2.98 ns 2.98 ns 230536281 +bm_rtl::function_calls__Function::get_string 2.26 ns 2.26 ns 310201816 +bm_rtl::method_calls______Method::get_string 2.76 ns 2.76 ns 260137507 -bm_rtl::function__ErasedReturnType::get_string 15.1 ns 15.1 ns 45710706 -bm_rtl::method____ErasedReturnType::get_string 15.8 ns 15.8 ns 44050977 -bm_rtl::method____ErasedTargetType::get_string 5.97 ns 5.97 ns 117370904 -bm_rtl::method____ErasedTargetAndReturnType::get_string 17.3 ns 17.3 ns 43244655 +bm_rtl::function__ErasedReturnType::get_string 13.7 ns 13.7 ns 51217947 +bm_rtl::method____ErasedReturnType::get_string 14.0 ns 14.0 ns 49918633 +bm_rtl::method____ErasedTargetType::get_string 6.75 ns 6.75 ns 103663468 +bm_rtl::method____ErasedTargetAndReturnType::get_string 15.5 ns 15.5 ns 45414826 ----------------------------------- -[2025-11-04 11:28:44] >>> Run 2: workload scale = 0 +[2026-01-19 22:17:19] >>> Run 2: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T11:28:44+05:30 +2026-01-19T22:17:19+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4611.4 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 0.78, 0.24, 0.08 +Load Average: 0.74, 0.50, 0.21 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 0.634 ns 0.634 ns 1000000000 +bm_call::direct__Function::set_string 0.615 ns 0.615 ns 1000000000 -bm_call::via_function_ptr__Function::set_string 1.08 ns 1.08 ns 654860358 -bm_call::via_function_ptr____Method::set_string 1.30 ns 1.30 ns 525150563 +bm_call::via_function_ptr__Function::set_string 1.03 ns 1.03 ns 684181498 +bm_call::via_function_ptr____Method::set_string 1.21 ns 1.21 ns 569642730 -bm_std::function_calls__Function::set_string 1.28 ns 1.28 ns 542946738 -bm_std::function_calls____Method::set_string 1.65 ns 1.65 ns 415930435 +bm_std::function_calls__Function::set_string 1.23 ns 1.23 ns 569800978 +bm_std::function_calls____Method::set_string 1.52 ns 1.52 ns 450875649 -bm_rtl::function_calls__Function::set_string 1.07 ns 1.07 ns 676793908 -bm_rtl::method_calls______Method::set_string 1.68 ns 1.68 ns 408934924 +bm_rtl::function_calls__Function::set_string 1.02 ns 1.02 ns 683995818 +bm_rtl::method_calls______Method::set_string 1.43 ns 1.43 ns 488611687 -bm_rtl::function__ErasedReturnType::set_string 3.20 ns 3.20 ns 229478489 -bm_rtl::method____ErasedReturnType::set_string 4.05 ns 4.05 ns 170238631 -bm_rtl::method____ErasedTargetType::set_string 4.22 ns 4.22 ns 164288125 -bm_rtl::method____ErasedTargetAndReturnType::set_string 4.68 ns 4.68 ns 150597958 +bm_rtl::function__ErasedReturnType::set_string 2.83 ns 2.83 ns 246485658 +bm_rtl::method____ErasedReturnType::set_string 3.30 ns 3.30 ns 214354534 +bm_rtl::method____ErasedTargetType::set_string 3.89 ns 3.89 ns 180045506 +bm_rtl::method____ErasedTargetAndReturnType::set_string 4.51 ns 4.51 ns 154404330 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1.43 ns 1.43 ns 474635786 +bm_call::direct__Function::get_string 1.44 ns 1.44 ns 487781988 -bm_call::via_function_ptr__Function::get_string 2.49 ns 2.49 ns 282523832 -bm_call::via_function_ptr____Method::get_string 2.48 ns 2.48 ns 283788061 +bm_call::via_function_ptr__Function::get_string 2.66 ns 2.66 ns 263194125 +bm_call::via_function_ptr____Method::get_string 2.46 ns 2.46 ns 285136636 -bm_std::function_calls__Function::get_string 2.69 ns 2.69 ns 256523801 -bm_std::function_calls____Method::get_string 3.11 ns 3.11 ns 225496053 +bm_std::function_calls__Function::get_string 2.46 ns 2.46 ns 285136994 +bm_std::function_calls____Method::get_string 3.18 ns 3.18 ns 228110017 -bm_rtl::function_calls__Function::get_string 2.56 ns 2.56 ns 271049574 -bm_rtl::method_calls______Method::get_string 2.95 ns 2.95 ns 242354631 +bm_rtl::function_calls__Function::get_string 2.26 ns 2.26 ns 310208330 +bm_rtl::method_calls______Method::get_string 2.72 ns 2.72 ns 256333628 -bm_rtl::function__ErasedReturnType::get_string 15.5 ns 15.5 ns 45846828 -bm_rtl::method____ErasedReturnType::get_string 15.7 ns 15.7 ns 44262788 -bm_rtl::method____ErasedTargetType::get_string 5.89 ns 5.89 ns 117265605 -bm_rtl::method____ErasedTargetAndReturnType::get_string 16.3 ns 16.3 ns 42284738 +bm_rtl::function__ErasedReturnType::get_string 13.8 ns 13.8 ns 51058389 +bm_rtl::method____ErasedReturnType::get_string 14.1 ns 14.1 ns 49524008 +bm_rtl::method____ErasedTargetType::get_string 6.75 ns 6.75 ns 103685569 +bm_rtl::method____ErasedTargetAndReturnType::get_string 15.1 ns 15.1 ns 46352459 ----------------------------------- -[2025-11-04 11:29:05] >>> Run 3: workload scale = 0 +[2026-01-19 22:17:39] >>> Run 3: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T11:29:05+05:30 +2026-01-19T22:17:39+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -119,101 +119,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.13, 0.35, 0.12 +Load Average: 0.81, 0.53, 0.22 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 0.543 ns 0.543 ns 1000000000 +bm_call::direct__Function::set_string 0.614 ns 0.614 ns 1000000000 -bm_call::via_function_ptr__Function::set_string 1.03 ns 1.03 ns 683567202 -bm_call::via_function_ptr____Method::set_string 1.23 ns 1.23 ns 569508463 +bm_call::via_function_ptr__Function::set_string 1.02 ns 1.02 ns 683812844 +bm_call::via_function_ptr____Method::set_string 1.22 ns 1.21 ns 577612805 -bm_std::function_calls__Function::set_string 1.23 ns 1.23 ns 570111428 -bm_std::function_calls____Method::set_string 1.64 ns 1.64 ns 427615238 +bm_std::function_calls__Function::set_string 1.23 ns 1.23 ns 569775056 +bm_std::function_calls____Method::set_string 1.59 ns 1.59 ns 434079632 -bm_rtl::function_calls__Function::set_string 1.02 ns 1.02 ns 684124829 -bm_rtl::method_calls______Method::set_string 1.62 ns 1.62 ns 476008120 +bm_rtl::function_calls__Function::set_string 1.02 ns 1.02 ns 683787447 +bm_rtl::method_calls______Method::set_string 1.42 ns 1.42 ns 488613617 -bm_rtl::function__ErasedReturnType::set_string 3.02 ns 3.02 ns 230302984 -bm_rtl::method____ErasedReturnType::set_string 4.02 ns 4.02 ns 172265220 -bm_rtl::method____ErasedTargetType::set_string 4.26 ns 4.26 ns 164395945 -bm_rtl::method____ErasedTargetAndReturnType::set_string 4.67 ns 4.67 ns 151752309 +bm_rtl::function__ErasedReturnType::set_string 7.37 ns 7.37 ns 95035791 +bm_rtl::method____ErasedReturnType::set_string 7.78 ns 7.78 ns 90042208 +bm_rtl::method____ErasedTargetType::set_string 3.90 ns 3.90 ns 180433649 +bm_rtl::method____ErasedTargetAndReturnType::set_string 8.60 ns 8.60 ns 81448564 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1.41 ns 1.41 ns 495458672 +bm_call::direct__Function::get_string 1.44 ns 1.44 ns 488585969 -bm_call::via_function_ptr__Function::get_string 2.46 ns 2.46 ns 284981627 -bm_call::via_function_ptr____Method::get_string 2.49 ns 2.49 ns 280143091 +bm_call::via_function_ptr__Function::get_string 2.66 ns 2.66 ns 265152552 +bm_call::via_function_ptr____Method::get_string 2.46 ns 2.46 ns 284574733 -bm_std::function_calls__Function::get_string 2.66 ns 2.66 ns 263196386 -bm_std::function_calls____Method::get_string 3.11 ns 3.10 ns 227498153 +bm_std::function_calls__Function::get_string 2.46 ns 2.46 ns 285006675 +bm_std::function_calls____Method::get_string 3.15 ns 3.15 ns 222331260 -bm_rtl::function_calls__Function::get_string 2.46 ns 2.46 ns 284559260 -bm_rtl::method_calls______Method::get_string 2.87 ns 2.87 ns 244503914 +bm_rtl::function_calls__Function::get_string 2.26 ns 2.26 ns 310066005 +bm_rtl::method_calls______Method::get_string 2.67 ns 2.67 ns 253455004 -bm_rtl::function__ErasedReturnType::get_string 14.7 ns 14.7 ns 48203413 -bm_rtl::method____ErasedReturnType::get_string 15.2 ns 15.2 ns 45954622 -bm_rtl::method____ErasedTargetType::get_string 5.81 ns 5.81 ns 120895674 -bm_rtl::method____ErasedTargetAndReturnType::get_string 16.4 ns 16.4 ns 42589796 +bm_rtl::function__ErasedReturnType::get_string 13.7 ns 13.7 ns 50596278 +bm_rtl::method____ErasedReturnType::get_string 14.1 ns 14.1 ns 49241845 +bm_rtl::method____ErasedTargetType::get_string 6.76 ns 6.76 ns 103534631 +bm_rtl::method____ErasedTargetAndReturnType::get_string 15.2 ns 15.2 ns 46787119 ----------------------------------- -[2025-11-04 11:29:25] >>> Run 4: workload scale = 0 +[2026-01-19 22:17:59] >>> Run 4: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T11:29:25+05:30 +2026-01-19T22:17:59+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4142.36 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.09, 0.39, 0.14 +Load Average: 0.87, 0.56, 0.24 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 0.619 ns 0.620 ns 1000000000 +bm_call::direct__Function::set_string 0.615 ns 0.614 ns 1000000000 -bm_call::via_function_ptr__Function::set_string 1.02 ns 1.02 ns 683826531 -bm_call::via_function_ptr____Method::set_string 1.23 ns 1.23 ns 569466070 +bm_call::via_function_ptr__Function::set_string 1.02 ns 1.02 ns 682977689 +bm_call::via_function_ptr____Method::set_string 1.23 ns 1.23 ns 563075836 -bm_std::function_calls__Function::set_string 1.23 ns 1.23 ns 563230061 -bm_std::function_calls____Method::set_string 1.64 ns 1.64 ns 427349799 +bm_std::function_calls__Function::set_string 1.23 ns 1.23 ns 569603803 +bm_std::function_calls____Method::set_string 1.54 ns 1.54 ns 460593978 -bm_rtl::function_calls__Function::set_string 1.02 ns 1.03 ns 684106315 -bm_rtl::method_calls______Method::set_string 1.50 ns 1.50 ns 485473792 +bm_rtl::function_calls__Function::set_string 1.02 ns 1.02 ns 683892125 +bm_rtl::method_calls______Method::set_string 1.43 ns 1.43 ns 488236125 -bm_rtl::function__ErasedReturnType::set_string 3.04 ns 3.04 ns 231054109 -bm_rtl::method____ErasedReturnType::set_string 4.01 ns 4.01 ns 177095634 -bm_rtl::method____ErasedTargetType::set_string 4.15 ns 4.15 ns 168485741 -bm_rtl::method____ErasedTargetAndReturnType::set_string 4.58 ns 4.58 ns 149929544 +bm_rtl::function__ErasedReturnType::set_string 7.37 ns 7.37 ns 95016114 +bm_rtl::method____ErasedReturnType::set_string 7.78 ns 7.78 ns 90024009 +bm_rtl::method____ErasedTargetType::set_string 3.89 ns 3.89 ns 180054936 +bm_rtl::method____ErasedTargetAndReturnType::set_string 8.60 ns 8.60 ns 81331959 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1.42 ns 1.42 ns 495133376 +bm_call::direct__Function::get_string 1.43 ns 1.43 ns 488678219 -bm_call::via_function_ptr__Function::get_string 2.45 ns 2.46 ns 285005788 -bm_call::via_function_ptr____Method::get_string 2.48 ns 2.48 ns 284236287 +bm_call::via_function_ptr__Function::get_string 2.66 ns 2.66 ns 264051337 +bm_call::via_function_ptr____Method::get_string 2.46 ns 2.46 ns 285120509 -bm_std::function_calls__Function::get_string 2.66 ns 2.66 ns 263017751 -bm_std::function_calls____Method::get_string 3.10 ns 3.10 ns 224825065 +bm_std::function_calls__Function::get_string 2.46 ns 2.46 ns 285112848 +bm_std::function_calls____Method::get_string 3.23 ns 3.23 ns 226611386 -bm_rtl::function_calls__Function::get_string 2.46 ns 2.46 ns 284512552 -bm_rtl::method_calls______Method::get_string 2.86 ns 2.86 ns 243917692 +bm_rtl::function_calls__Function::get_string 2.26 ns 2.26 ns 310198473 +bm_rtl::method_calls______Method::get_string 2.70 ns 2.70 ns 258499213 -bm_rtl::function__ErasedReturnType::get_string 14.7 ns 14.7 ns 47450172 -bm_rtl::method____ErasedReturnType::get_string 15.2 ns 15.2 ns 46035495 -bm_rtl::method____ErasedTargetType::get_string 5.86 ns 5.86 ns 121152258 -bm_rtl::method____ErasedTargetAndReturnType::get_string 16.3 ns 16.3 ns 41584993 +bm_rtl::function__ErasedReturnType::get_string 13.6 ns 13.6 ns 51481253 +bm_rtl::method____ErasedReturnType::get_string 14.1 ns 14.1 ns 50116508 +bm_rtl::method____ErasedTargetType::get_string 6.76 ns 6.76 ns 103642665 +bm_rtl::method____ErasedTargetAndReturnType::get_string 15.1 ns 15.1 ns 46654405 ----------------------------------- -[2025-11-04 11:29:46] >>> Run 5: workload scale = 0 +[2026-01-19 22:18:18] >>> Run 5: workload scale = 0 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 0 iterations ============================================= -2025-11-04T11:29:46+05:30 +2026-01-19T22:18:18+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -221,50 +221,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.06, 0.43, 0.16 +Load Average: 0.90, 0.59, 0.26 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 0.540 ns 0.540 ns 1000000000 +bm_call::direct__Function::set_string 0.614 ns 0.614 ns 1000000000 -bm_call::via_function_ptr__Function::set_string 1.03 ns 1.03 ns 682847039 -bm_call::via_function_ptr____Method::set_string 1.23 ns 1.23 ns 568512058 +bm_call::via_function_ptr__Function::set_string 1.02 ns 1.02 ns 680343092 +bm_call::via_function_ptr____Method::set_string 1.23 ns 1.23 ns 575099292 -bm_std::function_calls__Function::set_string 1.23 ns 1.23 ns 569587483 -bm_std::function_calls____Method::set_string 1.64 ns 1.64 ns 427385239 +bm_std::function_calls__Function::set_string 1.23 ns 1.23 ns 569190838 +bm_std::function_calls____Method::set_string 1.49 ns 1.49 ns 452799580 -bm_rtl::function_calls__Function::set_string 1.02 ns 1.02 ns 683618197 -bm_rtl::method_calls______Method::set_string 1.63 ns 1.63 ns 428438447 +bm_rtl::function_calls__Function::set_string 1.02 ns 1.02 ns 684190319 +bm_rtl::method_calls______Method::set_string 1.43 ns 1.43 ns 490962912 -bm_rtl::function__ErasedReturnType::set_string 3.03 ns 3.03 ns 230910273 -bm_rtl::method____ErasedReturnType::set_string 3.96 ns 3.96 ns 177102134 -bm_rtl::method____ErasedTargetType::set_string 4.21 ns 4.21 ns 166155415 -bm_rtl::method____ErasedTargetAndReturnType::set_string 4.63 ns 4.63 ns 151585002 +bm_rtl::function__ErasedReturnType::set_string 2.82 ns 2.82 ns 246594378 +bm_rtl::method____ErasedReturnType::set_string 3.33 ns 3.33 ns 211691857 +bm_rtl::method____ErasedTargetType::set_string 3.89 ns 3.89 ns 180435897 +bm_rtl::method____ErasedTargetAndReturnType::set_string 4.52 ns 4.52 ns 156477629 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1.42 ns 1.42 ns 495417193 +bm_call::direct__Function::get_string 1.43 ns 1.43 ns 487577300 -bm_call::via_function_ptr__Function::get_string 2.45 ns 2.46 ns 285068393 -bm_call::via_function_ptr____Method::get_string 2.48 ns 2.48 ns 283577125 +bm_call::via_function_ptr__Function::get_string 2.66 ns 2.66 ns 263417306 +bm_call::via_function_ptr____Method::get_string 2.46 ns 2.46 ns 285094736 -bm_std::function_calls__Function::get_string 2.66 ns 2.66 ns 263081859 -bm_std::function_calls____Method::get_string 3.09 ns 3.09 ns 225912956 +bm_std::function_calls__Function::get_string 2.46 ns 2.46 ns 285121796 +bm_std::function_calls____Method::get_string 3.16 ns 3.16 ns 215202059 -bm_rtl::function_calls__Function::get_string 2.46 ns 2.46 ns 285086595 -bm_rtl::method_calls______Method::get_string 2.88 ns 2.88 ns 242840494 +bm_rtl::function_calls__Function::get_string 2.26 ns 2.26 ns 310197791 +bm_rtl::method_calls______Method::get_string 2.76 ns 2.76 ns 258111711 -bm_rtl::function__ErasedReturnType::get_string 14.9 ns 14.9 ns 46919301 -bm_rtl::method____ErasedReturnType::get_string 15.0 ns 15.0 ns 45689265 -bm_rtl::method____ErasedTargetType::get_string 5.87 ns 5.88 ns 119688015 -bm_rtl::method____ErasedTargetAndReturnType::get_string 16.3 ns 16.3 ns 43375628 +bm_rtl::function__ErasedReturnType::get_string 13.7 ns 13.7 ns 51303361 +bm_rtl::method____ErasedReturnType::get_string 14.1 ns 14.1 ns 50044327 +bm_rtl::method____ErasedTargetType::get_string 6.76 ns 6.76 ns 103673181 +bm_rtl::method____ErasedTargetAndReturnType::get_string 15.1 ns 15.1 ns 46222419 ----------------------------------- -[2025-11-04 11:30:06] >>> Run 1: workload scale = 1 +[2026-01-19 22:18:39] >>> Run 1: workload scale = 1 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 1 iterations ============================================= -2025-11-04T11:30:06+05:30 +2026-01-19T22:18:39+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -272,50 +272,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 0.47, 0.18 +Load Average: 0.93, 0.62, 0.28 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 14.5 ns 14.5 ns 48242791 +bm_call::direct__Function::set_string 14.2 ns 14.2 ns 47602979 -bm_call::via_function_ptr__Function::set_string 14.6 ns 14.6 ns 47568680 -bm_call::via_function_ptr____Method::set_string 14.5 ns 14.5 ns 48746560 +bm_call::via_function_ptr__Function::set_string 14.7 ns 14.7 ns 47551280 +bm_call::via_function_ptr____Method::set_string 14.5 ns 14.5 ns 48814713 -bm_std::function_calls__Function::set_string 14.4 ns 14.4 ns 48361996 -bm_std::function_calls____Method::set_string 14.7 ns 14.7 ns 47229848 +bm_std::function_calls__Function::set_string 14.8 ns 14.8 ns 48125351 +bm_std::function_calls____Method::set_string 15.0 ns 15.0 ns 45842215 -bm_rtl::function_calls__Function::set_string 14.3 ns 14.3 ns 47864234 -bm_rtl::method_calls______Method::set_string 15.0 ns 15.0 ns 46668705 +bm_rtl::function_calls__Function::set_string 14.6 ns 14.6 ns 47596122 +bm_rtl::method_calls______Method::set_string 14.8 ns 14.8 ns 47688533 -bm_rtl::function__ErasedReturnType::set_string 16.8 ns 16.8 ns 41584347 -bm_rtl::method____ErasedReturnType::set_string 17.0 ns 17.0 ns 41277560 -bm_rtl::method____ErasedTargetType::set_string 17.9 ns 17.9 ns 38831295 -bm_rtl::method____ErasedTargetAndReturnType::set_string 18.1 ns 18.1 ns 38521566 +bm_rtl::function__ErasedReturnType::set_string 16.3 ns 16.3 ns 43204263 +bm_rtl::method____ErasedReturnType::set_string 17.4 ns 17.4 ns 39803981 +bm_rtl::method____ErasedTargetType::set_string 17.4 ns 17.4 ns 40619050 +bm_rtl::method____ErasedTargetAndReturnType::set_string 17.5 ns 17.5 ns 39261182 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 21.4 ns 21.4 ns 32748201 +bm_call::direct__Function::get_string 19.8 ns 19.8 ns 35318159 -bm_call::via_function_ptr__Function::get_string 21.7 ns 21.7 ns 32229019 -bm_call::via_function_ptr____Method::get_string 21.8 ns 21.8 ns 32216795 +bm_call::via_function_ptr__Function::get_string 19.9 ns 19.9 ns 34920150 +bm_call::via_function_ptr____Method::get_string 19.9 ns 19.9 ns 35041102 -bm_std::function_calls__Function::get_string 21.8 ns 21.8 ns 32016965 -bm_std::function_calls____Method::get_string 21.7 ns 21.7 ns 32038907 +bm_std::function_calls__Function::get_string 20.3 ns 20.3 ns 34279465 +bm_std::function_calls____Method::get_string 20.7 ns 20.7 ns 33535205 -bm_rtl::function_calls__Function::get_string 21.7 ns 21.7 ns 32075981 -bm_rtl::method_calls______Method::get_string 21.8 ns 21.8 ns 32139933 +bm_rtl::function_calls__Function::get_string 20.0 ns 20.0 ns 34773001 +bm_rtl::method_calls______Method::get_string 20.0 ns 20.0 ns 34838388 -bm_rtl::function__ErasedReturnType::get_string 34.3 ns 34.3 ns 20292635 -bm_rtl::method____ErasedReturnType::get_string 35.5 ns 35.5 ns 19832365 -bm_rtl::method____ErasedTargetType::get_string 24.2 ns 24.2 ns 29003990 -bm_rtl::method____ErasedTargetAndReturnType::get_string 35.8 ns 35.8 ns 19482072 +bm_rtl::function__ErasedReturnType::get_string 32.0 ns 32.0 ns 22025260 +bm_rtl::method____ErasedReturnType::get_string 32.3 ns 32.3 ns 21635178 +bm_rtl::method____ErasedTargetType::get_string 24.1 ns 24.1 ns 29030859 +bm_rtl::method____ErasedTargetAndReturnType::get_string 33.7 ns 33.6 ns 20685409 ----------------------------------- -[2025-11-04 11:30:27] >>> Run 2: workload scale = 1 +[2026-01-19 22:18:59] >>> Run 2: workload scale = 1 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 1 iterations ============================================= -2025-11-04T11:30:27+05:30 +2026-01-19T22:18:59+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -323,50 +323,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.03, 0.51, 0.20 +Load Average: 0.95, 0.65, 0.29 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 14.5 ns 14.5 ns 48600272 +bm_call::direct__Function::set_string 14.3 ns 14.3 ns 48584646 -bm_call::via_function_ptr__Function::set_string 14.4 ns 14.4 ns 47262841 -bm_call::via_function_ptr____Method::set_string 14.7 ns 14.7 ns 47560475 +bm_call::via_function_ptr__Function::set_string 15.0 ns 15.0 ns 46029690 +bm_call::via_function_ptr____Method::set_string 14.9 ns 14.9 ns 46651918 -bm_std::function_calls__Function::set_string 14.7 ns 14.7 ns 46778629 -bm_std::function_calls____Method::set_string 15.0 ns 15.0 ns 46225572 +bm_std::function_calls__Function::set_string 15.5 ns 15.5 ns 46957480 +bm_std::function_calls____Method::set_string 15.3 ns 15.3 ns 43780461 -bm_rtl::function_calls__Function::set_string 14.4 ns 14.4 ns 47934169 -bm_rtl::method_calls______Method::set_string 15.0 ns 15.0 ns 46326371 +bm_rtl::function_calls__Function::set_string 15.0 ns 15.0 ns 47249334 +bm_rtl::method_calls______Method::set_string 14.8 ns 14.8 ns 47018811 -bm_rtl::function__ErasedReturnType::set_string 16.7 ns 16.7 ns 41965256 -bm_rtl::method____ErasedReturnType::set_string 17.2 ns 17.2 ns 41096893 -bm_rtl::method____ErasedTargetType::set_string 17.5 ns 17.5 ns 40225175 -bm_rtl::method____ErasedTargetAndReturnType::set_string 18.1 ns 18.1 ns 38566575 +bm_rtl::function__ErasedReturnType::set_string 16.6 ns 16.6 ns 41801460 +bm_rtl::method____ErasedReturnType::set_string 17.4 ns 17.4 ns 41245734 +bm_rtl::method____ErasedTargetType::set_string 17.4 ns 17.4 ns 40022891 +bm_rtl::method____ErasedTargetAndReturnType::set_string 17.9 ns 17.9 ns 39375751 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 21.1 ns 21.2 ns 32955668 +bm_call::direct__Function::get_string 25.0 ns 25.0 ns 27910450 -bm_call::via_function_ptr__Function::get_string 21.2 ns 21.2 ns 33076981 -bm_call::via_function_ptr____Method::get_string 21.4 ns 21.4 ns 32585058 +bm_call::via_function_ptr__Function::get_string 25.0 ns 25.0 ns 27970128 +bm_call::via_function_ptr____Method::get_string 25.2 ns 25.1 ns 27845622 -bm_std::function_calls__Function::get_string 21.3 ns 21.3 ns 32772706 -bm_std::function_calls____Method::get_string 22.2 ns 22.2 ns 31420316 +bm_std::function_calls__Function::get_string 25.2 ns 25.2 ns 27757309 +bm_std::function_calls____Method::get_string 25.3 ns 25.3 ns 27601367 -bm_rtl::function_calls__Function::get_string 21.2 ns 21.2 ns 33089599 -bm_rtl::method_calls______Method::get_string 21.6 ns 21.6 ns 32466374 +bm_rtl::function_calls__Function::get_string 25.0 ns 25.0 ns 28025612 +bm_rtl::method_calls______Method::get_string 25.2 ns 25.2 ns 27785388 -bm_rtl::function__ErasedReturnType::get_string 34.2 ns 34.2 ns 20325951 -bm_rtl::method____ErasedReturnType::get_string 35.1 ns 35.1 ns 19870274 -bm_rtl::method____ErasedTargetType::get_string 24.3 ns 24.3 ns 29128625 -bm_rtl::method____ErasedTargetAndReturnType::get_string 36.0 ns 36.0 ns 19558210 +bm_rtl::function__ErasedReturnType::get_string 31.7 ns 31.7 ns 22028623 +bm_rtl::method____ErasedReturnType::get_string 32.3 ns 32.3 ns 21724774 +bm_rtl::method____ErasedTargetType::get_string 29.4 ns 29.4 ns 23749156 +bm_rtl::method____ErasedTargetAndReturnType::get_string 33.4 ns 33.4 ns 20507660 ----------------------------------- -[2025-11-04 11:30:47] >>> Run 3: workload scale = 1 +[2026-01-19 22:19:19] >>> Run 3: workload scale = 1 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 1 iterations ============================================= -2025-11-04T11:30:47+05:30 +2026-01-19T22:19:19+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -374,101 +374,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 0.55, 0.22 +Load Average: 0.97, 0.67, 0.31 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 24.0 ns 24.0 ns 29170635 +bm_call::direct__Function::set_string 14.5 ns 14.5 ns 48240969 -bm_call::via_function_ptr__Function::set_string 23.5 ns 23.5 ns 29738969 -bm_call::via_function_ptr____Method::set_string 23.7 ns 23.7 ns 29340017 +bm_call::via_function_ptr__Function::set_string 14.9 ns 14.9 ns 46922624 +bm_call::via_function_ptr____Method::set_string 14.9 ns 14.9 ns 46873657 -bm_std::function_calls__Function::set_string 23.7 ns 23.7 ns 29670419 -bm_std::function_calls____Method::set_string 15.2 ns 15.2 ns 46003960 +bm_std::function_calls__Function::set_string 15.0 ns 15.0 ns 46979264 +bm_std::function_calls____Method::set_string 14.8 ns 14.8 ns 46821025 -bm_rtl::function_calls__Function::set_string 23.5 ns 23.5 ns 29709584 -bm_rtl::method_calls______Method::set_string 23.8 ns 23.8 ns 29608054 +bm_rtl::function_calls__Function::set_string 14.9 ns 14.9 ns 47090225 +bm_rtl::method_calls______Method::set_string 14.9 ns 14.9 ns 47324383 -bm_rtl::function__ErasedReturnType::set_string 20.2 ns 20.2 ns 34607217 -bm_rtl::method____ErasedReturnType::set_string 20.3 ns 20.3 ns 34461009 -bm_rtl::method____ErasedTargetType::set_string 26.1 ns 26.1 ns 26810310 -bm_rtl::method____ErasedTargetAndReturnType::set_string 26.1 ns 26.1 ns 26832712 +bm_rtl::function__ErasedReturnType::set_string 16.5 ns 16.4 ns 42457769 +bm_rtl::method____ErasedReturnType::set_string 16.6 ns 16.6 ns 41747381 +bm_rtl::method____ErasedTargetType::set_string 17.3 ns 17.3 ns 40942180 +bm_rtl::method____ErasedTargetAndReturnType::set_string 19.2 ns 19.2 ns 36853482 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 32.8 ns 32.8 ns 21350792 +bm_call::direct__Function::get_string 20.2 ns 20.2 ns 34838734 -bm_call::via_function_ptr__Function::get_string 32.4 ns 32.4 ns 21599677 -bm_call::via_function_ptr____Method::get_string 32.6 ns 32.6 ns 21499549 +bm_call::via_function_ptr__Function::get_string 20.1 ns 20.1 ns 34908842 +bm_call::via_function_ptr____Method::get_string 20.2 ns 20.2 ns 34891499 -bm_std::function_calls__Function::get_string 32.6 ns 32.6 ns 21435275 -bm_std::function_calls____Method::get_string 26.5 ns 26.5 ns 26588723 +bm_std::function_calls__Function::get_string 20.3 ns 20.3 ns 34489947 +bm_std::function_calls____Method::get_string 20.5 ns 20.5 ns 34164828 -bm_rtl::function_calls__Function::get_string 32.4 ns 32.4 ns 21569659 -bm_rtl::method_calls______Method::get_string 32.6 ns 32.6 ns 21481163 +bm_rtl::function_calls__Function::get_string 20.1 ns 20.1 ns 34860515 +bm_rtl::method_calls______Method::get_string 20.1 ns 20.1 ns 34509987 -bm_rtl::function__ErasedReturnType::get_string 35.0 ns 35.0 ns 20082606 -bm_rtl::method____ErasedReturnType::get_string 45.6 ns 45.6 ns 15272559 -bm_rtl::method____ErasedTargetType::get_string 32.7 ns 32.7 ns 21388794 -bm_rtl::method____ErasedTargetAndReturnType::get_string 37.5 ns 37.5 ns 18706136 +bm_rtl::function__ErasedReturnType::get_string 32.0 ns 32.0 ns 21715254 +bm_rtl::method____ErasedReturnType::get_string 32.5 ns 32.5 ns 21786883 +bm_rtl::method____ErasedTargetType::get_string 24.6 ns 24.6 ns 28372972 +bm_rtl::method____ErasedTargetAndReturnType::get_string 33.7 ns 33.7 ns 20781704 ----------------------------------- -[2025-11-04 11:31:10] >>> Run 1: workload scale = 5 +[2026-01-19 22:19:40] >>> Run 1: workload scale = 5 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 5 iterations ============================================= -2025-11-04T11:31:10+05:30 +2026-01-19T22:19:40+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 800 MHz CPU s) +Run on (16 X 4865.77 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 0.58, 0.24 +Load Average: 0.98, 0.69, 0.32 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 93.8 ns 93.8 ns 7417031 +bm_call::direct__Function::set_string 105 ns 105 ns 6653489 -bm_call::via_function_ptr__Function::set_string 94.0 ns 94.0 ns 7452008 -bm_call::via_function_ptr____Method::set_string 93.8 ns 93.8 ns 7473913 +bm_call::via_function_ptr__Function::set_string 107 ns 107 ns 6492983 +bm_call::via_function_ptr____Method::set_string 107 ns 107 ns 6535246 -bm_std::function_calls__Function::set_string 94.1 ns 94.1 ns 7465042 -bm_std::function_calls____Method::set_string 94.1 ns 94.1 ns 7427433 +bm_std::function_calls__Function::set_string 107 ns 107 ns 6557447 +bm_std::function_calls____Method::set_string 108 ns 107 ns 6525899 -bm_rtl::function_calls__Function::set_string 93.9 ns 93.9 ns 7491989 -bm_rtl::method_calls______Method::set_string 94.3 ns 94.3 ns 7440296 +bm_rtl::function_calls__Function::set_string 107 ns 107 ns 6529877 +bm_rtl::method_calls______Method::set_string 107 ns 107 ns 6500537 -bm_rtl::function__ErasedReturnType::set_string 95.6 ns 95.6 ns 7316655 -bm_rtl::method____ErasedReturnType::set_string 96.8 ns 96.8 ns 7149766 -bm_rtl::method____ErasedTargetType::set_string 97.4 ns 97.4 ns 7189451 -bm_rtl::method____ErasedTargetAndReturnType::set_string 103 ns 103 ns 6771417 +bm_rtl::function__ErasedReturnType::set_string 109 ns 109 ns 6433512 +bm_rtl::method____ErasedReturnType::set_string 109 ns 109 ns 6441045 +bm_rtl::method____ErasedTargetType::set_string 109 ns 109 ns 6430367 +bm_rtl::method____ErasedTargetAndReturnType::set_string 110 ns 110 ns 6367909 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 115 ns 116 ns 6045433 +bm_call::direct__Function::get_string 141 ns 141 ns 4992850 -bm_call::via_function_ptr__Function::get_string 115 ns 115 ns 6052590 -bm_call::via_function_ptr____Method::get_string 115 ns 115 ns 6090268 +bm_call::via_function_ptr__Function::get_string 141 ns 141 ns 4947770 +bm_call::via_function_ptr____Method::get_string 140 ns 140 ns 5010278 -bm_std::function_calls__Function::get_string 115 ns 115 ns 6074354 -bm_std::function_calls____Method::get_string 115 ns 115 ns 6102339 +bm_std::function_calls__Function::get_string 141 ns 141 ns 4978328 +bm_std::function_calls____Method::get_string 141 ns 141 ns 4892890 -bm_rtl::function_calls__Function::get_string 115 ns 115 ns 6077686 -bm_rtl::method_calls______Method::get_string 115 ns 115 ns 6086147 +bm_rtl::function_calls__Function::get_string 141 ns 141 ns 4969715 +bm_rtl::method_calls______Method::get_string 140 ns 140 ns 4989739 -bm_rtl::function__ErasedReturnType::get_string 125 ns 125 ns 5583022 -bm_rtl::method____ErasedReturnType::get_string 125 ns 125 ns 5606210 -bm_rtl::method____ErasedTargetType::get_string 116 ns 116 ns 6030406 -bm_rtl::method____ErasedTargetAndReturnType::get_string 127 ns 127 ns 5496168 +bm_rtl::function__ErasedReturnType::get_string 150 ns 150 ns 4643950 +bm_rtl::method____ErasedReturnType::get_string 150 ns 150 ns 4635435 +bm_rtl::method____ErasedTargetType::get_string 143 ns 143 ns 4896326 +bm_rtl::method____ErasedTargetAndReturnType::get_string 151 ns 151 ns 4619363 ----------------------------------- -[2025-11-04 11:31:28] >>> Run 2: workload scale = 5 +[2026-01-19 22:19:58] >>> Run 2: workload scale = 5 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 5 iterations ============================================= -2025-11-04T11:31:28+05:30 +2026-01-19T22:19:58+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -476,101 +476,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 0.61, 0.26 +Load Average: 0.98, 0.71, 0.34 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 93.9 ns 93.9 ns 7413892 +bm_call::direct__Function::set_string 103 ns 103 ns 6802745 -bm_call::via_function_ptr__Function::set_string 93.6 ns 93.6 ns 7458233 -bm_call::via_function_ptr____Method::set_string 93.6 ns 93.6 ns 7470144 +bm_call::via_function_ptr__Function::set_string 105 ns 105 ns 6625968 +bm_call::via_function_ptr____Method::set_string 105 ns 105 ns 6695044 -bm_std::function_calls__Function::set_string 93.7 ns 93.7 ns 7426724 -bm_std::function_calls____Method::set_string 94.1 ns 94.1 ns 7412709 +bm_std::function_calls__Function::set_string 105 ns 105 ns 6624223 +bm_std::function_calls____Method::set_string 105 ns 105 ns 6663752 -bm_rtl::function_calls__Function::set_string 93.7 ns 93.7 ns 7485217 -bm_rtl::method_calls______Method::set_string 94.1 ns 94.1 ns 7455729 +bm_rtl::function_calls__Function::set_string 105 ns 105 ns 6681833 +bm_rtl::method_calls______Method::set_string 105 ns 105 ns 6668827 -bm_rtl::function__ErasedReturnType::set_string 95.7 ns 95.7 ns 7312618 -bm_rtl::method____ErasedReturnType::set_string 96.7 ns 96.7 ns 7219262 -bm_rtl::method____ErasedTargetType::set_string 97.6 ns 97.6 ns 7145010 -bm_rtl::method____ErasedTargetAndReturnType::set_string 103 ns 103 ns 6807671 +bm_rtl::function__ErasedReturnType::set_string 107 ns 107 ns 6536747 +bm_rtl::method____ErasedReturnType::set_string 107 ns 107 ns 6504031 +bm_rtl::method____ErasedTargetType::set_string 108 ns 108 ns 6469742 +bm_rtl::method____ErasedTargetAndReturnType::set_string 109 ns 109 ns 6479236 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 116 ns 116 ns 6072780 +bm_call::direct__Function::get_string 123 ns 123 ns 5698362 -bm_call::via_function_ptr__Function::get_string 115 ns 115 ns 6034419 -bm_call::via_function_ptr____Method::get_string 115 ns 115 ns 6080424 +bm_call::via_function_ptr__Function::get_string 123 ns 123 ns 5718997 +bm_call::via_function_ptr____Method::get_string 122 ns 122 ns 5745089 -bm_std::function_calls__Function::get_string 115 ns 115 ns 6047388 -bm_std::function_calls____Method::get_string 115 ns 115 ns 6093462 +bm_std::function_calls__Function::get_string 123 ns 123 ns 5703641 +bm_std::function_calls____Method::get_string 122 ns 122 ns 5715659 -bm_rtl::function_calls__Function::get_string 115 ns 115 ns 6097576 -bm_rtl::method_calls______Method::get_string 115 ns 115 ns 6098871 +bm_rtl::function_calls__Function::get_string 123 ns 123 ns 5702709 +bm_rtl::method_calls______Method::get_string 123 ns 123 ns 5717900 -bm_rtl::function__ErasedReturnType::get_string 125 ns 125 ns 5597537 -bm_rtl::method____ErasedReturnType::get_string 126 ns 126 ns 5581065 -bm_rtl::method____ErasedTargetType::get_string 116 ns 116 ns 6036900 -bm_rtl::method____ErasedTargetAndReturnType::get_string 127 ns 127 ns 5516757 +bm_rtl::function__ErasedReturnType::get_string 131 ns 131 ns 5383228 +bm_rtl::method____ErasedReturnType::get_string 130 ns 130 ns 5398546 +bm_rtl::method____ErasedTargetType::get_string 125 ns 125 ns 5610784 +bm_rtl::method____ErasedTargetAndReturnType::get_string 132 ns 132 ns 5317235 ----------------------------------- -[2025-11-04 11:31:46] >>> Run 3: workload scale = 5 +[2026-01-19 22:20:16] >>> Run 3: workload scale = 5 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 5 iterations ============================================= -2025-11-04T11:31:46+05:30 +2026-01-19T22:20:16+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 800 MHz CPU s) +Run on (16 X 1814.12 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 0.63, 0.27 +Load Average: 0.99, 0.73, 0.35 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 94.4 ns 94.4 ns 7268124 +bm_call::direct__Function::set_string 103 ns 103 ns 6759777 -bm_call::via_function_ptr__Function::set_string 94.2 ns 94.2 ns 7461840 -bm_call::via_function_ptr____Method::set_string 94.2 ns 94.2 ns 7427933 +bm_call::via_function_ptr__Function::set_string 105 ns 105 ns 6599680 +bm_call::via_function_ptr____Method::set_string 105 ns 105 ns 6637960 -bm_std::function_calls__Function::set_string 94.5 ns 94.5 ns 7422218 -bm_std::function_calls____Method::set_string 94.6 ns 94.6 ns 7430982 +bm_std::function_calls__Function::set_string 105 ns 105 ns 6634870 +bm_std::function_calls____Method::set_string 105 ns 105 ns 6629614 -bm_rtl::function_calls__Function::set_string 94.5 ns 94.5 ns 7430754 -bm_rtl::method_calls______Method::set_string 94.7 ns 94.8 ns 7407535 +bm_rtl::function_calls__Function::set_string 105 ns 105 ns 6700534 +bm_rtl::method_calls______Method::set_string 105 ns 105 ns 6641565 -bm_rtl::function__ErasedReturnType::set_string 96.1 ns 96.1 ns 7196656 -bm_rtl::method____ErasedReturnType::set_string 96.9 ns 96.9 ns 7211863 -bm_rtl::method____ErasedTargetType::set_string 97.0 ns 97.0 ns 7195465 -bm_rtl::method____ErasedTargetAndReturnType::set_string 102 ns 102 ns 6818975 +bm_rtl::function__ErasedReturnType::set_string 107 ns 107 ns 6489816 +bm_rtl::method____ErasedReturnType::set_string 107 ns 107 ns 6457036 +bm_rtl::method____ErasedTargetType::set_string 108 ns 108 ns 6480403 +bm_rtl::method____ErasedTargetAndReturnType::set_string 109 ns 109 ns 6477196 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 115 ns 115 ns 6065805 +bm_call::direct__Function::get_string 123 ns 123 ns 5671951 -bm_call::via_function_ptr__Function::get_string 115 ns 115 ns 6096645 -bm_call::via_function_ptr____Method::get_string 115 ns 115 ns 6071541 +bm_call::via_function_ptr__Function::get_string 123 ns 123 ns 5695007 +bm_call::via_function_ptr____Method::get_string 123 ns 123 ns 5701825 -bm_std::function_calls__Function::get_string 116 ns 116 ns 6047175 -bm_std::function_calls____Method::get_string 115 ns 115 ns 6060394 +bm_std::function_calls__Function::get_string 123 ns 123 ns 5623063 +bm_std::function_calls____Method::get_string 122 ns 122 ns 5746720 -bm_rtl::function_calls__Function::get_string 115 ns 115 ns 6075944 -bm_rtl::method_calls______Method::get_string 115 ns 115 ns 6079330 +bm_rtl::function_calls__Function::get_string 123 ns 123 ns 5685952 +bm_rtl::method_calls______Method::get_string 122 ns 122 ns 5737821 -bm_rtl::function__ErasedReturnType::get_string 125 ns 125 ns 5584045 -bm_rtl::method____ErasedReturnType::get_string 126 ns 126 ns 5557081 -bm_rtl::method____ErasedTargetType::get_string 117 ns 117 ns 5989672 -bm_rtl::method____ErasedTargetAndReturnType::get_string 128 ns 128 ns 5499308 +bm_rtl::function__ErasedReturnType::get_string 130 ns 130 ns 5363587 +bm_rtl::method____ErasedReturnType::get_string 130 ns 130 ns 5405976 +bm_rtl::method____ErasedTargetType::get_string 125 ns 125 ns 5623858 +bm_rtl::method____ErasedTargetAndReturnType::get_string 132 ns 132 ns 5294497 ----------------------------------- -[2025-11-04 11:32:04] >>> Run 1: workload scale = 10 +[2026-01-19 22:20:35] >>> Run 1: workload scale = 10 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 10 iterations ============================================= -2025-11-04T11:32:04+05:30 +2026-01-19T22:20:35+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -578,152 +578,152 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.65, 0.29 +Load Average: 0.99, 0.75, 0.37 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 161 ns 161 ns 4332878 +bm_call::direct__Function::set_string 180 ns 180 ns 3892288 -bm_call::via_function_ptr__Function::set_string 161 ns 161 ns 4416633 -bm_call::via_function_ptr____Method::set_string 160 ns 160 ns 4399361 +bm_call::via_function_ptr__Function::set_string 175 ns 175 ns 4013942 +bm_call::via_function_ptr____Method::set_string 175 ns 175 ns 4038326 -bm_std::function_calls__Function::set_string 161 ns 161 ns 4305144 -bm_std::function_calls____Method::set_string 161 ns 161 ns 4342427 +bm_std::function_calls__Function::set_string 175 ns 175 ns 4011236 +bm_std::function_calls____Method::set_string 176 ns 176 ns 3969974 -bm_rtl::function_calls__Function::set_string 161 ns 161 ns 4357679 -bm_rtl::method_calls______Method::set_string 160 ns 160 ns 4336485 +bm_rtl::function_calls__Function::set_string 175 ns 175 ns 4008955 +bm_rtl::method_calls______Method::set_string 175 ns 175 ns 4005545 -bm_rtl::function__ErasedReturnType::set_string 164 ns 164 ns 4290751 -bm_rtl::method____ErasedReturnType::set_string 164 ns 164 ns 4305488 -bm_rtl::method____ErasedTargetType::set_string 165 ns 165 ns 4271135 -bm_rtl::method____ErasedTargetAndReturnType::set_string 171 ns 171 ns 4087737 +bm_rtl::function__ErasedReturnType::set_string 178 ns 178 ns 3913334 +bm_rtl::method____ErasedReturnType::set_string 178 ns 178 ns 3957340 +bm_rtl::method____ErasedTargetType::set_string 178 ns 178 ns 3958988 +bm_rtl::method____ErasedTargetAndReturnType::set_string 179 ns 179 ns 3910029 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 209 ns 209 ns 3342955 +bm_call::direct__Function::get_string 236 ns 236 ns 2973260 -bm_call::via_function_ptr__Function::get_string 210 ns 210 ns 3341236 -bm_call::via_function_ptr____Method::get_string 209 ns 209 ns 3340519 +bm_call::via_function_ptr__Function::get_string 236 ns 236 ns 2986989 +bm_call::via_function_ptr____Method::get_string 235 ns 235 ns 2980300 -bm_std::function_calls__Function::get_string 209 ns 209 ns 3329193 -bm_std::function_calls____Method::get_string 209 ns 209 ns 3334552 +bm_std::function_calls__Function::get_string 236 ns 235 ns 2959537 +bm_std::function_calls____Method::get_string 236 ns 236 ns 2952611 -bm_rtl::function_calls__Function::get_string 210 ns 210 ns 3341471 -bm_rtl::method_calls______Method::get_string 210 ns 210 ns 3317212 +bm_rtl::function_calls__Function::get_string 235 ns 235 ns 2982781 +bm_rtl::method_calls______Method::get_string 236 ns 236 ns 2962352 -bm_rtl::function__ErasedReturnType::get_string 217 ns 217 ns 3257317 -bm_rtl::method____ErasedReturnType::get_string 218 ns 218 ns 3238960 -bm_rtl::method____ErasedTargetType::get_string 212 ns 212 ns 3304550 -bm_rtl::method____ErasedTargetAndReturnType::get_string 218 ns 218 ns 3228561 +bm_rtl::function__ErasedReturnType::get_string 241 ns 241 ns 2897516 +bm_rtl::method____ErasedReturnType::get_string 242 ns 242 ns 2911112 +bm_rtl::method____ErasedTargetType::get_string 239 ns 240 ns 2930612 +bm_rtl::method____ErasedTargetAndReturnType::get_string 242 ns 242 ns 2885077 ----------------------------------- -[2025-11-04 11:32:24] >>> Run 2: workload scale = 10 +[2026-01-19 22:20:55] >>> Run 2: workload scale = 10 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 10 iterations ============================================= -2025-11-04T11:32:24+05:30 +2026-01-19T22:20:55+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2413.91 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.67, 0.30 +Load Average: 1.00, 0.77, 0.38 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 163 ns 163 ns 4302963 +bm_call::direct__Function::set_string 165 ns 165 ns 4275197 -bm_call::via_function_ptr__Function::set_string 164 ns 164 ns 4290635 -bm_call::via_function_ptr____Method::set_string 164 ns 164 ns 4255706 +bm_call::via_function_ptr__Function::set_string 168 ns 168 ns 4170135 +bm_call::via_function_ptr____Method::set_string 167 ns 167 ns 4163825 -bm_std::function_calls__Function::set_string 163 ns 163 ns 4297600 -bm_std::function_calls____Method::set_string 163 ns 163 ns 4369051 +bm_std::function_calls__Function::set_string 169 ns 169 ns 4159852 +bm_std::function_calls____Method::set_string 170 ns 170 ns 4124142 -bm_rtl::function_calls__Function::set_string 163 ns 163 ns 4271991 -bm_rtl::method_calls______Method::set_string 163 ns 163 ns 4317493 +bm_rtl::function_calls__Function::set_string 169 ns 169 ns 4126732 +bm_rtl::method_calls______Method::set_string 169 ns 169 ns 4134774 -bm_rtl::function__ErasedReturnType::set_string 165 ns 165 ns 4257845 -bm_rtl::method____ErasedReturnType::set_string 164 ns 164 ns 4253764 -bm_rtl::method____ErasedTargetType::set_string 167 ns 167 ns 4215960 -bm_rtl::method____ErasedTargetAndReturnType::set_string 173 ns 173 ns 4066978 +bm_rtl::function__ErasedReturnType::set_string 172 ns 172 ns 4038085 +bm_rtl::method____ErasedReturnType::set_string 171 ns 171 ns 4105946 +bm_rtl::method____ErasedTargetType::set_string 171 ns 171 ns 4105870 +bm_rtl::method____ErasedTargetAndReturnType::set_string 178 ns 178 ns 3951279 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 211 ns 211 ns 3342799 +bm_call::direct__Function::get_string 207 ns 207 ns 3403062 -bm_call::via_function_ptr__Function::get_string 210 ns 210 ns 3344684 -bm_call::via_function_ptr____Method::get_string 212 ns 212 ns 3308560 +bm_call::via_function_ptr__Function::get_string 206 ns 206 ns 3379512 +bm_call::via_function_ptr____Method::get_string 206 ns 206 ns 3363220 -bm_std::function_calls__Function::get_string 211 ns 211 ns 3330519 -bm_std::function_calls____Method::get_string 211 ns 211 ns 3300133 +bm_std::function_calls__Function::get_string 206 ns 206 ns 3434973 +bm_std::function_calls____Method::get_string 205 ns 205 ns 3398931 -bm_rtl::function_calls__Function::get_string 211 ns 211 ns 3302953 -bm_rtl::method_calls______Method::get_string 212 ns 212 ns 3298514 +bm_rtl::function_calls__Function::get_string 206 ns 206 ns 3390234 +bm_rtl::method_calls______Method::get_string 205 ns 205 ns 3428973 -bm_rtl::function__ErasedReturnType::get_string 218 ns 218 ns 3215137 -bm_rtl::method____ErasedReturnType::get_string 219 ns 219 ns 3201579 -bm_rtl::method____ErasedTargetType::get_string 214 ns 214 ns 3298595 -bm_rtl::method____ErasedTargetAndReturnType::get_string 219 ns 219 ns 3203336 +bm_rtl::function__ErasedReturnType::get_string 212 ns 212 ns 3290226 +bm_rtl::method____ErasedReturnType::get_string 213 ns 213 ns 3308638 +bm_rtl::method____ErasedTargetType::get_string 213 ns 213 ns 3278298 +bm_rtl::method____ErasedTargetAndReturnType::get_string 213 ns 213 ns 3265716 ----------------------------------- -[2025-11-04 11:32:44] >>> Run 3: workload scale = 10 +[2026-01-19 22:21:15] >>> Run 3: workload scale = 10 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 10 iterations ============================================= -2025-11-04T11:32:44+05:30 +2026-01-19T22:21:15+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4877.87 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.70, 0.32 +Load Average: 1.00, 0.78, 0.40 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 162 ns 162 ns 4338121 +bm_call::direct__Function::set_string 165 ns 165 ns 4267506 -bm_call::via_function_ptr__Function::set_string 163 ns 163 ns 4377872 -bm_call::via_function_ptr____Method::set_string 161 ns 161 ns 4352982 +bm_call::via_function_ptr__Function::set_string 160 ns 160 ns 4395709 +bm_call::via_function_ptr____Method::set_string 159 ns 159 ns 4430252 -bm_std::function_calls__Function::set_string 161 ns 161 ns 4421243 -bm_std::function_calls____Method::set_string 161 ns 161 ns 4359250 +bm_std::function_calls__Function::set_string 159 ns 159 ns 4404565 +bm_std::function_calls____Method::set_string 160 ns 160 ns 4313674 -bm_rtl::function_calls__Function::set_string 161 ns 161 ns 4315918 -bm_rtl::method_calls______Method::set_string 161 ns 161 ns 4328071 +bm_rtl::function_calls__Function::set_string 160 ns 160 ns 4373147 +bm_rtl::method_calls______Method::set_string 159 ns 159 ns 4369703 -bm_rtl::function__ErasedReturnType::set_string 164 ns 164 ns 4284932 -bm_rtl::method____ErasedReturnType::set_string 164 ns 164 ns 4272614 -bm_rtl::method____ErasedTargetType::set_string 165 ns 165 ns 4233649 -bm_rtl::method____ErasedTargetAndReturnType::set_string 171 ns 171 ns 4102406 +bm_rtl::function__ErasedReturnType::set_string 161 ns 161 ns 4305630 +bm_rtl::method____ErasedReturnType::set_string 162 ns 162 ns 4292450 +bm_rtl::method____ErasedTargetType::set_string 161 ns 161 ns 4356887 +bm_rtl::method____ErasedTargetAndReturnType::set_string 168 ns 168 ns 4182174 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 209 ns 209 ns 3346131 +bm_call::direct__Function::get_string 204 ns 204 ns 3454724 -bm_call::via_function_ptr__Function::get_string 210 ns 210 ns 3324956 -bm_call::via_function_ptr____Method::get_string 211 ns 211 ns 3317701 +bm_call::via_function_ptr__Function::get_string 204 ns 204 ns 3439998 +bm_call::via_function_ptr____Method::get_string 205 ns 205 ns 3428085 -bm_std::function_calls__Function::get_string 210 ns 210 ns 3332691 -bm_std::function_calls____Method::get_string 210 ns 210 ns 3329162 +bm_std::function_calls__Function::get_string 204 ns 204 ns 3444872 +bm_std::function_calls____Method::get_string 205 ns 205 ns 3434997 -bm_rtl::function_calls__Function::get_string 209 ns 209 ns 3294911 -bm_rtl::method_calls______Method::get_string 211 ns 211 ns 3331679 +bm_rtl::function_calls__Function::get_string 204 ns 204 ns 3420037 +bm_rtl::method_calls______Method::get_string 204 ns 204 ns 3419836 -bm_rtl::function__ErasedReturnType::get_string 215 ns 216 ns 3244227 -bm_rtl::method____ErasedReturnType::get_string 216 ns 216 ns 3251398 -bm_rtl::method____ErasedTargetType::get_string 210 ns 210 ns 3351688 -bm_rtl::method____ErasedTargetAndReturnType::get_string 216 ns 216 ns 3247038 +bm_rtl::function__ErasedReturnType::get_string 213 ns 213 ns 3283998 +bm_rtl::method____ErasedReturnType::get_string 213 ns 213 ns 3295983 +bm_rtl::method____ErasedTargetType::get_string 211 ns 211 ns 3308046 +bm_rtl::method____ErasedTargetAndReturnType::get_string 214 ns 214 ns 3280155 ----------------------------------- -[2025-11-04 11:33:04] >>> Run 1: workload scale = 15 +[2026-01-19 22:21:35] >>> Run 1: workload scale = 15 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 15 iterations ============================================= -2025-11-04T11:33:04+05:30 +2026-01-19T22:21:35+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -731,101 +731,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.72, 0.33 +Load Average: 1.00, 0.80, 0.41 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 194 ns 194 ns 3624354 +bm_call::direct__Function::set_string 213 ns 213 ns 3278456 -bm_call::via_function_ptr__Function::set_string 194 ns 194 ns 3627036 -bm_call::via_function_ptr____Method::set_string 195 ns 195 ns 3601256 +bm_call::via_function_ptr__Function::set_string 209 ns 209 ns 3352560 +bm_call::via_function_ptr____Method::set_string 209 ns 209 ns 3360691 -bm_std::function_calls__Function::set_string 194 ns 194 ns 3589830 -bm_std::function_calls____Method::set_string 194 ns 194 ns 3637376 +bm_std::function_calls__Function::set_string 209 ns 209 ns 3361073 +bm_std::function_calls____Method::set_string 210 ns 210 ns 3318972 -bm_rtl::function_calls__Function::set_string 194 ns 194 ns 3638687 -bm_rtl::method_calls______Method::set_string 195 ns 195 ns 3599993 +bm_rtl::function_calls__Function::set_string 209 ns 209 ns 3369433 +bm_rtl::method_calls______Method::set_string 209 ns 209 ns 3354692 -bm_rtl::function__ErasedReturnType::set_string 196 ns 196 ns 3578184 -bm_rtl::method____ErasedReturnType::set_string 197 ns 197 ns 3547623 -bm_rtl::method____ErasedTargetType::set_string 198 ns 198 ns 3539370 -bm_rtl::method____ErasedTargetAndReturnType::set_string 203 ns 203 ns 3430347 +bm_rtl::function__ErasedReturnType::set_string 211 ns 211 ns 3314566 +bm_rtl::method____ErasedReturnType::set_string 217 ns 217 ns 3200487 +bm_rtl::method____ErasedTargetType::set_string 210 ns 210 ns 3339407 +bm_rtl::method____ErasedTargetAndReturnType::set_string 213 ns 213 ns 3272485 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 271 ns 271 ns 2477136 +bm_call::direct__Function::get_string 290 ns 290 ns 2399152 -bm_call::via_function_ptr__Function::get_string 254 ns 254 ns 2745060 -bm_call::via_function_ptr____Method::get_string 253 ns 253 ns 2760175 +bm_call::via_function_ptr__Function::get_string 292 ns 292 ns 2391389 +bm_call::via_function_ptr____Method::get_string 294 ns 294 ns 2387165 -bm_std::function_calls__Function::get_string 253 ns 253 ns 2742774 -bm_std::function_calls____Method::get_string 253 ns 253 ns 2748295 +bm_std::function_calls__Function::get_string 292 ns 292 ns 2385012 +bm_std::function_calls____Method::get_string 293 ns 293 ns 2370217 -bm_rtl::function_calls__Function::get_string 252 ns 252 ns 2791858 -bm_rtl::method_calls______Method::get_string 252 ns 252 ns 2745882 +bm_rtl::function_calls__Function::get_string 290 ns 290 ns 2389109 +bm_rtl::method_calls______Method::get_string 291 ns 291 ns 2413141 -bm_rtl::function__ErasedReturnType::get_string 258 ns 258 ns 2714931 -bm_rtl::method____ErasedReturnType::get_string 259 ns 259 ns 2686641 -bm_rtl::method____ErasedTargetType::get_string 252 ns 252 ns 2771666 -bm_rtl::method____ErasedTargetAndReturnType::get_string 260 ns 260 ns 2687541 +bm_rtl::function__ErasedReturnType::get_string 293 ns 293 ns 2376124 +bm_rtl::method____ErasedReturnType::get_string 294 ns 294 ns 2372537 +bm_rtl::method____ErasedTargetType::get_string 296 ns 296 ns 2363057 +bm_rtl::method____ErasedTargetAndReturnType::get_string 295 ns 295 ns 2377778 ----------------------------------- -[2025-11-04 11:33:25] >>> Run 2: workload scale = 15 +[2026-01-19 22:21:57] >>> Run 2: workload scale = 15 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 15 iterations ============================================= -2025-11-04T11:33:25+05:30 +2026-01-19T22:21:57+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 799.812 MHz CPU s) +Run on (16 X 801.32 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.74, 0.35 +Load Average: 1.00, 0.81, 0.42 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 211 ns 211 ns 3320178 +bm_call::direct__Function::set_string 212 ns 212 ns 3309102 -bm_call::via_function_ptr__Function::set_string 212 ns 212 ns 3321160 -bm_call::via_function_ptr____Method::set_string 211 ns 211 ns 3335082 +bm_call::via_function_ptr__Function::set_string 207 ns 207 ns 3394006 +bm_call::via_function_ptr____Method::set_string 207 ns 207 ns 3370944 -bm_std::function_calls__Function::set_string 212 ns 212 ns 3308055 -bm_std::function_calls____Method::set_string 211 ns 211 ns 3304941 +bm_std::function_calls__Function::set_string 207 ns 207 ns 3376717 +bm_std::function_calls____Method::set_string 207 ns 207 ns 3373440 -bm_rtl::function_calls__Function::set_string 212 ns 212 ns 3304781 -bm_rtl::method_calls______Method::set_string 213 ns 213 ns 3303226 +bm_rtl::function_calls__Function::set_string 207 ns 207 ns 3397337 +bm_rtl::method_calls______Method::set_string 207 ns 207 ns 3366295 -bm_rtl::function__ErasedReturnType::set_string 214 ns 214 ns 3258122 -bm_rtl::method____ErasedReturnType::set_string 214 ns 214 ns 3264878 -bm_rtl::method____ErasedTargetType::set_string 216 ns 216 ns 3251560 -bm_rtl::method____ErasedTargetAndReturnType::set_string 218 ns 218 ns 3207293 +bm_rtl::function__ErasedReturnType::set_string 209 ns 209 ns 3341976 +bm_rtl::method____ErasedReturnType::set_string 215 ns 215 ns 3250934 +bm_rtl::method____ErasedTargetType::set_string 209 ns 209 ns 3356043 +bm_rtl::method____ErasedTargetAndReturnType::set_string 213 ns 213 ns 3302810 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 293 ns 293 ns 2384492 +bm_call::direct__Function::get_string 290 ns 290 ns 2434486 -bm_call::via_function_ptr__Function::get_string 293 ns 293 ns 2407150 -bm_call::via_function_ptr____Method::get_string 294 ns 294 ns 2380693 +bm_call::via_function_ptr__Function::get_string 290 ns 290 ns 2418544 +bm_call::via_function_ptr____Method::get_string 292 ns 292 ns 2391400 -bm_std::function_calls__Function::get_string 295 ns 295 ns 2398510 -bm_std::function_calls____Method::get_string 292 ns 292 ns 2407469 +bm_std::function_calls__Function::get_string 290 ns 290 ns 2419226 +bm_std::function_calls____Method::get_string 292 ns 292 ns 2384728 -bm_rtl::function_calls__Function::get_string 293 ns 293 ns 2396622 -bm_rtl::method_calls______Method::get_string 292 ns 292 ns 2398263 +bm_rtl::function_calls__Function::get_string 289 ns 289 ns 2421073 +bm_rtl::method_calls______Method::get_string 289 ns 289 ns 2407117 -bm_rtl::function__ErasedReturnType::get_string 297 ns 297 ns 2353980 -bm_rtl::method____ErasedReturnType::get_string 299 ns 299 ns 2337886 -bm_rtl::method____ErasedTargetType::get_string 295 ns 295 ns 2380052 -bm_rtl::method____ErasedTargetAndReturnType::get_string 302 ns 302 ns 2319651 +bm_rtl::function__ErasedReturnType::get_string 291 ns 291 ns 2407608 +bm_rtl::method____ErasedReturnType::get_string 292 ns 292 ns 2397277 +bm_rtl::method____ErasedTargetType::get_string 297 ns 297 ns 2375795 +bm_rtl::method____ErasedTargetAndReturnType::get_string 293 ns 293 ns 2389315 ----------------------------------- -[2025-11-04 11:33:46] >>> Run 3: workload scale = 15 +[2026-01-19 22:22:18] >>> Run 3: workload scale = 15 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 15 iterations ============================================= -2025-11-04T11:33:46+05:30 +2026-01-19T22:22:18+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -833,50 +833,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.06, 0.77, 0.37 +Load Average: 1.00, 0.83, 0.44 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 194 ns 194 ns 3620973 +bm_call::direct__Function::set_string 213 ns 213 ns 3296227 -bm_call::via_function_ptr__Function::set_string 193 ns 193 ns 3638599 -bm_call::via_function_ptr____Method::set_string 193 ns 193 ns 3638008 +bm_call::via_function_ptr__Function::set_string 214 ns 214 ns 3263923 +bm_call::via_function_ptr____Method::set_string 205 ns 205 ns 3257153 -bm_std::function_calls__Function::set_string 194 ns 194 ns 3628619 -bm_std::function_calls____Method::set_string 194 ns 194 ns 3577027 +bm_std::function_calls__Function::set_string 197 ns 197 ns 3565329 +bm_std::function_calls____Method::set_string 196 ns 196 ns 3566944 -bm_rtl::function_calls__Function::set_string 194 ns 194 ns 3633217 -bm_rtl::method_calls______Method::set_string 195 ns 195 ns 3607754 +bm_rtl::function_calls__Function::set_string 197 ns 197 ns 3533127 +bm_rtl::method_calls______Method::set_string 198 ns 198 ns 3543068 -bm_rtl::function__ErasedReturnType::set_string 194 ns 194 ns 3603029 -bm_rtl::method____ErasedReturnType::set_string 196 ns 196 ns 3592022 -bm_rtl::method____ErasedTargetType::set_string 197 ns 197 ns 3535375 -bm_rtl::method____ErasedTargetAndReturnType::set_string 203 ns 203 ns 3455803 +bm_rtl::function__ErasedReturnType::set_string 200 ns 200 ns 3486313 +bm_rtl::method____ErasedReturnType::set_string 199 ns 199 ns 3506394 +bm_rtl::method____ErasedTargetType::set_string 201 ns 201 ns 3461289 +bm_rtl::method____ErasedTargetAndReturnType::set_string 207 ns 207 ns 3387381 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 251 ns 251 ns 2770899 +bm_call::direct__Function::get_string 255 ns 255 ns 2755617 -bm_call::via_function_ptr__Function::get_string 252 ns 252 ns 2787847 -bm_call::via_function_ptr____Method::get_string 255 ns 255 ns 2794390 +bm_call::via_function_ptr__Function::get_string 256 ns 256 ns 2766715 +bm_call::via_function_ptr____Method::get_string 255 ns 255 ns 2753165 -bm_std::function_calls__Function::get_string 252 ns 252 ns 2783053 -bm_std::function_calls____Method::get_string 254 ns 254 ns 2762588 +bm_std::function_calls__Function::get_string 254 ns 254 ns 2746618 +bm_std::function_calls____Method::get_string 254 ns 254 ns 2759317 -bm_rtl::function_calls__Function::get_string 251 ns 251 ns 2750173 -bm_rtl::method_calls______Method::get_string 254 ns 254 ns 2780142 +bm_rtl::function_calls__Function::get_string 254 ns 254 ns 2751392 +bm_rtl::method_calls______Method::get_string 255 ns 255 ns 2749046 -bm_rtl::function__ErasedReturnType::get_string 258 ns 258 ns 2713804 -bm_rtl::method____ErasedReturnType::get_string 259 ns 259 ns 2681868 -bm_rtl::method____ErasedTargetType::get_string 254 ns 254 ns 2774394 -bm_rtl::method____ErasedTargetAndReturnType::get_string 260 ns 260 ns 2703368 +bm_rtl::function__ErasedReturnType::get_string 259 ns 259 ns 2716598 +bm_rtl::method____ErasedReturnType::get_string 260 ns 260 ns 2686400 +bm_rtl::method____ErasedTargetType::get_string 260 ns 260 ns 2691016 +bm_rtl::method____ErasedTargetAndReturnType::get_string 261 ns 261 ns 2691710 ----------------------------------- -[2025-11-04 11:34:07] >>> Run 1: workload scale = 20 +[2026-01-19 22:22:39] >>> Run 1: workload scale = 20 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 20 iterations ============================================= -2025-11-04T11:34:07+05:30 +2026-01-19T22:22:39+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -884,50 +884,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 0.79, 0.38 +Load Average: 1.00, 0.84, 0.45 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 306 ns 306 ns 2290492 +bm_call::direct__Function::set_string 327 ns 327 ns 2130827 -bm_call::via_function_ptr__Function::set_string 311 ns 311 ns 2241247 -bm_call::via_function_ptr____Method::set_string 313 ns 313 ns 2234098 +bm_call::via_function_ptr__Function::set_string 297 ns 297 ns 2358942 +bm_call::via_function_ptr____Method::set_string 297 ns 297 ns 2362573 -bm_std::function_calls__Function::set_string 312 ns 312 ns 2234676 -bm_std::function_calls____Method::set_string 312 ns 312 ns 2241612 +bm_std::function_calls__Function::set_string 297 ns 297 ns 2350215 +bm_std::function_calls____Method::set_string 297 ns 297 ns 2358479 -bm_rtl::function_calls__Function::set_string 312 ns 312 ns 2253856 -bm_rtl::method_calls______Method::set_string 313 ns 313 ns 2228407 +bm_rtl::function_calls__Function::set_string 297 ns 297 ns 2357670 +bm_rtl::method_calls______Method::set_string 298 ns 298 ns 2345741 -bm_rtl::function__ErasedReturnType::set_string 308 ns 308 ns 2261970 -bm_rtl::method____ErasedReturnType::set_string 312 ns 312 ns 2245957 -bm_rtl::method____ErasedTargetType::set_string 311 ns 311 ns 2213517 -bm_rtl::method____ErasedTargetAndReturnType::set_string 314 ns 314 ns 2241483 +bm_rtl::function__ErasedReturnType::set_string 302 ns 302 ns 2338843 +bm_rtl::method____ErasedReturnType::set_string 301 ns 301 ns 2320729 +bm_rtl::method____ErasedTargetType::set_string 302 ns 302 ns 2324269 +bm_rtl::method____ErasedTargetAndReturnType::set_string 303 ns 303 ns 2309848 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 443 ns 443 ns 1581839 +bm_call::direct__Function::get_string 423 ns 423 ns 1656887 -bm_call::via_function_ptr__Function::get_string 451 ns 451 ns 1548794 -bm_call::via_function_ptr____Method::get_string 452 ns 452 ns 1550466 +bm_call::via_function_ptr__Function::get_string 421 ns 421 ns 1661981 +bm_call::via_function_ptr____Method::get_string 422 ns 422 ns 1656660 -bm_std::function_calls__Function::get_string 452 ns 452 ns 1550969 -bm_std::function_calls____Method::get_string 447 ns 447 ns 1563335 +bm_std::function_calls__Function::get_string 422 ns 422 ns 1657954 +bm_std::function_calls____Method::get_string 423 ns 423 ns 1656490 -bm_rtl::function_calls__Function::get_string 452 ns 452 ns 1551478 -bm_rtl::method_calls______Method::get_string 452 ns 452 ns 1548665 +bm_rtl::function_calls__Function::get_string 421 ns 420 ns 1661494 +bm_rtl::method_calls______Method::get_string 421 ns 421 ns 1661180 -bm_rtl::function__ErasedReturnType::get_string 459 ns 459 ns 1528761 -bm_rtl::method____ErasedReturnType::get_string 459 ns 459 ns 1522846 -bm_rtl::method____ErasedTargetType::get_string 449 ns 449 ns 1559946 -bm_rtl::method____ErasedTargetAndReturnType::get_string 468 ns 468 ns 1496384 +bm_rtl::function__ErasedReturnType::get_string 431 ns 431 ns 1619090 +bm_rtl::method____ErasedReturnType::get_string 431 ns 431 ns 1620223 +bm_rtl::method____ErasedTargetType::get_string 431 ns 431 ns 1619311 +bm_rtl::method____ErasedTargetAndReturnType::get_string 432 ns 432 ns 1616884 ----------------------------------- -[2025-11-04 11:34:32] >>> Run 2: workload scale = 20 +[2026-01-19 22:23:03] >>> Run 2: workload scale = 20 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 20 iterations ============================================= -2025-11-04T11:34:32+05:30 +2026-01-19T22:23:03+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -935,101 +935,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.03, 0.80, 0.40 +Load Average: 1.00, 0.85, 0.47 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 272 ns 272 ns 2558705 +bm_call::direct__Function::set_string 328 ns 328 ns 2133046 -bm_call::via_function_ptr__Function::set_string 272 ns 272 ns 2566816 -bm_call::via_function_ptr____Method::set_string 273 ns 273 ns 2560637 +bm_call::via_function_ptr__Function::set_string 297 ns 297 ns 2336742 +bm_call::via_function_ptr____Method::set_string 297 ns 297 ns 2330893 -bm_std::function_calls__Function::set_string 270 ns 270 ns 2573221 -bm_std::function_calls____Method::set_string 273 ns 273 ns 2573250 +bm_std::function_calls__Function::set_string 299 ns 299 ns 2338388 +bm_std::function_calls____Method::set_string 299 ns 299 ns 2361470 -bm_rtl::function_calls__Function::set_string 272 ns 272 ns 2575772 -bm_rtl::method_calls______Method::set_string 274 ns 274 ns 2567684 +bm_rtl::function_calls__Function::set_string 299 ns 299 ns 2355328 +bm_rtl::method_calls______Method::set_string 299 ns 299 ns 2354178 -bm_rtl::function__ErasedReturnType::set_string 276 ns 276 ns 2525378 -bm_rtl::method____ErasedReturnType::set_string 277 ns 277 ns 2554199 -bm_rtl::method____ErasedTargetType::set_string 275 ns 275 ns 2561448 -bm_rtl::method____ErasedTargetAndReturnType::set_string 282 ns 282 ns 2483219 +bm_rtl::function__ErasedReturnType::set_string 309 ns 309 ns 2248700 +bm_rtl::method____ErasedReturnType::set_string 307 ns 307 ns 2263835 +bm_rtl::method____ErasedTargetType::set_string 305 ns 305 ns 2290845 +bm_rtl::method____ErasedTargetAndReturnType::set_string 309 ns 309 ns 2270160 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 381 ns 381 ns 1842934 +bm_call::direct__Function::get_string 420 ns 420 ns 1667713 -bm_call::via_function_ptr__Function::get_string 386 ns 386 ns 1819888 -bm_call::via_function_ptr____Method::get_string 384 ns 384 ns 1818988 +bm_call::via_function_ptr__Function::get_string 419 ns 419 ns 1665420 +bm_call::via_function_ptr____Method::get_string 420 ns 420 ns 1661441 -bm_std::function_calls__Function::get_string 385 ns 385 ns 1814239 -bm_std::function_calls____Method::get_string 386 ns 386 ns 1810637 +bm_std::function_calls__Function::get_string 420 ns 420 ns 1665206 +bm_std::function_calls____Method::get_string 423 ns 423 ns 1659447 -bm_rtl::function_calls__Function::get_string 385 ns 385 ns 1821229 -bm_rtl::method_calls______Method::get_string 387 ns 387 ns 1815740 +bm_rtl::function_calls__Function::get_string 419 ns 419 ns 1666035 +bm_rtl::method_calls______Method::get_string 419 ns 419 ns 1667963 -bm_rtl::function__ErasedReturnType::get_string 401 ns 401 ns 1742383 -bm_rtl::method____ErasedReturnType::get_string 402 ns 402 ns 1744796 -bm_rtl::method____ErasedTargetType::get_string 391 ns 391 ns 1786914 -bm_rtl::method____ErasedTargetAndReturnType::get_string 402 ns 403 ns 1734389 +bm_rtl::function__ErasedReturnType::get_string 431 ns 431 ns 1622118 +bm_rtl::method____ErasedReturnType::get_string 433 ns 432 ns 1624592 +bm_rtl::method____ErasedTargetType::get_string 431 ns 430 ns 1630012 +bm_rtl::method____ErasedTargetAndReturnType::get_string 433 ns 433 ns 1616972 ----------------------------------- -[2025-11-04 11:34:55] >>> Run 3: workload scale = 20 +[2026-01-19 22:23:28] >>> Run 3: workload scale = 20 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 20 iterations ============================================= -2025-11-04T11:34:55+05:30 +2026-01-19T22:23:28+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1003.07 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 0.82, 0.42 +Load Average: 1.00, 0.87, 0.48 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 273 ns 273 ns 2555885 +bm_call::direct__Function::set_string 290 ns 290 ns 2424105 -bm_call::via_function_ptr__Function::set_string 273 ns 273 ns 2520891 -bm_call::via_function_ptr____Method::set_string 273 ns 273 ns 2549459 +bm_call::via_function_ptr__Function::set_string 268 ns 268 ns 2627333 +bm_call::via_function_ptr____Method::set_string 266 ns 266 ns 2656460 -bm_std::function_calls__Function::set_string 273 ns 273 ns 2576378 -bm_std::function_calls____Method::set_string 273 ns 273 ns 2571194 +bm_std::function_calls__Function::set_string 264 ns 264 ns 2608421 +bm_std::function_calls____Method::set_string 268 ns 268 ns 2624303 -bm_rtl::function_calls__Function::set_string 274 ns 274 ns 2506842 -bm_rtl::method_calls______Method::set_string 274 ns 274 ns 2574283 +bm_rtl::function_calls__Function::set_string 264 ns 264 ns 2641920 +bm_rtl::method_calls______Method::set_string 264 ns 264 ns 2648786 -bm_rtl::function__ErasedReturnType::set_string 278 ns 278 ns 2531104 -bm_rtl::method____ErasedReturnType::set_string 275 ns 275 ns 2543654 -bm_rtl::method____ErasedTargetType::set_string 274 ns 274 ns 2532744 -bm_rtl::method____ErasedTargetAndReturnType::set_string 284 ns 284 ns 2459606 +bm_rtl::function__ErasedReturnType::set_string 270 ns 270 ns 2603193 +bm_rtl::method____ErasedReturnType::set_string 274 ns 274 ns 2555196 +bm_rtl::method____ErasedTargetType::set_string 270 ns 270 ns 2629662 +bm_rtl::method____ErasedTargetAndReturnType::set_string 275 ns 275 ns 2558749 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 384 ns 384 ns 1816058 +bm_call::direct__Function::get_string 365 ns 365 ns 1916083 -bm_call::via_function_ptr__Function::get_string 388 ns 388 ns 1807084 -bm_call::via_function_ptr____Method::get_string 388 ns 388 ns 1802275 +bm_call::via_function_ptr__Function::get_string 365 ns 365 ns 1921180 +bm_call::via_function_ptr____Method::get_string 366 ns 366 ns 1904972 -bm_std::function_calls__Function::get_string 386 ns 386 ns 1800274 -bm_std::function_calls____Method::get_string 387 ns 387 ns 1809751 +bm_std::function_calls__Function::get_string 365 ns 365 ns 1911332 +bm_std::function_calls____Method::get_string 368 ns 368 ns 1884370 -bm_rtl::function_calls__Function::get_string 388 ns 388 ns 1809043 -bm_rtl::method_calls______Method::get_string 388 ns 388 ns 1807297 +bm_rtl::function_calls__Function::get_string 366 ns 366 ns 1923206 +bm_rtl::method_calls______Method::get_string 366 ns 366 ns 1908881 -bm_rtl::function__ErasedReturnType::get_string 403 ns 403 ns 1733679 -bm_rtl::method____ErasedReturnType::get_string 402 ns 402 ns 1738530 -bm_rtl::method____ErasedTargetType::get_string 392 ns 392 ns 1778195 -bm_rtl::method____ErasedTargetAndReturnType::get_string 404 ns 404 ns 1736458 +bm_rtl::function__ErasedReturnType::get_string 375 ns 375 ns 1863335 +bm_rtl::method____ErasedReturnType::get_string 375 ns 375 ns 1858239 +bm_rtl::method____ErasedTargetType::get_string 376 ns 376 ns 1870789 +bm_rtl::method____ErasedTargetAndReturnType::get_string 378 ns 378 ns 1847908 ----------------------------------- -[2025-11-04 11:35:19] >>> Run 1: workload scale = 25 +[2026-01-19 22:23:51] >>> Run 1: workload scale = 25 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 25 iterations ============================================= -2025-11-04T11:35:19+05:30 +2026-01-19T22:23:51+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1037,50 +1037,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 0.84, 0.43 +Load Average: 1.00, 0.88, 0.50 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 308 ns 308 ns 2289455 +bm_call::direct__Function::set_string 329 ns 329 ns 2137193 -bm_call::via_function_ptr__Function::set_string 308 ns 308 ns 2295086 -bm_call::via_function_ptr____Method::set_string 305 ns 305 ns 2282996 +bm_call::via_function_ptr__Function::set_string 314 ns 314 ns 2240187 +bm_call::via_function_ptr____Method::set_string 314 ns 314 ns 2262194 -bm_std::function_calls__Function::set_string 306 ns 306 ns 2287656 -bm_std::function_calls____Method::set_string 305 ns 305 ns 2290493 +bm_std::function_calls__Function::set_string 309 ns 309 ns 2250921 +bm_std::function_calls____Method::set_string 306 ns 306 ns 2305127 -bm_rtl::function_calls__Function::set_string 306 ns 306 ns 2293649 -bm_rtl::method_calls______Method::set_string 308 ns 308 ns 2263061 +bm_rtl::function_calls__Function::set_string 311 ns 311 ns 2239465 +bm_rtl::method_calls______Method::set_string 310 ns 310 ns 2237918 -bm_rtl::function__ErasedReturnType::set_string 310 ns 310 ns 2270433 -bm_rtl::method____ErasedReturnType::set_string 322 ns 322 ns 2184471 -bm_rtl::method____ErasedTargetType::set_string 311 ns 311 ns 2252261 -bm_rtl::method____ErasedTargetAndReturnType::set_string 318 ns 318 ns 2177221 +bm_rtl::function__ErasedReturnType::set_string 317 ns 317 ns 2168950 +bm_rtl::method____ErasedReturnType::set_string 305 ns 305 ns 2289661 +bm_rtl::method____ErasedTargetType::set_string 324 ns 324 ns 2180611 +bm_rtl::method____ErasedTargetAndReturnType::set_string 324 ns 324 ns 2167254 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 449 ns 449 ns 1556063 +bm_call::direct__Function::get_string 425 ns 425 ns 1646554 -bm_call::via_function_ptr__Function::get_string 449 ns 449 ns 1558473 -bm_call::via_function_ptr____Method::get_string 450 ns 450 ns 1553390 +bm_call::via_function_ptr__Function::get_string 428 ns 428 ns 1646159 +bm_call::via_function_ptr____Method::get_string 425 ns 425 ns 1640333 -bm_std::function_calls__Function::get_string 451 ns 451 ns 1557283 -bm_std::function_calls____Method::get_string 452 ns 452 ns 1544521 +bm_std::function_calls__Function::get_string 427 ns 427 ns 1644658 +bm_std::function_calls____Method::get_string 427 ns 427 ns 1645683 -bm_rtl::function_calls__Function::get_string 451 ns 451 ns 1549646 -bm_rtl::method_calls______Method::get_string 450 ns 450 ns 1547760 +bm_rtl::function_calls__Function::get_string 426 ns 426 ns 1647963 +bm_rtl::method_calls______Method::get_string 435 ns 435 ns 1609578 -bm_rtl::function__ErasedReturnType::get_string 468 ns 468 ns 1489242 -bm_rtl::method____ErasedReturnType::get_string 469 ns 469 ns 1493530 -bm_rtl::method____ErasedTargetType::get_string 457 ns 457 ns 1534035 -bm_rtl::method____ErasedTargetAndReturnType::get_string 471 ns 471 ns 1482462 +bm_rtl::function__ErasedReturnType::get_string 436 ns 436 ns 1607688 +bm_rtl::method____ErasedReturnType::get_string 437 ns 437 ns 1609148 +bm_rtl::method____ErasedTargetType::get_string 438 ns 438 ns 1604011 +bm_rtl::method____ErasedTargetAndReturnType::get_string 438 ns 438 ns 1600233 ----------------------------------- -[2025-11-04 11:35:44] >>> Run 2: workload scale = 25 +[2026-01-19 22:24:15] >>> Run 2: workload scale = 25 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 25 iterations ============================================= -2025-11-04T11:35:44+05:30 +2026-01-19T22:24:16+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1088,50 +1088,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 0.85, 0.45 +Load Average: 1.00, 0.89, 0.51 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 310 ns 310 ns 2249513 +bm_call::direct__Function::set_string 361 ns 361 ns 1941242 -bm_call::via_function_ptr__Function::set_string 309 ns 309 ns 2268930 -bm_call::via_function_ptr____Method::set_string 311 ns 311 ns 2250980 +bm_call::via_function_ptr__Function::set_string 346 ns 346 ns 2027125 +bm_call::via_function_ptr____Method::set_string 346 ns 346 ns 2031783 -bm_std::function_calls__Function::set_string 310 ns 310 ns 2266376 -bm_std::function_calls____Method::set_string 310 ns 310 ns 2268158 +bm_std::function_calls__Function::set_string 347 ns 347 ns 2034513 +bm_std::function_calls____Method::set_string 341 ns 341 ns 2049239 -bm_rtl::function_calls__Function::set_string 312 ns 312 ns 2263713 -bm_rtl::method_calls______Method::set_string 310 ns 310 ns 2262103 +bm_rtl::function_calls__Function::set_string 347 ns 347 ns 2018577 +bm_rtl::method_calls______Method::set_string 346 ns 346 ns 2020807 -bm_rtl::function__ErasedReturnType::set_string 315 ns 315 ns 2229881 -bm_rtl::method____ErasedReturnType::set_string 315 ns 315 ns 2221153 -bm_rtl::method____ErasedTargetType::set_string 311 ns 311 ns 2246314 -bm_rtl::method____ErasedTargetAndReturnType::set_string 321 ns 321 ns 2167043 +bm_rtl::function__ErasedReturnType::set_string 357 ns 357 ns 1960365 +bm_rtl::method____ErasedReturnType::set_string 344 ns 344 ns 2030461 +bm_rtl::method____ErasedTargetType::set_string 359 ns 359 ns 1955218 +bm_rtl::method____ErasedTargetAndReturnType::set_string 358 ns 358 ns 1947898 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 448 ns 448 ns 1561857 +bm_call::direct__Function::get_string 484 ns 484 ns 1444771 -bm_call::via_function_ptr__Function::get_string 448 ns 448 ns 1559884 -bm_call::via_function_ptr____Method::get_string 450 ns 450 ns 1556156 +bm_call::via_function_ptr__Function::get_string 486 ns 486 ns 1441287 +bm_call::via_function_ptr____Method::get_string 485 ns 485 ns 1446433 -bm_std::function_calls__Function::get_string 447 ns 447 ns 1561230 -bm_std::function_calls____Method::get_string 451 ns 451 ns 1549786 +bm_std::function_calls__Function::get_string 487 ns 487 ns 1441524 +bm_std::function_calls____Method::get_string 487 ns 487 ns 1433549 -bm_rtl::function_calls__Function::get_string 448 ns 448 ns 1563251 -bm_rtl::method_calls______Method::get_string 450 ns 450 ns 1554882 +bm_rtl::function_calls__Function::get_string 487 ns 487 ns 1436284 +bm_rtl::method_calls______Method::get_string 485 ns 485 ns 1444218 -bm_rtl::function__ErasedReturnType::get_string 468 ns 468 ns 1495466 -bm_rtl::method____ErasedReturnType::get_string 468 ns 468 ns 1496289 -bm_rtl::method____ErasedTargetType::get_string 456 ns 456 ns 1536797 -bm_rtl::method____ErasedTargetAndReturnType::get_string 470 ns 470 ns 1492470 +bm_rtl::function__ErasedReturnType::get_string 498 ns 498 ns 1405236 +bm_rtl::method____ErasedReturnType::get_string 501 ns 501 ns 1399059 +bm_rtl::method____ErasedTargetType::get_string 495 ns 495 ns 1394477 +bm_rtl::method____ErasedTargetAndReturnType::get_string 501 ns 501 ns 1394723 ----------------------------------- -[2025-11-04 11:36:08] >>> Run 3: workload scale = 25 +[2026-01-19 22:24:40] >>> Run 3: workload scale = 25 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 25 iterations ============================================= -2025-11-04T11:36:08+05:30 +2026-01-19T22:24:40+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1139,50 +1139,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.86, 0.47 +Load Average: 1.00, 0.90, 0.52 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 339 ns 339 ns 2075571 +bm_call::direct__Function::set_string 317 ns 317 ns 2207040 -bm_call::via_function_ptr__Function::set_string 339 ns 339 ns 2066316 -bm_call::via_function_ptr____Method::set_string 339 ns 339 ns 2068331 +bm_call::via_function_ptr__Function::set_string 326 ns 326 ns 2156299 +bm_call::via_function_ptr____Method::set_string 326 ns 326 ns 2165496 -bm_std::function_calls__Function::set_string 339 ns 339 ns 2063704 -bm_std::function_calls____Method::set_string 340 ns 340 ns 2055163 +bm_std::function_calls__Function::set_string 326 ns 326 ns 2167831 +bm_std::function_calls____Method::set_string 326 ns 326 ns 2153224 -bm_rtl::function_calls__Function::set_string 339 ns 339 ns 2070474 -bm_rtl::method_calls______Method::set_string 338 ns 338 ns 2054751 +bm_rtl::function_calls__Function::set_string 324 ns 324 ns 2151706 +bm_rtl::method_calls______Method::set_string 326 ns 326 ns 2121751 -bm_rtl::function__ErasedReturnType::set_string 342 ns 342 ns 2041861 -bm_rtl::method____ErasedReturnType::set_string 344 ns 344 ns 2032415 -bm_rtl::method____ErasedTargetType::set_string 344 ns 344 ns 2041850 -bm_rtl::method____ErasedTargetAndReturnType::set_string 346 ns 346 ns 2021772 +bm_rtl::function__ErasedReturnType::set_string 339 ns 339 ns 2052762 +bm_rtl::method____ErasedReturnType::set_string 325 ns 325 ns 2159375 +bm_rtl::method____ErasedTargetType::set_string 344 ns 344 ns 2023497 +bm_rtl::method____ErasedTargetAndReturnType::set_string 339 ns 339 ns 2051367 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 508 ns 508 ns 1375311 +bm_call::direct__Function::get_string 438 ns 438 ns 1606262 -bm_call::via_function_ptr__Function::get_string 508 ns 508 ns 1377949 -bm_call::via_function_ptr____Method::get_string 508 ns 508 ns 1376675 +bm_call::via_function_ptr__Function::get_string 440 ns 440 ns 1578140 +bm_call::via_function_ptr____Method::get_string 439 ns 439 ns 1584218 -bm_std::function_calls__Function::get_string 509 ns 509 ns 1381695 -bm_std::function_calls____Method::get_string 509 ns 509 ns 1372143 +bm_std::function_calls__Function::get_string 439 ns 439 ns 1581952 +bm_std::function_calls____Method::get_string 452 ns 452 ns 1551649 -bm_rtl::function_calls__Function::get_string 506 ns 507 ns 1370074 -bm_rtl::method_calls______Method::get_string 509 ns 509 ns 1374760 +bm_rtl::function_calls__Function::get_string 442 ns 442 ns 1602573 +bm_rtl::method_calls______Method::get_string 440 ns 440 ns 1587330 -bm_rtl::function__ErasedReturnType::get_string 526 ns 526 ns 1335483 -bm_rtl::method____ErasedReturnType::get_string 524 ns 524 ns 1334099 -bm_rtl::method____ErasedTargetType::get_string 516 ns 516 ns 1364756 -bm_rtl::method____ErasedTargetAndReturnType::get_string 526 ns 526 ns 1332934 +bm_rtl::function__ErasedReturnType::get_string 458 ns 458 ns 1517252 +bm_rtl::method____ErasedReturnType::get_string 463 ns 463 ns 1508769 +bm_rtl::method____ErasedTargetType::get_string 455 ns 455 ns 1531543 +bm_rtl::method____ErasedTargetAndReturnType::get_string 460 ns 460 ns 1534110 ----------------------------------- -[2025-11-04 11:36:29] >>> Run 1: workload scale = 30 +[2026-01-19 22:25:05] >>> Run 1: workload scale = 30 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 30 iterations ============================================= -2025-11-04T11:36:29+05:30 +2026-01-19T22:25:05+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1190,203 +1190,203 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.87, 0.48 +Load Average: 1.00, 0.91, 0.54 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 369 ns 369 ns 1897874 +bm_call::direct__Function::set_string 426 ns 426 ns 1642971 -bm_call::via_function_ptr__Function::set_string 368 ns 368 ns 1913102 -bm_call::via_function_ptr____Method::set_string 369 ns 369 ns 1901147 +bm_call::via_function_ptr__Function::set_string 340 ns 340 ns 2060776 +bm_call::via_function_ptr____Method::set_string 340 ns 340 ns 2054856 -bm_std::function_calls__Function::set_string 367 ns 367 ns 1908243 -bm_std::function_calls____Method::set_string 370 ns 370 ns 1882990 +bm_std::function_calls__Function::set_string 342 ns 342 ns 2047289 +bm_std::function_calls____Method::set_string 356 ns 356 ns 1968053 -bm_rtl::function_calls__Function::set_string 367 ns 367 ns 1889567 -bm_rtl::method_calls______Method::set_string 367 ns 367 ns 1903609 +bm_rtl::function_calls__Function::set_string 340 ns 340 ns 2054394 +bm_rtl::method_calls______Method::set_string 342 ns 342 ns 2051463 -bm_rtl::function__ErasedReturnType::set_string 376 ns 376 ns 1862890 -bm_rtl::method____ErasedReturnType::set_string 375 ns 375 ns 1858506 -bm_rtl::method____ErasedTargetType::set_string 380 ns 380 ns 1850619 -bm_rtl::method____ErasedTargetAndReturnType::set_string 385 ns 385 ns 1836768 +bm_rtl::function__ErasedReturnType::set_string 351 ns 351 ns 1991950 +bm_rtl::method____ErasedReturnType::set_string 350 ns 350 ns 2009636 +bm_rtl::method____ErasedTargetType::set_string 353 ns 353 ns 1976671 +bm_rtl::method____ErasedTargetAndReturnType::set_string 358 ns 358 ns 1959273 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 524 ns 524 ns 1338003 +bm_call::direct__Function::get_string 493 ns 493 ns 1418974 -bm_call::via_function_ptr__Function::get_string 525 ns 525 ns 1334577 -bm_call::via_function_ptr____Method::get_string 528 ns 528 ns 1335001 +bm_call::via_function_ptr__Function::get_string 495 ns 495 ns 1415006 +bm_call::via_function_ptr____Method::get_string 495 ns 495 ns 1417840 -bm_std::function_calls__Function::get_string 526 ns 526 ns 1316735 -bm_std::function_calls____Method::get_string 533 ns 533 ns 1315542 +bm_std::function_calls__Function::get_string 495 ns 495 ns 1409827 +bm_std::function_calls____Method::get_string 498 ns 498 ns 1407422 -bm_rtl::function_calls__Function::get_string 526 ns 526 ns 1333276 -bm_rtl::method_calls______Method::get_string 526 ns 526 ns 1342865 +bm_rtl::function_calls__Function::get_string 495 ns 495 ns 1419100 +bm_rtl::method_calls______Method::get_string 496 ns 496 ns 1409543 -bm_rtl::function__ErasedReturnType::get_string 558 ns 558 ns 1248312 -bm_rtl::method____ErasedReturnType::get_string 558 ns 558 ns 1257303 -bm_rtl::method____ErasedTargetType::get_string 546 ns 546 ns 1288987 -bm_rtl::method____ErasedTargetAndReturnType::get_string 563 ns 563 ns 1246070 +bm_rtl::function__ErasedReturnType::get_string 512 ns 512 ns 1364679 +bm_rtl::method____ErasedReturnType::get_string 510 ns 510 ns 1368522 +bm_rtl::method____ErasedTargetType::get_string 510 ns 510 ns 1372916 +bm_rtl::method____ErasedTargetAndReturnType::get_string 512 ns 512 ns 1365261 ----------------------------------- -[2025-11-04 11:36:49] >>> Run 2: workload scale = 30 +[2026-01-19 22:25:28] >>> Run 2: workload scale = 30 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 30 iterations ============================================= -2025-11-04T11:36:49+05:30 +2026-01-19T22:25:28+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1873.5 MHz CPU s) +Run on (16 X 4445.26 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.88, 0.49 +Load Average: 1.00, 0.92, 0.55 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 374 ns 374 ns 1879098 +bm_call::direct__Function::set_string 433 ns 433 ns 1616498 -bm_call::via_function_ptr__Function::set_string 375 ns 375 ns 1876482 -bm_call::via_function_ptr____Method::set_string 375 ns 375 ns 1865772 +bm_call::via_function_ptr__Function::set_string 352 ns 352 ns 1985642 +bm_call::via_function_ptr____Method::set_string 353 ns 353 ns 1978449 -bm_std::function_calls__Function::set_string 374 ns 374 ns 1878401 -bm_std::function_calls____Method::set_string 373 ns 373 ns 1886366 +bm_std::function_calls__Function::set_string 353 ns 353 ns 1991516 +bm_std::function_calls____Method::set_string 371 ns 371 ns 1867726 -bm_rtl::function_calls__Function::set_string 374 ns 374 ns 1876114 -bm_rtl::method_calls______Method::set_string 375 ns 375 ns 1869158 +bm_rtl::function_calls__Function::set_string 353 ns 353 ns 1989083 +bm_rtl::method_calls______Method::set_string 354 ns 354 ns 1969449 -bm_rtl::function__ErasedReturnType::set_string 397 ns 397 ns 1760547 -bm_rtl::method____ErasedReturnType::set_string 394 ns 394 ns 1778330 -bm_rtl::method____ErasedTargetType::set_string 388 ns 388 ns 1810762 -bm_rtl::method____ErasedTargetAndReturnType::set_string 403 ns 403 ns 1736610 +bm_rtl::function__ErasedReturnType::set_string 352 ns 352 ns 1984958 +bm_rtl::method____ErasedReturnType::set_string 353 ns 353 ns 1986122 +bm_rtl::method____ErasedTargetType::set_string 354 ns 354 ns 1980813 +bm_rtl::method____ErasedTargetAndReturnType::set_string 362 ns 362 ns 1931931 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 525 ns 525 ns 1327945 +bm_call::direct__Function::get_string 510 ns 510 ns 1375075 -bm_call::via_function_ptr__Function::get_string 529 ns 529 ns 1321273 -bm_call::via_function_ptr____Method::get_string 529 ns 530 ns 1329153 +bm_call::via_function_ptr__Function::get_string 511 ns 511 ns 1390317 +bm_call::via_function_ptr____Method::get_string 510 ns 510 ns 1360743 -bm_std::function_calls__Function::get_string 528 ns 528 ns 1315558 -bm_std::function_calls____Method::get_string 532 ns 532 ns 1307079 +bm_std::function_calls__Function::get_string 511 ns 511 ns 1368314 +bm_std::function_calls____Method::get_string 518 ns 518 ns 1350815 -bm_rtl::function_calls__Function::get_string 529 ns 529 ns 1318584 -bm_rtl::method_calls______Method::get_string 531 ns 531 ns 1310759 +bm_rtl::function_calls__Function::get_string 509 ns 509 ns 1380089 +bm_rtl::method_calls______Method::get_string 508 ns 508 ns 1383110 -bm_rtl::function__ErasedReturnType::get_string 572 ns 572 ns 1222508 -bm_rtl::method____ErasedReturnType::get_string 566 ns 566 ns 1234666 -bm_rtl::method____ErasedTargetType::get_string 549 ns 549 ns 1271292 -bm_rtl::method____ErasedTargetAndReturnType::get_string 567 ns 567 ns 1236981 +bm_rtl::function__ErasedReturnType::get_string 521 ns 521 ns 1350743 +bm_rtl::method____ErasedReturnType::get_string 523 ns 523 ns 1345324 +bm_rtl::method____ErasedTargetType::get_string 517 ns 517 ns 1363384 +bm_rtl::method____ErasedTargetAndReturnType::get_string 522 ns 522 ns 1343674 ----------------------------------- -[2025-11-04 11:37:10] >>> Run 3: workload scale = 30 +[2026-01-19 22:25:49] >>> Run 3: workload scale = 30 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 30 iterations ============================================= -2025-11-04T11:37:10+05:30 +2026-01-19T22:25:49+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4884.35 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.89, 0.50 +Load Average: 1.00, 0.92, 0.56 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 373 ns 373 ns 1882535 +bm_call::direct__Function::set_string 414 ns 414 ns 1697314 -bm_call::via_function_ptr__Function::set_string 370 ns 370 ns 1883841 -bm_call::via_function_ptr____Method::set_string 370 ns 370 ns 1885110 +bm_call::via_function_ptr__Function::set_string 345 ns 345 ns 2021772 +bm_call::via_function_ptr____Method::set_string 346 ns 346 ns 2022304 -bm_std::function_calls__Function::set_string 368 ns 368 ns 1888699 -bm_std::function_calls____Method::set_string 373 ns 373 ns 1885554 +bm_std::function_calls__Function::set_string 346 ns 346 ns 2023585 +bm_std::function_calls____Method::set_string 347 ns 347 ns 2008508 -bm_rtl::function_calls__Function::set_string 370 ns 370 ns 1903630 -bm_rtl::method_calls______Method::set_string 369 ns 369 ns 1891577 +bm_rtl::function_calls__Function::set_string 346 ns 346 ns 2014818 +bm_rtl::method_calls______Method::set_string 348 ns 348 ns 2017748 -bm_rtl::function__ErasedReturnType::set_string 377 ns 377 ns 1854098 -bm_rtl::method____ErasedReturnType::set_string 378 ns 378 ns 1851962 -bm_rtl::method____ErasedTargetType::set_string 382 ns 382 ns 1839652 -bm_rtl::method____ErasedTargetAndReturnType::set_string 411 ns 411 ns 1708015 +bm_rtl::function__ErasedReturnType::set_string 365 ns 365 ns 1925260 +bm_rtl::method____ErasedReturnType::set_string 374 ns 374 ns 1876867 +bm_rtl::method____ErasedTargetType::set_string 354 ns 354 ns 1985581 +bm_rtl::method____ErasedTargetAndReturnType::set_string 371 ns 371 ns 1878339 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 588 ns 588 ns 1193909 +bm_call::direct__Function::get_string 499 ns 499 ns 1407970 -bm_call::via_function_ptr__Function::get_string 591 ns 591 ns 1184323 -bm_call::via_function_ptr____Method::get_string 590 ns 590 ns 1182298 +bm_call::via_function_ptr__Function::get_string 497 ns 497 ns 1405740 +bm_call::via_function_ptr____Method::get_string 497 ns 497 ns 1403761 -bm_std::function_calls__Function::get_string 591 ns 591 ns 1191866 -bm_std::function_calls____Method::get_string 594 ns 594 ns 1174765 +bm_std::function_calls__Function::get_string 500 ns 500 ns 1000000 +bm_std::function_calls____Method::get_string 499 ns 499 ns 1391338 -bm_rtl::function_calls__Function::get_string 591 ns 591 ns 1187334 -bm_rtl::method_calls______Method::get_string 590 ns 591 ns 1188320 +bm_rtl::function_calls__Function::get_string 497 ns 497 ns 1412667 +bm_rtl::method_calls______Method::get_string 497 ns 497 ns 1409384 -bm_rtl::function__ErasedReturnType::get_string 627 ns 627 ns 1104635 -bm_rtl::method____ErasedReturnType::get_string 624 ns 624 ns 1123294 -bm_rtl::method____ErasedTargetType::get_string 612 ns 612 ns 1142836 -bm_rtl::method____ErasedTargetAndReturnType::get_string 628 ns 628 ns 1114390 +bm_rtl::function__ErasedReturnType::get_string 515 ns 515 ns 1356884 +bm_rtl::method____ErasedReturnType::get_string 515 ns 515 ns 1353416 +bm_rtl::method____ErasedTargetType::get_string 511 ns 511 ns 1375675 +bm_rtl::method____ErasedTargetAndReturnType::get_string 517 ns 516 ns 1363123 ----------------------------------- -[2025-11-04 11:37:31] >>> Run 1: workload scale = 35 +[2026-01-19 22:26:12] >>> Run 1: workload scale = 35 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 35 iterations ============================================= -2025-11-04T11:37:31+05:30 +2026-01-19T22:26:12+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4879.57 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.90, 0.51 +Load Average: 1.00, 0.93, 0.57 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 737 ns 737 ns 949233 +bm_call::direct__Function::set_string 710 ns 710 ns 981145 -bm_call::via_function_ptr__Function::set_string 744 ns 744 ns 940157 -bm_call::via_function_ptr____Method::set_string 739 ns 739 ns 947272 +bm_call::via_function_ptr__Function::set_string 692 ns 692 ns 1013095 +bm_call::via_function_ptr____Method::set_string 692 ns 692 ns 1011763 -bm_std::function_calls__Function::set_string 743 ns 743 ns 940579 -bm_std::function_calls____Method::set_string 750 ns 750 ns 931994 +bm_std::function_calls__Function::set_string 691 ns 691 ns 1013638 +bm_std::function_calls____Method::set_string 714 ns 714 ns 972767 -bm_rtl::function_calls__Function::set_string 743 ns 743 ns 942206 -bm_rtl::method_calls______Method::set_string 740 ns 739 ns 947113 +bm_rtl::function_calls__Function::set_string 691 ns 691 ns 1011286 +bm_rtl::method_calls______Method::set_string 693 ns 693 ns 1015686 -bm_rtl::function__ErasedReturnType::set_string 751 ns 751 ns 932672 -bm_rtl::method____ErasedReturnType::set_string 753 ns 753 ns 930104 -bm_rtl::method____ErasedTargetType::set_string 758 ns 758 ns 910359 -bm_rtl::method____ErasedTargetAndReturnType::set_string 758 ns 758 ns 922853 +bm_rtl::function__ErasedReturnType::set_string 706 ns 706 ns 990586 +bm_rtl::method____ErasedReturnType::set_string 707 ns 707 ns 990922 +bm_rtl::method____ErasedTargetType::set_string 711 ns 711 ns 985971 +bm_rtl::method____ErasedTargetAndReturnType::set_string 717 ns 717 ns 976150 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 941 ns 941 ns 747998 +bm_call::direct__Function::get_string 922 ns 922 ns 759196 -bm_call::via_function_ptr__Function::get_string 941 ns 941 ns 744259 -bm_call::via_function_ptr____Method::get_string 942 ns 942 ns 743961 +bm_call::via_function_ptr__Function::get_string 924 ns 924 ns 759281 +bm_call::via_function_ptr____Method::get_string 922 ns 922 ns 759827 -bm_std::function_calls__Function::get_string 942 ns 942 ns 736240 -bm_std::function_calls____Method::get_string 948 ns 948 ns 737759 +bm_std::function_calls__Function::get_string 924 ns 924 ns 759626 +bm_std::function_calls____Method::get_string 927 ns 927 ns 752753 -bm_rtl::function_calls__Function::get_string 944 ns 944 ns 742616 -bm_rtl::method_calls______Method::get_string 944 ns 944 ns 741708 +bm_rtl::function_calls__Function::get_string 925 ns 925 ns 756943 +bm_rtl::method_calls______Method::get_string 923 ns 923 ns 760058 -bm_rtl::function__ErasedReturnType::get_string 977 ns 977 ns 716160 -bm_rtl::method____ErasedReturnType::get_string 982 ns 982 ns 707304 -bm_rtl::method____ErasedTargetType::get_string 968 ns 968 ns 723075 -bm_rtl::method____ErasedTargetAndReturnType::get_string 989 ns 989 ns 709624 +bm_rtl::function__ErasedReturnType::get_string 960 ns 960 ns 730468 +bm_rtl::method____ErasedReturnType::get_string 961 ns 961 ns 728306 +bm_rtl::method____ErasedTargetType::get_string 950 ns 950 ns 737199 +bm_rtl::method____ErasedTargetAndReturnType::get_string 973 ns 973 ns 719799 ----------------------------------- -[2025-11-04 11:37:48] >>> Run 2: workload scale = 35 +[2026-01-19 22:26:29] >>> Run 2: workload scale = 35 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 35 iterations ============================================= -2025-11-04T11:37:48+05:30 +2026-01-19T22:26:29+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1394,101 +1394,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.91, 0.53 +Load Average: 1.00, 0.93, 0.58 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 696 ns 696 ns 997945 +bm_call::direct__Function::set_string 688 ns 688 ns 1012792 -bm_call::via_function_ptr__Function::set_string 696 ns 696 ns 1008698 -bm_call::via_function_ptr____Method::set_string 697 ns 697 ns 1006462 +bm_call::via_function_ptr__Function::set_string 696 ns 696 ns 1003588 +bm_call::via_function_ptr____Method::set_string 696 ns 696 ns 1007834 -bm_std::function_calls__Function::set_string 696 ns 696 ns 1006201 -bm_std::function_calls____Method::set_string 700 ns 700 ns 1001226 +bm_std::function_calls__Function::set_string 696 ns 696 ns 1006928 +bm_std::function_calls____Method::set_string 722 ns 722 ns 974459 -bm_rtl::function_calls__Function::set_string 697 ns 697 ns 1006362 -bm_rtl::method_calls______Method::set_string 697 ns 697 ns 1006337 +bm_rtl::function_calls__Function::set_string 697 ns 697 ns 1004193 +bm_rtl::method_calls______Method::set_string 696 ns 696 ns 1007755 -bm_rtl::function__ErasedReturnType::set_string 710 ns 710 ns 988589 -bm_rtl::method____ErasedReturnType::set_string 709 ns 709 ns 984855 -bm_rtl::method____ErasedTargetType::set_string 715 ns 712 ns 981415 -bm_rtl::method____ErasedTargetAndReturnType::set_string 723 ns 719 ns 972341 +bm_rtl::function__ErasedReturnType::set_string 704 ns 704 ns 993190 +bm_rtl::method____ErasedReturnType::set_string 703 ns 703 ns 992625 +bm_rtl::method____ErasedTargetType::set_string 709 ns 709 ns 988352 +bm_rtl::method____ErasedTargetAndReturnType::set_string 707 ns 707 ns 992378 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 905 ns 901 ns 777630 +bm_call::direct__Function::get_string 886 ns 886 ns 790128 -bm_call::via_function_ptr__Function::get_string 904 ns 900 ns 777827 -bm_call::via_function_ptr____Method::get_string 905 ns 901 ns 776675 +bm_call::via_function_ptr__Function::get_string 887 ns 887 ns 790635 +bm_call::via_function_ptr____Method::get_string 886 ns 886 ns 790890 -bm_std::function_calls__Function::get_string 904 ns 900 ns 777750 -bm_std::function_calls____Method::get_string 910 ns 906 ns 772493 +bm_std::function_calls__Function::get_string 886 ns 886 ns 790529 +bm_std::function_calls____Method::get_string 892 ns 892 ns 786318 -bm_rtl::function_calls__Function::get_string 903 ns 899 ns 777881 -bm_rtl::method_calls______Method::get_string 905 ns 901 ns 776797 +bm_rtl::function_calls__Function::get_string 885 ns 885 ns 790710 +bm_rtl::method_calls______Method::get_string 887 ns 886 ns 789776 -bm_rtl::function__ErasedReturnType::get_string 949 ns 945 ns 739878 -bm_rtl::method____ErasedReturnType::get_string 951 ns 948 ns 738968 -bm_rtl::method____ErasedTargetType::get_string 928 ns 925 ns 757011 -bm_rtl::method____ErasedTargetAndReturnType::get_string 965 ns 962 ns 727928 +bm_rtl::function__ErasedReturnType::get_string 910 ns 909 ns 767868 +bm_rtl::method____ErasedReturnType::get_string 911 ns 910 ns 769923 +bm_rtl::method____ErasedTargetType::get_string 903 ns 903 ns 776352 +bm_rtl::method____ErasedTargetAndReturnType::get_string 910 ns 910 ns 767263 ----------------------------------- -[2025-11-04 11:38:06] >>> Run 3: workload scale = 35 +[2026-01-19 22:26:46] >>> Run 3: workload scale = 35 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 35 iterations ============================================= -2025-11-04T11:38:06+05:30 +2026-01-19T22:26:46+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1390.47 MHz CPU s) +Run on (16 X 4826.63 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.91, 0.53 +Load Average: 1.00, 0.94, 0.59 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 685 ns 682 ns 1018054 +bm_call::direct__Function::set_string 687 ns 687 ns 1012333 -bm_call::via_function_ptr__Function::set_string 690 ns 687 ns 1016613 -bm_call::via_function_ptr____Method::set_string 687 ns 685 ns 1020388 +bm_call::via_function_ptr__Function::set_string 698 ns 698 ns 1001974 +bm_call::via_function_ptr____Method::set_string 699 ns 699 ns 1001002 -bm_std::function_calls__Function::set_string 689 ns 686 ns 1019090 -bm_std::function_calls____Method::set_string 696 ns 694 ns 1009476 +bm_std::function_calls__Function::set_string 699 ns 699 ns 1003186 +bm_std::function_calls____Method::set_string 695 ns 695 ns 1008207 -bm_rtl::function_calls__Function::set_string 691 ns 688 ns 1010954 -bm_rtl::method_calls______Method::set_string 688 ns 685 ns 1021430 +bm_rtl::function_calls__Function::set_string 698 ns 698 ns 1000755 +bm_rtl::method_calls______Method::set_string 700 ns 700 ns 1003123 -bm_rtl::function__ErasedReturnType::set_string 700 ns 698 ns 1002649 -bm_rtl::method____ErasedReturnType::set_string 704 ns 702 ns 997297 -bm_rtl::method____ErasedTargetType::set_string 705 ns 702 ns 998683 -bm_rtl::method____ErasedTargetAndReturnType::set_string 711 ns 709 ns 986675 +bm_rtl::function__ErasedReturnType::set_string 713 ns 713 ns 983307 +bm_rtl::method____ErasedReturnType::set_string 705 ns 705 ns 986819 +bm_rtl::method____ErasedTargetType::set_string 721 ns 721 ns 973763 +bm_rtl::method____ErasedTargetAndReturnType::set_string 719 ns 718 ns 972130 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 906 ns 903 ns 776326 +bm_call::direct__Function::get_string 868 ns 868 ns 808143 -bm_call::via_function_ptr__Function::get_string 906 ns 903 ns 774790 -bm_call::via_function_ptr____Method::get_string 906 ns 904 ns 774417 +bm_call::via_function_ptr__Function::get_string 873 ns 873 ns 802283 +bm_call::via_function_ptr____Method::get_string 873 ns 873 ns 802368 -bm_std::function_calls__Function::get_string 906 ns 903 ns 773345 -bm_std::function_calls____Method::get_string 914 ns 912 ns 768527 +bm_std::function_calls__Function::get_string 871 ns 871 ns 803251 +bm_std::function_calls____Method::get_string 875 ns 875 ns 800165 -bm_rtl::function_calls__Function::get_string 905 ns 903 ns 775225 -bm_rtl::method_calls______Method::get_string 906 ns 903 ns 775504 +bm_rtl::function_calls__Function::get_string 875 ns 875 ns 799948 +bm_rtl::method_calls______Method::get_string 875 ns 875 ns 798701 -bm_rtl::function__ErasedReturnType::get_string 947 ns 945 ns 740012 -bm_rtl::method____ErasedReturnType::get_string 947 ns 944 ns 742160 -bm_rtl::method____ErasedTargetType::get_string 929 ns 926 ns 755413 -bm_rtl::method____ErasedTargetAndReturnType::get_string 953 ns 950 ns 737066 +bm_rtl::function__ErasedReturnType::get_string 906 ns 906 ns 772812 +bm_rtl::method____ErasedReturnType::get_string 905 ns 905 ns 773400 +bm_rtl::method____ErasedTargetType::get_string 896 ns 896 ns 779165 +bm_rtl::method____ErasedTargetAndReturnType::get_string 910 ns 910 ns 767525 ----------------------------------- -[2025-11-04 11:38:23] >>> Run 1: workload scale = 40 +[2026-01-19 22:27:04] >>> Run 1: workload scale = 40 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 40 iterations ============================================= -2025-11-04T11:38:23+05:30 +2026-01-19T22:27:04+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1496,101 +1496,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.92, 0.55 +Load Average: 1.00, 0.94, 0.60 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 800 ns 799 ns 867264 +bm_call::direct__Function::set_string 802 ns 802 ns 868548 -bm_call::via_function_ptr__Function::set_string 798 ns 796 ns 880085 -bm_call::via_function_ptr____Method::set_string 799 ns 797 ns 880685 +bm_call::via_function_ptr__Function::set_string 807 ns 807 ns 867844 +bm_call::via_function_ptr____Method::set_string 812 ns 812 ns 863363 -bm_std::function_calls__Function::set_string 797 ns 795 ns 880499 -bm_std::function_calls____Method::set_string 809 ns 807 ns 866812 +bm_std::function_calls__Function::set_string 807 ns 807 ns 867775 +bm_std::function_calls____Method::set_string 824 ns 824 ns 850370 -bm_rtl::function_calls__Function::set_string 796 ns 794 ns 883223 -bm_rtl::method_calls______Method::set_string 799 ns 797 ns 876599 +bm_rtl::function_calls__Function::set_string 807 ns 807 ns 869726 +bm_rtl::method_calls______Method::set_string 812 ns 811 ns 861708 -bm_rtl::function__ErasedReturnType::set_string 812 ns 810 ns 861595 -bm_rtl::method____ErasedReturnType::set_string 815 ns 813 ns 863290 -bm_rtl::method____ErasedTargetType::set_string 817 ns 815 ns 860003 -bm_rtl::method____ErasedTargetAndReturnType::set_string 825 ns 823 ns 848476 +bm_rtl::function__ErasedReturnType::set_string 820 ns 820 ns 853781 +bm_rtl::method____ErasedReturnType::set_string 821 ns 821 ns 851633 +bm_rtl::method____ErasedTargetType::set_string 821 ns 821 ns 853270 +bm_rtl::method____ErasedTargetAndReturnType::set_string 821 ns 821 ns 852568 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1016 ns 1014 ns 691107 +bm_call::direct__Function::get_string 1060 ns 1060 ns 658475 -bm_call::via_function_ptr__Function::get_string 1018 ns 1016 ns 688866 -bm_call::via_function_ptr____Method::get_string 1017 ns 1015 ns 688426 +bm_call::via_function_ptr__Function::get_string 1065 ns 1064 ns 657487 +bm_call::via_function_ptr____Method::get_string 1064 ns 1063 ns 658536 -bm_std::function_calls__Function::get_string 1018 ns 1016 ns 689406 -bm_std::function_calls____Method::get_string 1030 ns 1028 ns 680879 +bm_std::function_calls__Function::get_string 1065 ns 1065 ns 657326 +bm_std::function_calls____Method::get_string 1068 ns 1068 ns 654286 -bm_rtl::function_calls__Function::get_string 1017 ns 1015 ns 688175 -bm_rtl::method_calls______Method::get_string 1017 ns 1016 ns 689699 +bm_rtl::function_calls__Function::get_string 1065 ns 1065 ns 656003 +bm_rtl::method_calls______Method::get_string 1064 ns 1064 ns 658205 -bm_rtl::function__ErasedReturnType::get_string 1062 ns 1060 ns 660938 -bm_rtl::method____ErasedReturnType::get_string 1062 ns 1060 ns 660987 -bm_rtl::method____ErasedTargetType::get_string 1041 ns 1039 ns 674072 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1068 ns 1066 ns 655561 +bm_rtl::function__ErasedReturnType::get_string 1094 ns 1094 ns 640286 +bm_rtl::method____ErasedReturnType::get_string 1094 ns 1094 ns 640985 +bm_rtl::method____ErasedTargetType::get_string 1087 ns 1087 ns 644549 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1101 ns 1101 ns 636794 ----------------------------------- -[2025-11-04 11:38:41] >>> Run 2: workload scale = 40 +[2026-01-19 22:27:21] >>> Run 2: workload scale = 40 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 40 iterations ============================================= -2025-11-04T11:38:41+05:30 +2026-01-19T22:27:21+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1231.43 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.92, 0.55 +Load Average: 1.00, 0.95, 0.61 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 788 ns 786 ns 878975 +bm_call::direct__Function::set_string 786 ns 786 ns 883972 -bm_call::via_function_ptr__Function::set_string 788 ns 787 ns 886890 -bm_call::via_function_ptr____Method::set_string 789 ns 788 ns 889408 +bm_call::via_function_ptr__Function::set_string 774 ns 774 ns 903846 +bm_call::via_function_ptr____Method::set_string 778 ns 778 ns 899190 -bm_std::function_calls__Function::set_string 790 ns 789 ns 890087 -bm_std::function_calls____Method::set_string 793 ns 792 ns 881178 +bm_std::function_calls__Function::set_string 774 ns 774 ns 903053 +bm_std::function_calls____Method::set_string 774 ns 773 ns 907756 -bm_rtl::function_calls__Function::set_string 789 ns 787 ns 889915 -bm_rtl::method_calls______Method::set_string 788 ns 787 ns 885010 +bm_rtl::function_calls__Function::set_string 773 ns 773 ns 906453 +bm_rtl::method_calls______Method::set_string 778 ns 778 ns 899327 -bm_rtl::function__ErasedReturnType::set_string 798 ns 797 ns 876161 -bm_rtl::method____ErasedReturnType::set_string 797 ns 796 ns 878707 -bm_rtl::method____ErasedTargetType::set_string 800 ns 799 ns 876369 -bm_rtl::method____ErasedTargetAndReturnType::set_string 807 ns 806 ns 871804 +bm_rtl::function__ErasedReturnType::set_string 780 ns 780 ns 897281 +bm_rtl::method____ErasedReturnType::set_string 782 ns 782 ns 895546 +bm_rtl::method____ErasedTargetType::set_string 785 ns 785 ns 890456 +bm_rtl::method____ErasedTargetAndReturnType::set_string 785 ns 785 ns 892386 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1004 ns 1003 ns 696947 +bm_call::direct__Function::get_string 988 ns 988 ns 709044 -bm_call::via_function_ptr__Function::get_string 1058 ns 1056 ns 696943 -bm_call::via_function_ptr____Method::get_string 1058 ns 1057 ns 662406 +bm_call::via_function_ptr__Function::get_string 991 ns 991 ns 707835 +bm_call::via_function_ptr____Method::get_string 988 ns 988 ns 708817 -bm_std::function_calls__Function::get_string 1060 ns 1059 ns 661064 -bm_std::function_calls____Method::get_string 1061 ns 1060 ns 660663 +bm_std::function_calls__Function::get_string 991 ns 991 ns 707988 +bm_std::function_calls____Method::get_string 993 ns 992 ns 705658 -bm_rtl::function_calls__Function::get_string 1059 ns 1057 ns 662143 -bm_rtl::method_calls______Method::get_string 1059 ns 1058 ns 661466 +bm_rtl::function_calls__Function::get_string 989 ns 989 ns 706853 +bm_rtl::method_calls______Method::get_string 988 ns 988 ns 709751 -bm_rtl::function__ErasedReturnType::get_string 1097 ns 1096 ns 638879 -bm_rtl::method____ErasedReturnType::get_string 1098 ns 1097 ns 638203 -bm_rtl::method____ErasedTargetType::get_string 1076 ns 1075 ns 650820 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1101 ns 1100 ns 636763 +bm_rtl::function__ErasedReturnType::get_string 1016 ns 1016 ns 690073 +bm_rtl::method____ErasedReturnType::get_string 1012 ns 1012 ns 692075 +bm_rtl::method____ErasedTargetType::get_string 1012 ns 1012 ns 694173 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1015 ns 1015 ns 690549 ----------------------------------- -[2025-11-04 11:38:58] >>> Run 3: workload scale = 40 +[2026-01-19 22:27:39] >>> Run 3: workload scale = 40 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 40 iterations ============================================= -2025-11-04T11:38:58+05:30 +2026-01-19T22:27:39+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1598,101 +1598,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.93, 0.56 +Load Average: 1.00, 0.95, 0.61 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 790 ns 789 ns 879491 +bm_call::direct__Function::set_string 771 ns 771 ns 885667 -bm_call::via_function_ptr__Function::set_string 801 ns 800 ns 876063 -bm_call::via_function_ptr____Method::set_string 801 ns 800 ns 875793 +bm_call::via_function_ptr__Function::set_string 793 ns 793 ns 878508 +bm_call::via_function_ptr____Method::set_string 800 ns 800 ns 874309 -bm_std::function_calls__Function::set_string 801 ns 800 ns 867836 -bm_std::function_calls____Method::set_string 793 ns 793 ns 882424 +bm_std::function_calls__Function::set_string 794 ns 794 ns 887848 +bm_std::function_calls____Method::set_string 779 ns 778 ns 901238 -bm_rtl::function_calls__Function::set_string 801 ns 800 ns 873938 -bm_rtl::method_calls______Method::set_string 800 ns 799 ns 876111 +bm_rtl::function_calls__Function::set_string 793 ns 792 ns 880417 +bm_rtl::method_calls______Method::set_string 799 ns 799 ns 873660 -bm_rtl::function__ErasedReturnType::set_string 791 ns 790 ns 883758 -bm_rtl::method____ErasedReturnType::set_string 794 ns 793 ns 882458 -bm_rtl::method____ErasedTargetType::set_string 795 ns 794 ns 882106 -bm_rtl::method____ErasedTargetAndReturnType::set_string 802 ns 802 ns 875097 +bm_rtl::function__ErasedReturnType::set_string 786 ns 786 ns 894928 +bm_rtl::method____ErasedReturnType::set_string 801 ns 800 ns 877038 +bm_rtl::method____ErasedTargetType::set_string 788 ns 788 ns 887908 +bm_rtl::method____ErasedTargetAndReturnType::set_string 806 ns 806 ns 866137 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1011 ns 1010 ns 691725 +bm_call::direct__Function::get_string 1016 ns 1016 ns 691784 -bm_call::via_function_ptr__Function::get_string 1013 ns 1012 ns 690708 -bm_call::via_function_ptr____Method::get_string 1015 ns 1014 ns 690969 +bm_call::via_function_ptr__Function::get_string 1000 ns 1000 ns 697377 +bm_call::via_function_ptr____Method::get_string 1000 ns 1000 ns 698055 -bm_std::function_calls__Function::get_string 1014 ns 1013 ns 691823 -bm_std::function_calls____Method::get_string 1007 ns 1006 ns 696324 +bm_std::function_calls__Function::get_string 1001 ns 1001 ns 700875 +bm_std::function_calls____Method::get_string 1003 ns 1003 ns 695781 -bm_rtl::function_calls__Function::get_string 1014 ns 1013 ns 690932 -bm_rtl::method_calls______Method::get_string 1016 ns 1015 ns 691167 +bm_rtl::function_calls__Function::get_string 1001 ns 1000 ns 701247 +bm_rtl::method_calls______Method::get_string 999 ns 999 ns 700681 -bm_rtl::function__ErasedReturnType::get_string 1029 ns 1028 ns 679959 -bm_rtl::method____ErasedReturnType::get_string 1036 ns 1035 ns 676196 -bm_rtl::method____ErasedTargetType::get_string 1017 ns 1016 ns 689113 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1043 ns 1042 ns 672677 +bm_rtl::function__ErasedReturnType::get_string 1023 ns 1023 ns 684652 +bm_rtl::method____ErasedReturnType::get_string 1022 ns 1022 ns 685580 +bm_rtl::method____ErasedTargetType::get_string 1016 ns 1016 ns 686936 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1031 ns 1031 ns 680324 ----------------------------------- -[2025-11-04 11:39:16] >>> Run 1: workload scale = 45 +[2026-01-19 22:27:57] >>> Run 1: workload scale = 45 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 45 iterations ============================================= -2025-11-04T11:39:16+05:30 +2026-01-19T22:27:57+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 1640.45 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.93, 0.57 +Load Average: 1.00, 0.95, 0.62 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 846 ns 846 ns 821898 +bm_call::direct__Function::set_string 843 ns 842 ns 829422 -bm_call::via_function_ptr__Function::set_string 846 ns 846 ns 829586 -bm_call::via_function_ptr____Method::set_string 847 ns 846 ns 827075 +bm_call::via_function_ptr__Function::set_string 826 ns 826 ns 847271 +bm_call::via_function_ptr____Method::set_string 830 ns 830 ns 841956 -bm_std::function_calls__Function::set_string 848 ns 848 ns 823698 -bm_std::function_calls____Method::set_string 850 ns 849 ns 824485 +bm_std::function_calls__Function::set_string 828 ns 828 ns 845355 +bm_std::function_calls____Method::set_string 832 ns 832 ns 840493 -bm_rtl::function_calls__Function::set_string 848 ns 848 ns 826498 -bm_rtl::method_calls______Method::set_string 847 ns 846 ns 826833 +bm_rtl::function_calls__Function::set_string 826 ns 826 ns 845523 +bm_rtl::method_calls______Method::set_string 831 ns 831 ns 842934 -bm_rtl::function__ErasedReturnType::set_string 857 ns 857 ns 817116 -bm_rtl::method____ErasedReturnType::set_string 856 ns 855 ns 819321 -bm_rtl::method____ErasedTargetType::set_string 860 ns 859 ns 815630 -bm_rtl::method____ErasedTargetAndReturnType::set_string 871 ns 870 ns 803543 +bm_rtl::function__ErasedReturnType::set_string 837 ns 837 ns 835998 +bm_rtl::method____ErasedReturnType::set_string 861 ns 861 ns 813815 +bm_rtl::method____ErasedTargetType::set_string 845 ns 845 ns 828408 +bm_rtl::method____ErasedTargetAndReturnType::set_string 845 ns 844 ns 829014 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1082 ns 1081 ns 648078 +bm_call::direct__Function::get_string 1061 ns 1061 ns 659854 -bm_call::via_function_ptr__Function::get_string 1079 ns 1078 ns 649415 -bm_call::via_function_ptr____Method::get_string 1080 ns 1079 ns 648859 +bm_call::via_function_ptr__Function::get_string 1059 ns 1059 ns 661004 +bm_call::via_function_ptr____Method::get_string 1059 ns 1058 ns 660856 -bm_std::function_calls__Function::get_string 1078 ns 1077 ns 649608 -bm_std::function_calls____Method::get_string 1085 ns 1084 ns 646485 +bm_std::function_calls__Function::get_string 1059 ns 1059 ns 659554 +bm_std::function_calls____Method::get_string 1065 ns 1065 ns 657328 -bm_rtl::function_calls__Function::get_string 1077 ns 1077 ns 650108 -bm_rtl::method_calls______Method::get_string 1080 ns 1079 ns 648442 +bm_rtl::function_calls__Function::get_string 1059 ns 1059 ns 660814 +bm_rtl::method_calls______Method::get_string 1058 ns 1058 ns 661209 -bm_rtl::function__ErasedReturnType::get_string 1115 ns 1114 ns 626958 -bm_rtl::method____ErasedReturnType::get_string 1117 ns 1116 ns 626786 -bm_rtl::method____ErasedTargetType::get_string 1096 ns 1095 ns 638830 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1126 ns 1125 ns 622353 +bm_rtl::function__ErasedReturnType::get_string 1083 ns 1083 ns 645463 +bm_rtl::method____ErasedReturnType::get_string 1083 ns 1083 ns 645790 +bm_rtl::method____ErasedTargetType::get_string 1075 ns 1075 ns 649976 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1082 ns 1082 ns 645611 ----------------------------------- -[2025-11-04 11:39:34] >>> Run 2: workload scale = 45 +[2026-01-19 22:28:14] >>> Run 2: workload scale = 45 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 45 iterations ============================================= -2025-11-04T11:39:34+05:30 +2026-01-19T22:28:14+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1700,101 +1700,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.94, 0.58 +Load Average: 1.00, 0.96, 0.63 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 848 ns 847 ns 822625 +bm_call::direct__Function::set_string 873 ns 873 ns 798150 -bm_call::via_function_ptr__Function::set_string 845 ns 844 ns 820487 -bm_call::via_function_ptr____Method::set_string 844 ns 843 ns 829949 +bm_call::via_function_ptr__Function::set_string 818 ns 818 ns 855496 +bm_call::via_function_ptr____Method::set_string 822 ns 822 ns 851194 -bm_std::function_calls__Function::set_string 845 ns 844 ns 825232 -bm_std::function_calls____Method::set_string 853 ns 852 ns 821822 +bm_std::function_calls__Function::set_string 820 ns 820 ns 853680 +bm_std::function_calls____Method::set_string 826 ns 826 ns 848997 -bm_rtl::function_calls__Function::set_string 845 ns 844 ns 827961 -bm_rtl::method_calls______Method::set_string 845 ns 845 ns 826856 +bm_rtl::function_calls__Function::set_string 820 ns 819 ns 855357 +bm_rtl::method_calls______Method::set_string 822 ns 822 ns 850380 -bm_rtl::function__ErasedReturnType::set_string 856 ns 855 ns 819788 -bm_rtl::method____ErasedReturnType::set_string 855 ns 854 ns 822908 -bm_rtl::method____ErasedTargetType::set_string 857 ns 857 ns 817574 -bm_rtl::method____ErasedTargetAndReturnType::set_string 868 ns 867 ns 808004 +bm_rtl::function__ErasedReturnType::set_string 829 ns 829 ns 843995 +bm_rtl::method____ErasedReturnType::set_string 833 ns 833 ns 841065 +bm_rtl::method____ErasedTargetType::set_string 835 ns 835 ns 836950 +bm_rtl::method____ErasedTargetAndReturnType::set_string 835 ns 835 ns 838849 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1083 ns 1082 ns 648003 +bm_call::direct__Function::get_string 1106 ns 1106 ns 633211 -bm_call::via_function_ptr__Function::get_string 1077 ns 1077 ns 649849 -bm_call::via_function_ptr____Method::get_string 1080 ns 1079 ns 649233 +bm_call::via_function_ptr__Function::get_string 1106 ns 1106 ns 632481 +bm_call::via_function_ptr____Method::get_string 1106 ns 1105 ns 633333 -bm_std::function_calls__Function::get_string 1076 ns 1076 ns 650966 -bm_std::function_calls____Method::get_string 1088 ns 1087 ns 643800 +bm_std::function_calls__Function::get_string 1106 ns 1106 ns 632483 +bm_std::function_calls____Method::get_string 1114 ns 1114 ns 628515 -bm_rtl::function_calls__Function::get_string 1078 ns 1078 ns 646730 -bm_rtl::method_calls______Method::get_string 1078 ns 1078 ns 649617 +bm_rtl::function_calls__Function::get_string 1106 ns 1106 ns 633284 +bm_rtl::method_calls______Method::get_string 1105 ns 1105 ns 633066 -bm_rtl::function__ErasedReturnType::get_string 1112 ns 1111 ns 629505 -bm_rtl::method____ErasedReturnType::get_string 1116 ns 1116 ns 626620 -bm_rtl::method____ErasedTargetType::get_string 1094 ns 1093 ns 640864 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1121 ns 1120 ns 619886 +bm_rtl::function__ErasedReturnType::get_string 1136 ns 1136 ns 615606 +bm_rtl::method____ErasedReturnType::get_string 1134 ns 1134 ns 616323 +bm_rtl::method____ErasedTargetType::get_string 1129 ns 1129 ns 621462 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1140 ns 1139 ns 614829 ----------------------------------- -[2025-11-04 11:39:52] >>> Run 3: workload scale = 45 +[2026-01-19 22:28:32] >>> Run 3: workload scale = 45 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 45 iterations ============================================= -2025-11-04T11:39:52+05:30 +2026-01-19T22:28:32+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 800 MHz CPU s) +Run on (16 X 2371.34 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.00, 0.94, 0.59 +Load Average: 1.00, 0.96, 0.64 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 841 ns 841 ns 828006 +bm_call::direct__Function::set_string 848 ns 848 ns 821823 -bm_call::via_function_ptr__Function::set_string 846 ns 845 ns 827058 -bm_call::via_function_ptr____Method::set_string 844 ns 843 ns 830739 +bm_call::via_function_ptr__Function::set_string 849 ns 849 ns 823432 +bm_call::via_function_ptr____Method::set_string 848 ns 848 ns 826357 -bm_std::function_calls__Function::set_string 844 ns 843 ns 826509 -bm_std::function_calls____Method::set_string 849 ns 848 ns 825604 +bm_std::function_calls__Function::set_string 849 ns 849 ns 825248 +bm_std::function_calls____Method::set_string 834 ns 834 ns 840820 -bm_rtl::function_calls__Function::set_string 846 ns 846 ns 828447 -bm_rtl::method_calls______Method::set_string 845 ns 844 ns 829668 +bm_rtl::function_calls__Function::set_string 847 ns 847 ns 826081 +bm_rtl::method_calls______Method::set_string 848 ns 848 ns 821829 -bm_rtl::function__ErasedReturnType::set_string 855 ns 854 ns 821153 -bm_rtl::method____ErasedReturnType::set_string 860 ns 859 ns 813919 -bm_rtl::method____ErasedTargetType::set_string 855 ns 854 ns 818020 -bm_rtl::method____ErasedTargetAndReturnType::set_string 869 ns 869 ns 807824 +bm_rtl::function__ErasedReturnType::set_string 868 ns 867 ns 806472 +bm_rtl::method____ErasedReturnType::set_string 848 ns 847 ns 823741 +bm_rtl::method____ErasedTargetType::set_string 872 ns 872 ns 802754 +bm_rtl::method____ErasedTargetAndReturnType::set_string 876 ns 876 ns 799331 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1074 ns 1073 ns 652774 +bm_call::direct__Function::get_string 1064 ns 1064 ns 658715 -bm_call::via_function_ptr__Function::get_string 1071 ns 1070 ns 653625 -bm_call::via_function_ptr____Method::get_string 1072 ns 1071 ns 653933 +bm_call::via_function_ptr__Function::get_string 1066 ns 1066 ns 655833 +bm_call::via_function_ptr____Method::get_string 1066 ns 1066 ns 656046 -bm_std::function_calls__Function::get_string 1072 ns 1071 ns 653516 -bm_std::function_calls____Method::get_string 1079 ns 1079 ns 648755 +bm_std::function_calls__Function::get_string 1067 ns 1067 ns 655205 +bm_std::function_calls____Method::get_string 1069 ns 1068 ns 655293 -bm_rtl::function_calls__Function::get_string 1071 ns 1071 ns 654398 -bm_rtl::method_calls______Method::get_string 1072 ns 1072 ns 653285 +bm_rtl::function_calls__Function::get_string 1066 ns 1065 ns 658227 +bm_rtl::method_calls______Method::get_string 1065 ns 1065 ns 657248 -bm_rtl::function__ErasedReturnType::get_string 1108 ns 1108 ns 631753 -bm_rtl::method____ErasedReturnType::get_string 1111 ns 1111 ns 630268 -bm_rtl::method____ErasedTargetType::get_string 1085 ns 1084 ns 645525 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1122 ns 1121 ns 624251 +bm_rtl::function__ErasedReturnType::get_string 1088 ns 1088 ns 643258 +bm_rtl::method____ErasedReturnType::get_string 1087 ns 1087 ns 644904 +bm_rtl::method____ErasedTargetType::get_string 1078 ns 1078 ns 647611 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1078 ns 1078 ns 649254 ----------------------------------- -[2025-11-04 11:40:09] >>> Run 1: workload scale = 50 +[2026-01-19 22:28:50] >>> Run 1: workload scale = 50 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 50 iterations ============================================= -2025-11-04T11:40:09+05:30 +2026-01-19T22:28:50+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1802,101 +1802,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.06, 0.96, 0.60 +Load Average: 1.00, 0.96, 0.65 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 909 ns 909 ns 767477 +bm_call::direct__Function::set_string 934 ns 934 ns 748128 -bm_call::via_function_ptr__Function::set_string 912 ns 911 ns 767505 -bm_call::via_function_ptr____Method::set_string 909 ns 909 ns 770254 +bm_call::via_function_ptr__Function::set_string 903 ns 903 ns 774622 +bm_call::via_function_ptr____Method::set_string 901 ns 901 ns 775359 -bm_std::function_calls__Function::set_string 911 ns 910 ns 771378 -bm_std::function_calls____Method::set_string 912 ns 912 ns 768127 +bm_std::function_calls__Function::set_string 904 ns 904 ns 774547 +bm_std::function_calls____Method::set_string 883 ns 883 ns 790621 -bm_rtl::function_calls__Function::set_string 911 ns 911 ns 768533 -bm_rtl::method_calls______Method::set_string 911 ns 911 ns 768158 +bm_rtl::function_calls__Function::set_string 902 ns 902 ns 774979 +bm_rtl::method_calls______Method::set_string 901 ns 900 ns 777221 -bm_rtl::function__ErasedReturnType::set_string 919 ns 919 ns 760767 -bm_rtl::method____ErasedReturnType::set_string 926 ns 926 ns 755851 -bm_rtl::method____ErasedTargetType::set_string 933 ns 932 ns 751905 -bm_rtl::method____ErasedTargetAndReturnType::set_string 931 ns 930 ns 751605 +bm_rtl::function__ErasedReturnType::set_string 919 ns 919 ns 763272 +bm_rtl::method____ErasedReturnType::set_string 895 ns 895 ns 782345 +bm_rtl::method____ErasedTargetType::set_string 924 ns 923 ns 759790 +bm_rtl::method____ErasedTargetAndReturnType::set_string 927 ns 927 ns 754650 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1174 ns 1174 ns 596533 +bm_call::direct__Function::get_string 1137 ns 1137 ns 617257 -bm_call::via_function_ptr__Function::get_string 1175 ns 1174 ns 596482 -bm_call::via_function_ptr____Method::get_string 1175 ns 1175 ns 595587 +bm_call::via_function_ptr__Function::get_string 1139 ns 1139 ns 614025 +bm_call::via_function_ptr____Method::get_string 1137 ns 1137 ns 615042 -bm_std::function_calls__Function::get_string 1174 ns 1173 ns 596838 -bm_std::function_calls____Method::get_string 1178 ns 1177 ns 594976 +bm_std::function_calls__Function::get_string 1134 ns 1134 ns 617301 +bm_std::function_calls____Method::get_string 1141 ns 1141 ns 614301 -bm_rtl::function_calls__Function::get_string 1174 ns 1173 ns 596710 -bm_rtl::method_calls______Method::get_string 1176 ns 1175 ns 596243 +bm_rtl::function_calls__Function::get_string 1135 ns 1134 ns 617395 +bm_rtl::method_calls______Method::get_string 1137 ns 1137 ns 616732 -bm_rtl::function__ErasedReturnType::get_string 1214 ns 1213 ns 577055 -bm_rtl::method____ErasedReturnType::get_string 1213 ns 1213 ns 577546 -bm_rtl::method____ErasedTargetType::get_string 1198 ns 1198 ns 584466 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1219 ns 1218 ns 574204 +bm_rtl::function__ErasedReturnType::get_string 1162 ns 1162 ns 601555 +bm_rtl::method____ErasedReturnType::get_string 1163 ns 1163 ns 602718 +bm_rtl::method____ErasedTargetType::get_string 1214 ns 1214 ns 577226 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1200 ns 1199 ns 572903 ----------------------------------- -[2025-11-04 11:40:27] >>> Run 2: workload scale = 50 +[2026-01-19 22:29:08] >>> Run 2: workload scale = 50 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 50 iterations ============================================= -2025-11-04T11:40:27+05:30 +2026-01-19T22:29:08+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 800 MHz CPU s) +Run on (16 X 4884.6 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.05, 0.97, 0.61 +Load Average: 1.00, 0.97, 0.65 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 943 ns 942 ns 737843 +bm_call::direct__Function::set_string 948 ns 948 ns 735867 -bm_call::via_function_ptr__Function::set_string 944 ns 943 ns 742177 -bm_call::via_function_ptr____Method::set_string 944 ns 944 ns 742264 +bm_call::via_function_ptr__Function::set_string 874 ns 874 ns 801342 +bm_call::via_function_ptr____Method::set_string 876 ns 876 ns 799863 -bm_std::function_calls__Function::set_string 944 ns 943 ns 743093 -bm_std::function_calls____Method::set_string 947 ns 946 ns 738334 +bm_std::function_calls__Function::set_string 875 ns 875 ns 798701 +bm_std::function_calls____Method::set_string 885 ns 885 ns 792333 -bm_rtl::function_calls__Function::set_string 944 ns 944 ns 741385 -bm_rtl::method_calls______Method::set_string 945 ns 944 ns 741519 +bm_rtl::function_calls__Function::set_string 874 ns 874 ns 800998 +bm_rtl::method_calls______Method::set_string 876 ns 875 ns 798915 -bm_rtl::function__ErasedReturnType::set_string 957 ns 956 ns 730993 -bm_rtl::method____ErasedReturnType::set_string 961 ns 961 ns 729195 -bm_rtl::method____ErasedTargetType::set_string 959 ns 958 ns 730421 -bm_rtl::method____ErasedTargetAndReturnType::set_string 967 ns 967 ns 723365 +bm_rtl::function__ErasedReturnType::set_string 888 ns 888 ns 789682 +bm_rtl::method____ErasedReturnType::set_string 888 ns 888 ns 788441 +bm_rtl::method____ErasedTargetType::set_string 894 ns 894 ns 783465 +bm_rtl::method____ErasedTargetAndReturnType::set_string 898 ns 898 ns 779245 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1259 ns 1259 ns 556770 +bm_call::direct__Function::get_string 1134 ns 1134 ns 618460 -bm_call::via_function_ptr__Function::get_string 1261 ns 1260 ns 554829 -bm_call::via_function_ptr____Method::get_string 1261 ns 1261 ns 555062 +bm_call::via_function_ptr__Function::get_string 1135 ns 1135 ns 615819 +bm_call::via_function_ptr____Method::get_string 1133 ns 1132 ns 614053 -bm_std::function_calls__Function::get_string 1261 ns 1260 ns 554486 -bm_std::function_calls____Method::get_string 1266 ns 1266 ns 553304 +bm_std::function_calls__Function::get_string 1133 ns 1133 ns 616594 +bm_std::function_calls____Method::get_string 1139 ns 1139 ns 614250 -bm_rtl::function_calls__Function::get_string 1261 ns 1260 ns 555273 -bm_rtl::method_calls______Method::get_string 1262 ns 1262 ns 554575 +bm_rtl::function_calls__Function::get_string 1133 ns 1133 ns 616500 +bm_rtl::method_calls______Method::get_string 1134 ns 1134 ns 618471 -bm_rtl::function__ErasedReturnType::get_string 1292 ns 1292 ns 541838 -bm_rtl::method____ErasedReturnType::get_string 1294 ns 1293 ns 541593 -bm_rtl::method____ErasedTargetType::get_string 1279 ns 1279 ns 546731 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1307 ns 1306 ns 536321 +bm_rtl::function__ErasedReturnType::get_string 1161 ns 1161 ns 603369 +bm_rtl::method____ErasedReturnType::get_string 1159 ns 1159 ns 603518 +bm_rtl::method____ErasedTargetType::get_string 1154 ns 1154 ns 607749 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1166 ns 1166 ns 598245 ----------------------------------- -[2025-11-04 11:40:46] >>> Run 3: workload scale = 50 +[2026-01-19 22:29:26] >>> Run 3: workload scale = 50 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 50 iterations ============================================= -2025-11-04T11:40:46+05:30 +2026-01-19T22:29:26+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1904,50 +1904,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.03, 0.97, 0.62 +Load Average: 1.00, 0.97, 0.66 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 913 ns 913 ns 765510 +bm_call::direct__Function::set_string 939 ns 939 ns 742183 -bm_call::via_function_ptr__Function::set_string 910 ns 909 ns 771256 -bm_call::via_function_ptr____Method::set_string 909 ns 908 ns 771309 +bm_call::via_function_ptr__Function::set_string 881 ns 881 ns 795159 +bm_call::via_function_ptr____Method::set_string 881 ns 881 ns 794504 -bm_std::function_calls__Function::set_string 908 ns 907 ns 770894 -bm_std::function_calls____Method::set_string 912 ns 912 ns 768112 +bm_std::function_calls__Function::set_string 882 ns 882 ns 793816 +bm_std::function_calls____Method::set_string 882 ns 882 ns 794659 -bm_rtl::function_calls__Function::set_string 907 ns 907 ns 770584 -bm_rtl::method_calls______Method::set_string 908 ns 908 ns 771993 +bm_rtl::function_calls__Function::set_string 881 ns 881 ns 795593 +bm_rtl::method_calls______Method::set_string 881 ns 881 ns 793528 -bm_rtl::function__ErasedReturnType::set_string 921 ns 921 ns 760196 -bm_rtl::method____ErasedReturnType::set_string 924 ns 923 ns 756860 -bm_rtl::method____ErasedTargetType::set_string 926 ns 926 ns 757342 -bm_rtl::method____ErasedTargetAndReturnType::set_string 929 ns 929 ns 754776 +bm_rtl::function__ErasedReturnType::set_string 891 ns 891 ns 785351 +bm_rtl::method____ErasedReturnType::set_string 911 ns 910 ns 770850 +bm_rtl::method____ErasedTargetType::set_string 895 ns 895 ns 780967 +bm_rtl::method____ErasedTargetAndReturnType::set_string 899 ns 899 ns 779662 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1174 ns 1173 ns 595250 +bm_call::direct__Function::get_string 1198 ns 1198 ns 584557 -bm_call::via_function_ptr__Function::get_string 1172 ns 1172 ns 597161 -bm_call::via_function_ptr____Method::get_string 1173 ns 1172 ns 597285 +bm_call::via_function_ptr__Function::get_string 1202 ns 1202 ns 583020 +bm_call::via_function_ptr____Method::get_string 1199 ns 1199 ns 583407 -bm_std::function_calls__Function::get_string 1173 ns 1172 ns 597217 -bm_std::function_calls____Method::get_string 1177 ns 1177 ns 595388 +bm_std::function_calls__Function::get_string 1199 ns 1199 ns 583877 +bm_std::function_calls____Method::get_string 1197 ns 1197 ns 584932 -bm_rtl::function_calls__Function::get_string 1172 ns 1171 ns 597813 -bm_rtl::method_calls______Method::get_string 1173 ns 1173 ns 596603 +bm_rtl::function_calls__Function::get_string 1199 ns 1199 ns 584180 +bm_rtl::method_calls______Method::get_string 1200 ns 1200 ns 583120 -bm_rtl::function__ErasedReturnType::get_string 1206 ns 1206 ns 580285 -bm_rtl::method____ErasedReturnType::get_string 1211 ns 1210 ns 578485 -bm_rtl::method____ErasedTargetType::get_string 1190 ns 1189 ns 588583 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1222 ns 1221 ns 573429 +bm_rtl::function__ErasedReturnType::get_string 1217 ns 1217 ns 574509 +bm_rtl::method____ErasedReturnType::get_string 1218 ns 1218 ns 573906 +bm_rtl::method____ErasedTargetType::get_string 1210 ns 1210 ns 579508 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1219 ns 1219 ns 575157 ----------------------------------- -[2025-11-04 11:41:04] >>> Run 1: workload scale = 58 +[2026-01-19 22:29:44] >>> Run 1: workload scale = 58 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 58 iterations ============================================= -2025-11-04T11:41:04+05:30 +2026-01-19T22:29:44+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -1955,101 +1955,101 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 0.97, 0.63 +Load Average: 1.00, 0.97, 0.67 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1032 ns 1031 ns 676070 +bm_call::direct__Function::set_string 1035 ns 1035 ns 674729 -bm_call::via_function_ptr__Function::set_string 1032 ns 1031 ns 678824 -bm_call::via_function_ptr____Method::set_string 1032 ns 1031 ns 678016 +bm_call::via_function_ptr__Function::set_string 1008 ns 1008 ns 693696 +bm_call::via_function_ptr____Method::set_string 1006 ns 1006 ns 696133 -bm_std::function_calls__Function::set_string 1031 ns 1031 ns 677827 -bm_std::function_calls____Method::set_string 1036 ns 1036 ns 674869 +bm_std::function_calls__Function::set_string 1008 ns 1008 ns 694435 +bm_std::function_calls____Method::set_string 1032 ns 1032 ns 677461 -bm_rtl::function_calls__Function::set_string 1030 ns 1029 ns 679752 -bm_rtl::method_calls______Method::set_string 1032 ns 1031 ns 678902 +bm_rtl::function_calls__Function::set_string 1008 ns 1008 ns 695440 +bm_rtl::method_calls______Method::set_string 1006 ns 1006 ns 695446 -bm_rtl::function__ErasedReturnType::set_string 1042 ns 1042 ns 671992 -bm_rtl::method____ErasedReturnType::set_string 1044 ns 1044 ns 669776 -bm_rtl::method____ErasedTargetType::set_string 1048 ns 1048 ns 669636 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1057 ns 1057 ns 662078 +bm_rtl::function__ErasedReturnType::set_string 1017 ns 1017 ns 688023 +bm_rtl::method____ErasedReturnType::set_string 1021 ns 1021 ns 684886 +bm_rtl::method____ErasedTargetType::set_string 1022 ns 1022 ns 685121 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1023 ns 1023 ns 685964 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1320 ns 1319 ns 530013 +bm_call::direct__Function::get_string 1283 ns 1283 ns 545681 -bm_call::via_function_ptr__Function::get_string 1320 ns 1319 ns 530104 -bm_call::via_function_ptr____Method::get_string 1322 ns 1321 ns 529144 +bm_call::via_function_ptr__Function::get_string 1289 ns 1289 ns 543451 +bm_call::via_function_ptr____Method::get_string 1289 ns 1289 ns 543536 -bm_std::function_calls__Function::get_string 1321 ns 1320 ns 530134 -bm_std::function_calls____Method::get_string 1328 ns 1327 ns 526957 +bm_std::function_calls__Function::get_string 1289 ns 1289 ns 543144 +bm_std::function_calls____Method::get_string 1289 ns 1289 ns 542843 -bm_rtl::function_calls__Function::get_string 1320 ns 1319 ns 530249 -bm_rtl::method_calls______Method::get_string 1323 ns 1322 ns 529609 +bm_rtl::function_calls__Function::get_string 1289 ns 1289 ns 543220 +bm_rtl::method_calls______Method::get_string 1288 ns 1288 ns 543490 -bm_rtl::function__ErasedReturnType::get_string 1362 ns 1361 ns 514888 -bm_rtl::method____ErasedReturnType::get_string 1368 ns 1367 ns 512162 -bm_rtl::method____ErasedTargetType::get_string 1334 ns 1334 ns 524950 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1372 ns 1371 ns 510495 +bm_rtl::function__ErasedReturnType::get_string 1310 ns 1310 ns 534100 +bm_rtl::method____ErasedReturnType::get_string 1310 ns 1310 ns 534021 +bm_rtl::method____ErasedTargetType::get_string 1300 ns 1300 ns 537670 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1314 ns 1314 ns 532015 ----------------------------------- -[2025-11-04 11:41:22] >>> Run 2: workload scale = 58 +[2026-01-19 22:30:02] >>> Run 2: workload scale = 58 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 58 iterations ============================================= -2025-11-04T11:41:22+05:30 +2026-01-19T22:30:02+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 820.226 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 0.97, 0.64 +Load Average: 1.07, 0.99, 0.68 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1031 ns 1031 ns 675121 +bm_call::direct__Function::set_string 1032 ns 1032 ns 678112 -bm_call::via_function_ptr__Function::set_string 1031 ns 1030 ns 679015 -bm_call::via_function_ptr____Method::set_string 1032 ns 1031 ns 679476 +bm_call::via_function_ptr__Function::set_string 996 ns 995 ns 702900 +bm_call::via_function_ptr____Method::set_string 994 ns 994 ns 706621 -bm_std::function_calls__Function::set_string 1031 ns 1031 ns 677910 -bm_std::function_calls____Method::set_string 1041 ns 1041 ns 670513 +bm_std::function_calls__Function::set_string 997 ns 997 ns 702773 +bm_std::function_calls____Method::set_string 1018 ns 1018 ns 687379 -bm_rtl::function_calls__Function::set_string 1032 ns 1031 ns 680773 -bm_rtl::method_calls______Method::set_string 1032 ns 1032 ns 679489 +bm_rtl::function_calls__Function::set_string 996 ns 996 ns 704180 +bm_rtl::method_calls______Method::set_string 994 ns 994 ns 704523 -bm_rtl::function__ErasedReturnType::set_string 1042 ns 1041 ns 671509 -bm_rtl::method____ErasedReturnType::set_string 1046 ns 1045 ns 668786 -bm_rtl::method____ErasedTargetType::set_string 1051 ns 1050 ns 668456 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1051 ns 1051 ns 665655 +bm_rtl::function__ErasedReturnType::set_string 1009 ns 1009 ns 694404 +bm_rtl::method____ErasedReturnType::set_string 1011 ns 1011 ns 692029 +bm_rtl::method____ErasedTargetType::set_string 1011 ns 1011 ns 691866 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1015 ns 1015 ns 689500 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1321 ns 1320 ns 529589 +bm_call::direct__Function::get_string 1289 ns 1289 ns 542977 -bm_call::via_function_ptr__Function::get_string 1319 ns 1319 ns 527334 -bm_call::via_function_ptr____Method::get_string 1321 ns 1320 ns 530323 +bm_call::via_function_ptr__Function::get_string 1293 ns 1293 ns 540961 +bm_call::via_function_ptr____Method::get_string 1292 ns 1292 ns 541764 -bm_std::function_calls__Function::get_string 1321 ns 1320 ns 530845 -bm_std::function_calls____Method::get_string 1330 ns 1329 ns 526538 +bm_std::function_calls__Function::get_string 1294 ns 1294 ns 540441 +bm_std::function_calls____Method::get_string 1296 ns 1296 ns 540693 -bm_rtl::function_calls__Function::get_string 1320 ns 1320 ns 531222 -bm_rtl::method_calls______Method::get_string 1321 ns 1320 ns 530152 +bm_rtl::function_calls__Function::get_string 1294 ns 1294 ns 540763 +bm_rtl::method_calls______Method::get_string 1293 ns 1293 ns 542121 -bm_rtl::function__ErasedReturnType::get_string 1361 ns 1361 ns 514252 -bm_rtl::method____ErasedReturnType::get_string 1362 ns 1362 ns 510922 -bm_rtl::method____ErasedTargetType::get_string 1338 ns 1337 ns 523350 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1371 ns 1370 ns 512355 +bm_rtl::function__ErasedReturnType::get_string 1314 ns 1314 ns 532124 +bm_rtl::method____ErasedReturnType::get_string 1312 ns 1312 ns 533500 +bm_rtl::method____ErasedTargetType::get_string 1305 ns 1305 ns 536094 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1316 ns 1316 ns 531529 ----------------------------------- -[2025-11-04 11:41:40] >>> Run 3: workload scale = 58 +[2026-01-19 22:30:20] >>> Run 3: workload scale = 58 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 58 iterations ============================================= -2025-11-04T11:41:40+05:30 +2026-01-19T22:30:20+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2057,50 +2057,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 0.98, 0.64 +Load Average: 1.06, 0.99, 0.69 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1017 ns 1027 ns 679622 +bm_call::direct__Function::set_string 1034 ns 1034 ns 675093 -bm_call::via_function_ptr__Function::set_string 1015 ns 1029 ns 680787 -bm_call::via_function_ptr____Method::set_string 1016 ns 1029 ns 679486 +bm_call::via_function_ptr__Function::set_string 1003 ns 1003 ns 697584 +bm_call::via_function_ptr____Method::set_string 1002 ns 1002 ns 697925 -bm_std::function_calls__Function::set_string 1018 ns 1030 ns 680557 -bm_std::function_calls____Method::set_string 1030 ns 1040 ns 672817 +bm_std::function_calls__Function::set_string 1004 ns 1004 ns 696678 +bm_std::function_calls____Method::set_string 1007 ns 1007 ns 693877 -bm_rtl::function_calls__Function::set_string 1019 ns 1028 ns 680440 -bm_rtl::method_calls______Method::set_string 1021 ns 1030 ns 679426 +bm_rtl::function_calls__Function::set_string 1004 ns 1004 ns 697377 +bm_rtl::method_calls______Method::set_string 1003 ns 1003 ns 698516 -bm_rtl::function__ErasedReturnType::set_string 1033 ns 1041 ns 669612 -bm_rtl::method____ErasedReturnType::set_string 1033 ns 1041 ns 673638 -bm_rtl::method____ErasedTargetType::set_string 1044 ns 1050 ns 668898 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1043 ns 1049 ns 667070 +bm_rtl::function__ErasedReturnType::set_string 1018 ns 1018 ns 687788 +bm_rtl::method____ErasedReturnType::set_string 1034 ns 1034 ns 677095 +bm_rtl::method____ErasedTargetType::set_string 1020 ns 1020 ns 686724 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1026 ns 1026 ns 681885 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1315 ns 1321 ns 530349 +bm_call::direct__Function::get_string 1365 ns 1365 ns 512813 -bm_call::via_function_ptr__Function::get_string 1313 ns 1319 ns 530447 -bm_call::via_function_ptr____Method::get_string 1314 ns 1320 ns 529779 +bm_call::via_function_ptr__Function::get_string 1366 ns 1366 ns 512341 +bm_call::via_function_ptr____Method::get_string 1365 ns 1365 ns 512596 -bm_std::function_calls__Function::get_string 1317 ns 1322 ns 530934 -bm_std::function_calls____Method::get_string 1321 ns 1326 ns 527723 +bm_std::function_calls__Function::get_string 1366 ns 1366 ns 512693 +bm_std::function_calls____Method::get_string 1368 ns 1368 ns 511225 -bm_rtl::function_calls__Function::get_string 1317 ns 1321 ns 530957 -bm_rtl::method_calls______Method::get_string 1316 ns 1320 ns 530817 +bm_rtl::function_calls__Function::get_string 1366 ns 1366 ns 512277 +bm_rtl::method_calls______Method::get_string 1364 ns 1364 ns 512854 -bm_rtl::function__ErasedReturnType::get_string 1354 ns 1357 ns 515832 -bm_rtl::method____ErasedReturnType::get_string 1358 ns 1361 ns 508856 -bm_rtl::method____ErasedTargetType::get_string 1336 ns 1339 ns 522359 -bm_rtl::method____ErasedTargetAndReturnType::get_string 1363 ns 1366 ns 511858 +bm_rtl::function__ErasedReturnType::get_string 1388 ns 1388 ns 504445 +bm_rtl::method____ErasedReturnType::get_string 1387 ns 1387 ns 505198 +bm_rtl::method____ErasedTargetType::get_string 1379 ns 1379 ns 507994 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1392 ns 1392 ns 502637 ----------------------------------- -[2025-11-04 11:41:58] >>> Run 1: workload scale = 66 +[2026-01-19 22:30:38] >>> Run 1: workload scale = 66 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 66 iterations ============================================= -2025-11-04T11:41:58+05:30 +2026-01-19T22:30:38+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2108,50 +2108,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.08, 0.99, 0.66 +Load Average: 1.04, 0.99, 0.69 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1657 ns 1660 ns 421772 +bm_call::direct__Function::set_string 1636 ns 1636 ns 427486 -bm_call::via_function_ptr__Function::set_string 1659 ns 1661 ns 421261 -bm_call::via_function_ptr____Method::set_string 1657 ns 1659 ns 421660 +bm_call::via_function_ptr__Function::set_string 1628 ns 1628 ns 430101 +bm_call::via_function_ptr____Method::set_string 1629 ns 1629 ns 430065 -bm_std::function_calls__Function::set_string 1659 ns 1661 ns 421457 -bm_std::function_calls____Method::set_string 1664 ns 1666 ns 417619 +bm_std::function_calls__Function::set_string 1628 ns 1628 ns 429723 +bm_std::function_calls____Method::set_string 1649 ns 1649 ns 424517 -bm_rtl::function_calls__Function::set_string 1655 ns 1657 ns 421767 -bm_rtl::method_calls______Method::set_string 1660 ns 1662 ns 421804 +bm_rtl::function_calls__Function::set_string 1627 ns 1627 ns 430133 +bm_rtl::method_calls______Method::set_string 1628 ns 1628 ns 430349 -bm_rtl::function__ErasedReturnType::set_string 1653 ns 1655 ns 418490 -bm_rtl::method____ErasedReturnType::set_string 1662 ns 1663 ns 424133 -bm_rtl::method____ErasedTargetType::set_string 1675 ns 1677 ns 417375 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1698 ns 1699 ns 412042 +bm_rtl::function__ErasedReturnType::set_string 1640 ns 1640 ns 427551 +bm_rtl::method____ErasedReturnType::set_string 1646 ns 1646 ns 425782 +bm_rtl::method____ErasedTargetType::set_string 1646 ns 1646 ns 425327 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1655 ns 1655 ns 423077 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2033 ns 2035 ns 343824 +bm_call::direct__Function::get_string 1990 ns 1990 ns 351983 -bm_call::via_function_ptr__Function::get_string 2029 ns 2030 ns 344946 -bm_call::via_function_ptr____Method::get_string 2029 ns 2030 ns 344269 +bm_call::via_function_ptr__Function::get_string 1992 ns 1992 ns 351406 +bm_call::via_function_ptr____Method::get_string 1992 ns 1992 ns 351688 -bm_std::function_calls__Function::get_string 2029 ns 2030 ns 344471 -bm_std::function_calls____Method::get_string 2037 ns 2038 ns 344001 +bm_std::function_calls__Function::get_string 1993 ns 1993 ns 351092 +bm_std::function_calls____Method::get_string 1997 ns 1997 ns 350755 -bm_rtl::function_calls__Function::get_string 2032 ns 2030 ns 344558 -bm_rtl::method_calls______Method::get_string 2034 ns 2032 ns 345067 +bm_rtl::function_calls__Function::get_string 1994 ns 1993 ns 350789 +bm_rtl::method_calls______Method::get_string 1991 ns 1990 ns 351526 -bm_rtl::function__ErasedReturnType::get_string 2076 ns 2075 ns 337071 -bm_rtl::method____ErasedReturnType::get_string 2082 ns 2080 ns 336215 -bm_rtl::method____ErasedTargetType::get_string 2049 ns 2048 ns 342138 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2085 ns 2083 ns 336181 +bm_rtl::function__ErasedReturnType::get_string 2012 ns 2012 ns 348023 +bm_rtl::method____ErasedReturnType::get_string 2014 ns 2014 ns 347409 +bm_rtl::method____ErasedTargetType::get_string 2006 ns 2006 ns 349290 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2017 ns 2017 ns 347043 ----------------------------------- -[2025-11-04 11:42:18] >>> Run 2: workload scale = 66 +[2026-01-19 22:30:58] >>> Run 2: workload scale = 66 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 66 iterations ============================================= -2025-11-04T11:42:18+05:30 +2026-01-19T22:30:58+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2159,50 +2159,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.05, 1.00, 0.67 +Load Average: 1.03, 1.00, 0.70 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1668 ns 1666 ns 420591 +bm_call::direct__Function::set_string 1633 ns 1632 ns 428557 -bm_call::via_function_ptr__Function::set_string 1666 ns 1665 ns 420519 -bm_call::via_function_ptr____Method::set_string 1665 ns 1664 ns 420393 +bm_call::via_function_ptr__Function::set_string 1638 ns 1638 ns 427508 +bm_call::via_function_ptr____Method::set_string 1637 ns 1637 ns 427652 -bm_std::function_calls__Function::set_string 1666 ns 1665 ns 420597 -bm_std::function_calls____Method::set_string 1670 ns 1669 ns 418433 +bm_std::function_calls__Function::set_string 1639 ns 1639 ns 424126 +bm_std::function_calls____Method::set_string 1655 ns 1654 ns 423338 -bm_rtl::function_calls__Function::set_string 1661 ns 1660 ns 421384 -bm_rtl::method_calls______Method::set_string 1664 ns 1663 ns 421078 +bm_rtl::function_calls__Function::set_string 1640 ns 1640 ns 427633 +bm_rtl::method_calls______Method::set_string 1637 ns 1637 ns 427542 -bm_rtl::function__ErasedReturnType::set_string 1674 ns 1674 ns 418103 -bm_rtl::method____ErasedReturnType::set_string 1676 ns 1676 ns 417778 -bm_rtl::method____ErasedTargetType::set_string 1681 ns 1680 ns 417245 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1684 ns 1683 ns 415930 +bm_rtl::function__ErasedReturnType::set_string 1651 ns 1651 ns 424262 +bm_rtl::method____ErasedReturnType::set_string 1654 ns 1654 ns 423134 +bm_rtl::method____ErasedTargetType::set_string 1653 ns 1653 ns 424141 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1655 ns 1655 ns 423152 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 1986 ns 1985 ns 352254 +bm_call::direct__Function::get_string 1929 ns 1929 ns 363024 -bm_call::via_function_ptr__Function::get_string 1987 ns 1986 ns 352702 -bm_call::via_function_ptr____Method::get_string 1988 ns 1988 ns 352071 +bm_call::via_function_ptr__Function::get_string 1930 ns 1930 ns 360634 +bm_call::via_function_ptr____Method::get_string 1928 ns 1927 ns 363245 -bm_std::function_calls__Function::get_string 1987 ns 1986 ns 352640 -bm_std::function_calls____Method::get_string 1993 ns 1993 ns 350926 +bm_std::function_calls__Function::get_string 1934 ns 1934 ns 362508 +bm_std::function_calls____Method::get_string 1933 ns 1933 ns 362322 -bm_rtl::function_calls__Function::get_string 1986 ns 1986 ns 352094 -bm_rtl::method_calls______Method::get_string 1989 ns 1989 ns 351886 +bm_rtl::function_calls__Function::get_string 1933 ns 1933 ns 362483 +bm_rtl::method_calls______Method::get_string 1927 ns 1927 ns 362975 -bm_rtl::function__ErasedReturnType::get_string 2027 ns 2027 ns 345297 -bm_rtl::method____ErasedReturnType::get_string 2029 ns 2029 ns 345232 -bm_rtl::method____ErasedTargetType::get_string 2004 ns 2004 ns 349685 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2034 ns 2034 ns 344459 +bm_rtl::function__ErasedReturnType::get_string 1955 ns 1955 ns 358477 +bm_rtl::method____ErasedReturnType::get_string 1954 ns 1954 ns 358280 +bm_rtl::method____ErasedTargetType::get_string 1948 ns 1948 ns 359867 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1956 ns 1955 ns 357971 ----------------------------------- -[2025-11-04 11:42:38] >>> Run 3: workload scale = 66 +[2026-01-19 22:31:18] >>> Run 3: workload scale = 66 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 66 iterations ============================================= -2025-11-04T11:42:38+05:30 +2026-01-19T22:31:18+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2210,50 +2210,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 1.00, 0.67 +Load Average: 1.02, 1.00, 0.71 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1656 ns 1656 ns 419723 +bm_call::direct__Function::set_string 1645 ns 1644 ns 425112 -bm_call::via_function_ptr__Function::set_string 1655 ns 1655 ns 422991 -bm_call::via_function_ptr____Method::set_string 1657 ns 1657 ns 422611 +bm_call::via_function_ptr__Function::set_string 1637 ns 1637 ns 426452 +bm_call::via_function_ptr____Method::set_string 1634 ns 1634 ns 428366 -bm_std::function_calls__Function::set_string 1656 ns 1656 ns 422654 -bm_std::function_calls____Method::set_string 1671 ns 1671 ns 419437 +bm_std::function_calls__Function::set_string 1638 ns 1638 ns 428140 +bm_std::function_calls____Method::set_string 1643 ns 1643 ns 426062 -bm_rtl::function_calls__Function::set_string 1653 ns 1653 ns 423328 -bm_rtl::method_calls______Method::set_string 1658 ns 1658 ns 422855 +bm_rtl::function_calls__Function::set_string 1637 ns 1636 ns 427885 +bm_rtl::method_calls______Method::set_string 1627 ns 1627 ns 430136 -bm_rtl::function__ErasedReturnType::set_string 1671 ns 1671 ns 418940 -bm_rtl::method____ErasedReturnType::set_string 1672 ns 1672 ns 418670 -bm_rtl::method____ErasedTargetType::set_string 1678 ns 1678 ns 415373 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1679 ns 1679 ns 416931 +bm_rtl::function__ErasedReturnType::set_string 1649 ns 1649 ns 424893 +bm_rtl::method____ErasedReturnType::set_string 1654 ns 1654 ns 420943 +bm_rtl::method____ErasedTargetType::set_string 1647 ns 1647 ns 424746 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1652 ns 1652 ns 424812 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2035 ns 2036 ns 344330 +bm_call::direct__Function::get_string 1924 ns 1924 ns 363906 -bm_call::via_function_ptr__Function::get_string 2031 ns 2032 ns 344346 -bm_call::via_function_ptr____Method::get_string 2034 ns 2035 ns 344556 +bm_call::via_function_ptr__Function::get_string 1928 ns 1928 ns 363891 +bm_call::via_function_ptr____Method::get_string 1923 ns 1923 ns 364281 -bm_std::function_calls__Function::get_string 2033 ns 2033 ns 344441 -bm_std::function_calls____Method::get_string 2040 ns 2041 ns 343498 +bm_std::function_calls__Function::get_string 1928 ns 1928 ns 363618 +bm_std::function_calls____Method::get_string 1927 ns 1927 ns 362893 -bm_rtl::function_calls__Function::get_string 2032 ns 2032 ns 344410 -bm_rtl::method_calls______Method::get_string 2035 ns 2035 ns 344515 +bm_rtl::function_calls__Function::get_string 1928 ns 1928 ns 363817 +bm_rtl::method_calls______Method::get_string 1923 ns 1923 ns 363994 -bm_rtl::function__ErasedReturnType::get_string 2076 ns 2077 ns 336831 -bm_rtl::method____ErasedReturnType::get_string 2077 ns 2077 ns 336922 -bm_rtl::method____ErasedTargetType::get_string 2049 ns 2049 ns 340087 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2083 ns 2084 ns 336074 +bm_rtl::function__ErasedReturnType::get_string 1949 ns 1948 ns 359235 +bm_rtl::method____ErasedReturnType::get_string 1949 ns 1949 ns 357588 +bm_rtl::method____ErasedTargetType::get_string 1942 ns 1942 ns 360625 +bm_rtl::method____ErasedTargetAndReturnType::get_string 1951 ns 1951 ns 359255 ----------------------------------- -[2025-11-04 11:42:58] >>> Run 1: workload scale = 74 +[2026-01-19 22:31:38] >>> Run 1: workload scale = 74 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 74 iterations ============================================= -2025-11-04T11:42:58+05:30 +2026-01-19T22:31:38+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2261,50 +2261,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.03, 1.00, 0.68 +Load Average: 1.01, 1.00, 0.72 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1702 ns 1702 ns 410993 +bm_call::direct__Function::set_string 1704 ns 1704 ns 410694 -bm_call::via_function_ptr__Function::set_string 1700 ns 1701 ns 411578 -bm_call::via_function_ptr____Method::set_string 1701 ns 1701 ns 411305 +bm_call::via_function_ptr__Function::set_string 1719 ns 1718 ns 407996 +bm_call::via_function_ptr____Method::set_string 1716 ns 1716 ns 407893 -bm_std::function_calls__Function::set_string 1703 ns 1704 ns 410550 -bm_std::function_calls____Method::set_string 1706 ns 1706 ns 410063 +bm_std::function_calls__Function::set_string 1719 ns 1719 ns 407912 +bm_std::function_calls____Method::set_string 1725 ns 1725 ns 405488 -bm_rtl::function_calls__Function::set_string 1699 ns 1699 ns 412192 -bm_rtl::method_calls______Method::set_string 1700 ns 1701 ns 412000 +bm_rtl::function_calls__Function::set_string 1715 ns 1715 ns 407851 +bm_rtl::method_calls______Method::set_string 1717 ns 1716 ns 405912 -bm_rtl::function__ErasedReturnType::set_string 1739 ns 1739 ns 401572 -bm_rtl::method____ErasedReturnType::set_string 1724 ns 1725 ns 405479 -bm_rtl::method____ErasedTargetType::set_string 1726 ns 1727 ns 405687 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1775 ns 1776 ns 393707 +bm_rtl::function__ErasedReturnType::set_string 1729 ns 1729 ns 405040 +bm_rtl::method____ErasedReturnType::set_string 1749 ns 1749 ns 400776 +bm_rtl::method____ErasedTargetType::set_string 1731 ns 1731 ns 404458 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1742 ns 1741 ns 402397 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2054 ns 2054 ns 340080 +bm_call::direct__Function::get_string 2149 ns 2148 ns 325819 -bm_call::via_function_ptr__Function::get_string 2054 ns 2055 ns 340747 -bm_call::via_function_ptr____Method::get_string 2056 ns 2056 ns 340564 +bm_call::via_function_ptr__Function::get_string 2155 ns 2155 ns 325341 +bm_call::via_function_ptr____Method::get_string 2152 ns 2151 ns 325266 -bm_std::function_calls__Function::get_string 2054 ns 2055 ns 340353 -bm_std::function_calls____Method::get_string 2064 ns 2065 ns 339177 +bm_std::function_calls__Function::get_string 2155 ns 2155 ns 324846 +bm_std::function_calls____Method::get_string 2158 ns 2158 ns 324258 -bm_rtl::function_calls__Function::get_string 2059 ns 2060 ns 340492 -bm_rtl::method_calls______Method::get_string 2056 ns 2057 ns 339582 +bm_rtl::function_calls__Function::get_string 2152 ns 2152 ns 325164 +bm_rtl::method_calls______Method::get_string 2151 ns 2151 ns 323536 -bm_rtl::function__ErasedReturnType::get_string 2106 ns 2106 ns 331861 -bm_rtl::method____ErasedReturnType::get_string 2146 ns 2147 ns 326249 -bm_rtl::method____ErasedTargetType::get_string 2091 ns 2092 ns 334710 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2116 ns 2116 ns 330808 +bm_rtl::function__ErasedReturnType::get_string 2180 ns 2180 ns 321132 +bm_rtl::method____ErasedReturnType::get_string 2184 ns 2184 ns 320612 +bm_rtl::method____ErasedTargetType::get_string 2170 ns 2170 ns 322408 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2191 ns 2191 ns 320089 ----------------------------------- -[2025-11-04 11:43:18] >>> Run 2: workload scale = 74 +[2026-01-19 22:31:58] >>> Run 2: workload scale = 74 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 74 iterations ============================================= -2025-11-04T11:43:18+05:30 +2026-01-19T22:31:58+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2312,50 +2312,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 1.00, 0.69 +Load Average: 1.01, 1.00, 0.73 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1705 ns 1706 ns 410050 +bm_call::direct__Function::set_string 1687 ns 1687 ns 414957 -bm_call::via_function_ptr__Function::set_string 1703 ns 1703 ns 411193 -bm_call::via_function_ptr____Method::set_string 1704 ns 1704 ns 410529 +bm_call::via_function_ptr__Function::set_string 1692 ns 1692 ns 414692 +bm_call::via_function_ptr____Method::set_string 1690 ns 1690 ns 414379 -bm_std::function_calls__Function::set_string 1703 ns 1703 ns 411017 -bm_std::function_calls____Method::set_string 1713 ns 1713 ns 408256 +bm_std::function_calls__Function::set_string 1692 ns 1692 ns 414244 +bm_std::function_calls____Method::set_string 1697 ns 1697 ns 412772 -bm_rtl::function_calls__Function::set_string 1702 ns 1702 ns 410861 -bm_rtl::method_calls______Method::set_string 1702 ns 1703 ns 411267 +bm_rtl::function_calls__Function::set_string 1689 ns 1688 ns 414394 +bm_rtl::method_calls______Method::set_string 1691 ns 1690 ns 410590 -bm_rtl::function__ErasedReturnType::set_string 1758 ns 1759 ns 398120 -bm_rtl::method____ErasedReturnType::set_string 1746 ns 1747 ns 400302 -bm_rtl::method____ErasedTargetType::set_string 1738 ns 1739 ns 403136 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1717 ns 1718 ns 406824 +bm_rtl::function__ErasedReturnType::set_string 1700 ns 1699 ns 412056 +bm_rtl::method____ErasedReturnType::set_string 1723 ns 1722 ns 406836 +bm_rtl::method____ErasedTargetType::set_string 1700 ns 1700 ns 411498 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1704 ns 1704 ns 411937 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2062 ns 2062 ns 339419 +bm_call::direct__Function::get_string 2042 ns 2042 ns 342973 -bm_call::via_function_ptr__Function::get_string 2062 ns 2063 ns 339231 -bm_call::via_function_ptr____Method::get_string 2064 ns 2065 ns 339106 +bm_call::via_function_ptr__Function::get_string 2047 ns 2046 ns 341626 +bm_call::via_function_ptr____Method::get_string 2048 ns 2048 ns 341905 -bm_std::function_calls__Function::get_string 2062 ns 2063 ns 339570 -bm_std::function_calls____Method::get_string 2070 ns 2070 ns 338163 +bm_std::function_calls__Function::get_string 2047 ns 2047 ns 341688 +bm_std::function_calls____Method::get_string 2049 ns 2049 ns 341249 -bm_rtl::function_calls__Function::get_string 2064 ns 2065 ns 338796 -bm_rtl::method_calls______Method::get_string 2065 ns 2066 ns 339087 +bm_rtl::function_calls__Function::get_string 2047 ns 2046 ns 342026 +bm_rtl::method_calls______Method::get_string 2047 ns 2047 ns 340194 -bm_rtl::function__ErasedReturnType::get_string 2105 ns 2106 ns 332120 -bm_rtl::method____ErasedReturnType::get_string 2100 ns 2100 ns 333314 -bm_rtl::method____ErasedTargetType::get_string 2095 ns 2096 ns 333978 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2105 ns 2106 ns 332620 +bm_rtl::function__ErasedReturnType::get_string 2071 ns 2071 ns 338168 +bm_rtl::method____ErasedReturnType::get_string 2070 ns 2070 ns 338474 +bm_rtl::method____ErasedTargetType::get_string 2065 ns 2065 ns 339303 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2075 ns 2075 ns 337545 ----------------------------------- -[2025-11-04 11:43:38] >>> Run 3: workload scale = 74 +[2026-01-19 22:32:18] >>> Run 3: workload scale = 74 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 74 iterations ============================================= -2025-11-04T11:43:38+05:30 +2026-01-19T22:32:18+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2363,50 +2363,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.08, 1.02, 0.70 +Load Average: 1.00, 1.00, 0.73 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1725 ns 1726 ns 406312 +bm_call::direct__Function::set_string 1713 ns 1713 ns 408838 -bm_call::via_function_ptr__Function::set_string 1726 ns 1726 ns 405636 -bm_call::via_function_ptr____Method::set_string 1727 ns 1727 ns 405754 +bm_call::via_function_ptr__Function::set_string 1737 ns 1737 ns 402892 +bm_call::via_function_ptr____Method::set_string 1736 ns 1736 ns 403689 -bm_std::function_calls__Function::set_string 1724 ns 1725 ns 405818 -bm_std::function_calls____Method::set_string 1731 ns 1731 ns 404376 +bm_std::function_calls__Function::set_string 1738 ns 1738 ns 403157 +bm_std::function_calls____Method::set_string 1757 ns 1757 ns 394167 -bm_rtl::function_calls__Function::set_string 1726 ns 1726 ns 402702 -bm_rtl::method_calls______Method::set_string 1725 ns 1725 ns 406029 +bm_rtl::function_calls__Function::set_string 1736 ns 1736 ns 403487 +bm_rtl::method_calls______Method::set_string 1738 ns 1738 ns 403093 -bm_rtl::function__ErasedReturnType::set_string 1734 ns 1734 ns 403830 -bm_rtl::method____ErasedReturnType::set_string 1736 ns 1736 ns 403200 -bm_rtl::method____ErasedTargetType::set_string 1741 ns 1742 ns 402231 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1741 ns 1742 ns 401846 +bm_rtl::function__ErasedReturnType::set_string 1718 ns 1718 ns 407569 +bm_rtl::method____ErasedReturnType::set_string 1728 ns 1728 ns 405368 +bm_rtl::method____ErasedTargetType::set_string 1709 ns 1709 ns 409316 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1722 ns 1722 ns 406715 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2091 ns 2092 ns 334903 +bm_call::direct__Function::get_string 2169 ns 2169 ns 322266 -bm_call::via_function_ptr__Function::get_string 2087 ns 2087 ns 335367 -bm_call::via_function_ptr____Method::get_string 2090 ns 2090 ns 335217 +bm_call::via_function_ptr__Function::get_string 2173 ns 2173 ns 322587 +bm_call::via_function_ptr____Method::get_string 2174 ns 2173 ns 321966 -bm_std::function_calls__Function::get_string 2087 ns 2087 ns 335223 -bm_std::function_calls____Method::get_string 2093 ns 2094 ns 334231 +bm_std::function_calls__Function::get_string 2174 ns 2174 ns 321859 +bm_std::function_calls____Method::get_string 2190 ns 2190 ns 319040 -bm_rtl::function_calls__Function::get_string 2087 ns 2088 ns 333794 -bm_rtl::method_calls______Method::get_string 2089 ns 2089 ns 335209 +bm_rtl::function_calls__Function::get_string 2174 ns 2174 ns 321952 +bm_rtl::method_calls______Method::get_string 2174 ns 2174 ns 322166 -bm_rtl::function__ErasedReturnType::get_string 2130 ns 2130 ns 328921 -bm_rtl::method____ErasedReturnType::get_string 2131 ns 2131 ns 328695 -bm_rtl::method____ErasedTargetType::get_string 2109 ns 2110 ns 332174 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2139 ns 2140 ns 327151 +bm_rtl::function__ErasedReturnType::get_string 2154 ns 2154 ns 324962 +bm_rtl::method____ErasedReturnType::get_string 2156 ns 2156 ns 324748 +bm_rtl::method____ErasedTargetType::get_string 2144 ns 2144 ns 326407 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2163 ns 2163 ns 323836 ----------------------------------- -[2025-11-04 11:43:58] >>> Run 1: workload scale = 82 +[2026-01-19 22:32:38] >>> Run 1: workload scale = 82 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 82 iterations ============================================= -2025-11-04T11:43:58+05:30 +2026-01-19T22:32:38+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2414,152 +2414,152 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.06, 1.01, 0.71 +Load Average: 1.00, 1.00, 0.74 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1797 ns 1797 ns 389525 +bm_call::direct__Function::set_string 1789 ns 1789 ns 391131 -bm_call::via_function_ptr__Function::set_string 1798 ns 1798 ns 389536 -bm_call::via_function_ptr____Method::set_string 1798 ns 1798 ns 389365 +bm_call::via_function_ptr__Function::set_string 1763 ns 1763 ns 397562 +bm_call::via_function_ptr____Method::set_string 1761 ns 1760 ns 397612 -bm_std::function_calls__Function::set_string 1800 ns 1801 ns 389607 -bm_std::function_calls____Method::set_string 1829 ns 1830 ns 386984 +bm_std::function_calls__Function::set_string 1761 ns 1761 ns 397459 +bm_std::function_calls____Method::set_string 1766 ns 1765 ns 395213 -bm_rtl::function_calls__Function::set_string 1810 ns 1810 ns 380113 -bm_rtl::method_calls______Method::set_string 1798 ns 1799 ns 389381 +bm_rtl::function_calls__Function::set_string 1761 ns 1761 ns 397571 +bm_rtl::method_calls______Method::set_string 1765 ns 1764 ns 397363 -bm_rtl::function__ErasedReturnType::set_string 1802 ns 1803 ns 388635 -bm_rtl::method____ErasedReturnType::set_string 1803 ns 1803 ns 388548 -bm_rtl::method____ErasedTargetType::set_string 1811 ns 1812 ns 386464 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1810 ns 1811 ns 386941 +bm_rtl::function__ErasedReturnType::set_string 1769 ns 1769 ns 395691 +bm_rtl::method____ErasedReturnType::set_string 1771 ns 1771 ns 395643 +bm_rtl::method____ErasedTargetType::set_string 1770 ns 1770 ns 395133 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1774 ns 1774 ns 395280 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2284 ns 2285 ns 306552 +bm_call::direct__Function::get_string 2245 ns 2244 ns 311980 -bm_call::via_function_ptr__Function::get_string 2283 ns 2284 ns 306654 -bm_call::via_function_ptr____Method::get_string 2286 ns 2286 ns 306173 +bm_call::via_function_ptr__Function::get_string 2248 ns 2248 ns 312148 +bm_call::via_function_ptr____Method::get_string 2246 ns 2246 ns 311894 -bm_std::function_calls__Function::get_string 2283 ns 2284 ns 306482 -bm_std::function_calls____Method::get_string 2290 ns 2290 ns 305618 +bm_std::function_calls__Function::get_string 2246 ns 2246 ns 311496 +bm_std::function_calls____Method::get_string 2262 ns 2261 ns 309168 -bm_rtl::function_calls__Function::get_string 2283 ns 2284 ns 306531 -bm_rtl::method_calls______Method::get_string 2285 ns 2285 ns 306323 +bm_rtl::function_calls__Function::get_string 2244 ns 2244 ns 311773 +bm_rtl::method_calls______Method::get_string 2248 ns 2248 ns 310230 -bm_rtl::function__ErasedReturnType::get_string 2326 ns 2327 ns 300755 -bm_rtl::method____ErasedReturnType::get_string 2325 ns 2325 ns 300885 -bm_rtl::method____ErasedTargetType::get_string 2310 ns 2311 ns 302696 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2330 ns 2330 ns 300284 +bm_rtl::function__ErasedReturnType::get_string 2282 ns 2282 ns 306813 +bm_rtl::method____ErasedReturnType::get_string 2290 ns 2290 ns 305848 +bm_rtl::method____ErasedTargetType::get_string 2274 ns 2274 ns 307761 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2290 ns 2290 ns 305896 ----------------------------------- -[2025-11-04 11:44:19] >>> Run 2: workload scale = 82 +[2026-01-19 22:32:59] >>> Run 2: workload scale = 82 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 82 iterations ============================================= -2025-11-04T11:44:19+05:30 +2026-01-19T22:32:59+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 851.313 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.10, 1.03, 0.72 +Load Average: 1.00, 1.00, 0.74 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1778 ns 1778 ns 393555 +bm_call::direct__Function::set_string 1778 ns 1778 ns 393210 -bm_call::via_function_ptr__Function::set_string 1783 ns 1783 ns 393270 -bm_call::via_function_ptr____Method::set_string 1785 ns 1785 ns 392516 +bm_call::via_function_ptr__Function::set_string 1748 ns 1748 ns 399918 +bm_call::via_function_ptr____Method::set_string 1747 ns 1747 ns 400516 -bm_std::function_calls__Function::set_string 1782 ns 1783 ns 393411 -bm_std::function_calls____Method::set_string 1789 ns 1789 ns 391871 +bm_std::function_calls__Function::set_string 1750 ns 1750 ns 400672 +bm_std::function_calls____Method::set_string 1755 ns 1755 ns 398944 -bm_rtl::function_calls__Function::set_string 1780 ns 1781 ns 392505 -bm_rtl::method_calls______Method::set_string 1778 ns 1778 ns 393604 +bm_rtl::function_calls__Function::set_string 1750 ns 1750 ns 400631 +bm_rtl::method_calls______Method::set_string 1749 ns 1749 ns 399395 -bm_rtl::function__ErasedReturnType::set_string 1778 ns 1779 ns 391999 -bm_rtl::method____ErasedReturnType::set_string 1782 ns 1783 ns 392539 -bm_rtl::method____ErasedTargetType::set_string 1794 ns 1794 ns 389821 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1786 ns 1787 ns 391779 +bm_rtl::function__ErasedReturnType::set_string 1760 ns 1760 ns 397764 +bm_rtl::method____ErasedReturnType::set_string 1760 ns 1760 ns 397768 +bm_rtl::method____ErasedTargetType::set_string 1762 ns 1762 ns 397246 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1763 ns 1763 ns 397178 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2181 ns 2181 ns 321380 +bm_call::direct__Function::get_string 2151 ns 2151 ns 325324 -bm_call::via_function_ptr__Function::get_string 2175 ns 2176 ns 321625 -bm_call::via_function_ptr____Method::get_string 2178 ns 2179 ns 321527 +bm_call::via_function_ptr__Function::get_string 2149 ns 2148 ns 325850 +bm_call::via_function_ptr____Method::get_string 2148 ns 2148 ns 326230 -bm_std::function_calls__Function::get_string 2175 ns 2176 ns 321528 -bm_std::function_calls____Method::get_string 2186 ns 2186 ns 320422 +bm_std::function_calls__Function::get_string 2149 ns 2149 ns 326263 +bm_std::function_calls____Method::get_string 2162 ns 2162 ns 323736 -bm_rtl::function_calls__Function::get_string 2173 ns 2174 ns 322110 -bm_rtl::method_calls______Method::get_string 2180 ns 2180 ns 321745 +bm_rtl::function_calls__Function::get_string 2147 ns 2147 ns 325662 +bm_rtl::method_calls______Method::get_string 2147 ns 2147 ns 325369 -bm_rtl::function__ErasedReturnType::get_string 2217 ns 2218 ns 315599 -bm_rtl::method____ErasedReturnType::get_string 2219 ns 2220 ns 315241 -bm_rtl::method____ErasedTargetType::get_string 2195 ns 2196 ns 317502 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2221 ns 2222 ns 315139 +bm_rtl::function__ErasedReturnType::get_string 2176 ns 2176 ns 322001 +bm_rtl::method____ErasedReturnType::get_string 2180 ns 2180 ns 320718 +bm_rtl::method____ErasedTargetType::get_string 2168 ns 2168 ns 322879 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2179 ns 2179 ns 321455 ----------------------------------- -[2025-11-04 11:44:39] >>> Run 3: workload scale = 82 +[2026-01-19 22:33:19] >>> Run 3: workload scale = 82 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 82 iterations ============================================= -2025-11-04T11:44:39+05:30 +2026-01-19T22:33:19+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4073.78 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.07, 1.03, 0.73 +Load Average: 1.00, 1.00, 0.75 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1789 ns 1789 ns 391681 +bm_call::direct__Function::set_string 1789 ns 1789 ns 391009 -bm_call::via_function_ptr__Function::set_string 1790 ns 1791 ns 391507 -bm_call::via_function_ptr____Method::set_string 1791 ns 1792 ns 390930 +bm_call::via_function_ptr__Function::set_string 1774 ns 1773 ns 395022 +bm_call::via_function_ptr____Method::set_string 1773 ns 1773 ns 394648 -bm_std::function_calls__Function::set_string 1787 ns 1788 ns 391890 -bm_std::function_calls____Method::set_string 1794 ns 1794 ns 390805 +bm_std::function_calls__Function::set_string 1774 ns 1774 ns 394608 +bm_std::function_calls____Method::set_string 1776 ns 1776 ns 394117 -bm_rtl::function_calls__Function::set_string 1786 ns 1787 ns 392220 -bm_rtl::method_calls______Method::set_string 1790 ns 1790 ns 391457 +bm_rtl::function_calls__Function::set_string 1773 ns 1773 ns 394842 +bm_rtl::method_calls______Method::set_string 1773 ns 1773 ns 393793 -bm_rtl::function__ErasedReturnType::set_string 1789 ns 1789 ns 391299 -bm_rtl::method____ErasedReturnType::set_string 1790 ns 1791 ns 391105 -bm_rtl::method____ErasedTargetType::set_string 1797 ns 1798 ns 389126 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1798 ns 1799 ns 388968 +bm_rtl::function__ErasedReturnType::set_string 1783 ns 1782 ns 392453 +bm_rtl::method____ErasedReturnType::set_string 1781 ns 1781 ns 393171 +bm_rtl::method____ErasedTargetType::set_string 1784 ns 1784 ns 392212 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1784 ns 1784 ns 392357 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2281 ns 2282 ns 307129 +bm_call::direct__Function::get_string 2259 ns 2259 ns 309811 -bm_call::via_function_ptr__Function::get_string 2277 ns 2278 ns 307178 -bm_call::via_function_ptr____Method::get_string 2282 ns 2283 ns 307132 +bm_call::via_function_ptr__Function::get_string 2262 ns 2262 ns 309475 +bm_call::via_function_ptr____Method::get_string 2261 ns 2261 ns 309595 -bm_std::function_calls__Function::get_string 2278 ns 2279 ns 307271 -bm_std::function_calls____Method::get_string 2289 ns 2290 ns 306018 +bm_std::function_calls__Function::get_string 2263 ns 2263 ns 309747 +bm_std::function_calls____Method::get_string 2275 ns 2275 ns 307808 -bm_rtl::function_calls__Function::get_string 2276 ns 2277 ns 307466 -bm_rtl::method_calls______Method::get_string 2283 ns 2283 ns 306991 +bm_rtl::function_calls__Function::get_string 2265 ns 2265 ns 309079 +bm_rtl::method_calls______Method::get_string 2262 ns 2262 ns 309463 -bm_rtl::function__ErasedReturnType::get_string 2316 ns 2316 ns 302121 -bm_rtl::method____ErasedReturnType::get_string 2317 ns 2318 ns 302362 -bm_rtl::method____ErasedTargetType::get_string 2302 ns 2303 ns 304074 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2325 ns 2325 ns 301350 +bm_rtl::function__ErasedReturnType::get_string 2302 ns 2302 ns 304220 +bm_rtl::method____ErasedReturnType::get_string 2303 ns 2303 ns 303903 +bm_rtl::method____ErasedTargetType::get_string 2286 ns 2286 ns 306033 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2299 ns 2299 ns 303954 ----------------------------------- -[2025-11-04 11:44:59] >>> Run 1: workload scale = 90 +[2026-01-19 22:33:39] >>> Run 1: workload scale = 90 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 90 iterations ============================================= -2025-11-04T11:44:59+05:30 +2026-01-19T22:33:39+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2567,50 +2567,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.05, 1.02, 0.74 +Load Average: 1.00, 1.00, 0.76 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1855 ns 1856 ns 377098 +bm_call::direct__Function::set_string 1861 ns 1860 ns 375999 -bm_call::via_function_ptr__Function::set_string 1855 ns 1855 ns 378267 -bm_call::via_function_ptr____Method::set_string 1853 ns 1853 ns 377675 +bm_call::via_function_ptr__Function::set_string 1835 ns 1835 ns 382030 +bm_call::via_function_ptr____Method::set_string 1834 ns 1834 ns 381859 -bm_std::function_calls__Function::set_string 1853 ns 1854 ns 378218 -bm_std::function_calls____Method::set_string 1862 ns 1862 ns 376248 +bm_std::function_calls__Function::set_string 1836 ns 1836 ns 381565 +bm_std::function_calls____Method::set_string 1840 ns 1840 ns 380541 -bm_rtl::function_calls__Function::set_string 1850 ns 1850 ns 378137 -bm_rtl::method_calls______Method::set_string 1855 ns 1856 ns 377582 +bm_rtl::function_calls__Function::set_string 1836 ns 1835 ns 381728 +bm_rtl::method_calls______Method::set_string 1834 ns 1834 ns 381897 -bm_rtl::function__ErasedReturnType::set_string 1862 ns 1863 ns 375415 -bm_rtl::method____ErasedReturnType::set_string 1864 ns 1865 ns 376111 -bm_rtl::method____ErasedTargetType::set_string 1869 ns 1870 ns 374624 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1870 ns 1870 ns 373729 +bm_rtl::function__ErasedReturnType::set_string 1847 ns 1847 ns 379564 +bm_rtl::method____ErasedReturnType::set_string 1873 ns 1873 ns 373534 +bm_rtl::method____ErasedTargetType::set_string 1847 ns 1847 ns 379013 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1846 ns 1846 ns 377722 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2285 ns 2285 ns 305947 +bm_call::direct__Function::get_string 2372 ns 2371 ns 295210 -bm_call::via_function_ptr__Function::get_string 2287 ns 2288 ns 305982 -bm_call::via_function_ptr____Method::get_string 2289 ns 2290 ns 305610 +bm_call::via_function_ptr__Function::get_string 2375 ns 2374 ns 295181 +bm_call::via_function_ptr____Method::get_string 2371 ns 2371 ns 295161 -bm_std::function_calls__Function::get_string 2287 ns 2288 ns 305896 -bm_std::function_calls____Method::get_string 2290 ns 2291 ns 305644 +bm_std::function_calls__Function::get_string 2373 ns 2373 ns 295444 +bm_std::function_calls____Method::get_string 2375 ns 2374 ns 294851 -bm_rtl::function_calls__Function::get_string 2287 ns 2288 ns 306110 -bm_rtl::method_calls______Method::get_string 2289 ns 2289 ns 305683 +bm_rtl::function_calls__Function::get_string 2375 ns 2375 ns 295197 +bm_rtl::method_calls______Method::get_string 2371 ns 2370 ns 295144 -bm_rtl::function__ErasedReturnType::get_string 2321 ns 2322 ns 301437 -bm_rtl::method____ErasedReturnType::get_string 2323 ns 2323 ns 301190 -bm_rtl::method____ErasedTargetType::get_string 2295 ns 2295 ns 304947 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2331 ns 2332 ns 300136 +bm_rtl::function__ErasedReturnType::get_string 2402 ns 2402 ns 291878 +bm_rtl::method____ErasedReturnType::get_string 2401 ns 2401 ns 291746 +bm_rtl::method____ErasedTargetType::get_string 2394 ns 2394 ns 292974 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2405 ns 2405 ns 291092 ----------------------------------- -[2025-11-04 11:45:20] >>> Run 2: workload scale = 90 +[2026-01-19 22:34:00] >>> Run 2: workload scale = 90 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 90 iterations ============================================= -2025-11-04T11:45:20+05:30 +2026-01-19T22:34:00+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2618,254 +2618,254 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 1.02, 0.74 +Load Average: 1.00, 1.00, 0.76 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1870 ns 1871 ns 373902 +bm_call::direct__Function::set_string 1849 ns 1849 ns 378261 -bm_call::via_function_ptr__Function::set_string 1866 ns 1866 ns 375733 -bm_call::via_function_ptr____Method::set_string 1860 ns 1860 ns 376397 +bm_call::via_function_ptr__Function::set_string 1823 ns 1823 ns 383390 +bm_call::via_function_ptr____Method::set_string 1826 ns 1826 ns 383423 -bm_std::function_calls__Function::set_string 1859 ns 1860 ns 376365 -bm_std::function_calls____Method::set_string 1862 ns 1863 ns 373798 +bm_std::function_calls__Function::set_string 1826 ns 1826 ns 383591 +bm_std::function_calls____Method::set_string 1831 ns 1831 ns 381967 -bm_rtl::function_calls__Function::set_string 1857 ns 1858 ns 376991 -bm_rtl::method_calls______Method::set_string 1862 ns 1863 ns 376328 +bm_rtl::function_calls__Function::set_string 1825 ns 1825 ns 383713 +bm_rtl::method_calls______Method::set_string 1827 ns 1826 ns 383181 -bm_rtl::function__ErasedReturnType::set_string 1865 ns 1865 ns 375497 -bm_rtl::method____ErasedReturnType::set_string 1868 ns 1868 ns 375141 -bm_rtl::method____ErasedTargetType::set_string 1872 ns 1873 ns 373961 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1876 ns 1876 ns 373051 +bm_rtl::function__ErasedReturnType::set_string 1834 ns 1834 ns 381783 +bm_rtl::method____ErasedReturnType::set_string 1864 ns 1864 ns 375810 +bm_rtl::method____ErasedTargetType::set_string 1837 ns 1837 ns 380838 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1836 ns 1836 ns 381270 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2317 ns 2317 ns 301971 +bm_call::direct__Function::get_string 2263 ns 2263 ns 309522 -bm_call::via_function_ptr__Function::get_string 2312 ns 2312 ns 302404 -bm_call::via_function_ptr____Method::get_string 2313 ns 2314 ns 302312 +bm_call::via_function_ptr__Function::get_string 2263 ns 2263 ns 309279 +bm_call::via_function_ptr____Method::get_string 2264 ns 2263 ns 309468 -bm_std::function_calls__Function::get_string 2312 ns 2313 ns 302678 -bm_std::function_calls____Method::get_string 2320 ns 2320 ns 301614 +bm_std::function_calls__Function::get_string 2264 ns 2264 ns 308991 +bm_std::function_calls____Method::get_string 2268 ns 2268 ns 308743 -bm_rtl::function_calls__Function::get_string 2313 ns 2314 ns 302455 -bm_rtl::method_calls______Method::get_string 2314 ns 2315 ns 302291 +bm_rtl::function_calls__Function::get_string 2264 ns 2263 ns 309197 +bm_rtl::method_calls______Method::get_string 2263 ns 2263 ns 309007 -bm_rtl::function__ErasedReturnType::get_string 2350 ns 2351 ns 297755 -bm_rtl::method____ErasedReturnType::get_string 2354 ns 2354 ns 297340 -bm_rtl::method____ErasedTargetType::get_string 2333 ns 2334 ns 300017 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2366 ns 2366 ns 295941 +bm_rtl::function__ErasedReturnType::get_string 2293 ns 2293 ns 305398 +bm_rtl::method____ErasedReturnType::get_string 2295 ns 2294 ns 305011 +bm_rtl::method____ErasedTargetType::get_string 2282 ns 2282 ns 306678 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2293 ns 2292 ns 305219 ----------------------------------- -[2025-11-04 11:45:40] >>> Run 3: workload scale = 90 +[2026-01-19 22:34:20] >>> Run 3: workload scale = 90 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 90 iterations ============================================= -2025-11-04T11:45:40+05:30 +2026-01-19T22:34:20+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 3231.2 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.09, 1.04, 0.75 +Load Average: 1.00, 1.00, 0.77 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1868 ns 1869 ns 374396 +bm_call::direct__Function::set_string 1848 ns 1847 ns 379051 -bm_call::via_function_ptr__Function::set_string 1867 ns 1867 ns 374797 -bm_call::via_function_ptr____Method::set_string 1868 ns 1869 ns 374400 +bm_call::via_function_ptr__Function::set_string 1834 ns 1834 ns 381757 +bm_call::via_function_ptr____Method::set_string 1840 ns 1840 ns 380947 -bm_std::function_calls__Function::set_string 1867 ns 1868 ns 375065 -bm_std::function_calls____Method::set_string 1871 ns 1872 ns 374292 +bm_std::function_calls__Function::set_string 1836 ns 1835 ns 381485 +bm_std::function_calls____Method::set_string 1868 ns 1868 ns 375302 -bm_rtl::function_calls__Function::set_string 1867 ns 1867 ns 374894 -bm_rtl::method_calls______Method::set_string 1869 ns 1869 ns 374490 +bm_rtl::function_calls__Function::set_string 1834 ns 1834 ns 381787 +bm_rtl::method_calls______Method::set_string 1837 ns 1836 ns 381079 -bm_rtl::function__ErasedReturnType::set_string 1871 ns 1872 ns 373958 -bm_rtl::method____ErasedReturnType::set_string 1875 ns 1875 ns 373262 -bm_rtl::method____ErasedTargetType::set_string 1883 ns 1883 ns 371719 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1883 ns 1884 ns 371947 +bm_rtl::function__ErasedReturnType::set_string 1845 ns 1844 ns 379011 +bm_rtl::method____ErasedReturnType::set_string 1846 ns 1846 ns 379197 +bm_rtl::method____ErasedTargetType::set_string 1848 ns 1848 ns 379779 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1848 ns 1847 ns 379216 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2410 ns 2410 ns 290228 +bm_call::direct__Function::get_string 2293 ns 2292 ns 305828 -bm_call::via_function_ptr__Function::get_string 2410 ns 2411 ns 290367 -bm_call::via_function_ptr____Method::get_string 2412 ns 2413 ns 290266 +bm_call::via_function_ptr__Function::get_string 2290 ns 2290 ns 305261 +bm_call::via_function_ptr____Method::get_string 2296 ns 2296 ns 305268 -bm_std::function_calls__Function::get_string 2408 ns 2409 ns 290412 -bm_std::function_calls____Method::get_string 2417 ns 2418 ns 289516 +bm_std::function_calls__Function::get_string 2293 ns 2293 ns 305575 +bm_std::function_calls____Method::get_string 2302 ns 2302 ns 304368 -bm_rtl::function_calls__Function::get_string 2410 ns 2411 ns 290432 -bm_rtl::method_calls______Method::get_string 2411 ns 2411 ns 290130 +bm_rtl::function_calls__Function::get_string 2291 ns 2290 ns 305721 +bm_rtl::method_calls______Method::get_string 2295 ns 2295 ns 305440 -bm_rtl::function__ErasedReturnType::get_string 2448 ns 2449 ns 285773 -bm_rtl::method____ErasedReturnType::get_string 2453 ns 2454 ns 285286 -bm_rtl::method____ErasedTargetType::get_string 2433 ns 2434 ns 287844 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2458 ns 2458 ns 284818 +bm_rtl::function__ErasedReturnType::get_string 2322 ns 2322 ns 301402 +bm_rtl::method____ErasedReturnType::get_string 2325 ns 2325 ns 300979 +bm_rtl::method____ErasedTargetType::get_string 2313 ns 2313 ns 301214 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2321 ns 2321 ns 301863 ----------------------------------- -[2025-11-04 11:46:01] >>> Run 1: workload scale = 100 +[2026-01-19 22:34:41] >>> Run 1: workload scale = 100 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 100 iterations ============================================= -2025-11-04T11:46:01+05:30 +2026-01-19T22:34:41+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2637.51 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.06, 1.03, 0.76 +Load Average: 1.00, 1.00, 0.77 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1962 ns 1962 ns 356628 +bm_call::direct__Function::set_string 1997 ns 1997 ns 348547 -bm_call::via_function_ptr__Function::set_string 1959 ns 1960 ns 357267 -bm_call::via_function_ptr____Method::set_string 1958 ns 1959 ns 357354 +bm_call::via_function_ptr__Function::set_string 1990 ns 1990 ns 352058 +bm_call::via_function_ptr____Method::set_string 1990 ns 1990 ns 351866 -bm_std::function_calls__Function::set_string 1958 ns 1959 ns 357026 -bm_std::function_calls____Method::set_string 1966 ns 1966 ns 356465 +bm_std::function_calls__Function::set_string 1989 ns 1989 ns 351920 +bm_std::function_calls____Method::set_string 1954 ns 1954 ns 358559 -bm_rtl::function_calls__Function::set_string 1959 ns 1959 ns 357324 -bm_rtl::method_calls______Method::set_string 1959 ns 1960 ns 357320 +bm_rtl::function_calls__Function::set_string 1989 ns 1989 ns 352081 +bm_rtl::method_calls______Method::set_string 1992 ns 1992 ns 351760 -bm_rtl::function__ErasedReturnType::set_string 1971 ns 1971 ns 354968 -bm_rtl::method____ErasedReturnType::set_string 1967 ns 1968 ns 355173 -bm_rtl::method____ErasedTargetType::set_string 1976 ns 1977 ns 354265 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1977 ns 1978 ns 353660 +bm_rtl::function__ErasedReturnType::set_string 1963 ns 1962 ns 357063 +bm_rtl::method____ErasedReturnType::set_string 1960 ns 1960 ns 357847 +bm_rtl::method____ErasedTargetType::set_string 1946 ns 1946 ns 359612 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1962 ns 1961 ns 356847 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2488 ns 2488 ns 281199 +bm_call::direct__Function::get_string 2504 ns 2504 ns 278402 -bm_call::via_function_ptr__Function::get_string 2486 ns 2487 ns 281683 -bm_call::via_function_ptr____Method::get_string 2490 ns 2491 ns 280922 +bm_call::via_function_ptr__Function::get_string 2501 ns 2501 ns 279911 +bm_call::via_function_ptr____Method::get_string 2502 ns 2502 ns 279036 -bm_std::function_calls__Function::get_string 2492 ns 2492 ns 280970 -bm_std::function_calls____Method::get_string 2494 ns 2495 ns 280222 +bm_std::function_calls__Function::get_string 2500 ns 2499 ns 280151 +bm_std::function_calls____Method::get_string 2459 ns 2458 ns 283683 -bm_rtl::function_calls__Function::get_string 2485 ns 2486 ns 281630 -bm_rtl::method_calls______Method::get_string 2488 ns 2489 ns 281276 +bm_rtl::function_calls__Function::get_string 2501 ns 2501 ns 279874 +bm_rtl::method_calls______Method::get_string 2504 ns 2504 ns 279888 -bm_rtl::function__ErasedReturnType::get_string 2523 ns 2524 ns 277389 -bm_rtl::method____ErasedReturnType::get_string 2527 ns 2528 ns 276820 -bm_rtl::method____ErasedTargetType::get_string 2504 ns 2504 ns 279332 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2533 ns 2534 ns 276551 +bm_rtl::function__ErasedReturnType::get_string 2482 ns 2481 ns 282147 +bm_rtl::method____ErasedReturnType::get_string 2485 ns 2485 ns 282054 +bm_rtl::method____ErasedTargetType::get_string 2467 ns 2467 ns 283637 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2488 ns 2487 ns 281941 ----------------------------------- -[2025-11-04 11:46:22] >>> Run 2: workload scale = 100 +[2026-01-19 22:35:01] >>> Run 2: workload scale = 100 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 100 iterations ============================================= -2025-11-04T11:46:22+05:30 +2026-01-19T22:35:01+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4866.2 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 1.03, 0.77 +Load Average: 1.00, 1.00, 0.78 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1958 ns 1959 ns 357126 +bm_call::direct__Function::set_string 1947 ns 1947 ns 359187 -bm_call::via_function_ptr__Function::set_string 1960 ns 1960 ns 357441 -bm_call::via_function_ptr____Method::set_string 1957 ns 1958 ns 357515 +bm_call::via_function_ptr__Function::set_string 1938 ns 1938 ns 361868 +bm_call::via_function_ptr____Method::set_string 1935 ns 1935 ns 361960 -bm_std::function_calls__Function::set_string 1957 ns 1958 ns 357880 -bm_std::function_calls____Method::set_string 1969 ns 1969 ns 356125 +bm_std::function_calls__Function::set_string 1937 ns 1936 ns 361911 +bm_std::function_calls____Method::set_string 1944 ns 1943 ns 360138 -bm_rtl::function_calls__Function::set_string 1959 ns 1959 ns 357313 -bm_rtl::method_calls______Method::set_string 1957 ns 1958 ns 357136 +bm_rtl::function_calls__Function::set_string 1934 ns 1934 ns 361967 +bm_rtl::method_calls______Method::set_string 1935 ns 1935 ns 360915 -bm_rtl::function__ErasedReturnType::set_string 1966 ns 1967 ns 355791 -bm_rtl::method____ErasedReturnType::set_string 1968 ns 1968 ns 355742 -bm_rtl::method____ErasedTargetType::set_string 1973 ns 1973 ns 354496 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1978 ns 1979 ns 353748 +bm_rtl::function__ErasedReturnType::set_string 1945 ns 1945 ns 360218 +bm_rtl::method____ErasedReturnType::set_string 1942 ns 1942 ns 358792 +bm_rtl::method____ErasedTargetType::set_string 1947 ns 1946 ns 359434 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1949 ns 1949 ns 359796 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2583 ns 2584 ns 270769 +bm_call::direct__Function::get_string 2451 ns 2450 ns 285493 -bm_call::via_function_ptr__Function::get_string 2585 ns 2586 ns 270684 -bm_call::via_function_ptr____Method::get_string 2586 ns 2587 ns 270687 +bm_call::via_function_ptr__Function::get_string 2453 ns 2453 ns 285744 +bm_call::via_function_ptr____Method::get_string 2451 ns 2451 ns 285759 -bm_std::function_calls__Function::get_string 2591 ns 2592 ns 270101 -bm_std::function_calls____Method::get_string 2592 ns 2593 ns 270162 +bm_std::function_calls__Function::get_string 2456 ns 2455 ns 285718 +bm_std::function_calls____Method::get_string 2469 ns 2469 ns 283176 -bm_rtl::function_calls__Function::get_string 2588 ns 2589 ns 270376 -bm_rtl::method_calls______Method::get_string 2591 ns 2591 ns 269776 +bm_rtl::function_calls__Function::get_string 2456 ns 2456 ns 285646 +bm_rtl::method_calls______Method::get_string 2451 ns 2451 ns 285771 -bm_rtl::function__ErasedReturnType::get_string 2619 ns 2620 ns 267102 -bm_rtl::method____ErasedReturnType::get_string 2619 ns 2620 ns 267036 -bm_rtl::method____ErasedTargetType::get_string 2601 ns 2602 ns 268965 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2625 ns 2626 ns 266419 +bm_rtl::function__ErasedReturnType::get_string 2500 ns 2500 ns 281548 +bm_rtl::method____ErasedReturnType::get_string 2599 ns 2599 ns 274914 +bm_rtl::method____ErasedTargetType::get_string 2587 ns 2586 ns 270912 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2595 ns 2595 ns 269299 ----------------------------------- -[2025-11-04 11:46:43] >>> Run 3: workload scale = 100 +[2026-01-19 22:35:22] >>> Run 3: workload scale = 100 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 100 iterations ============================================= -2025-11-04T11:46:43+05:30 +2026-01-19T22:35:22+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4684.54 MHz CPU s) +Run on (16 X 2685.67 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.09, 1.04, 0.78 +Load Average: 1.08, 1.02, 0.79 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 1958 ns 1958 ns 357642 +bm_call::direct__Function::set_string 1940 ns 1940 ns 359624 -bm_call::via_function_ptr__Function::set_string 1976 ns 1976 ns 354513 -bm_call::via_function_ptr____Method::set_string 1975 ns 1975 ns 354409 +bm_call::via_function_ptr__Function::set_string 1944 ns 1944 ns 360107 +bm_call::via_function_ptr____Method::set_string 1942 ns 1942 ns 360542 -bm_std::function_calls__Function::set_string 1975 ns 1976 ns 354522 -bm_std::function_calls____Method::set_string 2040 ns 2040 ns 342871 +bm_std::function_calls__Function::set_string 1942 ns 1942 ns 357815 +bm_std::function_calls____Method::set_string 1963 ns 1963 ns 356515 -bm_rtl::function_calls__Function::set_string 1972 ns 1972 ns 355167 -bm_rtl::method_calls______Method::set_string 1973 ns 1974 ns 354698 +bm_rtl::function_calls__Function::set_string 1947 ns 1947 ns 360618 +bm_rtl::method_calls______Method::set_string 1943 ns 1943 ns 360619 -bm_rtl::function__ErasedReturnType::set_string 1969 ns 1970 ns 355340 -bm_rtl::method____ErasedReturnType::set_string 1974 ns 1975 ns 354492 -bm_rtl::method____ErasedTargetType::set_string 1979 ns 1980 ns 353705 -bm_rtl::method____ErasedTargetAndReturnType::set_string 1982 ns 1982 ns 353134 +bm_rtl::function__ErasedReturnType::set_string 1977 ns 1976 ns 358735 +bm_rtl::method____ErasedReturnType::set_string 1946 ns 1945 ns 358855 +bm_rtl::method____ErasedTargetType::set_string 1949 ns 1949 ns 359699 +bm_rtl::method____ErasedTargetAndReturnType::set_string 1949 ns 1949 ns 359356 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2570 ns 2571 ns 272122 +bm_call::direct__Function::get_string 2458 ns 2458 ns 284033 -bm_call::via_function_ptr__Function::get_string 2615 ns 2616 ns 267506 -bm_call::via_function_ptr____Method::get_string 2618 ns 2619 ns 267281 +bm_call::via_function_ptr__Function::get_string 2457 ns 2457 ns 285086 +bm_call::via_function_ptr____Method::get_string 2458 ns 2458 ns 285013 -bm_std::function_calls__Function::get_string 2618 ns 2618 ns 267315 -bm_std::function_calls____Method::get_string 2658 ns 2658 ns 263345 +bm_std::function_calls__Function::get_string 2455 ns 2455 ns 285133 +bm_std::function_calls____Method::get_string 2462 ns 2462 ns 284508 -bm_rtl::function_calls__Function::get_string 2616 ns 2617 ns 267494 -bm_rtl::method_calls______Method::get_string 2619 ns 2620 ns 267124 +bm_rtl::function_calls__Function::get_string 2457 ns 2457 ns 285057 +bm_rtl::method_calls______Method::get_string 2456 ns 2456 ns 285020 -bm_rtl::function__ErasedReturnType::get_string 2616 ns 2617 ns 267478 -bm_rtl::method____ErasedReturnType::get_string 2615 ns 2616 ns 267658 -bm_rtl::method____ErasedTargetType::get_string 2591 ns 2592 ns 270061 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2620 ns 2620 ns 266947 +bm_rtl::function__ErasedReturnType::get_string 2486 ns 2486 ns 281798 +bm_rtl::method____ErasedReturnType::get_string 2487 ns 2486 ns 281683 +bm_rtl::method____ErasedTargetType::get_string 2470 ns 2470 ns 283091 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2492 ns 2492 ns 280955 ----------------------------------- -[2025-11-04 11:47:04] >>> Run 1: workload scale = 120 +[2026-01-19 22:35:43] >>> Run 1: workload scale = 120 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 120 iterations ============================================= -2025-11-04T11:47:04+05:30 +2026-01-19T22:35:43+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2873,50 +2873,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.06, 1.04, 0.78 +Load Average: 1.06, 1.01, 0.80 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 2135 ns 2136 ns 327606 +bm_call::direct__Function::set_string 2137 ns 2137 ns 326829 -bm_call::via_function_ptr__Function::set_string 2134 ns 2135 ns 327517 -bm_call::via_function_ptr____Method::set_string 2134 ns 2135 ns 327554 +bm_call::via_function_ptr__Function::set_string 2125 ns 2124 ns 329605 +bm_call::via_function_ptr____Method::set_string 2125 ns 2125 ns 329665 -bm_std::function_calls__Function::set_string 2138 ns 2139 ns 327567 -bm_std::function_calls____Method::set_string 2137 ns 2138 ns 326930 +bm_std::function_calls__Function::set_string 2124 ns 2124 ns 329576 +bm_std::function_calls____Method::set_string 2157 ns 2157 ns 324516 -bm_rtl::function_calls__Function::set_string 2134 ns 2135 ns 328040 -bm_rtl::method_calls______Method::set_string 2134 ns 2135 ns 327050 +bm_rtl::function_calls__Function::set_string 2123 ns 2123 ns 329881 +bm_rtl::method_calls______Method::set_string 2125 ns 2124 ns 329448 -bm_rtl::function__ErasedReturnType::set_string 2140 ns 2141 ns 326742 -bm_rtl::method____ErasedReturnType::set_string 2142 ns 2143 ns 326912 -bm_rtl::method____ErasedTargetType::set_string 2147 ns 2147 ns 326378 -bm_rtl::method____ErasedTargetAndReturnType::set_string 2151 ns 2152 ns 325392 +bm_rtl::function__ErasedReturnType::set_string 2129 ns 2129 ns 328759 +bm_rtl::method____ErasedReturnType::set_string 2131 ns 2130 ns 305340 +bm_rtl::method____ErasedTargetType::set_string 2131 ns 2131 ns 328500 +bm_rtl::method____ErasedTargetAndReturnType::set_string 2132 ns 2132 ns 328066 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 2925 ns 2926 ns 239187 +bm_call::direct__Function::get_string 3007 ns 3007 ns 232978 -bm_call::via_function_ptr__Function::get_string 2922 ns 2923 ns 239675 -bm_call::via_function_ptr____Method::get_string 2919 ns 2920 ns 239757 +bm_call::via_function_ptr__Function::get_string 3011 ns 3010 ns 232634 +bm_call::via_function_ptr____Method::get_string 3012 ns 3011 ns 232464 -bm_std::function_calls__Function::get_string 2922 ns 2923 ns 239511 -bm_std::function_calls____Method::get_string 2927 ns 2927 ns 239088 +bm_std::function_calls__Function::get_string 3014 ns 3013 ns 232339 +bm_std::function_calls____Method::get_string 3019 ns 3019 ns 231831 -bm_rtl::function_calls__Function::get_string 2921 ns 2922 ns 239587 -bm_rtl::method_calls______Method::get_string 2919 ns 2920 ns 239850 +bm_rtl::function_calls__Function::get_string 3014 ns 3013 ns 232535 +bm_rtl::method_calls______Method::get_string 3008 ns 3008 ns 232654 -bm_rtl::function__ErasedReturnType::get_string 2970 ns 2971 ns 235687 -bm_rtl::method____ErasedReturnType::get_string 2969 ns 2970 ns 235693 -bm_rtl::method____ErasedTargetType::get_string 2939 ns 2940 ns 238228 -bm_rtl::method____ErasedTargetAndReturnType::get_string 2973 ns 2974 ns 235380 +bm_rtl::function__ErasedReturnType::get_string 3051 ns 3051 ns 229522 +bm_rtl::method____ErasedReturnType::get_string 3040 ns 3040 ns 230285 +bm_rtl::method____ErasedTargetType::get_string 3040 ns 3040 ns 230408 +bm_rtl::method____ErasedTargetAndReturnType::get_string 3042 ns 3041 ns 230091 ----------------------------------- -[2025-11-04 11:47:25] >>> Run 2: workload scale = 120 +[2026-01-19 22:36:05] >>> Run 2: workload scale = 120 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 120 iterations ============================================= -2025-11-04T11:47:25+05:30 +2026-01-19T22:36:05+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2924,50 +2924,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.04, 1.03, 0.79 +Load Average: 1.04, 1.01, 0.80 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 2143 ns 2143 ns 327009 +bm_call::direct__Function::set_string 2128 ns 2128 ns 329355 -bm_call::via_function_ptr__Function::set_string 2144 ns 2144 ns 326962 -bm_call::via_function_ptr____Method::set_string 2143 ns 2143 ns 326336 +bm_call::via_function_ptr__Function::set_string 2125 ns 2125 ns 329104 +bm_call::via_function_ptr____Method::set_string 2128 ns 2128 ns 329260 -bm_std::function_calls__Function::set_string 2141 ns 2142 ns 326610 -bm_std::function_calls____Method::set_string 2147 ns 2148 ns 325479 +bm_std::function_calls__Function::set_string 2126 ns 2126 ns 329537 +bm_std::function_calls____Method::set_string 2159 ns 2158 ns 325160 -bm_rtl::function_calls__Function::set_string 2141 ns 2141 ns 326887 -bm_rtl::method_calls______Method::set_string 2141 ns 2142 ns 326810 +bm_rtl::function_calls__Function::set_string 2126 ns 2126 ns 329470 +bm_rtl::method_calls______Method::set_string 2125 ns 2125 ns 329217 -bm_rtl::function__ErasedReturnType::set_string 2149 ns 2149 ns 325633 -bm_rtl::method____ErasedReturnType::set_string 2152 ns 2152 ns 325416 -bm_rtl::method____ErasedTargetType::set_string 2151 ns 2152 ns 325646 -bm_rtl::method____ErasedTargetAndReturnType::set_string 2159 ns 2160 ns 324017 +bm_rtl::function__ErasedReturnType::set_string 2134 ns 2134 ns 326337 +bm_rtl::method____ErasedReturnType::set_string 2140 ns 2140 ns 327348 +bm_rtl::method____ErasedTargetType::set_string 2137 ns 2137 ns 327992 +bm_rtl::method____ErasedTargetAndReturnType::set_string 2150 ns 2150 ns 325220 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3033 ns 3034 ns 230681 +bm_call::direct__Function::get_string 2895 ns 2894 ns 242080 -bm_call::via_function_ptr__Function::get_string 3036 ns 3037 ns 230556 -bm_call::via_function_ptr____Method::get_string 3035 ns 3036 ns 230561 +bm_call::via_function_ptr__Function::get_string 2892 ns 2892 ns 242012 +bm_call::via_function_ptr____Method::get_string 2897 ns 2897 ns 241915 -bm_std::function_calls__Function::get_string 3036 ns 3037 ns 230558 -bm_std::function_calls____Method::get_string 3044 ns 3045 ns 229777 +bm_std::function_calls__Function::get_string 2894 ns 2894 ns 242013 +bm_std::function_calls____Method::get_string 2897 ns 2897 ns 241621 -bm_rtl::function_calls__Function::get_string 3036 ns 3036 ns 230539 -bm_rtl::method_calls______Method::get_string 3036 ns 3037 ns 230571 +bm_rtl::function_calls__Function::get_string 2891 ns 2891 ns 242113 +bm_rtl::method_calls______Method::get_string 2970 ns 2939 ns 241649 -bm_rtl::function__ErasedReturnType::get_string 3078 ns 3079 ns 227428 -bm_rtl::method____ErasedReturnType::get_string 3082 ns 3083 ns 227040 -bm_rtl::method____ErasedTargetType::get_string 3052 ns 3053 ns 229389 -bm_rtl::method____ErasedTargetAndReturnType::get_string 3092 ns 3093 ns 226442 +bm_rtl::function__ErasedReturnType::get_string 2922 ns 2922 ns 239779 +bm_rtl::method____ErasedReturnType::get_string 2924 ns 2924 ns 238642 +bm_rtl::method____ErasedTargetType::get_string 2911 ns 2911 ns 240434 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2937 ns 2937 ns 237304 ----------------------------------- -[2025-11-04 11:47:47] >>> Run 3: workload scale = 120 +[2026-01-19 22:36:26] >>> Run 3: workload scale = 120 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 120 iterations ============================================= -2025-11-04T11:47:47+05:30 +2026-01-19T22:36:26+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -2975,50 +2975,50 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.03, 1.03, 0.80 +Load Average: 1.02, 1.01, 0.81 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 2146 ns 2147 ns 326155 +bm_call::direct__Function::set_string 2123 ns 2123 ns 330104 -bm_call::via_function_ptr__Function::set_string 2146 ns 2146 ns 326275 -bm_call::via_function_ptr____Method::set_string 2146 ns 2146 ns 326240 +bm_call::via_function_ptr__Function::set_string 2119 ns 2118 ns 331108 +bm_call::via_function_ptr____Method::set_string 2143 ns 2142 ns 327007 -bm_std::function_calls__Function::set_string 2145 ns 2146 ns 325899 -bm_std::function_calls____Method::set_string 2147 ns 2148 ns 325784 +bm_std::function_calls__Function::set_string 2117 ns 2117 ns 330772 +bm_std::function_calls____Method::set_string 2123 ns 2123 ns 329985 -bm_rtl::function_calls__Function::set_string 2143 ns 2143 ns 326216 -bm_rtl::method_calls______Method::set_string 2144 ns 2144 ns 326155 +bm_rtl::function_calls__Function::set_string 2118 ns 2118 ns 331201 +bm_rtl::method_calls______Method::set_string 2123 ns 2123 ns 330834 -bm_rtl::function__ErasedReturnType::set_string 2152 ns 2153 ns 325106 -bm_rtl::method____ErasedReturnType::set_string 2155 ns 2156 ns 324821 -bm_rtl::method____ErasedTargetType::set_string 2156 ns 2157 ns 324752 -bm_rtl::method____ErasedTargetAndReturnType::set_string 2161 ns 2162 ns 323898 +bm_rtl::function__ErasedReturnType::set_string 2132 ns 2131 ns 328810 +bm_rtl::method____ErasedReturnType::set_string 2157 ns 2156 ns 324121 +bm_rtl::method____ErasedTargetType::set_string 2135 ns 2134 ns 321782 +bm_rtl::method____ErasedTargetAndReturnType::set_string 2130 ns 2130 ns 328678 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 3035 ns 3036 ns 230716 +bm_call::direct__Function::get_string 2890 ns 2890 ns 242683 -bm_call::via_function_ptr__Function::get_string 3033 ns 3034 ns 230686 -bm_call::via_function_ptr____Method::get_string 3034 ns 3035 ns 230636 +bm_call::via_function_ptr__Function::get_string 2892 ns 2891 ns 237467 +bm_call::via_function_ptr____Method::get_string 2891 ns 2891 ns 242306 -bm_std::function_calls__Function::get_string 3034 ns 3034 ns 230656 -bm_std::function_calls____Method::get_string 3047 ns 3048 ns 230042 +bm_std::function_calls__Function::get_string 2891 ns 2891 ns 242434 +bm_std::function_calls____Method::get_string 2893 ns 2892 ns 242299 -bm_rtl::function_calls__Function::get_string 3040 ns 3041 ns 230018 -bm_rtl::method_calls______Method::get_string 3034 ns 3035 ns 230309 +bm_rtl::function_calls__Function::get_string 2888 ns 2887 ns 242305 +bm_rtl::method_calls______Method::get_string 2897 ns 2897 ns 242416 -bm_rtl::function__ErasedReturnType::get_string 3080 ns 3080 ns 227057 -bm_rtl::method____ErasedReturnType::get_string 3083 ns 3084 ns 226951 -bm_rtl::method____ErasedTargetType::get_string 3056 ns 3057 ns 229016 -bm_rtl::method____ErasedTargetAndReturnType::get_string 3086 ns 3087 ns 226766 +bm_rtl::function__ErasedReturnType::get_string 2918 ns 2918 ns 239887 +bm_rtl::method____ErasedReturnType::get_string 3088 ns 3087 ns 238252 +bm_rtl::method____ErasedTargetType::get_string 2907 ns 2907 ns 236594 +bm_rtl::method____ErasedTargetAndReturnType::get_string 2929 ns 2928 ns 239651 ----------------------------------- -[2025-11-04 11:48:09] >>> Run 1: workload scale = 150 +[2026-01-19 22:36:48] >>> Run 1: workload scale = 150 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 150 iterations ============================================= -2025-11-04T11:48:09+05:30 +2026-01-19T22:36:48+05:30 Running ./bin/RTLBenchmarkApp Run on (16 X 800 MHz CPU s) CPU Caches: @@ -3026,142 +3026,142 @@ CPU Caches: L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.02, 1.03, 0.80 +Load Average: 1.10, 1.03, 0.82 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 3513 ns 3514 ns 199230 +bm_call::direct__Function::set_string 3502 ns 3502 ns 200154 -bm_call::via_function_ptr__Function::set_string 3518 ns 3518 ns 199138 -bm_call::via_function_ptr____Method::set_string 3515 ns 3517 ns 199100 +bm_call::via_function_ptr__Function::set_string 3514 ns 3514 ns 199717 +bm_call::via_function_ptr____Method::set_string 3511 ns 3511 ns 198567 -bm_std::function_calls__Function::set_string 3513 ns 3514 ns 199262 -bm_std::function_calls____Method::set_string 3522 ns 3523 ns 198748 +bm_std::function_calls__Function::set_string 3515 ns 3515 ns 199394 +bm_std::function_calls____Method::set_string 3485 ns 3485 ns 200801 -bm_rtl::function_calls__Function::set_string 3511 ns 3512 ns 199310 -bm_rtl::method_calls______Method::set_string 3513 ns 3514 ns 199163 +bm_rtl::function_calls__Function::set_string 3511 ns 3510 ns 199483 +bm_rtl::method_calls______Method::set_string 3515 ns 3514 ns 199409 -bm_rtl::function__ErasedReturnType::set_string 3524 ns 3525 ns 198360 -bm_rtl::method____ErasedReturnType::set_string 3524 ns 3525 ns 198512 -bm_rtl::method____ErasedTargetType::set_string 3528 ns 3529 ns 198173 -bm_rtl::method____ErasedTargetAndReturnType::set_string 3534 ns 3535 ns 198093 +bm_rtl::function__ErasedReturnType::set_string 3524 ns 3524 ns 196051 +bm_rtl::method____ErasedReturnType::set_string 3496 ns 3495 ns 200018 +bm_rtl::method____ErasedTargetType::set_string 3531 ns 3531 ns 197723 +bm_rtl::method____ErasedTargetAndReturnType::set_string 3534 ns 3533 ns 198440 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 4425 ns 4426 ns 158169 +bm_call::direct__Function::get_string 4399 ns 4399 ns 159236 -bm_call::via_function_ptr__Function::get_string 4427 ns 4429 ns 158159 -bm_call::via_function_ptr____Method::get_string 4427 ns 4428 ns 158046 +bm_call::via_function_ptr__Function::get_string 4399 ns 4398 ns 159393 +bm_call::via_function_ptr____Method::get_string 4393 ns 4392 ns 159311 -bm_std::function_calls__Function::get_string 4425 ns 4427 ns 158030 -bm_std::function_calls____Method::get_string 4437 ns 4438 ns 157709 +bm_std::function_calls__Function::get_string 4393 ns 4393 ns 158980 +bm_std::function_calls____Method::get_string 4394 ns 4394 ns 159365 -bm_rtl::function_calls__Function::get_string 4426 ns 4427 ns 158157 -bm_rtl::method_calls______Method::get_string 4429 ns 4430 ns 158050 +bm_rtl::function_calls__Function::get_string 4391 ns 4391 ns 159379 +bm_rtl::method_calls______Method::get_string 4400 ns 4399 ns 159263 -bm_rtl::function__ErasedReturnType::get_string 4477 ns 4478 ns 156294 -bm_rtl::method____ErasedReturnType::get_string 4477 ns 4479 ns 156172 -bm_rtl::method____ErasedTargetType::get_string 4454 ns 4456 ns 157109 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4486 ns 4487 ns 155951 +bm_rtl::function__ErasedReturnType::get_string 4437 ns 4436 ns 157746 +bm_rtl::method____ErasedReturnType::get_string 4434 ns 4434 ns 157288 +bm_rtl::method____ErasedTargetType::get_string 4426 ns 4425 ns 158114 +bm_rtl::method____ErasedTargetAndReturnType::get_string 4434 ns 4434 ns 157500 ----------------------------------- -[2025-11-04 11:48:34] >>> Run 2: workload scale = 150 +[2026-01-19 22:37:13] >>> Run 2: workload scale = 150 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 150 iterations ============================================= -2025-11-04T11:48:34+05:30 +2026-01-19T22:37:13+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 4900.01 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 1.02, 0.81 +Load Average: 1.06, 1.02, 0.83 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 3523 ns 3524 ns 198828 +bm_call::direct__Function::set_string 3527 ns 3526 ns 198689 -bm_call::via_function_ptr__Function::set_string 3520 ns 3521 ns 199061 -bm_call::via_function_ptr____Method::set_string 3524 ns 3525 ns 198822 +bm_call::via_function_ptr__Function::set_string 3483 ns 3483 ns 200998 +bm_call::via_function_ptr____Method::set_string 3488 ns 3487 ns 201053 -bm_std::function_calls__Function::set_string 3518 ns 3519 ns 198928 -bm_std::function_calls____Method::set_string 3530 ns 3531 ns 198583 +bm_std::function_calls__Function::set_string 3485 ns 3484 ns 200867 +bm_std::function_calls____Method::set_string 3490 ns 3489 ns 200690 -bm_rtl::function_calls__Function::set_string 3521 ns 3522 ns 198936 -bm_rtl::method_calls______Method::set_string 3525 ns 3526 ns 198848 +bm_rtl::function_calls__Function::set_string 3483 ns 3482 ns 200910 +bm_rtl::method_calls______Method::set_string 3487 ns 3487 ns 200961 -bm_rtl::function__ErasedReturnType::set_string 3527 ns 3528 ns 198359 -bm_rtl::method____ErasedReturnType::set_string 3527 ns 3528 ns 197890 -bm_rtl::method____ErasedTargetType::set_string 3534 ns 3535 ns 197890 -bm_rtl::method____ErasedTargetAndReturnType::set_string 3536 ns 3537 ns 197487 +bm_rtl::function__ErasedReturnType::set_string 3493 ns 3493 ns 200445 +bm_rtl::method____ErasedReturnType::set_string 3491 ns 3491 ns 199857 +bm_rtl::method____ErasedTargetType::set_string 3495 ns 3495 ns 200225 +bm_rtl::method____ErasedTargetAndReturnType::set_string 3495 ns 3494 ns 199782 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 4456 ns 4457 ns 157300 +bm_call::direct__Function::get_string 4404 ns 4404 ns 159253 -bm_call::via_function_ptr__Function::get_string 4449 ns 4450 ns 157301 -bm_call::via_function_ptr____Method::get_string 4457 ns 4458 ns 157197 +bm_call::via_function_ptr__Function::get_string 4394 ns 4394 ns 159252 +bm_call::via_function_ptr____Method::get_string 4504 ns 4504 ns 159232 -bm_std::function_calls__Function::get_string 4449 ns 4450 ns 157266 -bm_std::function_calls____Method::get_string 4458 ns 4460 ns 156701 +bm_std::function_calls__Function::get_string 4571 ns 4570 ns 153180 +bm_std::function_calls____Method::get_string 4586 ns 4585 ns 152353 -bm_rtl::function_calls__Function::get_string 4455 ns 4456 ns 157313 -bm_rtl::method_calls______Method::get_string 4451 ns 4453 ns 157215 +bm_rtl::function_calls__Function::get_string 4578 ns 4578 ns 153148 +bm_rtl::method_calls______Method::get_string 4571 ns 4571 ns 153119 -bm_rtl::function__ErasedReturnType::get_string 4495 ns 4497 ns 155850 -bm_rtl::method____ErasedReturnType::get_string 4494 ns 4495 ns 155702 -bm_rtl::method____ErasedTargetType::get_string 4470 ns 4471 ns 156262 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4508 ns 4510 ns 155393 +bm_rtl::function__ErasedReturnType::get_string 4602 ns 4601 ns 152206 +bm_rtl::method____ErasedReturnType::get_string 4607 ns 4606 ns 151999 +bm_rtl::method____ErasedTargetType::get_string 4589 ns 4588 ns 152669 +bm_rtl::method____ErasedTargetAndReturnType::get_string 4600 ns 4600 ns 152200 ----------------------------------- -[2025-11-04 11:48:59] >>> Run 3: workload scale = 150 +[2026-01-19 22:37:38] >>> Run 3: workload scale = 150 ======== RTL Benchmark Configuration ======== Workload: concatenate string of length 500 Scale : 150 iterations ============================================= -2025-11-04T11:48:59+05:30 +2026-01-19T22:37:38+05:30 Running ./bin/RTLBenchmarkApp -Run on (16 X 2162.72 MHz CPU s) +Run on (16 X 800 MHz CPU s) CPU Caches: L1 Data 48 KiB (x8) L1 Instruction 32 KiB (x8) L2 Unified 1280 KiB (x8) L3 Unified 20480 KiB (x1) -Load Average: 1.01, 1.02, 0.82 +Load Average: 1.04, 1.02, 0.83 -------------------------------------------------------------------------------------------------- Benchmark Time CPU Iterations -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::set_string 3504 ns 3505 ns 199689 +bm_call::direct__Function::set_string 3547 ns 3547 ns 197337 -bm_call::via_function_ptr__Function::set_string 3505 ns 3506 ns 199740 -bm_call::via_function_ptr____Method::set_string 3504 ns 3505 ns 199829 +bm_call::via_function_ptr__Function::set_string 3484 ns 3484 ns 200911 +bm_call::via_function_ptr____Method::set_string 3484 ns 3484 ns 200978 -bm_std::function_calls__Function::set_string 3502 ns 3503 ns 199609 -bm_std::function_calls____Method::set_string 3512 ns 3513 ns 199226 +bm_std::function_calls__Function::set_string 3484 ns 3484 ns 200913 +bm_std::function_calls____Method::set_string 3485 ns 3485 ns 200887 -bm_rtl::function_calls__Function::set_string 3505 ns 3506 ns 199956 -bm_rtl::method_calls______Method::set_string 3504 ns 3505 ns 199794 +bm_rtl::function_calls__Function::set_string 3482 ns 3482 ns 201096 +bm_rtl::method_calls______Method::set_string 3485 ns 3484 ns 200963 -bm_rtl::function__ErasedReturnType::set_string 3519 ns 3520 ns 198946 -bm_rtl::method____ErasedReturnType::set_string 3518 ns 3519 ns 198913 -bm_rtl::method____ErasedTargetType::set_string 3525 ns 3526 ns 198501 -bm_rtl::method____ErasedTargetAndReturnType::set_string 3525 ns 3526 ns 198610 +bm_rtl::function__ErasedReturnType::set_string 3490 ns 3490 ns 200491 +bm_rtl::method____ErasedReturnType::set_string 3491 ns 3491 ns 200589 +bm_rtl::method____ErasedTargetType::set_string 3496 ns 3495 ns 200278 +bm_rtl::method____ErasedTargetAndReturnType::set_string 3496 ns 3496 ns 200227 -------------------------------------------------------------------------------------------------- -bm_call::direct__Function::get_string 4431 ns 4432 ns 157921 +bm_call::direct__Function::get_string 4561 ns 4560 ns 153507 -bm_call::via_function_ptr__Function::get_string 4440 ns 4441 ns 157629 -bm_call::via_function_ptr____Method::get_string 4441 ns 4442 ns 157533 +bm_call::via_function_ptr__Function::get_string 4560 ns 4559 ns 153553 +bm_call::via_function_ptr____Method::get_string 4559 ns 4559 ns 153622 -bm_std::function_calls__Function::get_string 4440 ns 4441 ns 157655 -bm_std::function_calls____Method::get_string 4437 ns 4438 ns 157742 +bm_std::function_calls__Function::get_string 4559 ns 4559 ns 153581 +bm_std::function_calls____Method::get_string 4578 ns 4578 ns 152921 -bm_rtl::function_calls__Function::get_string 4439 ns 4440 ns 157633 -bm_rtl::method_calls______Method::get_string 4441 ns 4443 ns 157563 +bm_rtl::function_calls__Function::get_string 4627 ns 4627 ns 153630 +bm_rtl::method_calls______Method::get_string 4486 ns 4484 ns 158892 -bm_rtl::function__ErasedReturnType::get_string 4470 ns 4471 ns 156524 -bm_rtl::method____ErasedReturnType::get_string 4472 ns 4474 ns 156472 -bm_rtl::method____ErasedTargetType::get_string 4448 ns 4449 ns 157314 -bm_rtl::method____ErasedTargetAndReturnType::get_string 4478 ns 4479 ns 156261 +bm_rtl::function__ErasedReturnType::get_string 4433 ns 4433 ns 156084 +bm_rtl::method____ErasedReturnType::get_string 4433 ns 4432 ns 157643 +bm_rtl::method____ErasedTargetType::get_string 4403 ns 4403 ns 158980 +bm_rtl::method____ErasedTargetAndReturnType::get_string 4422 ns 4421 ns 157853 ----------------------------------- All benchmarks completed. diff --git a/docs/benchmark_summary.md b/docs/benchmark_summary.md new file mode 100644 index 00000000..a74cda08 --- /dev/null +++ b/docs/benchmark_summary.md @@ -0,0 +1,104 @@ +# ⚡ RTL Performance Summary + +This document provides a concise, evidence-backed overview of the runtime performance characteristics of **RTL**, derived from systematic microbenchmarking across multiple workload scales, CPU frequencies, and typical real-world C++ usage patterns. + +## Benchmark Overview + +The benchmark measures the cost of calling functions that perform simple but realistic `string` work. Two variants are evaluated using the types `std::string_view` and `std::string`. + +### Lightweight Workflow + +The `set`/`get` functions are called via reflection and, RTL’s dispatch layer perfect-forwards the provided arguments to the target call site. + +* The input string of length 500 is passed by value as `std::string_view`. +* The function `set(std::string_view)` copies the argument. This copy is very lightweight, as it only contains a pointer and a size. +* The actual work performed is concatenating the passed string into a global `std::string` for a given number of iterations (the workload scale). +* The getter, `std::string_view get(std::string_view)`, follows the same flow, including the argument copy, and returns a `std::string_view` pointing to the globally stored string, which is again a lightweight object. + +### Heavy Workflow + +The dispatch setup of the heavy workflow is the same, except it uses `std::string` instead of `std::string_view`, which means: + +* The input string is passed by value as `std::string` and is copied on every call. Both `set` and `get` perform this copy operation for a 500-character string, typically involving heap allocation. +* Each workload iteration concatenates this 500-character string into the global storage. +* The getter `std::string get(std::string)`, returns a full `std::string` copy of the accumulated global string, which grows in size with the workload and requires heap allocation. + +In both cases, the real work is dominated by string concatenation, allocation, and copying. +The benchmarks therefore highlight how different call paths – direct calls, `std::function`, and reflected(`rtl::function`/`rtl::method`) calls behave when meaningful work is present, rather than measuring dispatch overhead in isolation. + +Workload scales tested: *0, 1, 5, 10, 15, 20, 25 … up to 150.* + +## 🚀 Results with `std::string_view` Workflow + +### Dispatch Overhead + + + +***RTL (standard)** refers to typed calls where the target and return types are known at compile time.* + +### Scaling Workloads (0 to 150) + + + +### Observations + +* `rtl::function` matches or outperforms `std::function`. +* Non-erased RTL calls are effectively zero-overhead. +* Erased return types introduce measurable but bounded overhead. +* Dispatch cost is quickly amortized once real work is present. + +## 🧱 Results with `std::string` Workflow + +### Dispatch Overhead + + + +### Scaling Workloads (0 to 150) + + + +### Observations + +* Getter cost is significantly higher due to return-by-value. +* Memory allocation and copying dominate runtime. +* Reflection overhead becomes negligible in comparison. +* Even fully erased RTL calls remain within ~3–5% of direct calls. + +## 📌 Key Insights + +* `rtl::function` consistently matches or outperforms `std::function` across all workloads. +* Non-erased RTL calls behave like near-zero-overhead abstractions, comparable to raw function pointers. +* Type erasure introduces overhead, but the cost is bounded and predictable. +* Return-type erasure is more expensive than target-type erasure, especially for `std::string` return values. +* As workload size increases, real work dominates dispatch overhead. +* Memory allocation and string copying become the primary performance costs. +* Reflection does not distort scaling behavior or introduce nonlinear slowdowns. +* The value vs view semantics have a larger performance impact than reflection itself. + +## 🖥️ Test Bed + +The benchmarks were executed on a Linux x86_64 system in a typical release-style configuration. The details below capture the essential factors needed for reproducibility. + +* **OS:** Linux (Kernel `6.12.38+kali-amd64`) +* **Compiler:** Clang++ **21.1.8** +* **C++ Standard:** GNU++20 (`-std=gnu++20`) +* **Optimization:** `-O3 -DNDEBUG` +* **LTO:** disabled (no `-flto`) +* **RTTI / Exceptions:** enabled (defaults) +* **CPU tuning:** generic x86-64 (no `-march=native`) +* **Standard library:** `libstdc++` (system default) + +**Hardware (observed):** + +* 16 logical cores +* Dynamic frequency scaling (~800 MHz – ~4.8 GHz) + +Benchmarks were run multiple times under **low system load** (load average consistently < 1.0, as recorded in logs) to ensure stable and comparable performance trends across workloads. + +## 📂 Raw Benchmark Logs + +[benchmark_runs_string.log](benchmark_runs_string.log) + +[benchmark_runs_string_view.log](benchmark_runs_string_view.log) + +These logs contain the full per-scale measurements for all dispatch paths, including multiple runs at different CPU frequencies to validate consistency. diff --git a/docs/images/string_micro_bm.png b/docs/images/string_micro_bm.png new file mode 100644 index 00000000..cce074d1 Binary files /dev/null and b/docs/images/string_micro_bm.png differ diff --git a/docs/images/string_view_micro_bm.png b/docs/images/string_view_micro_bm.png new file mode 100644 index 00000000..dc74fbb9 Binary files /dev/null and b/docs/images/string_view_micro_bm.png differ diff --git a/docs/images/string_view_workload_bm.png b/docs/images/string_view_workload_bm.png new file mode 100644 index 00000000..c522823d Binary files /dev/null and b/docs/images/string_view_workload_bm.png differ diff --git a/docs/images/string_workload_bm.png b/docs/images/string_workload_bm.png new file mode 100644 index 00000000..6e7bcb1f Binary files /dev/null and b/docs/images/string_workload_bm.png differ diff --git a/text-benchmark-logs/flat-overhead-analysis.md b/text-benchmark-logs/flat-overhead-analysis.md deleted file mode 100644 index 21690c7d..00000000 --- a/text-benchmark-logs/flat-overhead-analysis.md +++ /dev/null @@ -1,75 +0,0 @@ -# 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. diff --git a/text-design-docs/DESIGN_PRINCIPLES_AND_FEATURES.md b/text-design-docs/DESIGN_PRINCIPLES_AND_FEATURES.md deleted file mode 100644 index a6702599..00000000 --- a/text-design-docs/DESIGN_PRINCIPLES_AND_FEATURES.md +++ /dev/null @@ -1,121 +0,0 @@ -### 🪶 No Static Globals, No Macros, No Surprises - -RTL does not rely on: - -* Hidden static registration -* Centralized global registries -* Preprocessor hacks - -Instead, registration is explicit and lazy. - -For each registered type, RTL contributes **two lightweight entries** into its process-local tables: - -* A **lambda wrapper** placed in a scoped `static` `std::vector` and is responsible for making the final call using the actual functor. -* A **raw function pointer** stored in a parallel scoped `static` `std::vector`, used to detect and prevent redundant registrations. - -From there, `rtl::CxxMirror` does not hold onto heavyweight state. It is **as ordinary as any local variable** — you can construct one, keep it alive for the entire application, or discard it after a short-lived query. The `CxxMirror` can be materialized again with the same or different set of types. RTL guarantees that **materializing the same registration statement multiple times** (for example): - -```cpp -rtl::type().member().method("getName").build(&Person::getName); -``` - -will always yield **exactly the same metadata**, without ever admitting redundant lambdas or functors into the static tables. - -> *"Mirrors are **cheap and repeatable**: the metadata is stable, redundant entries are never entertained, and the user remains in full control of a mirror’s lifetime."* - ---- - -### ⚡ Reflective Call Performance - -Reflective calls in RTL are designed to be explicit, predictable, and minimal. The mechanism unfolds in two clear steps: - -1. **Signature Matching** — Each call signature yields a unique type-ID, compared directly against the ID of the lambda-table holding the final call. With a single overload this resolves immediately; if multiple overloads exist, RTL just scans a tiny `std::vector` of candidate IDs. - -2. **Call Dispatch** — Once the correct overload is identified, RTL performs constant-time `std::vector` indexing to retrieve the associated lambda wrapper. This wrapper executes a single hop to the underlying function pointer, forwarding the provided arguments perfectly. - -The net overhead of a reflective call is thus a handful of integer comparisons, one direct `std::vector` access, and one lambda-to-function-pointer indirection. There are no dynamic allocations, RTTI lookups, or hidden metadata traversals at call time. The cost is transparent and limited to exactly what is required for overload resolution and safe forwarding — no more, no less. - -> *"A reflective call in RTL is not free, but its cost is explicit, transparent, and no greater than what you would write by hand."* - ---- - -### 🛡 Exception-Free Guarantee - -RTL is designed to be virtually exception-free. If an exception ever emerges from RTL, it signals that something deeper is wrong. In practice, such exceptions are almost always caused by client/user code and merely propagate through RTL. Internally, only one scenario could theoretically throw: - -* `std::any_cast` — guarded by strict, break-proof type checks that make throwing virtually impossible. - -This is extremely unlikely, but not absolutely impossible — no system is perfect. -For every predictable failure case, RTL returns explicit error codes instead of throwing. -RTL validates all critical assumptions before proceeding, ensuring predictable behavior and eliminating mid-operation surprises. - -> *"Exceptions should never surprise you — in RTL, failures are explicit, validated, and reported as error codes, not as hidden runtime traps."* - ---- - -### 🔒 Const-By-Default Discipline - -RTL enforces a *const-by-default* discipline. All objects **created through reflection** start as *logically-const* — they default to immutability. If no const overload exists, RTL will **automatically fall back** to the non-const overload, since these objects were never originally declared `const`. Explicit `rtl::constCast()` is only required when both const and non-const overloads are present. - -The guiding principle is simple: reflective objects are safe by default, and any mutation must be a conscious, visible decision by the caller. - -At the same time, RTL strictly respects **true-const** objects (e.g., declared-`const` instances or const return values). Such objects remain immutable inside RTL — any attempt to force mutation results in predictable error code (`rtl::error::IllegalConstCast`). - -> *"RTL never mutates true-const objects, and for RTL-created ones it defaults to const, falling back only if needed — explicit rtl::constCast() is required when both overloads exist."* - -This discipline complements RTL’s exception-free guarantee, ensuring both **predictability** and **safety** at the API boundary. - ---- - -### 🎁 Transparent Handling of Smart Pointers - -Reflection should never feel like a cage. -In everyday C++, if you hold a `std::unique_ptr` or `std::shared_ptr`, you don’t think twice about how to use it — you simply work with the object it points to, sometimes copying it, sometimes sharing it, sometimes moving it. RTL extends this same natural experience into runtime reflection. - -Every heap object created through RTL is safely managed inside a smart pointer. Yet to you, as the developer, that detail is invisible. You can look at it as the smart pointer if you wish, or simply as the underlying type `T`. - -When you ask RTL to clone, it adapts to the situation in the most intuitive way: - -* If a type is naturally shared, you can get a shared view. -* If it is unique, RTL respects that uniqueness. -* And if the value itself can be copied, you can always ask for a fresh independent object. - -The key idea is that RTL doesn’t force you into a wrapper-first mindset. Instead, it makes wrappers feel transparent — you can still reason in terms of *your type*, just as you would in normal C++. - -> *"Developers shouldn’t have to think about “reflection semantics” versus “normal C++ semantics.” With RTL, the two worlds are aligned. Whether you’re holding a raw object or a smart pointer, the same intuition applies — reflection just works the way you expect."* - ---- - -### 🧠 Tooling-Friendly Architecture - -**RTL** separates the *generation* of reflection metadata from its *consumption*. This makes it ideal not just for runtime introspection, but also for external tools like: - -* Code generators -* Serialization pipelines -* Game or UI editors -* Live scripting or plugin systems - -#### ✨ The Mirror & The Reflection - -> *A client system hands off a `CxxMirror` to RTL — and RTL sees its reflection.* - -That’s it. The mirror is a **single object**, typically returned from a function like: - -```cpp -extern const rtl::CxxMirror& MyReflection(); -``` - -This function is: - -* **Externally linkable** — can live in any translation unit or even dynamic module -* **Lazy** — doesn’t require metadata unless explicitly accessed -* **Pure** — returns a complete, immutable view of reflection metadata - -#### 📎 Why This Matters for Tooling - -This design turns RTL into a **pluggable, runtime-agnostic consumer** of metadata. You can: - -* Reflect types from external libraries -* Link in auto-generated metadata modules -* Expose your reflection system to scripts or tools without tight coupling -* Swap different `CxxMirror` sources depending on build mode (dev/editor/runtime) diff --git a/text-design-docs/RTL_SYNTAX_AND_SEMANTICS.md b/text-design-docs/RTL_SYNTAX_AND_SEMANTICS.md deleted file mode 100644 index b1487991..00000000 --- a/text-design-docs/RTL_SYNTAX_AND_SEMANTICS.md +++ /dev/null @@ -1,514 +0,0 @@ -# RTL at a Glance: Syntax & Semantics ⚡ - -RTL makes C++ reflection feel like a natural extension of the language. Let’s explore its syntax and the semantics it unlocks. -This guide walks you step by step through RTL’s reflection syntax. - -### 📖 Index - -1. [Building the Mirror 🪞](#building-the-mirror-) -2. [Getting Started with Registration 📝](#getting-started-with-registration-) -3. [Reflective Invocations with RTL ✨](#reflective-invocations-with-rtl-) - - * [Querying C-Style Functions 🔍](#querying-c-style-functions) - * [Performing Reflective Calls ⚙️](#performing-reflective-calls) - * [Extracting Return Values 📤](#extracting-return-values) - * [Querying Member Functions 👤](#querying-member-functions) - * [Binding an Object and Calling 🔗](#binding-an-object-and-calling) - * [Binding Signatures and Perfect Forwarding 🎯](#binding-signatures-and-perfect-forwarding) - * [Const vs Non-Const Method Binding ⚡](#const-vs-non-const-method-binding) -4. [Const-by-Default Discipline 🛡️](#const-by-default-discipline) -5. [Reflective Construction and Destruction 🏗️](#reflective-construction-and-destruction) -6. [Move Semantics in RTL 🔀](#move-semantics-in-rtl) - ---- - -## Building the Mirror 🪞 - -Before registering anything, you need a central place to hold all reflection metadata: the `rtl::CxxMirror`. You can create an instance, passing all type metadata through an initializer list — each type obtained via `rtl::type()`. - -```cpp - auto cxx_mirror = rtl::CxxMirror({ - // .. all the registrations go here, comma separated .. - }); -``` - -Every registration statement you add here is collected into the `rtl::CxxMirror` as an `rtl::Function` object. The `CxxMirror` forms the backbone of RTL. Every type, function, or method you register ultimately gets encapsulated into this single object, serving as the gateway to query, introspect, and instantiate all registered types at runtime. - -### A few key points about managing this object - -* ***Dispensable by design*** → The `CxxMirror` itself carries no hidden global state. You can define one central mirror, create multiple mirrors in different scopes, or even rebuild mirrors on demand. RTL imposes no restriction on how you manage its lifetime. - -* ***Duplicate registration is harmless*** → Identical registrations always materialize the same metadata. If a canonical function pointer is already registered, it is not added again to the lambda/functor table — the metadata simply refers back to the existing entry. - -* ***Thread-safety guaranteed by RTL*** → No matter how you choose to manage mirrors (singleton, multiple, or transient), RTL itself guarantees synchronized, race-free registration and access across threads. - -* ***Overhead is deliberate*** → Each registration carries a small cost in memory and initialization time. Concretely: - * Every registration statement acquires a lock on the functor table. - * It checks whether the function or lambda is already present. - * If not, it adds the new entry to the lambda table and updates the functor table. - -This ensures thread-safety and prevents redundant entries. While negligible for isolated registrations, this cost can accumulate when creating many mirrors or registering large numbers of types. - -👉 Bottom Line -> *"Manage `CxxMirror` however your design requires — singleton, multiple, or transient. Each registration incurs a lock and table lookup, but the cost is negligible in normal use and only noticeable when scaling to very large numbers of types."* - ---- - -## Getting Started with Registration 📝 - -The fundamental pattern of registration in RTL is a **builder combination**. You chain together parts to declare what you are reflecting, and then call `.build()` to complete it. - -### Non-Member Functions - -```cpp -rtl::type().ns("ext").function<..signature..>("func").build(ptr); -``` - -* **`ns("ext")`**: specifies the namespace under which the function lives. Omitting `.ns()` or passing an empty string `.ns("")` keeps the function in the global namespace. -* **`function<..signature..>("func")`**: declares the function by name. If overloaded, the template parameter `<..signature..>` disambiguates which overload to pick. -* **`.build(ptr)`**: supplies the actual function pointer to complete the registration. - -### Handling Overloads - -If multiple overloads exist, you must specify the signature in the template argument. Otherwise, the compiler cannot resolve which function pointer you mean. - -For example: - -```cpp - -bool sendMessage(const char*); -void sendMessage(int, std::string); - -rtl::type().ns("ext").function("sendMessage").build(ext::sendMessage); -rtl::type().ns("ext").function("sendMessage").build(ext::sendMessage); -``` - -### Classes / Structs - -```cpp -rtl::type().ns("ext").record("Name").build(); -``` - -* Registers a type by reflective name under a namespace. -* This step is **mandatory** to register any of its members. -* Default, copy, and move constructors, along with the destructor, are automatically registered. Explicit registration of these special members is disallowed and will result in a compile error. - -### Constructors - -```cpp -rtl::type().member().constructor<..signature..>().build(); -``` - -* **`.member()`**: enters the scope of class/struct `T`. -* **`.constructor<..signature..>()`**: registers a user-defined constructor. The template parameter `<..signature..>` must be provided since no function pointer is available for deduction, and this also disambiguates overloads. - -### Member Functions - -```cpp -rtl::type().member().method<..signature..>("method").build(&T::f); -``` - -* **`.member()`**: enters the scope of class/struct `T`. -* **`.method<..signature..>(...)`**: registers a non-const member function. The template parameter `<..signature..>` disambiguates overloads. -* Variants exist for const (`.methodConst`) and static (`.methodStatic`) methods. - -👉 **Note:** -> ***The `function<..signature..>` and `method<..signature..>` template parameters are primarily for overload resolution. They tell RTL exactly which overload of a function or method you mean to register.*** - -With these constructs—namespaces, non-member functions, overloads, records `(class/struct)`, constructors, and methods—you now have the full registration syntax for RTL. Together, they let you build a complete reflective model of your C++ code. - ---- - -## Reflective Invocations with RTL ✨ - -Discover how to query, invoke, and manipulate functions and objects at runtime using RTL’s powerful reflection API. -Once a function is registered in `rtl::CxxMirror`, you can query it and perform reflective calls dynamically. - - - -### Querying C-Style Functions 🔍 - -```cpp -// Function without a namespace -std::optional popMessage = cxx::mirror().getFunction("popMessage"); - -// Function registered with a namespace -std::optional sendMessage = cxx::mirror().getFunction("utils", "sendMessage"); -``` - -* If a function is registered **without a namespace**, it can only be retrieved without specifying a namespace. -* If a function is registered **with a namespace**, it **must** be queried with the correct namespace. -* The returned value is an `std::optional`. If the function is not found, the optional is empty. - -```cpp -if (popMessage) -{ - // function exists, safe to invoke -} -``` - ---- - - - -### Performing Reflective Calls ⚙️ - -Once you have a `rtl::Function`, a complete reflective call involves two steps: - -```cpp -auto [err, retObj] = popMessage->bind().call(); -``` - -* **`.bind<>()`**: Associates an object for member functions and allows explicit specification of the **signature** of the arguments to be forwarded. For non-member functions, you can simply call `.bind()` without arguments. -* **`.call(args...)`**: Executes the function with the provided arguments. - -Every reflective call returns a `std::pair`: - -* `rtl::error` indicates whether the call was successful (`rtl::error::None`) or if an error occurred. - - * `rtl::error::SignatureMismatch` → provided arguments/signature don’t match with expected signature or any overload. -* `rtl::RObject` contains the return value if the function returns something, or is empty if the function returns `void`. - ---- - - - -### Extracting Return Values 📤 - -```cpp -if (err == rtl::error::None) -{ - if (!retObj.isEmpty() && retObj.canViewAs()) - { - std::optional> viewStr = retObj.view(); - std::string retStr = viewStr->get(); // fully-typed returned string - } -} -``` - -* Return Handling Summary - -When dealing with `rtl::RObject` results: - -| Function | Purpose | -| ------------------ | ----------------------------------------------------------------------------------------------------------------------- | -| `isEmpty()` | Checks if the function returned anything (i.e., non-`void`). | -| `canViewAs()` | Quick type check: returns `true` if the stored type is exactly `T` or safely convertible. | -| `view()` | Retrieves a typed **view** of the stored value if possible. Returns an empty `std::optional` if the type doesn’t match. | -| `view()->get()` | Extracts a const reference or value of `T` from the view, safely typed. | - -👉 **Tip** - -> ***Use `canViewAs()` for a cheap boolean check when branching, and `view()` when you actually need the value.*** - ---- - - - -### Querying Member Functions 👤 - -Member functions require an instance of the class to call upon. RTL provides a two-step process: first retrieve the `rtl::Record` for the type, then get the `rtl::Method` from that record. - -```cpp -// Retrieve the record for the class -std::optional classPerson = cxx::mirror().getRecord("Person"); - -if (classPerson) -{ - // Retrieve a specific method from the record - std::optional setProfile = classPerson->getMethod("setProfile"); - - if (setProfile) - { - // You can now bind an object and call the method - } -} -``` - -* `getRecord("TypeName")` returns the registered class/struct as `rtl::Record`. -* `getMethod("methodName")` retrieves a member function from the record. Returns `std::optional`. -* An empty optional indicates the method was not found. - ---- - - - -### Binding an Object and Calling 🔗 - -```cpp -auto [err, retObj] = setProfile->bind(targetObj).call(std::string("Developer")); -``` - -* **`.bind(targetObj)`**: binds the target instance for the method. - - * `targetObj` is an `rtl::RObject` instance representing the object. - * You can create this instance reflectively using the `rtl::Record`’s constructor (we’ll cover this shortly). -* **`.call(args...)`**: executes the method on the bound object with the provided arguments. - -Errors specific to member function calls: - -* `rtl::error::TargetMismatch` → when the bound `RObject` does not represent the same type as the method’s owning class. -* `rtl::error::EmptyTarget` → when attempting to bind an empty `RObject`. -* `rtl::error::SignatureMismatch` → provided arguments/signature don’t match with expected signature or any overload. - ---- - - - -### Binding Signatures and Perfect Forwarding 🎯 - -```cpp -setProfile->bind(targetObj).call(10); // 10 forwarded as int -setProfile->bind(targetObj).call(10); // 10 forwarded as double (10.0) -setProfile->bind(targetObj).call(10); // compile-time error -``` - -* The template parameter in `bind<..signature..>()` tells RTL how to perceive and forward the arguments. -* RTL uses the template signature to ***figure out*** which method (and which overload, if multiple exist) to select from the registration. -* All arguments are forwarded as universal references (`&&`), enabling **perfect forwarding** with **no copies**. Arguments are ultimately received exactly as the registered function expects (`lvalue`, `rvalue`, `const-lvalue-ref`). -* `rtl::RObject` contains the return value, or is empty if the method returns `void`. - -> ***By retrieving a `Method` from a `Record`, binding a target instance, and specifying the signature as needed, RTL allows safe, perfectly-forwarded reflective calls on member functions.*** - ---- - - - -### Const vs Non-Const Method Binding ⚡ - -When binding methods reflectively, RTL enforces const-correctness in a way that mirrors C++ itself, but with an extra layer of runtime safety. Let’s walk through how this works. - -#### Default Behavior - -Whenever both `const` and `non-const` overloads of a method exist, RTL prefers the **const overload**. This is consistent with RTL’s *const-by-default* philosophy: reflective calls always begin from the safest stance possible. - -```cpp -Person john("John"); -rtl::RObject robj = rtl::type(john); // Reflect object with statically-type; details covered later. - -// If both overloads exist, RTL selects the const one. -auto [err, ret] = someMethod->bind(robj).call(); -``` - -#### Choosing the Non-Const Path - -Sometimes you really do want the non-const overload. RTL requires you to be explicit in that case, by using `rtl::constCast()`: - -```cpp -auto [err, ret] = someMethod->bind(rtl::constCast(robj)).call(); -``` - -This signals intent clearly: *“Treat this object as non-const for this call.”* If the object is safe to cast, RTL allows it. - -#### Fallback to Non-Const - -If a class only defines a non-const method and no const variant exists, RTL will safely fall back and bind to the non-const overload. No extra steps are required, and this remains safe so long as the object wasn’t originally declared `const`. - -#### Declared-Const Objects - -Things change when the reflected object itself was declared `const` in the first place: - -```cpp -const Person constSam("Const-Sam"); // Reflect 'const' with statically-type; details covered later. -rtl::RObject robj = rtl::type(constSam); -``` - -Here, RTL preserves that constness strictly. Non-const methods cannot be invoked on such an object. Attempts to do so will result in `rtl::error::IllegalConstCast`. - -If you attempt a method where **no const overload exists**, RTL reports `rtl::error::ConstOverloadMissing`. - -#### Checking Provenance - -Because reflective calls may hand back new `RObject`s, you may sometimes wonder whether an object is safe to cast. That’s what `isConstCastSafe()` is for: - -```cpp -bool safe = robj.isConstCastSafe(); -``` - -* `false` → The object was originally declared const; treating it as mutable is unsafe. -* `true` → The object wasn’t originally const; RTL may relax constness internally if needed. - -#### Error Codes - -* **None** → Success; call resolved safely. -* **ConstOverloadMissing** → A const-qualified overload was required but not found. -* **NonConstOverloadMissing** → A non-const overload was explicitly requested but not found. -* **IllegalConstCast** → Attempted to cast away `const` from a true-const object. - -#### Summary - -* RTL defaults to the const overload when both exist. -* Explicitly request the non-const overload with `rtl::constCast()`. -* If only non-const exists, RTL uses it safely (unless the object was declared const). -* Declared-const objects reject non-const calls (`rtl::error::IllegalConstCast`) and fail if no const overload is present (`rtl::error::ConstOverloadMissing`). -* `isConstCastSafe()` tells you whether relaxation is permitted. -* Reflective objects are always const-first; declared-const objects are strictly immutable. - ---- - - -## Const-by-Default Discipline 🛡️ - -C++ treats **const** as a contract: a `const` object can only invoke `const` methods, and any attempt to mutate it without an explicit `const_cast` leads to undefined behavior. A non-const object, by contrast, freely chooses non-const overloads but can fall back to const ones when needed. - -RTL mirrors this model but strengthens it with **provenance-aware constness**. In other words, RTL distinguishes between objects it created itself and objects provided externally, applying rules that match their origin. - -### Two Kinds of Constness in RTL - -* **Logically-Const (RTL-Created)** - - * Objects constructed reflectively—whether on the stack or heap—are treated as *const-first*. - * If a non-const overload is the only option, RTL may safely apply an internal `const_cast` because these objects were never originally declared `const`. - * Users can still opt into non-const explicitly via `rtl::constCast()` if both overloads exist. - -* **True-Const (Externally Provided)** - - * Objects passed into RTL with declared `const` remain **strictly const**. - * RTL will never cast them internally, ensuring you can’t accidentally mutate something the compiler itself forbids. - * Missing const overloads result in `rtl::error::ConstOverloadMissing`. Forcing a non-const call results in `rtl::error::IllegalConstCast`. - -### Quick Comparison - -| Case | Native C++ | RTL Behavior | -| -------------------- | ---------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | -| **Const object** | Only const overload allowed; non-const requires cast; mutation is UB. | **True-const**: only const overload allowed; missing const → `ConstOverloadMissing`; forcing non-const → `IllegalConstCast`. | -| **Non-const object** | Prefers non-const overload, but may call const if that’s the only one. | **Logically-const**: defaults to const; missing const but non-const present → safe fallback; both present → explicit non-const via `rtl::constCast()`. | - -✅ Key Takeaway - -RTL codifies C++’s const rules at runtime: - -* **True-const** objects are strictly immutable. -* **Logically-const** objects default to immutability but can be safely relaxed when overload resolution requires it. - -This makes overload resolution **predictable, safe, and explicit**, giving you runtime reflection that behaves like C++—but with added clarity. - ---- - - -## Reflective Construction and Destruction 🏗️ - -Reflection in RTL doesn’t stop at functions and methods — you can also create full-fledged objects at runtime, directly through their reflected constructors. Cleanup, on the other hand, is fully automatic thanks to C++’s RAII. - -### Constructing Objects - -To construct a reflected object, first grab the `Record` that represents the type, then call one of its `create` helpers: - -```cpp -std::optional classPerson = cxx::mirror().getRecord("Person"); - -// Default constructor — create on heap -auto [err, person] = classPerson->create(); -if (err == rtl::error::None) -{ - // construction successful, use object to call methods now... -} - -// Overloaded constructor — this time create on stack -auto [err, person] = classPerson->create( - std::string("John Doe"), - 42 -); -``` - -Key takeaways: - -* Allocation policy is always explicit — you decide `Heap` or `Stack`. -* Creation returns `[rtl::error, rtl::RObject]`. -* If construction fails, `error != rtl::error::None` and the `RObject` will be empty. -* `rtl::error::SignatureMismatch` if provided arguments/signature don’t match with expected signature or any overload. -* `RObject` is the type-erased container that can hold either: - - * An instance created via a reflected constructor. - * A return value from any reflected call (as we have already seen earlier). - -### Destruction Semantics - -RTL does **not** give you a “destroy” API. All lifetime management is pure **RAII**: - -* **Heap objects** → wrapped in `std::unique_ptr`, destroyed automatically when the owning `RObject` goes out of scope. -* **Stack objects** → destroyed at scope exit like any local variable. -* **Return values** → temporary values that follow normal C++ value semantics. - -This design is intentional: - -* No risk of manual double-free or dangling references. -* Mirrors idiomatic C++ usage — you never call destructors explicitly in regular code, and you don’t here either. - -**Bottom line:** you never destroy a reflected object yourself — RAII does it for you. - -### Creating Reflected Objects With Static-Type - -Besides constructing objects via reflective calls (`create()` or `create()`), RTL also lets you create an `RObject` by **reflecting an existing object**: - -```cpp -Person mutableSam("Mutable-Sam"); -const Person constSam("Const-Sam"); - -rtl::RObject robj1 = rtl::type(mutableSam); -rtl::RObject robj2 = rtl::type(constSam); -``` - -* This always creates a **copy on the stack** inside the `RObject`. -* These stack-based reflections are **scope bound** and never heap-managed. -* Useful for **testing**, since you can quickly reflect arbitrary statically-typed objects. - ---- - - -## Move Semantics in RTL 🔀 - -Let’s walk you through how **move semantics** work in RTL. Since `rtl::RObject` is **move-only** (copying is disallowed), moving objects is the primary way ownership is transferred. The behavior differs depending on whether the object was created on the **stack** or the **heap**. - -### Moving Stack-Allocated Objects - -When you create an object reflectively with `alloc::Stack`, the underlying instance lives directly inside the `RObject`. Moving such an `RObject` looks just like a regular C++ move: - -```cpp -RObject obj1 = /* created on stack */; -RObject obj2 = std::move(obj1); -``` -**What happens here:** - -* The reflected type’s **move constructor** is invoked. -* Ownership of the object transfers into `obj2`. -* The moved-from object (`obj1`) becomes **empty**. -* No duplication or destruction happens — the object is simply relocated. - -👉 **Key idea:** -> *Stack move = reflected type’s move constructor is called.* - -### Moving Heap-Allocated Objects - -When you create an object reflectively with `alloc::Heap`, the instance is managed inside a **`std::unique_ptr`**. Moving such an `RObject` also uses standard C++ move semantics: - -```cpp -RObject obj1 = /* created on heap */; -RObject obj2 = std::move(obj1); -``` -**What happens here:** - -* The internal `unique_ptr` is moved. -* No move constructor of the reflected type is called. -* Ownership transfers to `obj2`. -* The moved-from object (`obj1`) becomes **empty**. -* The underlying heap object remains untouched and alive until its final owner is destroyed. - -👉 **Key idea** -> ***Heap move = `unique_ptr` move semantics (cheap pointer transfer).*** - -### Consistent Guarantees 🟨 - -Across both stack and heap moves: - -* The moved-from `RObject` is always **empty**. -* The destination `RObject` becomes the sole owner. -* RAII ensures proper cleanup — objects are destroyed once and only once. -* Cloning or invoking a moved-from object results in `rtl::error::EmptyRObject`. - -✅ Bottom Line -> ***“When you move an `RObject`, RTL either calls your type’s move constructor (stack) or transfers ownership of its `unique_ptr` (heap). In both cases, the source is emptied and ownership remains safe.”*** - ---- - -***More to come...*** diff --git a/text-design-docs/WHY_CPP_REFLECTION_MATTERS.md b/text-design-docs/WHY_CPP_REFLECTION_MATTERS.md deleted file mode 100644 index 58d7a1b6..00000000 --- a/text-design-docs/WHY_CPP_REFLECTION_MATTERS.md +++ /dev/null @@ -1,133 +0,0 @@ -# 🎯 Why Runtime Reflection in C++ (with RTL) Matters - -> **Position**: Runtime reflection is not “anti‑C++.” It’s an opt‑in capability that, when scoped and engineered correctly, unlocks workflows that are painful or impossible with templates alone—without betraying C++’s zero‑cost ethos. RTL makes this practical, safe, and tooling‑friendly. - ---- - -C++ culture favors compile‑time solutions, but not all problems are compile‑time problems. Static metaprogramming has costs too: binary/code size, compile times, and readability. - -RTL’s design (⚡ macro‑free, 🧩 external registration, ⏳ lazy/immutable `CxxMirror`, 🛠️ error‑code surfaces, 🔒 const‑by‑default, ♻️ deterministic lifetimes) reduces the classic risks of runtime reflection while preserving type safety where it matters. - -The philosophy is simple: use reflection at the edges (tooling, glue, scripting, plugins, serialization) and keep hot code paths static. - ---- - -## 🚧 Why Some C++ Developers Say “No” - -1. **Zero‑cost ideology** – Fear of paying for metadata you don’t use. -2. **Static‑first mindset** – Preference for templates/constexpr over any runtime mechanism. -3. **ABI/portability concerns** – Lack of a stable C++ ABI across platforms/compilers. -4. **Safety/predictability worries** – Fear of “stringly‑typed” APIs, hidden costs, harder debugging. -5. **Cultural inertia** – The ecosystem grew up without runtime reflection. - -These instincts are valid—but not disqualifiers. Instead, they set requirements for a responsible design. - ---- - -## ✨ RTL’s Philosophical Response - -* **Opt‑in, pay‑as‑you‑go** – Metadata is externally defined and lazy‑loaded via an immutable `CxxMirror`. If you don’t access reflection, you don’t pay. -* **No hidden global state** – No static registries, macros, or preprocessor hacks. Developers control what’s exposed and when. -* **Type‑safety discipline** – - - * 🚫 Exception‑free surfaces (errors via codes). - * 🔒 Const‑by‑default to avoid accidental mutation. - * 🎯 Conservative parameter matching (safe widenings, string‑like conversions, smart‑pointer transparencies) with clear rules. -* **Deterministic lifetimes** – `RObject` is a type‑erased, lifetime‑aware handle. It preserves `Heap`/`Stack` ownership and never hides deep copies. -* **Tooling‑friendly split** – Metadata providers and runtime consumers are decoupled; the mirror is swappable per build/mode and load‑on‑touch. - -📌 **Bottom line:** RTL preserves the values of C++ (control, performance, explicitness) while offering runtime shape where it’s needed. - ---- - -## 🚀 What Becomes Possible (Parity With Java/C#‑style Workflows) - -1. **📦 Generic Serialization/Deserialization** – Walk members/methods at runtime to build serializers without hand‑rolled boilerplate. -2. **🐍 Scripting Bridges (Lua/Python/JS)** – Expose app objects dynamically to scripts; invoke methods by name with safe conversions. -3. **🖼️ Inspector UIs & Editors** – Auto‑generate property panels (Qt/ImGui) from metadata; bind widgets to fields. -4. **🔌 Plugin & Module Systems** – Load `.so`/`.dll`, query its `CxxMirror`, discover callable endpoints. -5. **🧪 Test Discovery & Orchestration** – Enumerate test functions by convention at runtime—no macro registries. -6. **📡 RPC/IPC & Data Pipelines** – Reflective marshalling, schema introspection, versioned message handling. -7. **⚙️ Live Tooling/Automation** – Logging, telemetry, app consoles, REPLs, hot‑reloadable metadata providers. - -💡 These are exactly why ecosystems like Java/C# leaned on reflection—and with RTL, C++ can enjoy the same benefits while keeping hot paths static and optimized. - ---- - -## 📝 Minimal, Concrete Patterns With RTL - -**Reflective Call (method invoke)** - -```c++ -const rtl::CxxMirror& m = MyReflection(); - -auto cls = m.record("engine::Audio"); -auto [err, inst] = cls->create(/* args */); // heap or stack as requested -auto setVolume = cls->getMethod("setVolume"); -auto [err, vol] = setVolume->bind(inst).call(0.75); // conservative conversions apply -``` - -**Serializer Sketch (pseudo‑code)** - -```c++ -json to_json(const rtl::RObject& obj) { - auto t = obj.record(); - json j; - for (auto& field : t.fields()) { // planned field/property reflection - j[field.name()] = to_json(obj.get(field)); - } - return j; -} -``` - -**Plugin Mirror Boundary** - -```c++ -extern "C" const rtl::CxxMirror& PluginReflection(); -// Host loads plugin, inspects its mirror, and queries callable endpoints. -``` - ---- - -## 🛡️ Performance & Safety Guardrails - -* Keep reflection at the boundaries: UI, scripting, serialization, plugins. -* Cache lookups: Resolve handles once, reuse them. -* Avoid string dispatch in hot loops. -* Prefer `rtl::view` for const refs instead of materializing copies. -* Benchmark reflective sections separately. -* Prototype with reflection → specialize hotspots with templates later. - ---- - -## ❓ Addressing Common Objections - -**“Zero‑cost means no runtime reflection.”** - -> Zero‑cost means no *mandatory* cost. With RTL’s lazy mirror and external registration, unused metadata is never touched. - -**“Just use templates.”** - -> Templates can’t solve runtime shape problems (dynamic plugins, scripts, external schemas). Reflection shifts cost only where runtime shape is unavoidable. - -**“Reflection is unsafe and stringly‑typed.”** - -> RTL APIs are explicit and exception‑free. Conversions are conservative, and lifetimes are deterministic. - -**“ABI will bite you.”** - -> RTL treats the mirror as the stable boundary. Metadata is authored explicitly—not guessed from compiler ABI. - -**“It will bloat my binary.”** - -> You register only what you expose. Metadata is lazy and link‑time selectable. You can strip it in production builds. - -**“What about fields/enums/inheritance?”** - -> They’re on the roadmap. Current function/constructor focus already unlocks major workflows; adoption can be incremental. - ---- - -## 🔚 Final Take - -*C++ can do runtime reflection responsibly. The choice is not “templates or chaos.” With RTL’s explicit, lazy, exception‑free design and deterministic lifetimes, you get the power of runtime shape when you want it, and zero cost when you don’t. That is the C++ way.* diff --git a/text-sailors-log/DLLs-ThinkingOutLoud.md b/text-sailors-log/DLLs-ThinkingOutLoud.md deleted file mode 100644 index d48bf8be..00000000 --- a/text-sailors-log/DLLs-ThinkingOutLoud.md +++ /dev/null @@ -1,80 +0,0 @@ -### ReflectionTemplateLibrary (RTL) — Design Log - -*Author: Neeraj Singh* -*Date: 2025-08-28* - ---- - -## Core Vision - -RTL is designed as a **pure C++ runtime reflection system** that eliminates the need for macros, boilerplate, or special compilers. Unlike traditional attempts that only cover type introspection, RTL enables **full type usage reflectively**: constructing, invoking methods, accessing properties, and cloning — all with type safety and zero overhead abstraction. - ---- - -## Key Revelations & Insights - -### 1. Beyond Handles — True Reflective DLL Communication - -Traditionally, DLLs expose a handful of opaque handles and C-like APIs. With RTL, however, we can: - -* Load a DLL dynamically. -* Obtain **type info, methods, and objects as handles**. -* Pass PODs and c-strings with ABI safety. -* Invoke methods reflectively, as if types were known at compile time. - -This blurs the line between host and DLL. The DLL no longer feels foreign — **all its types are accessible via reflection**. Programmers can work with it using pure C++ syntax, without worrying about handles or memory quirks. - -**Revelation:** RTL turns DLLs into **transparent C++ modules**, not just opaque binaries. - ---- - -### 2. Unit Testing Reinvented with RTL - -With RTL, unit tests no longer need macro-heavy frameworks (like gtest, Catch2, etc.). Instead: - -* Tests are written as **pure C++ classes**. -* A host application can load these classes **reflectively** from a DLL. -* The test runner can execute test cases dynamically without any registration macros. - -**Impact:** CI/CD pipelines can directly run reflected tests — a **JUnit-like experience for C++**. - -**Revelation:** Macro-based test frameworks exist only because **runtime reflection was missing** in C++. - ---- - -### 3. DLL Boundary Abstraction Layer - -While DLLs normally require manual handle and lifetime management, RTL can provide an **API layer** that: - -* Automates DLL loading/unloading. -* Manages lifetimes of reflected objects. -* Exposes the DLL’s internal types as if they were local to the project. - -**Effect:** The DLL boundary disappears — programmers interact reflectively in C++ as if everything were part of one codebase. - ---- - -### 4. Safe Widening & Relaxed Parameter Matching - -* RTL supports **safe widening conversions** for PODs (e.g., `int → double`, `const char* → std::string`). -* This makes reflected calls much more natural and robust across DLL boundaries. - -**Impact:** Function invocation feels seamless even when type signatures differ slightly. - ---- - -### 5. Industry Implications - -* **Macro-based frameworks** (testing, serialization, RPC) exist only due to missing reflection. -* **Plugin ecosystems** in C++ can now be designed with the same transparency as Java/.NET. -* **Adoption Resistance?** Some may resist due to fear of dynamic features in C++, but the **utility will outweigh resistance**. - -**Revelation:** RTL can become the **go-to pattern** for plugin/DLL design and reflective test execution. - ---- - -## Next Steps - -* Maintain a **DLL-specific design log** (chronological, PDF) alongside this Canvas. -* Expand CI/CD integration examples (CTest, GitHub Actions, etc.). -* Keep cross-referencing insights between the main log (Canvas) and the DLL log. diff --git a/text-sailors-log/cloning-semantic-quirks-with-wrappers.md b/text-sailors-log/cloning-semantic-quirks-with-wrappers.md deleted file mode 100644 index cfabb144..00000000 --- a/text-sailors-log/cloning-semantic-quirks-with-wrappers.md +++ /dev/null @@ -1,112 +0,0 @@ -# RTL Design Evolution Log - -## Milestone: Cloning Semantics — Unified Control with `rtl::copy` - -**Date:** 2025-08-16 -**Author:** Neeraj Singh - ---- - -### Problem Context - -Cloning objects inside RTL (`RObject`) originally had semantics tied only to value-copying. While this worked for most user-defined types, ambiguity and inconsistency emerged when dealing with **STL wrappers** such as `std::shared_ptr`, `std::unique_ptr`, and `std::optional`: - -* Should cloning a wrapper clone the *wrapper itself* (shallow copy)? -* Or should it clone the *underlying contained type* (deep copy)? -* What happens when the contained type is **non-copyable**? -* How do we make this intuitive yet efficient for real-world use? - -Performance concerns also came into play: deep-copying wrappers like `shared_ptr` in performance-critical applications would be wasteful when shallow-copy semantics (ref-count increments) are usually what developers expect. - -### Early Exploration - -1. **Default to Value Copy:** - - * Simple and safe. - * But performance-heavy when working with smart pointers. - * Non-intuitive: developers returning/consuming wrappers usually expect to work with the wrapper itself. - -2. **Default to Wrapper Copy:** - - * Better aligned with performance and developer expectations for `shared_ptr` and `optional`. - * But breaks intuition for cases where deep-copy of the underlying type was actually intended. - -Neither extreme fully captured the range of C++-native expectations. - -### Final Design - -To reconcile the competing needs, a **two-axis control** was introduced: - -```cpp -enum class alloc { Heap, Stack }; -enum class copy { Auto, Value, Wrapper }; - -template -std::pair clone() const; -``` - -#### Modes of Operation - -* **`copy::Value`** → Force deep copy of the contained entity `T`. - - * Errors out with `TypeNotCopyConstructible` if `T`’s copy ctor is deleted. - * Heap/stack behavior respected via `alloc`. - -* **`copy::Wrapper`** → Copy the wrapper itself. - - * `std::shared_ptr` shallow-copy increments ref-count. - * `std::unique_ptr` is forbidden (`TypeNotCopyConstructible`). - * Heap allocation of wrapper is disallowed (`StlWrapperHeapAllocForbidden`). - -* **`copy::Auto`** → Context-sensitive default: - - * If object was **RTL-allocated** (heap objects wrapped in `unique_ptr` internally): treat wrapper as transparent → **Value copy**. - * If object is a **non-RTL wrapper** (e.g., obtained from user return value): treat wrapper as significant → **Wrapper copy**. - -This provides an API that is **intuitive for developers**, while giving them control when they need it. - -However, RTL never performs deep copies internally during normal operations. All internal access uses zero-cost, read-only views by reference. - ---- - -### Error Handling Philosophy - -* **Fail Fast, No UB**: every illegal operation returns a clear `rtl::error`. - - * `error::EmptyRObject` if attempting to clone an empty `RObject`. - * `error::NotWrapperType` if `Wrapper` mode is requested on non-wrapper. - * `error::StlWrapperHeapAllocForbidden` if heap clone of wrapper is attempted. - * `error::TypeNotCopyConstructible` if underlying entity is not copyable. -* No silent fallbacks — clarity is always preferred. - -### Benefits - -* **Performance-Aware Defaults**: `Auto` intelligently chooses between shallow and deep copy based on context. -* **C++-Native Intuition**: Mirrors how developers think about copying raw types vs. wrappers in day-to-day C++. -* **Explicit Overrides**: Power users can explicitly request deep or shallow copy. -* **Consistency & Safety**: No hidden behavior, all outcomes expressed via `rtl::error`. - -### Example Use - -```cpp -// Smart default: deep-copy value if RTL-allocated, else shallow-copy wrapper -auto [err0, copy0] = robj.clone(); - -// Explicit deep-copy -auto [err1, copy1] = robj.clone(); - -// Explicit shallow-copy of shared_ptr wrapper -auto [err2, copy2] = robj.clone(); -``` - ---- - -### Why This Matters - -Reflection systems in C++ live at the intersection of **type safety**, **performance**, and **developer intuition**. By separating `alloc` and `copy` dimensions: - -* RTL ensures **safe lifetime management**. -* Developers get **precise control** without boilerplate. -* The library avoids performance pitfalls while staying faithful to native C++ semantics. - -This design resolves one of the most subtle challenges in runtime reflection — making **wrapper types transparent when desired, but still first-class citizens when needed**. diff --git a/text-sailors-log/cloning-semantics-at-a-glance.md b/text-sailors-log/cloning-semantics-at-a-glance.md deleted file mode 100644 index e9344bd0..00000000 --- a/text-sailors-log/cloning-semantics-at-a-glance.md +++ /dev/null @@ -1,104 +0,0 @@ -# 🔄 Cloning Semantics — At a Glance - -Cloning in RTL is explicit and predictable. -When you call: - -```cpp -auto [err, copyObj] = robj.clone(); -``` - -you control **where** the clone is created (`alloc::Heap` vs `alloc::Stack`) and **what** is cloned (`copy::Value` vs `copy::Wrapper` vs `copy::Auto`). - ---- - -## 📌 The `copy` modes - -### `copy::Value` - -Deep copy of the underlying *contained type `T`*. -Wrappers are treated as transparent. - -✅ Examples: - -* `RObject` of `std::shared_ptr` → copy of `int`. -* `RObject` of `std::unique_ptr` → copy of `MyType` (if copy-constructible). - -❌ Errors if: - -* Contained type is not copy-constructible. -* Wrapper forbids value copy (e.g. `unique_ptr` with deleted copy ctor). - ---- - -### `copy::Wrapper` - -Copy the wrapper itself (shallow copy semantics). -Contained entity is *not* copied. - -✅ Examples: - -* `RObject` of `std::shared_ptr` → shallow copy (`use_count` increases). -* `RObject` of `std::optional` → copy of the optional wrapper. - -❌ Errors if: - -* Wrapper is not copyable (e.g. `unique_ptr`). -* Heap allocation of wrapper is disallowed (`StlWrapperHeapAllocForbidden`). - ---- - -### `copy::Auto` *(Default)* - -RTL decides based on context: - -* If object came from **RTL-managed heap allocation** (`unique_ptr` wrapping a constructed type) → deep-copy `Value`. -* If object came from an **external wrapper** (e.g. return value `shared_ptr`) → shallow-copy `Wrapper`. - -✅ Intuitive: -Behaves like “do what a C++ dev would expect here.” -You get value-copies for RTL-created objects, wrapper-copies for externally-supplied smart pointers. - -⚠️ Important Clarification -When an object originates from an RTL-managed heap allocation (internally wrapped in std::unique_ptr), the default copy::Auto resolves to Value semantics. - -* However, RTL never performs deep copies internally during normal operations. All internal access uses zero-cost, read-only views by reference. -* A deep copy of the contained type only occurs if the user explicitly requests it via clone(). - -This ensures maximum efficiency while keeping semantics intuitive. - ---- - -## 📌 The `alloc` modes - -* **`alloc::Stack`** → new clone lives on the stack. -* **`alloc::Heap`** → new clone lives on the heap. -* Heap + Wrapper is forbidden → `error::StlWrapperHeapAllocForbidden`. - ---- - -## ⚡ Examples - -```cpp -RObject robj = reflect(std::make_shared(42)); - -// Deep copy the int (wrapper is transparent). -auto [e0, vCopy] = robj.clone(); - -// Shallow copy the shared_ptr (reference-counted). -auto [e1, wCopy] = robj.clone(); - -// Let RTL decide: shared_ptr → wrapper copy. -auto [e2, autoCopy] = robj.clone(); -``` - ---- - -## 🧭 Quick Rules of Thumb - -* Want the **thing inside**? → `copy::Value` -* Want the **wrapper itself**? → `copy::Wrapper` -* Don’t want to think about it? → `copy::Auto` - ---- - -👉 With this, RTL cloning semantics mirror **how you’d naturally treat smart pointers and wrappers in C++** — no surprises, no magic, just transparent, explicit control. diff --git a/text-sailors-log/const-by-default-semantics.md b/text-sailors-log/const-by-default-semantics.md deleted file mode 100644 index 679a0995..00000000 --- a/text-sailors-log/const-by-default-semantics.md +++ /dev/null @@ -1,142 +0,0 @@ -# Design Log: Const Semantics in RTL - -**Author:** Neeraj Singh -**Date:** 2025-08-24 - ---- - -## Overview - -This document details the **const semantics** in RTL (ReflectionTemplateLibrary-CPP), covering the distinction between RTL-created (logically-const) objects and externally provided (true-const) objects. It also explains how method binding, overload resolution, and error handling are governed by this model. - ---- - -## Core Principles - -1. **Const-by-Default Discipline** - - * All objects created via RTL reflection are treated as immutable by default. - * External objects passed to RTL retain their declared constness without alteration. - -2. **Two Kinds of Constness** - - * **Logically-Const (RTL-Created):** Objects appear immutable but may be safely cast internally by RTL. - * **True-Const (External):** Objects declared const by user code; RTL strictly respects their constness and never applies const\_cast internally. - ---- - -## Method Binding & Overload Resolution - -### 1. RTL-Created Objects (Logically-Const) - -* **Default:** RTL always prefers binding to the `const` overload of a method. -* **Fallback:** If no `const` overload exists but a non-const overload is present, RTL applies a *safe logical const\_cast* and binds to the non-const overload. -* **Explicit Choice:** If both overloads exist, the user may explicitly select which to bind by using `rtl::constCast()`. - -### 2. Externally Provided Objects (True-Const) - -* **Allowed Binding:** RTL binds only to `const` overloads. -* **Illegal Binding Attempt:** If the user explicitly attempts to bind a true-const object to a non-const overload, RTL reports: - - * `rtl::error::IllegalConstCast`. -* **Missing Const Overload:** If only a non-const overload exists (no `const` variant), RTL reports: - - * `rtl::error::ConstOverloadMissing`. -* **Guarantee:** RTL never internally const\_casts true-const objects. - ---- - -## Error Semantics - -* `rtl::error::IllegalConstCast` → Raised when the user attempts to bind a true-const object to a non-const method. -* `rtl::error::ConstOverloadMissing` → Raised when a true-const object attempts a call but no `const` overload is available. - ---- - -### 📌 Const Overload Handling: Native C++ vs RTL - -**Objective:** Verify whether RTL’s fallback and overload resolution for const/non-const methods aligns with native C++ semantics. - ---- - -#### 🟦 Native C++ Const Method Resolution - -* **Case 1: Call on `const T` / `const T&` / `const T*`:** - - * Only `const` member functions are viable. - * If only a non-const overload exists → **compile-time error**. - * User may `const_cast` and call non-const, but that’s UB if the object is truly const. - -* **Case 2: Call on non-const `T` / `T&` / `T*`:** - - * If both const and non-const overloads exist → compiler **chooses the non-const overload**. - - * Reason: binding to a non-cv-qualified `this` is a better match than converting to `const this`. - * If only the const overload exists → call is **valid**. A non-const object **can call a const member**. - ---- - -#### 🟦 RTL Const Method Resolution - -* **True-const objects (external const instances):** - - * RTL mirrors native C++ strictly. - * Only const overloads are considered. - * If missing → returns **`rtl::error::ConstOverloadMissing`**. - * If user explicitly attempts a constCast → **`rtl::error::IllegalConstCast`**. - -* **Logically-const objects (RTL-created, safe for const\_cast):** - - * RTL defaults to **binding the const overload** even if both exist → defensive by design. - * User can explicitly call the non-const overload via **`rtl::constCast()`** when intended. - * If only non-const exists, RTL safely **falls back to non-const** (guaranteed safe, since RTL owns the object). - ---- - -#### ✅ Cross-Verification Result - -* With a **non-const object**, native C++ picks non-const overload if available, otherwise falls back to const overload. -* With a **const object**, native C++ restricts to const overloads, otherwise errors. -* RTL matches this baseline but adds safety defaults for **logically-const** objects: - - * Defaults to const when both are present. - * Requires explicit opt-in (`rtl::constCast()`) for non-const. - * Provides error signaling instead of UB for illegal casts. - ---- - -📖 **Conclusion:** -RTL’s fallback is fully aligned with native C++ semantics for true constness, while extending the model with explicit safety rules and clearer error channels for logically-const cases. This preserves C++ familiarity while adding reflection-layer discipline. - - -## Strengths of the Model - -* **Safety First:** Prevents unsafe const-casting on external objects. -* **Flexibility:** Allows controlled safe relaxation of constness on RTL-managed objects. -* **Clarity:** Overload resolution is predictable and explicit. -* **Alignment with C++:** Fully consistent with const-correctness principles. - ---- - -## Considerations - -* **Documentation Needs:** Users must clearly understand the distinction between logically-const and true-const. -* **Testing:** Edge cases (e.g., methods with only non-const overloads) must be thoroughly verified. -* **Consistency:** Const semantics must remain uniform across cloning, moving, and nested reflection contexts. - ---- - -## Comparative Note - -* **Java Reflection:** Does not enforce constness; all members can be accessed/mutated freely. -* **C# Reflection:** Similar to Java, though `readonly` exists at field level; reflection can still override it. -* **RTL:** Unique in enforcing const-by-default while distinguishing between safe logical const-casts (for RTL-owned objects) and strict const adherence (for external objects). - ---- - -## Summary - -The const semantics in RTL establish a principled model: - -* **RTL-created objects:** const by default, but safe to relax when needed; users may explicitly call non-const overloads with `rtl::constCast()`. -* **External objects:** const is strictly enforced; unsafe relaxation is disallowed. diff --git a/text-sailors-log/const-semantic-dialogues.md b/text-sailors-log/const-semantic-dialogues.md deleted file mode 100644 index 3800dfcd..00000000 --- a/text-sailors-log/const-semantic-dialogues.md +++ /dev/null @@ -1,78 +0,0 @@ -### 🗨️ Dev Conversation (Revised): Evaluating RTL’s Handling of C++ Const‑Method Quirks - -**Updated:** 2025-08-25 - -> Two engineers are evaluating RTL from the outside (they don’t own it). They’re cross‑checking RTL’s behavior against **native C++ const overload rules** and reconciling any gotchas. - ---- - -#### Quick refresher: Native C++ rules for `const` vs `non‑const` member overloads - -1. **Call on a `const` object** - - * Overload resolution prefers **`const`‑qualified** member functions. - * If **no `const` overload exists**, a direct call to a non‑const member is a **compile‑time error**. - * A user may write `const_cast(obj).nonConst()`; the call compiles, **but any mutation of an originally `const` object yields undefined behavior**. - -2. **Call on a non‑const object** - - * If both overloads exist, overload resolution prefers the **non‑const** overload. - * If **only a `const` overload** exists, **calling it is perfectly valid**; there is **no compile error**. (A non‑const object can call a `const` member function.) - -These are the ground truths we’ll map RTL onto. - ---- - -#### Conversation - -**Dev A:** I’m reading RTL’s docs about const semantics. They talk about “logically‑const” for RTL‑created objects and “true‑const” for external ones. Before we judge that, let’s sanity‑check against native C++ rules we just reviewed. - -**Dev B:** Right. In native C++, a `const` object can only call `const` members unless you `const_cast`—and mutating that object is UB. A non‑const object prefers the non‑const overload, but it can still call a `const` member if that’s the only one available. - -**Dev A:** Cool. Now, how does RTL line up? - -**Dev B:** From what I gather: - -* **True‑const objects (externally provided into RTL):** - RTL treats them like native C++ `const` objects. It **only considers `const` overloads**. - • If the `const` overload is **missing**, RTL returns **`rtl::error::ConstOverloadMissing`** instead of trying anything clever. - • If the user **explicitly** tries to bind to a non‑const overload using `rtl::constCast()`, RTL rejects it with **`rtl::error::IllegalConstCast`**. - • RTL never performs an internal `const_cast` on such objects. - -* **Logically‑const objects (created by RTL via reflection):** - RTL defaults to the `const` overload to keep things safe and predictable. - • If **both** overloads exist, users can **explicitly opt into** the non‑const one using **`rtl::constCast()`**. - • If the **`const` overload is missing** but a **non‑const** one exists, RTL may **safely fall back** to the non‑const overload by performing an internal, guaranteed‑safe logical `const_cast` (since RTL owns the object’s lifecycle). - • This mirrors the “you could `const_cast` in C++ if it’s safe,” but **with stronger guarantees** because RTL distinguishes logical vs true constness. - -**Dev A:** So we should tweak the summary line to be precise: *“If the reflected object is const, RTL only considers the const overload. If it doesn’t exist, you’ll get `ConstOverloadMissing`.”* → That’s **only** for **true‑const** objects, right? - -**Dev B:** Exactly. For **true‑const**, missing `const` → `ConstOverloadMissing`. But for **logically‑const** RTL‑created objects, **missing `const` + present non‑const** → RTL will legitimately call the non‑const overload (safe internal `const_cast`). - -**Dev A:** And on the non‑const side, does RTL emulate native C++’s preference for the non‑const overload when both exist? - -**Dev B:** Conceptually yes—but with RTL’s **const‑by‑default discipline**, calls start from a logically‑const stance. So by default, RTL picks the `const` overload; **users must be explicit** (via `rtl::constCast()`) to select the non‑const overload. That’s a deliberate design: *safety first, explicit mutation second.* - -**Dev A:** That’s fair. It’s stricter than C++’s default, but predictable. And it still lets you reach the non‑const path when you mean it. - -**Dev B:** Right. And the error taxonomy makes intent obvious: - -* `rtl::error::ConstOverloadMissing` → true‑const object, only non‑const overload exists. -* `rtl::error::IllegalConstCast` → explicit attempt to force a non‑const call on a true‑const object. -* No error for RTL‑created objects when falling back to a non‑const overload—the fallback is **by design** and **safe**. - -**Dev A:** Last cross‑check with native C++: non‑const object calling a `const` member when that’s the only option—valid in C++. Does RTL allow the analogous scenario? - -**Dev B:** Yes—that maps to either (a) true‑const objects calling `const` members (the only option), or (b) logically‑const objects defaulting to `const` members even if the underlying instance is mutable. Both are consistent. - -**Dev A:** Makes sense. So the headline is: *RTL codifies C++’s const rules at runtime, adds provenance‑aware safety (true‑const vs logically‑const), defaults to const for clarity, and requires explicit opt‑in for mutation via `rtl::constCast()`.* - -**Dev B:** Exactly. Cleaner than ad‑hoc const\_casts in user code, and safer than pretending const doesn’t matter at runtime. - ---- - -#### TL;DR - -* Native C++: `const` object → only `const` overload (non‑const needs cast; mutating originally `const` is UB). Non‑const object → prefers non‑const; may call `const` if that’s all there is. -* RTL (true‑const): only `const` overload; missing `const` → `ConstOverloadMissing`; forcing non‑const → `IllegalConstCast`. -* RTL (logically‑const): defaults to `const`; missing `const` but non‑const present → safe fallback to non‑const; both present → user can explicitly pick non‑const with `rtl::constCast()`. diff --git a/text-sailors-log/copy-constructor-reflection.md b/text-sailors-log/copy-constructor-reflection.md deleted file mode 100644 index bdfa04eb..00000000 --- a/text-sailors-log/copy-constructor-reflection.md +++ /dev/null @@ -1,52 +0,0 @@ -# RTL Design Evolution Log - -## Entry: Restricting Direct Copy Constructor Calls in Reflection - -**Date:** 2025-08-16 -**Author:** Neeraj Singh - -### Problem Context - -In C++, copy constructors are universally available (unless explicitly deleted), but their **direct invocation is not semantically equivalent** to creating new objects via constructors. In most cases, if a programmer knows the type `T`, they would simply invoke `T()` or `T(other)` themselves. Reflection should not encourage redundant or confusing usage patterns. - -During testing with POD types like `char`, it became clear that exposing direct copy constructor calls through `Record::create<>()` added no value and introduced ambiguity: - -```cpp -optional charType = cxx::mirror().getRecord(reflected_id::char_t); -auto [err, rchar] = charType->create('Q'); -EXPECT_TRUE(err == rtl::error::SignatureMismatch); -``` - -The call above attempts to use the copy constructor signature for `char`. RTL rejects it with a `SignatureMismatch` error — **by design**. - -### Design Decision - -* **No direct copy constructor invocation via `Record::create<>()`.** - - * If the user knows the type `T`, they should construct it directly. - * Reflection only steps in when type erasure or runtime indirection is needed. - -* **Copy semantics are still fully supported, but in the right places:** - - * `RObject::clone<>()` uses the implicitly registered copy constructor safely. - * `rtl::reflect(T)` lets you reflect an existing object (copy constructed into `RObject`) when you want to treat it as type-erased. - -### Why This Matters - -This design avoids feature-bloat while preserving clarity: - -* Prevents **unintuitive misuse** of copy constructors through reflection. -* Ensures reflection remains a **tool for runtime type-erasure** and not a redundant duplication of normal C++ syntax. -* Keeps `Record::create<>()` semantically tied to *real object construction* (default or parameterized), not copying. -* Developers who need copying in a reflection context still have a direct and intuitive API: `clone()` or `reflect()`. - -### Benefits - -* **Clarity:** Users immediately understand what `create<>()` means — it *creates*, not *copies*. -* **Safety:** Avoids accidental misuse that could lead to semantic confusion. -* **Consistency:** Copying is consistently handled through `clone()` across all types. -* **Alignment with C++ Philosophy:** If you know the type, do it in plain C++; reflection is for when you don’t. - ---- - -✅ **Final Rule:** `Record::create<>()` never binds to copy constructor overloads. Copy semantics are available only through `RObject::clone()` or `rtl::reflect(T)`. diff --git a/text-sailors-log/design-summary-RObject.md b/text-sailors-log/design-summary-RObject.md deleted file mode 100644 index f6239971..00000000 --- a/text-sailors-log/design-summary-RObject.md +++ /dev/null @@ -1,62 +0,0 @@ -RTL Design Evolution Log -Milestone: RObject – The Runtime Instance Container -Date: 2025-08-13 -Author: Neeraj Singh - ---- - -## Purpose - -`RObject` is the central runtime container in RTL — the bridge between compile-time registered metadata and actual object instances at runtime. It encapsulates: - -* The underlying value or pointer (type-erased in `std::any`). -* Ownership and lifetime management logic. -* Metadata (`RObjectId`) linking the instance to its reflection type info. -* Cloning and controlled movement. - -This design allows RTL to operate on objects without compile-time type knowledge while preserving safety, performance, and predictable semantics. - ---- - -## Core Characteristics - -* **Move-only:** No accidental copies; move constructor provided, move assignment deleted. -* **Explicit Cloning:** All duplication is via a stored `Cloner` function pointer; no hidden copies. -* **Type-Erased Storage:** `std::any` holds stack values, heap allocations, or wrapped move-only types like `std::unique_ptr`. -* **Consistent Metadata Link:** Every `RObject` carries an `RObjectId` to resolve runtime type operations. - ---- - -## Creation & Storage Rules - -* Built via type-trait-dispatched builders. -* Special handling for string-like types and raw C strings. -* Heap vs stack distinction recorded in metadata. -* Uses safe wrappers (e.g., `RObjectUptr`) for move-only types to ensure cross-compiler compatibility. -* RTL rule: **All `any_cast` operations retrieve values only as `const T&`** — preventing unwanted copies, even for copyable types. - ---- - -## Cloning & Lifetime Management - -* `Cloner` supports type-specific shallow or deep copies. -* Metadata preserves original allocation type and const-cast safety. -* Destructor access is validated — if deleted/private, heap allocation is rejected. -* No double-deletes or leaks across move and clone operations. - ---- - -## Interoperability & Conversion - -* Planned relaxed parameter type matching (e.g., `const char*` → `std::string`). -* Safe implicit conversions recognized. -* Works with values, refs, and pointers. - ---- - -## Benefits - -* **Predictable API:** Logical constness enforced; internal mutability for reflection only. -* **Cross-Compiler Consistency:** Single code path for MSVC, GCC, Clang. -* **Performance-Aware:** Avoids redundant copies and allocations. -* **Extensible:** Designed for future relaxed conversions, advanced lifetime rules, and complex type handling. diff --git a/text-sailors-log/design-summary-RObjectUPtr.md b/text-sailors-log/design-summary-RObjectUPtr.md deleted file mode 100644 index a9c63b84..00000000 --- a/text-sailors-log/design-summary-RObjectUPtr.md +++ /dev/null @@ -1,67 +0,0 @@ -RTL Design Evolution Log -Milestone: RObjectUptr – Safe Ownership of Move-Only Types -Date: 2025-08-13 -Author: Neeraj Singh - ---- - -## Problem Context - -While integrating `std::unique_ptr` support into `RObject` for storing move-only types, an issue surfaced: - -* `std::any` requires the contained type to be CopyConstructible when using certain APIs or performing unintended copy operations. -* `std::unique_ptr` is move-only and cannot be copied, making it incompatible with `std::any` in some compilers (notably MSVC) at the construction step itself. - -### Key Goal - -Store move-only types (especially `std::unique_ptr`) inside `RObject` without relying on compiler-specific quirks and without triggering copy construction. - ---- - -## Initial Exploration - -### Direct `std::any` Storage - -* Works in GCC/Clang for some cases, but fails on MSVC during `std::any` construction. -* Behavior inconsistent across compilers — unacceptable for RTL’s cross-platform guarantee. - -### Conditional Compilation - -* Possible workaround, but introduces complexity and risk of platform divergence. -* Violates RTL’s design principle of consistent behavior across compilers. - ---- - -## Final Design - -A dedicated wrapper class — **RObjectUptr** — was introduced: - -### Key Features - -* Stores the move-only type directly in a safe, non-copyable wrapper. -* Enforces no accidental copy-construction within RTL internals. -* **All `std::any_cast` operations in RTL retrieve values only via `const T&`** — guaranteeing that no copies are ever made, even for copyable types. -* Allows `RObject` to hold and operate on move-only types transparently. -* No compiler-specific hacks; same code path for MSVC, GCC, and Clang. - ---- - -## Core Design Decisions - -1. **No Ownership Transfer in Copy Constructor** - The wrapper ensures no implicit transfer or move in copy contexts — this avoids subtle ownership bugs. - -2. **No `std::move` in Copy Constructor** - Now a simple, safe, “harmless-looking” class — easier to maintain and audit. - -3. **One Code Path for All Compilers** - Consistency is a feature, not an afterthought. - ---- - -## Benefits - -* **Predictable Behavior:** Developers using RTL know that move-only types will *just work* without compiler-specific surprises. -* **Maintainability:** No preprocessor conditionals to juggle. -* **Safety First:** Internals of RTL can’t accidentally cause lifetime errors. -* **Extensibility:** Paves the way for storing other move-only, non-copyable types. diff --git a/text-sailors-log/progress-timline.md b/text-sailors-log/progress-timline.md deleted file mode 100644 index a5065a95..00000000 --- a/text-sailors-log/progress-timline.md +++ /dev/null @@ -1,182 +0,0 @@ -# RTL Milestone Timeline — RObject, `rtl::view`, and Cloning Semantics - -**Goal**: Build a non-intrusive, native-feeling runtime reflection system for C++ that preserves C++’s ownership, value categories, and performance expectations while enabling **relaxed parameter matching** across type-erased boundaries. - ---- - -## Phase 0 — Principles & North Star - -* **Non-intrusive**: No macros in user types. Registration is external and explicit. -* **C++-native intuition**: Reflected calls should behave like normal C++ calls (ownership, constness, overload resolution). -* **Zero accidental cost**: No hidden copies; pay only when you ask for it. -* **Deterministic lifetime**: Clear heap/stack semantics, explicit ownership. -* **Error-code based**: Robust, exception-free error paths. - ---- - -## Phase 1 — Why `RObject` exists - -**Problem**: After a reflected call, you often don’t know the static type of the result (or you want to pass it to another reflected call that expects a *different* but compatible type). - -**Solution**: `RObject` is a **type-erased, lifetime-aware runtime handle** that: - -* Stores the produced value (or pointer) and its metadata. -* Lets you **view** it as different target types (`view()`) when safe. -* Enables **relaxed parameter matching** by projecting the same stored entity into multiple compatible request shapes (e.g., `std::string` ↔ `const char*`, safe arithmetic widenings, etc.). - -**Design anchors**: - -* Internally uses `std::any` for storage (with strict rules, see Phase 2). -* Tracks allocation site and wrapper kind in `RObjectId` (heap/stack, wrapper type, const-cast safety). -* All internal access is via **read-only views by reference**; **no implicit cloning**. - ---- - -## Phase 2 — Storage & Ownership (type erasure without footguns) - -**Challenges** - -* `std::unique_ptr` cannot be copied; some toolchains reject placing it directly into `std::any`. -* `std::any` may trigger copy paths in naive designs. - -**Decisions** - -1. **Wrapper for move-only types**: Introduced `RObjectUPtr` — a simple, copyable-looking façade whose semantics are controlled by RTL. It enables consistent storage of `unique_ptr` across MSVC/GCC/Clang. -2. **`std::any` access rule**: **Every `any_cast` inside RTL is by `const T&` only**. Once constructed in-place, RTL never triggers a copy via `std::any` operations. -3. **Metadata (`RObjectId`)**: Records whether the stored entity is on heap or stack, whether it is a wrapper (`shared_ptr`, `unique_ptr`, etc.), and whether const-cast is safe (for RTL-managed instances only). - -**Outcomes** - -* Cross-compiler consistent behavior for move-only storage. -* No hidden copies; lifetime stays intuitive and explicit. - ---- - -## Phase 3 — `rtl::view` (see-through, zero-overhead access) - -**What a view is** - -* An immutable façade over the stored entity that **either** references the original value **or** materializes a value when a conversion is requested. -* Constructed with **bare types** only (`T`), then you decide how to consume it (ref/pointer/value) via `get()`. - -**Properties** - -* **Zero-copy until needed**: Viewing as the same type yields a const reference; viewing as different but compatible type *may* materialize a temporary (e.g., `std::string` from `const char*`). -* **No dangling**: The view’s lifetime is scoped to the `RObject` and call site. -* **Validation**: Views are only produced when statically/semantically safe; otherwise `std::optional` is empty. - -**Why it matters for relaxed matching** - -* A single stored value can be presented as `T`, `U`, or `V` if (and only if) conversions are safe by RTL policy. - ---- - -## Phase 4 — Smart Pointers: reflecting real-world ownership - -**Support added**: `std::unique_ptr`, `std::shared_ptr` - -**Semantics** - -* **`view>`**: - - * Multiple views can exist. Calling `get()` **moves** the pointer **once** out of the `RObject`-held storage; subsequent `get()` calls yield an empty `unique_ptr`. - * `RObject` itself remains valid after the move; only the contained `unique_ptr` becomes empty. -* **`view>`**: - - * `view->get()` as `const std::shared_ptr&` does **not** bump refcount. - * Acquiring by value creates a **shallow, ref-counted copy** (obvious from C++ intuition). -* **Transparent access to underlying `T`**: Users can request `view` directly; wrappers act as transparent containers whenever reasonable. - -**Safety rules** - -* RTL does **not** invent copying for noncopyable `T`. -* If the original object was **RTL-constructed on heap**, it is stored in an RTL-owned `unique_ptr` (transparent internally). Internal operations never deep-copy; cloning happens only on explicit request. - ---- - -## Phase 5 — Cloning Semantics (explicit, predictable) - -**Public API** - -```cpp -// Choose allocation site and clone target (Auto / Value / Wrapper) -template -std::pair RObject::clone() const; -``` - -**Copy target policy** - -* `copy::Value` → Deep-copy the **underlying value** `T` (if copy-constructible). Allocation site decided by `A`. -* `copy::Wrapper` → Copy the **wrapper** when applicable: - - * `shared_ptr` → shallow, ref-counted copy (allowed on `alloc::Stack`; **heap forbidden**). - * `unique_ptr` → not copyable → `error::TypeNotCopyConstructible`. -* `copy::Auto` → The intuitive default: - - * If the object is a **non-RTL** wrapper (e.g., a `shared_ptr` or a `unique_ptr` returned from user code), clone the **Wrapper**. - * If the object is **RTL-managed heap instance** (constructed via reflection, owned by RTL’s internal `unique_ptr`), clone the **Value** (deep-copy) *only when explicitly requested by the user via `clone()`*. - -**Allocation policy** - -* `alloc::Stack` → produces a stack-held instance when cloning `Value`, or a stack-held wrapper when cloning `Wrapper` (for `shared_ptr`). -* `alloc::Heap` → deep-copy to heap for `Value`; **forbid** heap-alloc of wrapper clones (`error::StlWrapperHeapAllocForbidden`). - -**Errors you’ll see** - -* `error::EmptyRObject`, `error::NotWrapperType`, `error::TypeNotCopyConstructible`, `error::StlWrapperHeapAllocForbidden`. - -**Crucial nuance** - -* *Efficiency preserved*: Despite the rule “If RTL-managed heap ⇒ deep-copy Value,” **RTL never performs hidden clones**. Internally, RTL only uses read-only references; cloning happens **solely** when the user calls `clone()`. - -**Evolution note** - -* Early iterations used an internal `EntityKind` (Value/Wrapper). Public API is now unified as `rtl::copy { Auto, Value, Wrapper }` for clarity. - ---- - -## Phase 6 — Relaxed Parameter Matching (roadmap & current policy) - -**Motivation**: Let users compose reflected calls without hand-writing glue types. - -**Current safe projections** - -* **String-like**: `const char* → std::string` (materialize), `std::string_view ↔ std::string` (configurable, conservative by default). -* **Arithmetic**: only **proven-safe widenings** (e.g., `int → long long`, `float → double`). No narrowing; no int↔float unless explicitly allowed. Policy backed by a compile-time trait (conservative by design). -* **Pointer/view**: From `unique_ptr` / `shared_ptr` to `T` via `view` (transparent read-only access), honoring ownership rules. - -**Future** - -* Enums, properties, composite types, inheritance — each with explicit, conservative matching tables. - ---- - -## Phase 7 — Testing Milestones - -* **`unique_ptr` round-trip**: reflect, multiple views, single-move extraction, post-move stability of `RObject`. -* **`shared_ptr` sharing**: ref-count behavior via read-only vs by-value access; wrapper clone vs value clone behavior; mixed ownership lifetimes. -* **User-defined noncopyable types** (`Node`): verify wrapper-level shallow clones succeed while value-level clones fail with `TypeNotCopyConstructible`; resource counters prove correct destruction. -* **Constructor misuse guard**: Calling `Record::create` with a copy-ctor signature reports `SignatureMismatch` (design choice: copy construction is reserved for `RObject::clone`). - ---- - -## Phase 8 — Performance & Safety Posture - -* **No hidden work**: All internal access is via const refs; no implicit deep copies. -* **Explicit costs**: Cloning is explicit; conversions happen only when `view` asks for them. -* **Thread- & exception-safety**: Error codes over exceptions; atomic counters for diagnostics; clear ownership tracking. -* **Cross-compiler consistency**: `RObjectUPtr` and `const-ref any_cast` discipline keep MSVC/GCC/Clang aligned. - ---- - -## Phase 9 — What’s Next - -* **Relaxed matching tables** (documented, auditable) for string-like and arithmetic families. -* **Property/Enum/Composite/Inheritance** reflection with the same semantics discipline. -* **ABI boundary story** (plugins): keeping binary boundaries stable by constraining surface types to ABI-friendly shapes. - ---- - -## One-liner Summary - -**RObject** stores *what you have*; **`rtl::view`** gives you *what you need*; **clone semantics** make the cost *explicit and intuitive*. Together, they enable relaxed parameter matching that still *feels like C++.* diff --git a/text-sailors-log/reflection-apis-redefined.md b/text-sailors-log/reflection-apis-redefined.md deleted file mode 100644 index 137ac67c..00000000 --- a/text-sailors-log/reflection-apis-redefined.md +++ /dev/null @@ -1,514 +0,0 @@ -Design log, 06/11/2025 -Author, Neeraj Singh. -------------------------------------- -# Why RTL's API is Different - -Most C++ reflection libraries follow patterns inherited from dynamically-typed languages like Python, Ruby, or JavaScript. These patterns make sense in those contexts—but they're fundamentally mismatched to C++'s nature as a statically-typed, performance-oriented language. - -RTL takes a different approach: **leverage C++'s type system instead of fighting it**. - ---- - -## The Traditional Reflection Model: "Shooting in the Dark" - -**The typical reflection API looks like this:** - -```cpp -// Traditional reflection (most libraries) -result = invoke("functionName", arg1, arg2, arg3); -``` - -**What happens at runtime:** - -1. **Lookup:** Hash map search for "functionName" (~10-50ns) -2. **Arity check:** Does argument count match? (~5ns) -3. **Type validation:** Do argument types match expected types? (~10-30ns) -4. **Type conversion:** Convert arguments if possible (~10-50ns) -5. **Dispatch:** Finally, call the function (~1-2ns) - -**If any step 1-4 fails:** Throw exception (after consuming all that time). - -**If you call this function 1,000 times:** Pay the lookup + validation cost 1,000 times. - ---- - -### **The Problems with This Model** - -#### **1. Performance Degrades at Scale** - -```cpp -// Every call repeats the entire lookup + validation process -for (int i = 0; i < 1000000; i++) { - invoke("processData", data[i]); // 1M × (lookup + validate + dispatch) -} -``` - -**Cost per call:** 30-100ns overhead, even if the function itself is fast. - -For a trivial function (say, 5ns of actual work), **you're spending 85-95% of time on reflection overhead**. - ---- - -#### **2. Error Handling is Reactive, Not Proactive** - -```cpp -try { - result = invoke("funcName", arg1, arg2); -} catch (const ReflectionException& e) { - // What failed? - // - Function not found? - // - Wrong argument count? - // - Type mismatch? - // - Can't convert types? - - // Parse error message to figure it out? 😞 -} -``` - -**You discover errors during the call, not before.** - -Every invocation is a gamble: will it work, or will it throw? - ---- - -#### **3. User Intent is Ambiguous** - -```cpp -invoke("compute", 42, 3.14); -``` - -**Questions the library must guess:** -- Is this a function taking `(int, double)`? -- Or `(double, double)` with int→double conversion? -- Or `(float, float)` with narrowing conversions? -- Or `(long, float)` with multiple conversions? - -**The library guesses. Sometimes it guesses wrong.** - ---- - -## The RTL Model: "Turn On the Lights First" - -RTL separates reflection into **two distinct phases**: - -### **Phase 1: Lookup & Validation (Once)** - -```cpp -rtl::function compute = - mirror.getFunction("compute") - ->argsT() - .returnT(); - -if (!compute) { - // Function doesn't exist or signature doesn't match - // Handle this ONCE, at setup time - std::cerr << "Function 'compute' not found or signature mismatch\n"; - return; -} -``` - -**This is where you "agree and commit":** -- "I want a function named `compute`" -- "That takes `(float, float)`" -- "And returns `std::string`" - -**If this succeeds:** You have a **valid, typed callable**. Invocation is guaranteed to work. - -**If this fails:** You get an empty `optional`. Handle it gracefully, once. - ---- - -### **Phase 2: Dispatch (Many Times, Zero Overhead)** - -```cpp -// Now call it as many times as you want -for (int i = 0; i < 1000000; i++) { - std::string result = compute(data[i].x, data[i].y); // Just dispatch -} -``` - -**What happens per call:** -1. **Dispatch:** Jump to function pointer (~1-2ns) -2. Done. - -**No lookup. No validation. No type checking. No exceptions.** - -**Just a single, native function pointer jump.** - ---- - -## Why This is Architecturally Superior - -### **1. Performance: Amortize the Cost** - -**Traditional Model:** -``` -Total cost = N × (Lookup + Validate + Dispatch) -1,000 calls = 1,000 × (50ns) = 50,000ns = 50µs -``` - -**RTL Model:** -``` -Total cost = 1 × (Lookup + Validate) + N × (Dispatch) -1,000 calls = 1 × (50ns) + 1,000 × (2ns) = 2,050ns = 2µs -``` - -**RTL is 24× faster for 1,000 calls.** - -**The more you call, the bigger RTL's advantage.** - ---- - -### **2. Error Handling: Fail Fast** - -**Traditional:** -```cpp -try { - for (auto& item : data) { - invoke("process", item); // Might fail on iteration 847 - } -} catch (...) { - // Crashed mid-loop. Now what? -} -``` - -**RTL:** -```cpp -auto process = mirror.getFunction("process")->argsT().returnT<>(); - -if (!process) { - // Failed at setup. Handle it BEFORE the loop. - return error("Function 'process' not found"); -} - -// If we get here, all 1,000 calls are guaranteed to work: -for (auto& item : data) { - process(item); // No try-catch needed -} -``` - -**Errors are discovered at lookup time, not call time.** - -**"Fail fast" done right.** - ---- - -### **3. User Intent is Explicit** - -**Traditional (ambiguous):** -```cpp -invoke("func", 42, 3.14); // What signature does user expect? -``` - -**RTL (explicit):** -```cpp -rtl::function func = ...; // User declares intent -func(42, 3.14); // Compiler enforces it -``` - -**No guessing. User's expectations are crystal clear.** - ---- - -### **4. Composability** - -RTL's callables are **first-class objects**: - -```cpp -// Store them -std::map> handlers; -handlers["onConnect"] = mirror.getFunction("handleConnect")->argsT(); -handlers["onDisconnect"] = mirror.getFunction("handleDisconnect")->argsT(); - -// Pass them around -void registerHandler(const std::string& event, rtl::function handler); - -// Compose them -auto combined = [f1, f2](int x) { f1(x); f2(x); }; -``` - -**You can't do this with `invoke("name", ...)` — the lookup is coupled to the call.** - ---- - -## The Type System is Your Friend - -### **Insight: Types Exist at the Call Site** - -When you write: -```cpp -int x = 42; -float y = 3.14f; -invoke("compute", x, y); -``` - -**The compiler knows `x` is `int` and `y` is `float`.** - -**Why throw away that information just to rediscover it at runtime?** - ---- - -### **RTL's Philosophy:** - -> **"C++ is statically typed. Users write typed code. Reflection should use those types, not fight them."** - -When you write: -```cpp -rtl::function compute = ...; -compute(x, y); -``` - -**The compiler:** -- Knows you're calling a function expecting `(int, float)` -- Knows you're passing `(int, float)` -- Validates this at compile time (if variables are typed) -- Generates the call with zero overhead - -**RTL just forwards the arguments. The compiler does the rest.** - ---- - -## The Two Design Decisions That Make This Work - -### **Decision 1: Let C++ Handle Implicit Conversions** - -**Most reflection libraries try to implement conversion logic:** - -```cpp -// What other libraries do (pseudocode): -if (arg_type == int && param_type == float) { - float converted = static_cast(arg); - // Now handle: double, long, short, unsigned... - // Also handle: const, pointers, references... - // Also handle: user-defined conversions... - // 5,000 lines later... -} -``` - -**RTL's approach:** - -```cpp -// User declares expected types -rtl::function func = ...; - -// User passes ints -func(61, 35); // Compiler converts int→float (standard C++) -``` - -**RTL doesn't handle conversions. C++ does.** - -**Benefits:** -- ✅ Zero conversion code to write/maintain -- ✅ Zero runtime overhead (compiler optimizes) -- ✅ All standard conversions work automatically -- ✅ User-defined conversions work automatically -- ✅ Perfect forwarding works -- ✅ Const-correctness preserved - -**RTL leverages the compiler instead of reimplementing it.** - ---- - -### **Decision 2: Decouple Lookup from Invocation** - -**Most libraries couple them:** -```cpp -invoke(name, args) = [Lookup + Validate + Call] as one operation -``` - -**RTL decouples them:** -```cpp -callable = lookup(name, signature) // Once -callable(args) // Many times -``` - -**This separation gives you:** -- ✅ Performance (amortize lookup cost) -- ✅ Safety (validate once, call many) -- ✅ Clarity (errors at lookup, not call) -- ✅ Composability (callables are values) - -**Single Responsibility Principle applied to reflection.** - ---- - -## A Complete Example: Before and After - -### **Traditional Reflection Library** - -```cpp -// Setup (none needed, everything happens at call-time) - -// Usage -void processData(const std::vector& data) { - for (const auto& point : data) { - try { - // Every call: lookup + validate + dispatch - auto result = reflection::invoke("computeValue", point.x, point.y); - - // Type-cast the result (runtime check) - double value = std::any_cast(result); - - // Use value... - } catch (const reflection::NotFoundException& e) { - // Function not found - } catch (const reflection::TypeMismatchException& e) { - // Type error - } catch (const std::bad_any_cast& e) { - // Wrong return type - } - } -} -``` - -**Problems:** -- ❌ Lookup + validation × N times (slow) -- ❌ Three different exception types to catch -- ❌ Runtime type casting required -- ❌ Errors discovered during loop (too late) - ---- - -### **RTL Approach** - -```cpp -// Setup (once, at initialization) -auto computeValue = mirror.getFunction("computeValue") - ->argsT() - .returnT(); - -if (!computeValue) { - // Handle error at setup time - return error("Function 'computeValue' not found or signature mismatch"); -} - -// Usage -void processData(const std::vector& data) { - for (const auto& point : data) { - // Just dispatch (no lookup, no validation, no exceptions) - double value = computeValue(point.x, point.y); - - // Use value... - } -} -``` - -**Benefits:** -- ✅ Lookup + validation once (fast) -- ✅ Zero exception handling in loop -- ✅ Statically typed result (no casting) -- ✅ Errors discovered before loop (fail fast) - ---- - -## When to Use Each API Style - -RTL provides **two APIs** for different scenarios: - -### **Typed API (When You Know Types)** - -```cpp -// You know the signature at the call site -rtl::function func = - mirror.getFunction("toString") - ->argsT() - .returnT(); - -std::string result = func(42, 100); // Compile-time type checking -``` - -**Use when:** -- You know the function signature -- You want compile-time type safety -- You need maximum performance (~1-2ns overhead) - ---- - -### **Type-Erased API (When Types are Unknown)** - -```cpp -// Runtime flexibility when types aren't known at compile time -auto [err, result] = mirror.getFunction("toString") - ->bind(obj) - .call(42, 100); - -if (err == rtl::error::None && result.canViewAs()) { - std::string str = result.view()->get(); -} -``` - -**Use when:** -- Loading plugins at runtime -- Scripting language integration -- Serialization/deserialization -- Generic tool building (debuggers, editors) - -**Even the type-erased API separates lookup from invocation:** -- Lookup: `getFunction("toString")` -- Invocation: `call(args)` - ---- - -## The Philosophy: "Ask, Don't Assume" - -**Traditional reflection:** -```cpp -invoke("func", args); // Hope it works, catch if it doesn't -``` - -**RTL:** -```cpp -auto func = mirror.getFunction("func")->argsT(); -if (func) { - func(args); // Guaranteed to work -} else { - // Handle the known error -} -``` - -**Instead of assuming the function exists and catching exceptions when it doesn't, RTL lets you ASK:** - -- "Does this function exist?" -- "Does it have this signature?" -- "Give me a callable if yes, null if no." - -**Then you decide what to do.** - -**This is:** -- More explicit (no hidden exceptions) -- More efficient (no wasted work on invalid calls) -- More composable (callables are values) - ---- - -## Summary: Two Key Insights - -### **1. C++ Has Types — Use Them** - -**Don't throw away type information just to rediscover it at runtime.** - -Let users declare expected types. Let the compiler handle conversions and validation. Reflection becomes a thin layer, not a complex runtime system. - ---- - -### **2. Separate Lookup from Dispatch** - -**Don't couple lookup + validation with every call.** - -Validate once at setup. Then dispatch becomes a single function pointer jump — as fast as C++ can possibly be. - ---- - -## The Result - -**RTL reflection calls are 10-50× faster than traditional reflection.** - -**Not through clever optimization tricks.** - -**Through better architecture.** - ---- - -**By thinking in C++ instead of copying dynamic languages, RTL achieves both flexibility AND performance.** - -**That's the RTL difference.** diff --git a/text-sailors-log/rtl-bind-function-design-log.md b/text-sailors-log/rtl-bind-function-design-log.md deleted file mode 100644 index 6c220fb6..00000000 --- a/text-sailors-log/rtl-bind-function-design-log.md +++ /dev/null @@ -1,104 +0,0 @@ -# Design Log: bind() — API semantics, purpose and usage - -**Author:** Neeraj Singh -**Date:** 2025-08-25 - ---- - -## Overview - -`bind()` is the central invocation API in RTL that expresses two responsibilities in one call: - -1. **Target binding** — which runtime object (if any) the method should be invoked on. -2. **Argument forwarding policy** — how call-site arguments are to be forwarded (value, lvalue-ref, rvalue-ref, const-ref). - -`bind()` therefore gives the user explicit control over *how* RTL should perceive the invocation context and *how* to forward arguments to resolve overloads correctly. This is essential in a C++ reflection system because value-category and constness affect overload selection and correctness. - ---- - -## API Surface (conceptual) - -```cpp -// Zero-argument form: no target, default forwarding -auto callSite = funcOrMethod->bind(); - -// Bind to an RObject target (by value) — used for instance methods -auto callSite = method->bind(RObject{...}); - -// Explicitly request treating the target as non-const -auto callSite = method->bind(rtl::constCast(RObject{...})); - -// Template form: specify forwarding categories for parameters -auto callSite = func->bind(); // e.g. bind() - -// Combination: bind the target and specify forwarding -auto callSite = method->bind(target); -``` ---- - -## Accepted argument types for `bind()` - -* `rtl::access::RObject` — binds the reflected object as the call target. This is the normal case for invoking instance methods. -* `rtl::constCast&&` (or equivalent explicit wrapper) — signals to RTL: "treat this RObject as non-const for this call". This is an explicit, user-driven request to relax logical constness; if the RObject is *true-const*, the runtime rejects the attempt (`rtl::error::IllegalConstCast`). - -`bind()` *only* accepts these target forms for instance binding. Passing other types as the target should be a compile-time error. - ---- - -## Template parameter pack (perfect-forwarding control) - -* `bind()` allows the caller to *explicitly declare the forwarding category* for each function parameter, e.g. `T`, `T&`, `T&&`, `const T&`. -* This is necessary because reflection cannot deduce value category from a runtime `any`-style container; when overload selection depends on rvalue vs lvalue, `bind<...>()` disambiguates the call. -* If omitted, RTL will attempt best-effort matching using available argument values; but some overloads (especially rvalue-ref overloads) require explicit `bind()` to select. - ---- - -## Semantics — how `bind()` interacts with RTL const model - -* If binding an **RObject created by RTL** (logically-const): - - * Default behavior: bind the target as logically-const (no mutation). Overload resolution will prefer `const` overloads. - * If `const` overload doesn't exist but a non-const overload does, RTL may internally perform a **safe logical `const_cast`** and call the non-const overload. - * If caller explicitly uses `rtl::constCast(RObject)` in `bind()`, RTL will select the non-const overload when safe. - -* If binding an **externally-provided true-const** RObject: - - * `bind()` preserves true constness. RTL will consider only `const` overloads. - * If user calls `bind(rtl::constCast(robj))`, RTL will reject with `rtl::error::IllegalConstCast`. - -* For **static functions**, the object-target passed to `bind()` is ignored (becomes a sink). However, `bind()` still controls perfect-forwarding for parameters. - ---- - -## Error behavior and diagnostics - -* `rtl::error::ConstCallViolation` — raised when a non-const method is attempted on a true-const object without constCast. -* `rtl::error::IllegalConstCast` — raised when user explicitly requests a constCast on a true-const object. -* `rtl::error::ConstOverloadMissing` — raised when a true-const object has no const overload to call. -* `rtl::error::SignatureMismatch` — raised when the forwarded argument types do not match any registered signature. - -Design note: `bind()` should validate as early as possible (during `bind()` return or immediately on `.call()` entry) and provide clear diagnostics. In debug builds provide helpful messages; in release builds keep errors lightweight. - ---- - -## Rationale and benefits - -* **Explicitness:** users can express intent (target identity, const-relaxation, forwarding categories) in a single, discoverable call. -* **Correctness:** avoids ambiguous runtime overload resolution; reduces accidental UB from naive const\_casts. -* **Ergonomics:** templates on `bind()` provide the minimal, explicit syntax needed for perfect-forwarding without changing the call-site semantics. -* **Consistency:** aligns with C++ overload and const rules while providing reflection-specific guarantees (logical vs true constness). - ---- - -## Recommended usage patterns - -* Use `bind()` with no template parameters for common cases where value-categories are natural (lvalue args, no rvalue-only overloads). -* Use `bind()` when you need to target rvalue-ref overloads. -* Use `bind(rtl::constCast(robj))` only when you intentionally want to invoke a non-const overload on an RTL-created object. -* Avoid binding an object to static methods in production code if you want stricter correctness. - ---- - -## Summary - -`bind()` is the explicit control point for method/function invocation in RTL. It unifies target binding and argument forwarding, enabling correct overload resolution in the face of C++'s value-category and const subtleties. The design balances strictness and ergonomics: conservative by default (favoring const), explicit when mutation or rvalue selection is intended. diff --git a/text-sailors-log/rtl-created-shared-ptr-design-exploration.md b/text-sailors-log/rtl-created-shared-ptr-design-exploration.md deleted file mode 100644 index b26efc45..00000000 --- a/text-sailors-log/rtl-created-shared-ptr-design-exploration.md +++ /dev/null @@ -1,60 +0,0 @@ -RTL Design Evolution Log -Date: 2025-08-19 -Author: Neeraj Singh - -# Design Exploration Log — `rtl::alloc::Shared` - -## 🧩 The Motivation - -So far, RTL supports cloning semantics across **stack**, **heap**, and **wrapper-aware** modes. But one common C++ pattern isn’t fully reflected yet: **shared ownership.** - -In native C++, developers often pass around `std::shared_ptr` instead of deep-copying or moving values — especially when sharing is cheaper and semantically correct. RTL should preserve this intuition by offering a reflection-level equivalent. - -## ✨ The Proposal: `rtl::alloc::Shared` - -Introduce a new allocation selector: - -```c++ -enum class alloc { - Stack, - Heap, - Shared, // NEW: share ownership instead of cloning - // (Wrapper/Auto handled as part of copy semantics) -}; -``` - -## 🔧 Behavior by Case - -* **If the RObject wraps a `std::shared_ptr`** → produce a shallow copy (increment ref count). - -* **If the RObject wraps a `std::unique_ptr` owned by RTL** → promote to `std::shared_ptr` via `std::shared_ptr(std::move(unique_ptr))`. RTL keeps the semantics natural — a unique resource can be turned into shared ownership. - -* **If the RObject holds a stack/heap `T` (value)** → allocate a new `std::shared_ptr` holding that value, making it shareable across RTL boundaries. - -* **If the RObject holds a `std::weak_ptr`** → lock and wrap into `std::shared_ptr` if valid, or fail gracefully with `error::ExpiredWeakPtr`. - -## 🎯 Why This Matters - -* **Performance** – avoids deep copies when unnecessary, mirrors what devs already do manually with `shared_ptr`. -* **Intuition** – fits seamlessly with C++ semantics. You can choose: value-copy, heap-owning unique, or shareable pointer — exactly what you’d expect. -* **Flexibility** – lets RTL adapt to client code that’s designed around sharing semantics without forcing developers to write workarounds. - -## 📝 Example - -```c++ -RObject robj = reflect(std::make_unique()); - -// Instead of deep-copying MyType, just create a shared wrapper -auto [err, sharedObj] = robj.clone(); - -// sharedObj now reflects `std::shared_ptr` -EXPECT_TRUE(sharedObj.canViewAs>()); -``` - -## 🌱 Design Status - -This is an **exploration**, not finalized yet. The semantics look natural and consistent, but needs validation through: - -* Performance tests (to ensure shared vs deep-copy is beneficial in practice). -* API ergonomics (does `Shared` feel natural to users, or is it surprising?). -* Integration with `copy::Auto` (does auto-selection need to consider `Shared`?). diff --git a/text-sailors-log/smart-pointers-reflection-support.md b/text-sailors-log/smart-pointers-reflection-support.md deleted file mode 100644 index 282e03cd..00000000 --- a/text-sailors-log/smart-pointers-reflection-support.md +++ /dev/null @@ -1,97 +0,0 @@ -# RTL Design Evolution Log - -## Milestone: Smart Pointer Reflection & Unwrap Semantics - -**Date:** 2025-08-15 -**Author:** Neeraj Singh - ---- - -### Problem Context - -While adding support for `std::unique_ptr`, `std::shared_ptr`, and `std::weak_ptr` to **RObject**, the challenge was to maintain: - -* Full reflection transparency. -* Correct ownership semantics. -* Cross-compiler compatibility. -* Intuitive behavior that matches native C++ usage. - -The goal: **Make working with reflected smart pointers feel as natural as working with them directly in C++.** - ---- - -### Key Challenges - -1. **Move-only types (`std::unique_ptr`)** - - * `std::any` requires `CopyConstructible` types in certain code paths. - * Direct storage of `unique_ptr` in `std::any` can fail on MSVC. - -2. **Shared ownership (`std::shared_ptr`)** - - * Reflection must preserve reference counts when passing between `RObject`s. - -3. **Weak references (`std::weak_ptr`)** - - * Reflection must allow locking to create temporary usable objects without accidental ownership transfer. - -4. **Developer intuition** - - * If you can do it in C++ normally, you should be able to do it via reflection — without unexpected surprises. - ---- - -### Final Design - -**1. Smart Pointer Storage** - -* All heap-created objects in RTL are wrapped in `std::unique_ptr` internally. -* The underlying type `T` can be accessed either as `std::unique_ptr` or directly as `T`. -* Deep-cloning from `unique_ptr` is the default when unwrapping. - -**2. `RObjectUptr` Wrapper** - -* Bypasses `std::any`'s copy-constructor requirement. -* Stores move-only types safely. -* Preserves cross-compiler behavior. - -**3. New Allocation Modes** - -* `alloc::Heap` – Normal heap allocation. -* `alloc::Stack` – Stack allocation. -* `alloc::UnwrapOnHeap` – Deep-clone underlying type `T` from inside smart pointer into a new heap object. -* `alloc::UnwrapOnStack` – Deep-clone underlying type `T` from inside smart pointer into a new stack object. - -**4. Transparent View Semantics** - -* If you know the type, you can view as `T` or `std::unique_ptr` directly. -* If you don't know the type, treating it as an opaque `RObject` is harmless — ownership rules are preserved. - ---- - -### Why This Matters - -In standard C++ development, handling smart pointers is muscle memory — you know when you can move, copy, or share. The **Unwrap-on-Heap/Stack** modes extend that instinct into reflection, allowing you to: - -* Safely clone from `unique_ptr` without stealing ownership. -* Share `shared_ptr` across reflected calls. -* Lock and use `weak_ptr` without surprises. - -The result: a **zero-friction reflection experience** where the developer’s mental model matches the runtime behavior. - ---- - -### Benefits - -* **Predictable behavior** — matches native C++ semantics. -* **Cross-platform consistency** — identical behavior on MSVC, GCC, and Clang. -* **Intuitive API** — unwrapping and cloning are explicit and intention-revealing. -* **Safe by default** — no accidental ownership leaks or lifetime bugs. - ---- - -### Next Steps - -* Expand test coverage for all combinations of smart pointer types and allocation modes. -* Document real-world usage patterns for devs unfamiliar with smart pointer internals. -* Add diagnostics when unwrapping fails due to inaccessible copy constructors. diff --git a/text-sailors-log/thread-safety-revised.md b/text-sailors-log/thread-safety-revised.md deleted file mode 100644 index f27f22ba..00000000 --- a/text-sailors-log/thread-safety-revised.md +++ /dev/null @@ -1,87 +0,0 @@ -# 📓 RTL Design Log — `CxxMirror` Thread-Safety & Singleton Model - -**Date:** 2025-08-29 -**Author:** Neeraj Singh - ---- - -## Background - -`rtl::CxxMirror` is the **root container** of RTL, holding all registrations (records, functions, methods, constructors). -By design, it should: - -* Be a **singleton** (one shared mirror across the program). -* Be **thread-safe** (registration happens once, and the mirror becomes immutable). -* Avoid unnecessary **runtime overhead** (locks, contention, etc.). - -Earlier, RTL used **internal locking** to guard critical sections during registration and query. This made the system **idiot-proof** — safe even if a user misused the mirror. - -At the same time, C++ itself guarantees that **`static`**\*\* local initialization is thread-safe and atomic\*\* (since C++11). This means that if a user follows the recommended *singleton pattern* (placing the mirror in a `static` local), the compiler already enforces thread-safety. - -This raised the question: -➡️ *Should RTL still keep internal locks even when the compiler already provides thread-safety guarantees?* - ---- - -## Initial Options Considered - -### Option 1 — Always Keep Locks - -* ✅ Safe in all cases (idiot-proof). -* ✅ Protects against misuse (e.g., non-static mirrors created across threads). -* ❌ Adds small but non-zero runtime overhead (mutex acquire/release). -* ❌ Redundant in canonical usage (`static` local mirror). - -### Option 2 — Remove Locks in `Static` Mode - -* ✅ Zero runtime overhead. -* ✅ Leverages compiler’s thread-safety. -* ❌ Risk of misuse: a user could instantiate a `CxxMirror` as a local/automatic variable in multiple threads and break invariants. -* ❌ “God mode” is nice for experts, but dangerous in practice. - -### Option 3 — Configurable Policy (ThreadSafe vs Static) - -* ✅ Gives users control (`rtl::CxxMirror` vs `rtl::CxxMirror`). -* ✅ Defaults to safe mode. -* ❌ Opens a footgun: users might misuse `Static` in a non-static context. -* ❌ Adds cognitive load (users must pick policies). - ---- - -## Later Idea: Template Singleton with Universe Indices - -We then considered making `CxxMirror` a **templated, compiler-enforced singleton**: - -* `CxxMirror` is **always static + thread-safe** by compiler guarantees. -* Users create **independent reflective universes** by indexing with a template parameter (`<0>, <1>, <2>…`). - -### Benefits - -* ✅ Compiler-enforced singleton. -* ✅ Zero runtime overhead. -* ✅ Multiple isolated universes. - -### Downsides - -* ❌ Burden on developers to manage indices. -* ❌ No semantic meaning behind numbers (risk of collisions, confusion). -* ❌ Removes flexibility of explicit construction. - ---- - -## 📅 Update — 2025-08-31 (Decision Reversal) - -After deeper consideration, we are **reverting to the original design** with **internal locking** and explicit user-managed construction. - -### Reasons for Reversal - -1. **Flexibility matters** — Users should retain the ability to explicitly construct and manage `rtl::CxxMirror`, not be forced into a rigid template+static model. -2. **Idiot-proof safety is already achieved** — Internal locks guarantee correctness even if a mirror is instantiated incorrectly (e.g., non-static, multi-threaded scenarios). -3. **Programmer responsibility is acceptable** — programmers will naturally recognize the essence of the singleton design pattern and use it wisely (placing the mirror in a `static` local). The docs can emphasize this idiom without enforcing it at the type system level. -4. **Simplicity of usage** — No need to manage artificial template indices or worry about collisions. - -### Final Takeaway - -> **CxxMirror will remain internally thread-safe via locks, with flexibility for explicit construction.** -> The **singleton pattern** (via `static` local) remains the recommended best practice, but it is *advisory, not enforced*. -> This keeps RTL both **idiot-proof and flexible**, avoiding unnecessary limitations while ensuring correctness in all usage scenarios.