openscad-cpp-evaluator 1.5.0__tar.gz → 1.6.1__tar.gz

{openscad_cpp_evaluator-1.5.0 → openscad_cpp_evaluator-1.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openscad_cpp_evaluator
-Version: 1.5.0
+Version: 1.6.1
 Summary: C++ OpenSCAD evaluator with Python bindings
 Author: NeuSCAD Contributors
 License-Expression: MIT

{openscad_cpp_evaluator-1.5.0 → openscad_cpp_evaluator-1.6.1}/include/openscad_cpp_evaluator/bytecode_vm.hpp

@@ -152,7 +152,20 @@ struct IterList {
 // (pre-redesign) behavior exactly.
 struct VmFrame {
     const CompiledChunk* chunk = nullptr;
-    const std::vector<Instruction>* code = nullptr;
+    // This frame's instruction stream, pre-decomposed into data()/size().
+    // driveVm's dispatch loop reads both once per INSTRUCTION; when this was a
+    // `const std::vector<Instruction>*`, that cost a pointer chase plus an
+    // end-minus-begin divided by sizeof(Instruction) (a multiply by a magic
+    // constant) on every opcode. ~11% of a whole Anklet.scad render sat in that
+    // loop preamble. A compiled chunk's code vector is immutable for as long as
+    // any frame runs it, so caching these is free -- but they must only ever be
+    // set together, hence setCode() rather than two public fields to forget.
+    const Instruction* code = nullptr;
+    size_t codeSize = 0;
+    void setCode(const std::vector<Instruction>& c) {
+        code = c.data();
+        codeSize = c.size();
+    }
     size_t pc = 0;
     std::vector<Value> slots;
     std::vector<Value> stack;
@@ -189,6 +202,16 @@ struct VmFrame {
     // brackets first", normally via matched Push/Pop, or via
     // teardownVmCallStackDownTo on the exception path) already covers it.
     std::vector<PendingCsgWrap> csgWrapStack;
+    // Scratch CallArgs for this frame's builtin/import call sites, reused
+    // across calls so its two vectors keep their capacity: building a fresh
+    // one per call was 1.99M of one Anklet.scad render's 10M allocations,
+    // second only to the argument vector this frame's operand stack now
+    // stands in for. One per FRAME rather than one per Evaluator because a
+    // builtin can re-enter the VM -- but only by pushing a new frame, which
+    // brings its own scratch, and a frame never has two call opcodes in
+    // flight at once. Frames themselves are pooled (acquireVmFrame), so the
+    // capacity survives the call that grew it.
+    CallArgs argScratch;
     // The ORIGINAL callee name at push time, used by
     // Evaluator::exitUserCallSuccess's own returnHook call when this frame
     // carries a bracket -- deliberately NOT updated by a later tail hop

{openscad_cpp_evaluator-1.5.0 → openscad_cpp_evaluator-1.6.1}/include/openscad_cpp_evaluator/call_args.hpp

@@ -97,4 +97,14 @@ const oscad::Expression* argExpr(const oscad::Argument& arg);
 // positional argument, not a fixed named slot.
 std::vector<Value> allPositional(const CallArgs& args);
 
+// allPositional()'s size and element access, without building the vector.
+// The argument CHECKERS (function_builtins.cpp) only ever ask how many
+// positional slots there are and look at a couple of them, so they used to
+// pay a heap allocation plus a Value copy per slot on every builtin call
+// that has a check entry -- 1.97M of the 16.6M allocations in one
+// Anklet.scad render. positionalAt() answers undef for a gap, exactly as
+// allPositional() pads one.
+size_t positionalCount(const CallArgs& args);
+const Value& positionalAt(const CallArgs& args, size_t pos);
+
 } // namespace oscadeval

{openscad_cpp_evaluator-1.5.0 → openscad_cpp_evaluator-1.6.1}/include/openscad_cpp_evaluator/evaluator.hpp

@@ -1812,7 +1812,26 @@ private:
     // its (possibly many) active occurrences is checked, checking each
     // DISTINCT X once is exactly equivalent to checking every occurrence
     // -- not an approximation.
-    std::unordered_map<const oscad::ASTNode*, int> activeDeclRefcount_;
+    // A flat vector, not a map, for the reason the paragraph above already
+    // establishes: the number of DISTINCT active declarations stays small and
+    // roughly constant, so a linear scan beats hashing -- and an
+    // unordered_map cost one node allocation per user call (595K in one
+    // Anklet.scad render) where this costs none after warmup, while the
+    // every-call containment scan above walks contiguous memory instead of a
+    // hash table's buckets. Same flat-vector-over-small-map trade CallArgs and
+    // BoundArgs already make. Entry order is not meaningful (the scan visits
+    // all of them), so removal swaps with the back.
+    std::vector<std::pair<const oscad::ASTNode*, int>> activeDeclRefcount_;
+    // ++count for `decl`, appending an entry if it has none yet.
+    void noteActiveDeclEnter(const oscad::ASTNode* declNode) {
+        for (auto& entry : activeDeclRefcount_) {
+            if (entry.first == declNode) {
+                ++entry.second;
+                return;
+            }
+        }
+        activeDeclRefcount_.emplace_back(declNode, 1);
+    }
 
     // Shared cap on callStack_'s own size, checked by both
     // evalUserFunctionCore (below) and evalUserModule (user_calls.cpp) --

{openscad_cpp_evaluator-1.5.0 → openscad_cpp_evaluator-1.6.1}/include/openscad_cpp_evaluator/scope_trail.hpp

@@ -12,37 +12,101 @@
 
 namespace oscadeval {
 
-// A "binding trail" (the classic Prolog/WAM undo-log pattern): each
-// variable name owns a stack of (value, level) entries. Setting a name
-// pushes; entering a new scope opens a fresh `level`; exiting a scope pops
-// every entry tagged with that level, in O(bindings actually made at that
-// level) rather than O(whole-map-size) -- replacing EvalContext's previous
-// copy-the-whole-map-on-every-derivation design. Safe here specifically
-// because this codebase has no escaping closures: a FunctionLiteral value
-// is a bare AST pointer with no captured environment, and callCtxFor()
-// re-derives every call's context from the LIVE call stack -- nothing ever
-// reads a binding after the scope that pushed it has already exited.
+// Recycles the blocks that TrailView/IndexedTrailView's own shared_ptrs are
+// made of. Deriving one EvalContext opens three trail levels -- dyn, let_,
+// dynPositions -- and each was a fresh make_shared: ~2M allocations in one
+// Anklet.scad render, all of them the same size, almost all of them freed in
+// reverse order a few microseconds later. This hands the same block straight
+// back out.
 //
-// Visibility is by TRUE ANCESTRY, not by level-number comparison: each
-// level records its own PARENT level (the level that was current when it
-// was opened, or 0 -- meaning "no parent" -- for an isolating derivation,
-// see TrailView::openChild). A view at level L can see an entry pushed at
-// level E iff E appears on L's own parent chain (L, parent(L), parent(
-// parent(L)), ... down to 0). This was NOT the original design here: an
-// earlier version used a single numeric "ceiling" (visible iff E <= L),
-// which is necessary but not sufficient -- it incorrectly treated any
-// chronologically-earlier-but-still-open level as an ancestor, even an
-// unrelated sibling/isolated scope that happens to still be on the call
-// stack. Caught on a real script (BOSL2's attachable()/trapezoid(), which
-// deep-forwards children() through several more calls while attachable()
-// itself -- an ISOLATED scope with its own same-named "path"/"h"
-// parameters, still open throughout -- sits on the stack): the ceiling-
-// only check found attachable()'s own unbound "path"/"h" (undef) instead
-// of trapezoid()'s real ones, since level-number order alone can't tell
-// "ancestor" from "unrelated open branch." Parent-chain walking fixes this
-// by construction. See eval_context.hpp for how each derivation method
-// picks its own level and (via `isolate`) whether the parent chain
-// continues to the caller or terminates there.
+// It changes WHERE the memory comes from and nothing else: no lifetime, no
+// visibility, no popLevel timing. That is the whole point -- the trail's
+// escaping-closure rules are the most delicate thing in this file, and an
+// allocator cannot get them wrong.
+//
+// One size class, because there is exactly one: every block is the control
+// block plus one view object. Anything else falls through to the global
+// allocator rather than being kept.
+//
+// Worth ~1% of an Anklet.scad render, for 2M allocations removed -- a modest
+// return, and deliberately recorded here as such: macOS's own small-object
+// allocator is already a free list, so swapping it for another one only pays
+// for the bookkeeping either side of it. Removing an allocation that also
+// removed real work (a vector's worth of Value moves, say) has paid far
+// better everywhere it has been tried in this codebase.
+class ViewBlockPool {
+public:
+    ViewBlockPool() { free_.reserve(kMaxKept); }
+    ~ViewBlockPool() {
+        for (void* p : free_) ::operator delete(p);
+    }
+    ViewBlockPool(const ViewBlockPool&) = delete;
+    ViewBlockPool& operator=(const ViewBlockPool&) = delete;
+
+    void* take(std::size_t bytes) {
+        if (bytes == blockSize_ && !free_.empty()) {
+            void* p = free_.back();
+            free_.pop_back();
+            return p;
+        }
+        if (blockSize_ == 0) blockSize_ = bytes;
+        return ::operator new(bytes);
+    }
+    // noexcept is safe: free_ was reserved to kMaxKept up front and is never
+    // pushed past it, so this push_back cannot reallocate and cannot throw.
+    void give(void* p, std::size_t bytes) noexcept {
+        if (bytes != blockSize_ || free_.size() >= kMaxKept) {
+            ::operator delete(p);
+            return;
+        }
+        free_.push_back(p);
+    }
+
+private:
+    static constexpr std::size_t kMaxKept = 512;
+    std::size_t blockSize_ = 0;
+    std::vector<void*> free_;
+};
+
+// A STATELESS allocator over one pool per view type (each type has exactly
+// one block size, so each gets its own single-size-class pool). Stateless
+// matters twice over: std::allocate_shared stores a copy of the allocator
+// inside the very block it allocated, so a stateful one both grows every
+// block and -- if it held a shared_ptr to keep the pool alive past the last
+// view, which a pool owned by the storage would need -- pays an atomic
+// refcount pair per allocation. That version was measured, and it was SLOWER
+// than not pooling at all.
+//
+// thread_local, so no locking and no cross-thread sharing, and it outlives
+// every view on its thread, which is what makes "keep the pool alive for the
+// final deallocate" a non-problem rather than a lifetime puzzle.
+template <typename T>
+class ViewBlockAllocator {
+public:
+    using value_type = T;
+    ViewBlockAllocator() = default;
+    template <typename U>
+    ViewBlockAllocator(const ViewBlockAllocator<U>&) {}
+
+    T* allocate(std::size_t n) { return static_cast<T*>(pool().take(n * sizeof(T))); }
+    void deallocate(T* p, std::size_t n) noexcept { pool().give(p, n * sizeof(T)); }
+
+    template <typename U>
+    bool operator==(const ViewBlockAllocator<U>&) const noexcept {
+        return true;
+    }
+    template <typename U>
+    bool operator!=(const ViewBlockAllocator<U>&) const noexcept {
+        return false;
+    }
+
+private:
+    static ViewBlockPool& pool() {
+        static thread_local ViewBlockPool p;
+        return p;
+    }
+};
+
 template <typename T>
 class ScopeTrailStorage {
 public:
@@ -50,7 +114,7 @@ public:
     // ancestry chain here (an isolating derivation -- see openChild).
     int openLevel(int parentLevel) {
         int level = ++nextLevel_;
-        parent_[level] = parentLevel;
+        parent_.push_back(parentLevel); // index == level; see parent_'s own comment
         return level;
     }
 
@@ -122,7 +186,7 @@ public:
             }
             dirty_.erase(it);
         }
-        parent_.erase(level);
+        parent_[static_cast<size_t>(level)] = 0; // dead: an ancestry walk stops here
     }
 
     // nullptr if `name` has no binding on `myLevel`'s own ancestry chain.
@@ -154,8 +218,7 @@ public:
             } else if (entryLevel == ancestor) {
                 return &vec[static_cast<size_t>(idx)].value;
             } else {
-                auto pit = parent_.find(ancestor);
-                ancestor = pit != parent_.end() ? pit->second : 0;
+                ancestor = parent_[static_cast<size_t>(ancestor)];
             }
         }
         return nullptr;
