732 benchmarks for abm model

cpp/CMakeLists.txt

@@ -16,12 +16,16 @@ option(MEMILIO_SANITIZE_UNDEFINED "Enable undefined behavior sanitizer." OFF)
 option(MEMILIO_BUILD_SHARED_LIBS "Build memilio as a shared library." ON)
 option(MEMILIO_BUILD_STATIC_LIBS "Build memilio as a static library." ON)
 option(MEMILIO_ENABLE_MPI "Build memilio with MPI." OFF)
+option(MEMILIO_ENABLE_OPENMP "Enable Multithreading with OpenMP." ON)
 
 mark_as_advanced(MEMILIO_USE_BUNDLED_SPDLOG MEMILIO_SANITIZE_ADDRESS MEMILIO_SANITIZE_UNDEFINED)
 
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 
+# needed for likwid marker api
+find_package(LIKWID REQUIRED)
+
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Please choose Release or Debug. Default is Release." FORCE)
 endif()
@@ -100,8 +104,8 @@ endif((CMAKE_CXX_COMPILER_ID STREQUAL "GNU") AND(CMAKE_CXX_COMPILER_VERSION VERS
 # define flags to enable most warnings and treat them as errors for different compilers
 # add flags to each target separately instead of globally so users have the choice to use their own flags
 if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-    set(MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS
-        "-Wno-unknown-warning;-Wno-pragmas;-Wall;-Wextra;-Werror;-Wshadow;--pedantic-errors;-Wno-deprecated-copy")
+    #set(MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS
+    #    "-Wno-unknown-warning;-Wno-pragmas;-Wall;-Wextra;-Werror;-Wshadow;--pedantic-errors;-Wno-deprecated-copy;-Wno-expansion-to-defined")
 elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
     set(MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS
         "-Wno-unknown-warning-option;-Wall;-Wextra;-Werror;-Wshadow;--pedantic-errors;-Wno-deprecated;-Wno-gnu-zero-variadic-macro-arguments")

cpp/examples/CMakeLists.txt

@@ -4,68 +4,96 @@ configure_file(data_dir.h.in data_dir.h)
 
 add_executable(euler_example euler_test.cpp)
 target_link_libraries(euler_example PRIVATE memilio)
+target_compile_options(euler_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 add_executable(ode_secir_parameter_sampling_example ode_secir_parameter_sampling.cpp)
 target_link_libraries(ode_secir_parameter_sampling_example PRIVATE memilio ode_secir)
+target_compile_options(ode_secir_parameter_sampling_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 add_executable(adapt_rk_example adapt_rk_test.cpp)
 target_link_libraries(adapt_rk_example PRIVATE memilio)
+target_compile_options(adapt_rk_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 add_executable(ode_seir_example ode_seir.cpp)
-target_link_libraries(ode_seir_example PRIVATE memilio ode_seir)
+target_include_directories(ode_seir_example PRIVATE ${LIKWID_INCLUDE_DIRS})
+target_link_libraries(ode_seir_example PRIVATE memilio ode_seir ${LIKWID_LIBRARIES})
+target_compile_options(ode_seir_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+target_compile_definitions(ode_seir_example PRIVATE "-DLIKWID_PERFMON")
 
 add_executable(ode_secir_example ode_secir.cpp)
-target_link_libraries(ode_secir_example PRIVATE memilio ode_secir)
+target_include_directories(ode_secir_example PRIVATE ${LIKWID_INCLUDE_DIRS})
+target_link_libraries(ode_secir_example PRIVATE memilio ode_secir ${LIKWID_LIBRARIES})
+target_compile_options(ode_secir_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+target_compile_definitions(ode_secir_example PRIVATE "-DLIKWID_PERFMON")
 
 add_executable(ode_secirvvs_example ode_secirvvs.cpp)
-target_link_libraries(ode_secirvvs_example PRIVATE memilio ode_secirvvs)
+target_include_directories(ode_secirvvs_example PRIVATE ${LIKWID_INCLUDE_DIRS})
+target_link_libraries(ode_secirvvs_example PRIVATE memilio ode_secirvvs ${LIKWID_LIBRARIES})
+target_compile_options(ode_secirvvs_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+target_compile_definitions(ode_secirvvs_example PRIVATE "-DLIKWID_PERFMON")
 
 add_executable(ode_secir_ageres_example ode_secir_ageres.cpp)
 target_link_libraries(ode_secir_ageres_example PRIVATE memilio ode_secir)
+target_compile_options(ode_secir_ageres_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 add_executable(graph_example graph.cpp)
 target_link_libraries(graph_example PRIVATE memilio ode_seir)
+target_compile_options(graph_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 add_executable(graph_stochastic_mobility_example graph_stochastic_mobility.cpp)
 target_link_libraries(graph_stochastic_mobility_example PRIVATE memilio ode_secir)
+target_compile_options(graph_stochastic_mobility_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 add_executable(abm_minimal_example abm_minimal.cpp)
-target_link_libraries(abm_minimal_example PRIVATE memilio abm)
+target_include_directories(abm_minimal_example PRIVATE ${LIKWID_INCLUDE_DIRS})
+target_link_libraries(abm_minimal_example PRIVATE memilio abm ${LIKWID_LIBRARIES})
+target_compile_options(abm_minimal_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
+target_compile_definitions(abm_minimal_example PRIVATE "-DLIKWID_PERFMON")
+
 
 add_executable(abm_history_example abm_history_object.cpp)
 target_link_libraries(abm_history_example PRIVATE memilio abm)
+target_compile_options(abm_history_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 add_executable(twitter_migration_example twitter_migration.cpp)
 target_link_libraries(twitter_migration_example PRIVATE memilio ode_secir)
+target_compile_options(twitter_migration_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 add_executable(ide_seir_example ide_seir.cpp)
 target_link_libraries(ide_seir_example PRIVATE memilio ide_seir)
+target_compile_options(ide_seir_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 add_executable(ide_secir_example ide_secir.cpp)
 target_link_libraries(ide_secir_example PRIVATE memilio ide_secir)
+target_compile_options(ide_secir_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 
 if(MEMILIO_HAS_JSONCPP)
   add_executable(ode_secir_read_graph_example ode_secir_read_graph.cpp)
   target_link_libraries(ode_secir_read_graph_example PRIVATE memilio ode_secir)
   target_include_directories(ode_secir_read_graph_example PRIVATE ${CMAKE_CURRENT_BINARY_DIR}) # configured headers
+  target_compile_options(ode_secir_read_graph_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 endif()
 
 if(MEMILIO_HAS_HDF5 AND MEMILIO_HAS_JSONCPP)
   add_executable(ode_secir_parameter_study_example ode_secir_parameter_study.cpp)
   target_link_libraries(ode_secir_parameter_study_example PRIVATE memilio ode_secir)
+  target_compile_options(ode_secir_parameter_study_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 endif()
 
 if(MEMILIO_HAS_JSONCPP)
   add_executable(cli_example cli.cpp)
   target_link_libraries(cli_example PRIVATE memilio)
+  target_compile_options(cli_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 endif()
 
 if(MEMILIO_HAS_JSONCPP)
   add_executable(serialize_example serialize.cpp)
   target_link_libraries(serialize_example PRIVATE memilio)
+  target_compile_options(serialize_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 endif()
 
 if(MEMILIO_HAS_HDF5)
-  add_executable(ode_secir_save_results ode_secir_save_results.cpp)
-  target_link_libraries(ode_secir_save_results PRIVATE memilio ode_secir)
+  add_executable(ode_secir_save_results_example ode_secir_save_results.cpp)
+  target_link_libraries(ode_secir_save_results_example PRIVATE memilio ode_secir)
+  target_compile_options(ode_secir_save_results_example PRIVATE ${MEMILIO_CXX_FLAGS_ENABLE_WARNING_ERRORS})
 endif()

cpp/examples/abm_history_object.cpp

@@ -44,13 +44,13 @@ void write_log_to_file(const T& history)
     std::string input;
     std::ofstream myfile("test_output.txt");
     myfile << "Locations as numbers:\n";
-    for (auto loc_id_index = 0; loc_id_index < loc_id[0].size(); ++loc_id_index) {
-        myfile << convert_loc_id_to_string(loc_id[0][loc_id_index]) << "\n";
+    for (auto&& id : loc_id[0]) {
+        myfile << convert_loc_id_to_string(id) << "\n";
     }
     myfile << "Timepoints:\n";
 
-    for (int t = 0; t < time_points.size(); ++t) {
-        input += std::to_string(time_points[t]) + " ";
+    for (auto&& t : time_points) {
+        input += std::to_string(t) + " ";
     }
     myfile << input << "\n";
 
@@ -132,10 +132,11 @@ int main()
     // The infection states are chosen randomly.
     auto persons = world.get_persons();
     for (auto& person : persons) {
+        auto rng = mio::abm::Person::RandomNumberGenerator(world.get_rng(), person);
         mio::abm::InfectionState infection_state =
             (mio::abm::InfectionState)(rand() % ((uint32_t)mio::abm::InfectionState::Count - 1));
         if (infection_state != mio::abm::InfectionState::Susceptible)
-            person.add_new_infection(mio::abm::Infection(mio::abm::VirusVariant::Wildtype, person.get_age(),
+            person.add_new_infection(mio::abm::Infection(rng, mio::abm::VirusVariant::Wildtype, person.get_age(),
                                                          world.get_global_infection_parameters(), start_date,
                                                          infection_state));
     }