all_fixes_final.patch

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)