@@ -194,8 +257,21 @@ private:
     };
     std::unordered_map<std::string, std::vector<Entry>> stacks_;
     std::unordered_map<int, std::vector<std::string>> dirty_;
-    std::unordered_map<int, int> parent_; // level -> parent level (0 = chain terminates here)
+    // level -> parent level (0 = chain terminates here, which is also what a
+    // popped level reads back as). Levels come from `++nextLevel_`, so they are
+    // dense and monotonic and this is a plain vector indexed BY level, with
+    // element 0 the unused stand-in for "no parent" -- push_back in openLevel()
+    // keeps index == level. It used to be an unordered_map<int,int>, which cost
+    // one hash-node allocation per scope derivation (3 of the 10 allocations a
+    // user function call makes, ~2M of them in one Anklet.scad render) and made
+    // lookup()'s ancestry walk -- run on every variable read -- a hash probe per
+    // hop instead of an array index. It never shrinks: 4 bytes per level ever
+    // opened (~2.6MB for Anklet.scad), traded knowingly for the allocation.
+    // Levels are NEVER renumbered or reused -- lookup()'s sorted-merge walk
+    // depends on level numbers being globally monotonic.
+    std::vector<int> parent_{0};
     int nextLevel_ = 0;
+
 };
 
 // Per-EvalContext handle onto a shared ScopeTrailStorage<T>: this view's
