fibernet 4.0.2__tar.gz → 4.0.4__tar.gz

{fibernet-4.0.2 → fibernet-4.0.4}/CHANGELOG.md

@@ -1,3 +1,35 @@
+## [4.0.4] - 2026-07-17
+
+### Fixed
+- **Critical: Progressive slowdown during batch simulation (kernel recompilation)**
+  - Moved `@ti.kernel def substep()` out of `dynamics()` method body
+  - Kernel now compiled once per `(dim, num_nodes, num_edges)` and cached alongside fields
+  - Before: Each `dynamics()` call recompiled the kernel → Taichi LLVM accumulated modules → progressive slowdown
+  - After: Kernel cached → constant per-structure time across hundreds of calls
+  - Test: 50 structures, first-10 avg = 6.60s, last-10 avg = 7.09s (ratio 1.07x — no slowdown)
+
+### Technical Details
+- File: `fibernet/sim/accelerated.py`
+- Change: Kernel definition moved inside the `_field_cache` allocation block, stored as `cached['substep']`
+- Impact: Eliminates ~0.5-1s kernel compilation overhead per call after the first
+- Combined with 4.0.2 (vectorized save) and 4.0.3 (field cache): total ~16x speedup from original
+
+## [4.0.3] - 2026-07-17
+
+### Fixed
+- **Critical: Taichi SNode exhaustion causing simulation hang at ~128 structures**
+  - Added `_field_cache` to `TaichiEngine` class
+  - Reuses Taichi fields across calls with same `(dim, num_nodes, num_edges)`
+  - Before: Each `dynamics()` call allocated 14 Taichi fields → SNode limit (~1024) hit at ~128 calls → process hangs indefinitely
+  - After: Fields cached and reused → tested 150+ structures without hang
+  - Memory usage reduced significantly (no field accumulation)
+
+### Technical Details
+- File: `fibernet/sim/accelerated.py`
+- Change: Added class-level `_field_cache` dict keyed by `(dim, num_nodes, num_edges)`
+- Impact: Fixes critical hang bug, improves memory efficiency
+- Test: Successfully ran 150 structures sequentially (previously hung at #128)
+
 ## [4.0.2] - 2026-07-16
 
 ### Performance

{fibernet-4.0.2 → fibernet-4.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fibernet
-Version: 4.0.2
+Version: 4.0.4
 Summary: A comprehensive fiber network generation, simulation, and ML toolkit for materials science research
 Author: FiberNet Contributors
 License-Expression: MIT
@@ -86,7 +86,7 @@ Dynamic: license-file
 
 ---
 
-[![PyPI version](https://img.shields.io/pypi/v/fibernet.svg?logo=pypi&logoColor=white&label=PyPI)](https://pypi.org/project/fibernet/4.0.2/)
+[![PyPI version](https://img.shields.io/pypi/v/fibernet.svg?logo=pypi&logoColor=white&label=PyPI)](https://pypi.org/project/fibernet/4.0.3/)
 [![Python](https://img.shields.io/badge/Python-3.9%2B-blue?logo=python&logoColor=white)](https://www.python.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
 [![Downloads](https://img.shields.io/pypi/dm/fibernet.svg?label=Downloads&color=brightgreen)](https://pypi.org/project/fibernet/)
@@ -626,4 +626,4 @@ python3 tutorials/v4_tutorial/test_pipeline.py --full
 
 ---
 
-*FiberNet v4.0.0 | [PyPI](https://pypi.org/project/fibernet/4.0.2/) | [GitHub](https://github.com/GellmanSparrowS/fibernet)*
+*FiberNet v4.0.0 | [PyPI](https://pypi.org/project/fibernet/4.0.3/) | [GitHub](https://github.com/GellmanSparrowS/fibernet)*

{fibernet-4.0.2 → fibernet-4.0.4}/README.md

@@ -7,7 +7,7 @@
 
 ---
 
-[![PyPI version](https://img.shields.io/pypi/v/fibernet.svg?logo=pypi&logoColor=white&label=PyPI)](https://pypi.org/project/fibernet/4.0.2/)
+[![PyPI version](https://img.shields.io/pypi/v/fibernet.svg?logo=pypi&logoColor=white&label=PyPI)](https://pypi.org/project/fibernet/4.0.3/)
 [![Python](https://img.shields.io/badge/Python-3.9%2B-blue?logo=python&logoColor=white)](https://www.python.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
 [![Downloads](https://img.shields.io/pypi/dm/fibernet.svg?label=Downloads&color=brightgreen)](https://pypi.org/project/fibernet/)
@@ -547,4 +547,4 @@ python3 tutorials/v4_tutorial/test_pipeline.py --full
 
 ---
 
-*FiberNet v4.0.0 | [PyPI](https://pypi.org/project/fibernet/4.0.2/) | [GitHub](https://github.com/GellmanSparrowS/fibernet)*
+*FiberNet v4.0.0 | [PyPI](https://pypi.org/project/fibernet/4.0.3/) | [GitHub](https://github.com/GellmanSparrowS/fibernet)*

{fibernet-4.0.2 → fibernet-4.0.4}/fibernet/__init__.py

@@ -33,7 +33,7 @@ Parametric Structure Generation (for RL)
 >>> internal = g.get_internal_nodes()  # Nodes available for RL actions
 """
 
-__version__ = "4.0.2"
+__version__ = "4.0.4"
 
 # --- Core ---
 from fibernet.core.structure_graph import StructureGraph, SNode, SEdge

{fibernet-4.0.2 → fibernet-4.0.4}/fibernet/sim/accelerated.py

@@ -266,6 +266,10 @@ class TaichiEngine:
     Explicit Verlet integration with damping.
     """
 
+    # Cache Taichi fields and kernels to avoid SNode exhaustion
+    # Key: (dim, num_nodes, num_edges)
+    _field_cache = {}
+
     def __init__(self, arch: str = "cpu", num_threads: int = 4):
         _ensure_taichi(arch, num_threads)
 
@@ -395,16 +399,94 @@ class TaichiEngine:
         else:
             stiff_np = np.full(num_edges, stiffness)
 
-        # Taichi fields (allocated once)
-        ti_pos = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
-        ti_vel = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
-        ti_edges = ti.Vector.field(2, dtype=ti.i32, shape=num_edges)
-        ti_L0 = ti.field(dtype=ti.f64, shape=num_edges)
-        ti_k = ti.field(dtype=ti.f64, shape=num_edges)
-        ti_fixed = ti.field(dtype=ti.i32, shape=num_nodes)
-        ti_ext = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
-        ti_pos0 = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
+        # Taichi fields and kernel (cached to avoid SNode exhaustion and kernel recompilation)
+        cache_key = (dim, num_nodes, num_edges)
+        if cache_key not in TaichiEngine._field_cache:
+            # Allocate fields once
+            ti_pos = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
+            ti_vel = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
+            ti_edges = ti.Vector.field(2, dtype=ti.i32, shape=num_edges)
+            ti_L0 = ti.field(dtype=ti.f64, shape=num_edges)
+            ti_k = ti.field(dtype=ti.f64, shape=num_edges)
+            ti_fixed = ti.field(dtype=ti.i32, shape=num_nodes)
+            ti_ext = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
+            ti_pos0 = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
+            ti_sched = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
+            ti_sched_mask = ti.field(dtype=ti.i32, shape=num_nodes)
+            ti_dt = ti.field(dtype=ti.f64, shape=())
+            ti_dashpot = ti.field(dtype=ti.f64, shape=())
+            ti_drag = ti.field(dtype=ti.f64, shape=())
+            ti_ramp = ti.field(dtype=ti.f64, shape=())
+
+            # Compile kernel once (closure captures fields + constants)
+            @ti.kernel
+            def _cached_substep():
+                _dt = ti_dt[None]
+                _dash = ti_dashpot[None]
+                _drag = ti_drag[None]
+                _ramp = ti_ramp[None]
+
+                for e in range(num_edges):
+                    ia = ti_edges[e][0]
+                    ib = ti_edges[e][1]
+                    d = ti_pos[ia] - ti_pos[ib]
+                    dist = d.norm() + 1e-6
+                    dir_ = d / dist
+                    f_spring = -ti_k[e] * dir_ * (dist / ti_L0[e] - 1.0)
+                    rel_v = ti_vel[ia] - ti_vel[ib]
+                    f_damp = -_dash * rel_v.dot(dir_) * dir_ * ti_L0[e]
+                    f_total = f_spring + f_damp
+                    for k in ti.static(range(dim)):
+                        ti.atomic_add(ti_vel[ia][k], f_total[k] * _dt)
+                        ti.atomic_add(ti_vel[ib][k], -f_total[k] * _dt)
 
+                for i in range(num_nodes):
+                    for k in ti.static(range(dim)):
+                        ti_vel[i][k] += ti_ext[i][k] * _dt
+                    ti_vel[i] *= ti.exp(-_drag * _dt)
+                    for k in ti.static(range(dim)):
+                        ti_pos[i][k] += ti_vel[i][k] * _dt
+
+                for i in range(num_nodes):
+                    if ti_fixed[i] == 1:
+                        for k in ti.static(range(dim)):
+                            ti_pos[i][k] = ti_pos0[i][k]
+                            ti_vel[i][k] = 0.0
+
+                for i in range(num_nodes):
+                    if ti_sched_mask[i] == 1:
+                        for k in ti.static(range(dim)):
+                            ti_pos[i][k] = ti_pos0[i][k] + ti_sched[i][k] * _ramp
+                            ti_vel[i][k] = 0.0
+
+            TaichiEngine._field_cache[cache_key] = {
+                'ti_pos': ti_pos, 'ti_vel': ti_vel, 'ti_edges': ti_edges,
+                'ti_L0': ti_L0, 'ti_k': ti_k, 'ti_fixed': ti_fixed,
+                'ti_ext': ti_ext, 'ti_pos0': ti_pos0, 'ti_sched': ti_sched,
+                'ti_sched_mask': ti_sched_mask, 'ti_dt': ti_dt,
+                'ti_dashpot': ti_dashpot, 'ti_drag': ti_drag, 'ti_ramp': ti_ramp,
+                'substep': _cached_substep,
+            }
+
+        # Retrieve cached fields and kernel
+        cached = TaichiEngine._field_cache[cache_key]
+        ti_pos = cached['ti_pos']
+        ti_vel = cached['ti_vel']
+        ti_edges = cached['ti_edges']
+        ti_L0 = cached['ti_L0']
+        ti_k = cached['ti_k']
+        ti_fixed = cached['ti_fixed']
+        ti_ext = cached['ti_ext']
+        ti_pos0 = cached['ti_pos0']
+        ti_sched = cached['ti_sched']
+        ti_sched_mask = cached['ti_sched_mask']
+        ti_dt = cached['ti_dt']
+        ti_dashpot = cached['ti_dashpot']
+        ti_drag = cached['ti_drag']
+        ti_ramp = cached['ti_ramp']
+        substep = cached['substep']
+
+        # Reset field data (always, even on cache hit)
         ti_pos0.from_numpy(pos_orig.astype(np.float64))
         ti_pos.from_numpy(pos_orig.astype(np.float64))
         ti_vel.from_numpy(np.zeros_like(pos_orig))
@@ -430,73 +512,9 @@ class TaichiEngine:
         sched_mask = np.zeros(num_nodes, dtype=np.int32)
         for ni in schedule_nodes:
             sched_mask[ni] = 1
-        ti_sched = ti.Vector.field(dim, dtype=ti.f64, shape=num_nodes)
         ti_sched.from_numpy(schedule_targets.astype(np.float64))
-        ti_sched_mask = ti.field(dtype=ti.i32, shape=num_nodes)
         ti_sched_mask.from_numpy(sched_mask)
 
-        # Parameter fields
-        ti_dt = ti.field(dtype=ti.f64, shape=())
-        ti_dashpot = ti.field(dtype=ti.f64, shape=())
-        ti_drag = ti.field(dtype=ti.f64, shape=())
-        ti_ramp = ti.field(dtype=ti.f64, shape=())
-
-        @ti.kernel
-        def substep():
-            _dt = ti_dt[None]
-            _dash = ti_dashpot[None]
-            _drag = ti_drag[None]
-            _ramp = ti_ramp[None]
-
-            # Spring + dashpot forces
-            for e in range(num_edges):
-                ia = ti_edges[e][0]
-                ib = ti_edges[e][1]
-                d = ti_pos[ia] - ti_pos[ib]
-                dist = d.norm() + 1e-6
-                dir_ = d / dist
-
-                # Spring force: F = -k * dir * (dist/rest - 1)
-                f_spring = -ti_k[e] * dir_ * (dist / ti_L0[e] - 1.0)
-
-                # Dashpot: F_damp = -damp * (vi-vj).dot(dir) * dir * rest
-                rel_v = ti_vel[ia] - ti_vel[ib]
-                f_damp = -_dash * rel_v.dot(dir_) * dir_ * ti_L0[e]
-
-                f_total = f_spring + f_damp
-
-                for k in ti.static(range(dim)):
-                    ti.atomic_add(ti_vel[ia][k], f_total[k] * _dt)
-                    ti.atomic_add(ti_vel[ib][k], -f_total[k] * _dt)
-
-            # Euler step + air drag + external force
-            for i in range(num_nodes):
-                # External force
-                for k in ti.static(range(dim)):
-                    ti_vel[i][k] += ti_ext[i][k] * _dt
-
-                # Air drag
-                ti_vel[i] *= ti.exp(-_drag * _dt)
-
-                # Position update
-                for k in ti.static(range(dim)):
-                    ti_pos[i][k] += ti_vel[i][k] * _dt
-
-            # Constraints: fixed nodes
-            for i in range(num_nodes):
-                if ti_fixed[i] == 1:
-                    for k in ti.static(range(dim)):
-                        ti_pos[i][k] = ti_pos0[i][k]
-                        ti_vel[i][k] = 0.0
-
-            # Constraints: schedule nodes (ramped displacement)
-            for i in range(num_nodes):
-                if ti_sched_mask[i] == 1:
-                    for k in ti.static(range(dim)):
-                        ti_pos[i][k] = ti_pos0[i][k] + ti_sched[i][k] * _ramp
-                        ti_vel[i][k] = 0.0
-
-
         # Run loop
         ti_dt[None] = dt
         ti_dashpot[None] = dashpot

{fibernet-4.0.2 → fibernet-4.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fibernet"
-version = "4.0.2"
+version = "4.0.4"
 description = "A comprehensive fiber network generation, simulation, and ML toolkit for materials science research"
 readme = "README.md"
 license = "MIT"