State saving support with proxyfmu

Author: davidhjp01

conanfile.py

@@ -43,7 +43,7 @@ def requirements(self):
         self.requires("libzip/[>=1.7 <1.10]") # 1.10 deprecates some functions we use
         self.requires("ms-gsl/[>=3 <5]", transitive_headers=True)
         if self.options.proxyfmu:
-            self.requires("proxyfmu/0.3.2@osp/stable")
+            self.requires("proxyfmu/0.3.3@osp/testing-feature_779-state-serialization")
             self.requires("boost/[~1.81]", transitive_headers=True, transitive_libs=True) # Required by Thrift
         else:
             self.requires("boost/[>=1.71]", transitive_headers=True, transitive_libs=True)

src/cosim/proxy/remote_fmu.cpp

@@ -71,6 +71,8 @@ std::unique_ptr<cosim::model_description> parse_model_description(const proxyfmu
     _md->author = md.author;
     _md->name = md.modelName;
     _md->description = md.description;
+    _md->capabilities.can_get_and_set_fmu_state = md.canGetAndSetFMUstate;
+    _md->capabilities.can_serialize_fmu_state = md.canSerializeFMUstate;
 
     for (auto& var : md.modelVariables) {
         cosim::variable_description vd;

src/cosim/proxy/remote_slave.cpp

@@ -6,6 +6,7 @@
 #include <cosim/error.hpp>
 #include <cosim/exception.hpp>
 #include <cosim/proxy/remote_slave.hpp>
+#include <proxyfmu/thrift/defs_types.h>
 
 #include <utility>
 
@@ -204,45 +205,60 @@ void cosim::proxy::remote_slave::set_string_variables(gsl::span<const cosim::val
 
 cosim::slave::state_index cosim::proxy::remote_slave::save_state()
 {
-    throw error(
-        make_error_code(errc::unsupported_feature),
-        "Proxyfmu does not support state saving");
+    return slave_->save_state();
 }
 
-void cosim::proxy::remote_slave::save_state(state_index)
+void cosim::proxy::remote_slave::save_state(state_index idx)
 {
-    throw error(
-        make_error_code(errc::unsupported_feature),
-        "Proxyfmu does not support state saving");
+    slave_->save_state(idx);
 }
 
-void cosim::proxy::remote_slave::restore_state(state_index)
+void cosim::proxy::remote_slave::restore_state(state_index idx)
 {
-    throw error(
-        make_error_code(errc::unsupported_feature),
-        "Proxyfmu does not support state saving");
+    slave_->restore_state(idx);
 }
 
-void cosim::proxy::remote_slave::release_state(state_index)
+void cosim::proxy::remote_slave::release_state(state_index idx)
 {
-    throw error(
-        make_error_code(errc::unsupported_feature),
-        "Proxyfmu does not support state saving");
+    slave_->release_state(idx);
 }
 
-cosim::serialization::node cosim::proxy::remote_slave::export_state(state_index) const
+cosim::serialization::node cosim::proxy::remote_slave::export_state(state_index idx) const
 {
-    throw error(
-        make_error_code(errc::unsupported_feature),
-        "Proxyfmu does not support state serialization");
+    proxyfmu::thrift::ExportedState state;
+    slave_->export_state(idx, state);
+
+    // Create the exported state
+    serialization::node exportedState;
+    exportedState.put("scheme_version", state.schemeVersion);
+    exportedState.put("fmu_uuid", state.uuid);
+
+    std::vector<std::byte> vec;
+    std::transform(state.fmuState.begin(), state.fmuState.end(), std::back_inserter(vec),
+        [](unsigned char c) { return std::byte(c); });
+
+    exportedState.put("serialized_fmu_state", vec);
+    exportedState.put("setup_complete", state.setupComplete);
+    exportedState.put("simulation_started", state.simStarted);
+    return exportedState;
 }
 
 cosim::slave::state_index cosim::proxy::remote_slave::import_state(
-    const cosim::serialization::node&)
+    const cosim::serialization::node& node)
 {
-    throw error(
-        make_error_code(errc::unsupported_feature),
-        "Proxyfmu does not support state serialization");
+    proxyfmu::thrift::ExportedState state;
+    state.schemeVersion = node.get<std::int32_t>("scheme_version");
+    state.uuid = node.get<std::string>("fmu_uuid");
+
+    const auto& serializedFMUState = std::get<std::vector<std::byte>>(
+        node.get_child("serialized_fmu_state").data());
+    state.fmuState.reserve(serializedFMUState.size());
+    std::transform(serializedFMUState.begin(), serializedFMUState.end(), std::back_inserter(state.fmuState),
+        [](std::byte b) { return static_cast<unsigned char>(b); });
+
+    state.setupComplete = node.get<bool>("setup_complete");
+    state.simStarted = node.get<bool>("simulation_started");
+    return slave_->import_state(state);
 }
 
 cosim::proxy::remote_slave::~remote_slave()

tests/data/msmi/OspSystemStructure_BouncingBall_proxyfmu.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<OspSystemStructure
+        xmlns="http://opensimulationplatform.com/MSMI/OSPSystemStructure"
+        version="0.1">
+    <StartTime>0.0</StartTime>
+    <BaseStepSize>0.01</BaseStepSize>
+    <Algorithm>fixedStep</Algorithm>
+    <Simulators>
+        <Simulator name="bouncingball" source="proxyfmu://localhost?file=../fmi2/BouncingBall.fmu">
+        </Simulator>
+    </Simulators>
+    <Connections>
+    </Connections>
+</OspSystemStructure>

tests/save_state_test.cpp

@@ -38,7 +38,7 @@ std::vector<double> get_reals(
     return values;
 }
 
-int main()
+int run(const cosim::filesystem::path& configPath)
 {
     try {
         cosim::log::setup_simple_console_logging();
@@ -49,10 +49,6 @@ int main()
         // ================================================================
         constexpr cosim::duration stepSize = cosim::to_duration(0.05);
 
-        const auto testDataDir = std::getenv("TEST_DATA_DIR");
-        REQUIRE(testDataDir);
-        auto configPath = cosim::filesystem::path(testDataDir) / "msmi" / "OspSystemStructure_BouncingBall.xml";
-
         auto resolver = cosim::default_model_uri_resolver();
         const auto config = cosim::load_osp_config(configPath, *resolver);
         auto execution = cosim::execution(
@@ -212,7 +208,26 @@ int main()
         REQUIRE(state2ValuesAgain == state2Values);
     } catch (const std::exception& e) {
         std::cerr << "Error: " << e.what() << std::endl;
-        return 1;
+        return 0;
     }
+    return 1;
+}
+
+int main()
+{
+    const auto testDataDir = std::getenv("TEST_DATA_DIR");
+    REQUIRE(testDataDir);
+
+    auto configPath1 = cosim::filesystem::path(testDataDir) / "msmi" / "OspSystemStructure_BouncingBall.xml";
+    auto result1 = run(configPath1);
+
+    std::cout << "Result 1: " << result1 << std::endl;
+
+    auto configPath2 = cosim::filesystem::path(testDataDir) / "msmi" / "OspSystemStructure_BouncingBall_proxyfmu.xml";
+    auto result2 = run(configPath2);
+
+    std::cout << "Result 2: " << result2 << std::endl;
+
+    REQUIRE(result1 && result2);
     return 0;
 }