@@ -224,7 +300,8 @@ public:
     static std::shared_ptr<TrailView<T>> makeRoot() {
         auto storage = std::make_shared<ScopeTrailStorage<T>>();
         int level = storage->openLevel(0);
-        return std::make_shared<TrailView<T>>(storage, level);
+        return std::allocate_shared<TrailView<T>>(ViewBlockAllocator<TrailView<T>>(), storage,
+                                                  level);
     }
 
     // Open a fresh level for writes. `isolate=true` terminates the new
@@ -249,7 +326,7 @@ public:
     // call returns; ~TrailView() pops ITS bindings from ScopeTrailStorage
     // (erasing the very data the still-alive child's ancestry walk needs)
     // even though the walk can still numerically reach that ancestor level
-    // via ScopeTrailStorage::parent_ (that map entry is untouched -- only
+    // via ScopeTrailStorage::parent_ (that entry is untouched -- only
     // the DATA is gone). Caught by a closure created inside a let()
     // nested one level inside its own enclosing call reading undef for a
     // variable bound at the call's own (now-popped) level, not the let()'s
@@ -261,7 +338,8 @@ public:
     // changes what happens when something holds an EXTRA reference.
     std::shared_ptr<TrailView<T>> openChild(bool isolate) const {
         int level = storage_->openLevel(isolate ? 0 : level_);
-        auto child = std::make_shared<TrailView<T>>(storage_, level);
+        auto child = std::allocate_shared<TrailView<T>>(ViewBlockAllocator<TrailView<T>>(),
+                                                       storage_, level);
         if (!isolate) child->parentView_ = this->shared_from_this();
         return child;
     }
