[Draft] Implement Checkpoint APIs

runtime/onert/api/nnfw/include/nnfw_experimental.h

@@ -375,6 +375,28 @@ NNFW_STATUS nnfw_train_get_loss(nnfw_session *session, uint32_t index, float *lo
  */
 NNFW_STATUS nnfw_train_export_circle(nnfw_session *session, const char *path);
 
+/**
+ * @brief Import circle checkpoint
+ * @note  This function should be called on training mode
+ *        This function should be called before {@link nnfw_train}
+ *
+ * @param[in] session The session to export a checkpoint
+ * @param[in] path    The path to export a checkpoint
+ * @return @c NNFW_STATUS_NO_ERROR if successful
+ */
+NNFW_STATUS nnfw_train_import_checkpoint(nnfw_session *session, const char *path);
+
+/**
+ * @brief Export circle checkpoint
+ * @note  This function should be called on training mode
+ *        This function should be called after {@link nnfw_train}
+ *
+ * @param[in] session The session to export a checkpoint
+ * @param[in] path    The path to export a checkpoint
+ * @return @c NNFW_STATUS_NO_ERROR if successful
+ */
+NNFW_STATUS nnfw_train_export_checkpoint(nnfw_session *session, const char *path);
+
 //////////////////////////////////////////////
 // Optional APIs for training
 //////////////////////////////////////////////

runtime/onert/api/nnfw/src/nnfw_api.cc

@@ -464,6 +464,18 @@ NNFW_STATUS nnfw_train_export_circleplus(nnfw_session *session, const char *path
   return session->train_export_circleplus(path);
 }
 
+NNFW_STATUS nnfw_train_import_checkpoint(nnfw_session *session, const char *path)
+{
+  NNFW_RETURN_ERROR_IF_NULL(session);
+  return session->train_import_checkpoint(path);
+}
+
+NNFW_STATUS nnfw_train_export_checkpoint(nnfw_session *session, const char *path)
+{
+  NNFW_RETURN_ERROR_IF_NULL(session);
+  return session->train_export_checkpoint(path);
+}
+
 // Quantization
 
 NNFW_STATUS nnfw_set_quantization_type(nnfw_session *session, NNFW_QUANTIZE_TYPE qtype)

runtime/onert/api/nnfw/src/nnfw_api_internal.cc

@@ -21,11 +21,13 @@
 #include "util/Exceptions.h"
 #include "util/logging.h"
 #include "exec/Execution.h"
+#include "loader/CheckpointLoader.h"
 #include "loader/CircleLoader.h"
 #include "loader/ModelLoader.h"
 #include "loader/TFLiteLoader.h"
 #include "loader/TrainInfoLoader.h"
 #include "exporter/CircleExporter.h"
+#include "exporter/CheckpointExporter.h"
 #include "json/json.h"
 #include "ir/NNPkg.h"
 #include "ir/OpCode.h"
@@ -1701,6 +1703,61 @@ NNFW_STATUS nnfw_session::train_export_circleplus(const char *path)
   return NNFW_STATUS_NO_ERROR;
 }
 
