openscad-cpp-evaluator 1.6.0__tar.gz → 1.7.0__tar.gz

{openscad_cpp_evaluator-1.6.0 → openscad_cpp_evaluator-1.7.0}/PKG-INFO

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

{openscad_cpp_evaluator-1.6.0 → openscad_cpp_evaluator-1.7.0}/include/openscad_cpp_evaluator/bytecode.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "openscad_cpp_evaluator/function_builtins.hpp"
 #include "openscad_cpp_evaluator/value.hpp"
 
 #include "openscad_cpp_parser/ast/ast_node.hpp"
@@ -787,6 +788,40 @@ struct CompiledChunk {
         const oscad::FunctionDeclaration* decl = nullptr;
         std::vector<std::optional<std::string>> argNames;
         const oscad::ASTNode* callNode = nullptr;
+        // Everything below is `calleeName` already looked up, once, here at
+        // compile time. The VM used to redo all three on EVERY builtin call:
+        // two std::string hashes into static tables plus a string compare
+        // against "object", for answers that cannot change once this site is
+        // compiled. `declaredParams` points into a function-local static
+        // table with process lifetime, so holding the pointer is safe.
+        BuiltinFnId builtinId = BuiltinFnId::None;
+        const std::vector<std::string>* declaredParams = nullptr;
+        bool isObjectBuiltin = false;
+
+        // Where each argument of this call goes, worked out once at compile
+        // time against `decl`'s parameter list -- see ArgBind. Only filled in
+        // for a static user-function callee (`decl` set); a builtin, an
+        // import or a dynamic/closure callee has no compile-time parameter
+        // list to match against and keeps the name-matching path.
+        //
+        // The names on both sides of that matching are fixed the moment this
+        // site is compiled, but the VM was redoing it on every call, twice:
+        // buildBoundArgs linear-scanned a name-keyed BoundArgs (copying each
+        // name into it), then bindBoundArgsIntoFrame linear-scanned it again
+        // for every parameter, then a third nested loop compared every bound
+        // name against every parameter name. A two-argument call did roughly
+        // ten std::string comparisons and two string copies to reach an
+        // answer that was already known. Binding straight into the frame's
+        // slots also MOVES each argument instead of moving it into BoundArgs
+        // and copying it back out.
+        struct ArgBind {
+            int paramIndex = -1;    // >=0: this argument binds that parameter
+            bool toDyn = false;     // instead bind by name into ctx.dyn ($-named, undeclared)
+            bool warnUnexpectedNamed = false;
+            bool warnTooManyPositional = false;
+        };
+        std::vector<ArgBind> argBinds;
+        bool hasArgPlan = false; // argBinds is authoritative (it is empty for a zero-argument call too)
     };
 
     // An upvalue read (see Op::LoadUpvalue): `targetDecl` is the enclosing

{openscad_cpp_evaluator-1.6.0 → openscad_cpp_evaluator-1.7.0}/include/openscad_cpp_evaluator/function_builtins.hpp

@@ -26,8 +26,35 @@ bool isBuiltinFunctionName(const std::string& name);
 // accept $-prefixed named-argument overrides). Mirrors the reference's
 // _math_fns dispatch table plus the textmetrics()/fontmetrics() special
 // cases (implemented on top of FontProvider, text_metrics.hpp).
+// One id per name evalBuiltinFunction handles (NOT the same list as
+// isBuiltinFunctionName -- "object" is deliberately absent, since it is
+// special-cased to builtinObject() before this function is reached). Public
+// so a CALL SITE can resolve its callee once, at compile time
+// (CompiledChunk::CallSite::builtinId), instead of hashing the name string
+// on every single call.
+enum class BuiltinFnId {
+    None, // not a name evalBuiltinFunction handles
+    TextMetrics, FontMetrics, Abs, Sign, Ceil, Floor, Round, Sqrt, Ln, Log, Exp, Sin, Cos, Tan,
+    Asin, Acos, Atan, Atan2, Max, Min, Pow, Norm, Cross, Rands, Concat, Len, Str, Chr, Ord,
+    IsUndef, IsNum, IsBool, IsString, IsList, IsFunction, IsObject, Search, Lookup, HasKey,
+    Version, VersionNum, ParentModule, DxfDim, DxfCross, SupportedFeature, LinearSolve,
+};
+
+// `name` -> its id, or None. The one place that hashes the name; everything
+// on a hot path should call this once at compile time and keep the answer.
+BuiltinFnId builtinFnIdFor(const std::string& name);
+
 Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs& args, const oscad::ASTNode& node);
 
