From b117150f830b2b477f94493fed8ef80e53b8a82c Mon Sep 17 00:00:00 2001 From: Jake Hillion Date: Thu, 16 Nov 2023 07:34:03 -0800 Subject: [PATCH] tbv2: add dynamic context passed through all functions (#410) Summary: tbv2: add dynamic context passed through all functions Previously for we had some shared state between all requests, noticeably the pointers set. This change adds a by reference value to all requests which can hold additional mutable state. The pointers set is moved into this mutable state for OIL, which means each concurrent request will have its own pointer set. Doing things this way allows more features to be added in the future without such a big code modification. Closes https://github.com/facebookexperimental/object-introspection/issues/404 Pull Request resolved: https://github.com/facebookexperimental/object-introspection/pull/410 Test Plan: - CI Differential Revision: D51394035 Pulled By: JakeHillion fbshipit-source-id: 55d2ba9b5e056148a29dc821020cfc3d94e5175a --- oi/CodeGen.cpp | 25 +++++++++++++------ oi/FuncGen.cpp | 34 +++++++++++++++----------- oi/OICodeGen.cpp | 8 +++++- oi/OITraceCode.cpp | 7 +++--- types/array_type.toml | 4 +-- types/cxx11_list_type.toml | 4 +-- types/f14_fast_map.toml | 8 +++--- types/f14_fast_set.toml | 4 +-- types/f14_node_map.toml | 8 +++--- types/f14_node_set.toml | 4 +-- types/f14_value_map.toml | 8 +++--- types/f14_value_set.toml | 4 +-- types/f14_vector_map.toml | 8 +++--- types/f14_vector_set.toml | 4 +-- types/fb_string_type.toml | 4 +-- types/folly_iobuf_queue_type.toml | 2 +- types/list_type.toml | 4 +-- types/map_seq_type.toml | 10 ++++---- types/multi_map_type.toml | 8 +++--- types/multi_set_type.toml | 4 +-- types/optional_type.toml | 4 +-- types/pair_type.toml | 6 ++--- types/ref_wrapper_type.toml | 2 +- types/seq_type.toml | 4 +-- types/set_type.toml | 4 +-- types/shrd_ptr_type.toml | 8 +++--- types/small_vec_type.toml | 4 +-- types/sorted_vec_set_type.toml | 4 +-- types/std_map_type.toml | 10 ++++---- types/std_unordered_map_type.toml | 10 ++++---- types/std_unordered_multimap_type.toml | 4 +-- types/uniq_ptr_type.toml | 8 +++--- types/unordered_multiset_type.toml | 4 +-- types/unordered_set_type.toml | 4 +-- 34 files changed, 131 insertions(+), 107 deletions(-) diff --git a/oi/CodeGen.cpp b/oi/CodeGen.cpp index cfa87e7..bef102f 100644 --- a/oi/CodeGen.cpp +++ b/oi/CodeGen.cpp @@ -128,8 +128,9 @@ void addIncludes(const TypeGraph& typeGraph, includes.emplace("oi/types/st.h"); } if (features[Feature::Library]) { - includes.emplace("vector"); + includes.emplace("memory"); includes.emplace("oi/IntrospectionResult.h"); + includes.emplace("vector"); } if (features[Feature::JitTiming]) { includes.emplace("chrono"); @@ -428,7 +429,7 @@ void addStandardGetSizeFuncDefs(std::string& code) { JLOG("ptr val @"); JLOGPTR(s_ptr); StoreData((uintptr_t)(s_ptr), returnArg); - if (s_ptr && pointers.add((uintptr_t)s_ptr)) { + if (s_ptr && ctx.pointers.add((uintptr_t)s_ptr)) { StoreData(1, returnArg); getSizeType(*(s_ptr), returnArg); } else { @@ -649,7 +650,8 @@ void CodeGen::genClassTraversalFunction(const Class& c, std::string& code) { code += " static types::st::Unit "; code += funcName; - code += "(\n const "; + code += "(\n Ctx& ctx,\n"; + code += " const "; code += c.name(); code += "& t,\n typename TypeHandler(ctx, t."; code += member.name; code += ", ret); })"; } @@ -921,6 +924,7 @@ void genContainerTypeHandler(std::unordered_set& used, code += ";\n"; code += " static types::st::Unit getSizeType(\n"; + code += " Ctx& ctx,\n"; code += " const "; code += containerWithTypes; code += "& container,\n"; @@ -979,7 +983,7 @@ void addCaptureKeySupport(std::string& code) { }; template - auto maybeCaptureKey(const T& key, auto returnArg) { + auto maybeCaptureKey(Ctx& ctx, const T& key, auto returnArg) { if constexpr (CaptureKeys) { return returnArg.delegate([&key](auto ret) { return CaptureKeyHandler::captureKey(key, ret); @@ -1041,10 +1045,10 @@ void addStandardTypeHandlers(TypeGraph& typeGraph, code += R"( template types::st::Unit - getSizeType(const T &t, typename TypeHandler::type returnArg) { + getSizeType(Ctx& ctx, const T &t, typename TypeHandler::type returnArg) { JLOG("obj @"); JLOGPTR(&t); - return TypeHandler::getSizeType(t, returnArg); + return TypeHandler::getSizeType(ctx, t, returnArg); } )"; @@ -1233,6 +1237,13 @@ void CodeGen::generate( if (config_.features[Feature::CaptureThriftIsset]) { genDefsThrift(typeGraph, code); } + if (!config_.features[Feature::TreeBuilderV2]) { + code += "namespace {\n"; + code += "static struct Context {\n"; + code += " PointerHashSet<> pointers;\n"; + code += "} ctx;\n"; + code += "} // namespace\n"; + } /* * The purpose of the anonymous namespace within `OIInternal` is that diff --git a/oi/FuncGen.cpp b/oi/FuncGen.cpp index 7cc2868..0b1e293 100644 --- a/oi/FuncGen.cpp +++ b/oi/FuncGen.cpp @@ -262,19 +262,24 @@ void __attribute__((used, retain)) introspect_%2$016x( std::vector& v) #pragma GCC diagnostic pop { - pointers.initialize(); - pointers.add((uintptr_t)&t); - v.clear(); v.reserve(4096); + auto pointers = std::make_unique>(); + pointers->initialize(); + struct Context { using DataBuffer = DataBuffer::BackInserter>; + + PointerHashSet<>& pointers; }; + Context ctx{ .pointers = *pointers }; + ctx.pointers.add((uintptr_t)&t); + using ContentType = OIInternal::TypeHandler::type; ContentType ret{Context::DataBuffer{v}}; - OIInternal::getSizeType(t, ret); + OIInternal::getSizeType(ctx, t, ret); } )"; @@ -319,8 +324,8 @@ void FuncGen::DefineTopLevelGetSizeRef(std::string& testCode, func += " const auto startTime = std::chrono::steady_clock::now();\n"; } func += R"( - pointers.initialize(); - pointers.add((uintptr_t)&t); + ctx.pointers.initialize(); + ctx.pointers.add((uintptr_t)&t); auto data = reinterpret_cast(dataBase); size_t dataSegOffset = 0; @@ -340,8 +345,8 @@ void FuncGen::DefineTopLevelGetSizeRef(std::string& testCode, OIInternal::StoreData((uintptr_t)123456789, dataSegOffset); writtenSize = dataSegOffset; dataBase += dataSegOffset; - pointersSize = pointers.size(); - pointersCapacity = pointers.capacity(); + pointersSize = ctx.pointers.size(); + pointersCapacity = ctx.pointers.capacity(); )"; if (features[Feature::JitTiming]) { func += R"( @@ -421,7 +426,7 @@ void FuncGen::DefineTopLevelGetSizeSmartPtr(std::string& testCode, func += " const auto startTime = std::chrono::steady_clock::now();\n"; } func += R"( - pointers.initialize(); + ctx.pointers.initialize(); auto data = reinterpret_cast(dataBase); size_t dataSegOffset = 0; @@ -440,8 +445,8 @@ void FuncGen::DefineTopLevelGetSizeSmartPtr(std::string& testCode, OIInternal::StoreData((uintptr_t)123456789, dataSegOffset); writtenSize = dataSegOffset; dataBase += dataSegOffset; - pointersSize = pointers.size(); - pointersCapacity = pointers.capacity(); + pointersSize = ctx.pointers.size(); + pointersCapacity = ctx.pointers.capacity(); )"; if (features[Feature::JitTiming]) { func += R"( @@ -678,13 +683,14 @@ void FuncGen::DefineBasicTypeHandlers(std::string& code, FeatureSet features) { } code += R"( static types::st::Unit getSizeType( + Ctx& ctx, const T& t, typename TypeHandler::type returnArg) { if constexpr(std::is_pointer_v) { JLOG("ptr val @"); JLOGPTR(t); auto r0 = returnArg.write((uintptr_t)t); - if (t && pointers.add((uintptr_t)t)) { + if (t && ctx.pointers.add((uintptr_t)t)) { return r0.template delegate<1>([&t](auto ret) { if constexpr (!std::is_void>::value) { return TypeHandler>::getSizeType(*t, ret); @@ -727,8 +733,8 @@ ContainerInfo FuncGen::GetOiArrayContainerInfo() { oiArray.codegen.traversalFunc = R"( auto tail = returnArg.write(N0); for (size_t i=0; i::getSizeType(container.vals[i], ret); + tail = tail.delegate([&ctx, &container, i](auto ret) { + return TypeHandler::getSizeType(ctx, container.vals[i], ret); }); } return tail.finish(); diff --git a/oi/OICodeGen.cpp b/oi/OICodeGen.cpp index ee18429..eaa25ad 100644 --- a/oi/OICodeGen.cpp +++ b/oi/OICodeGen.cpp @@ -3049,6 +3049,12 @@ bool OICodeGen::generateJitCode(std::string& code) { #define SAVE_DATA(val) StoreData(val, returnArg) )"); + code.append("namespace {\n"); + code.append("static struct Context {\n"); + code.append(" PointerHashSet<> pointers;\n"); + code.append("} ctx;\n"); + code.append("} // namespace\n"); + FuncGen::DefineJitLog(code, config.features); // The purpose of the anonymous namespace within `OIInternal` is that @@ -3267,7 +3273,7 @@ bool OICodeGen::generateJitCode(std::string& code) { JLOG("ptr val @"); JLOGPTR(s_ptr); StoreData((uintptr_t)(s_ptr), returnArg); - if (s_ptr && pointers.add((uintptr_t)s_ptr)) { + if (s_ptr && ctx.pointers.add((uintptr_t)s_ptr)) { StoreData(1, returnArg); getSizeType(*(s_ptr), returnArg); } else { diff --git a/oi/OITraceCode.cpp b/oi/OITraceCode.cpp index 5cc443d..31a873b 100644 --- a/oi/OITraceCode.cpp +++ b/oi/OITraceCode.cpp @@ -40,10 +40,11 @@ constexpr int oidMagicId = 0x01DE8; namespace { -class { +template +class PointerHashSet { private: // 1 MiB of pointers - std::array data; + std::array data; size_t numEntries; /* @@ -107,7 +108,7 @@ class { bool add(const auto* p) { return add((uintptr_t)p); } -} static pointers; +}; } // namespace diff --git a/types/array_type.toml b/types/array_type.toml index 126af6a..054d0c6 100644 --- a/types/array_type.toml +++ b/types/array_type.toml @@ -33,8 +33,8 @@ traversal_func = """ auto tail = returnArg.write(container.size()); for (auto & it: container) { - tail = tail.delegate([&it](auto ret) { - return TypeHandler::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](auto ret) { + return TypeHandler::getSizeType(ctx, it, ret); }); } diff --git a/types/cxx11_list_type.toml b/types/cxx11_list_type.toml index f838eee..6788750 100644 --- a/types/cxx11_list_type.toml +++ b/types/cxx11_list_type.toml @@ -38,8 +38,8 @@ auto tail = returnArg.write((uintptr_t)&container) .write(container.size()); for (auto&& it : container) { - tail = tail.delegate([&it](auto ret) { - return OIInternal::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](auto ret) { + return OIInternal::getSizeType(ctx, it, ret); }); } diff --git a/types/f14_fast_map.toml b/types/f14_fast_map.toml index faf2e9d..06c6f72 100644 --- a/types/f14_fast_map.toml +++ b/types/f14_fast_map.toml @@ -43,11 +43,11 @@ auto tail = returnArg .write(container.size()); for (auto &&entry: container) { - tail = tail.delegate([&key = entry.first, &value = entry.second](auto ret) { - auto next = ret.delegate([&key](typename TypeHandler::type ret) { - return OIInternal::getSizeType(key, ret); + tail = tail.delegate([&ctx, &key = entry.first, &value = entry.second](auto ret) { + auto next = ret.delegate([&ctx, &key](typename TypeHandler::type ret) { + return OIInternal::getSizeType(ctx, key, ret); }); - return OIInternal::getSizeType(value, next); + return OIInternal::getSizeType(ctx, value, next); }); } diff --git a/types/f14_fast_set.toml b/types/f14_fast_set.toml index b66284b..fb0017c 100644 --- a/types/f14_fast_set.toml +++ b/types/f14_fast_set.toml @@ -42,8 +42,8 @@ auto tail = returnArg .write(container.size()); for (auto &&entry: container) { - tail = tail.delegate([&entry](auto ret) { - return OIInternal::getSizeType(entry, ret); + tail = tail.delegate([&ctx, &entry](auto ret) { + return OIInternal::getSizeType(ctx, entry, ret); }); } diff --git a/types/f14_node_map.toml b/types/f14_node_map.toml index a53c3e6..de1dcda 100644 --- a/types/f14_node_map.toml +++ b/types/f14_node_map.toml @@ -43,11 +43,11 @@ auto tail = returnArg .write(container.size()); for (auto &&entry: container) { - tail = tail.delegate([&key = entry.first, &value = entry.second](auto ret) { - auto next = ret.delegate([&key](typename TypeHandler::type ret) { - return OIInternal::getSizeType(key, ret); + tail = tail.delegate([&ctx, &key = entry.first, &value = entry.second](auto ret) { + auto next = ret.delegate([&ctx, &key](typename TypeHandler::type ret) { + return OIInternal::getSizeType(ctx, key, ret); }); - return OIInternal::getSizeType(value, next); + return OIInternal::getSizeType(ctx, value, next); }); } diff --git a/types/f14_node_set.toml b/types/f14_node_set.toml index 3ed0b5d..224789e 100644 --- a/types/f14_node_set.toml +++ b/types/f14_node_set.toml @@ -42,8 +42,8 @@ auto tail = returnArg .write(container.size()); for (auto &&entry: container) { - tail = tail.delegate([&entry](auto ret) { - return OIInternal::getSizeType(entry, ret); + tail = tail.delegate([&ctx, &entry](auto ret) { + return OIInternal::getSizeType(ctx, entry, ret); }); } diff --git a/types/f14_value_map.toml b/types/f14_value_map.toml index 8072abf..c09bbf0 100644 --- a/types/f14_value_map.toml +++ b/types/f14_value_map.toml @@ -43,11 +43,11 @@ auto tail = returnArg .write(container.size()); for (auto &&entry: container) { - tail = tail.delegate([&key = entry.first, &value = entry.second](auto ret) { - auto next = ret.delegate([&key](typename TypeHandler::type ret) { - return OIInternal::getSizeType(key, ret); + tail = tail.delegate([&ctx, &key = entry.first, &value = entry.second](auto ret) { + auto next = ret.delegate([&ctx, &key](typename TypeHandler::type ret) { + return OIInternal::getSizeType(ctx, key, ret); }); - return OIInternal::getSizeType(value, next); + return OIInternal::getSizeType(ctx, value, next); }); } diff --git a/types/f14_value_set.toml b/types/f14_value_set.toml index dd4070d..f37f7d0 100644 --- a/types/f14_value_set.toml +++ b/types/f14_value_set.toml @@ -42,8 +42,8 @@ auto tail = returnArg .write(container.size()); for (auto &&entry: container) { - tail = tail.delegate([&entry](auto ret) { - return OIInternal::getSizeType(entry, ret); + tail = tail.delegate([&ctx, &entry](auto ret) { + return OIInternal::getSizeType(ctx, entry, ret); }); } diff --git a/types/f14_vector_map.toml b/types/f14_vector_map.toml index ec7ac93..a673bbd 100644 --- a/types/f14_vector_map.toml +++ b/types/f14_vector_map.toml @@ -43,11 +43,11 @@ auto tail = returnArg .write(container.size()); for (auto &&entry: container) { - tail = tail.delegate([&key = entry.first, &value = entry.second](auto ret) { - auto next = ret.delegate([&key](typename TypeHandler::type ret) { - return OIInternal::getSizeType(key, ret); + tail = tail.delegate([&ctx, &key = entry.first, &value = entry.second](auto ret) { + auto next = ret.delegate([&ctx, &key](typename TypeHandler::type ret) { + return OIInternal::getSizeType(ctx, key, ret); }); - return OIInternal::getSizeType(value, next); + return OIInternal::getSizeType(ctx, value, next); }); } diff --git a/types/f14_vector_set.toml b/types/f14_vector_set.toml index e98b6d8..d85f36d 100644 --- a/types/f14_vector_set.toml +++ b/types/f14_vector_set.toml @@ -42,8 +42,8 @@ auto tail = returnArg .write(container.size()); for (auto &&entry: container) { - tail = tail.delegate([&entry](auto ret) { - return OIInternal::getSizeType(entry, ret); + tail = tail.delegate([&ctx, &entry](auto ret) { + return OIInternal::getSizeType(ctx, entry, ret); }); } diff --git a/types/fb_string_type.toml b/types/fb_string_type.toml index e0679d3..169be87 100644 --- a/types/fb_string_type.toml +++ b/types/fb_string_type.toml @@ -29,7 +29,7 @@ void getSizeType(const %1% &container, size_t& returnArg) && ((uintptr_t)container.data() >= (uintptr_t)&container); - if (!inlined && pointers.add((uintptr_t)container.data())) { + if (!inlined && ctx.pointers.add((uintptr_t)container.data())) { SAVE_SIZE(container.capacity() * sizeof(T)); SAVE_DATA(1); } else { @@ -60,7 +60,7 @@ if (isStorageInline(container)) { category = Category::InlinedStorage; } else if (capacity < minLargeSize) { category = Category::OwnedHeapStorage; -} else if (pointers.add(container.data())) { +} else if (ctx.pointers.add(container.data())) { category = Category::ReferenceCountedStorage; } else { category = Category::AlreadyAttributed; diff --git a/types/folly_iobuf_queue_type.toml b/types/folly_iobuf_queue_type.toml index 0af134d..b9ef72c 100644 --- a/types/folly_iobuf_queue_type.toml +++ b/types/folly_iobuf_queue_type.toml @@ -22,7 +22,7 @@ void getSizeType(const %1% &container, size_t& returnArg) const folly::IOBuf *head = container.front(); SAVE_DATA((uintptr_t)head); - if (head && pointers.add((uintptr_t)head)) { + if (head && ctx.pointers.add((uintptr_t)head)) { SAVE_DATA(1); getSizeType(*head, returnArg); } else { diff --git a/types/list_type.toml b/types/list_type.toml index 86d457e..3e0da3c 100644 --- a/types/list_type.toml +++ b/types/list_type.toml @@ -38,8 +38,8 @@ auto tail = returnArg.write((uintptr_t)&container) .write(container.size()); for (auto&& it : container) { - tail = tail.delegate([&it](auto ret) { - return OIInternal::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](auto ret) { + return OIInternal::getSizeType(ctx, it, ret); }); } diff --git a/types/map_seq_type.toml b/types/map_seq_type.toml index 887df6a..a09efff 100644 --- a/types/map_seq_type.toml +++ b/types/map_seq_type.toml @@ -42,12 +42,12 @@ traversal_func = ''' .write(container.size()); for (const auto& kv : container) { - tail = tail.delegate([&kv](auto ret) { - auto start = maybeCaptureKey(kv.first, ret); - auto next = start.delegate([&kv](typename TypeHandler::type ret) { - return OIInternal::getSizeType(kv.first, ret); + tail = tail.delegate([&ctx, &kv](auto ret) { + auto start = maybeCaptureKey(ctx, kv.first, ret); + auto next = start.delegate([&ctx, &kv](typename TypeHandler::type ret) { + return OIInternal::getSizeType(ctx, kv.first, ret); }); - return OIInternal::getSizeType(kv.second, next); + return OIInternal::getSizeType(ctx, kv.second, next); }); } diff --git a/types/multi_map_type.toml b/types/multi_map_type.toml index e05a1e3..a5d628f 100644 --- a/types/multi_map_type.toml +++ b/types/multi_map_type.toml @@ -39,11 +39,11 @@ auto tail = returnArg .write(container.size()); for (const auto &entry: container) { - tail = tail.delegate([&key = entry.first, &value = entry.second](auto ret) { - auto next = ret.delegate([&key](typename TypeHandler::type ret) { - return OIInternal::getSizeType(key, ret); + tail = tail.delegate([&ctx, &key = entry.first, &value = entry.second](auto ret) { + auto next = ret.delegate([&ctx, &key](typename TypeHandler::type ret) { + return OIInternal::getSizeType(ctx, key, ret); }); - return OIInternal::getSizeType(value, next); + return OIInternal::getSizeType(ctx, value, next); }); } diff --git a/types/multi_set_type.toml b/types/multi_set_type.toml index 00f8239..f238356 100644 --- a/types/multi_set_type.toml +++ b/types/multi_set_type.toml @@ -42,8 +42,8 @@ auto tail = returnArg.write((uintptr_t)&container) // The double ampersand is needed otherwise this loop doesn't work with // vector for (auto&& it : container) { - tail = tail.delegate([&it](auto ret) { - return OIInternal::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](auto ret) { + return OIInternal::getSizeType(ctx, it, ret); }); } diff --git a/types/optional_type.toml b/types/optional_type.toml index 3bd9cff..eeba64e 100644 --- a/types/optional_type.toml +++ b/types/optional_type.toml @@ -30,8 +30,8 @@ void getSizeType(const %1%& container, size_t& returnArg) { traversal_func = """ if (container.has_value()) { - return returnArg.template delegate<1>([&container](auto ret) { - return OIInternal::getSizeType(*container, ret); + return returnArg.template delegate<1>([&ctx, &container](auto ret) { + return OIInternal::getSizeType(ctx, *container, ret); }); } else { return returnArg.template delegate<0>(std::identity()); diff --git a/types/pair_type.toml b/types/pair_type.toml index ba5bc38..f157144 100644 --- a/types/pair_type.toml +++ b/types/pair_type.toml @@ -27,10 +27,10 @@ void getSizeType(const %1% &container, size_t& returnArg) """ traversal_func = """ - return OIInternal::getSizeType( + return OIInternal::getSizeType(ctx, container.second, - returnArg.delegate([&container](auto ret) { - return OIInternal::getSizeType(container.first, ret); + returnArg.delegate([&ctx, &container](auto ret) { + return OIInternal::getSizeType(ctx, container.first, ret); }) ); """ diff --git a/types/ref_wrapper_type.toml b/types/ref_wrapper_type.toml index 949b385..9ed5094 100644 --- a/types/ref_wrapper_type.toml +++ b/types/ref_wrapper_type.toml @@ -21,7 +21,7 @@ void getSizeType(const %1% &ref, size_t& returnArg) { SAVE_SIZE(sizeof(%1%)); SAVE_DATA((uintptr_t)&(ref.get())); - if (pointers.add((uintptr_t)&ref.get())) { + if (ctx.pointers.add((uintptr_t)&ref.get())) { SAVE_DATA(1); getSizeType(ref.get(), returnArg); } else { diff --git a/types/seq_type.toml b/types/seq_type.toml index 88ddd1d..f561d0b 100644 --- a/types/seq_type.toml +++ b/types/seq_type.toml @@ -43,8 +43,8 @@ auto tail = returnArg.write((uintptr_t)&container) // The double ampersand is needed otherwise this loop doesn't work with // vector for (auto&& it : container) { - tail = tail.delegate([&it](auto ret) { - return OIInternal::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](auto ret) { + return OIInternal::getSizeType(ctx, it, ret); }); } diff --git a/types/set_type.toml b/types/set_type.toml index e29611e..9d3bc3c 100644 --- a/types/set_type.toml +++ b/types/set_type.toml @@ -43,8 +43,8 @@ auto tail = returnArg.write((uintptr_t)&container) // The double ampersand is needed otherwise this loop doesn't work with // vector for (auto&& it : container) { - tail = tail.delegate([&it](auto ret) { - return OIInternal::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](auto ret) { + return OIInternal::getSizeType(ctx, it, ret); }); } diff --git a/types/shrd_ptr_type.toml b/types/shrd_ptr_type.toml index 125fd71..bb3a622 100644 --- a/types/shrd_ptr_type.toml +++ b/types/shrd_ptr_type.toml @@ -24,7 +24,7 @@ void getSizeType(const %1% &s_ptr, size_t& returnArg) if constexpr (!std::is_void::value) { SAVE_DATA((uintptr_t)(s_ptr.get())); - if (s_ptr && pointers.add((uintptr_t)(s_ptr.get()))) { + if (s_ptr && ctx.pointers.add((uintptr_t)(s_ptr.get()))) { SAVE_DATA(1); getSizeType(*(s_ptr.get()), returnArg); } else { @@ -40,12 +40,12 @@ auto tail = returnArg.write((uintptr_t)container.get()); if constexpr (std::is_void::value) { return tail.template delegate<0>(std::identity()); } else { - bool do_visit = container && pointers.add((uintptr_t)container.get()); + bool do_visit = container && ctx.pointers.add((uintptr_t)container.get()); if (!do_visit) return tail.template delegate<0>(std::identity()); - return tail.template delegate<1>([&container](auto ret) { - return OIInternal::getSizeType(*container, ret); + return tail.template delegate<1>([&ctx, &container](auto ret) { + return OIInternal::getSizeType(ctx, *container, ret); }); } """ diff --git a/types/small_vec_type.toml b/types/small_vec_type.toml index d129285..a5f1694 100644 --- a/types/small_vec_type.toml +++ b/types/small_vec_type.toml @@ -56,8 +56,8 @@ auto tail = returnArg .write(container.size()); for (auto &&it: container) { - tail = tail.delegate([&it](typename TypeHandler::type ret) { - return OIInternal::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](typename TypeHandler::type ret) { + return OIInternal::getSizeType(ctx, it, ret); }); } diff --git a/types/sorted_vec_set_type.toml b/types/sorted_vec_set_type.toml index e8b9483..a803d61 100644 --- a/types/sorted_vec_set_type.toml +++ b/types/sorted_vec_set_type.toml @@ -37,8 +37,8 @@ auto tail = returnArg.write((uintptr_t)&container) .write(container.size()); for (const auto& el : container) { - tail = tail.delegate([&el](auto ret) { - return OIInternal::getSizeType(el, ret); + tail = tail.delegate([&ctx, &el](auto ret) { + return OIInternal::getSizeType(ctx, el, ret); }); } diff --git a/types/std_map_type.toml b/types/std_map_type.toml index df06cc7..ee652ec 100644 --- a/types/std_map_type.toml +++ b/types/std_map_type.toml @@ -43,12 +43,12 @@ auto tail = returnArg .write(container.size()); for (const auto &entry: container) { - tail = tail.delegate([&key = entry.first, &value = entry.second](auto ret) { - auto start = maybeCaptureKey(key, ret); - auto next = start.delegate([&key](typename TypeHandler::type ret) { - return OIInternal::getSizeType(key, ret); + tail = tail.delegate([&ctx, &key = entry.first, &value = entry.second](auto ret) { + auto start = maybeCaptureKey(ctx, key, ret); + auto next = start.delegate([&ctx, &key](typename TypeHandler::type ret) { + return OIInternal::getSizeType(ctx, key, ret); }); - return OIInternal::getSizeType(value, next); + return OIInternal::getSizeType(ctx, value, next); }); } diff --git a/types/std_unordered_map_type.toml b/types/std_unordered_map_type.toml index 27142a1..5b2402f 100644 --- a/types/std_unordered_map_type.toml +++ b/types/std_unordered_map_type.toml @@ -46,12 +46,12 @@ auto tail = returnArg .write(container.size()); for (const auto& kv : container) { - tail = tail.delegate([&kv](auto ret) { - auto start = maybeCaptureKey(kv.first, ret); - auto next = start.delegate([&kv](typename TypeHandler::type ret) { - return OIInternal::getSizeType(kv.first, ret); + tail = tail.delegate([&ctx, &kv](auto ret) { + auto start = maybeCaptureKey(ctx, kv.first, ret); + auto next = start.delegate([&ctx, &kv](typename TypeHandler::type ret) { + return OIInternal::getSizeType(ctx, kv.first, ret); }); - return OIInternal::getSizeType(kv.second, next); + return OIInternal::getSizeType(ctx, kv.second, next); }); } diff --git a/types/std_unordered_multimap_type.toml b/types/std_unordered_multimap_type.toml index 261a0be..a6f7671 100644 --- a/types/std_unordered_multimap_type.toml +++ b/types/std_unordered_multimap_type.toml @@ -46,8 +46,8 @@ auto tail = returnArg .write(container.size()); for (const auto &it : container) { - tail = tail.delegate([&it](auto ret) { - return OIInternal::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](auto ret) { + return OIInternal::getSizeType(ctx, it, ret); }); } diff --git a/types/uniq_ptr_type.toml b/types/uniq_ptr_type.toml index 58364cf..f723f80 100644 --- a/types/uniq_ptr_type.toml +++ b/types/uniq_ptr_type.toml @@ -25,7 +25,7 @@ void getSizeType(const %1% &u_ptr, size_t& returnArg) if constexpr (!std::is_void::value) { SAVE_DATA((uintptr_t)(u_ptr.get())); - if (u_ptr && pointers.add((uintptr_t)(u_ptr.get()))) { + if (u_ptr && ctx.pointers.add((uintptr_t)(u_ptr.get()))) { SAVE_DATA(1); getSizeType(*(u_ptr.get()), returnArg); } else { @@ -41,12 +41,12 @@ auto tail = returnArg.write((uintptr_t)container.get()); if constexpr (std::is_void::value) { return tail.template delegate<0>(std::identity()); } else { - bool do_visit = container && pointers.add((uintptr_t)container.get()); + bool do_visit = container && ctx.pointers.add((uintptr_t)container.get()); if (!do_visit) return tail.template delegate<0>(std::identity()); - return tail.template delegate<1>([&container](auto ret) { - return OIInternal::getSizeType(*container, ret); + return tail.template delegate<1>([&ctx, &container](auto ret) { + return OIInternal::getSizeType(ctx, *container, ret); }); } """ diff --git a/types/unordered_multiset_type.toml b/types/unordered_multiset_type.toml index 5c2e96b..bfcf203 100644 --- a/types/unordered_multiset_type.toml +++ b/types/unordered_multiset_type.toml @@ -44,8 +44,8 @@ auto tail = returnArg .write(container.size()); for (const auto &it : container) { - tail = tail.delegate([&it](auto ret) { - return OIInternal::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](auto ret) { + return OIInternal::getSizeType(ctx, it, ret); }); } diff --git a/types/unordered_set_type.toml b/types/unordered_set_type.toml index f8d26c9..d9a827a 100644 --- a/types/unordered_set_type.toml +++ b/types/unordered_set_type.toml @@ -44,8 +44,8 @@ auto tail = returnArg .write(container.size()); for (const auto &it : container) { - tail = tail.delegate([&it](auto ret) { - return OIInternal::getSizeType(it, ret); + tail = tail.delegate([&ctx, &it](auto ret) { + return OIInternal::getSizeType(ctx, it, ret); }); }