Fixing Cadmium v1

devstone/cadmium/CMakeLists.txt

@@ -1,43 +1,21 @@
 cmake_minimum_required(VERSION 3.10)
 project(devstone-cadmium)
+
 set (CMAKE_CXX_STANDARD 17)
 set (CMAKE_CXX_COMPILER "g++")
-set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/bin)
-
-if(NOT CMAKE_BUILD_TYPE)
-    set(CMAKE_BUILD_TYPE Release)
-endif()
-set(CMAKE_CXX_FLAGS_DEBUG "-g")
-set(CMAKE_CXX_FLAGS_RELEASE "-O3")
+add_compile_options(-O3)
 
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../../simulators/cadmium/include)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src)
 
-find_package(Boost COMPONENTS program_options thread unit_test_framework REQUIRED)
+set(Boost_USE_STATIC_LIBS ON)
 
-set(Boost_USE_STATIC_LIBS        ON)
-set(Boost_USE_MULTITHREADED     OFF)
+find_package(Boost COMPONENTS program_options unit_test_framework REQUIRED)
 
 include_directories(${Boost_INCLUDE_DIRS})
 
 ## Cadmium dynamic
-add_executable(cadmium-dynamic-devstone
-        src/cadmium-dynamic-devstone.cpp
-        src/cadmium-devstone-atomic.hpp src/cadmium-event-reader.hpp
-        events_devstone.txt
-        )
+add_executable(cadmium-dynamic-devstone src/cadmium-dynamic-devstone.cpp
+        events_devstone.txt)
 target_link_libraries(cadmium-dynamic-devstone
-        ${Boost_PROGRAM_OPTIONS_LIBRARY} ${UTILOBJS}
-        )
-
-## Cadmium dynamic, concurrent version
-add_executable(cadmium-dynamic-conc-devstone
-        src/cadmium-dynamic-devstone.cpp
-        src/cadmium-devstone-atomic.hpp src/cadmium-event-reader.hpp
-        events_devstone.txt
-        )
-
-target_compile_definitions(cadmium-dynamic-conc-devstone
-        PUBLIC CADMIUM_EXECUTE_CONCURRENT
-        )
-target_link_libraries(cadmium-dynamic-conc-devstone ${Boost_LIBRARIES} ${UTILOBJS})
+    ${Boost_PROGRAM_OPTIONS_LIBRARY} ${UTILOBJS})

devstone/cadmium/src/cadmium-devstone-atomic.hpp