+NNFW_STATUS nnfw_session::train_import_checkpoint(const char *path)
+{
+  if (path == nullptr)
+  {
+    std::cerr << "Error during nnfw_session::train_import_checkpoint : path is null" << std::endl;
+    return NNFW_STATUS_UNEXPECTED_NULL;
+  }
+
+  if (!isStatePreparedOrFinishedTraining())
+  {
+    std::cerr << "Error during nnfw_session::train_import_checkpoint : invalid state" << std::endl;
+    return NNFW_STATUS_INVALID_STATE;
+  }
+
+  try
+  {
+    onert::loader::loadCheckpoint(path, _train_info, _execution);
+  }
+  catch (const std::exception &e)
+  {
+    std::cerr << "Error during nnfw_session::train_import_checkpoint : " << e.what() << std::endl;
+    return NNFW_STATUS_ERROR;
+  }
+
+  return NNFW_STATUS_NO_ERROR;
+}
+
+NNFW_STATUS nnfw_session::train_export_checkpoint(const char *path)
+{
+  if (path == nullptr)
+  {
+    std::cerr << "Error during nnfw_session::train_export_checkpoint : path is null" << std::endl;
+    return NNFW_STATUS_UNEXPECTED_NULL;
+  }
+
+  // Check training mode is enabled
+  if (!isStateFinishedTraining())
+  {
+    std::cerr << "Error during nnfw_session::train_export_checkpoint : invalid state" << std::endl;
+    return NNFW_STATUS_INVALID_STATE;
+  }
+
+  try
+  {
+    onert::exporter::exportCheckpoint(path, _train_info, _execution);
+  }
+  catch (const std::exception &e)
+  {
+    std::cerr << "Error during nnfw_session::train_export_checkpoint : " << e.what() << std::endl;
+    return NNFW_STATUS_ERROR;
+  }
+
+  return NNFW_STATUS_NO_ERROR;
+}
+
 bool nnfw_session::isStatePreparedTraining()
 {
   if (_state == State::PREPARED_TRAINING)

runtime/onert/api/nnfw/src/nnfw_api_internal.h

@@ -184,6 +184,8 @@ struct nnfw_session
   NNFW_STATUS train_get_loss(uint32_t index, float *loss);
   NNFW_STATUS train_export_circle(const char *path);
   NNFW_STATUS train_export_circleplus(const char *path);
+  NNFW_STATUS train_import_checkpoint(const char *path);
+  NNFW_STATUS train_export_checkpoint(const char *path);
 
   NNFW_STATUS set_quantization_type(NNFW_QUANTIZE_TYPE qtype);
   NNFW_STATUS set_quantized_model_path(const char *path);

runtime/onert/core/include/exporter/CheckpointExporter.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd. 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 __ONERT_EXPORTER_CHECKPOINT_EXPORTER_H__
+#define __ONERT_EXPORTER_CHECKPOINT_EXPORTER_H__
+
+#include <string>
+#include <vector>
+#include <memory>
+
+#include "ir/Checkpoint.h"
+
+namespace onert
+{
+namespace exec
+{
+class Execution;
+} // namespace exec
+namespace ir
+{
+namespace train
+{
+class TrainingInfo;
+} // namespace train
+} // namespace ir
+} // namespace onert
+
+namespace onert
+{
+namespace exporter
+{
+
+void exportCheckpoint(const std::string &filename,
+                      const std::unique_ptr<ir::train::TrainingInfo> &train_info,
+                      const std::unique_ptr<onert::exec::Execution> &exec);
+
+} // namespace exporter
+} // namespace onert
+
+#endif // __ONERT_EXPORTER_CHECKPOINT_EXPORTER_H__

runtime/onert/core/include/ir/Checkpoint.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd. 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 __ONERT_IR_CHECKPOINT_H__
+#define __ONERT_IR_CHECKPOINT_H__
+
+namespace onert
+{
+namespace checkpoint
+{
+
+struct __attribute__((packed)) Header
+{
+  uint16_t magic;
+  uint8_t schema;
+  uint8_t reserved;
+  uint32_t opt1_offset;
+  uint32_t opt2_offset;
+  uint32_t other_offset;
+  uint32_t length;
+};
+
+struct __attribute__((packed)) Footer
+{
+  uint32_t cur_step;
+  uint32_t cur_epoch;
+};
+
+constexpr uint16_t MAGIC_NUMBER = 429;
+constexpr uint8_t SCHEMA_VERSION = 1;
+
+} // namespace checkpoint
+} // namespace onert
+
+#endif // __ONERT_IR_CHECKPOINT_H__

runtime/onert/core/include/loader/CheckpointLoader.h

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd. 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 __ONERT_LOADER_CHECKPOINT_LOADER_H__
+#define __ONERT_LOADER_CHECKPOINT_LOADER_H__
+
+#include <string>
+#include <memory>
+
+namespace onert
+{
+namespace exec
+{
+class Execution;
+} // namespace exec
+namespace ir
+{
+namespace train
+{
+class TrainingInfo;
+} // namespace train
+} // namespace ir
+} // namespace onert
+
+namespace onert
+{
+namespace loader
+{
+
+void loadCheckpoint(const std::string &filename,
+                    const std::unique_ptr<ir::train::TrainingInfo> &train_info,
+                    const std::unique_ptr<onert::exec::Execution> &exec);
+
+} // namespace loader
+} // namespace onert
+
+#endif // __ONERT_LOADER_CHECKPOINT_LOADER_H__