From e421266ad63d4e1c3798ec8be96398241c1d7228 Mon Sep 17 00:00:00 2001
From: Anjali Pal <anjalip@cs.washington.edu>
Date: Thu, 20 Feb 2025 09:53:10 -0800
Subject: [PATCH] small instead of medium

---
 .../polybench/datamining/correlation.rs       | 34 ++++++++---------
 .../polybench/datamining/covariance.rs        | 30 +++++++--------
 .../passing/polybench/medley/deriche.rs       | 38 +++++++++----------
 .../polybench/medley/floyd-warshall.rs        | 14 +++----
 .../passing/polybench/medley/nussinov.rs      | 16 ++++----
 benchmarks/passing/polybench/stencils/adi.rs  | 38 +++++++++----------
 .../passing/polybench/stencils/heat-3d.rs     | 30 +++++++--------
 .../passing/polybench/stencils/jacobi-1d.rs   | 16 ++++----
 .../passing/polybench/stencils/jacobi-2d.rs   | 22 +++++------
 .../passing/polybench/stencils/seidel-2d.rs   | 18 ++++-----
 10 files changed, 128 insertions(+), 128 deletions(-)

diff --git a/benchmarks/passing/polybench/datamining/correlation.rs b/benchmarks/passing/polybench/datamining/correlation.rs
index 388c64eb3..5c2a96f15 100644
--- a/benchmarks/passing/polybench/datamining/correlation.rs
+++ b/benchmarks/passing/polybench/datamining/correlation.rs
@@ -8,7 +8,7 @@ fn custom_sqrt(x: f64) -> f64 {
     return guess;
 }
 
-fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
+fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 80]; 100]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -25,7 +25,7 @@ fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
     }
 }
 
