[benchmark] Add activity-analysis headroom cases measuring master - #1874
[benchmark] Add activity-analysis headroom cases measuring master#1874leetcodez wants to merge 1 commit into
Conversation
![github-actions[bot]](https://avatars.githubusercontent.com/in/15368?s=60&v=4){kind=small}
| #include "clad/Differentiator/Differentiator.h" | ||
| #include <memory> | ||
|
|
||
| double dummy_out = 0; // Global to prevent Clang constant folding |
There was a problem hiding this comment.
warning: variable 'dummy_out' is non-const and globally accessible, consider making it const [cppcoreguidelines-avoid-non-const-global-variables]
double dummy_out = 0; // Global to prevent Clang constant folding
^|
|
||
| namespace { | ||
| struct MemoryManager : public benchmark::MemoryManager { | ||
| size_t cur_num_allocs = 0; |
There was a problem hiding this comment.
warning: no header providing "size_t" is directly included [misc-include-cleaner]
benchmark/ActivityWaste.cpp:2:
- #include <memory>
+ #include <cstddef>
+ #include <memory>| cur_max_bytes_used = 0; | ||
| } | ||
| void Stop(Result& result) override { | ||
| result.num_allocs = cur_num_allocs; |
There was a problem hiding this comment.
warning: narrowing conversion from 'size_t' (aka 'unsigned long') to signed type 'int64_t' (aka 'long') is implementation-defined [cppcoreguidelines-narrowing-conversions]
result.num_allocs = cur_num_allocs;
^| } | ||
| void Stop(Result& result) override { | ||
| result.num_allocs = cur_num_allocs; | ||
| result.max_bytes_used = cur_max_bytes_used; |
There was a problem hiding this comment.
warning: narrowing conversion from 'size_t' (aka 'unsigned long') to signed type 'int64_t' (aka 'long') is implementation-defined [cppcoreguidelines-narrowing-conversions]
result.max_bytes_used = cur_max_bytes_used;
^| result.max_bytes_used = cur_max_bytes_used; | ||
| } | ||
| }; | ||
| static auto mm = std::unique_ptr<MemoryManager>(new MemoryManager()); |
There was a problem hiding this comment.
warning: 'mm' is a static definition in anonymous namespace; static is redundant here [readability-static-definition-in-anonymous-namespace]
| static auto mm = std::unique_ptr<MemoryManager>(new MemoryManager()); | |
| auto mm = std::unique_ptr<MemoryManager>(new MemoryManager()); |
| result.max_bytes_used = cur_max_bytes_used; | ||
| } | ||
| }; | ||
| static auto mm = std::unique_ptr<MemoryManager>(new MemoryManager()); |
There was a problem hiding this comment.
warning: use std::make_unique instead [modernize-make-unique]
| static auto mm = std::unique_ptr<MemoryManager>(new MemoryManager()); | |
| static auto mm = std::make_unique<MemoryManager>(); |
| result.max_bytes_used = cur_max_bytes_used; | ||
| } | ||
| }; | ||
| static auto mm = std::unique_ptr<MemoryManager>(new MemoryManager()); |
There was a problem hiding this comment.
warning: variable 'mm' is non-const and globally accessible, consider making it const [cppcoreguidelines-avoid-non-const-global-variables]
static auto mm = std::unique_ptr<MemoryManager>(new MemoryManager());
^| } | ||
| }; | ||
| static auto mm = std::unique_ptr<MemoryManager>(new MemoryManager()); | ||
| static struct InstrumentationRegistrer { |
There was a problem hiding this comment.
warning: class 'InstrumentationRegistrer' defines a non-default destructor but does not define a copy constructor, a copy assignment operator, a move constructor or a move assignment operator [cppcoreguidelines-special-member-functions]
static struct InstrumentationRegistrer {
^| static struct InstrumentationRegistrer { | ||
| InstrumentationRegistrer() { benchmark::RegisterMemoryManager(mm.get()); } | ||
| ~InstrumentationRegistrer() { benchmark::RegisterMemoryManager(nullptr); } | ||
| } __mem_mgr_register; |
There was a problem hiding this comment.
warning: '__mem_mgr_register' is a static definition in anonymous namespace; static is redundant here [readability-static-definition-in-anonymous-namespace]
benchmark/ActivityWaste.cpp:23:
- static struct InstrumentationRegistrer {
+ struct InstrumentationRegistrer {| static struct InstrumentationRegistrer { | ||
| InstrumentationRegistrer() { benchmark::RegisterMemoryManager(mm.get()); } | ||
| ~InstrumentationRegistrer() { benchmark::RegisterMemoryManager(nullptr); } | ||
| } __mem_mgr_register; |
There was a problem hiding this comment.
warning: declaration uses identifier '__mem_mgr_register', which is a reserved identifier [bugprone-reserved-identifier]
} __mem_mgr_register;
^this fix will not be applied because it overlaps with another fix
Codecov Report✅ All modified and coverable lines are covered by tests. 📢 Thoughts on this report? Let us know! |
3a48c1b to
6f0d65e
Compare
| @@ -0,0 +1,255 @@ | |||
| #include "clad/Differentiator/Differentiator.h" | |||
| #include <memory> | |||
| #include "benchmark/benchmark.h" | |||
There was a problem hiding this comment.
warning: #includes are not sorted properly [llvm-include-order]
| #include "benchmark/benchmark.h" | |
| #include "benchmark/benchmark.h" | |
| #include <memory> |
|
|
||
| namespace { | ||
| struct MemoryManager : public benchmark::MemoryManager { | ||
| size_t cur_num_allocs = 0; |
There was a problem hiding this comment.
warning: no header providing "size_t" is directly included [misc-include-cleaner]
benchmark/ActivityWaste.cpp:1:
- #include <memory>
+ #include <cstddef>
+ #include <memory>| static struct InstrumentationRegistrer { | ||
| InstrumentationRegistrer() { benchmark::RegisterMemoryManager(mm.get()); } | ||
| ~InstrumentationRegistrer() { benchmark::RegisterMemoryManager(nullptr); } | ||
| } __mem_mgr_register; |
There was a problem hiding this comment.
warning: '__mem_mgr_register' is a static definition in anonymous namespace; static is redundant here [readability-static-definition-in-anonymous-namespace]
benchmark/ActivityWaste.cpp:22:
- static struct InstrumentationRegistrer {
+ struct InstrumentationRegistrer {| static struct InstrumentationRegistrer { | ||
| InstrumentationRegistrer() { benchmark::RegisterMemoryManager(mm.get()); } | ||
| ~InstrumentationRegistrer() { benchmark::RegisterMemoryManager(nullptr); } | ||
| } __mem_mgr_register; |
There was a problem hiding this comment.
warning: invalid case style for variable '__mem_mgr_register' [readability-identifier-naming]
} __mem_mgr_register;
^this fix will not be applied because it overlaps with another fix
| static struct InstrumentationRegistrer { | ||
| InstrumentationRegistrer() { benchmark::RegisterMemoryManager(mm.get()); } | ||
| ~InstrumentationRegistrer() { benchmark::RegisterMemoryManager(nullptr); } | ||
| } __mem_mgr_register; |
There was a problem hiding this comment.
warning: variable '__mem_mgr_register' is non-const and globally accessible, consider making it const [cppcoreguidelines-avoid-non-const-global-variables]
} __mem_mgr_register;
^| ~InstrumentationRegistrer() { benchmark::RegisterMemoryManager(nullptr); } | ||
| } __mem_mgr_register; | ||
|
|
||
| class AddBMCounterRAII { |
There was a problem hiding this comment.
warning: class 'AddBMCounterRAII' defines a non-default destructor but does not define a copy constructor, a copy assignment operator, a move constructor or a move assignment operator [cppcoreguidelines-special-member-functions]
class AddBMCounterRAII {
^| } __mem_mgr_register; | ||
|
|
||
| class AddBMCounterRAII { | ||
| MemoryManager& MemMgr; |
There was a problem hiding this comment.
warning: invalid case style for private member 'MemMgr' [readability-identifier-naming]
| MemoryManager& MemMgr; | |
| MemoryManager& m_MemMgr; |
benchmark/ActivityWaste.cpp:33:
- : MemMgr(m), State(s) {
+ : m_MemMgr(m), State(s) {benchmark/ActivityWaste.cpp:40:
- State.counters["AllocN"] = MemMgr.cur_num_allocs / it;
- State.counters["DellocN"] = MemMgr.cur_num_deallocs / it;
- State.counters["AllocBytes"] = MemMgr.cur_max_bytes_used / it;
+ State.counters["AllocN"] = m_MemMgr.cur_num_allocs / it;
+ State.counters["DellocN"] = m_MemMgr.cur_num_deallocs / it;
+ State.counters["AllocBytes"] = m_MemMgr.cur_max_bytes_used / it;| } __mem_mgr_register; | ||
|
|
||
| class AddBMCounterRAII { | ||
| MemoryManager& MemMgr; |
There was a problem hiding this comment.
warning: member 'MemMgr' of type 'MemoryManager &' is a reference [cppcoreguidelines-avoid-const-or-ref-data-members]
MemoryManager& MemMgr;
^|
|
||
| class AddBMCounterRAII { | ||
| MemoryManager& MemMgr; | ||
| benchmark::State& State; |
There was a problem hiding this comment.
warning: invalid case style for private member 'State' [readability-identifier-naming]
| benchmark::State& State; | |
| benchmark::State& m_State; |
benchmark/ActivityWaste.cpp:33:
- : MemMgr(m), State(s) {
+ : MemMgr(m), m_State(s) {benchmark/ActivityWaste.cpp:39:
- const unsigned long it = State.iterations();
- State.counters["AllocN"] = MemMgr.cur_num_allocs / it;
- State.counters["DellocN"] = MemMgr.cur_num_deallocs / it;
- State.counters["AllocBytes"] = MemMgr.cur_max_bytes_used / it;
+ const unsigned long it = m_State.iterations();
+ m_State.counters["AllocN"] = MemMgr.cur_num_allocs / it;
+ m_State.counters["DellocN"] = MemMgr.cur_num_deallocs / it;
+ m_State.counters["AllocBytes"] = MemMgr.cur_max_bytes_used / it;|
|
||
| class AddBMCounterRAII { | ||
| MemoryManager& MemMgr; | ||
| benchmark::State& State; |
There was a problem hiding this comment.
warning: member 'State' of type 'benchmark::State &' is a reference [cppcoreguidelines-avoid-const-or-ref-data-members]
benchmark::State& State;
^
49fc827 to
42ade6f
Compare
| #include "clad/Differentiator/Differentiator.h" | ||
| #include <cstddef> | ||
| #include <memory> | ||
| #include "benchmark/benchmark.h" |
There was a problem hiding this comment.
warning: #includes are not sorted properly [llvm-include-order]
| #include "benchmark/benchmark.h" | |
| #include "benchmark/benchmark.h" | |
| #include <cstddef> | |
| #include <memory> |
| result.max_bytes_used = cur_max_bytes_used; | ||
| } | ||
| }; | ||
| auto mm = std::make_unique<MemoryManager>(); |
There was a problem hiding this comment.
warning: variable 'mm' is non-const and globally accessible, consider making it const [cppcoreguidelines-avoid-non-const-global-variables]
auto mm = std::make_unique<MemoryManager>();
^| } | ||
| }; | ||
| auto mm = std::make_unique<MemoryManager>(); | ||
| struct InstrumentationRegistrer { |
There was a problem hiding this comment.
warning: class 'InstrumentationRegistrer' defines a non-default destructor but does not define a copy constructor, a copy assignment operator, a move constructor or a move assignment operator [cppcoreguidelines-special-member-functions]
struct InstrumentationRegistrer {
^| struct InstrumentationRegistrer { | ||
| InstrumentationRegistrer() { benchmark::RegisterMemoryManager(mm.get()); } | ||
| ~InstrumentationRegistrer() { benchmark::RegisterMemoryManager(nullptr); } | ||
| } MemMgrRegister; |
There was a problem hiding this comment.
warning: variable 'MemMgrRegister' is non-const and globally accessible, consider making it const [cppcoreguidelines-avoid-non-const-global-variables]
} MemMgrRegister;
^| } | ||
| ~AddBMCounterRAII() { | ||
| const unsigned long it = State.iterations(); | ||
| State.counters["AllocN"] = MemMgr.cur_num_allocs / it; |
There was a problem hiding this comment.
warning: narrowing conversion from 'unsigned long' to 'double' [cppcoreguidelines-narrowing-conversions]
State.counters["AllocN"] = MemMgr.cur_num_allocs / it;
^| } | ||
| ~AddBMCounterRAII() { | ||
| const unsigned long it = State.iterations(); | ||
| State.counters["AllocN"] = MemMgr.cur_num_allocs / it; |
There was a problem hiding this comment.
warning: result of integer division used in a floating point context; possible loss of precision [bugprone-integer-division]
State.counters["AllocN"] = MemMgr.cur_num_allocs / it;
^| ~AddBMCounterRAII() { | ||
| const unsigned long it = State.iterations(); | ||
| State.counters["AllocN"] = MemMgr.cur_num_allocs / it; | ||
| State.counters["DellocN"] = MemMgr.cur_num_deallocs / it; |
There was a problem hiding this comment.
warning: narrowing conversion from 'unsigned long' to 'double' [cppcoreguidelines-narrowing-conversions]
State.counters["DellocN"] = MemMgr.cur_num_deallocs / it;
^| ~AddBMCounterRAII() { | ||
| const unsigned long it = State.iterations(); | ||
| State.counters["AllocN"] = MemMgr.cur_num_allocs / it; | ||
| State.counters["DellocN"] = MemMgr.cur_num_deallocs / it; |
There was a problem hiding this comment.
warning: result of integer division used in a floating point context; possible loss of precision [bugprone-integer-division]
State.counters["DellocN"] = MemMgr.cur_num_deallocs / it;
^| const unsigned long it = State.iterations(); | ||
| State.counters["AllocN"] = MemMgr.cur_num_allocs / it; | ||
| State.counters["DellocN"] = MemMgr.cur_num_deallocs / it; | ||
| State.counters["AllocBytes"] = MemMgr.cur_max_bytes_used / it; |
There was a problem hiding this comment.
warning: narrowing conversion from 'unsigned long' to 'double' [cppcoreguidelines-narrowing-conversions]
State.counters["AllocBytes"] = MemMgr.cur_max_bytes_used / it;
^| const unsigned long it = State.iterations(); | ||
| State.counters["AllocN"] = MemMgr.cur_num_allocs / it; | ||
| State.counters["DellocN"] = MemMgr.cur_num_deallocs / it; | ||
| State.counters["AllocBytes"] = MemMgr.cur_max_bytes_used / it; |
There was a problem hiding this comment.
warning: result of integer division used in a floating point context; possible loss of precision [bugprone-integer-division]
State.counters["AllocBytes"] = MemMgr.cur_max_bytes_used / it;
^
42ade6f to
6689ff2
Compare
| mm->cur_num_allocs++; | ||
| mm->cur_max_bytes_used += size; | ||
| } | ||
| return malloc(size); |
There was a problem hiding this comment.
warning: do not manage memory manually; consider a container or a smart pointer [cppcoreguidelines-no-malloc]
return malloc(size);
^| mm->cur_num_allocs++; | ||
| mm->cur_max_bytes_used += size; | ||
| } | ||
| return malloc(size); |
There was a problem hiding this comment.
warning: no header providing "malloc" is directly included [misc-include-cleaner]
benchmark/ActivityWaste.cpp:3:
- #include <memory>
+ #include <cstdlib>
+ #include <memory>| mm->cur_num_allocs++; | ||
| mm->cur_max_bytes_used += size; | ||
| } | ||
| return malloc(size); |
There was a problem hiding this comment.
warning: returning a newly created resource of type 'void *' or 'gsl::owner<>' from a function whose return type is not 'gsl::owner<>' [cppcoreguidelines-owning-memory]
return malloc(size);
^| void operator delete(void* p) noexcept { | ||
| if (mm) | ||
| mm->cur_num_deallocs++; | ||
| free(p); |
There was a problem hiding this comment.
warning: calling legacy resource function without passing a 'gsl::owner<>' [cppcoreguidelines-owning-memory]
free(p);
^| void operator delete(void* p) noexcept { | ||
| if (mm) | ||
| mm->cur_num_deallocs++; | ||
| free(p); |
There was a problem hiding this comment.
warning: do not manage memory manually; use RAII [cppcoreguidelines-no-malloc]
free(p);
^| void operator delete(void* p) noexcept { | ||
| if (mm) | ||
| mm->cur_num_deallocs++; | ||
| free(p); |
There was a problem hiding this comment.
warning: no header providing "free" is directly included [misc-include-cleaner]
free(p);
^| double positive_control(const double* x, int n) { | ||
| double r = 0; | ||
| for (int i = 0; i < n; ++i) { | ||
| double t = x[i] * x[i]; |
There was a problem hiding this comment.
warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
double t = x[i] * x[i];
^| double positive_control(const double* x, int n) { | ||
| double r = 0; | ||
| for (int i = 0; i < n; ++i) { | ||
| double t = x[i] * x[i]; |
There was a problem hiding this comment.
warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
double t = x[i] * x[i];
^| } | ||
|
|
||
| static void BM_PositiveControl(benchmark::State& state) { | ||
| int n = state.range(0); |
There was a problem hiding this comment.
warning: narrowing conversion from 'int64_t' (aka 'long') to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions]
int n = state.range(0);
^|
|
||
| static void BM_PositiveControl(benchmark::State& state) { | ||
| int n = state.range(0); | ||
| double* x = new double[n]; |
There was a problem hiding this comment.
warning: initializing non-owner 'double *' with a newly created 'gsl::owner<>' [cppcoreguidelines-owning-memory]
double* x = new double[n];
^
|
|
||
| static void BM_PositiveControl(benchmark::State& state) { | ||
| int n = state.range(0); | ||
| double* x = new double[n]; |
There was a problem hiding this comment.
warning: use auto when initializing with new to avoid duplicating the type name [modernize-use-auto]
| double* x = new double[n]; | |
| auto* x = new double[n]; |
| static void BM_PositiveControl(benchmark::State& state) { | ||
| int n = state.range(0); | ||
| double* x = new double[n]; | ||
| double* dx = new double[n]; |
There was a problem hiding this comment.
warning: initializing non-owner 'double *' with a newly created 'gsl::owner<>' [cppcoreguidelines-owning-memory]
double* dx = new double[n];
^| static void BM_PositiveControl(benchmark::State& state) { | ||
| int n = state.range(0); | ||
| double* x = new double[n]; | ||
| double* dx = new double[n]; |
There was a problem hiding this comment.
warning: use auto when initializing with new to avoid duplicating the type name [modernize-use-auto]
| double* dx = new double[n]; | |
| auto* dx = new double[n]; |
| double* x = new double[n]; | ||
| double* dx = new double[n]; | ||
| for (int i = 0; i < n; ++i) | ||
| x[i] = 0.5; |
There was a problem hiding this comment.
warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
x[i] = 0.5;
^| AddBMCounterRAII c(*mm.get(), state); | ||
| for (auto _ : state) { | ||
| for (int i = 0; i < n; ++i) | ||
| dx[i] = 0; |
There was a problem hiding this comment.
warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
dx[i] = 0;
^| benchmark::DoNotOptimize(dx); | ||
| } | ||
| } | ||
| delete[] x; |
There was a problem hiding this comment.
warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead [cppcoreguidelines-owning-memory]
delete[] x;
^Additional context
benchmark/ActivityWaste.cpp:71: variable declared here
double* x = new double[n];
^| } | ||
| } | ||
| delete[] x; | ||
| delete[] dx; |
There was a problem hiding this comment.
warning: deleting a pointer through a type that is not marked 'gsl::owner<>'; consider using a smart pointer instead [cppcoreguidelines-owning-memory]
delete[] dx;
^Additional context
benchmark/ActivityWaste.cpp:72: variable declared here
double* dx = new double[n];
^| double interproc_passive(const double* x, int n, int work) { | ||
| double r = 0; | ||
| for (int i = 0; i < n; ++i) | ||
| r += inner_accumulate(x[i], work); |
There was a problem hiding this comment.
warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
r += inner_accumulate(x[i], work);
^|
|
||
| static void BM_InterprocPassive(benchmark::State& state) { | ||
| const int n = 50; | ||
| int work = state.range(0); |
There was a problem hiding this comment.
warning: narrowing conversion from 'int64_t' (aka 'long') to signed type 'int' is implementation-defined [cppcoreguidelines-narrowing-conversions]
int work = state.range(0);
^| static void BM_InterprocPassive(benchmark::State& state) { | ||
| const int n = 50; | ||
| int work = state.range(0); | ||
| double x[n], dx[n]; |
There was a problem hiding this comment.
warning: do not declare C-style arrays, use std::array<> instead [cppcoreguidelines-avoid-c-arrays]
double x[n], dx[n];
^
1e8995d to
201aa29
Compare
| mm->cur_num_allocs++; | ||
| mm->cur_max_bytes_used += size; | ||
| } | ||
| return malloc(size); |
There was a problem hiding this comment.
warning: no header providing "malloc" is directly included [misc-include-cleaner]
benchmark/ActivityWaste.cpp:2:
- #include <memory>
+ #include <cstdlib>
+ #include <memory>| static void BM_InterprocPassive(benchmark::State& state) { | ||
| const int n = 50; | ||
| int work = state.range(0); | ||
| double x[n], dx[n]; |
There was a problem hiding this comment.
warning: multiple declarations in a single statement reduces readability [readability-isolate-declaration]
| double x[n], dx[n]; | |
| double x[n]; | |
| double dx[n]; |
| int work = state.range(0); | ||
| double x[n], dx[n]; | ||
| for (int i = 0; i < n; ++i) { | ||
| x[i] = 0.5; |
There was a problem hiding this comment.
warning: do not use array subscript when the index is not an integer constant expression [cppcoreguidelines-pro-bounds-constant-array-index]
x[i] = 0.5;
^| double x[n], dx[n]; | ||
| for (int i = 0; i < n; ++i) { | ||
| x[i] = 0.5; | ||
| dx[i] = 0; |
There was a problem hiding this comment.
warning: do not use array subscript when the index is not an integer constant expression [cppcoreguidelines-pro-bounds-constant-array-index]
dx[i] = 0;
^| AddBMCounterRAII c(*mm.get(), state); | ||
| for (auto _ : state) { | ||
| for (int i = 0; i < n; ++i) | ||
| dx[i] = 0; |
There was a problem hiding this comment.
warning: do not use array subscript when the index is not an integer constant expression [cppcoreguidelines-pro-bounds-constant-array-index]
dx[i] = 0;
^| AddBMCounterRAII c(*mm.get(), state); | ||
| for (auto _ : state) { | ||
| for (int i = 0; i < n; ++i) | ||
| dx[i] = 0; |
There was a problem hiding this comment.
warning: use range-based for loop instead [modernize-loop-convert]
| dx[i] = 0; | |
| for (double & i : dx) | |
| i = 0; |
| double dead_struct_field(const double* x, int n) { | ||
| double r = 0; | ||
| for (int i = 0; i < n; ++i) { | ||
| Particle p; |
There was a problem hiding this comment.
warning: uninitialized record type: 'p' [cppcoreguidelines-pro-type-member-init]
| Particle p; | |
| Particle p{}; |
| double r = 0; | ||
| for (int i = 0; i < n; ++i) { | ||
| Particle p; | ||
| p.active1 = x[i]; |
There was a problem hiding this comment.
warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
p.active1 = x[i];
^| for (int i = 0; i < n; ++i) { | ||
| Particle p; | ||
| p.active1 = x[i]; | ||
| p.active2 = x[i] * x[i]; |
There was a problem hiding this comment.
warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
p.active2 = x[i] * x[i];
^| for (int i = 0; i < n; ++i) { | ||
| Particle p; | ||
| p.active1 = x[i]; | ||
| p.active2 = x[i] * x[i]; |
There was a problem hiding this comment.
warning: do not use pointer arithmetic [cppcoreguidelines-pro-bounds-pointer-arithmetic]
p.active2 = x[i] * x[i];
^1 participant
This PR introduces benchmark/ActivityWaste.cpp, a set of microbenchmarks designed to measure and monitor tape allocation overhead on the master branch. These act as baseline regression targets for upcoming activity analysis and dead-code pruning passes in the Clad differentiator.
Each benchmark case is designed to bypass Clang's constant folding and Clad's TBR optimization, successfully
forcing the recording of non-linear passive or dead intermediate variables.
The table below documents the measured headroom (tape waste) on master for each structural pattern before any advanced
activity analysis pruning is applied:
Related to issue #1873