@@ -344,7 +422,7 @@ public:
 
     int openLevel(int parentLevel) {
         int level = ++nextLevel_;
-        parent_[level] = parentLevel;
+        parent_.push_back(parentLevel); // index == level; see parent_'s own comment
         return level;
     }
 
@@ -395,7 +473,7 @@ public:
             }
             dirty_.erase(it);
         }
-        parent_.erase(level);
+        parent_[static_cast<size_t>(level)] = 0; // dead: an ancestry walk stops here
     }
 
     // Same sorted-merge ancestry walk as ScopeTrailStorage::lookup -- see
@@ -414,8 +492,7 @@ public:
             } else if (entryLevel == ancestor) {
                 return &vec[static_cast<size_t>(idx)].value;
             } else {
-                auto pit = parent_.find(ancestor);
-                ancestor = pit != parent_.end() ? pit->second : 0;
+                ancestor = parent_[static_cast<size_t>(ancestor)];
             }
         }
         return nullptr;
@@ -450,8 +527,9 @@ private:
     std::shared_ptr<DynNameIntern> intern_;
     std::vector<std::vector<Entry>> stacks_;
     std::unordered_map<int, std::vector<int>> dirty_;
-    std::unordered_map<int, int> parent_;
+    std::vector<int> parent_{0}; // see ScopeTrailStorage::parent_
     int nextLevel_ = 0;
+
 };
 
 // Per-EvalContext handle onto a shared IndexedScopeTrailStorage<T> -- the
@@ -464,12 +542,14 @@ public:
     static std::shared_ptr<IndexedTrailView<T>> makeRoot(std::shared_ptr<DynNameIntern> intern) {
         auto storage = std::make_shared<IndexedScopeTrailStorage<T>>(std::move(intern));
         int level = storage->openLevel(0);
-        return std::make_shared<IndexedTrailView<T>>(storage, level);
+        return std::allocate_shared<IndexedTrailView<T>>(
+            ViewBlockAllocator<IndexedTrailView<T>>(), storage, level);
     }
 
     std::shared_ptr<IndexedTrailView<T>> openChild(bool isolate) const {
         int level = storage_->openLevel(isolate ? 0 : level_);
-        return std::make_shared<IndexedTrailView<T>>(storage_, level);
+        return std::allocate_shared<IndexedTrailView<T>>(
+            ViewBlockAllocator<IndexedTrailView<T>>(), storage_, level);
     }
 
     IndexedTrailView(std::shared_ptr<IndexedScopeTrailStorage<T>> storage, int level)

