[ArrayPartition] Partition arrays and access

integration-test/memory_partition/test_1d_partition/test_1d_partition.c

@@ -0,0 +1,31 @@
+#include <stdlib.h>
+#define N 32
+#include "dynamatic/Integration.h"
+
+// NOTE: Simple test for 1d array halve partition
+void test_1d_partition(const int A[N], const int B[N], const int C[N],
+                       int result[N]) {
+#pragma DYN array_partition array = intermediate dimension = 1 style =         \
+    block factor = 2
+  int intermediate[N];
+  for (int i = 0; i < N; ++i) {
+    intermediate[i] = A[i] * B[i];
+  }
+  for (int i = 0; i < N; i++) {
+    result[i] = intermediate[i] * C[i];
+  }
+}
+
+int main(void) {
+  int A[N];
+  int B[N];
+  int C[N];
+  int result[N];
+  for (int i = 0; i < N; ++i) {
+    A[i] = rand() % 100;
+    B[i] = rand() % 100;
+    C[i] = rand() % 100;
+  }
+  CALL_KERNEL(test_1d_partition, A, B, C, result);
+  return 0;
+}

integration-test/memory_partition/test_1d_partition_f4/test_1d_partition_f4.c

@@ -0,0 +1,31 @@
+#include <stdlib.h>
+#define N 32
+#include "dynamatic/Integration.h"
+
+// NOTE: Test for testing larger factors
+void test_1d_partition_f4(const int A[N], const int B[N], const int C[N],
+                          int result[N]) {
+#pragma DYN array_partition array = intermediate dimension = 1 style =         \
+    block factor = 4
+  int intermediate[N];
+  for (int i = 0; i < N; ++i) {
+    intermediate[i] = A[i] * B[i];
+  }
+  for (int i = 0; i < N; i++) {
+    result[i] = intermediate[i] * C[i];
+  }
+}
+
+int main(void) {
+  int A[N];
+  int B[N];
+  int C[N];
+  int result[N];
+  for (int i = 0; i < N; ++i) {
+    A[i] = rand() % 100;
+    B[i] = rand() % 100;
+    C[i] = rand() % 100;
+  }
+  CALL_KERNEL(test_1d_partition_f4, A, B, C, result);
+  return 0;
+}

integration-test/memory_partition/test_1d_partition_fu/test_1d_partition_fu.c

@@ -0,0 +1,31 @@
+#include <stdlib.h>
+#define N 67
+#include "dynamatic/Integration.h"
+
+// NOTE: Test for division with remainder after doing N / factor
+void test_1d_partition_fu(const int A[N], const int B[N], const int C[N],
+                          int result[N]) {
+#pragma DYN array_partition array = intermediate dimension = 1 style =         \
+    block factor = 8
+  int intermediate[N];
+  for (int i = 0; i < N; ++i) {
+    intermediate[i] = A[i] * B[i];
+  }
+  for (int i = 0; i < N; i++) {
+    result[i] = intermediate[i] * C[i];
+  }
+}
+
+int main(void) {
+  int A[N];
+  int B[N];
+  int C[N];
+  int result[N];
+  for (int i = 0; i < N; ++i) {
+    A[i] = rand() % 100;
+    B[i] = rand() % 100;
+    C[i] = rand() % 100;
+  }
+  CALL_KERNEL(test_1d_partition_fu, A, B, C, result);
+  return 0;
+}

integration-test/memory_partition/test_2d_partition/test_2d_partition.c

@@ -0,0 +1,39 @@
+#include <stdlib.h>
+#define ROWS 32
+#define COLS 64
+#include "dynamatic/Integration.h"
+
+// NOTE: Test for outer partition of 2d array, i.e. A[N][M] -> A1[N/2][M],
+// A2[N/2][M]
+void test_2d_partition(const int A[ROWS][COLS], const int B[ROWS][COLS],
+                       const int C[ROWS][COLS], int result[ROWS][COLS]) {
+#pragma DYN array_partition array = intermediate dimension = 1 style =         \
+    block factor = 2
+  int intermediate[ROWS][COLS];
+  for (int i = 0; i < ROWS; ++i) {
+    for (int j = 0; j < COLS; ++j) {
+      intermediate[i][j] = A[i][j] * B[i][j];
+    }
+  }
+  for (int i = 0; i < ROWS; ++i) {
+    for (int j = 0; j < COLS; ++j) {
+      result[i][j] = intermediate[i][j] * C[i][j];
+    }
+  }
+}
+
+int main(void) {
+  int A[ROWS][COLS];
+  int B[ROWS][COLS];
+  int C[ROWS][COLS];
+  int result[ROWS][COLS];
+  for (int i = 0; i < ROWS; ++i) {
+    for (int j = 0; j < COLS; ++j) {
+      A[i][j] = rand() % 100;
+      B[i][j] = rand() % 100;
+      C[i][j] = rand() % 100;
+    }
+  }
+  CALL_KERNEL(test_2d_partition, A, B, C, result);
+  return 0;
+}

integration-test/memory_partition/test_2d_partition_inner/test_2d_partition_inner.c

@@ -0,0 +1,39 @@
+#include <stdlib.h>
+#define ROWS 32
+#define COLS 64
+#include "dynamatic/Integration.h"
+
+// NOTE: Test for inner partition of 2d array, i.e. A[N][M] -> A1[N][M/2],
+// A2[N][M/2]
+void test_2d_partition_inner(const int A[ROWS][COLS], const int B[ROWS][COLS],
+                             const int C[ROWS][COLS], int result[ROWS][COLS]) {
+#pragma DYN array_partition array = intermediate dimension = 2 style =         \
+    block factor = 2
+  int intermediate[ROWS][COLS];
+  for (int i = 0; i < ROWS; ++i) {
+    for (int j = 0; j < COLS; ++j) {
+      intermediate[i][j] = A[i][j] * B[i][j];
+    }
+  }
+  for (int i = 0; i < ROWS; ++i) {
+    for (int j = 0; j < COLS; ++j) {
+      result[i][j] = intermediate[i][j] * C[i][j];
+    }
+  }
+}
+
+int main(void) {
+  int A[ROWS][COLS];
+  int B[ROWS][COLS];
+  int C[ROWS][COLS];
+  int result[ROWS][COLS];
+  for (int i = 0; i < ROWS; ++i) {
+    for (int j = 0; j < COLS; ++j) {
+      A[i][j] = rand() % 100;
+      B[i][j] = rand() % 100;
+      C[i][j] = rand() % 100;
+    }
+  }
+  CALL_KERNEL(test_2d_partition_inner, A, B, C, result);
+  return 0;
+}