refactor

Author: andy6804tw

.gitignore

@@ -1,2 +1,4 @@
-.ipynb_checkpoints/
-*.so
+.ipynb_checkpoints
+.pkl_memoize_py3
+main
+.DS_Store

onnx-mlir/Release/lib/libcruntime.a

@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: Apache-2.0
+
+add_subdirectory(onnx-mlir)
+
+install(FILES OnnxMlirCompiler.h DESTINATION include)
+install(FILES OnnxMlirRuntime.h DESTINATION include)

onnx-mlir/include/CMakeLists.txt

@@ -0,0 +1,132 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//===------- OnnxMlirCompiler.h - ONNX-MLIR Compiler API Declarations -----===//
+//
+// This file contains declaration of onnx-mlir compiler functionality
+// exported from the OnnxMlirCompiler library
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ONNX_MLIR_ONNXMLIRCOMPILER_H
+#define ONNX_MLIR_ONNXMLIRCOMPILER_H
+
+#include <onnx-mlir/Compiler/OMCompilerTypes.h>
+#include <string>
+#ifdef __cplusplus
+#include <cstdint>
+#else
+#include <stdint.h>
+#endif // #ifdef __cplusplus
+
+#ifdef ONNX_MLIR_BUILT_AS_STATIC
+#define ONNX_MLIR_EXPORT
+#else
+#ifdef _MSC_VER
+#ifdef OnnxMlirCompiler_EXPORTS
+/* We are building this library */
+#define ONNX_MLIR_EXPORT __declspec(dllexport)
+#else
+/* We are using this library */
+#define ONNX_MLIR_EXPORT __declspec(dllimport)
+#endif
+#else
+#define ONNX_MLIR_EXPORT __attribute__((__visibility__("default")))
+#endif
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+namespace onnx_mlir {
+#endif
+
+/*!
+ *  C interface to compile an onnx model from a file via onnx-mlir command.
+ *  This interface is thread safe, and does not take any flags from the
+ *  current environment. All flags are passed by using the flags parameter,
+ *  including the "-o output-file-name" option or the "-EmitXXX" options. All
+ *  options that are available to onnx-mlir are also available here.
+ *
+ *  This call rely on executing onnx-mlir compiler. The user can override its
+ *  default location by using the ONNX_MLIR_BIN_PATH environment variable.
+ *
+ *  When generating libraries or jar files, the compiler will link in
+ *  lightweight runtimes / jar files. If these libraries / jar files are not in
+ *  the system wide directory (typically /usr/local/lib), the user can override
+ *  the default location using the ONNX_MLIR_LIBRARY_PATH environment variable.
+ *
+ *  @param inputFilename File name pointing onnx model protobuf or MLIR.
+ *  Name may include a path, and must include the file name and its extention.
+ *
+ *  @param outputFilename Output file name of the compiled output for the given
+ *  emission target. User is responsible for freeing the string.
+ *
+ *  @param flags A char * contains all the options provided to compile the
+ *  model.
+ *
+ *  @param errorMessage Output error message, if any. User is responsible for
+ *  freeing the string.
+ *
+ *  @return 0 on success or OnnxMlirCompilerErrorCodes on failure.
+ */
+ONNX_MLIR_EXPORT int64_t omCompileFromFile(const char *inputFilename,
+    const char *flags, char **outputFilename, char **errorMessage);
+
+/*!
+ *  Compile an onnx model from an ONNX protobuf array. This method is not thread
+ *  safe, and borrows the current compiler options currently defined in this
+ *  process. When generating libraries or jar files, the compiler will link in
+ *  lightweight runtimes / jar files. If these libraries / jar files are not in
+ *  the system wide directory (typically /usr/local/lib), the user can override
+ *  the default location using the ONNX_MLIR_LIBRARY_PATH environment variable.
+ *
+ *  @param inputBuffer ONNX protobuf array.
+ *  @param bufferSize Size of ONNX protobuf array.
+ *  @param outputBaseName File name without extension to write output.
+ *  Name may include a path, must include the file name, and should not include
+ *  an extention.
+ *  @param emissionTarget Target format to compile to.
+ *  @param outputFilename Output file name of the compiled output for the given
+ *  emission target. User is responsible for freeing the string.
+ *  @param errorMessage Error message, if any. User is responsible for freeing
+ *  the string.
+ *  @return 0 on success or OnnxMlirCompilerErrorCodes failure. User is
+ *  responsible for freeing the string.
+ */
+ONNX_MLIR_EXPORT int64_t omCompileFromArray(const void *inputBuffer,
+    int64_t bufferSize, const char *outputBaseName,
+    EmissionTargetType emissionTarget, char **outputFilename,
+    char **errorMessage);
+
+/*!
+ * Compute the file name of the compiled output for the given
+ * emission target. User is responsible for freeing the string.
+ *
+ *  @param inputFilename File name pointing onnx model protobuf or MLIR.
+ *  Name may include a path, and must include the file name and its extention.
+ *  @param flags A char * contains all the options provided to compile the
+ *  model.
+ *  @return string containing the file name. User is responsible for freeing the
+ *  string.
+ */
+ONNX_MLIR_EXPORT char *omCompileOutputFileName(
+    const char *inputFilename, const char *flags);
+
+/*!
+ * Compute the model tag from the given compile options.
+ * User is responsible for freeing the string.
+ *
+ *  @param flags A char * contains all the options provided to compile the
+ *  model.
+ *  @return string containing the model tag. User is responsible for freeing the
+ *  string.
+ */
+ONNX_MLIR_EXPORT char *omCompileModelTag(const char *flags);
+
+#ifdef __cplusplus
+} // namespace onnx_mlir
+} // extern C
+#endif
+
+#endif