+// The same dispatch with both of its name lookups already done: `id` from
+// builtinFnIdFor and `declaredParams` from builtinParamNames (dispatch.hpp),
+// which for all but a couple of builtins is null. `name` survives only
+// because diagnostics quote it. The string-taking overload above is just
+// this one with the two lookups performed first, and remains the entry point
+// for the AST interpreter, where there is no call site to cache them on.
+Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vector<std::string>* declaredParams,
+                                   const std::string& name, const CallArgs& args, const oscad::ASTNode& node);
+
 // object(a=1, b=2, ...) -- an ordered string-keyed map merging positional
 // (an existing object's entries, or a list of [key,value] pairs) and named
 // arguments, later arguments winning over earlier ones for the same key --

{openscad_cpp_evaluator-1.6.0 → openscad_cpp_evaluator-1.7.0}/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:
@@ -207,6 +271,7 @@ private:
     // 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
@@ -235,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
@@ -272,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;
     }
@@ -462,6 +529,7 @@ private:
     std::unordered_map<int, std::vector<int>> dirty_;
     std::vector<int> parent_{0}; // see ScopeTrailStorage::parent_
     int nextLevel_ = 0;
+
 };
 
 // Per-EvalContext handle onto a shared IndexedScopeTrailStorage<T> -- the
@@ -474,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.6.0 → openscad_cpp_evaluator-1.7.0}/pyproject.toml

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

{openscad_cpp_evaluator-1.6.0 → openscad_cpp_evaluator-1.7.0}/src/builtins/function_builtins.cpp

@@ -1007,12 +1007,7 @@ namespace {
 // `if (name == "...")` string-compare chain; the switch below then
 // compiles to a jump table instead of sequential comparisons. No branch's
 // logic changed, only how it's reached.
-enum class BuiltinFnId {
-    TextMetrics, FontMetrics, Abs, Sign, Ceil, Floor, Round, Sqrt, Ln, Log, Exp, Sin, Cos, Tan,
-    Asin, Acos, Atan, Atan2, Max, Min, Pow, Norm, Cross, Rands, Concat, Len, Str, Chr, Ord,
-    IsUndef, IsNum, IsBool, IsString, IsList, IsFunction, IsObject, Search, Lookup, HasKey,
-    Version, VersionNum, ParentModule, DxfDim, DxfCross, SupportedFeature, LinearSolve,
-};
+// BuiltinFnId itself now lives in function_builtins.hpp -- see builtinFnIdFor.
 
 // supported_feature("name") -> the level at which this build implements that
 // feature, or 0 for one it does not implement (and for a name it has never
@@ -1242,18 +1237,26 @@ bool checkBuiltinArgs(Evaluator& ev, const std::string& name, BuiltinFnId id, co
 
 } // namespace
 
+BuiltinFnId builtinFnIdFor(const std::string& name) {
+    const auto& ids = builtinFnIds();
+    const auto it = ids.find(name);
+    return it == ids.end() ? BuiltinFnId::None : it->second;
+}
+
 Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs& args, const oscad::ASTNode& node) {
+    return evalBuiltinFunctionResolved(ev, builtinFnIdFor(name), builtinParamNames(name), name, args, node);
+}
 
