diff --git a/pallasbench/kernels/level1/add_op.py b/pallasbench/kernels/level1/add_op.py index f219255..dc6e7ad 100644 --- a/pallasbench/kernels/level1/add_op.py +++ b/pallasbench/kernels/level1/add_op.py @@ -19,18 +19,19 @@ def _add_kernel(x_ref, y_ref, o_ref): def pallas_add(x: jax.Array, y: jax.Array) -> jax.Array: n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size + bm = min(128, n) + bn = min(128, x.shape[1]) if x.ndim > 1 else 1 + grid = (n // bm, x.shape[1] // bn) if x.ndim > 1 else (n // bm,) return pl.pallas_call( _add_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), + grid=grid, in_specs=[ - pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), - pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + pl.BlockSpec((bm, bn), lambda i, j: (i, j)), + pl.BlockSpec((bm, bn), lambda i, j: (i, j)), ], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + out_specs=pl.BlockSpec((bm, bn), lambda i, j: (i, j)), )(x, y) diff --git a/pallasbench/kernels/level1/batched_matmul.py b/pallasbench/kernels/level1/batched_matmul.py index ec707ab..32570ee 100644 --- a/pallasbench/kernels/level1/batched_matmul.py +++ b/pallasbench/kernels/level1/batched_matmul.py @@ -20,15 +20,17 @@ def pallas_batched_matmul(x: jax.Array, y: jax.Array) -> jax.Array: batch, m, k = x.shape _, _, n = y.shape + bm_ = min(32, m) + bn_ = min(32, n) return pl.pallas_call( _batched_matmul_kernel, out_shape=jax.ShapeDtypeStruct((batch, m, n), x.dtype), - grid=(batch,), + grid=(batch, m // bm_, n // bn_), in_specs=[ - pl.BlockSpec((1, m, k), lambda b: (b, 0, 0)), - pl.BlockSpec((1, k, n), lambda b: (b, 0, 0)), + pl.BlockSpec((1, bm_, k), lambda b, i, j: (b, i, 0)), + pl.BlockSpec((1, k, bn_), lambda b, i, j: (b, 0, j)), ], - out_specs=pl.BlockSpec((1, m, n), lambda b: (b, 0, 0)), + out_specs=pl.BlockSpec((1, bm_, bn_), lambda b, i, j: (b, i, j)), )(x, y) diff --git a/pallasbench/kernels/level1/clamp.py b/pallasbench/kernels/level1/clamp.py index 88e68f4..717727d 100644 --- a/pallasbench/kernels/level1/clamp.py +++ b/pallasbench/kernels/level1/clamp.py @@ -18,16 +18,21 @@ def _clamp_kernel(x_ref, o_ref): def pallas_clamp(x: jax.Array) -> jax.Array: - n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size - + bm = min(128, x.shape[0]) + bn = min(128, x.shape[1]) if x.ndim > 1 else x.shape[0] + grid = (x.shape[0] // bm, x.shape[1] // bn) if x.ndim > 1 else (x.shape[0] // bm,) + if x.ndim > 1: + in_sp = [pl.BlockSpec((bm, bn), lambda i, j: (i, j))] + out_sp = pl.BlockSpec((bm, bn), lambda i, j: (i, j)) + else: + in_sp = [pl.BlockSpec((bm,), lambda i: (i,))] + out_sp = pl.BlockSpec((bm,), lambda i: (i,)) return pl.pallas_call( _clamp_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), - in_specs=[pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1))))], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + grid=grid, + in_specs=in_sp, + out_specs=out_sp, )(x) diff --git a/pallasbench/kernels/level1/cosine_sim.py b/pallasbench/kernels/level1/cosine_sim.py index 660c066..43d3f83 100644 --- a/pallasbench/kernels/level1/cosine_sim.py +++ b/pallasbench/kernels/level1/cosine_sim.py @@ -26,6 +26,8 @@ def pallas_cosine_sim(x: jax.Array, y: jax.Array) -> jax.Array: n_rows = x.shape[0] n_cols = x.shape[1] block_rows = min(256, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/cross_entropy.py b/pallasbench/kernels/level1/cross_entropy.py index 7643fd5..0dac1eb 100644 --- a/pallasbench/kernels/level1/cross_entropy.py +++ b/pallasbench/kernels/level1/cross_entropy.py @@ -27,6 +27,8 @@ def pallas_cross_entropy(logits: jax.Array, labels: jax.Array) -> jax.Array: n_rows = logits.shape[0] n_cols = logits.shape[1] block_rows = min(128, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/exp_op.py b/pallasbench/kernels/level1/exp_op.py index 835748d..c4eab09 100644 --- a/pallasbench/kernels/level1/exp_op.py +++ b/pallasbench/kernels/level1/exp_op.py @@ -19,15 +19,16 @@ def _exp_kernel(x_ref, o_ref): def pallas_exp(x: jax.Array) -> jax.Array: n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size + bm = min(128, n) + bn = min(128, x.shape[1]) if x.ndim > 1 else 1 + grid = (n // bm, x.shape[1] // bn) if x.ndim > 1 else (n // bm,) return pl.pallas_call( _exp_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), - in_specs=[pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1))))], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + grid=grid, + in_specs=[pl.BlockSpec((bm, bn), lambda i, j: (i, j))], + out_specs=pl.BlockSpec((bm, bn), lambda i, j: (i, j)), )(x) diff --git a/pallasbench/kernels/level1/gelu.py b/pallasbench/kernels/level1/gelu.py index 6e4867a..4316a63 100644 --- a/pallasbench/kernels/level1/gelu.py +++ b/pallasbench/kernels/level1/gelu.py @@ -20,16 +20,21 @@ def _gelu_kernel(x_ref, o_ref): def pallas_gelu(x: jax.Array) -> jax.Array: - n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size - + bm = min(128, x.shape[0]) + bn = min(128, x.shape[1]) if x.ndim > 1 else x.shape[0] + grid = (x.shape[0] // bm, x.shape[1] // bn) if x.ndim > 1 else (x.shape[0] // bm,) + if x.ndim > 1: + in_sp = [pl.BlockSpec((bm, bn), lambda i, j: (i, j))] + out_sp = pl.BlockSpec((bm, bn), lambda i, j: (i, j)) + else: + in_sp = [pl.BlockSpec((bm,), lambda i: (i,))] + out_sp = pl.BlockSpec((bm,), lambda i: (i,)) return pl.pallas_call( _gelu_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), - in_specs=[pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1))))], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + grid=grid, + in_specs=in_sp, + out_specs=out_sp, )(x) diff --git a/pallasbench/kernels/level1/layernorm.py b/pallasbench/kernels/level1/layernorm.py index 6e8153e..05b953f 100644 --- a/pallasbench/kernels/level1/layernorm.py +++ b/pallasbench/kernels/level1/layernorm.py @@ -23,6 +23,8 @@ def pallas_layernorm(x: jax.Array) -> jax.Array: n_rows = x.shape[0] block_rows = min(128, n_rows) n_cols = x.shape[1] + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/log_op.py b/pallasbench/kernels/level1/log_op.py index 57d9ffc..6092ed3 100644 --- a/pallasbench/kernels/level1/log_op.py +++ b/pallasbench/kernels/level1/log_op.py @@ -19,15 +19,16 @@ def _log_kernel(x_ref, o_ref): def pallas_log(x: jax.Array) -> jax.Array: n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size + bm = min(128, n) + bn = min(128, x.shape[1]) if x.ndim > 1 else 1 + grid = (n // bm, x.shape[1] // bn) if x.ndim > 1 else (n // bm,) return pl.pallas_call( _log_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), - in_specs=[pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1))))], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + grid=grid, + in_specs=[pl.BlockSpec((bm, bn), lambda i, j: (i, j))], + out_specs=pl.BlockSpec((bm, bn), lambda i, j: (i, j)), )(x) diff --git a/pallasbench/kernels/level1/log_softmax.py b/pallasbench/kernels/level1/log_softmax.py index 962c2ff..47c173f 100644 --- a/pallasbench/kernels/level1/log_softmax.py +++ b/pallasbench/kernels/level1/log_softmax.py @@ -25,6 +25,8 @@ def pallas_log_softmax(x: jax.Array) -> jax.Array: n_rows = x.shape[0] n_cols = x.shape[1] block_rows = min(128, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/matmul.py b/pallasbench/kernels/level1/matmul.py index d68b03c..e2b3b06 100644 --- a/pallasbench/kernels/level1/matmul.py +++ b/pallasbench/kernels/level1/matmul.py @@ -20,8 +20,8 @@ def _matmul_kernel(x_ref, y_ref, o_ref): def pallas_matmul(x: jax.Array, y: jax.Array) -> jax.Array: m, k = x.shape _, n = y.shape - bm = min(512, m) - bn = min(512, n) + bm = min(16, m) + bn = min(16, n) grid = (m // bm, n // bn) return pl.pallas_call( diff --git a/pallasbench/kernels/level1/mse_loss.py b/pallasbench/kernels/level1/mse_loss.py index e460713..c0cf653 100644 --- a/pallasbench/kernels/level1/mse_loss.py +++ b/pallasbench/kernels/level1/mse_loss.py @@ -22,6 +22,8 @@ def pallas_mse_loss(pred: jax.Array, target: jax.Array) -> jax.Array: n_rows = pred.shape[0] n_cols = pred.shape[1] block_rows = min(256, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/multiply_op.py b/pallasbench/kernels/level1/multiply_op.py index 6c7bc6a..f893dce 100644 --- a/pallasbench/kernels/level1/multiply_op.py +++ b/pallasbench/kernels/level1/multiply_op.py @@ -19,18 +19,19 @@ def _multiply_kernel(x_ref, y_ref, o_ref): def pallas_multiply(x: jax.Array, y: jax.Array) -> jax.Array: n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size + bm = min(128, n) + bn = min(128, x.shape[1]) if x.ndim > 1 else 1 + grid = (n // bm, x.shape[1] // bn) if x.ndim > 1 else (n // bm,) return pl.pallas_call( _multiply_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), + grid=grid, in_specs=[ - pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), - pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + pl.BlockSpec((bm, bn), lambda i, j: (i, j)), + pl.BlockSpec((bm, bn), lambda i, j: (i, j)), ], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + out_specs=pl.BlockSpec((bm, bn), lambda i, j: (i, j)), )(x, y) diff --git a/pallasbench/kernels/level1/reduce_max.py b/pallasbench/kernels/level1/reduce_max.py index f14a255..cdb37cb 100644 --- a/pallasbench/kernels/level1/reduce_max.py +++ b/pallasbench/kernels/level1/reduce_max.py @@ -21,6 +21,8 @@ def pallas_reduce_max(x: jax.Array) -> jax.Array: n_rows = x.shape[0] n_cols = x.shape[1] block_rows = min(256, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/reduce_mean.py b/pallasbench/kernels/level1/reduce_mean.py index b00d88f..32e94ad 100644 --- a/pallasbench/kernels/level1/reduce_mean.py +++ b/pallasbench/kernels/level1/reduce_mean.py @@ -21,6 +21,8 @@ def pallas_reduce_mean(x: jax.Array) -> jax.Array: n_rows = x.shape[0] n_cols = x.shape[1] block_rows = min(256, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/reduce_sum.py b/pallasbench/kernels/level1/reduce_sum.py index acbbb9b..7fcd22d 100644 --- a/pallasbench/kernels/level1/reduce_sum.py +++ b/pallasbench/kernels/level1/reduce_sum.py @@ -20,6 +20,8 @@ def pallas_reduce_sum(x: jax.Array) -> jax.Array: n_rows = x.shape[0] n_cols = x.shape[1] block_rows = min(256, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/relu.py b/pallasbench/kernels/level1/relu.py index 17e49a0..83b5ada 100644 --- a/pallasbench/kernels/level1/relu.py +++ b/pallasbench/kernels/level1/relu.py @@ -18,16 +18,21 @@ def _relu_kernel(x_ref, o_ref): def pallas_relu(x: jax.Array) -> jax.Array: - n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size - + bm = min(128, x.shape[0]) + bn = min(128, x.shape[1]) if x.ndim > 1 else x.shape[0] + grid = (x.shape[0] // bm, x.shape[1] // bn) if x.ndim > 1 else (x.shape[0] // bm,) + if x.ndim > 1: + in_sp = [pl.BlockSpec((bm, bn), lambda i, j: (i, j))] + out_sp = pl.BlockSpec((bm, bn), lambda i, j: (i, j)) + else: + in_sp = [pl.BlockSpec((bm,), lambda i: (i,))] + out_sp = pl.BlockSpec((bm,), lambda i: (i,)) return pl.pallas_call( _relu_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), - in_specs=[pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1))))], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + grid=grid, + in_specs=in_sp, + out_specs=out_sp, )(x) diff --git a/pallasbench/kernels/level1/rmsnorm.py b/pallasbench/kernels/level1/rmsnorm.py index 5ecdc40..430ccab 100644 --- a/pallasbench/kernels/level1/rmsnorm.py +++ b/pallasbench/kernels/level1/rmsnorm.py @@ -23,6 +23,8 @@ def pallas_rmsnorm(x: jax.Array) -> jax.Array: n_rows = x.shape[0] block_rows = min(128, n_rows) n_cols = x.shape[1] + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/rsqrt_op.py b/pallasbench/kernels/level1/rsqrt_op.py index 487cedb..e0498bd 100644 --- a/pallasbench/kernels/level1/rsqrt_op.py +++ b/pallasbench/kernels/level1/rsqrt_op.py @@ -18,15 +18,16 @@ def _rsqrt_kernel(x_ref, o_ref): def pallas_rsqrt(x: jax.Array) -> jax.Array: n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size + bm = min(128, n) + bn = min(128, x.shape[1]) if x.ndim > 1 else 1 + grid = (n // bm, x.shape[1] // bn) if x.ndim > 1 else (n // bm,) return pl.pallas_call( _rsqrt_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), - in_specs=[pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1))))], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + grid=grid, + in_specs=[pl.BlockSpec((bm, bn), lambda i, j: (i, j))], + out_specs=pl.BlockSpec((bm, bn), lambda i, j: (i, j)), )(x) diff --git a/pallasbench/kernels/level1/sigmoid.py b/pallasbench/kernels/level1/sigmoid.py index 5a72a64..4024c5f 100644 --- a/pallasbench/kernels/level1/sigmoid.py +++ b/pallasbench/kernels/level1/sigmoid.py @@ -18,16 +18,21 @@ def _sigmoid_kernel(x_ref, o_ref): def pallas_sigmoid(x: jax.Array) -> jax.Array: - n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size - + bm = min(128, x.shape[0]) + bn = min(128, x.shape[1]) if x.ndim > 1 else x.shape[0] + grid = (x.shape[0] // bm, x.shape[1] // bn) if x.ndim > 1 else (x.shape[0] // bm,) + if x.ndim > 1: + in_sp = [pl.BlockSpec((bm, bn), lambda i, j: (i, j))] + out_sp = pl.BlockSpec((bm, bn), lambda i, j: (i, j)) + else: + in_sp = [pl.BlockSpec((bm,), lambda i: (i,))] + out_sp = pl.BlockSpec((bm,), lambda i: (i,)) return pl.pallas_call( _sigmoid_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), - in_specs=[pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1))))], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + grid=grid, + in_specs=in_sp, + out_specs=out_sp, )(x) diff --git a/pallasbench/kernels/level1/silu.py b/pallasbench/kernels/level1/silu.py index 2821845..bdd4d99 100644 --- a/pallasbench/kernels/level1/silu.py +++ b/pallasbench/kernels/level1/silu.py @@ -18,16 +18,21 @@ def _silu_kernel(x_ref, o_ref): def pallas_silu(x: jax.Array) -> jax.Array: - n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size - + bm = min(128, x.shape[0]) + bn = min(128, x.shape[1]) if x.ndim > 1 else x.shape[0] + grid = (x.shape[0] // bm, x.shape[1] // bn) if x.ndim > 1 else (x.shape[0] // bm,) + if x.ndim > 1: + in_sp = [pl.BlockSpec((bm, bn), lambda i, j: (i, j))] + out_sp = pl.BlockSpec((bm, bn), lambda i, j: (i, j)) + else: + in_sp = [pl.BlockSpec((bm,), lambda i: (i,))] + out_sp = pl.BlockSpec((bm,), lambda i: (i,)) return pl.pallas_call( _silu_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), - in_specs=[pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1))))], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + grid=grid, + in_specs=in_sp, + out_specs=out_sp, )(x) diff --git a/pallasbench/kernels/level1/softmax.py b/pallasbench/kernels/level1/softmax.py index 0a4d3e7..333f5a3 100644 --- a/pallasbench/kernels/level1/softmax.py +++ b/pallasbench/kernels/level1/softmax.py @@ -27,6 +27,8 @@ def pallas_softmax(x: jax.Array) -> jax.Array: n_rows = x.shape[0] block_rows = min(128, n_rows) n_cols = x.shape[1] + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level1/tanh_act.py b/pallasbench/kernels/level1/tanh_act.py index a4fbd69..fb9271e 100644 --- a/pallasbench/kernels/level1/tanh_act.py +++ b/pallasbench/kernels/level1/tanh_act.py @@ -18,15 +18,16 @@ def _tanh_kernel(x_ref, o_ref): def pallas_tanh(x: jax.Array) -> jax.Array: n = x.shape[0] - block_size = min(1024, n) - grid_size = n // block_size + bm = min(128, n) + bn = min(128, x.shape[1]) if x.ndim > 1 else 1 + grid = (n // bm, x.shape[1] // bn) if x.ndim > 1 else (n // bm,) return pl.pallas_call( _tanh_kernel, out_shape=jax.ShapeDtypeStruct(x.shape, x.dtype), - grid=(grid_size,), - in_specs=[pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1))))], - out_specs=pl.BlockSpec((block_size, *x.shape[1:]), lambda i: (i, *([0] * (x.ndim - 1)))), + grid=grid, + in_specs=[pl.BlockSpec((bm, bn), lambda i, j: (i, j))], + out_specs=pl.BlockSpec((bm, bn), lambda i, j: (i, j)), )(x) diff --git a/pallasbench/kernels/level2/fused_softmax_cross_entropy.py b/pallasbench/kernels/level2/fused_softmax_cross_entropy.py index b2f9f2a..aafaacc 100644 --- a/pallasbench/kernels/level2/fused_softmax_cross_entropy.py +++ b/pallasbench/kernels/level2/fused_softmax_cross_entropy.py @@ -29,6 +29,8 @@ def pallas_fused_softmax_cross_entropy( n_rows = logits.shape[0] n_cols = logits.shape[1] block_rows = min(128, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level2/geglu.py b/pallasbench/kernels/level2/geglu.py index a85d030..73bd149 100644 --- a/pallasbench/kernels/level2/geglu.py +++ b/pallasbench/kernels/level2/geglu.py @@ -26,18 +26,19 @@ def _geglu_kernel(x_ref, w_gate_ref, w_up_ref, o_ref): def pallas_geglu(x: jax.Array, w_gate: jax.Array, w_up: jax.Array) -> jax.Array: m, k = x.shape _, n = w_gate.shape - bm = min(256, m) + bm = min(16, m) + bn = min(16, n) return pl.pallas_call( _geglu_kernel, out_shape=jax.ShapeDtypeStruct((m, n), x.dtype), - grid=(m // bm,), + grid=(m // bm, n // bn), in_specs=[ - pl.BlockSpec((bm, k), lambda i: (i, 0)), - pl.BlockSpec((k, n), lambda i: (0, 0)), - pl.BlockSpec((k, n), lambda i: (0, 0)), + pl.BlockSpec((bm, k), lambda i, j: (i, 0)), + pl.BlockSpec((k, bn), lambda i, j: (0, j)), + pl.BlockSpec((k, bn), lambda i, j: (0, j)), ], - out_specs=pl.BlockSpec((bm, n), lambda i: (i, 0)), + out_specs=pl.BlockSpec((bm, bn), lambda i, j: (i, j)), )(x, w_gate, w_up) diff --git a/pallasbench/kernels/level2/layernorm_residual.py b/pallasbench/kernels/level2/layernorm_residual.py index cf77840..d3327f6 100644 --- a/pallasbench/kernels/level2/layernorm_residual.py +++ b/pallasbench/kernels/level2/layernorm_residual.py @@ -26,6 +26,8 @@ def pallas_layernorm_residual(x: jax.Array, residual: jax.Array) -> jax.Array: n_rows = x.shape[0] n_cols = x.shape[1] block_rows = min(128, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level2/linear_bias_relu.py b/pallasbench/kernels/level2/linear_bias_relu.py index 3a594a2..563ab36 100644 --- a/pallasbench/kernels/level2/linear_bias_relu.py +++ b/pallasbench/kernels/level2/linear_bias_relu.py @@ -21,18 +21,19 @@ def _linear_bias_relu_kernel(x_ref, w_ref, b_ref, o_ref): def pallas_linear_bias_relu(x: jax.Array, w: jax.Array, b: jax.Array) -> jax.Array: m, k = x.shape _, n = w.shape - bm = min(512, m) + bm = min(32, m) + bn = min(32, n) return pl.pallas_call( _linear_bias_relu_kernel, out_shape=jax.ShapeDtypeStruct((m, n), x.dtype), - grid=(m // bm,), + grid=(m // bm, n // bn), in_specs=[ - pl.BlockSpec((bm, k), lambda i: (i, 0)), - pl.BlockSpec((k, n), lambda i: (0, 0)), - pl.BlockSpec((n,), lambda i: (0,)), + pl.BlockSpec((bm, k), lambda i, j: (i, 0)), + pl.BlockSpec((k, bn), lambda i, j: (0, j)), + pl.BlockSpec((bn,), lambda i, j: (j,)), ], - out_specs=pl.BlockSpec((bm, n), lambda i: (i, 0)), + out_specs=pl.BlockSpec((bm, bn), lambda i, j: (i, j)), )(x, w, b) diff --git a/pallasbench/kernels/level2/matmul_gelu.py b/pallasbench/kernels/level2/matmul_gelu.py index eb6a4da..1bd2637 100644 --- a/pallasbench/kernels/level2/matmul_gelu.py +++ b/pallasbench/kernels/level2/matmul_gelu.py @@ -23,8 +23,8 @@ def _matmul_gelu_kernel(x_ref, w_ref, o_ref): def pallas_matmul_gelu(x: jax.Array, w: jax.Array) -> jax.Array: m, k = x.shape _, n = w.shape - bm = min(512, m) - bn = min(512, n) + bm = min(16, m) + bn = min(16, n) grid = (m // bm, n // bn) return pl.pallas_call( diff --git a/pallasbench/kernels/level2/matmul_relu.py b/pallasbench/kernels/level2/matmul_relu.py index 5c74afa..955e471 100644 --- a/pallasbench/kernels/level2/matmul_relu.py +++ b/pallasbench/kernels/level2/matmul_relu.py @@ -21,8 +21,8 @@ def _matmul_relu_kernel(x_ref, w_ref, o_ref): def pallas_matmul_relu(x: jax.Array, w: jax.Array) -> jax.Array: m, k = x.shape _, n = w.shape - bm = min(512, m) - bn = min(512, n) + bm = min(16, m) + bn = min(16, n) grid = (m // bm, n // bn) return pl.pallas_call( diff --git a/pallasbench/kernels/level2/matmul_silu.py b/pallasbench/kernels/level2/matmul_silu.py index e72c80b..f79d68b 100644 --- a/pallasbench/kernels/level2/matmul_silu.py +++ b/pallasbench/kernels/level2/matmul_silu.py @@ -21,8 +21,8 @@ def _matmul_silu_kernel(x_ref, w_ref, o_ref): def pallas_matmul_silu(x: jax.Array, w: jax.Array) -> jax.Array: m, k = x.shape _, n = w.shape - bm = min(512, m) - bn = min(512, n) + bm = min(16, m) + bn = min(16, n) grid = (m // bm, n // bn) return pl.pallas_call( diff --git a/pallasbench/kernels/level2/qk_softmax.py b/pallasbench/kernels/level2/qk_softmax.py index 818b05a..d80c2a5 100644 --- a/pallasbench/kernels/level2/qk_softmax.py +++ b/pallasbench/kernels/level2/qk_softmax.py @@ -26,6 +26,8 @@ def _qk_softmax_kernel(q_ref, k_ref, o_ref): def pallas_qk_softmax(q: jax.Array, k: jax.Array) -> jax.Array: seq_len, d_model = q.shape block_q = min(128, seq_len) + while block_q * d_model > 16384 and block_q > 1: + block_q //= 2 grid_size = seq_len // block_q return pl.pallas_call( diff --git a/pallasbench/kernels/level2/rmsnorm_residual.py b/pallasbench/kernels/level2/rmsnorm_residual.py index 47219b1..53fea64 100644 --- a/pallasbench/kernels/level2/rmsnorm_residual.py +++ b/pallasbench/kernels/level2/rmsnorm_residual.py @@ -28,6 +28,8 @@ def pallas_rmsnorm_residual( n_rows = x.shape[0] n_cols = x.shape[1] block_rows = min(128, n_rows) + while block_rows * n_cols > 16384 and block_rows > 1: + block_rows //= 2 grid_size = n_rows // block_rows return pl.pallas_call( diff --git a/pallasbench/kernels/level2/sigmoid_bce.py b/pallasbench/kernels/level2/sigmoid_bce.py index 32f08db..3b43ef5 100644 --- a/pallasbench/kernels/level2/sigmoid_bce.py +++ b/pallasbench/kernels/level2/sigmoid_bce.py @@ -23,7 +23,10 @@ def _sigmoid_bce_kernel(logits_ref, targets_ref, o_ref): def pallas_sigmoid_bce(logits: jax.Array, targets: jax.Array) -> jax.Array: n = logits.shape[0] - block_size = min(1024, n) + cols = 1 + for s in logits.shape[1:]: + cols *= s + block_size = min(min(128, n), max(1, 16384 // cols)) grid_size = n // block_size return pl.pallas_call( diff --git a/pallasbench/kernels/level2/swiglu.py b/pallasbench/kernels/level2/swiglu.py index df7ae22..13c5cdc 100644 --- a/pallasbench/kernels/level2/swiglu.py +++ b/pallasbench/kernels/level2/swiglu.py @@ -28,18 +28,19 @@ def pallas_swiglu( ) -> jax.Array: m, k = x.shape _, n = w_gate.shape - bm = min(256, m) + bm = min(16, m) + bn = min(16, n) return pl.pallas_call( _swiglu_kernel, out_shape=jax.ShapeDtypeStruct((m, n), x.dtype), - grid=(m // bm,), + grid=(m // bm, n // bn), in_specs=[ - pl.BlockSpec((bm, k), lambda i: (i, 0)), - pl.BlockSpec((k, n), lambda i: (0, 0)), - pl.BlockSpec((k, n), lambda i: (0, 0)), + pl.BlockSpec((bm, k), lambda i, j: (i, 0)), + pl.BlockSpec((k, bn), lambda i, j: (0, j)), + pl.BlockSpec((k, bn), lambda i, j: (0, j)), ], - out_specs=pl.BlockSpec((bm, n), lambda i: (i, 0)), + out_specs=pl.BlockSpec((bm, bn), lambda i, j: (i, j)), )(x, w_gate, w_up) diff --git a/pallasbench/kernels/level3/flash_attention.py b/pallasbench/kernels/level3/flash_attention.py index b31f663..35882e4 100644 --- a/pallasbench/kernels/level3/flash_attention.py +++ b/pallasbench/kernels/level3/flash_attention.py @@ -38,7 +38,7 @@ def pallas_flash_attention( q: jax.Array, k: jax.Array, v: jax.Array ) -> jax.Array: seq_len, d_model = q.shape - block_q = min(128, seq_len) + block_q = min(32, seq_len) grid_size = seq_len // block_q return pl.pallas_call( diff --git a/pallasbench/kernels/level3/gated_mlp.py b/pallasbench/kernels/level3/gated_mlp.py index 037c029..6f2015c 100644 --- a/pallasbench/kernels/level3/gated_mlp.py +++ b/pallasbench/kernels/level3/gated_mlp.py @@ -28,7 +28,7 @@ def pallas_gated_mlp( ) -> jax.Array: m, d_model = x.shape _, d_ff = w_gate.shape - bm = min(256, m) + bm = min(8, m) return pl.pallas_call( _gated_mlp_kernel, diff --git a/pallasbench/kernels/level3/multi_head_attention.py b/pallasbench/kernels/level3/multi_head_attention.py index df8ed09..1bb3857 100644 --- a/pallasbench/kernels/level3/multi_head_attention.py +++ b/pallasbench/kernels/level3/multi_head_attention.py @@ -30,16 +30,17 @@ def pallas_multi_head_attention( ) -> jax.Array: n_heads, seq_len, d_head = q.shape + bq = min(32, seq_len) return pl.pallas_call( _mha_kernel, out_shape=jax.ShapeDtypeStruct(q.shape, q.dtype), - grid=(n_heads,), + grid=(n_heads, seq_len // bq), in_specs=[ - pl.BlockSpec((1, seq_len, d_head), lambda h: (h, 0, 0)), - pl.BlockSpec((1, seq_len, d_head), lambda h: (h, 0, 0)), - pl.BlockSpec((1, seq_len, d_head), lambda h: (h, 0, 0)), + pl.BlockSpec((1, bq, d_head), lambda h, i: (h, i, 0)), + pl.BlockSpec((1, seq_len, d_head), lambda h, i: (h, 0, 0)), + pl.BlockSpec((1, seq_len, d_head), lambda h, i: (h, 0, 0)), ], - out_specs=pl.BlockSpec((1, seq_len, d_head), lambda h: (h, 0, 0)), + out_specs=pl.BlockSpec((1, bq, d_head), lambda h, i: (h, i, 0)), )(q, k, v)