onnx-mlir/include/OnnxMlirCompiler.h

@@ -0,0 +1,180 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//===------- OnnxMlirRuntime.h - ONNX-MLIR Runtime API Declarations -------===//
+//
+// Copyright 2019-2023 The IBM Research Authors.
+//
+// =============================================================================
+//
+// This file contains declaration of external OMTensor data structures and
+// helper functions.
+//
+//===----------------------------------------------------------------------===//
+#ifndef ONNX_MLIR_ONNXMLIRRUNTIME_H
+#define ONNX_MLIR_ONNXMLIRRUNTIME_H
+
+#ifdef __cplusplus
+#include <cstdint>
+#else
+#include <stdbool.h>
+#include <stdint.h>
+#endif
+
+#include <onnx-mlir/Runtime/OMEntryPoint.h>
+#include <onnx-mlir/Runtime/OMInstrument.h>
+#include <onnx-mlir/Runtime/OMSignature.h>
+#include <onnx-mlir/Runtime/OMTensor.h>
+#include <onnx-mlir/Runtime/OMTensorList.h>
+
+/*! \mainpage ONNX-MLIR Runtime API documentation
+ *
+ * \section intro_sec Introduction
+ *
+ * ONNX-MLIR project comes with an executable `onnx-mlir` capable
+ * of compiling onnx models to a shared library. In this documentation, we
+ * demonstrate how to interact programmatically with the compiled
+ * shared library using ONNX-MLIR's Runtime API.
+ *
+ * \section c-runtime-api C Runtime API
+ *
+ * \subsection data-structures Data Structures
+ *
+ * `OMTensor` is the data structure used to describe the runtime information
+ * (rank, shape, data type, etc) associated with a tensor input or output.
+ *
+ * `OMTensorList` is the data structure used to hold a list of pointers to
+ * OMTensor so that they can be passed into and out of the compiled model as
+ * inputs and outputs.
+ *
+ * `OMEntryPoint` is the data structure used to return all entry point names
+ * in a model. These entry point names are the symbols of the inference functions
+ * in the model.
+ *
+ * `OMSignature` is the data structure used to return the output signature of
+ * the given entry point as a JSON string.
+ *
+ * \subsection model-entry-point-signature Model Entry Point Signature
+ *
+ * All compiled models will have the same exact C function signature equivalent
+ * to:
+ *
+ * ```c
+ * OMTensorList* run_main_graph(OMTensorList*);
+ * ```
+ *
+ * Intuitively, the model takes a list of tensors as input and returns a list of
+ * tensors as output.
+ *
+ * \subsection invoke-models-using-c-runtime-api Invoke Models Using C Runtime
+ * API
+ *
+ * We demonstrate using the API functions to run a simple ONNX model consisting
+ * of an add operation. To create such an onnx model, use this
+ * <a href="gen_add_onnx.py" target="_blank"><b>python script</b></a>
+ *
+ * To compile the above model, run `onnx-mlir add.onnx` and a binary library
+ * "add.so" should appear. We can use the following C code to call into the
+ * compiled function computing the sum of two inputs:
+ *
+ * ```c
+ * #include <OnnxMlirRuntime.h>
+ * #include <stdio.h>
+ *
+ * OMTensorList *run_main_graph(OMTensorList *);
+ *
+ * OMTensorList *create_input_list() {
+ *   // Shared shape & rank.
+ *   int64_t shape[] = {3, 2};
+ *   int64_t num_elements = shape[0] * shape[1];
+ *   int64_t rank = 2;
+ *
+ *   // Construct float arrays filled with 1s or 2s.
+ *   float *x1Data = (float *)malloc(sizeof(float) * num_elements);
+ *   for (int i = 0; i < num_elements; i++)
+ *     x1Data[i] = 1.0;
+ *   float *x2Data = (float *)malloc(sizeof(float) * num_elements);
+ *   for (int i = 0; i < num_elements; i++)
+ *     x2Data[i] = 2.0;
+ *
+ *   // Use omTensorCreateWithOwnership "true" so float arrays are automatically
+ *   // freed when the Tensors are destroyed.
+ *   OMTensor *x1 = omTensorCreateWithOwnership(x1Data, shape, rank, ONNX_TYPE_FLOAT, true);
+ *   OMTensor *x2 = omTensorCreateWithOwnership(x2Data, shape, rank, ONNX_TYPE_FLOAT, true);
+ *
+ *   // Construct a TensorList using the Tensors
+ *   OMTensor *list[2] = {x1, x2};
+ *   return omTensorListCreate(list, 2);
+ * }
+ *
+ * int main() {
+ *   // Generate input TensorList
+ *   OMTensorList *input_list = create_input_list();
+ *
+ *   // Call the compiled onnx model function.
+ *   OMTensorList *output_list = run_main_graph(input_list);
+ *   if (!output_list) {
+ *     // May inspect errno to get info about the error.
+ *     return 1;
+ *   }
+ *
+ *   // Get the first tensor from output list.
+ *   OMTensor *y = omTensorListGetOmtByIndex(output_list, 0);
+ *   float *outputPtr = (float *) omTensorGetDataPtr(y);
+ *
+ *   // Print its content, should be all 3.
+ *   for (int i = 0; i < 6; i++)
+ *     printf("%f ", outputPtr[i]);
+ *   printf("\n");
+ *
+ *   // Destory the list and the tensors inside of it.
+ *   // Use omTensorListDestroyShallow if only want to destroy the list themselves.
+ *   omTensorListDestroy(input_list);
+ *   omTensorListDestroy(output_list);
+ *   return 0;
+ * }
+ * ```
+ *
+ * Compile with `gcc main.c add.so -o add`, you should see an executable `add`
+ * appearing. Run it, and the output should be:
+ *
+ * ```
+ * 3.000000 3.000000 3.000000 3.000000 3.000000 3.000000
+ * ```
+ * Exactly as it should be.
+ *
+ * \subsection freeing-tensor-memory Freeing Tensor Memory
+ *
+ * In general, if a caller creates a tensor object (omTensorCreate), they are
+ * responsible for deallocating the data buffer separately after the tensor is
+ * destroyed. If onnx-mlir creates the tensor (run_main_graph), then the
+ * tensor object owns the data buffer and it is freed automatically when the
+ * tensor is destroyed.
+ *
+ * This default behavior can be changed. When creating a tensor, a user may use
+ * omTensorCreateWithOwnership to explicitly set data buffer ownership. Additionally,
+ * after a tenor is created, omTensorSetOwning can be used to change
+ * the ownership setting.
+ *
+ * When omTensorDestroy is called, if the ownership flag is set to "true",
+ * then the destruction of the tensor will also free any associated data buffer
+ * memory. If the ownership flag is set to "false", then the user is responsible
+ * for freeing the data buffer memory after destroying the tensor.
+ *
+ * For tensor list objects, when omTensorListDestory is called, omTensorDestory
+ * is called on all tensors the list contained. The data buffer of each tensor
+ * is freed based on each tensor's ownership setting.
+ *
+ * To destroy a TensorList without automatically destorying the tensors it
+ * contained, use omTensorListDestroyShallow.
+ *
+ * \subsection reference Reference
+ *
+ * For full reference to available C Runtime API, refer to
+ * `include/onnx-mlir/Runtime/OMTensor.h` and
+ * `include/onnx-mlir/Runtime/OMTensorList.h`.
+ *
+ */
+
+#endif // ONNX_MLIR_ONNXMLIRRUNTIME_H