-fn sum_array(m: i64, corr: &[[f64; 240]; 240]) -> f64 {
+fn sum_array(m: i64, corr: &[[f64; 80]; 80]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < m {
@@ -47,10 +47,10 @@ fn kernel_correlation(
     m: i64,
     n: i64,
     nf: f64,
-    data: &mut [[f64; 240]; 260],
-    corr: &mut [[f64; 240]; 240],
-    mean: &mut [f64; 240],
-    stddev: &mut [f64; 240],
+    data: &mut [[f64; 80]; 100],
+    corr: &mut [[f64; 80]; 80],
+    mean: &mut [f64; 80],
+    stddev: &mut [f64; 80],
 ) {
     let eps: f64 = 0.1;
     let mut j: i64 = 0;
@@ -119,25 +119,25 @@ fn kernel_correlation(
 }
 
 fn main() {
-    let n: i64 = 260;
-    let nf: f64 = 260.0;
-    let m: i64 = 240;
-    let mf: f64 = 240.0;
-    let mut dummy: [f64; 240] = [0.0; 240];
-    let mut data: [[f64; 240]; 260] = [dummy; 260];
-    let mut corr: [[f64; 240]; 240] = [dummy; 240];
-    let mut mean: [f64; 240] = [0.0; 240];
-    let mut stddev: [f64; 240] = [0.0; 240];
+    let n: i64 = 100;
+    let nf: f64 = 100.0;
+    let m: i64 = 80;
+    let mf: f64 = 80.0;
+    let mut dummy: [f64; 80] = [0.0; 80];
+    let mut data: [[f64; 80]; 100] = [dummy; 100];
+    let mut corr: [[f64; 80]; 80] = [dummy; 80];
+    let mut mean: [f64; 80] = [0.0; 80];
+    let mut stddev: [f64; 80] = [0.0; 80];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        data[i] = [0.0; 240];
+        data[i] = [0.0; 80];
         i += 1;
     }
     i = 0;
     while i < m {
-        corr[i] = [0.0; 240];
+        corr[i] = [0.0; 80];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/datamining/covariance.rs b/benchmarks/passing/polybench/datamining/covariance.rs
index 40b58a0c7..b41428fec 100644
--- a/benchmarks/passing/polybench/datamining/covariance.rs
+++ b/benchmarks/passing/polybench/datamining/covariance.rs
@@ -1,4 +1,4 @@
-fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
+fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 80]; 100]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -14,7 +14,7 @@ fn init_array(m: i64, mf: f64, n: i64, data: &mut [[f64; 240]; 260]) {
     }
 }
 
-fn sum_array(m: i64, cov: &[[f64; 240]; 240]) -> f64 {
+fn sum_array(m: i64, cov: &[[f64; 80]; 80]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < m {
@@ -36,9 +36,9 @@ fn kernel_covariance(
     m: i64,
     n: i64,
     nf: f64,
-    data: &mut [[f64; 240]; 260],
-    cov: &mut [[f64; 240]; 240],
-    mean: &mut [f64; 240],
+    data: &mut [[f64; 80]; 100],
+    cov: &mut [[f64; 80]; 80],
+    mean: &mut [f64; 80],
 ) {
     let mut j: i64 = 0;
     while j < m {
@@ -83,24 +83,24 @@ fn kernel_covariance(
 }
 
 fn main() {
-    let n: i64 = 260;
-    let nf: f64 = 260.0;
-    let m: i64 = 240;
-    let mf: f64 = 240.0;
-    let dummy: [f64; 240] = [0.0; 240];
-    let mut data: [[f64; 240]; 260] = [dummy; 260];
-    let mut cov: [[f64; 240]; 240] = [dummy; 240];
-    let mut mean: [f64; 240] = [0.0; 240];
+    let n: i64 = 100;
+    let nf: f64 = 100.0;
+    let m: i64 = 80;
+    let mf: f64 = 80.0;
+    let dummy: [f64; 80] = [0.0; 80];
+    let mut data: [[f64; 80]; 100] = [dummy; 100];
+    let mut cov: [[f64; 80]; 80] = [dummy; 80];
+    let mut mean: [f64; 80] = [0.0; 80];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        data[i] = [0.0; 240];
+        data[i] = [0.0; 80];
         i += 1;
     }
     i = 0;
     while i < m {
-        cov[i] = [0.0; 240];
+        cov[i] = [0.0; 80];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/medley/deriche.rs b/benchmarks/passing/polybench/medley/deriche.rs
index df5c93aeb..2e04ef860 100644
--- a/benchmarks/passing/polybench/medley/deriche.rs
+++ b/benchmarks/passing/polybench/medley/deriche.rs
@@ -9,7 +9,7 @@ fn modulo(a: f64, b: f64) -> f64 {
     return remainder;
 }
 
-fn init_array(w: i64, h: i64, img_in: &mut [[f64; 480]; 720], img_out: &mut [[f64; 480]; 720]) {
+fn init_array(w: i64, h: i64, img_in: &mut [[f64; 128]; 192], img_out: &mut [[f64; 128]; 192]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < w {
@@ -25,7 +25,7 @@ fn init_array(w: i64, h: i64, img_in: &mut [[f64; 480]; 720], img_out: &mut [[f6
     }
 }
 
-fn sum_array(w: i64, h: i64, arr: &[[f64; 480]; 720]) -> f64 {
+fn sum_array(w: i64, h: i64, arr: &[[f64; 128]; 192]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < w {
@@ -61,10 +61,10 @@ fn kernel_deriche(
     w: i64,
     h: i64,
     alpha: f64,
-    img_in: &mut [[f64; 480]; 720],
-    img_out: &mut [[f64; 480]; 720],
-    y1: &mut [[f64; 480]; 720],
-    y2: &mut [[f64; 480]; 720],
+    img_in: &mut [[f64; 128]; 192],
+    img_out: &mut [[f64; 128]; 192],
+    y1: &mut [[f64; 128]; 192],
+    y2: &mut [[f64; 128]; 192],
 ) {
     let k: f64 = (1.0 - custom_exp(-alpha)) * (1.0 - custom_exp(-alpha))
         / (1.0 + 2.0 * alpha * custom_exp(-alpha) - custom_exp(2.0 * alpha));
@@ -75,7 +75,7 @@ fn kernel_deriche(
     let a5: f64 = a1;
     let a6: f64 = a2;
     let a7: f64 = a3;
-    let a480: f64 = a4;
+    let a8: f64 = a4;
     // Doing this in our subset of rust is kinda tricky...
     // Luckily, we know alpha is 0.25, so it's just 2^(-.25)
     // let b1: f64 = pow(2.0, -alpha);
@@ -160,7 +160,7 @@ fn kernel_deriche(
         let mut yp2: f64 = 0.0;
         i = w - 1;
         while i >= 0 {
-            y2[i as usize][j as usize] = a7 * tp1 + a480 * tp2 + b1 * yp1 + b2 * yp2;
+            y2[i as usize][j as usize] = a7 * tp1 + a8 * tp2 + b1 * yp1 + b2 * yp2;
             tp2 = tp1 * 1.0;
             tp1 = img_out[i as usize][j as usize] * 1.0;
             yp2 = yp1 * 1.0;
@@ -183,22 +183,22 @@ fn kernel_deriche(
 }
 
 fn main() {
-    let w: i64 = 720;
-    let h: i64 = 480;
+    let w: i64 = 192;
+    let h: i64 = 128;
     let mut alpha: f64 = 0.25;
-    let dummy: [f64; 480] = [0.0; 480];
-    let mut img_in: [[f64; 480]; 720] = [dummy; 720];
-    let mut img_out: [[f64; 480]; 720] = [dummy; 720];
-    let mut y1: [[f64; 480]; 720] = [dummy; 720];
-    let mut y2: [[f64; 480]; 720] = [dummy; 720];
+    let dummy: [f64; 128] = [0.0; 128];
+    let mut img_in: [[f64; 128]; 192] = [dummy; 192];
+    let mut img_out: [[f64; 128]; 192] = [dummy; 192];
+    let mut y1: [[f64; 128]; 192] = [dummy; 192];
+    let mut y2: [[f64; 128]; 192] = [dummy; 192];
 
     // Init
     let mut i: i64 = 0;
     while i < w {
-        img_in[i] = [0.0; 480];
-        img_out[i] = [0.0; 480];
-        y1[i] = [0.0; 480];
-        y2[i] = [0.0; 480];
+        img_in[i] = [0.0; 128];
+        img_out[i] = [0.0; 128];
+        y1[i] = [0.0; 128];
+        y2[i] = [0.0; 128];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/medley/floyd-warshall.rs b/benchmarks/passing/polybench/medley/floyd-warshall.rs
index 9d3f96285..b0353eb3c 100644
--- a/benchmarks/passing/polybench/medley/floyd-warshall.rs
+++ b/benchmarks/passing/polybench/medley/floyd-warshall.rs
@@ -8,7 +8,7 @@ fn modulo(a: i64, b: i64) -> i64 {
     }
 }
 
-fn init_array(n: i64, path: &mut [[i64; 500]; 500]) {
+fn init_array(n: i64, path: &mut [[i64; 180]; 180]) {
     let mut i: i64 = 0;
     while i < n {
         let mut j: i64 = 0;
@@ -23,7 +23,7 @@ fn init_array(n: i64, path: &mut [[i64; 500]; 500]) {
     }
 }
 
-fn sum_array(n: i64, path: &[[i64; 500]; 500]) -> i64 {
+fn sum_array(n: i64, path: &[[i64; 180]; 180]) -> i64 {
     let mut sum: i64 = 0;
     let mut i: i64 = 0;
     while i < n {
@@ -41,7 +41,7 @@ fn sum_array(n: i64, path: &[[i64; 500]; 500]) -> i64 {
     return sum;
 }
 
-fn kernel_floyd_warshall(n: i64, path: &mut [[i64; 500]; 500]) {
+fn kernel_floyd_warshall(n: i64, path: &mut [[i64; 180]; 180]) {
     let mut k: i64 = 0;
     while k < n {
         let mut i: i64 = 0;
@@ -63,15 +63,15 @@ fn kernel_floyd_warshall(n: i64, path: &mut [[i64; 500]; 500]) {
 }
 
 fn main() {
-    let n: i64 = 500;
+    let n: i64 = 180;
 
-    let dummy: [i64; 500] = [0; 500];
-    let mut path: [[i64; 500]; 500] = [dummy; 500];
+    let dummy: [i64; 180] = [0; 180];
+    let mut path: [[i64; 180]; 180] = [dummy; 180];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        path[i] = [0; 500];
+        path[i] = [0; 180];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/medley/nussinov.rs b/benchmarks/passing/polybench/medley/nussinov.rs
index 8d614fbf8..afff3c59c 100644
--- a/benchmarks/passing/polybench/medley/nussinov.rs
+++ b/benchmarks/passing/polybench/medley/nussinov.rs
@@ -24,7 +24,7 @@ fn match_base(b1: i64, b2: i64) -> i64 {
     }
 }
 
-fn init_array(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500]) {
+fn init_array(n: i64, seq: &mut [i64; 180], table: &mut [[i64; 180]; 180]) {
     let mut i: i64 = 0;
     while i < n {
         seq[i as usize] = modulo(i + 1, 4);
@@ -42,7 +42,7 @@ fn init_array(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500]) {
     }
 }
 
-fn sum_array(n: i64, table: &[[i64; 500]; 500]) -> i64 {
+fn sum_array(n: i64, table: &[[i64; 180]; 180]) -> i64 {
     let mut sum: i64 = 0;
     let mut i: i64 = 0;
     while i < n {
@@ -60,7 +60,7 @@ fn sum_array(n: i64, table: &[[i64; 500]; 500]) -> i64 {
     return sum;
 }
 
-fn kernel_nussinov(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500]) {
+fn kernel_nussinov(n: i64, seq: &mut [i64; 180], table: &mut [[i64; 180]; 180]) {
     let mut i: i64 = n - 1;
     while i >= 0 {
         let mut j: i64 = i + 1;
@@ -106,15 +106,15 @@ fn kernel_nussinov(n: i64, seq: &mut [i64; 500], table: &mut [[i64; 500]; 500])
 }
 
 fn main() {
-    let n: i64 = 500;
-    let mut seq: [i64; 500] = [0; 500];
-    let dummy: [i64; 500] = [0; 500];
-    let mut table: [[i64; 500]; 500] = [dummy; 500];
+    let n: i64 = 180;
+    let mut seq: [i64; 180] = [0; 180];
+    let dummy: [i64; 180] = [0; 180];
+    let mut table: [[i64; 180]; 180] = [dummy; 180];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        table[i] = [0; 500];
+        table[i] = [0; 180];
         i += 1;
     }
     drop(dummy);
diff --git a/benchmarks/passing/polybench/stencils/adi.rs b/benchmarks/passing/polybench/stencils/adi.rs
index e13123db6..09831e733 100644
--- a/benchmarks/passing/polybench/stencils/adi.rs
+++ b/benchmarks/passing/polybench/stencils/adi.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, u: &mut [[f64; 200]; 200]) {
+fn init_array(n: i64, nf: f64, u: &mut [[f64; 60]; 60]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -14,7 +14,7 @@ fn init_array(n: i64, nf: f64, u: &mut [[f64; 200]; 200]) {
     }
 }
 
-fn sum_array(n: i64, u: &[[f64; 200]; 200]) -> f64 {
+fn sum_array(n: i64, u: &[[f64; 60]; 60]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < n {
@@ -37,10 +37,10 @@ fn kernel_adi(
     tstepsf: f64,
     n: i64,
     nf: f64,
-    u: &mut [[f64; 200]; 200],
-    v: &mut [[f64; 200]; 200],
-    p: &mut [[f64; 200]; 200],
-    q: &mut [[f64; 200]; 200],
+    u: &mut [[f64; 60]; 60],
+    v: &mut [[f64; 60]; 60],
+    p: &mut [[f64; 60]; 60],
+    q: &mut [[f64; 60]; 60],
 ) {
     let dx: f64 = 1.0 / nf;
     let dy: f64 = 1.0 / nf;
@@ -81,25 +81,25 @@ fn kernel_adi(
 }
 
 fn main() {
-    let n: i64 = 200;
-    let nf: f64 = 200.0;
-    let tsteps: i64 = 100;
-    let tstepsf: f64 = 100.0;
+    let n: i64 = 60;
+    let nf: f64 = 60.0;
+    let tsteps: i64 = 40;
+    let tstepsf: f64 = 40.0;
 
-    let mut dummy: [f64; 200] = [0.0; 200];
+    let mut dummy: [f64; 60] = [0.0; 60];
 
-    let mut u: [[f64; 200]; 200] = [dummy; 200];
-    let mut v: [[f64; 200]; 200] = [dummy; 200];
-    let mut p: [[f64; 200]; 200] = [dummy; 200];
-    let mut q: [[f64; 200]; 200] = [dummy; 200];
+    let mut u: [[f64; 60]; 60] = [dummy; 60];
+    let mut v: [[f64; 60]; 60] = [dummy; 60];
+    let mut p: [[f64; 60]; 60] = [dummy; 60];
+    let mut q: [[f64; 60]; 60] = [dummy; 60];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        u[i] = [0.0; 200];
-        v[i] = [0.0; 200];
-        p[i] = [0.0; 200];
-        q[i] = [0.0; 200];
+        u[i] = [0.0; 60];
+        v[i] = [0.0; 60];
+        p[i] = [0.0; 60];
+        q[i] = [0.0; 60];
         i += 1;
     }
 
diff --git a/benchmarks/passing/polybench/stencils/heat-3d.rs b/benchmarks/passing/polybench/stencils/heat-3d.rs
index 9f9732193..667391fb7 100644
--- a/benchmarks/passing/polybench/stencils/heat-3d.rs
+++ b/benchmarks/passing/polybench/stencils/heat-3d.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, a: &mut [[[f64; 40]; 40]; 40], b: &mut [[[f64; 40]; 40]; 40]) {
+fn init_array(n: i64, nf: f64, a: &mut [[[f64; 20]; 20]; 20], b: &mut [[[f64; 20]; 20]; 20]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -21,7 +21,7 @@ fn init_array(n: i64, nf: f64, a: &mut [[[f64; 40]; 40]; 40], b: &mut [[[f64; 40
     }
 }
 
-fn sum_array(n: i64, a: &[[[f64; 40]; 40]; 40]) -> f64 {
+fn sum_array(n: i64, a: &[[[f64; 20]; 20]; 20]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < n {
@@ -46,8 +46,8 @@ fn sum_array(n: i64, a: &[[[f64; 40]; 40]; 40]) -> f64 {
 fn kernel_heat_3d(
     tsteps: i64,
     n: i64,
-    a: &mut [[[f64; 40]; 40]; 40],
-    b: &mut [[[f64; 40]; 40]; 40],
+    a: &mut [[[f64; 20]; 20]; 20],
+    b: &mut [[[f64; 20]; 20]; 20],
 ) {
     let mut t: i64 = 1;
     while t <= tsteps {
@@ -107,23 +107,23 @@ fn kernel_heat_3d(
 }
 
 fn main() {
-    let n: i64 = 40;
-    let nf: f64 = 40.0;
-    let tsteps: i64 = 400;
+    let n: i64 = 20;
+    let nf: f64 = 20.0;
+    let tsteps: i64 = 40;
 
-    let inner_dummy: [f64; 40] = [0.0; 40];
-    let dummy: [[f64; 40]; 40] = [inner_dummy; 40];
-    let mut a: [[[f64; 40]; 40]; 40] = [dummy; 40];
-    let mut b: [[[f64; 40]; 40]; 40] = [dummy; 40];
+    let inner_dummy: [f64; 20] = [0.0; 20];
+    let dummy: [[f64; 20]; 20] = [inner_dummy; 20];
+    let mut a: [[[f64; 20]; 20]; 20] = [dummy; 20];
+    let mut b: [[[f64; 20]; 20]; 20] = [dummy; 20];
 
     let mut i: i64 = 0;
     while i < n {
-        let a_elt: [[f64; 40]; 40] = [inner_dummy; 40];
-        let b_elt: [[f64; 40]; 40] = [inner_dummy; 40];
+        let a_elt: [[f64; 20]; 20] = [inner_dummy; 20];
+        let b_elt: [[f64; 20]; 20] = [inner_dummy; 20];
         let mut j: i64 = 0;
         while j < n {
-            a_elt[j] = [0.0; 40];
-            b_elt[j] = [0.0; 40];
+            a_elt[j] = [0.0; 20];
+            b_elt[j] = [0.0; 20];
             j += 1;
         }
         a[i] = a_elt;
diff --git a/benchmarks/passing/polybench/stencils/jacobi-1d.rs b/benchmarks/passing/polybench/stencils/jacobi-1d.rs
index 399e3bb21..31226c782 100644
--- a/benchmarks/passing/polybench/stencils/jacobi-1d.rs
+++ b/benchmarks/passing/polybench/stencils/jacobi-1d.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, a: &mut [f64; 400], b: &mut [f64; 400]) {
+fn init_array(n: i64, nf: f64, a: &mut [f64; 120], b: &mut [f64; 120]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -9,7 +9,7 @@ fn init_array(n: i64, nf: f64, a: &mut [f64; 400], b: &mut [f64; 400]) {
     }
 }
 
-fn sum_array(n: i64, a: &[f64; 400]) -> f64 {
+fn sum_array(n: i64, a: &[f64; 120]) -> f64 {
     let mut i: i64 = 0;
     let mut sum: f64 = 0.0;
     while i < n {
@@ -23,7 +23,7 @@ fn sum_array(n: i64, a: &[f64; 400]) -> f64 {
     return sum;
 }
 
-fn kernel_jacobi_1d(tsteps: i64, n: i64, a: &mut [f64; 400], b: &mut [f64; 400]) {
+fn kernel_jacobi_1d(tsteps: i64, n: i64, a: &mut [f64; 120], b: &mut [f64; 120]) {
     let mut t: i64 = 0;
     while t < tsteps {
         let mut i: i64 = 1;
@@ -41,12 +41,12 @@ fn kernel_jacobi_1d(tsteps: i64, n: i64, a: &mut [f64; 400], b: &mut [f64; 400])
 }
 
 fn main() {
-    let n: i64 = 400;
-    let nf: f64 = 400.0;
-    let tsteps: i64 = 100;
+    let n: i64 = 120;
+    let nf: f64 = 120.0;
+    let tsteps: i64 = 40;
 
-    let mut a: [f64; 400] = [0.0; 400];
-    let mut b: [f64; 400] = [0.0; 400];
+    let mut a: [f64; 120] = [0.0; 120];
+    let mut b: [f64; 120] = [0.0; 120];
 
     init_array(n, nf, &mut a, &mut b);
     kernel_jacobi_1d(tsteps, n, &mut a, &mut b);
diff --git a/benchmarks/passing/polybench/stencils/jacobi-2d.rs b/benchmarks/passing/polybench/stencils/jacobi-2d.rs
index aa2c2c9c6..659ef6d60 100644
--- a/benchmarks/passing/polybench/stencils/jacobi-2d.rs
+++ b/benchmarks/passing/polybench/stencils/jacobi-2d.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, a: &mut [[f64; 250]; 250], b: &mut [[f64; 250]; 250]) {
+fn init_array(n: i64, nf: f64, a: &mut [[f64; 90]; 90], b: &mut [[f64; 90]; 90]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -15,7 +15,7 @@ fn init_array(n: i64, nf: f64, a: &mut [[f64; 250]; 250], b: &mut [[f64; 250]; 2
     }
 }
 
-fn sum_array(n: i64, a: &[[f64; 250]; 250]) -> f64 {
+fn sum_array(n: i64, a: &[[f64; 90]; 90]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < n {
@@ -33,7 +33,7 @@ fn sum_array(n: i64, a: &[[f64; 250]; 250]) -> f64 {
     return sum;
 }
 
-fn kernel_jacobi_2d(tsteps: i64, n: i64, a: &mut [[f64; 250]; 250], b: &mut [[f64; 250]; 250]) {
+fn kernel_jacobi_2d(tsteps: i64, n: i64, a: &mut [[f64; 90]; 90], b: &mut [[f64; 90]; 90]) {
     let mut t: i64 = 0;
     while t < tsteps {
         let mut i: i64 = 1;
@@ -70,20 +70,20 @@ fn kernel_jacobi_2d(tsteps: i64, n: i64, a: &mut [[f64; 250]; 250], b: &mut [[f6
 }
 
 fn main() {
-    let n: i64 = 250;
-    let mut nf: f64 = 250.0;
-    let tsteps: i64 = 100;
+    let n: i64 = 90;
+    let mut nf: f64 = 90.0;
+    let tsteps: i64 = 40;
 
-    let mut dummy: [f64; 250] = [0.0; 250];
+    let mut dummy: [f64; 90] = [0.0; 90];
 
-    let mut a: [[f64; 250]; 250] = [dummy; 250];
-    let mut b: [[f64; 250]; 250] = [dummy; 250];
+    let mut a: [[f64; 90]; 90] = [dummy; 90];
+    let mut b: [[f64; 90]; 90] = [dummy; 90];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        a[i] = [0.0; 250];
-        b[i] = [0.0; 250];
+        a[i] = [0.0; 90];
+        b[i] = [0.0; 90];
         i += 1;
     }
 
diff --git a/benchmarks/passing/polybench/stencils/seidel-2d.rs b/benchmarks/passing/polybench/stencils/seidel-2d.rs
index 4a48e5fa5..b59c9653a 100644
--- a/benchmarks/passing/polybench/stencils/seidel-2d.rs
+++ b/benchmarks/passing/polybench/stencils/seidel-2d.rs
@@ -1,4 +1,4 @@
-fn init_array(n: i64, nf: f64, a: &mut [[f64; 400]; 400]) {
+fn init_array(n: i64, nf: f64, a: &mut [[f64; 120]; 120]) {
     let mut i: i64 = 0;
     let mut fi: f64 = 0.0;
     while i < n {
@@ -14,7 +14,7 @@ fn init_array(n: i64, nf: f64, a: &mut [[f64; 400]; 400]) {
     }
 }
 
-fn sum_array(n: i64, a: &[[f64; 400]; 400]) -> f64 {
+fn sum_array(n: i64, a: &[[f64; 120]; 120]) -> f64 {
     let mut sum: f64 = 0.0;
     let mut i: i64 = 0;
     while i < n {
@@ -32,7 +32,7 @@ fn sum_array(n: i64, a: &[[f64; 400]; 400]) -> f64 {
     return sum;
 }
 
-fn kernel_seidel_2d(tsteps: i64, n: i64, a: &mut [[f64; 400]; 400]) {
+fn kernel_seidel_2d(tsteps: i64, n: i64, a: &mut [[f64; 120]; 120]) {
     let mut t: i64 = 0;
     while t < tsteps {
         let mut i: i64 = 1;
@@ -58,17 +58,17 @@ fn kernel_seidel_2d(tsteps: i64, n: i64, a: &mut [[f64; 400]; 400]) {
 }
 
 fn main() {
-    let n: i64 = 400;
-    let nf: f64 = 400.0;
-    let tsteps: i64 = 100;
+    let n: i64 = 120;
+    let nf: f64 = 120.0;
+    let tsteps: i64 = 40;
 
-    let dummy: [f64; 400] = [0.0; 400];
-    let mut a: [[f64; 400]; 400] = [dummy; 400];
+    let dummy: [f64; 120] = [0.0; 120];
+    let mut a: [[f64; 120]; 120] = [dummy; 120];
 
     // Init
     let mut i: i64 = 0;
     while i < n {
-        a[i] = [0.0; 400];
+        a[i] = [0.0; 120];
         i += 1;
     }
     drop(dummy);