-    const auto& ids = builtinFnIds();
-    const auto idIt = ids.find(name);
+Value evalBuiltinFunctionResolved(Evaluator& ev, BuiltinFnId id, const std::vector<std::string>* declaredParams,
+                                   const std::string& name, const CallArgs& args, const oscad::ASTNode& node) {
     // Not one of the names this function handles (e.g. "object", routed
     // elsewhere before reaching here) -- mirrors the old chain's fallthrough.
-    if (idIt == ids.end()) return Value{};
+    if (id == BuiltinFnId::None) return Value{};
 
     // Only textmetrics/fontmetrics have an entry -- every other builtin
     // function reads its arguments positionally upstream and warns about
     // nothing. See builtinParamNames (registry.cpp).
-    if (const std::vector<std::string>* declared = builtinParamNames(name)) {
+    if (const std::vector<std::string>* declared = declaredParams) {
         for (const auto& [argName, _] : args.named) {
             if (!isConfigVariable(argName) &&
                 std::find(declared->begin(), declared->end(), argName) == declared->end()) {
@@ -1265,9 +1268,10 @@ Value evalBuiltinFunction(Evaluator& ev, const std::string& name, const CallArgs
     // Arity and argument types, with the reference's own two diagnostics.
     // This replaced a silent version of the same gate (scalarNumericArity /
     // numericOnlyNames), which returned undef without ever saying why.
-    if (!checkBuiltinArgs(ev, name, idIt->second, args, &node.position())) return Value{};
+    if (!checkBuiltinArgs(ev, name, id, args, &node.position())) return Value{};
 
-    switch (idIt->second) {
+    switch (id) {
+        case BuiltinFnId::None: return Value{}; // unreachable: handled above
         case BuiltinFnId::TextMetrics: return builtinTextmetrics(ev, args);
         case BuiltinFnId::FontMetrics: return builtinFontmetrics(ev, args);
         case BuiltinFnId::Abs: return Value{std::fabs(toDoubleLenient(getArg(args, 0, "x", Value{})))};

{openscad_cpp_evaluator-1.6.0 → openscad_cpp_evaluator-1.7.0}/src/bytecode_compiler.cpp

@@ -20,6 +20,46 @@
 namespace oscadeval {
 
 namespace {
+// Replays buildBoundArgs' own positional/named matching rule (bytecode_vm.cpp)
+// against a parameter list known at compile time, recording the answer per
+// argument instead of recomputing it per call. The rule, unchanged: a named
+// argument binds the parameter of that name, warning when there is none and
+// the name is not a $-config variable; a positional argument binds the
+// parameter at its own positional index, warning once when it runs past the
+// end; an undeclared $-name still reaches ctx.dyn; anything else is dropped.
+// A later argument writing the same parameter still wins, because both bind
+// the same slot in order.
+void planCallSiteArgs(CompiledChunk::CallSite& site,
+                      const std::vector<std::unique_ptr<oscad::ParameterDeclaration>>& params) {
+    const size_t nparams = params.size();
+    size_t positionalIdx = 0;
+    site.argBinds.resize(site.argNames.size());
+    for (size_t i = 0; i < site.argNames.size(); ++i) {
+        CompiledChunk::CallSite::ArgBind& b = site.argBinds[i];
+        if (site.argNames[i]) {
+            const std::string& name = *site.argNames[i];
+            int found = -1;
+            for (size_t p = 0; p < nparams; ++p) {
+                if (params[p]->name->name == name) {
+                    found = static_cast<int>(p);
+                    break;
+                }
+            }
+            b.paramIndex = found;
+            b.warnUnexpectedNamed = (found < 0) && !isConfigVariable(name);
+            b.toDyn = (found < 0) && !name.empty() && name[0] == '$';
+        } else {
+            if (positionalIdx < nparams) {
+                b.paramIndex = static_cast<int>(positionalIdx);
+            } else if (positionalIdx == nparams) {
+                b.warnTooManyPositional = true;
+            }
+            ++positionalIdx;
+        }
+    }
+    site.hasArgPlan = true;
+}
+
 
 // Thrown by compileExpr wherever it hits a construct this phase doesn't
 // compile yet -- tryCompileFunction catches it and returns nullopt (falls
@@ -601,6 +641,11 @@ public:
                         // call-site interleaved order, not resolveArgs'
                         // split positional/named CallArgs shape).
                         site.isBuiltin = true;
+                        // Resolve the callee here rather than per call; see
+                        // CallSite's own doc comment (bytecode.hpp).
+                        site.builtinId = builtinFnIdFor(calleeName);
+                        site.declaredParams = builtinParamNames(calleeName);
+                        site.isObjectBuiltin = (calleeName == "object");
                         isStatic = true;
                     }
                     // Anything else stays dynamic: a function-literal value,
@@ -674,6 +719,9 @@ public:
                         }
                     }
                 }
+                // Resolve every argument to its parameter now; see
+                // CallSite::argBinds (bytecode.hpp) for why.
+                if (site.decl) planCallSiteArgs(site, site.decl->parameters);
                 int siteIdx = static_cast<int>(chunk_.callSites.size());
                 chunk_.callSites.push_back(std::move(site));
                 // Builtins and import() never trampoline (matching