Restart clean. fpm as submodule of waves (depends on fwk and tbox). Add timers.

.clang-format

+# https://clang.llvm.org/docs/ClangFormatStyleOptions.html
+BasedOnStyle: LLVM
+UseTab: Never
+IndentWidth: 4
+BreakBeforeBraces: Allman
+SortIncludes: false
+ColumnLimit: 0
+AccessModifierOffset: -4

.gitlab-ci.yml

 # gitlab-ci file for fpm
 
 default:
-    image: rboman/waves-py3:2020.1
+    image: rboman/waves-py3:2020.3
     before_script:
         - source /opt/intel/mkl/bin/mklvars.sh intel64
         - source /opt/intel/tbb/bin/tbbvars.sh intel64
@@ -11,14 +11,26 @@ stages:
     - test
 
 build:
-    image: rboman/waves-py3:2020.1
+    image: rboman/waves-py3:2020.3
     stage: build
     script:
         - printenv | sort
+        - cd ..
+        - rm -rf waves
+        - wget -q https://gitlab.uliege.be/am-dept/waves/-/archive/feature_fpm/waves-feature_fpm.tar.bz2
+        - tar xf waves-feature_fpm.tar.bz2
+        - rm waves-feature_fpm.tar.bz2
+        - mv waves-feature_fpm waves
+        - cd waves
+        - mkdir build
+        - cd build
+        - cmake -Wno-dev -C ../CMake/disable-trilinos.cmake ..
+        - make -j $(nproc)
+        - cd ../../fpm
         - rm -rf build workspace
         - mkdir build
         - cd build
-        - cmake -Wno-dev ..
+        - cmake -DCMAKE_PREFIX_PATH=../../waves -Wno-dev ..
         - make -j $(nproc)
     artifacts:
         paths:
@@ -37,8 +49,8 @@ doxygen:
     dependencies:
         - build
 
-ctest-py3:
-    image: rboman/waves-py3:2020.1
+ctest:
+    image: rboman/waves-py3:2020.3
     stage: test
     script:
         - cd build
@@ -46,4 +58,3 @@ ctest-py3:
     #timeout: 10 hours  # will be available in 12.3
     dependencies:
         - build
-

fpm/_src/CMakeLists.txt

@@ -22,8 +22,16 @@ FILE(GLOB ISRCS *.i)
 SET(CMAKE_SWIG_FLAGS "")
 SET_SOURCE_FILES_PROPERTIES(${ISRCS} PROPERTIES CPLUSPLUS ON)
 
+FOREACH(dir ${WAVES_INCLUDE_DIRS})
+    LIST(APPEND WAVES_SINCLUDE_DIRS "-I${dir}")
+ENDFOREACH()
+FOREACH(dir ${WAVES_SWIG_DIRS})
+    LIST(APPEND WAVES_SINCLUDE_DIRS "-I${dir}")
+ENDFOREACH()
+
 SET(SWINCFLAGS
 -I${PROJECT_SOURCE_DIR}/fpm/src
+${WAVES_SINCLUDE_DIRS}
 )
 SET_SOURCE_FILES_PROPERTIES(${ISRCS} PROPERTIES SWIG_FLAGS "${SWINCFLAGS}")
 
@@ -35,10 +43,11 @@ endif()
 MACRO_DebugPostfix(_fpmw)
 
 TARGET_INCLUDE_DIRECTORIES(_fpmw PRIVATE ${PROJECT_SOURCE_DIR}/fpm/_src
+                                         ${WAVES_SWIG_DIRS}
                                          ${PYTHON_INCLUDE_PATH}
 )
 
 SWIG_LINK_LIBRARIES(fpmw
-                    fpm ${PYTHON_LIBRARIES}
+                    fpm ${WAVES_LIBRARIES} ${PYTHON_LIBRARIES}
 )
 

fpm/_src/fpmw.h

@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 
-#include "fObject.h"
+#include "fTimers.h"

fpm/_src/fpmw.i

@@ -36,34 +36,33 @@ threads="1"
 #include <sstream>
 #include <typeinfo>
 
-#include "fpm.h"
+#include "fwkw.h"
+#include "tboxw.h"
 #include "fpmw.h"
 
+#include "fpm.h"
+
 %}
 
