Frank14f/CelerisLab
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Blocked fine storage: passive stationary circles via receiver-local BFL

Browse Source 
FixedPatchStepper(fine_block=..., fine_objects=[circle]) now accepts
passive stationary circles; any surface actuation is rejected before CUDA
(dense fine path unchanged). prepare_fine_boundary still decides legality
on the dense fine grid; its SoA is mapped by the new array-based storage
adapter blocks.blocked_link_tables (map_cut_links: unique receiver owner
and local writer, row order kept; blocked flags sized nblocks*L), which
PeriodicBlockStepper._static_circles now also uses (single-level legality
builder unchanged). Per fine hop on the same buffer: halo -> existing
BlockCurvedBoundary -> BlockStep(flags, kind). No CUDA changes.
Tests: fixture 76 links / 68 q<.5 and 8 seam writes + 8 seam donors per
decomposed layout (both modes); adapter flags sizing; mocked launch-order
contract; GPU: periodic and slot_reservoir, 8 coarse steps, dense fine
body vs 1x1/2x2/4x2 fine blocks, exact values + NaN masks on masked
downloads and raw final arrays, ACTIVE fluid finite, solid/OUTER NaN.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Claude
2026-10-15 04:25:09 +00:00
co-authored by Claude Opus 5.5
parent 59921a0181
commit 2bbf82121e
4 changed files with 181 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/validation/multigrid/test_refinement_blocked_fine.py
+113 -5
View File
@@ -13,12 +13,14 @@ import numpy as np
import pycuda.driver as cuda
from CelerisLab.body.geometry.circle import CircleGeometry
from CelerisLab.body.objects import SimObject
from CelerisLab.body.objects import SimObject, SurfaceActuation
from CelerisLab.config import LBMConfig
from CelerisLab.cuda import compiler_v2 as compiler
from CelerisLab.lbm.blocks import BlockLayout2D
from CelerisLab.lbm.blocks import NO_DONOR, BlockLayout2D, blocked_link_tables
from CelerisLab.lbm.descriptors import D2Q9_EX, D2Q9_EY
from CelerisLab.lbm.refinement import ACTIVE, INNER_GHOST, OUTER_GHOST, FixedPatch2D
from CelerisLab.lbm.descriptors import SOLID
from CelerisLab.lbm.refinement import (ACTIVE, INNER_GHOST, OUTER_GHOST, FixedPatch2D,
prepare_fine_boundary)
from CelerisLab.lbm.refinement_stepper import FixedPatchStepper, blocked_fine_tables
NX, NY, BOUNDS, STEPS = 32, 24, (8, 6, 24, 18), 8
@@ -45,6 +47,27 @@ def state(ny, nx, seed):
return (feq + noise).astype(np.float32)
def circle(actuation=None):
"""Astra fixture: coarse cell-edge C=(16,12), R=2.15 -> fine C=(19.5,15.5), R=4.3."""
return SimObject(0, geometry=CircleGeometry(16.0, 12.0, 2.15), center=(16.0, 12.0),
radius=2.15, surface_actuation=actuation)
def fine_circle(mode):
cfg = config(mode)
patch = FixedPatch2D.from_config(cfg, BOUNDS)
return patch, prepare_fine_boundary(cfg, patch, (circle(),), wall_aware=mode == "slot_reservoir")
def seam_cells(layout, mapped):
"""Distinct non-core cells written / read as q<.5 donors (receiver-local halos)."""
L = int(np.prod(layout.local_shape))
core = set(layout.owner.ravel().tolist())
writes = {int(w) // (9 * L) * L + int(w) % L for w in mapped.write}
donors = {int(d) for d in mapped.donor if d != NO_DONOR}
return len(writes - core), len(donors - core)
def raw(backend):
"""Unmasked device arrays; blocked fine storage unpacked from owner cores."""
coarse, fine = backend._levels
@@ -63,9 +86,9 @@ class BlockedFineCPU(unittest.TestCase):
return Mock(activate=Mock(side_effect=AssertionError("CUDA reached")), sm_arch="sm_70")
def test_rejections_before_cuda(self):
circle = SimObject(0, geometry=CircleGeometry(16.0, 12.0, 2.0), center=(16.0, 12.0), radius=2.0)
actuated = circle(SurfaceActuation(0.0, 0.5, 0.002))
for kw in ({"fine_block": (7, 7)}, {"fine_block": (16,)},
{"fine_block": (16, 20), "fine_objects": [circle]}):
{"fine_block": (16, 20), "fine_objects": [actuated]}):
with self.subTest(kw=kw), self.assertRaises(ValueError):
FixedPatchStepper(config("periodic"), BOUNDS, context=self.forbidden_context(), **kw)
@@ -94,6 +117,64 @@ class BlockedFineCPU(unittest.TestCase):
backend.close()
self.assertTrue(sizes)
def test_circle_fixture_counts_and_seam_staging(self):
for mode in ("periodic", "slot_reservoir"):
patch, boundary = fine_circle(mode)
fluid_idx, dirs, q, _, _, _, _, fallback = boundary.curved_host
self.assertEqual(len(fluid_idx), 76, mode)
self.assertEqual(int(np.count_nonzero(q < .5)), 68, mode)
for by, bx in FINE_BLOCKS[1:]:
layout = BlockLayout2D.build(*patch.fine_shape, by, bx, periodic=(False, False))
_, mapped = blocked_link_tables(layout, boundary.flags, fluid_idx, dirs, q, fallback)
self.assertEqual(seam_cells(layout, mapped), (8, 8), (mode, by, bx))
def test_storage_adapter_flags_sizing(self):
patch, boundary = fine_circle("periodic")
columns = [boundary.curved_host[i] for i in (0, 1, 2, 7)]
layout = BlockLayout2D.build(*patch.fine_shape, 16, 20, periodic=(False, False))
tables, mapped = blocked_link_tables(layout, boundary.flags, *columns)
L = int(np.prod(layout.local_shape))
self.assertEqual(tables["flags"].shape, (layout.nblocks * L,))
np.testing.assert_array_equal(tables["flags"][layout.owner.ravel().astype(np.intp)],
boundary.flags)
np.testing.assert_array_equal(tables["cell"], mapped.receiver % np.uint64(L))
for bad in (boundary.flags[:-1], boundary.flags.astype(np.uint32)):
with self.assertRaises(ValueError):
blocked_link_tables(layout, bad, *columns)
def test_same_buffer_halo_bfl_step_launch_order(self):
context = Mock(activate=nullcontext, sm_arch="sm_70")
calls, functions = [], {}
def get_function(name):
return functions.setdefault(name, Mock(side_effect=lambda *a, **k: calls.append((name, a))))
module = Mock(get_function=Mock(side_effect=get_function))
module.get_global.return_value = (Mock(), 20)
with patch.object(cuda, "Stream"), patch.object(compiler, "generate_config"), \
patch.object(compiler, "compile_kernel"), patch.object(compiler, "cleanup_build_dir"), \
patch.object(compiler, "load_module", return_value=module), \
patch.object(cuda, "mem_alloc", side_effect=lambda size: Mock()), \
patch.object(cuda, "memcpy_htod"):
backend = FixedPatchStepper(config("periodic"), BOUNDS, context=context,
fine_objects=[circle()], fine_block=FINE_BLOCKS[1])
g_fine = state(*backend.patch.fine_shape, 2)
backend.initialize(state(NY, NX, 1), g_fine)
c, f = backend._levels
coarse, cur, spare = c.current, f.current, f.spare
flags, kind = backend._fine_flags, backend._kind
backend.step(1)
backend.close()
order = [(name, a[0]) for name, a in calls]
self.assertEqual(order, [("BlockExplode", coarse),
("BlockHaloCopy", cur), ("BlockCurvedBoundary", cur), ("BlockStep", cur),
("BlockHaloCopy", spare), ("BlockCurvedBoundary", spare),
("BlockStep", spare), ("PatchCoarseStep", coarse)])
steps = [a for name, a in calls if name == "BlockStep"]
self.assertEqual([a[1] for a in steps], [spare, cur])
for a in steps:
self.assertIs(a[3], flags) # blocked flags, not null
self.assertIs(a[4], kind)
def test_tables_map_back_to_dense_slots_in_order(self):
patch = FixedPatch2D.from_config(config("periodic"), BOUNDS)
fy, fx = patch.fine_shape
@@ -151,6 +232,33 @@ class BlockedFineGPU(unittest.TestCase):
print(f"{mode}: dense vs {len(blocked)} fine-block layouts bit-identical "
f"after {STEPS} coarse steps", flush=True)
def test_passive_circle_dense_and_blocked_fine_storage_are_bit_identical(self):
from CelerisLab.cuda.context import CudaContext
for mode in ("periodic", "slot_reservoir"):
cfg = config(mode)
patch, boundary = fine_circle(mode)
solid = (boundary.flags.reshape(patch.fine_shape) & SOLID) != 0
g_coarse, g_fine = state(NY, NX, 1), state(*patch.fine_shape, 2)
results = []
with CudaContext(0) as context:
for fine_block in (None, *FINE_BLOCKS):
with FixedPatchStepper(cfg, BOUNDS, context=context, coarse_boundary=mode,
fine_objects=[circle()], fine_block=fine_block) as backend:
backend.initialize(g_coarse, g_fine)
backend.step(STEPS)
results.append((backend.download(), raw(backend)))
(dense_public, dense_raw), blocked = results[0], results[1:]
fine = dense_raw[1]
self.assertTrue(np.isfinite(fine[:, (patch.fine_kind == ACTIVE) & ~solid]).all(), mode)
self.assertTrue(np.isnan(fine[:, solid]).all(), mode)
self.assertTrue(np.isnan(fine[:, patch.fine_kind == OUTER_GHOST]).all(), mode)
for fine_block, (public, raw_arrays) in zip(FINE_BLOCKS, blocked):
msg = f"circle {mode} fine_block={fine_block}"
for a, b in zip(public + tuple(raw_arrays), dense_public + tuple(dense_raw)):
np.testing.assert_array_equal(a, b, err_msg=msg) # values and NaN masks
print(f"circle {mode}: dense vs {len(blocked)} fine-block layouts bit-identical "
f"after {STEPS} coarse steps", flush=True)
if __name__ == "__main__":
unittest.main()