{openscad_cpp_evaluator-1.5.0 → openscad_cpp_evaluator-1.6.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "openscad_cpp_evaluator"
-version = "1.5.0"
+version = "1.6.1"
 description = "C++ OpenSCAD evaluator with Python bindings"
 readme = "README.md"
 requires-python = ">=3.12"

{openscad_cpp_evaluator-1.5.0 → openscad_cpp_evaluator-1.6.1}/src/builtins/call_args.cpp

@@ -106,6 +106,18 @@ const oscad::Expression* argExpr(const oscad::Argument& arg) {
     return static_cast<const oscad::PositionalArgument&>(arg).expr.get();
 }
 
+size_t positionalCount(const CallArgs& args) {
+    int maxPos = -1;
+    for (const auto& [idx, v] : args.positional) maxPos = std::max(maxPos, idx);
+    return static_cast<size_t>(maxPos + 1);
+}
+
+const Value& positionalAt(const CallArgs& args, size_t pos) {
+    static const Value kUndef;
+    const Value* v = args.findPositional(static_cast<int>(pos));
+    return v ? *v : kUndef;
+}
+
 std::vector<Value> allPositional(const CallArgs& args) {
     int maxPos = -1;
     for (const auto& [idx, v] : args.positional) maxPos = std::max(maxPos, idx);

{openscad_cpp_evaluator-1.5.0 → openscad_cpp_evaluator-1.6.1}/src/builtins/function_builtins.cpp

@@ -1179,15 +1179,15 @@ void warnConversion(Evaluator& ev, const std::string& name, const std::string& w
 // numbers, with a distinct "at least 1 vector element" arity text for the
 // empty-vector case.
 bool checkMinMax(Evaluator& ev, const std::string& name, const CallArgs& args, const oscad::Position* pos) {
-    const std::vector<Value> positional = allPositional(args);
-    const size_t count = positional.size() + args.named.size();
+    const size_t nPos = positionalCount(args);
+    const size_t count = nPos + args.named.size();
     if (count < 1) {
         warnArity(ev, name, "at least 1", count, pos);
         return false;
     }
-    if (positional.size() == 1 && std::holds_alternative<ListPtr>(positional[0])) {
+    if (nPos == 1 && std::holds_alternative<ListPtr>(positionalAt(args, 0))) {
         static const std::vector<Value> kEmptyItems;
-        const ListPtr& l = std::get<ListPtr>(positional[0]);
+        const ListPtr& l = std::get<ListPtr>(positionalAt(args, 0));
         const std::vector<Value>& items = l ? l->items : kEmptyItems;
         if (items.empty()) {
             warnArity(ev, name, "at least 1 vector element", 0, pos);
@@ -1201,9 +1201,9 @@ bool checkMinMax(Evaluator& ev, const std::string& name, const CallArgs& args, c
         }
         return true;
     }
-    for (size_t i = 0; i < positional.size(); ++i) {
-        if (!std::holds_alternative<double>(positional[i])) {
-            warnConversion(ev, name, "argument " + std::to_string(i), "number", positional[i], pos);
+    for (size_t i = 0; i < nPos; ++i) {
+        if (!std::holds_alternative<double>(positionalAt(args, i))) {
+            warnConversion(ev, name, "argument " + std::to_string(i), "number", positionalAt(args, i), pos);
             return false;
         }
     }
@@ -1219,8 +1219,8 @@ bool checkBuiltinArgs(Evaluator& ev, const std::string& name, BuiltinFnId id, co
     if (it == checks.end()) return true;
     const BuiltinCheck& c = it->second;
 
-    const std::vector<Value> positional = allPositional(args);
-    const size_t count = positional.size() + args.named.size();
+    const size_t nPos = positionalCount(args);
+    const size_t count = nPos + args.named.size();
     if (c.arityText && (static_cast<int>(count) < c.minArgs || (c.maxArgs >= 0 && static_cast<int>(count) > c.maxArgs))) {
         warnArity(ev, name, c.arityText, count, pos);
         return false;
@@ -1229,9 +1229,10 @@ bool checkBuiltinArgs(Evaluator& ev, const std::string& name, BuiltinFnId id, co
     // flat argument list can't be reconstructed from our split
     // positional/named form, and warning on the wrong index would be worse
     // than staying quiet on a spelling nobody uses for these builtins.
-    for (size_t i = 0; i < c.types.size() && i < positional.size(); ++i) {
-        if (!(typeBit(positional[i]) & c.types[i].allowed)) {
-            warnConversion(ev, name, "argument " + std::to_string(i), c.types[i].expected, positional[i], pos);
+    for (size_t i = 0; i < c.types.size() && i < nPos; ++i) {
+        const Value& v = positionalAt(args, i);
+        if (!(typeBit(v) & c.types[i].allowed)) {
+            warnConversion(ev, name, "argument " + std::to_string(i), c.types[i].expected, v, pos);
             return false;
         }
     }