onnx-mlir/include/OnnxMlirRuntime.h

@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: Apache-2.0
+
+add_subdirectory(Runtime)
+add_subdirectory(Compiler)

onnx-mlir/include/onnx-mlir/CMakeLists.txt

@@ -0,0 +1,4 @@
+# SPDX-License-Identifier: Apache-2.0
+
+install(FILES OMCompilerTypes.h DESTINATION include/onnx-mlir/Compiler)
+install(FILES OMCompilerMacros.h DESTINATION include/onnx-mlir/Compiler)

onnx-mlir/include/onnx-mlir/Compiler/CMakeLists.txt

@@ -0,0 +1,29 @@
+/*
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//====----------------- Compiler.h - Compiler abstraction support ---------===//
+//
+// Copyright 2022 The IBM Research Authors.
+//
+// =============================================================================
+//
+// This file defines several macros, which allows use of compiler-specific
+// features in a way that remains portable. This header can be included from
+// either C or C++.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef ONNX_MLIR_COMPILER_MACROS_H
+#define ONNX_MLIR_COMPILER_MACROS_H
+
+/// OM_EXTERNAL_VISIBILITY - classes, functions, and variables marked with this
+/// keywork will be made public and visible outside of any shared library they
+/// are linked in to.
+#if defined(_WIN32)
+#define OM_EXTERNAL_VISIBILITY __declspec(dllexport)
+#else
+#define OM_EXTERNAL_VISIBILITY
+#endif
+
+#endif // ONNX_MLIR_COMPILER_MACROS_H