xmos-ai-tools 1.3.2.dev80__py3-none-macosx_10_15_universal2.whl

xmos_ai_tools/runtime/include/tensorflow/lite/micro/testing/micro_test.h

@@ -0,0 +1,267 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+// An ultra-lightweight testing framework designed for use with microcontroller
+// applications. This is designed to be usable even
+// when no standard C or C++ libraries are available, and without any dynamic
+// memory allocation or reliance on global constructors.
+//
+// To build a test, you use syntax similar to gunit, but with some extra
+// decoration to create a hidden 'main' function containing each of the tests to
+// be run. Your code should look something like:
+// ----------------------------------------------------------------------------
+// #include "path/to/this/header"
+//
+// TF_LITE_MICRO_TESTS_BEGIN
+//
+// TF_LITE_MICRO_TEST(SomeTest) {
+//   TF_LITE_LOG_EXPECT_EQ(true, true);
+// }
+//
+// TF_LITE_MICRO_TESTS_END
+// ----------------------------------------------------------------------------
+// If you compile this for your platform, you'll get a normal binary that you
+// should be able to run. Executing it will output logging information like this
+// to stderr:
+// ----------------------------------------------------------------------------
+// Testing SomeTest
+// 1/1 tests passed
+// ~~~ALL TESTS PASSED~~~
+// ----------------------------------------------------------------------------
+// This is designed to be human-readable, so you can just run tests manually,
+// but the string "~~~ALL TESTS PASSED~~~" should only appear if all of the
+// tests do pass. This makes it possible to integrate with automated test
+// systems by scanning the output logs and looking for that magic value.
+//
+// This framework is intended to be a rudimentary alternative to no testing at
+// all on systems that struggle to run more conventional approaches, so use with
+// caution!
+
+#ifndef TENSORFLOW_LITE_MICRO_TESTING_MICRO_TEST_H_
+#define TENSORFLOW_LITE_MICRO_TESTING_MICRO_TEST_H_
+#include <limits>
+#include <type_traits>
+
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/micro_log.h"
+#include "tensorflow/lite/micro/system_setup.h"
+
+namespace micro_test {
+extern int tests_passed;
+extern int tests_failed;
+extern bool is_test_complete;
+extern bool did_test_fail;
+}  // namespace micro_test
+
+namespace tflite_micro {
+
+// This additional helper function is used (instead of directly calling
+// tflite_micro::InitializeTarget from the TF_LITE_MICRO_TESTS_BEGIN macro) to avoid
+// adding a dependency from every bazel test target to micro:system_setp (which
+// is the target that implements InitializeTarget().
+//
+// The underlying issue here is that the use of the macros results in
+// dependencies that can be containted within the micro/testing:micro_test
+// target bleeding on to all the tests.
+inline void InitializeTest() { InitializeTarget(); }
+}  // namespace tflite_micro
+
+#define TF_LITE_MICRO_TESTS_BEGIN   \
+  namespace micro_test {            \
+  int tests_passed;                 \
+  int tests_failed;                 \
+  bool is_test_complete;            \
+  bool did_test_fail;               \
+  }                                 \
+                                    \
+  int main(int argc, char** argv) { \
+    micro_test::tests_passed = 0;   \
+    micro_test::tests_failed = 0;   \
+    tflite_micro::InitializeTest();
+
+#define TF_LITE_MICRO_TESTS_END                                       \
+  MicroPrintf("%d/%d tests passed", micro_test::tests_passed,         \
+              (micro_test::tests_failed + micro_test::tests_passed)); \
+  if (micro_test::tests_failed == 0) {                                \
+    MicroPrintf("~~~ALL TESTS PASSED~~~\n");                          \
+    return kTfLiteOk;                                                 \
+  } else {                                                            \
+    MicroPrintf("~~~SOME TESTS FAILED~~~\n");                         \
+    return kTfLiteError;                                              \
+  }                                                                   \
+  }
+
+// TODO(petewarden): I'm going to hell for what I'm doing to this poor for loop.
+#define TF_LITE_MICRO_TEST(name)                                           \
+  MicroPrintf("Testing " #name);                                           \
+  for (micro_test::is_test_complete = false,                               \
+      micro_test::did_test_fail = false;                                   \
+       !micro_test::is_test_complete; micro_test::is_test_complete = true, \
+      micro_test::tests_passed += (micro_test::did_test_fail) ? 0 : 1,     \
+      micro_test::tests_failed += (micro_test::did_test_fail) ? 1 : 0)
+
+#define TF_LITE_MICRO_EXPECT(x)                               \
+  do {                                                        \
+    if (!(x)) {                                               \
+      MicroPrintf(#x " failed at %s:%d", __FILE__, __LINE__); \
+      micro_test::did_test_fail = true;                       \
+    }                                                         \
+  } while (false)
+
+#define TF_LITE_MICRO_EXPECT_EQ(x, y)                                     \
+  do {                                                                    \
+    auto vx = x;                                                          \
+    auto vy = y;                                                          \
+    bool isFloatingX = (std::is_floating_point<decltype(vx)>::value);     \
+    bool isFloatingY = (std::is_floating_point<decltype(vy)>::value);     \
+    if (isFloatingX && isFloatingY) {                                     \
+      auto delta = ((vx) > (vy)) ? ((vx) - (vy)) : ((vy) - (vx));         \
+      if (delta > std::numeric_limits<decltype(delta)>::epsilon()) {      \
+        MicroPrintf(#x " == " #y " failed at %s:%d (%f vs %f)", __FILE__, \
+                    __LINE__, static_cast<double>(vx),                    \
+                    static_cast<double>(vy));                             \
+        micro_test::did_test_fail = true;                                 \
+      }                                                                   \
+    } else if ((vx) != (vy)) {                                            \
+      MicroPrintf(#x " == " #y " failed at %s:%d (%d vs %d)", __FILE__,   \
+                  __LINE__, static_cast<int>(vx), static_cast<int>(vy));  \
+      if (isFloatingX || isFloatingY) {                                   \
+        MicroPrintf("-----------WARNING-----------");                     \
+        MicroPrintf("Only one of the values is floating point value.");   \
+      }                                                                   \
+      micro_test::did_test_fail = true;                                   \
+    }                                                                     \
+  } while (false)
+
+#define TF_LITE_MICRO_EXPECT_NE(x, y)                                     \
+  do {                                                                    \
+    auto vx = x;                                                          \
+    auto vy = y;                                                          \
+    bool isFloatingX = (std::is_floating_point<decltype(vx)>::value);     \
+    bool isFloatingY = (std::is_floating_point<decltype(vy)>::value);     \
+    if (isFloatingX && isFloatingY) {                                     \
+      auto delta = ((vx) > (vy)) ? ((vx) - (vy)) : ((vy) - (vx));         \
+      if (delta <= std::numeric_limits<decltype(delta)>::epsilon()) {     \
+        MicroPrintf(#x " != " #y " failed at %s:%d", __FILE__, __LINE__); \
+        micro_test::did_test_fail = true;                                 \
+      }                                                                   \
+    } else if ((vx) == (vy)) {                                            \
+      MicroPrintf(#x " != " #y " failed at %s:%d", __FILE__, __LINE__);   \
+      if (isFloatingX || isFloatingY) {                                   \
+        MicroPrintf("-----------WARNING-----------");                     \
+        MicroPrintf("Only one of the values is floating point value.");   \
+      }                                                                   \
+      micro_test::did_test_fail = true;                                   \
+    }                                                                     \
+  } while (false)
+
+// TODO(wangtz): Making it more generic once needed.
+#define TF_LITE_MICRO_ARRAY_ELEMENT_EXPECT_NEAR(arr1, idx1, arr2, idx2,       \
+                                                epsilon)                      \
+  do {                                                                        \
+    auto delta = ((arr1)[(idx1)] > (arr2)[(idx2)])                            \
+                     ? ((arr1)[(idx1)] - (arr2)[(idx2)])                      \
+                     : ((arr2)[(idx2)] - (arr1)[(idx1)]);                     \
+    if (delta > epsilon) {                                                    \
+      MicroPrintf(#arr1 "[%d] (%f) near " #arr2 "[%d] (%f) failed at %s:%d",  \
+                  static_cast<int>(idx1), static_cast<float>((arr1)[(idx1)]), \
+                  static_cast<int>(idx2), static_cast<float>((arr2)[(idx2)]), \
+                  __FILE__, __LINE__);                                        \
+      micro_test::did_test_fail = true;                                       \
+    }                                                                         \
+  } while (false)
+
+// The check vx != vy is needed to properly handle the case where both
+// x and y evaluate to infinity. See #46960 for more details.
+#define TF_LITE_MICRO_EXPECT_NEAR(x, y, epsilon)                              \
+  do {                                                                        \
+    auto vx = (x);                                                            \
+    auto vy = (y);                                                            \
+    auto delta = ((vx) > (vy)) ? ((vx) - (vy)) : ((vy) - (vx));               \
+    if (vx != vy && delta > epsilon) {                                        \
+      MicroPrintf(#x " (%f) near " #y " (%f) failed at %s:%d",                \
+                  static_cast<double>(vx), static_cast<double>(vy), __FILE__, \
+                  __LINE__);                                                  \
+      micro_test::did_test_fail = true;                                       \
+    }                                                                         \
+  } while (false)
+
+#define TF_LITE_MICRO_EXPECT_GT(x, y)                                  \
+  do {                                                                 \
+    if ((x) <= (y)) {                                                  \
+      MicroPrintf(#x " > " #y " failed at %s:%d", __FILE__, __LINE__); \
+      micro_test::did_test_fail = true;                                \
+    }                                                                  \
+  } while (false)
+
+#define TF_LITE_MICRO_EXPECT_LT(x, y)                                  \
+  do {                                                                 \
+    if ((x) >= (y)) {                                                  \
+      MicroPrintf(#x " < " #y " failed at %s:%d", __FILE__, __LINE__); \
+      micro_test::did_test_fail = true;                                \
+    }                                                                  \
+  } while (false)
+
+#define TF_LITE_MICRO_EXPECT_GE(x, y)                                   \
+  do {                                                                  \
+    if ((x) < (y)) {                                                    \
+      MicroPrintf(#x " >= " #y " failed at %s:%d", __FILE__, __LINE__); \
+      micro_test::did_test_fail = true;                                 \
+    }                                                                   \
+  } while (false)
+
+#define TF_LITE_MICRO_EXPECT_LE(x, y)                                   \
+  do {                                                                  \
+    if ((x) > (y)) {                                                    \
+      MicroPrintf(#x " <= " #y " failed at %s:%d", __FILE__, __LINE__); \
+      micro_test::did_test_fail = true;                                 \
+    }                                                                   \
+  } while (false)
+
+#define TF_LITE_MICRO_EXPECT_TRUE(x)                                       \
+  do {                                                                     \
+    if (!(x)) {                                                            \
+      MicroPrintf(#x " was not true failed at %s:%d", __FILE__, __LINE__); \
+      micro_test::did_test_fail = true;                                    \
+    }                                                                      \
+  } while (false)
+
+#define TF_LITE_MICRO_EXPECT_FALSE(x)                                       \
+  do {                                                                      \
+    if (x) {                                                                \
+      MicroPrintf(#x " was not false failed at %s:%d", __FILE__, __LINE__); \
+      micro_test::did_test_fail = true;                                     \
+    }                                                                       \
+  } while (false)
+
+#define TF_LITE_MICRO_FAIL(msg)                       \
+  do {                                                \
+    MicroPrintf("FAIL: %s", msg, __FILE__, __LINE__); \
+    micro_test::did_test_fail = true;                 \
+  } while (false)
+
+#define TF_LITE_MICRO_EXPECT_STRING_EQ(string1, string2)                     \
+  do {                                                                       \
+    for (int i = 0; string1[i] != '\0' && string2[i] != '\0'; i++) {         \
+      if (string1[i] != string2[i]) {                                        \
+        MicroPrintf("FAIL: %s did not match %s", string1, string2, __FILE__, \
+                    __LINE__);                                               \
+        micro_test::did_test_fail = true;                                    \
+        break;                                                               \
+      }                                                                      \
+    }                                                                        \
+  } while (false)
+
+#endif  // TENSORFLOW_LITE_MICRO_TESTING_MICRO_TEST_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/testing/test_conv_model.h

@@ -0,0 +1,23 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TENSORFLOW_LITE_MICRO_TESTING_TEST_CONV_MODEL_H_
+#define TENSORFLOW_LITE_MICRO_TESTING_TEST_CONV_MODEL_H_
+
+// See generate_test_models.py for updating the contents of this model:
+extern const unsigned char kTestConvModelData[];
+extern const unsigned int kTestConvModelDataSize;
+
+#endif  // TENSORFLOW_LITE_MICRO_TESTING_TEST_CONV_MODEL_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/tflite_bridge/flatbuffer_conversions_bridge.h

@@ -0,0 +1,45 @@
+/* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_LITE_MICRO_TFLITE_BRIDGE_FLATBUFFER_CONVERSIONS_BRIDGE_H_
+#define TENSORFLOW_LITE_MICRO_TFLITE_BRIDGE_FLATBUFFER_CONVERSIONS_BRIDGE_H_
+
+#include "tensorflow/lite/c/c_api_types.h"
+#include "tensorflow/lite/core/api/flatbuffer_conversions.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+
+namespace tflite_micro {
+
+// Forward declaration of the ErrorReporter class to hide it from the TFLM code.
+class ErrorReporter;
+
+using TfLiteBridgeBuiltinDataAllocator = BuiltinDataAllocator;
+
+using TfLiteBridgeBuiltinParseFunction =
+    TfLiteStatus (*)(const Operator* op, ErrorReporter* error_reporter,
+                     BuiltinDataAllocator* allocator, void** builtin_data);
+
+// Converts the tensor data type used in the flatbuffer to the representation
+// used by the runtime.
+TfLiteStatus ConvertTensorType(TensorType tensor_type, TfLiteType* type);
+
+// CallBuiltinParseFunction is a wrapper function to wrap the parser function
+// calls to Call parser(op, allocator, builtin_data)
+TfLiteStatus CallBuiltinParseFunction(TfLiteBridgeBuiltinParseFunction parser,
+                                      const Operator* op,
+                                      BuiltinDataAllocator* allocator,
+                                      void** builtin_data);
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_TFLITE_BRIDGE_FLATBUFFER_CONVERSIONS_BRIDGE_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/tflite_bridge/micro_error_reporter.h

@@ -0,0 +1,36 @@
+/* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_LITE_MICRO_TFLITE_BRIDGE_MICRO_ERROR_REPORTER_H_
+#define TENSORFLOW_LITE_MICRO_TFLITE_BRIDGE_MICRO_ERROR_REPORTER_H_
+
+#include <cstdarg>
+
+#include "tensorflow/lite/core/api/error_reporter.h"
+#include "tensorflow/lite/micro/compatibility.h"
+
+namespace tflite_micro {
+// Get a pointer to a singleton global error reporter.
+ErrorReporter* GetMicroErrorReporter();
+class MicroErrorReporter : public ErrorReporter {
+ public:
+  ~MicroErrorReporter() override {}
+  int Report(const char* format, va_list args) override;
+
+  TF_LITE_REMOVE_VIRTUAL_DELETE
+};
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_MICRO_TFLITE_BRIDGE_MICRO_ERROR_REPORTER_H_

xmos_ai_tools/runtime/include/tensorflow/lite/micro/tools/benchmarking/log_utils.h

@@ -0,0 +1,273 @@
+/* Copyright 2023 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#ifndef TFLM_BENCHMARK_INTERNAL_LOG_UTILS_H_
+#define TFLM_BENCHMARK_INTERNAL_LOG_UTILS_H_
+
+#include <algorithm>
+#include <cstdarg>
+#include <cstdint>
+#include <cstring>
+
+#include "tensorflow/lite/micro/micro_log.h"
+
+namespace tflite_micro {
+
+// The maxmimum length of a string.
+static constexpr int kMaxStringLength = 32;
+
+// The maximum length of a table row, applies to the header as well.
+static constexpr int kMaxRowLength = 100;
+
+// The default padding between columns in a table.
+static constexpr int kDefaultColumnPadding = 4;
+
+// Defines how formatted data is printed to stdout.
+enum class PrettyPrintType {
+  // Prints as a CSV file.
+  kCsv,
+  // Prints as a formatted table.
+  kTable,
+};
+
+// Returns the length of the longest string in an array.
+// Args:
+// - strings: An array of strings.
+// - count: The number of strings in the array.
+int GetLongestStringLength(const char strings[][kMaxStringLength], int count);
+
+// Adds padding between two columns in a table.
+// ex) "hello" is being inserted into a column. The largest value in that column
+//     is 10, and there's a global padding of 4 spaces. Therefore, 9 spaces (10
+//     - 5 + 4) are added as padding.
+// Args:
+// - string: The input padding string.
+// - size: The size of the string that's being inserted into a column.
+// - max_size: The size of the largest string in the column.
+// - padding: The amount of padding to add to each column regardless of its
+//     size.
+void FillColumnPadding(char* string, int size, int max_size,
+                       int padding = kDefaultColumnPadding);
+
+// Fills a string with a specified value.
+// Args:
+// - string: The input string. This is filled in with the specified value.
+// - size: The size of the string after being filled in. This must be less than
+//     the allocated space for the string.
+// - buffer_size: The size of the string's buffer.
+// - value: The value to insert into the string. Defaults to a space.
+void FillString(char* string, int size, int buffer_size, char value = ' ');
+
+// Concatenates the input string onto the first.
+// Args:
+// - output: The destination string for where to append input.
+// - input: The input string to concatenate.
+// - size: The number of characters to concatenate from the first string. If
+//     negative, the whole input string will be concatenated.
+void MicroStrcat(char* output, const char* input, int size = -1);
+
+// Copies the input string into the output.
+void MicroStrcpy(char* output, const char* input);
+
+// Formats a division operation to have a specified number of decimal places.
+// Args:
+// - output: The output string to be formatted.
+// - numerator: The numerator in the division operation.
+// - denominator: The denominator in the division operation.
+// - decimal places: The number of decimal places to print to.
+void FormatIntegerDivide(char* output, int64_t numerator, int64_t denominator,
+                         int decimal_places);
+
+// Formats a division operation as a percentage.
+// Args:
+// - output: The output string to be formatted.
+// - numerator: The numerator in the division operation.
+// - denominator: The denominator in the division operation.
+// - decimal places: The number of decimal places to print to.
+void FormatAsPercentage(char* output, int64_t numerator, int64_t denominator,
+                        int decimal_places);
+
+void PrettyPrintTableHeader(PrettyPrintType type, const char* table_name);
+
+// Formats a number as a string.
+// Args:
+// - output: The location of where to write the formatted number.
+// - value: The value to write to a string.
+template <typename T>
+void FormatNumber(char* output, T value);
+
+// Pretty prints a table to stdout.
+// Note: kMaxRows and kColumns should describe the allocated size of the table,
+//       not the amount of data that is populated. It is required that all
+//       columns are filled out, but not all rows.
+//
+// ex) PrintTable<3, 25>(headers, data, 4);
+//     This will print a table with 3 columns and 4 rows. In this example, it
+//     is required that data is defined as char[3][25][kMaxStringLength] to
+//     properly print.
+//
+// op        cycles    cpu %
+// -------------------------
+// foo     | 1000     | 10
+// bar     | 2500     | 25
+// baz     | 1000     | 10
+// lorem   | 2000     | 20
+//
+// Args:
+// - headers: A 1D array of strings containing the headers of the table. This
+//     must be equal in size to kColumns.
+// - data: A 2D array of string data organized in [columns, rows]. As stated
+//     above, it is required that all columns are populated, but not all rows.
+// - rows: The number of populated rows in `data`.
+template <int kMaxRows, int kColumns>
+void PrintTable(const char headers[kColumns][kMaxStringLength],
+                const char data[kColumns][kMaxRows][kMaxStringLength],
+                const int rows) {
+  // Get the maximum width for each column in the table.
+  int max_column_width[kColumns];
+  for (int i = 0; i < kColumns; ++i) {
+    max_column_width[i] = std::max(GetLongestStringLength(data[i], rows),
+                                   static_cast<int>(strlen(headers[i])));
+  }
+
+  // Add padding between each item in the header so it can be printed on one
+  // line.
+  char header_spaces[kColumns][kMaxStringLength];
+  for (int i = 0; i < kColumns; ++i) {
+    FillColumnPadding(header_spaces[i], strlen(headers[i]), max_column_width[i],
+                      kDefaultColumnPadding + 2);
+  }
+
+  // Print the header.
+  char header[kMaxRowLength];
+  memset(header, 0, kMaxRowLength);
+  for (int i = 0; i < kColumns; ++i) {
+    MicroStrcat(header, headers[i]);
+    MicroStrcat(header, header_spaces[i]);
+  }
+  MicroPrintf("%s", header);
+
+  // Print a separator to separate the header from the data.
+  char separator[kMaxRowLength];
+  FillString(separator, strlen(header) - 1, kMaxRowLength, '-');
+  MicroPrintf("%s", separator);
+
+  for (int i = 0; i < rows; ++i) {
+    char spaces[kColumns][kMaxStringLength];
+    for (int j = 0; j < kColumns; ++j) {
+      FillColumnPadding(spaces[j], strlen(data[j][i]), max_column_width[j]);
+    }
+
+    char row[kMaxRowLength];
+    memset(row, 0, kMaxRowLength);
+
+    // Concatenate each column in a row with the format "[data][padding]| "
+    for (int j = 0; j < kColumns; ++j) {
+      MicroStrcat(row, data[j][i]);
+      MicroStrcat(row, spaces[j]);
+      MicroStrcat(row, "| ");
+    }
+
+    MicroPrintf("%s", row);
+  }
+
+  MicroPrintf(separator);
+  MicroPrintf("");
+}
+
+// Pretty prints a csv to stdout.
+// Note: kMaxRows and kColumns should describe the allocated size of the table,
+//       not the amount of data that is populated. It is required that all
+//       columns are filled out, but not all rows.
+//
+// ex)
+// op,cycles,%cpu
+// foo,1000,10
+// bar,2500,25
+// baz,1000,10
+//
+// Args:
+// - headers: A 1D array of strings containing the headers of the table. This
+//     must be equal in size to kColumns.
+// - data: A 2D array of string data organized in [columns, rows]. As stated
+//     above, it is required that all columns are populated, but not all rows.
+// - rows: The number of populated rows in `data`.
+template <int kMaxRows, int kColumns>
+void PrintCsv(const char headers[kColumns][kMaxStringLength],
+              const char data[kColumns][kMaxRows][kMaxStringLength],
+              const int rows) {
+  char header[kMaxRowLength];
+  memset(header, 0, kMaxRowLength);
+  for (int i = 0; i < kColumns; ++i) {
+    MicroStrcat(header, headers[i]);
+    if (i < kColumns - 1) {
+      MicroStrcat(header, ",");
+    }
+  }
+
+  MicroPrintf("%s", header);
+
+  char row[kMaxRowLength];
+  for (int i = 0; i < rows; ++i) {
+    memset(row, 0, kMaxRowLength);
+    for (int j = 0; j < kColumns; ++j) {
+      MicroStrcat(row, data[j][i]);
+      if (j < kColumns - 1) {
+        MicroStrcat(row, ",");
+      }
+    }
+
+    MicroPrintf("%s", row);
+  }
+
+  MicroPrintf("");  // Serves as a new line.
+}
+
+// Prints a 2D array of strings in a formatted manner along with a table name
+// that includes the table type.
+//
+// Note: kMaxRows and kColumns should describe the allocated size of the table,
+//       not the amount of data that is populated. It is required that all
+//       columns are filled out, but not all rows.
+//
+// ex) PrettyPrint::kCsv will print a csv with a [[ CSV ]]: table_name header.
+//
+// Args:
+// - headers: A 1D array of strings containing the headers of the table. This
+//     must be equal in size to kColumns.
+// - data: A 2D array of string data organized in [columns, rows]. As stated
+//     above, it is required that all columns are populated, but not all rows.
+// - rows: The number of populated rows in `data`.
+// - type: The format type that should be used to pretty print.
+// - table_name: The name of the table to be printed alongside the format type.
+template <int kMaxRows, int kColumns>
+void PrintFormattedData(const char headers[kColumns][kMaxStringLength],
+                        const char data[kColumns][kMaxRows][kMaxStringLength],
+                        const int rows, const PrettyPrintType type,
+                        const char* table_name) {
+  PrettyPrintTableHeader(type, table_name);
+  switch (type) {
+    case PrettyPrintType::kCsv:
+      PrintCsv<kMaxRows, kColumns>(headers, data, rows);
+      break;
+    case PrettyPrintType::kTable:
+      PrintTable<kMaxRows, kColumns>(headers, data, rows);
+      break;
+  }
+}
+
+}  // namespace tflite_micro
+
+#endif  // TFLM_BENCHMARK_INTERNAL_LOG_UTILS_H_