From 87b030dbb33cd5c62b4e25a1661ee0887dcb71b5 Mon Sep 17 00:00:00 2001 From: Francesc Alted Date: Fri, 6 Feb 2026 08:41:19 +0100 Subject: [PATCH 1/6] First preliminary version of DSL support for lazy expressions --- CMakeLists.txt | 5 +- bench/ndarray/dsl-kernel-bench.py | 240 +++++++++++ src/blosc2/__init__.py | 3 + src/blosc2/dsl_kernel.py | 645 ++++++++++++++++++++++++++++++ src/blosc2/lazyexpr.py | 33 +- tests/ndarray/test_dsl_kernels.py | 175 ++++++++ 6 files changed, 1091 insertions(+), 10 deletions(-) create mode 100644 bench/ndarray/dsl-kernel-bench.py create mode 100644 src/blosc2/dsl_kernel.py create mode 100644 tests/ndarray/test_dsl_kernels.py diff --git a/CMakeLists.txt b/CMakeLists.txt index 769eb14b..66e217bc 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -57,8 +57,9 @@ set(MINIEXPR_BUILD_EXAMPLES OFF CACHE BOOL "Build miniexpr examples" FORCE) set(MINIEXPR_BUILD_BENCH OFF CACHE BOOL "Build miniexpr benchmarks" FORCE) FetchContent_Declare(miniexpr - GIT_REPOSITORY https://github.com/Blosc/miniexpr.git - GIT_TAG 77d633cb2c134552da045b8d2cc0ad23908e6b9e + #GIT_REPOSITORY https://github.com/Blosc/miniexpr.git + #GIT_TAG 77d633cb2c134552da045b8d2cc0ad23908e6b9e + SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../miniexpr ) FetchContent_MakeAvailable(miniexpr) diff --git a/bench/ndarray/dsl-kernel-bench.py b/bench/ndarray/dsl-kernel-bench.py new file mode 100644 index 00000000..35e6b36c --- /dev/null +++ b/bench/ndarray/dsl-kernel-bench.py @@ -0,0 +1,240 @@ +####################################################################### +# Copyright (c) 2019-present, Blosc Development Team +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +####################################################################### + +import contextlib +import time + +import numpy as np + +import blosc2 +import importlib + +lazyexpr_mod = importlib.import_module("blosc2.lazyexpr") + + +@blosc2.dsl_kernel +def kernel_loop1(x, y): + acc = 0.0 + for i in range(1): + if i % 2 == 0: + tmp = np.where(x < y, y + i, x - i) + else: + tmp = np.where(x > y, x + i, y - i) + acc = acc + tmp * (i + 1) + return acc + + +@blosc2.dsl_kernel +def kernel_loop2(x, y): + acc = 0.0 + for i in range(2): + if i % 2 == 0: + tmp = np.where(x < y, y + i, x - i) + else: + tmp = np.where(x > y, x + i, y - i) + acc = acc + tmp * (i + 1) + return acc + + +@blosc2.dsl_kernel +def kernel_loop4(x, y): + acc = 0.0 + for i in range(4): + if i % 2 == 0: + tmp = np.where(x < y, y + i, x - i) + else: + tmp = np.where(x > y, x + i, y - i) + acc = acc + tmp * (i + 1) + return acc + + +@blosc2.dsl_kernel +def kernel_loop4_heavy(x, y): + acc = 0.0 + for i in range(4): + if i % 2 == 0: + tmp = np.where(x < y, y + i, x - i) + else: + tmp = np.where(x > y, x + i, y - i) + acc = acc + tmp * (i + 1) + (tmp * tmp) * 0.05 + return acc + + +@blosc2.dsl_kernel +def kernel_nested2(x, y): + acc = 0.0 + for i in range(2): + for j in range(2): + if (i + j) % 2 == 0: + tmp = np.where(x < y, y + i + j, x - i - j) + else: + tmp = np.where(x > y, x + i + j, y - i - j) + acc = acc + tmp * (i + j + 1) + return acc + + +def expr_for_steps(steps: int) -> str: + terms = [] + for i in range(steps): + if i % 2 == 0: + terms.append(f"where(x < y, y + {i}, x - {i}) * {i + 1}") + else: + terms.append(f"where(x > y, x + {i}, y - {i}) * {i + 1}") + return " + ".join(terms) + + +def expr_for_steps_heavy(steps: int) -> str: + terms = [] + for i in range(steps): + if i % 2 == 0: + term = f"where(x < y, y + {i}, x - {i})" + else: + term = f"where(x > y, x + {i}, y - {i})" + terms.append(f"{term} * {i + 1} + ({term} * {term}) * 0.05") + return " + ".join(terms) + + +def expr_nested2() -> str: + terms = [] + for i in range(2): + for j in range(2): + if (i + j) % 2 == 0: + term = f"where(x < y, y + {i + j}, x - {i + j})" + else: + term = f"where(x > y, x + {i + j}, y - {i + j})" + terms.append(f"{term} * {i + j + 1}") + return " + ".join(terms) + + +@contextlib.contextmanager +def miniexpr_enabled(enabled: bool): + old = lazyexpr_mod.try_miniexpr + lazyexpr_mod.try_miniexpr = enabled + try: + yield + finally: + lazyexpr_mod.try_miniexpr = old + + +def time_it(fn, niter=3): + best = None + for _ in range(niter): + t0 = time.perf_counter() + out = fn() + dt = time.perf_counter() - t0 + best = dt if best is None else min(best, dt) + return best, out + + +def bench_case(name, kernel, expr, a, b, dtype, gb): + if kernel.dsl_source is None: + raise RuntimeError(f"DSL extraction failed for {name}") + + with miniexpr_enabled(False): + lazy_expr_base = blosc2.lazyexpr(expr, {"x": a, "y": b}) + res_base = lazy_expr_base.compute() + base_time, _ = time_it(lambda: lazy_expr_base.compute()) + + with miniexpr_enabled(True): + lazy_expr_fast = blosc2.lazyexpr(expr, {"x": a, "y": b}) + _ = lazy_expr_fast.compute() + expr_time, _ = time_it(lambda: lazy_expr_fast.compute()) + + lazy_dsl = blosc2.lazyudf(kernel, (a, b), dtype=dtype) + res_dsl = lazy_dsl.compute() + dsl_time, _ = time_it(lambda: lazy_dsl.compute()) + + np.testing.assert_allclose(res_dsl[...], res_base[...], rtol=1e-5, atol=1e-6) + + return { + "case": name, + "baseline": base_time, + "lazyexpr": expr_time, + "dsl": dsl_time, + "baseline_gbps": gb / base_time, + "lazyexpr_gbps": gb / expr_time, + "dsl_gbps": gb / dsl_time, + } + + +def table_formatter(): + headers = [ + "Case", + "Base ms", + "Base GB/s", + "Expr ms", + "Expr GB/s", + "DSL ms", + "DSL GB/s", + "Expr/Base", + "DSL/Base", + ] + widths = [ + 12, + len(headers[1]), + len(headers[2]), + len(headers[3]), + len(headers[4]), + len(headers[5]), + len(headers[6]), + len(headers[7]), + len(headers[8]), + ] + align_right = {1, 2, 3, 4, 5, 6, 7, 8} + fmt_parts = [] + for i, w in enumerate(widths): + align = ">" if i in align_right else "<" + fmt_parts.append(f"{{:{align}{w}}}") + fmt = "|".join(fmt_parts) + sep = "+".join("-" * w for w in widths) + return headers, fmt, sep + + +def format_row(row): + base = row["baseline"] * 1000 + expr = row["lazyexpr"] * 1000 + dsl = row["dsl"] * 1000 + return [ + row["case"], + f"{base:.2f}", + f"{row['baseline_gbps']:.2f}", + f"{expr:.2f}", + f"{row['lazyexpr_gbps']:.2f}", + f"{dsl:.2f}", + f"{row['dsl_gbps']:.2f}", + f"{row['baseline'] / row['lazyexpr']:.2f}x", + f"{row['baseline'] / row['dsl']:.2f}x", + ] + + +def main(): + n = 10_000 + dtype = np.float32 + cparams = blosc2.CParams(codec=blosc2.Codec.BLOSCLZ, clevel=1) + + a = blosc2.linspace(0, 1, n * n, shape=(n, n), dtype=dtype, cparams=cparams) + b = blosc2.linspace(1, 0, n * n, shape=(n, n), dtype=dtype, cparams=cparams) + gb = a.nbytes * 3 / 1e9 + + cases = [ + ("loop1", kernel_loop1, expr_for_steps(1)), + ("loop2", kernel_loop2, expr_for_steps(2)), + ("loop4", kernel_loop4, expr_for_steps(4)), + ("loop4_heavy", kernel_loop4_heavy, expr_for_steps_heavy(4)), + ("nested2", kernel_nested2, expr_nested2()), + ] + + headers, fmt, sep = table_formatter() + print(fmt.format(*headers), flush=True) + print(sep, flush=True) + for name, kernel, expr in cases: + row = bench_case(name, kernel, expr, a, b, dtype, gb) + print(fmt.format(*format_row(row)), flush=True) + + +if __name__ == "__main__": + main() diff --git a/src/blosc2/__init__.py b/src/blosc2/__init__.py index c9c3ab36..896cd553 100644 --- a/src/blosc2/__init__.py +++ b/src/blosc2/__init__.py @@ -465,6 +465,7 @@ def _raise(exc): from .c2array import c2context, C2Array, URLPath +from .dsl_kernel import DSLKernel, dsl_kernel from .lazyexpr import ( LazyExpr, lazyudf, @@ -645,6 +646,7 @@ def _raise(exc): "EmbedStore", "Filter", "LazyArray", + "DSLKernel", "LazyExpr", "LazyUDF", "NDArray", @@ -760,6 +762,7 @@ def _raise(exc): "isnan", "jit", "lazyexpr", + "dsl_kernel", "lazyudf", "lazywhere", "less", diff --git a/src/blosc2/dsl_kernel.py b/src/blosc2/dsl_kernel.py new file mode 100644 index 00000000..b7a42c85 --- /dev/null +++ b/src/blosc2/dsl_kernel.py @@ -0,0 +1,645 @@ +####################################################################### +# Copyright (c) 2019-present, Blosc Development Team +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +####################################################################### + +from __future__ import annotations + +import ast +import inspect +import os +import textwrap +from typing import ClassVar + +_PRINT_DSL_KERNEL = os.environ.get("PRINT_DSL_KERNEL", "").strip().lower() +_PRINT_DSL_KERNEL = _PRINT_DSL_KERNEL not in ("", "0", "false", "no", "off") + + +class DSLKernel: + """Wrap a Python function and optionally extract a miniexpr DSL kernel from it.""" + + def __init__(self, func): + self.func = func + self.__name__ = getattr(func, "__name__", self.__class__.__name__) + self.__qualname__ = getattr(func, "__qualname__", self.__name__) + self.__doc__ = getattr(func, "__doc__", None) + try: + sig = inspect.signature(func) + except (TypeError, ValueError): + sig = None + self._sig = sig + self._sig_has_varargs = False + self._sig_npositional = None + if sig is not None: + params = list(sig.parameters.values()) + self._sig_has_varargs = any(p.kind == p.VAR_POSITIONAL for p in params) + self._sig_npositional = sum( + 1 for p in params if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD) + ) + self.dsl_source = None + self.input_names = None + try: + dsl_source, input_names = self._extract_dsl(func) + except Exception: + dsl_source = None + input_names = None + self.dsl_source = dsl_source + self.input_names = input_names + + def _extract_dsl(self, func): + source = inspect.getsource(func) + source = textwrap.dedent(source) + tree = ast.parse(source) + func_node = None + for node in tree.body: + if isinstance(node, ast.FunctionDef) and node.name == func.__name__: + func_node = node + break + if func_node is None: + for node in tree.body: + if isinstance(node, ast.FunctionDef): + func_node = node + break + if func_node is None: + raise ValueError("No function definition found for DSL extraction") + + dsl_source_full = None + if _PRINT_DSL_KERNEL: + try: + dsl_source_full = _DSLBuilder().build(func_node) + func_name = getattr(func, "__name__", "") + print(f"[DSLKernel:{func_name}] dsl_source (full):") + print(dsl_source_full[0]) + except Exception as exc: + func_name = getattr(func, "__name__", "") + print(f"[DSLKernel:{func_name}] dsl_source (full) failed: {exc}") + + reducer = _DSLReducer() + reduced = reducer.reduce(func_node) + if reduced is not None: + if _PRINT_DSL_KERNEL: + func_name = getattr(func, "__name__", "") + print(f"[DSLKernel:{func_name}] reduced_expr:") + print(reduced[0]) + return reduced + + if dsl_source_full is not None: + return dsl_source_full + + builder = _DSLBuilder() + return builder.build(func_node) + + def __call__(self, inputs_tuple, output, offset=None): + if self._sig is not None and not self._sig_has_varargs and self._sig_npositional == 3: + return self.func(inputs_tuple, output, offset) + + n_inputs = len(inputs_tuple) + if self._sig is not None and ( + self._sig_npositional in (n_inputs, n_inputs + 1) or self._sig_has_varargs + ): + if self._sig_npositional == n_inputs + 1: + result = self.func(*inputs_tuple, offset) + else: + result = self.func(*inputs_tuple) + output[...] = result + return None + + try: + return self.func(inputs_tuple, output, offset) + except TypeError: + result = self.func(*inputs_tuple) + output[...] = result + return None + + +def dsl_kernel(func): + """Decorator to wrap a function in a DSLKernel.""" + + return DSLKernel(func) + + +class _DSLBuilder: + _binop_map: ClassVar[dict[type[ast.operator], str]] = { + ast.Add: "+", + ast.Sub: "-", + ast.Mult: "*", + ast.Div: "/", + ast.FloorDiv: "//", + ast.Mod: "%", + ast.Pow: "**", + ast.BitAnd: "&", + ast.BitOr: "|", + ast.BitXor: "^", + ast.LShift: "<<", + ast.RShift: ">>", + } + + _cmp_map: ClassVar[dict[type[ast.cmpop], str]] = { + ast.Eq: "==", + ast.NotEq: "!=", + ast.Lt: "<", + ast.LtE: "<=", + ast.Gt: ">", + ast.GtE: ">=", + } + + def __init__(self): + self._lines = [] + + def build(self, func_node: ast.FunctionDef): + input_names = self._args(func_node.args) + self._emit(f"def {func_node.name}({', '.join(input_names)}):", 0) + if not func_node.body: + raise ValueError("DSL kernel must have a body") + for stmt in func_node.body: + self._stmt(stmt, 4) + return "\n".join(self._lines), input_names + + def _emit(self, line: str, indent: int): + self._lines.append(" " * indent + line) + + def _args(self, args: ast.arguments): + if args.vararg or args.kwarg or args.kwonlyargs: + raise ValueError("DSL kernel does not support *args/**kwargs/kwonly args") + if args.defaults or args.kw_defaults: + raise ValueError("DSL kernel does not support default arguments") + names = [a.arg for a in (args.posonlyargs + args.args)] + if not names: + raise ValueError("DSL kernel must accept at least one argument") + return names + + def _stmt(self, node: ast.stmt, indent: int): + if isinstance(node, ast.Assign): + if len(node.targets) != 1 or not isinstance(node.targets[0], ast.Name): + raise ValueError("Only simple assignments are supported in DSL kernels") + target = node.targets[0].id + value = self._expr(node.value) + self._emit(f"{target} = {value}", indent) + return + if isinstance(node, ast.AugAssign): + if not isinstance(node.target, ast.Name): + raise ValueError("Only simple augmented assignments are supported") + target = node.target.id + op = self._binop(node.op) + value = self._expr(node.value) + self._emit(f"{target} = {target} {op} {value}", indent) + return + if isinstance(node, ast.Return): + if node.value is None: + raise ValueError("DSL kernel return must have a value") + value = self._expr(node.value) + self._emit(f"return {value}", indent) + return + if isinstance(node, ast.Expr): + value = self._expr(node.value) + self._emit(value, indent) + return + if isinstance(node, ast.If): + self._if_stmt(node, indent) + return + if isinstance(node, ast.For): + self._for_stmt(node, indent) + return + if isinstance(node, ast.Break): + self._emit("break", indent) + return + if isinstance(node, ast.Continue): + self._emit("continue", indent) + return + raise ValueError(f"Unsupported DSL statement: {type(node).__name__}") + + def _stmt_block(self, body, indent: int): + if not body: + raise ValueError("Empty blocks are not supported in DSL kernels") + for stmt in body: + self._stmt(stmt, indent) + + def _if_stmt(self, node: ast.If, indent: int): + current = node + first = True + while True: + prefix = "if" if first else "elif" + cond = self._expr(current.test) + self._emit(f"{prefix} {cond}:", indent) + self._stmt_block(current.body, indent + 4) + first = False + if current.orelse and len(current.orelse) == 1 and isinstance(current.orelse[0], ast.If): + current = current.orelse[0] + continue + break + if current.orelse: + self._emit("else:", indent) + self._stmt_block(current.orelse, indent + 4) + + def _for_stmt(self, node: ast.For, indent: int): + if node.orelse: + raise ValueError("for/else is not supported in DSL kernels") + if not isinstance(node.target, ast.Name): + raise ValueError("DSL for-loop target must be a simple name") + if not isinstance(node.iter, ast.Call): + raise ValueError("DSL for-loop must iterate over range()") + func_name = self._call_name(node.iter.func) + if func_name != "range": + raise ValueError("DSL for-loop must iterate over range()") + if node.iter.keywords or len(node.iter.args) != 1: + raise ValueError("DSL range() must take a single argument") + limit = self._expr(node.iter.args[0]) + self._emit(f"for {node.target.id} in range({limit}):", indent) + self._stmt_block(node.body, indent + 4) + + def _expr(self, node: ast.AST) -> str: # noqa: C901 + if isinstance(node, ast.Name): + return node.id + if isinstance(node, ast.Constant): + val = node.value + if isinstance(val, bool): + return "1" if val else "0" + if isinstance(val, int | float): + return repr(val) + raise ValueError("Unsupported constant in DSL expression") + if isinstance(node, ast.UnaryOp): + if isinstance(node.op, ast.UAdd): + return f"+{self._expr(node.operand)}" + if isinstance(node.op, ast.USub): + return f"-{self._expr(node.operand)}" + if isinstance(node.op, ast.Not): + return f"!{self._expr(node.operand)}" + raise ValueError("Unsupported unary operator in DSL expression") + if isinstance(node, ast.BinOp): + left = self._expr(node.left) + right = self._expr(node.right) + op = self._binop(node.op) + return f"({left} {op} {right})" + if isinstance(node, ast.BoolOp): + op = "&" if isinstance(node.op, ast.And) else "|" + values = [self._expr(v) for v in node.values] + expr = values[0] + for val in values[1:]: + expr = f"({expr} {op} {val})" + return expr + if isinstance(node, ast.Compare): + if len(node.ops) != 1 or len(node.comparators) != 1: + raise ValueError("Chained comparisons are not supported in DSL") + left = self._expr(node.left) + right = self._expr(node.comparators[0]) + op = self._cmpop(node.ops[0]) + return f"({left} {op} {right})" + if isinstance(node, ast.Call): + func_name = self._call_name(node.func) + if node.keywords: + raise ValueError("Keyword arguments are not supported in DSL calls") + args = ", ".join(self._expr(a) for a in node.args) + return f"{func_name}({args})" + if isinstance(node, ast.IfExp): + cond = self._expr(node.test) + body = self._expr(node.body) + orelse = self._expr(node.orelse) + return f"where({cond}, {body}, {orelse})" + raise ValueError(f"Unsupported DSL expression: {type(node).__name__}") + + def _call_name(self, node: ast.AST) -> str: + if isinstance(node, ast.Name): + return node.id + if ( + isinstance(node, ast.Attribute) + and isinstance(node.value, ast.Name) + and node.value.id in {"np", "numpy", "math"} + ): + return node.attr + raise ValueError("Unsupported call target in DSL") + + def _binop(self, op: ast.operator) -> str: + for k, v in self._binop_map.items(): + if isinstance(op, k): + return v + raise ValueError("Unsupported binary operator in DSL") + + def _cmpop(self, op: ast.cmpop) -> str: + for k, v in self._cmp_map.items(): + if isinstance(op, k): + return v + raise ValueError("Unsupported comparison in DSL") + + +class _DSLReducer: + _binop_map: ClassVar[dict[type[ast.operator], str]] = _DSLBuilder._binop_map + _cmp_map: ClassVar[dict[type[ast.cmpop], str]] = _DSLBuilder._cmp_map + + def __init__(self, max_unroll: int = 64): + self._env: dict[str, str] = {} + self._const_env: dict[str, object] = {} + self._return_expr: str | None = None + self._max_unroll = max_unroll + + def reduce(self, func_node: ast.FunctionDef): + input_names = self._args(func_node.args) + if not func_node.body: + return None + for stmt in func_node.body: + if not self._stmt(stmt): + return None + if self._return_expr is not None: + break + if self._return_expr is None: + return None + return self._return_expr, input_names + + def _args(self, args: ast.arguments): + if args.vararg or args.kwarg or args.kwonlyargs: + raise ValueError("DSL kernel does not support *args/**kwargs/kwonly args") + if args.defaults or args.kw_defaults: + raise ValueError("DSL kernel does not support default arguments") + names = [a.arg for a in (args.posonlyargs + args.args)] + if not names: + raise ValueError("DSL kernel must accept at least one argument") + return names + + def _stmt(self, node: ast.stmt) -> bool: # noqa: C901 + if isinstance(node, ast.Assign): + if len(node.targets) != 1 or not isinstance(node.targets[0], ast.Name): + return False + target = node.targets[0].id + value = self._expr(node.value) + self._env[target] = value + const_val = self._const_eval(node.value) + if const_val is None: + self._const_env.pop(target, None) + else: + self._const_env[target] = const_val + return True + if isinstance(node, ast.AugAssign): + if not isinstance(node.target, ast.Name): + return False + target = node.target.id + op = self._binop(node.op) + value = self._expr(node.value) + left = self._env.get(target, target) + left_const = self._const_env.get(target) + right_const = self._const_eval(node.value) + simplified = self._simplify_binop_expr(op, left, value, left_const, right_const) + self._env[target] = simplified + if left_const is None or right_const is None: + self._const_env.pop(target, None) + else: + self._const_env[target] = self._apply_binop(left_const, right_const, node.op) + return True + if isinstance(node, ast.Return): + if node.value is None: + return False + self._return_expr = self._expr(node.value) + return True + if isinstance(node, ast.If): + test_val = self._const_eval(node.test) + if test_val is None: + return False + branch = node.body if bool(test_val) else node.orelse + if not branch: + return True + for stmt in branch: + if not self._stmt(stmt): + return False + if self._return_expr is not None: + return True + return True + if isinstance(node, ast.For): + if node.orelse: + return False + if not isinstance(node.target, ast.Name): + return False + if not isinstance(node.iter, ast.Call): + return False + func_name = self._call_name(node.iter.func) + if func_name != "range": + return False + if node.iter.keywords or len(node.iter.args) != 1: + return False + limit_val = self._const_eval(node.iter.args[0]) + if limit_val is None or not isinstance(limit_val, int): + return False + if limit_val < 0 or limit_val > self._max_unroll: + return False + loop_var = node.target.id + old_env = self._env.get(loop_var) + old_const = self._const_env.get(loop_var) + for i in range(limit_val): + self._env[loop_var] = str(i) + self._const_env[loop_var] = i + for stmt in node.body: + if not self._stmt(stmt): + if old_env is None: + self._env.pop(loop_var, None) + else: + self._env[loop_var] = old_env + if old_const is None: + self._const_env.pop(loop_var, None) + else: + self._const_env[loop_var] = old_const + return False + if self._return_expr is not None: + break + if self._return_expr is not None: + break + if old_env is None: + self._env.pop(loop_var, None) + else: + self._env[loop_var] = old_env + if old_const is None: + self._const_env.pop(loop_var, None) + else: + self._const_env[loop_var] = old_const + return True + return False + + def _expr(self, node: ast.AST) -> str: # noqa: C901 + const_val = self._const_eval(node) + if const_val is not None: + if isinstance(const_val, bool): + return "1" if const_val else "0" + return repr(const_val) + if isinstance(node, ast.Name): + if node.id in self._env: + val = self._env[node.id] + # Avoid double-wrapping if already parenthesized or is a function call + if (val.startswith("(") and val.endswith(")")) or "(" in val: + return val + return f"({val})" + return node.id + if isinstance(node, ast.Constant): + val = node.value + if isinstance(val, bool): + return "1" if val else "0" + if isinstance(val, int | float): + return repr(val) + raise ValueError("Unsupported constant in DSL expression") + if isinstance(node, ast.UnaryOp): + if isinstance(node.op, ast.UAdd): + return f"+{self._expr(node.operand)}" + if isinstance(node.op, ast.USub): + return f"-{self._expr(node.operand)}" + if isinstance(node.op, ast.Not): + return f"!{self._expr(node.operand)}" + raise ValueError("Unsupported unary operator in DSL expression") + if isinstance(node, ast.BinOp): + left = self._expr(node.left) + right = self._expr(node.right) + op = self._binop(node.op) + left_const = self._const_eval(node.left) + right_const = self._const_eval(node.right) + return self._simplify_binop_expr(op, left, right, left_const, right_const) + if isinstance(node, ast.BoolOp): + op = "&" if isinstance(node.op, ast.And) else "|" + values = [self._expr(v) for v in node.values] + expr = values[0] + for val in values[1:]: + expr = f"({expr} {op} {val})" + return expr + if isinstance(node, ast.Compare): + if len(node.ops) != 1 or len(node.comparators) != 1: + raise ValueError("Chained comparisons are not supported in DSL") + left = self._expr(node.left) + right = self._expr(node.comparators[0]) + op = self._cmpop(node.ops[0]) + return f"({left} {op} {right})" + if isinstance(node, ast.Call): + func_name = self._call_name(node.func) + if node.keywords: + raise ValueError("Keyword arguments are not supported in DSL calls") + args = ", ".join(self._expr(a) for a in node.args) + return f"{func_name}({args})" + if isinstance(node, ast.IfExp): + cond = self._expr(node.test) + body = self._expr(node.body) + orelse = self._expr(node.orelse) + return f"where({cond}, {body}, {orelse})" + raise ValueError(f"Unsupported DSL expression: {type(node).__name__}") + + def _call_name(self, node: ast.AST) -> str: + if isinstance(node, ast.Name): + return node.id + if ( + isinstance(node, ast.Attribute) + and isinstance(node.value, ast.Name) + and node.value.id in {"np", "numpy", "math"} + ): + return node.attr + raise ValueError("Unsupported call target in DSL") + + def _binop(self, op: ast.operator) -> str: + for k, v in self._binop_map.items(): + if isinstance(op, k): + return v + raise ValueError("Unsupported binary operator in DSL") + + def _cmpop(self, op: ast.cmpop) -> str: + for k, v in self._cmp_map.items(): + if isinstance(op, k): + return v + raise ValueError("Unsupported comparison in DSL") + + def _const_eval(self, node: ast.AST): # noqa: C901 + if isinstance(node, ast.Constant): + if isinstance(node.value, int | float | bool): + return node.value + return None + if isinstance(node, ast.Name): + return self._const_env.get(node.id) + if isinstance(node, ast.UnaryOp): + val = self._const_eval(node.operand) + if val is None: + return None + if isinstance(node.op, ast.UAdd): + return +val + if isinstance(node.op, ast.USub): + return -val + if isinstance(node.op, ast.Not): + return not val + return None + if isinstance(node, ast.BinOp): + left = self._const_eval(node.left) + right = self._const_eval(node.right) + if left is None or right is None: + return None + return self._apply_binop(left, right, node.op) + if isinstance(node, ast.BoolOp): + vals = [self._const_eval(v) for v in node.values] + if any(v is None for v in vals): + return None + if isinstance(node.op, ast.And): + return all(vals) + if isinstance(node.op, ast.Or): + return any(vals) + return None + if isinstance(node, ast.Compare): + if len(node.ops) != 1 or len(node.comparators) != 1: + return None + left = self._const_eval(node.left) + right = self._const_eval(node.comparators[0]) + if left is None or right is None: + return None + return self._apply_cmp(left, right, node.ops[0]) + return None + + def _apply_binop(self, left, right, op): + if isinstance(op, ast.Add): + return left + right + if isinstance(op, ast.Sub): + return left - right + if isinstance(op, ast.Mult): + return left * right + if isinstance(op, ast.Div): + return left / right + if isinstance(op, ast.FloorDiv): + return left // right + if isinstance(op, ast.Mod): + return left % right + if isinstance(op, ast.Pow): + return left**right + if isinstance(op, ast.BitAnd): + return left & right + if isinstance(op, ast.BitOr): + return left | right + if isinstance(op, ast.BitXor): + return left ^ right + if isinstance(op, ast.LShift): + return left << right + if isinstance(op, ast.RShift): + return left >> right + return None + + def _apply_cmp(self, left, right, op): + if isinstance(op, ast.Eq): + return left == right + if isinstance(op, ast.NotEq): + return left != right + if isinstance(op, ast.Lt): + return left < right + if isinstance(op, ast.LtE): + return left <= right + if isinstance(op, ast.Gt): + return left > right + if isinstance(op, ast.GtE): + return left >= right + return None + + def _simplify_binop_expr(self, op, left_expr, right_expr, left_const, right_const): + if op == "+": + if self._is_zero(left_const): + return right_expr + if self._is_zero(right_const): + return left_expr + if op == "-" and self._is_zero(right_const): + return left_expr + if op == "*": + if self._is_one(left_const): + return right_expr + if self._is_one(right_const): + return left_expr + return f"({left_expr} {op} {right_expr})" + + def _is_zero(self, value): + return isinstance(value, int | float | bool) and value == 0 + + def _is_one(self, value): + return isinstance(value, int | float | bool) and value == 1 diff --git a/src/blosc2/lazyexpr.py b/src/blosc2/lazyexpr.py index 6f53a249..f5f0c193 100644 --- a/src/blosc2/lazyexpr.py +++ b/src/blosc2/lazyexpr.py @@ -41,6 +41,8 @@ import blosc2 +from .dsl_kernel import DSLKernel + if blosc2._HAS_NUMBA: import numba from blosc2 import compute_chunks_blocks @@ -1262,8 +1264,11 @@ def fast_eval( # noqa: C901 # Use a local copy so we don't modify the global use_miniexpr = try_miniexpr - # Disable miniexpr for UDFs (callable expressions) - if callable(expression): + is_dsl = isinstance(expression, DSLKernel) and expression.dsl_source + expr_string = expression.dsl_source if is_dsl else expression + + # Disable miniexpr for UDFs (callable expressions), except DSL kernels + if callable(expression) and not is_dsl: use_miniexpr = False out = kwargs.pop("_output", None) @@ -1329,11 +1334,11 @@ def fast_eval( # noqa: C901 isinstance(op, blosc2.NDArray) and blosc2.isdtype(op.dtype, "complex floating") for op in operands.values() ) - if isinstance(expression, str) and has_complex: + if isinstance(expr_string, str) and has_complex: if sys.platform == "win32": # On Windows, miniexpr has issues with complex numbers use_miniexpr = False - if any(tok in expression for tok in ("!=", "==", "<=", ">=", "<", ">")): + if any(tok in expr_string for tok in ("!=", "==", "<=", ">=", "<", ">")): use_miniexpr = False if sys.platform == "win32" and use_miniexpr and not _MINIEXPR_WINDOWS_OVERRIDE: # Work around Windows miniexpr issues for integer outputs and dtype conversions. @@ -1351,7 +1356,7 @@ def fast_eval( # noqa: C901 # All values will be overwritten, so we can use an uninitialized array res_eval = blosc2.uninit(shape, dtype, chunks=chunks, blocks=blocks, cparams=cparams, **kwargs) try: - res_eval._set_pref_expr(expression, operands, fp_accuracy=fp_accuracy) + res_eval._set_pref_expr(expr_string, operands, fp_accuracy=fp_accuracy) # print("expr->miniexpr:", expression, fp_accuracy) # Data to compress is fetched from operands, so it can be uninitialized here data = np.empty(res_eval.schunk.chunksize, dtype=np.uint8) @@ -3526,7 +3531,13 @@ def __init__(self, func, inputs, dtype, shape=None, chunked_eval=True, **kwargs) # if 0 not in self._shape: # self.res_getitem._set_postf_udf(self.func, id(self.inputs)) - self.inputs_dict = {f"o{i}": obj for i, obj in enumerate(self.inputs)} + if isinstance(self.func, DSLKernel) and self.func.input_names: + if len(self.func.input_names) == len(self.inputs): + self.inputs_dict = dict(zip(self.func.input_names, self.inputs, strict=True)) + else: + self.inputs_dict = {f"o{i}": obj for i, obj in enumerate(self.inputs)} + else: + self.inputs_dict = {f"o{i}": obj for i, obj in enumerate(self.inputs)} @property def dtype(self): @@ -3734,10 +3745,16 @@ def save(self, urlpath=None, **kwargs): if value.schunk.urlpath is None: raise ValueError("To save a LazyArray, all operands must be stored on disk/network") operands[key] = value.schunk.urlpath + udf_func = self.func.func if isinstance(self.func, DSLKernel) else self.func + udf_name = getattr(udf_func, "__name__", self.func.__name__) + try: + udf_source = textwrap.dedent(inspect.getsource(udf_func)).lstrip() + except Exception: + udf_source = None array.schunk.vlmeta["_LazyArray"] = { - "UDF": textwrap.dedent(inspect.getsource(self.func)).lstrip(), + "UDF": udf_source, "operands": operands, - "name": self.func.__name__, + "name": udf_name, } diff --git a/tests/ndarray/test_dsl_kernels.py b/tests/ndarray/test_dsl_kernels.py new file mode 100644 index 00000000..5821e73d --- /dev/null +++ b/tests/ndarray/test_dsl_kernels.py @@ -0,0 +1,175 @@ +####################################################################### +# Copyright (c) 2019-present, Blosc Development Team +# All rights reserved. +# +# SPDX-License-Identifier: BSD-3-Clause +####################################################################### + +import numpy as np +import pytest + +import blosc2 + + +def _make_arrays(shape=(8, 8), chunks=(4, 4), blocks=(2, 2)): + a = np.linspace(0, 1, num=np.prod(shape), dtype=np.float32).reshape(shape) + b = np.linspace(1, 2, num=np.prod(shape), dtype=np.float32).reshape(shape) + a2 = blosc2.asarray(a, chunks=chunks, blocks=blocks) + b2 = blosc2.asarray(b, chunks=chunks, blocks=blocks) + return a, b, a2, b2 + + +def _make_int_arrays(shape=(8, 8), chunks=(4, 4), blocks=(2, 2)): + a = np.arange(np.prod(shape), dtype=np.int32).reshape(shape) + b = np.arange(np.prod(shape), dtype=np.int32).reshape(shape) + 3 + a2 = blosc2.asarray(a, chunks=chunks, blocks=blocks) + b2 = blosc2.asarray(b, chunks=chunks, blocks=blocks) + return a, b, a2, b2 + + +@blosc2.dsl_kernel +def kernel_loop(x, y): + acc = 0.0 + for i in range(2): + if i % 2 == 0: + tmp = np.where(x < y, y + i, x - i) + else: + tmp = np.where(x > y, x + i, y - i) + acc = acc + tmp * (i + 1) + return acc + + +@blosc2.dsl_kernel +def kernel_fallback_range_2args(x, y): + acc = 0.0 + for i in range(1, 3): + acc = acc + x + y + i + return acc + + +@blosc2.dsl_kernel +def kernel_integer_ops(x, y): + acc = ((x + y) - (x * 2)) // 3 + acc = acc % 5 + acc = acc ^ (x & y) + acc = acc | (x << 1) + return acc + (y >> 1) + + +@blosc2.dsl_kernel +def kernel_control_flow_full(x, y): + acc = x + for i in range(4): + if i == 0: + acc = acc + y + continue + if i == 1: + acc = acc - y + else: + acc = np.where(acc < y, acc + i, acc - i) + if i == 3: + break + return acc + + +@blosc2.dsl_kernel +def kernel_fallback_kw_call(x, y): + return np.clip(x + y, a_min=0.5, a_max=2.5) + + +@blosc2.dsl_kernel +def kernel_fallback_for_else(x, y): + acc = x + for i in range(2): + acc = acc + i + else: + acc = acc + y + return acc + + +@blosc2.dsl_kernel +def kernel_fallback_tuple_assign(x, y): + lhs, rhs = x, y + return lhs + rhs + + +def test_dsl_kernel_reduced_expr(): + assert kernel_loop.dsl_source is not None + assert "def " not in kernel_loop.dsl_source + assert kernel_loop.input_names == ["x", "y"] + + a, b, a2, b2 = _make_arrays() + expr = blosc2.lazyudf(kernel_loop, (a2, b2), dtype=a2.dtype, chunks=a2.chunks, blocks=a2.blocks) + res = expr.compute() + expected = kernel_loop.func(a, b) + + np.testing.assert_allclose(res[...], expected, rtol=1e-5, atol=1e-6) + + +def test_dsl_kernel_integer_ops_reduced_expr(): + assert kernel_integer_ops.dsl_source is not None + assert "def " not in kernel_integer_ops.dsl_source + assert kernel_integer_ops.input_names == ["x", "y"] + + a, b, a2, b2 = _make_int_arrays() + expr = blosc2.lazyudf( + kernel_integer_ops, + (a2, b2), + dtype=a2.dtype, + chunks=a2.chunks, + blocks=a2.blocks, + ) + res = expr.compute() + expected = kernel_integer_ops.func(a, b) + + np.testing.assert_equal(res[...], expected) + + +def test_dsl_kernel_full_control_flow_kept_as_dsl_function(): + assert kernel_control_flow_full.dsl_source is not None + assert "def kernel_control_flow_full(x, y):" in kernel_control_flow_full.dsl_source + assert "for i in range(4):" in kernel_control_flow_full.dsl_source + assert "elif (i == 1):" in kernel_control_flow_full.dsl_source + assert "continue" in kernel_control_flow_full.dsl_source + assert "break" in kernel_control_flow_full.dsl_source + assert "where(" in kernel_control_flow_full.dsl_source + + a, b, a2, b2 = _make_arrays() + expr = blosc2.lazyudf( + kernel_control_flow_full, + (a2, b2), + dtype=a2.dtype, + chunks=a2.chunks, + blocks=a2.blocks, + ) + res = expr.compute() + expected = kernel_control_flow_full.func(a, b) + + np.testing.assert_allclose(res[...], expected, rtol=1e-5, atol=1e-6) + + +@pytest.mark.parametrize( + "kernel", + [ + kernel_fallback_range_2args, + kernel_fallback_kw_call, + kernel_fallback_for_else, + kernel_fallback_tuple_assign, + ], +) +def test_dsl_kernel_flawed_syntax_detected_fallback_callable(kernel): + assert kernel.dsl_source is None + assert kernel.input_names is None + + a, b, a2, b2 = _make_arrays() + expr = blosc2.lazyudf( + kernel, + (a2, b2), + dtype=a2.dtype, + chunks=a2.chunks, + blocks=a2.blocks, + ) + res = expr.compute() + expected = kernel.func(a, b) + + np.testing.assert_allclose(res[...], expected, rtol=1e-5, atol=1e-6) From 96e0ea53b03a2116fd70c0acb2de03764f13358b Mon Sep 17 00:00:00 2001 From: Francesc Alted Date: Fri, 6 Feb 2026 12:30:36 +0100 Subject: [PATCH 2/6] Fixes if/else terminating issue --- src/blosc2/dsl_kernel.py | 28 +++++++++++++++++++++++++++- 1 file changed, 27 insertions(+), 1 deletion(-) diff --git a/src/blosc2/dsl_kernel.py b/src/blosc2/dsl_kernel.py index b7a42c85..3fca3e65 100644 --- a/src/blosc2/dsl_kernel.py +++ b/src/blosc2/dsl_kernel.py @@ -213,8 +213,34 @@ def _stmt(self, node: ast.stmt, indent: int): def _stmt_block(self, body, indent: int): if not body: raise ValueError("Empty blocks are not supported in DSL kernels") - for stmt in body: + i = 0 + while i < len(body): + stmt = body[i] + if ( + isinstance(stmt, ast.If) + and not stmt.orelse + and self._block_terminates(stmt.body) + and i + 1 < len(body) + and isinstance(body[i + 1], ast.If) + ): + merged = ast.If(test=stmt.test, body=stmt.body, orelse=[body[i + 1]]) + self._if_stmt(merged, indent) + i += 2 + continue self._stmt(stmt, indent) + i += 1 + + def _block_terminates(self, body) -> bool: + if not body: + return False + return self._stmt_terminates(body[-1]) + + def _stmt_terminates(self, node: ast.stmt) -> bool: + if isinstance(node, (ast.Return, ast.Break, ast.Continue)): + return True + if isinstance(node, ast.If) and node.orelse: + return self._block_terminates(node.body) and self._block_terminates(node.orelse) + return False def _if_stmt(self, node: ast.If, indent: int): current = node From 3590e61b33e75a8dde77bf8c54c2d5f1faa31746 Mon Sep 17 00:00:00 2001 From: Francesc Alted Date: Fri, 6 Feb 2026 13:21:31 +0100 Subject: [PATCH 3/6] Add a new example on Mandelbrot compute --- examples/ndarray/mandelbrot-dsl.ipynb | 270 ++++++++++++++++++++++++++ src/blosc2/dsl_kernel.py | 79 +++++++- src/blosc2/lazyexpr.py | 33 +++- tests/ndarray/test_dsl_kernels.py | 73 +++++++ 4 files changed, 441 insertions(+), 14 deletions(-) create mode 100644 examples/ndarray/mandelbrot-dsl.ipynb diff --git a/examples/ndarray/mandelbrot-dsl.ipynb b/examples/ndarray/mandelbrot-dsl.ipynb new file mode 100644 index 00000000..f9ed714c --- /dev/null +++ b/examples/ndarray/mandelbrot-dsl.ipynb @@ -0,0 +1,270 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "intro", + "metadata": {}, + "source": [ + "# Mandelbrot With Blosc2 DSL vs Numba\n", + "\n", + "This notebook builds a Mandelbrot kernel with `@blosc2.dsl_kernel`, following the structure in `../miniexpr/examples/13_mandelbrot_dsl.c`:\n", + "- state variables (`zr`, `zi`, `escape_iter`)\n", + "- a `for` loop over iterations\n", + "- conditional updates with `where`\n", + "- early `break` when all points escaped\n", + "\n", + "Then it times the same computation implemented with Numba and plots both outputs." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "imports", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from numba import njit, prange\n", + "\n", + "import blosc2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "grid-setup", + "metadata": {}, + "outputs": [], + "source": [ + "# Problem size and Mandelbrot domain\n", + "WIDTH = 1200\n", + "HEIGHT = 800\n", + "MAX_ITER = 200\n", + "X_MIN, X_MAX = -2.0, 0.6\n", + "Y_MIN, Y_MAX = -1.1, 1.1\n", + "DTYPE = np.float32\n", + "\n", + "x = np.linspace(X_MIN, X_MAX, WIDTH, dtype=DTYPE)\n", + "y = np.linspace(Y_MIN, Y_MAX, HEIGHT, dtype=DTYPE)\n", + "cr_np, ci_np = np.meshgrid(x, y)\n", + "\n", + "# Keep compression overhead low for the timing comparison\n", + "cparams_fast = blosc2.CParams(codec=blosc2.Codec.LZ4, clevel=1)\n", + "cr_b2 = blosc2.asarray(cr_np, cparams=cparams_fast)\n", + "ci_b2 = blosc2.asarray(ci_np, cparams=cparams_fast)\n", + "\n", + "print(f\"grid: {cr_np.shape}, dtype: {cr_np.dtype}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "dsl-kernel", + "metadata": {}, + "outputs": [], + "source": [ + "@blosc2.dsl_kernel\n", + "def mandelbrot_dsl(cr, ci, max_iter):\n", + " # max_iter is passed per-call through lazyudf inputs\n", + " zr = 0.0\n", + " zi = 0.0\n", + " escape_iter = float(max_iter)\n", + " for it in range(max_iter):\n", + " zr2 = zr * zr\n", + " zi2 = zi * zi\n", + " mag2 = zr2 + zi2\n", + "\n", + " active = escape_iter == float(max_iter)\n", + " just_escaped = (mag2 > 4.0) & active\n", + " escape_iter = np.where(just_escaped, it, escape_iter)\n", + "\n", + " active = escape_iter == float(max_iter)\n", + " if np.all(active == 0):\n", + " break\n", + "\n", + " zr_new = zr2 - zi2 + cr\n", + " zi_new = 2.0 * zr * zi + ci\n", + " zr = np.where(active, zr_new, zr)\n", + " zi = np.where(active, zi_new, zi)\n", + "\n", + " return escape_iter\n", + "\n", + "\n", + "if mandelbrot_dsl.dsl_source is None:\n", + " raise RuntimeError(\"DSL extraction failed. Re-run this cell in a file-backed notebook session.\")\n", + "\n", + "print(mandelbrot_dsl.dsl_source)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "numba-kernel", + "metadata": {}, + "outputs": [], + "source": [ + "@njit(parallel=True, fastmath=False)\n", + "def mandelbrot_numba(cr, ci, max_iter):\n", + " h, w = cr.shape\n", + " out = np.empty((h, w), dtype=np.float32)\n", + " for iy in prange(h):\n", + " for ix in range(w):\n", + " zr = np.float32(0.0)\n", + " zi = np.float32(0.0)\n", + " escape_iter = np.float32(max_iter)\n", + " c_re = cr[iy, ix]\n", + " c_im = ci[iy, ix]\n", + " for it in range(max_iter):\n", + " zr2 = zr * zr\n", + " zi2 = zi * zi\n", + " if zr2 + zi2 > np.float32(4.0):\n", + " escape_iter = np.float32(it)\n", + " break\n", + " zr_new = zr2 - zi2 + c_re\n", + " zi_new = np.float32(2.0) * zr * zi + c_im\n", + " zr = zr_new\n", + " zi = zi_new\n", + " out[iy, ix] = escape_iter\n", + " return out" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "benchmark", + "metadata": {}, + "outputs": [], + "source": [ + "def best_time(func, repeats=3, warmup=1):\n", + " for _ in range(warmup):\n", + " func()\n", + " best = float(\"inf\")\n", + " best_out = None\n", + " for _ in range(repeats):\n", + " t0 = time.perf_counter()\n", + " out = func()\n", + " dt = time.perf_counter() - t0\n", + " if dt < best:\n", + " best = dt\n", + " best_out = out\n", + " return best, best_out\n", + "\n", + "\n", + "def run_dsl():\n", + " lazy = blosc2.lazyudf(mandelbrot_dsl, (cr_b2, ci_b2, MAX_ITER), dtype=np.float32, cparams=cparams_fast)\n", + " return lazy.compute()[...]\n", + "\n", + "\n", + "def run_numba():\n", + " return mandelbrot_numba(cr_np, ci_np, MAX_ITER)\n", + "\n", + "\n", + "# Measure first iteration (includes one-time overhead, especially Numba JIT compile)\n", + "t0 = time.perf_counter()\n", + "_ = run_dsl()\n", + "t_dsl_first = time.perf_counter() - t0\n", + "\n", + "t0 = time.perf_counter()\n", + "_ = run_numba()\n", + "t_numba_first = time.perf_counter() - t0\n", + "\n", + "t_dsl, img_dsl = best_time(run_dsl, repeats=3, warmup=1)\n", + "t_numba, img_numba = best_time(run_numba, repeats=5, warmup=1)\n", + "max_abs_diff = float(np.max(np.abs(img_dsl - img_numba)))\n", + "\n", + "print(\"First iteration timings (one-time overhead included):\")\n", + "print(f\"DSL first run: {t_dsl_first:.6f} s\")\n", + "print(f\"Numba first run: {t_numba_first:.6f} s\")\n", + "print(f\"DSL / Numba: {t_dsl_first / t_numba_first:.2f}x\")\n", + "\n", + "print(\"\\nBest-time stats:\")\n", + "print(f\"DSL time (best): {t_dsl:.6f} s\")\n", + "print(f\"Numba time (best): {t_numba:.6f} s\")\n", + "print(f\"DSL / Numba: {t_dsl / t_numba:.2f}x\")\n", + "print(f\"max |dsl-numba|: {max_abs_diff:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "plot", + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots(1, 2, figsize=(13, 5), constrained_layout=True)\n", + "\n", + "im0 = ax[0].imshow(\n", + " img_dsl,\n", + " cmap=\"magma\",\n", + " extent=(X_MIN, X_MAX, Y_MIN, Y_MAX),\n", + " origin=\"lower\",\n", + ")\n", + "ax[0].set_title(\"Mandelbrot (Blosc2 DSL)\")\n", + "ax[0].set_xlabel(\"Re(c)\")\n", + "ax[0].set_ylabel(\"Im(c)\")\n", + "fig.colorbar(im0, ax=ax[0], shrink=0.82, label=\"Escape iteration\")\n", + "\n", + "im1 = ax[1].imshow(\n", + " img_numba,\n", + " cmap=\"magma\",\n", + " extent=(X_MIN, X_MAX, Y_MIN, Y_MAX),\n", + " origin=\"lower\",\n", + ")\n", + "ax[1].set_title(\"Mandelbrot (Numba)\")\n", + "ax[1].set_xlabel(\"Re(c)\")\n", + "ax[1].set_ylabel(\"Im(c)\")\n", + "fig.colorbar(im1, ax=ax[1], shrink=0.82, label=\"Escape iteration\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "timing-bars", + "metadata": {}, + "outputs": [], + "source": [ + "labels = [\"Blosc2 DSL\", \"Numba\"]\n", + "first_times = [t_dsl_first, t_numba_first]\n", + "best_times = [t_dsl, t_numba]\n", + "\n", + "x = np.arange(len(labels))\n", + "width = 0.36\n", + "\n", + "fig, ax = plt.subplots(figsize=(8, 5), constrained_layout=True)\n", + "ax.bar(x - width / 2, first_times, width, label=\"First run\", color=\"#4C78A8\")\n", + "ax.bar(x + width / 2, best_times, width, label=\"Best run\", color=\"#F58518\")\n", + "\n", + "ax.set_xticks(x)\n", + "ax.set_xticklabels(labels)\n", + "ax.set_ylabel(\"Time (seconds)\")\n", + "ax.set_title(\"Mandelbrot Timings: First vs Best\")\n", + "ax.legend()\n", + "\n", + "for i, t in enumerate(first_times):\n", + " ax.text(i - width / 2, t, f\"{t:.3f}s\", ha=\"center\", va=\"bottom\")\n", + "for i, t in enumerate(best_times):\n", + " ax.text(i + width / 2, t, f\"{t:.3f}s\", ha=\"center\", va=\"bottom\")\n", + "\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/blosc2/dsl_kernel.py b/src/blosc2/dsl_kernel.py index 3fca3e65..98221c4b 100644 --- a/src/blosc2/dsl_kernel.py +++ b/src/blosc2/dsl_kernel.py @@ -8,6 +8,7 @@ from __future__ import annotations import ast +import contextlib import inspect import os import textwrap @@ -17,6 +18,71 @@ _PRINT_DSL_KERNEL = _PRINT_DSL_KERNEL not in ("", "0", "false", "no", "off") +def _normalize_dsl_scalar(value): + # NumPy scalar-like values expose .item(); plain Python scalars do not. + if hasattr(value, "item") and callable(value.item): + with contextlib.suppress(Exception): + value = value.item() + if isinstance(value, bool): + return int(value) + if isinstance(value, int | float): + return value + raise TypeError("Unsupported scalar type for DSL miniexpr specialization") + + +class _DSLScalarSpecializer(ast.NodeTransformer): + def __init__(self, replacements: dict[str, int | float]): + self.replacements = replacements + + def visit_Name(self, node): + if isinstance(node.ctx, ast.Load) and node.id in self.replacements: + return ast.copy_location(ast.Constant(value=self.replacements[node.id]), node) + return node + + def visit_Call(self, node): + node = self.generic_visit(node) + if ( + isinstance(node.func, ast.Name) + and node.func.id in {"float", "int"} + and len(node.args) == 1 + and not node.keywords + and isinstance(node.args[0], ast.Constant) + and isinstance(node.args[0].value, int | float | bool) + ): + folded = float(node.args[0].value) if node.func.id == "float" else int(node.args[0].value) + return ast.copy_location(ast.Constant(value=folded), node) + return node + + +def specialize_dsl_miniexpr_inputs(expr_string: str, operands: dict): + """Inline scalar DSL operands as constants for miniexpr compilation.""" + scalar_replacements = {} + array_operands = {} + for name, value in operands.items(): + if hasattr(value, "shape") and value.shape == (): + scalar_replacements[name] = _normalize_dsl_scalar(value[()]) + continue + if isinstance(value, int | float | bool) or (hasattr(value, "item") and callable(value.item)): + try: + scalar_replacements[name] = _normalize_dsl_scalar(value) + continue + except TypeError: + pass + array_operands[name] = value + + if not scalar_replacements: + return expr_string, operands + + tree = ast.parse(expr_string) + tree = _DSLScalarSpecializer(scalar_replacements).visit(tree) + for node in tree.body: + if isinstance(node, ast.FunctionDef): + node.args.posonlyargs = [a for a in node.args.posonlyargs if a.arg not in scalar_replacements] + node.args.args = [a for a in node.args.args if a.arg not in scalar_replacements] + ast.fix_missing_locations(tree) + return ast.unparse(tree), array_operands + + class DSLKernel: """Wrap a Python function and optionally extract a miniexpr DSL kernel from it.""" @@ -32,12 +98,17 @@ def __init__(self, func): self._sig = sig self._sig_has_varargs = False self._sig_npositional = None + self._legacy_udf_signature = False if sig is not None: params = list(sig.parameters.values()) + positional_params = [p for p in params if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD)] self._sig_has_varargs = any(p.kind == p.VAR_POSITIONAL for p in params) - self._sig_npositional = sum( - 1 for p in params if p.kind in (p.POSITIONAL_ONLY, p.POSITIONAL_OR_KEYWORD) - ) + self._sig_npositional = len(positional_params) + # Preserve support for classic lazyudf signature: (inputs_tuple, output, offset) + if not self._sig_has_varargs and len(positional_params) == 3: + p2 = positional_params[1].name.lower() + p3 = positional_params[2].name.lower() + self._legacy_udf_signature = p2 in {"output", "out"} and p3 == "offset" self.dsl_source = None self.input_names = None try: @@ -92,7 +163,7 @@ def _extract_dsl(self, func): return builder.build(func_node) def __call__(self, inputs_tuple, output, offset=None): - if self._sig is not None and not self._sig_has_varargs and self._sig_npositional == 3: + if self._legacy_udf_signature: return self.func(inputs_tuple, output, offset) n_inputs = len(inputs_tuple) diff --git a/src/blosc2/lazyexpr.py b/src/blosc2/lazyexpr.py index f5f0c193..e7a59cee 100644 --- a/src/blosc2/lazyexpr.py +++ b/src/blosc2/lazyexpr.py @@ -41,7 +41,7 @@ import blosc2 -from .dsl_kernel import DSLKernel +from .dsl_kernel import DSLKernel, specialize_dsl_miniexpr_inputs if blosc2._HAS_NUMBA: import numba @@ -1320,25 +1320,38 @@ def fast_eval( # noqa: C901 # WebAssembly does not support threading, so we cannot use the iter_disk option iter_disk = False + expr_string_miniexpr = expr_string + operands_miniexpr = operands + if use_miniexpr and is_dsl: + try: + expr_string_miniexpr, operands_miniexpr = specialize_dsl_miniexpr_inputs(expr_string, operands) + except Exception: + # If specialization fails, keep original expression/operands and let normal checks decide. + expr_string_miniexpr = expr_string + operands_miniexpr = operands + # Check whether we can use miniexpr if use_miniexpr: + all_ndarray_miniexpr = all( + isinstance(value, blosc2.NDArray) and value.shape != () for value in operands_miniexpr.values() + ) # Require aligned NDArray operands with identical chunk/block grid. - same_shape = all(hasattr(op, "shape") and op.shape == shape for op in operands.values()) - same_chunks = all(hasattr(op, "chunks") and op.chunks == chunks for op in operands.values()) - same_blocks = all(hasattr(op, "blocks") and op.blocks == blocks for op in operands.values()) + same_shape = all(hasattr(op, "shape") and op.shape == shape for op in operands_miniexpr.values()) + same_chunks = all(hasattr(op, "chunks") and op.chunks == chunks for op in operands_miniexpr.values()) + same_blocks = all(hasattr(op, "blocks") and op.blocks == blocks for op in operands_miniexpr.values()) if not (same_shape and same_chunks and same_blocks): use_miniexpr = False - if not (all_ndarray and out is None): + if not (all_ndarray_miniexpr and out is None): use_miniexpr = False has_complex = any( isinstance(op, blosc2.NDArray) and blosc2.isdtype(op.dtype, "complex floating") - for op in operands.values() + for op in operands_miniexpr.values() ) - if isinstance(expr_string, str) and has_complex: + if isinstance(expr_string_miniexpr, str) and has_complex: if sys.platform == "win32": # On Windows, miniexpr has issues with complex numbers use_miniexpr = False - if any(tok in expr_string for tok in ("!=", "==", "<=", ">=", "<", ">")): + if any(tok in expr_string_miniexpr for tok in ("!=", "==", "<=", ">=", "<", ">")): use_miniexpr = False if sys.platform == "win32" and use_miniexpr and not _MINIEXPR_WINDOWS_OVERRIDE: # Work around Windows miniexpr issues for integer outputs and dtype conversions. @@ -1346,7 +1359,7 @@ def fast_eval( # noqa: C901 use_miniexpr = False else: dtype_mismatch = any( - isinstance(op, blosc2.NDArray) and op.dtype != dtype for op in operands.values() + isinstance(op, blosc2.NDArray) and op.dtype != dtype for op in operands_miniexpr.values() ) if dtype_mismatch: use_miniexpr = False @@ -1356,7 +1369,7 @@ def fast_eval( # noqa: C901 # All values will be overwritten, so we can use an uninitialized array res_eval = blosc2.uninit(shape, dtype, chunks=chunks, blocks=blocks, cparams=cparams, **kwargs) try: - res_eval._set_pref_expr(expr_string, operands, fp_accuracy=fp_accuracy) + res_eval._set_pref_expr(expr_string_miniexpr, operands_miniexpr, fp_accuracy=fp_accuracy) # print("expr->miniexpr:", expression, fp_accuracy) # Data to compress is fetched from operands, so it can be uninitialized here data = np.empty(res_eval.schunk.chunksize, dtype=np.uint8) diff --git a/tests/ndarray/test_dsl_kernels.py b/tests/ndarray/test_dsl_kernels.py index 5821e73d..717bbac2 100644 --- a/tests/ndarray/test_dsl_kernels.py +++ b/tests/ndarray/test_dsl_kernels.py @@ -72,6 +72,14 @@ def kernel_control_flow_full(x, y): return acc +@blosc2.dsl_kernel +def kernel_loop_param(x, y, niter): + acc = x + for _i in range(niter): + acc = np.where(acc < y, acc + 1, acc - 1) + return acc + + @blosc2.dsl_kernel def kernel_fallback_kw_call(x, y): return np.clip(x + y, a_min=0.5, a_max=2.5) @@ -148,6 +156,71 @@ def test_dsl_kernel_full_control_flow_kept_as_dsl_function(): np.testing.assert_allclose(res[...], expected, rtol=1e-5, atol=1e-6) +def test_dsl_kernel_accepts_scalar_param_per_call(): + assert kernel_loop_param.dsl_source is not None + assert "def kernel_loop_param(x, y, niter):" in kernel_loop_param.dsl_source + assert "for _i in range(niter):" in kernel_loop_param.dsl_source + assert kernel_loop_param.input_names == ["x", "y", "niter"] + + a, b, a2, b2 = _make_arrays() + niter = 3 + expr = blosc2.lazyudf( + kernel_loop_param, + (a2, b2, niter), + dtype=a2.dtype, + chunks=a2.chunks, + blocks=a2.blocks, + ) + res = expr.compute() + expected = kernel_loop_param.func(a, b, niter) + + np.testing.assert_allclose(res[...], expected, rtol=1e-5, atol=1e-6) + + +def test_dsl_kernel_scalar_param_keeps_miniexpr_fast_path(monkeypatch): + if blosc2.IS_WASM: + pytest.skip("miniexpr fast path is not available on WASM") + + import importlib + + lazyexpr_mod = importlib.import_module("blosc2.lazyexpr") + old_try_miniexpr = lazyexpr_mod.try_miniexpr + lazyexpr_mod.try_miniexpr = True + + original_set_pref_expr = blosc2.NDArray._set_pref_expr + captured = {"calls": 0, "expr": None, "keys": None} + + def wrapped_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc=None): + captured["calls"] += 1 + captured["expr"] = expression.decode("utf-8") if isinstance(expression, bytes) else expression + captured["keys"] = tuple(inputs.keys()) + return original_set_pref_expr(self, expression, inputs, fp_accuracy, aux_reduc) + + monkeypatch.setattr(blosc2.NDArray, "_set_pref_expr", wrapped_set_pref_expr) + + try: + a, b, a2, b2 = _make_arrays(shape=(32, 32), chunks=(16, 16), blocks=(8, 8)) + niter = 3 + expr = blosc2.lazyudf( + kernel_loop_param, + (a2, b2, niter), + dtype=a2.dtype, + ) + res = expr.compute() + expected = kernel_loop_param.func(a, b, niter) + + np.testing.assert_allclose(res[...], expected, rtol=1e-5, atol=1e-6) + assert captured["calls"] >= 1 + assert captured["keys"] == ("x", "y") + assert "def kernel_loop_param(x, y):" in captured["expr"] + assert "for it in range(3):" not in captured["expr"] + assert "for _i in range(3):" in captured["expr"] + assert "range(niter)" not in captured["expr"] + assert "float(niter)" not in captured["expr"] + finally: + lazyexpr_mod.try_miniexpr = old_try_miniexpr + + @pytest.mark.parametrize( "kernel", [ From 08d92137c353dc124dc44520720c6ab8a0f7b4ce Mon Sep 17 00:00:00 2001 From: Francesc Alted Date: Fri, 6 Feb 2026 13:22:03 +0100 Subject: [PATCH 4/6] Use latest miniexpr --- CMakeLists.txt | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index 66e217bc..ea5922a4 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -57,9 +57,9 @@ set(MINIEXPR_BUILD_EXAMPLES OFF CACHE BOOL "Build miniexpr examples" FORCE) set(MINIEXPR_BUILD_BENCH OFF CACHE BOOL "Build miniexpr benchmarks" FORCE) FetchContent_Declare(miniexpr - #GIT_REPOSITORY https://github.com/Blosc/miniexpr.git - #GIT_TAG 77d633cb2c134552da045b8d2cc0ad23908e6b9e - SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../miniexpr + GIT_REPOSITORY https://github.com/Blosc/miniexpr.git + GIT_TAG b4cfa9c2dc26772ad2126e6a611f93daf050915f + #SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../miniexpr ) FetchContent_MakeAvailable(miniexpr) From 8d15c20a9922fb904474e1c8c4fd8c0e3d458e1d Mon Sep 17 00:00:00 2001 From: Francesc Alted Date: Sat, 7 Feb 2026 08:54:50 +0100 Subject: [PATCH 5/6] Add blosc2+numba in the comparison chart --- examples/ndarray/mandelbrot-dsl.ipynb | 284 ++++++++++++++++++++------ 1 file changed, 226 insertions(+), 58 deletions(-) diff --git a/examples/ndarray/mandelbrot-dsl.ipynb b/examples/ndarray/mandelbrot-dsl.ipynb index f9ed714c..c5cc5013 100644 --- a/examples/ndarray/mandelbrot-dsl.ipynb +++ b/examples/ndarray/mandelbrot-dsl.ipynb @@ -4,23 +4,18 @@ "cell_type": "markdown", "id": "intro", "metadata": {}, - "source": [ - "# Mandelbrot With Blosc2 DSL vs Numba\n", - "\n", - "This notebook builds a Mandelbrot kernel with `@blosc2.dsl_kernel`, following the structure in `../miniexpr/examples/13_mandelbrot_dsl.c`:\n", - "- state variables (`zr`, `zi`, `escape_iter`)\n", - "- a `for` loop over iterations\n", - "- conditional updates with `where`\n", - "- early `break` when all points escaped\n", - "\n", - "Then it times the same computation implemented with Numba and plots both outputs." - ] + "source": "# Mandelbrot With Blosc2 DSL vs Blosc2+Numba\n\nThis notebook compares two Blosc2-backed execution paths for Mandelbrot side-by-side:\n- `@blosc2.dsl_kernel` through `blosc2.lazyudf` (`blosc2+DSL`)\n- a Numba-compiled `lazyudf` kernel (`blosc2+numba`), following the pattern in `compute_udf_numba.py`\n\nThe previous native Numba implementation is moved earlier as a baseline and is still plotted for visual comparison.\n" }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "imports", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-02-07T07:02:24.027879Z", + "start_time": "2026-02-07T07:02:23.731399Z" + } + }, "outputs": [], "source": [ "import time\n", @@ -34,14 +29,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "grid-setup", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-02-07T07:02:24.058225Z", + "start_time": "2026-02-07T07:02:24.029111Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "grid: (800, 1200), dtype: float32\n" + ] + } + ], "source": [ "# Problem size and Mandelbrot domain\n", - "WIDTH = 1200\n", - "HEIGHT = 800\n", + "WIDTH = 1200 * 2\n", + "HEIGHT = 800 * 2\n", "MAX_ITER = 200\n", "X_MIN, X_MAX = -2.0, 0.6\n", "Y_MIN, Y_MAX = -1.1, 1.1\n", @@ -61,10 +69,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "dsl-kernel", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-02-07T07:02:24.081756Z", + "start_time": "2026-02-07T07:02:24.059685Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "def mandelbrot_dsl(cr, ci, max_iter):\n", + " zr = 0.0\n", + " zi = 0.0\n", + " escape_iter = float(max_iter)\n", + " for it in range(max_iter):\n", + " zr2 = (zr * zr)\n", + " zi2 = (zi * zi)\n", + " mag2 = (zr2 + zi2)\n", + " active = (escape_iter == float(max_iter))\n", + " just_escaped = ((mag2 > 4.0) & active)\n", + " escape_iter = where(just_escaped, it, escape_iter)\n", + " active = (escape_iter == float(max_iter))\n", + " if all((active == 0)):\n", + " break\n", + " zr_new = ((zr2 - zi2) + cr)\n", + " zi_new = (((2.0 * zr) * zi) + ci)\n", + " zr = where(active, zr_new, zr)\n", + " zi = where(active, zi_new, zi)\n", + " return escape_iter\n" + ] + } + ], "source": [ "@blosc2.dsl_kernel\n", "def mandelbrot_dsl(cr, ci, max_iter):\n", @@ -101,13 +140,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "numba-kernel", - "metadata": {}, + "metadata": { + "ExecuteTime": { + "end_time": "2026-02-07T07:02:24.103853Z", + "start_time": "2026-02-07T07:02:24.083437Z" + } + }, "outputs": [], "source": [ "@njit(parallel=True, fastmath=False)\n", - "def mandelbrot_numba(cr, ci, max_iter):\n", + "def mandelbrot_numba_native(cr, ci, max_iter):\n", " h, w = cr.shape\n", " out = np.empty((h, w), dtype=np.float32)\n", " for iy in prange(h):\n", @@ -128,15 +172,68 @@ " zr = zr_new\n", " zi = zi_new\n", " out[iy, ix] = escape_iter\n", - " return out" + " return out\n", + "\n", + "\n", + "@njit(parallel=True, fastmath=False)\n", + "def mandelbrot_numba_lazyudf(inputs_tuple, output, offset):\n", + " cr = inputs_tuple[0]\n", + " ci = inputs_tuple[1]\n", + " max_iter = np.int32(MAX_ITER)\n", + " h, w = output.shape\n", + " for iy in prange(h):\n", + " for ix in range(w):\n", + " zr = np.float32(0.0)\n", + " zi = np.float32(0.0)\n", + " escape_iter = np.float32(max_iter)\n", + " c_re = cr[iy, ix]\n", + " c_im = ci[iy, ix]\n", + " for it in range(max_iter):\n", + " zr2 = zr * zr\n", + " zi2 = zi * zi\n", + " if zr2 + zi2 > np.float32(4.0):\n", + " escape_iter = np.float32(it)\n", + " break\n", + " zr_new = zr2 - zi2 + c_re\n", + " zi_new = np.float32(2.0) * zr * zi + c_im\n", + " zr = zr_new\n", + " zi = zi_new\n", + " output[iy, ix] = escape_iter" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "benchmark", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-02-07T07:02:27.052865Z", + "start_time": "2026-02-07T07:02:24.104692Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "First iteration timings (one-time overhead included):\n", + "Native numba first run (baseline): 0.457351 s\n", + "Blosc2+numba first run: 0.287874 s\n", + "Blosc2+DSL first run: 0.343547 s\n", + "\n", + "Best-time stats:\n", + "Native numba time (best): 0.051693 s\n", + "Blosc2+numba time (best): 0.056486 s\n", + "Blosc2+DSL time (best): 0.317045 s\n", + "Blosc2+numba / native: 1.09x\n", + "Blosc2+DSL / native: 6.13x\n", + "Blosc2+DSL / Blosc2+numba: 5.61x\n", + "max |dsl-b2_numba|: 0.000000\n", + "max |native-b2_numba|: 0.000000\n", + "max |native-dsl|: 0.000000\n" + ] + } + ], "source": [ "def best_time(func, repeats=3, warmup=1):\n", " for _ in range(warmup):\n", @@ -153,96 +250,167 @@ " return best, best_out\n", "\n", "\n", + "def run_numba_native():\n", + " return mandelbrot_numba_native(cr_np, ci_np, MAX_ITER)\n", + "\n", + "\n", + "def run_blosc2_numba():\n", + " lazy = blosc2.lazyudf(mandelbrot_numba_lazyudf, (cr_b2, ci_b2), dtype=np.float32, cparams=cparams_fast)\n", + " return lazy.compute()[...]\n", + "\n", + "\n", "def run_dsl():\n", " lazy = blosc2.lazyudf(mandelbrot_dsl, (cr_b2, ci_b2, MAX_ITER), dtype=np.float32, cparams=cparams_fast)\n", " return lazy.compute()[...]\n", "\n", "\n", - "def run_numba():\n", - " return mandelbrot_numba(cr_np, ci_np, MAX_ITER)\n", + "# Measure first iteration (includes one-time overhead, especially Numba JIT compile)\n", + "t0 = time.perf_counter()\n", + "_ = run_numba_native()\n", + "t_numba_native_first = time.perf_counter() - t0\n", "\n", + "t0 = time.perf_counter()\n", + "_ = run_blosc2_numba()\n", + "t_b2_numba_first = time.perf_counter() - t0\n", "\n", - "# Measure first iteration (includes one-time overhead, especially Numba JIT compile)\n", "t0 = time.perf_counter()\n", "_ = run_dsl()\n", "t_dsl_first = time.perf_counter() - t0\n", "\n", - "t0 = time.perf_counter()\n", - "_ = run_numba()\n", - "t_numba_first = time.perf_counter() - t0\n", "\n", + "t_numba_native, img_numba_native = best_time(run_numba_native, repeats=5, warmup=1)\n", + "t_b2_numba, img_b2_numba = best_time(run_blosc2_numba, repeats=3, warmup=1)\n", "t_dsl, img_dsl = best_time(run_dsl, repeats=3, warmup=1)\n", - "t_numba, img_numba = best_time(run_numba, repeats=5, warmup=1)\n", - "max_abs_diff = float(np.max(np.abs(img_dsl - img_numba)))\n", + "\n", + "max_abs_diff_dsl_vs_b2_numba = float(np.max(np.abs(img_dsl - img_b2_numba)))\n", + "max_abs_diff_native_vs_b2_numba = float(np.max(np.abs(img_numba_native - img_b2_numba)))\n", + "max_abs_diff_native_vs_dsl = float(np.max(np.abs(img_numba_native - img_dsl)))\n", "\n", "print(\"First iteration timings (one-time overhead included):\")\n", - "print(f\"DSL first run: {t_dsl_first:.6f} s\")\n", - "print(f\"Numba first run: {t_numba_first:.6f} s\")\n", - "print(f\"DSL / Numba: {t_dsl_first / t_numba_first:.2f}x\")\n", + "print(f\"Native numba first run (baseline): {t_numba_native_first:.6f} s\")\n", + "print(f\"Blosc2+numba first run: {t_b2_numba_first:.6f} s\")\n", + "print(f\"Blosc2+DSL first run: {t_dsl_first:.6f} s\")\n", "\n", "print(\"\\nBest-time stats:\")\n", - "print(f\"DSL time (best): {t_dsl:.6f} s\")\n", - "print(f\"Numba time (best): {t_numba:.6f} s\")\n", - "print(f\"DSL / Numba: {t_dsl / t_numba:.2f}x\")\n", - "print(f\"max |dsl-numba|: {max_abs_diff:.6f}\")" + "print(f\"Native numba time (best): {t_numba_native:.6f} s\")\n", + "print(f\"Blosc2+numba time (best): {t_b2_numba:.6f} s\")\n", + "print(f\"Blosc2+DSL time (best): {t_dsl:.6f} s\")\n", + "print(f\"Blosc2+numba / native: {t_b2_numba / t_numba_native:.2f}x\")\n", + "print(f\"Blosc2+DSL / native: {t_dsl / t_numba_native:.2f}x\")\n", + "print(f\"Blosc2+DSL / Blosc2+numba: {t_dsl / t_b2_numba:.2f}x\")\n", + "print(f\"max |dsl-b2_numba|: {max_abs_diff_dsl_vs_b2_numba:.6f}\")\n", + "print(f\"max |native-b2_numba|: {max_abs_diff_native_vs_b2_numba:.6f}\")\n", + "print(f\"max |native-dsl|: {max_abs_diff_native_vs_dsl:.6f}\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "plot", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-02-07T07:02:27.524673Z", + "start_time": "2026-02-07T07:02:27.073130Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "jetTransient": { + "display_id": null + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots(1, 2, figsize=(13, 5), constrained_layout=True)\n", "\n", "im0 = ax[0].imshow(\n", - " img_dsl,\n", + " img_b2_numba,\n", " cmap=\"magma\",\n", " extent=(X_MIN, X_MAX, Y_MIN, Y_MAX),\n", " origin=\"lower\",\n", ")\n", - "ax[0].set_title(\"Mandelbrot (Blosc2 DSL)\")\n", + "ax[0].set_title(\"Mandelbrot (Blosc2+Numba)\")\n", "ax[0].set_xlabel(\"Re(c)\")\n", "ax[0].set_ylabel(\"Im(c)\")\n", "fig.colorbar(im0, ax=ax[0], shrink=0.82, label=\"Escape iteration\")\n", "\n", "im1 = ax[1].imshow(\n", - " img_numba,\n", + " img_dsl,\n", " cmap=\"magma\",\n", " extent=(X_MIN, X_MAX, Y_MIN, Y_MAX),\n", " origin=\"lower\",\n", ")\n", - "ax[1].set_title(\"Mandelbrot (Numba)\")\n", + "ax[1].set_title(\"Mandelbrot (Blosc2+DSL)\")\n", "ax[1].set_xlabel(\"Re(c)\")\n", "ax[1].set_ylabel(\"Im(c)\")\n", "fig.colorbar(im1, ax=ax[1], shrink=0.82, label=\"Escape iteration\")\n", "\n", + "plt.show()\n", + "\n", + "fig, ax = plt.subplots(1, 1, figsize=(6.4, 5), constrained_layout=True)\n", + "im_base = ax.imshow(\n", + " img_numba_native,\n", + " cmap=\"magma\",\n", + " extent=(X_MIN, X_MAX, Y_MIN, Y_MAX),\n", + " origin=\"lower\",\n", + ")\n", + "ax.set_title(\"Mandelbrot (Native Numba baseline)\")\n", + "ax.set_xlabel(\"Re(c)\")\n", + "ax.set_ylabel(\"Im(c)\")\n", + "fig.colorbar(im_base, ax=ax, shrink=0.82, label=\"Escape iteration\")\n", + "\n", "plt.show()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "timing-bars", - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-02-07T07:02:27.612828Z", + "start_time": "2026-02-07T07:02:27.534390Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "jetTransient": { + "display_id": null + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "labels = [\"Blosc2 DSL\", \"Numba\"]\n", - "first_times = [t_dsl_first, t_numba_first]\n", - "best_times = [t_dsl, t_numba]\n", + "labels = [\"Native Numba (baseline)\", \"Blosc2+Numba\", \"Blosc2+DSL\"]\n", + "first_times = [t_numba_native_first, t_b2_numba_first, t_dsl_first]\n", + "best_times = [t_numba_native, t_b2_numba, t_dsl]\n", "\n", "x = np.arange(len(labels))\n", "width = 0.36\n", "\n", - "fig, ax = plt.subplots(figsize=(8, 5), constrained_layout=True)\n", + "fig, ax = plt.subplots(figsize=(9, 5), constrained_layout=True)\n", "ax.bar(x - width / 2, first_times, width, label=\"First run\", color=\"#4C78A8\")\n", "ax.bar(x + width / 2, best_times, width, label=\"Best run\", color=\"#F58518\")\n", "\n", "ax.set_xticks(x)\n", "ax.set_xticklabels(labels)\n", "ax.set_ylabel(\"Time (seconds)\")\n", - "ax.set_title(\"Mandelbrot Timings: First vs Best\")\n", + "ax.set_title(\"Mandelbrot Timings: Native Baseline vs Blosc2 Pipelines\")\n", "ax.legend()\n", "\n", "for i, t in enumerate(first_times):\n", From c25e3b51cae2b9b5ebd72dcfdda4f5084651826a Mon Sep 17 00:00:00 2001 From: Francesc Alted Date: Sat, 7 Feb 2026 12:28:41 +0100 Subject: [PATCH 6/6] Cleanup notebook --- examples/ndarray/mandelbrot-dsl.ipynb | 179 +++++--------------------- 1 file changed, 30 insertions(+), 149 deletions(-) diff --git a/examples/ndarray/mandelbrot-dsl.ipynb b/examples/ndarray/mandelbrot-dsl.ipynb index c5cc5013..99cbfdb5 100644 --- a/examples/ndarray/mandelbrot-dsl.ipynb +++ b/examples/ndarray/mandelbrot-dsl.ipynb @@ -8,15 +8,8 @@ }, { "cell_type": "code", - "execution_count": 1, "id": "imports", - "metadata": { - "ExecuteTime": { - "end_time": "2026-02-07T07:02:24.027879Z", - "start_time": "2026-02-07T07:02:23.731399Z" - } - }, - "outputs": [], + "metadata": {}, "source": [ "import time\n", "\n", @@ -25,31 +18,18 @@ "from numba import njit, prange\n", "\n", "import blosc2" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 2, "id": "grid-setup", - "metadata": { - "ExecuteTime": { - "end_time": "2026-02-07T07:02:24.058225Z", - "start_time": "2026-02-07T07:02:24.029111Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "grid: (800, 1200), dtype: float32\n" - ] - } - ], + "metadata": {}, "source": [ "# Problem size and Mandelbrot domain\n", - "WIDTH = 1200 * 2\n", - "HEIGHT = 800 * 2\n", + "WIDTH = 1200\n", + "HEIGHT = 800\n", "MAX_ITER = 200\n", "X_MIN, X_MAX = -2.0, 0.6\n", "Y_MIN, Y_MAX = -1.1, 1.1\n", @@ -65,45 +45,14 @@ "ci_b2 = blosc2.asarray(ci_np, cparams=cparams_fast)\n", "\n", "print(f\"grid: {cr_np.shape}, dtype: {cr_np.dtype}\")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 3, "id": "dsl-kernel", - "metadata": { - "ExecuteTime": { - "end_time": "2026-02-07T07:02:24.081756Z", - "start_time": "2026-02-07T07:02:24.059685Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "def mandelbrot_dsl(cr, ci, max_iter):\n", - " zr = 0.0\n", - " zi = 0.0\n", - " escape_iter = float(max_iter)\n", - " for it in range(max_iter):\n", - " zr2 = (zr * zr)\n", - " zi2 = (zi * zi)\n", - " mag2 = (zr2 + zi2)\n", - " active = (escape_iter == float(max_iter))\n", - " just_escaped = ((mag2 > 4.0) & active)\n", - " escape_iter = where(just_escaped, it, escape_iter)\n", - " active = (escape_iter == float(max_iter))\n", - " if all((active == 0)):\n", - " break\n", - " zr_new = ((zr2 - zi2) + cr)\n", - " zi_new = (((2.0 * zr) * zi) + ci)\n", - " zr = where(active, zr_new, zr)\n", - " zi = where(active, zi_new, zi)\n", - " return escape_iter\n" - ] - } - ], + "metadata": {}, "source": [ "@blosc2.dsl_kernel\n", "def mandelbrot_dsl(cr, ci, max_iter):\n", @@ -136,19 +85,14 @@ " raise RuntimeError(\"DSL extraction failed. Re-run this cell in a file-backed notebook session.\")\n", "\n", "print(mandelbrot_dsl.dsl_source)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 4, "id": "numba-kernel", - "metadata": { - "ExecuteTime": { - "end_time": "2026-02-07T07:02:24.103853Z", - "start_time": "2026-02-07T07:02:24.083437Z" - } - }, - "outputs": [], + "metadata": {}, "source": [ "@njit(parallel=True, fastmath=False)\n", "def mandelbrot_numba_native(cr, ci, max_iter):\n", @@ -199,41 +143,14 @@ " zr = zr_new\n", " zi = zi_new\n", " output[iy, ix] = escape_iter" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 5, "id": "benchmark", - "metadata": { - "ExecuteTime": { - "end_time": "2026-02-07T07:02:27.052865Z", - "start_time": "2026-02-07T07:02:24.104692Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "First iteration timings (one-time overhead included):\n", - "Native numba first run (baseline): 0.457351 s\n", - "Blosc2+numba first run: 0.287874 s\n", - "Blosc2+DSL first run: 0.343547 s\n", - "\n", - "Best-time stats:\n", - "Native numba time (best): 0.051693 s\n", - "Blosc2+numba time (best): 0.056486 s\n", - "Blosc2+DSL time (best): 0.317045 s\n", - "Blosc2+numba / native: 1.09x\n", - "Blosc2+DSL / native: 6.13x\n", - "Blosc2+DSL / Blosc2+numba: 5.61x\n", - "max |dsl-b2_numba|: 0.000000\n", - "max |native-b2_numba|: 0.000000\n", - "max |native-dsl|: 0.000000\n" - ] - } - ], + "metadata": {}, "source": [ "def best_time(func, repeats=3, warmup=1):\n", " for _ in range(warmup):\n", @@ -301,33 +218,14 @@ "print(f\"max |dsl-b2_numba|: {max_abs_diff_dsl_vs_b2_numba:.6f}\")\n", "print(f\"max |native-b2_numba|: {max_abs_diff_native_vs_b2_numba:.6f}\")\n", "print(f\"max |native-dsl|: {max_abs_diff_native_vs_dsl:.6f}\")" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 6, "id": "plot", - "metadata": { - "ExecuteTime": { - "end_time": "2026-02-07T07:02:27.524673Z", - "start_time": "2026-02-07T07:02:27.073130Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "jetTransient": { - "display_id": null - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "metadata": {}, "source": [ "fig, ax = plt.subplots(1, 2, figsize=(13, 5), constrained_layout=True)\n", "\n", @@ -368,33 +266,14 @@ "fig.colorbar(im_base, ax=ax, shrink=0.82, label=\"Escape iteration\")\n", "\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 7, "id": "timing-bars", - "metadata": { - "ExecuteTime": { - "end_time": "2026-02-07T07:02:27.612828Z", - "start_time": "2026-02-07T07:02:27.534390Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "jetTransient": { - "display_id": null - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "metadata": {}, "source": [ "labels = [\"Native Numba (baseline)\", \"Blosc2+Numba\", \"Blosc2+DSL\"]\n", "first_times = [t_numba_native_first, t_b2_numba_first, t_dsl_first]\n", @@ -419,7 +298,9 @@ " ax.text(i + width / 2, t, f\"{t:.3f}s\", ha=\"center\", va=\"bottom\")\n", "\n", "plt.show()" - ] + ], + "outputs": [], + "execution_count": null } ], "metadata": {