@@ -1,3 +1,28 @@
+/**
+ * Copyright (c) 2017, Damian Vicino
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
 #ifndef CADMIUM_DEVSTONE_ATOMIC_HPP
 #define CADMIUM_DEVSTONE_ATOMIC_HPP
 
@@ -5,21 +30,18 @@
 #include<cadmium/modeling/message_bag.hpp>
 #include<limits>
 
+#include "../../dhry/dhry_1.c"
+
+
 /**
- * @brief DEVStone atomic model state.
- * @tparam TIME data type used to represent the time.
- */
-template<typename TIME>
-struct devstone_state {
-    TIME sigma;
-    unsigned int n_internals, n_externals, n_events;
-    devstone_state(): sigma(std::numeric_limits<TIME>::infinity()), n_internals(), n_externals(), n_events() {}
-
-    friend std::ostream &operator << (std::ostream &os, const devstone_state<TIME> &s) {
-        os << s.n_internals << " ; " << s.n_externals << " ; " << s.n_events;
-        return os;
-    }
-};
+ * @brief PDEVStone Atomic Model.
+ *
+ * PDEVStone (InternalTime, ExternalTime, Period):
+ * This model executes:
+ * - a Dhrystone for InternalCycles on each Internal transition,
+ * - a Dhrystone for ExternalCycles on each External transition,
+ * - the time advance after each external transition is Period.
+*/
 
 //  an integer input and output port for the model
 struct devstone_atomic_defs{
@@ -28,53 +50,68 @@ struct devstone_atomic_defs{
     struct out : public cadmium::out_port<int> {};
 };
 
+
 template<typename TIME>
-struct devstone_atomic {
+class devstone_atomic {
     using defs=devstone_atomic_defs;
-    using input_ports=std::tuple<typename defs::in>;
-    using output_ports=std::tuple<typename defs::out>;
-    using outbag_t=typename cadmium::make_message_bags<output_ports>::type;
-    using state_type=devstone_state<TIME>;
-
-    state_type state = devstone_state<TIME>();
-    [[maybe_unused]] int internal_cycles, external_cycles;
-    outbag_t outbag;
-
-    constexpr devstone_atomic() noexcept: internal_cycles(), external_cycles() {
+public:
+    // default constructor
+    constexpr devstone_atomic() noexcept {
         //preparing the output bag, since we return always same message
         cadmium::get_messages<typename defs::out>(outbag).emplace_back(1);
     }
 
-    constexpr devstone_atomic(int int_cycles, int ext_cycles) noexcept: internal_cycles(int_cycles), external_cycles(ext_cycles) {
+    constexpr devstone_atomic(int ext_cycles, int int_cycles, TIME time_advance) noexcept
+        : period(time_advance), external_cycles(ext_cycles), internal_cycles(int_cycles){
         //preparing the output bag, since we return always same message
         cadmium::get_messages<typename defs::out>(outbag).emplace_back(1);
     }
 
+    // state definition
+    using queued_processes=int; //for readability
+    using state_type=queued_processes;
+    state_type state = 0;
+
+    // ports definition
+    using input_ports=std::tuple<typename defs::in>;
+    using output_ports=std::tuple<typename defs::out>;
+
+protected:
+    /*
+     * This model executes:
+     * - a Dhrystone for InternalCycles on each Internal transition,
+     * - a Dhrystone for ExternalCycles on each External transition,
+     * - the time advance after each external transition is Period.
+     * The following 3 variables need to be overriden by the inheriting model constructor.
+     */
+    TIME period=std::numeric_limits<float>::infinity();
+    int external_cycles=-1;
+    int internal_cycles=-1;
+    using outbag_t=typename cadmium::make_message_bags<output_ports>::type;
+    outbag_t outbag;
+
 public:
     void internal_transition() {
-        // DhryStone().dhrystoneRun(internal_cycles);  // TODO enable Dhrystone cycles
-        state.sigma = std::numeric_limits<TIME>::infinity();
-        state.n_internals += 1;
+        DhryStone().dhrystoneRun(internal_cycles);
+        state--;
     }
 
     void external_transition(TIME e, typename cadmium::make_message_bags<input_ports>::type mbs) {
-        // DhryStone().dhrystoneRun(external_cycles);  // TODO enable Dhrystone cycles
-        state.sigma = TIME();
-        state.n_externals += 1;
-        state.n_events += cadmium::get_messages<typename defs::in>(mbs).size();
+        DhryStone().dhrystoneRun(external_cycles);
+        state+= cadmium::get_messages<typename defs::in>(mbs).size();
     }
 
-    [[maybe_unused]] void confluence_transition(TIME e, typename cadmium::make_message_bags<input_ports>::type mbs) {
+    void confluence_transition(TIME e, typename cadmium::make_message_bags<input_ports>::type mbs) {
         internal_transition();
         external_transition(e, mbs);
     }
 
-    [[maybe_unused]][[nodiscard]] outbag_t output() const {
+    outbag_t output() const {
         return outbag;
     }
 
-    [[maybe_unused]] TIME time_advance() const {
-        return state.sigma;
+    TIME time_advance() const {
+        return (state!=0?period:std::numeric_limits<TIME>::infinity());
     }
 };
 

devstone/cadmium/src/cadmium-dynamic-devstone.cpp

@@ -26,6 +26,7 @@
 #include <iostream>
 #include <chrono>
 #include <algorithm>
+#include <fstream>
 
 #include <boost/program_options.hpp>
 
@@ -93,13 +94,13 @@ int main(int argc, char* argv[]){
     auto processed_parameters = hclock::now();
 
     std::shared_ptr<cadmium::dynamic::modeling::coupled<Time>> TOP_coupled;
-    if (kind == "LI"){
+    if (kind.compare("LI") == 0){
         TOP_coupled = create_LI_model(width,depth, ext_cycles, int_cycles, time_advance);
-    } else if (kind == "HI") {
+    } else if (kind.compare("HI") == 0) {
         TOP_coupled = create_HI_model(width, depth, ext_cycles, int_cycles, time_advance);
-    } else if (kind == "HO") {
+    } else if (kind.compare("HO") == 0) {
         TOP_coupled = create_HO_model(width,depth, ext_cycles, int_cycles, time_advance);
-    } else if (kind == "HOmod") {
+    } else if (kind.compare("HOmod") == 0) {
         TOP_coupled = create_HOmod_model(width,depth, ext_cycles, int_cycles, time_advance);
     } else {
         abort();

devstone/cadmium/src/dynamic/LI_generator.cpp

@@ -30,9 +30,15 @@
 #include "../cadmium-devstone-atomic.hpp"
 #include "../cadmium-event-reader.hpp"
 
+//#include <cadmium/modeling/coupled_model.hpp>
 #include <cadmium/modeling/ports.hpp>
 #include <cadmium/modeling/dynamic_model_translator.hpp>
+#include <cadmium/concept/coupled_model_assert.hpp>
+#include <cadmium/modeling/dynamic_coupled.hpp>
+#include <cadmium/modeling/dynamic_atomic.hpp>
+#include <cadmium/engine/pdevs_dynamic_runner.hpp>
 #include <cadmium/logger/tuple_to_ostream.hpp>
+#include <cadmium/logger/common_loggers.hpp>
 
 using TIME = float;
 
@@ -40,14 +46,15 @@ using TIME = float;
 struct coupledLI_in_port : public cadmium::in_port<int>{};
 struct coupledLI_out_port : public cadmium::out_port<int>{};
 
-std::shared_ptr<cadmium::dynamic::modeling::coupled<TIME>> create_LI_model(uint width, uint depth, int int_cycles, int ext_cycles) {
+std::shared_ptr<cadmium::dynamic::modeling::coupled<TIME>> create_LI_model(
+        uint width, uint depth, int ext_cycles, int int_cycles, TIME time_advance) {
     // Creates the LI model with the passed parameters
     // Returns a shared_ptr to the TOP model
-    auto make_atomic_devstone = [&ext_cycles, &int_cycles](const std::string& model_id) -> std::shared_ptr<cadmium::dynamic::modeling::model> {
-        return cadmium::dynamic::translate::make_dynamic_atomic_model<devstone_atomic, TIME>(model_id, int_cycles, ext_cycles);
+    auto make_atomic_devstone = [&ext_cycles, &int_cycles, &time_advance](std::string model_id) -> std::shared_ptr<cadmium::dynamic::modeling::model> {
+        return cadmium::dynamic::translate::make_dynamic_atomic_model<devstone_atomic, TIME>(model_id, ext_cycles, int_cycles, time_advance);
     };
-    //Level 1 has always a single model
-    std::shared_ptr<cadmium::dynamic::modeling::model> devstone_atomic_L1_1 = make_atomic_devstone("devstone_atomic_L1_1");
+    //Level 0 has always a single model
+    std::shared_ptr<cadmium::dynamic::modeling::model> devstone_atomic_L0_0 = make_atomic_devstone("devstone_atomic_L0_0");
 
     std::unordered_map<int, cadmium::dynamic::modeling::Models> atomics_by_level;
     std::unordered_map<int, std::shared_ptr<cadmium::dynamic::modeling::model>> coupleds_by_level;
@@ -56,12 +63,16 @@ std::shared_ptr<cadmium::dynamic::modeling::coupled<TIME>> create_LI_model(uint
     cadmium::dynamic::modeling::Ports coupled_out_ports = {typeid(coupledLI_out_port)};
     cadmium::dynamic::modeling::ICs ics = {}; //LI models have no Internal coupling
 
-    for (int level=2; level <= depth; level++) {
+    for (int level=1; level <= depth; level++) {
+
         //atomics
         std::vector<std::shared_ptr<cadmium::dynamic::modeling::model>> atomics_current_level;
-        for(int idx_atomic=1; idx_atomic < width; idx_atomic++) {
-            std::string atomic_name = "devstone_atomic_L" + std::to_string(level) + "_" + std::to_string(idx_atomic);
-            atomics_current_level.push_back(make_atomic_devstone(atomic_name));
+        if (level < depth) {
+            //Last level does not have atomics
+            for(int idx_atomic=0; idx_atomic < width-1; idx_atomic++) {
+                std::string atomic_name = "devstone_atomic_L" + std::to_string(level) + "_" + std::to_string(idx_atomic);
+                atomics_current_level.push_back(make_atomic_devstone(atomic_name));
+            }
         }
         atomics_by_level[level] = atomics_current_level;
 
@@ -69,13 +80,13 @@ std::shared_ptr<cadmium::dynamic::modeling::coupled<TIME>> create_LI_model(uint
         cadmium::dynamic::modeling::Models Lcoupled_submodels;
         cadmium::dynamic::modeling::EICs Lcoupled_eics;
         cadmium::dynamic::modeling::EOCs Lcoupled_eocs;
-        if (level == 2) {
-            Lcoupled_submodels= { devstone_atomic_L1_1};
+        if (level == 1) {
+            Lcoupled_submodels= {devstone_atomic_L0_0};
             Lcoupled_eics = {
-                cadmium::dynamic::translate::make_EIC<coupledLI_in_port, devstone_atomic_defs::in>("devstone_atomic_L1_1")
+                cadmium::dynamic::translate::make_EIC<coupledLI_in_port, devstone_atomic_defs::in>("devstone_atomic_L0_0")
             };
             Lcoupled_eocs = {
-              cadmium::dynamic::translate::make_EOC<devstone_atomic_defs::out,coupledLI_out_port>("devstone_atomic_L1_1")
+              cadmium::dynamic::translate::make_EOC<devstone_atomic_defs::out,coupledLI_out_port>("devstone_atomic_L0_0")
             };
         } else {
             std::shared_ptr<cadmium::dynamic::modeling::model> coupled_prev_level = coupleds_by_level[level - 1];
@@ -84,19 +95,19 @@ std::shared_ptr<cadmium::dynamic::modeling::coupled<TIME>> create_LI_model(uint
 
             Lcoupled_eics = {
                 cadmium::dynamic::translate::make_EIC<coupledLI_in_port, coupledLI_in_port>(
-                    coupled_prev_level->get_id()
+                    coupled_prev_level.get()->get_id()
                 )
             };
 
             Lcoupled_eocs = {
                 cadmium::dynamic::translate::make_EOC<coupledLI_out_port, coupledLI_out_port>(
-                    coupled_prev_level->get_id()
+                    coupled_prev_level.get()->get_id()
                 )
             };
-            for (const auto& atomic : atomics_by_level[level - 1]) {
+            for (auto atomic : atomics_by_level[level - 1]) {
                 Lcoupled_submodels.push_back(atomic);
                 Lcoupled_eics.push_back(
-                    cadmium::dynamic::translate::make_EIC<coupledLI_in_port, devstone_atomic_defs::in>(atomic->get_id())
+                    cadmium::dynamic::translate::make_EIC<coupledLI_in_port, devstone_atomic_defs::in>(atomic.get()->get_id())
                 );
             }
         }
@@ -135,5 +146,6 @@ std::shared_ptr<cadmium::dynamic::modeling::coupled<TIME>> create_LI_model(uint
      TOP_eocs,
      TOP_ics
     );
+
     return TOP_coupled;
 }