-%include "fpmw.swg"
+%include "fwkw.swg"
+%import "tboxw.i"
 
 %include "fpm.h"
 
-%include <std_shared_ptr.i>
-
-%shared_ptr(fpm::fSharedObject);
-%include "fObject.h"
+%include "fTimers.h"
 
 namespace fpm {
-
-%extend fObject {
-    std::string __str__() {
-        std::stringstream str; str << *self;
-        return str.str();
+%extend Timers {
+    Timer &getitem(std::string const &name)
+    {
+        return (*self)[name];
     }
-}
 
-%extend fSharedObject {
-    std::string __str__() {
-        std::stringstream str; str << *self;
-        return str.str();
+    %pythoncode {
+def __getitem__(self, name):
+    return self.getitem(name)
     }
 }
 };
 
+//%include <std_shared_ptr.i>

fpm/_src/fpmw.swg

-/*
- * Copyright 2020 University of Liège
- *
- * 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.
- */
- 
- // common includes
-
-// !! mingw + c++11 + python:
-// cmath doit être inclus AVANT Python.h (et en particulier pyconfig.h)
-// car il renomme hypot en _hypoth (bidouille liée au visual)
-%begin %{
-#if defined(_WIN32) && defined(__GNUC__)
-#include <cmath>
-#endif
-%}
-
-// petite bidouille pour pouvoir compiler avec "threads=1" et iterer sur des std_vector
-// (sinon ca explose � la destruction de l'iterateur)
-%nothread swig::SwigPyIterator::~SwigPyIterator();
-
-%include "std_string.i"
-%include "exception.i"
-%include "std_vector.i"
-%include "std_list.i"
-%include "std_map.i"
-
-// from: http://swig.10945.n7.nabble.com/Trapping-Swig-DirectorException-td6013.html
-// le code suivant permet de voir la call stack dans les appels C++ => python
-
-%{ 
-   static void handle_exception(void) { 
-     try { 
-       throw; 
-     } catch (std::exception &e) { 
-        std::stringstream txt; 
-        txt << e.what(); // << ' ' << typeid(e).name();
-        PyErr_SetString(PyExc_RuntimeError, e.what()); 
-     } 
-     catch(...) 
-     {
-        PyErr_SetString(PyExc_RuntimeError, "Unknown C++ Runtime Error");
-     } 
-   } 
-%} 
-
-%exception { 
-   try { 
-     $action 
-   } catch (...) { 
-     // Note that if a director method failed, the Python error indicator 
-     // already contains full details of the exception, and it will be 
-     // reraised when we go to SWIG_fail; so no need to convert the C++ 
-     // exception back to a Python one 
-     if (!PyErr_Occurred()) { 
-       handle_exception(); 
-     } 
-     SWIG_fail; 
-   } 
-} 
-
-%feature("director:except") { 
-   if ($error != NULL) { 
-     throw Swig::DirectorMethodException(); 
-   } 
-} 
-
-
-%ignore operator<<;
-

fpm/src/CMakeLists.txt

@@ -32,5 +32,9 @@ FIND_PACKAGE(EIGEN 3.3.4 REQUIRED)
 TARGET_INCLUDE_DIRECTORIES(fpm PUBLIC ${EIGEN_INCLUDE_DIRS})
 TARGET_COMPILE_DEFINITIONS(fpm PUBLIC EIGEN_DONT_PARALLELIZE)
 
-SOURCE_GROUP(base       REGULAR_EXPRESSION ".*\\.(cpp|inl|hpp|h)")
+# -- WAVES
+FIND_PACKAGE(WAVES REQUIRED)
+TARGET_INCLUDE_DIRECTORIES(fpm PUBLIC ${WAVES_INCLUDE_DIRS})
+TARGET_LINK_LIBRARIES(fpm ${WAVES_LIBRARIES})
 
+SOURCE_GROUP(base       REGULAR_EXPRESSION ".*\\.(cpp|inl|hpp|h)")

fpm/src/fTimers.cpp

+/*
+ * Copyright 2020 University of Liège
+ *
+ * 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.
+ */
+
+#include "fTimers.h"
+#include <iomanip>
+
+using namespace fpm;
+
+Timer::Timer() : isOn(false)
+{
+    reset();
+}
+
+/**
+ * @brief Reset the timer
+ */
+void Timer::reset()
+{
+    if (!isOn)
+    {
+        start();
+        stop();
+    }
+    else
+        throw std::runtime_error("Cannot reset a running timer!\n");
+}
+
+/**
+ * @brief Start the timer
+ */
+void Timer::start()
+{
+    if (!isOn)
+    {
+        tS = std::chrono::high_resolution_clock::now();
+        cS = std::clock();
+        isOn = true;
+    }
+    else
+        throw std::runtime_error("Cannot start a running timer!\n");
+}
+
+/**
+ * @brief Stop the timer
+ */
+void Timer::stop()
+{
+    if (isOn)
+    {
+        tE = std::chrono::high_resolution_clock::now();
+        cE = std::clock();
+        isOn = false;
+    }
+    else
+        throw std::runtime_error("Cannot stop a non-running timer!\n");
+}
+
+/**
+ * @brief Access/create a given timer
+ */
+Timer &Timers::operator[](std::string const &name)
+{
+    return timers[name];
+}
+
+/**
+ * @brief Print the times of all timers
+ */
+void Timers::write(std::ostream &out) const
+{
+    out << std::fixed << std::setprecision(1);
+    out << std::setw(20) << std::left << "Timer"
+        << std::setw(15) << std::right << "Wall-clock (s)"
+        << std::setw(15) << std::right << "CPU (s)"
+        << std::endl;
+
+    for (auto const tm : timers)
+    {
+        out << std::setw(20) << std::left << tm.first
+            << std::setw(15) << std::right << tm.second.getWall()
+            << std::setw(15) << std::right << tm.second.getCpu()
+            << std::endl;
+    }
+}

fpm/src/fObject.h → fpm/src/fTimers.h

@@ -14,62 +14,63 @@
  * limitations under the License.
  */
 
-#ifndef FOBJECT_H
-#define FOBJECT_H
+#ifndef FTIMERS_H
+#define FTIMERS_H
 
 #include "fpm.h"
-#include <iostream>
+#include "wObject.h"
+#include <map>
+#include <chrono>
 
 namespace fpm
 {
 
 /**
- * @brief Base class of all virtual objects
- *
- *        The only purpose of this class is that it avoids many copy/paste for
- *        the print function (__str__() fct) in SWIG/python
+ * @brief Basic and portable timer
+ * @author Adrien Crovato
+ * @todo use clock_gettime for POSIX (https://en.cppreference.com/w/cpp/chrono/c/clock)?
  */
-
-class FPM_API fObject
+class FPM_API Timer
 {
+private:
+    bool isOn;                                         ///< status
+    std::chrono::high_resolution_clock::time_point tS; ///< start time (wall-clock)
+    std::chrono::high_resolution_clock::time_point tE; ///< stop time (wall-clock)
+    std::clock_t cS;                                   ///< start time (cpu)
+    std::clock_t cE;                                   ///< stop time (cpu)
+
 public:
-    fObject() = default;
-    virtual ~fObject() {}
-    fObject(const fObject &) = delete;
-    fObject &operator=(const fObject &) = delete;
+    Timer();
+    virtual ~Timer() {}
 
-#ifndef SWIG
-    friend FPM_API std::ostream &operator<<(std::ostream &out, fObject const &obj);
-    virtual void write(std::ostream &out) const;
-#endif
+    void reset();
+    void start();
+    void stop();
+    inline double getWall() const;
+    inline double getCpu() const;
 };
 
+#include "fTimers.inl"
+
 /**
- * @brief Base class of smart-pointed objects (shared_ptr)
- *
- *        This base class is only required for "print" in SWIG/python.
- *        std::cout << *o works from C++ (it calls "write") even if the object inherits from wObject
- *        which is not defined in SWIG as shared_ptr-managed object
- *        However "print o" fails in python if the shared object inherits from wObject.
- *        This class also avoids a warning in SWIG telling that some derived or base classes are not
- *        managed by shared_ptr.
+ * @brief Collection of timers
+ * @author Romain Boman, Adrien Crovato
  */
-
-class FPM_API fSharedObject
+class FPM_API Timers : public fwk::wObject
 {
+private:
+    std::map<std::string, Timer> timers; ///< set of timers
+
 public:
-    fSharedObject() = default;
-    virtual ~fSharedObject() {}
-    fSharedObject(const fSharedObject &) = delete;
-    fSharedObject &operator=(const fSharedObject &) = delete;
+    Timers() : fwk::wObject() {}
+    virtual ~Timers() {}
 
 #ifndef SWIG
-    friend FPM_API std::ostream &operator<<(std::ostream &out, fSharedObject const &obj);
-    virtual void write(std::ostream &out) const;
-#endif
+    Timer &operator[](std::string const &name);
+    virtual void write(std::ostream &out) const override;
+#endif //SWIG
 };
 
 } // namespace fpm
 
-#endif //FOBJECT_H
-
+#endif //FTIMERS_H

fpm/src/fObject.cpp → fpm/src/fTimers.inl

@@ -14,32 +14,18 @@
  * limitations under the License.
  */
 
-#include "fObject.h"
-
-namespace fpm
-{
-
-FPM_API std::ostream &
-operator<<(std::ostream &out, fObject const &obj)
-{
-    obj.write(out);
-    return out;
-}
-
-void fObject::write(std::ostream &out) const
-{
-}
-
-FPM_API std::ostream &
-operator<<(std::ostream &out, fSharedObject const &obj)
+/**
+ * @brief Compute the wall-clock (ellasped) time from "start" to "stop"
+ */
+inline double Timer::getWall() const
 {
-    obj.write(out);
-    return out;
+    return std::chrono::duration<double>(tE - tS).count();
 }
 
-void fSharedObject::write(std::ostream &out) const
+/**
+ * @brief Compute the cpu (user) time from "start" to "stop"
+ */
+inline double Timer::getCpu() const
 {
-}
-
-} // namespace fpm
+    return (cE - cS) / (double)CLOCKS_PER_SEC;
+}
\ No newline at end of file
-

fpm/src/fpm.h

@@ -29,26 +29,15 @@
 #define FPM_API
 #endif
 
-#ifdef _MSC_VER
-#if !defined(_CRT_SECURE_NO_WARNINGS)
-#define _CRT_SECURE_NO_WARNINGS 1
-#endif
-
-#pragma warning(disable : 4251) // DLL/templates non exportes
-#pragma warning(disable : 4275) // non - DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier'
-
-#define NOMINMAX // avoids the definition of "min/max" macro  in <minwindef.h> (which could shadow std::max)
-
-#endif //_MSC_VER
-
+#include "tbox.h"
 
 namespace fpm
 {
 
-class fObject;
+// utilities
+class fTimer;
+class fTimers;
 
 } // namespace fpm
 
-
 #endif //FPM_H
-

fpm/tests/basic.py → fpm/tests/timers.py

-#!/usr/bin/env python
+#!/usr/bin/env python3
 # -*- coding: utf-8 -*-
 
 # Copyright 2020 University of Liège
@@ -15,17 +15,38 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# basic test
+# Test the timers
+# Adrien Crovato
 
 import fpm
+import time
 from fwk.testing import *
 from fwk.coloring import ccolors
 
 def main():
-    a = 10.0
+    tms = fpm.Timers()
+    tms['1'].start()
+    time.sleep(0.3)
+    tms['1'].stop()
+    tms['2'].start()
+    tic = time.perf_counter()
+    dummy()
+    toc = time.perf_counter()
+    tms['2'].stop()
+    print(ccolors.ANSI_BLUE + 'PyTiming...' + ccolors.ANSI_RESET)
+    print(tms)
+
     print(ccolors.ANSI_BLUE + 'PyTesting...' + ccolors.ANSI_RESET)
     tests = CTests()
-    tests.add(CTest('test', a, 10., 1e-2))
+    tests.add(CTest('1w', tms['1'].getWall(), 0.3, 2e-2))
+    tests.add(CTest('1u', tms['1'].getCpu(), 0.0, 1e-2))
+    tests.add(CTest('2w', tms['2'].getWall(), toc - tic, 2e-2))
+    tests.add(CTest('2u', tms['2'].getCpu(), toc - tic, 2e-2))
+    tests.run()
+    
+def dummy():
+    for i in range(0, int(1e7)):
+        a = 1+1
 
 if __name__ == '__main__':
     main()