Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Merge branch 'torus'
authorAugustin Degomme <degomme@idpann.imag.fr>
Wed, 22 Jan 2014 10:12:40 +0000 (11:12 +0100)
committerAugustin Degomme <degomme@idpann.imag.fr>
Wed, 22 Jan 2014 10:12:40 +0000 (11:12 +0100)
56 files changed:
.cproject
buildtools/Cmake/AddTests.cmake
buildtools/Cmake/CompleteInFiles.cmake
buildtools/Cmake/DefinePackages.cmake
buildtools/Cmake/MakeLib.cmake
buildtools/Cmake/Modules/FindLibSigc++.cmake [new file with mode: 0644]
buildtools/Cmake/PrintArgs.cmake
buildtools/Cmake/src/internal_config.h.in
doc/Doxyfile.in
doc/doxygen/module-surf.doc
examples/msg/energy/e2/e2.c
examples/msg/energy/e2/energy_consumption.tesh
examples/msg/energy/e3/concurrent_tasks.tesh
examples/msg/energy/e3/e3.c
examples/smpi/energy/energy.tesh
examples/smpi/energy/f77/energy.tesh
examples/smpi/energy/f90/energy.tesh
include/simgrid.h [new file with mode: 0644]
include/simgrid/platf.h
include/simgrid/plugins.h [new file with mode: 0644]
include/smpi/smpi.h
include/smpi/smpi_cocci.h
include/smpi/smpif.h.in
src/include/surf/surf.h
src/simgrid/sg_config.c
src/smpi/smpi_global.c
src/smpi/smpicc.in
src/surf/cpu_cas01.cpp
src/surf/cpu_cas01.hpp
src/surf/cpu_interface.cpp
src/surf/cpu_interface.hpp
src/surf/cpu_ti.hpp
src/surf/maxmin_private_.h [deleted file]
src/surf/network_gtnets.c [deleted file]
src/surf/network_gtnets_private.h [deleted file]
src/surf/network_interface.cpp
src/surf/network_interface.hpp
src/surf/plugins/energy.cpp [new file with mode: 0644]
src/surf/plugins/energy.hpp [new file with mode: 0644]
src/surf/storage_interface.hpp
src/surf/surf_c_bindings.cpp
src/surf/surf_interface.cpp
src/surf/surf_interface.hpp
src/surf/surf_private.h
src/surf/surf_routing.hpp
src/surf/vm_workstation_hl13.cpp
src/surf/vm_workstation_interface.hpp
src/surf/workstation_interface.cpp
src/surf/workstation_interface.hpp
src/xbt/log.c
src/xbt/mmalloc/mm_module.c
teshsuite/smpi/mpich3-test/coll/allgatherv4.c
teshsuite/smpi/mpich3-test/datatype/contents.c
teshsuite/smpi/mpich3-test/f90/coll/redscatf90.f90
teshsuite/smpi/mpich3-test/util/mtest.c
tools/check_dist_archive.exclude

index 56ee086..12679b9 100644 (file)
--- a/.cproject
+++ b/.cproject
@@ -1,7 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<?fileVersion 5.0.0?>
-
-<cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage2">
+<?fileVersion 5.0.0?><cproject storage_type_id="org.eclipse.cdt.core.XmlProjectDescriptionStorage2">
        <storageModule moduleId="org.eclipse.cdt.core.settings">
                <cconfiguration id="cdt.managedbuild.toolchain.gnu.base.1053321950">
                        <storageModule externalCElementFile="cdt.managedbuild.toolchain.gnu.base.1053321950_org.eclipse.cdt.core.settings" id="cdt.managedbuild.toolchain.gnu.base.1053321950" name="Default"/>
index 05924e5..207890e 100644 (file)
@@ -525,6 +525,19 @@ if(NOT enable_memcheck)
     ADD_TEST(smpi-mpich3-coll-ompi-thread       ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:thread -execarg=--cfg=smpi/coll_selector:ompi -execarg=--cfg=smpi/send_is_detached_thres:0)
     ADD_TEST(smpi-mpich3-coll-mpich-thread      ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:thread -execarg=--cfg=smpi/coll_selector:mpich)
     set_tests_properties(smpi-mpich3-coll-thread smpi-mpich3-coll-ompi-thread smpi-mpich3-coll-mpich-thread PROPERTIES PASS_REGULAR_EXPRESSION "tests passed!")
+    if(CONTEXT_UCONTEXT)
+      ADD_TEST(smpi-mpich3-coll-ucontext        ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:ucontext)
+      ADD_TEST(smpi-mpich3-coll-ompi-ucontext   ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:ucontext -execarg=--cfg=smpi/coll_selector:ompi -execarg=--cfg=smpi/send_is_detached_thres:0)
+      ADD_TEST(smpi-mpich3-coll-mpich-ucontext  ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:ucontext -execarg=--cfg=smpi/coll_selector:mpich)
+      set_tests_properties(smpi-mpich3-coll-ucontext smpi-mpich3-coll-ompi-ucontext smpi-mpich3-coll-mpich-ucontext PROPERTIES PASS_REGULAR_EXPRESSION "tests passed!")
+    endif()
+    if(HAVE_RAWCTX)
+      ADD_TEST(smpi-mpich3-coll-raw             ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:raw)
+      ADD_TEST(smpi-mpich3-coll-ompi-raw        ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:raw -execarg=--cfg=smpi/coll_selector:ompi -execarg=--cfg=smpi/send_is_detached_thres:0)
+      ADD_TEST(smpi-mpich3-coll-mpich-raw       ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/coll perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/coll -tests=testlist -execarg=--cfg=contexts/factory:raw -execarg=--cfg=smpi/coll_selector:mpich)
+      set_tests_properties(smpi-mpich3-coll-raw smpi-mpich3-coll-ompi-raw smpi-mpich3-coll-mpich-raw PROPERTIES PASS_REGULAR_EXPRESSION "tests passed!")
+    endif()
+
     if(HAVE_RAWCTX)
       ADD_TEST(smpi-mpich3-attr-raw             ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/attr perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/attr -tests=testlist -execarg=--cfg=contexts/factory:raw)
       ADD_TEST(smpi-mpich3-comm-raw             ${CMAKE_COMMAND} -E chdir ${CMAKE_BINARY_DIR}/teshsuite/smpi/mpich3-test/comm perl ${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/runtests -mpiexec=${CMAKE_BINARY_DIR}/smpi_script/bin/smpirun -srcdir=${CMAKE_HOME_DIRECTORY}/teshsuite/smpi/mpich3-test/comm -tests=testlist -execarg=--cfg=contexts/factory:raw)
index 858267f..57cab1c 100644 (file)
@@ -73,6 +73,7 @@ include(TestBigEndian)
 TEST_BIG_ENDIAN(BIGENDIAN)
 
 include(FindGraphviz)
+include(FindLibSigc++)
 
 set(HAVE_GTNETS 0)
 if(enable_gtnets)
index 108d9fe..980f973 100644 (file)
@@ -40,6 +40,7 @@ set(EXTRA_DIST
   src/smpi/colls/coll_tuned_topo.h
   src/smpi/private.h
   src/smpi/smpi_mpi_dt_private.h
+  src/surf/plugins/energy.hpp
   src/surf/cpu_interface.hpp
   src/surf/cpu_ti.hpp
   src/surf/cpu_cas01.hpp
@@ -300,6 +301,7 @@ set(NS3_SRC
   )
 
 set(SURF_SRC
+  src/surf/plugins/energy.cpp
   src/surf/cpu_interface.cpp
   src/surf/cpu_ti.cpp
   src/surf/cpu_cas01.cpp
@@ -542,6 +544,7 @@ set(MC_SRC
   )
 
 set(headers_to_install
+  include/simgrid.h
   include/instr/instr.h
   include/msg/datatypes.h
   include/msg/msg.h
@@ -551,6 +554,7 @@ set(headers_to_install
   include/simgrid/modelchecker.h
   include/simgrid/platf.h
   include/simgrid/platf_generator.h
+  include/simgrid/plugins.h
   include/simgrid/simix.h
   include/smpi/mpi.h
   include/smpi/smpi.h
@@ -992,6 +996,7 @@ set(CMAKE_SOURCE_FILES
   buildtools/Cmake/Modules/FindGFortran.cmake
   buildtools/Cmake/Modules/FindGTnets.cmake
   buildtools/Cmake/Modules/FindGraphviz.cmake
+  buildtools/Cmake/Modules/FindLibSigc++.cmake
   buildtools/Cmake/Modules/FindLibunwind.cmake
   buildtools/Cmake/Modules/FindLua51Simgrid.cmake
   buildtools/Cmake/Modules/FindNS3.cmake
index bddc356..8ee81ad 100644 (file)
@@ -82,6 +82,10 @@ if(HAVE_GRAPHVIZ)
   endif()
 endif()
 
+if(HAVE_LIBSIGC++)
+  SET(SIMGRID_DEP "${SIMGRID_DEP} -lsigc-2.0")   
+endif()
+
 if(HAVE_GTNETS)
   SET(SIMGRID_DEP "${SIMGRID_DEP} -lgtnets")
 endif()
diff --git a/buildtools/Cmake/Modules/FindLibSigc++.cmake b/buildtools/Cmake/Modules/FindLibSigc++.cmake
new file mode 100644 (file)
index 0000000..2d2aa03
--- /dev/null
@@ -0,0 +1,71 @@
+find_path(PATH_LIBSIGC++_H "sigc++/sigc++.h"
+  HINTS
+  $ENV{LD_LIBRARY_PATH}
+  PATH_SUFFIXES include/sigc++-2.0/ include/
+  PATHS
+  /opt
+  /opt/local
+  /opt/csw
+  /sw
+  /usr)
+
+find_path(PATH_LIBSIGC++CONFIG_H "sigc++config.h"
+  HINTS
+  $ENV{LD_LIBRARY_PATH}
+  PATH_SUFFIXES lib/x86_64-linux-gnu/sigc++-2.0/include/ include/
+  PATHS
+  /opt
+  /opt/local
+  /opt/csw
+  /sw
+  /usr)
+
+find_library(PATH_LIBSIGC++_LIB
+  NAMES sigc-2.0
+  HINTS
+  $ENV{LD_LIBRARY_PATH}
+  PATH_SUFFIXES lib/x86_64-linux-gnu/ lib/sigc++/ lib/
+  PATHS
+  /opt
+  /opt/local
+  /opt/csw
+  /sw
+  /usr)
+
+message(STATUS "Looking for sigc++/sigc++.h")
+if(PATH_LIBSIGC++_H)
+  message(STATUS "Looking for sigc++/sigc++.h - found")
+else()
+  message(STATUS "Looking for sigc++/sigc++.h - not found")
+endif()
+
+message(STATUS "Looking for sigc++config.h")
+if(PATH_LIBSIGC++CONFIG_H)
+  message(STATUS "Looking for sigc++config.h - found")
+else()
+  message(STATUS "Looking for sigc++config.h - not found")
+endif()
+
+message(STATUS "Looking for libsigc++")
+if(PATH_LIBSIGC++_LIB)
+  message(STATUS "Looking for libsigc++ - found")
+else()
+  message(STATUS "Looking for libsigc++ - not found")
+endif()
+
+if(PATH_LIBSIGC++_LIB AND PATH_LIBSIGC++_H AND PATH_LIBSIGC++CONFIG_H)
+  string(REGEX REPLACE "/sigc\\+\\+/sigc\\+\\+.h" "" PATH_LIBSIGC++_H   "${PATH_LIBSIGC++_H}")
+  string(REGEX REPLACE "/sigc\\+\\+config.h" "" PATH_LIBSIGC++CONFIG_H   "${PATH_LIBSIGC++CONFIG_H}")
+  string(REGEX REPLACE "/libsig.*" "" PATH_LIBSIGC++_LIB "${PATH_LIBSIGC++_LIB}")
+      
+  include_directories(${PATH_LIBSIGC++_H})
+  include_directories(${PATH_LIBSIGC++CONFIG_H})
+  link_directories(${PATH_LIBSIGC++_LIB})
+  set(HAVE_LIBSIGC++ "1")
+else()
+  set(HAVE_LIBSIGC++ "0")
+endif()
+
+mark_as_advanced(PATH_LIBSIGC++_H)
+mark_as_advanced(PATH_LIBSIGC++CONFIG_H)
+mark_as_advanced(PATH_LIBSIGC++_LIB)
index 122fd57..9a4a8c4 100644 (file)
@@ -121,6 +121,7 @@ message("        Tracing mode ........: ${enable_tracing}")
 message("        Jedule  mode ........: ${enable_jedule}")
 message("        Latency bound .......: ${enable_latency_bound_tracking}")
 message("        Graphviz mode .......: ${HAVE_GRAPHVIZ}")
+message("        Sigc++ mode .........: ${HAVE_LIBSIGC++}")
 message("        Mallocators .........: ${enable_mallocators}")
 message("")
 message("        Simgrid dependencies : ${SIMGRID_DEP}")
index 8400694..43270cc 100644 (file)
@@ -61,6 +61,9 @@
 /* If have linux_futex.h */
 #cmakedefine HAVE_FUTEX_H @HAVE_FUTEX_H@
 
+/* Some variable for libsigc++ */
+#cmakedefine HAVE_LIBSIGC @HAVE_LIBSIGC++@
+
 /* Some variable for graphviz */
 #cmakedefine HAVE_GRAPHVIZ @HAVE_GRAPHVIZ@
 #cmakedefine HAVE_GRAPH_H @GRAPH_H@
index 104b4ee..dde4f8d 100644 (file)
@@ -116,7 +116,7 @@ ALWAYS_DETAILED_SEC    = NO
 # members were ordinary class members. Constructors, destructors and assignment
 # operators of the base classes will not be shown.
 
-INLINE_INHERITED_MEMB  = YES
+INLINE_INHERITED_MEMB  = NO
 
 # If the FULL_PATH_NAMES tag is set to YES then Doxygen will prepend the full
 # path before files name in the file list and in the header files. If set
@@ -699,6 +699,7 @@ INPUT                  = doxygen/index.doc \
                          @top_srcdir@/src/include/surf \
                          @top_srcdir@/src/xbt/ \
                          @top_srcdir@/src/surf/ \
+                         @top_srcdir@/src/surf/plugins/ \
                          @top_srcdir@/src/msg/ \
                          @top_srcdir@/src/simdag \
                          @top_srcdir@/src/simix \
index a756aef..0ebc5fa 100644 (file)
@@ -1,10 +1,21 @@
 /** \addtogroup SURF_API
-
+  
   \section SURF_doc Surf documentation
+   Surf is composed several components:
    - \ref SURF_simulation
    - \ref SURF_actions
    - \ref SURF_resources
    - \ref SURF_build_api
+   - \ref SURF_interface
+   - \ref SURF_routing
+   - \ref SURF_cpu_interface
+   - \ref SURF_network_interface
+   - \ref SURF_storage_interface
+   - \ref SURF_workstation_interface
+   - \ref SURF_vm_workstation_interface
+   - \ref SURF_callbacks
+   - \ref SURF_plugin_energy
+   
 
 */
 
     we strongly recommand you to contact us before anyway.
 
 */
+
+/**
+@defgroup SURF_c_bindings   SURF C bindings
+@ingroup SURF_API
+@brief Describes the c bindings of SURF
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Surf C bindings" --> @endhtmlonly
+*/
+
+/**
+@defgroup SURF_routing_interface   SURF Routing Interface
+@ingroup SURF_API
+@brief Describes the routing interface
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Surf Routing" --> @endhtmlonly
+*/
+
+/**
+@defgroup SURF_interface   SURF Interface
+@ingroup SURF_API
+@brief Describes the general interface for all components (Cpu, Network, Storage, Workstation, WorkstationVM)
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Surf Interface" --> @endhtmlonly
+*/
+
+/**
+@defgroup SURF_cpu_interface   SURF Cpu Interface
+@ingroup SURF_API
+@brief Describes the general Cpu interface for all Cpu implementations
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Cpu Interface" --> @endhtmlonly
+*/
+
+/**
+@defgroup SURF_network_interface   SURF Network Interface
+@ingroup SURF_API
+@brief Describes the general Network interface for all Network implementations
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Network Interface" --> @endhtmlonly
+*/
+
+/**
+@defgroup SURF_storage_interface   SURF Storage Interface
+@ingroup SURF_API
+@brief Describes the general  interface for all Storage implementations
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Storage Interface" --> @endhtmlonly
+*/
+
+/**
+@defgroup SURF_workstation_interface   SURF Workstation Interface
+@ingroup SURF_API
+@brief Describes the general  interface for all Workstation implementations
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Workstation Interface" --> @endhtmlonly
+*/
+
+/**
+@defgroup SURF_vm_workstation_interface   SURF VM Workstation Interface
+@ingroup SURF_API
+@brief Describes the general  interface for all VM Workstation implementations
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="VM Workstation Interface" --> @endhtmlonly
+*/
+
+/**
+@defgroup SURF_callbacks   SURF callbacks
+@ingroup SURF_API
+@brief Describes how to use the SURF callbacks
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="SURF callbacks" --> @endhtmlonly
+*/
+
+/**
+@defgroup SURF_plugin_energy   SURF Energy Plugin
+@ingroup SURF_API
+@brief Describes how to use the energy plugin.
+
+@htmlonly <!-- DOXYGEN_NAVBAR_LABEL="Energy plugin" --> @endhtmlonly
+*/
\ No newline at end of file
index d0ea20b..64536f5 100644 (file)
@@ -9,6 +9,7 @@
 
 #include "msg/msg.h"
 #include "xbt/sysdep.h"         /* calloc */
+#include "simgrid/plugins.h"
 
 /* Create a log channel to have nice outputs. */
 #include "xbt/log.h"
@@ -70,14 +71,13 @@ int dvfs(int argc, char *argv[])
   consumed_energy = MSG_get_host_consumed_energy(host);
   XBT_INFO("Total energy (Joules): %f", consumed_energy);
 
-
   return 0;
 }
 
 int main(int argc, char *argv[])
 {
   msg_error_t res = MSG_OK;
-
+  sg_energy_plugin_init();
   MSG_init(&argc, argv);
 
   if (argc != 3) {
index 02c620e..105621b 100644 (file)
@@ -14,3 +14,4 @@ $ $SG_TEST_EXENV energy/e2/e2$EXEEXT ${srcdir:=.}/energy/e2/platform_e2.xml ${sr
 > [  9.000000] (1:dvfs_test@MyHost1) Task3 (sleep) simulation time: 4.000000e+00
 > [  9.000000] (1:dvfs_test@MyHost1) Total energy (Joules): 1220.000000
 > [  9.000000] (0:@) Total simulation time: 9.000000e+00
+> [  9.000000] (0:@) Total energy (Joules) of host MyHost1: 1220.000000
index 1bcb927..9cf2d89 100644 (file)
@@ -19,3 +19,4 @@ $ $SG_TEST_EXENV energy/e3/e3$EXEEXT ${srcdir:=.}/energy/e3/platform_e3.xml ${sr
 > [  8.000000] (1:dvfs_test@MyHost1) Task simulation time: 8.000000e+00
 > [  8.000000] (1:dvfs_test@MyHost1) Total energy (Joules): 1390.000000
 > [  8.000000] (0:@) Total simulation time: 8.000000e+00
+> [  8.000000] (0:@) Total energy (Joules) of host MyHost1: 1390.000000
index 4230a8e..ffa57e8 100644 (file)
@@ -8,6 +8,7 @@
 
 #include "msg/msg.h"
 #include "xbt/sysdep.h"         /* calloc */
+#include "simgrid/plugins.h"
 
 /* Create a log channel to have nice outputs. */
 #include "xbt/log.h"
@@ -99,7 +100,7 @@ static int dvfs(int argc, char *argv[])
 int main(int argc, char *argv[])
 {
   msg_error_t res = MSG_OK;
-
+  sg_energy_plugin_init();
   MSG_init(&argc, argv);
 
   if (argc != 3) {
index aac0673..b4aa3a4 100644 (file)
@@ -1,10 +1,13 @@
 p Test smpi bindings for dvfs functions (C example)
-$ ../../../smpi_script/bin/smpirun -np 2 -hostfile ${srcdir:=.}/hostfile  -platform ${srcdir:=.}/platform.xml --cfg=smpi/cpu_threshold:-1 ${bindir:=.}/se
+$ ../../../smpi_script/bin/smpirun -np 2 -hostfile ${srcdir:=.}/hostfile  -platform ${srcdir:=.}/platform.xml --cfg=smpi/cpu_threshold:-1 ${bindir:=.}/se --cfg=plugin:Energy
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-9'
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI'
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304'
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'smpi/cpu_threshold' to '-1'
+> [0.000000] [xbt_cfg/INFO] Configuration change: Set 'plugin' to 'Energy'
 > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s)
+> [80.000000] [surf_energy/INFO] Total energy (Joules) of host MyHost1: 12900.000000
+> [80.000000] [surf_energy/INFO] Total energy (Joules) of host MyHost2: 2000.000000
 > [0.000000] [rank 1] Pstates: 1; Powers: 100000000
 > [0.000000] [rank 0] Pstates: 3; Powers: 100000000, 50000000, 20000000
 > [0.000000] [rank 1] Current pstate: 0; Current power: 100000000
index 10ccab9..83fc49e 100644 (file)
@@ -1,10 +1,13 @@
 p Test smpi bindings for dvfs functions (Fortran 77 example)
-$ ../../../smpi_script/bin/smpirun -np 2 -hostfile ${srcdir:=.}/hostfile  -platform ${srcdir:=.}/platform.xml --cfg=smpi/cpu_threshold:-1 ${bindir:=.}/f77/sef
+$ ../../../smpi_script/bin/smpirun -np 2 -hostfile ${srcdir:=.}/hostfile  -platform ${srcdir:=.}/platform.xml --cfg=smpi/cpu_threshold:-1 ${bindir:=.}/f77/sef --cfg=plugin:Energy
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-9'
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI'
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304'
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'smpi/cpu_threshold' to '-1'
+> [0.000000] [xbt_cfg/INFO] Configuration change: Set 'plugin' to 'Energy'
 > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s)
+> [80.000000] [surf_energy/INFO] Total energy (Joules) of host MyHost1: 12900.000000
+> [80.000000] [surf_energy/INFO] Total energy (Joules) of host MyHost2: 2000.000000
 >  [  0.] [rank  0] 3 pstates available
 >  [  0.] [rank  1] 1 pstates available
 >  [  0.] [rank  0] Power:   100000000.
index fe1859b..5e82975 100644 (file)
@@ -1,9 +1,10 @@
 p Test smpi bindings for dvfs functions (Fortran 90 example)
-$ ../../../smpi_script/bin/smpirun -np 2 -hostfile ${srcdir:=.}/hostfile  -platform ${srcdir:=.}/platform.xml --cfg=smpi/cpu_threshold:-1 ${bindir:=.}/f90/sef90
+$ ../../../smpi_script/bin/smpirun -np 2 -hostfile ${srcdir:=.}/hostfile  -platform ${srcdir:=.}/platform.xml --cfg=smpi/cpu_threshold:-1 ${bindir:=.}/f90/sef90 --cfg=plugin:Energy 
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'maxmin/precision' to '1e-9'
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'SMPI'
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'network/TCP_gamma' to '4194304'
 > [0.000000] [xbt_cfg/INFO] Configuration change: Set 'smpi/cpu_threshold' to '-1'
+> [0.000000] [xbt_cfg/INFO] Configuration change: Set 'plugin' to 'Energy'
 > [0.000000] [surf_config/INFO] Switching workstation model to compound since you changed the network and/or cpu model(s)
 >  [   0.0000000000000000      ] [rank            0 ]           3 pstates available
 >  [   0.0000000000000000      ] [rank            1 ]           1 pstates available
@@ -19,3 +20,5 @@ $ ../../../smpi_script/bin/smpirun -np 2 -hostfile ${srcdir:=.}/hostfile  -platf
 >  [   30.000000000000000      ] [rank            0 ] Energy consumed (Joules):    5400.0000000000000     
 >  [   30.000000000000000      ] [rank            0 ] Current pstate:            2 ; Current power:    20000000.000000000     
 >  [   80.000000000000000      ] [rank            0 ] Energy consumed (Joules):    12900.000000000000     
+> [80.000000] [surf_energy/INFO] Total energy (Joules) of host MyHost1: 12900.000000
+> [80.000000] [surf_energy/INFO] Total energy (Joules) of host MyHost2: 2000.000000
diff --git a/include/simgrid.h b/include/simgrid.h
new file mode 100644 (file)
index 0000000..d4dc185
--- /dev/null
@@ -0,0 +1,24 @@
+/* simgrid.h - Public interface all SimGrid APIs                            */
+
+/* Copyright (c) 2014. The SimGrid Team. All rights reserved.               */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
+#ifndef SIMGRID_H
+#define SIMGRID_H
+
+#include <xbt.h>
+
+#include <simgrid/datatypes.h>
+#include <simgrid/modelchecker.h>
+#include <simgrid/platf_generator.h>
+#include <simgrid/platf.h>
+#include <simgrid/simix.h>
+#include <simgrid/plugins.h>
+
+// SG_BEGIN_DECL()
+// nothing
+// SG_END_DECL()
+
+#endif                          /* SG_PLATF_H */
index f5f37fa..d894607 100644 (file)
@@ -18,7 +18,8 @@ typedef struct RoutingEdge *sg_routing_edge_t;
 
 XBT_PUBLIC(sg_routing_edge_t) sg_routing_edge_by_name_or_null(const char *name);
 
-/** Defines whether a given resource is working or not */
+/** @ingroup SURF_interface
+* @brief Defines whether a given resource is working or not */
 typedef enum {
   SURF_RESOURCE_ON = 1,                   /**< Up & ready        */
   SURF_RESOURCE_OFF = 0                   /**< Down & broken     */
diff --git a/include/simgrid/plugins.h b/include/simgrid/plugins.h
new file mode 100644 (file)
index 0000000..4f6f6a2
--- /dev/null
@@ -0,0 +1,20 @@
+/*
+ * plugins.h
+ *
+ *  Created on: Jan 15, 2014
+ *      Author: bedaride
+ */
+
+#ifndef PLUGINS_H_
+#define PLUGINS_H_
+
+SG_BEGIN_DECL()
+
+/** \ingroup SURF_plugins
+ *  \brief The cpu energy consumption plugin
+ */
+XBT_PUBLIC(void) sg_energy_plugin_init(void);
+
+SG_END_DECL()
+
+#endif /* PLUGINS_H_ */
index 4b91260..5fd5a7c 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2013. The SimGrid Team.
+/* Copyright (c) 2007-2014. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -673,6 +673,7 @@ MPI_CALL(XBT_PUBLIC(int), MPI_Comm_get_parent,( MPI_Comm *parent));
 //FIXME: End of all the not yet implemented stuff
 
 // smpi functions
+XBT_PUBLIC(int) smpi_global_size(void);
 XBT_PUBLIC(MPI_Comm) smpi_process_comm_self(void);
 /*
 XBT_PUBLIC(void) smpi_exit(int);
index 534c443..c4ea46f 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (c) 2011-2013. The SimGrid Team.
+/* Copyright (c) 2011-2014. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
 
 #define SMPI_VARINIT_GLOBAL(name,type)                          \
 type *name = NULL;                                              \
-void __attribute__((weak,constructor)) __preinit_##name(void) { \
+static void __attribute__((constructor)) __preinit_##name(void) { \
    if(!name)                                                    \
-      name = (type*)malloc(smpi_global_size() * sizeof(type));  \
+      name = (type*)calloc(smpi_global_size(), sizeof(type));   \
 }                                                               \
-void __attribute__((weak,destructor)) __postfini_##name(void) { \
+static void __attribute__((destructor)) __postfini_##name(void) { \
    free(name);                                                  \
    name = NULL;                                                 \
 }
 
 #define SMPI_VARINIT_GLOBAL_AND_SET(name,type,expr)             \
 type *name = NULL;                                              \
-void __attribute__((weak,constructor)) __preinit_##name(void) { \
+static void __attribute__((constructor)) __preinit_##name(void) { \
    size_t size = smpi_global_size();                            \
    size_t i;                                                    \
    type value = expr;                                           \
@@ -35,7 +35,7 @@ void __attribute__((weak,constructor)) __preinit_##name(void) { \
       }                                                         \
    }                                                            \
 }                                                               \
-void __attribute__((weak,destructor)) __postfini_##name(void) { \
+static void __attribute__((destructor)) __postfini_##name(void) { \
    free(name);                                                  \
    name = NULL;                                                 \
 }
@@ -55,7 +55,7 @@ XBT_PUBLIC(void) smpi_free_static(void);
 #define SMPI_VARINIT_STATIC(name,type)                      \
 static type *name = NULL;                                   \
 if(!name) {                                                 \
-   name = (type*)malloc(smpi_global_size() * sizeof(type)); \
+   name = (type*)calloc(smpi_global_size(), sizeof(type));  \
    smpi_register_static(name, xbt_free);                    \
 }
 
index e558101..eea7f19 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2013. The SimGrid Team.
+/* Copyright (c) 2007-2014. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -19,7 +19,6 @@ XBT_PUBLIC_DATA(__thread int) smpi_current_rank;
 
 XBT_PUBLIC(int) smpi_process_argc(void);
 XBT_PUBLIC(int) smpi_process_getarg(integer* index, char* dst, ftnlen len);
-XBT_PUBLIC(int) smpi_global_size(void);
 
 #define smpi_sample_local__(pi,pt) \
    { \
index 61ca8f9..162e610 100644 (file)
@@ -19,6 +19,7 @@
 #include "surf/surf_routing.h"
 #include "simgrid/platf_interface.h"
 #include "simgrid/datatypes.h"
+#include "simgrid/plugins.h"
 
 SG_BEGIN_DECL()
 /* Actions and models are highly connected structures... */
@@ -148,14 +149,13 @@ XBT_PUBLIC(int) find_model_description(s_surf_model_description_t * table,
 XBT_PUBLIC(void) model_help(const char *category,
                             s_surf_model_description_t * table);
 
-/** \ingroup SURF_actions
- *  \brief Action states
+/** @ingroup SURF_interface
+ *  @brief Action states
  *
  *  Action states.
  *
- *  \see surf_action_t, surf_action_state_t
+ *  @see Action
  */
-
 typedef enum {
   SURF_ACTION_READY = 0,        /**< Ready        */
   SURF_ACTION_RUNNING,          /**< Running      */
@@ -166,19 +166,20 @@ typedef enum {
                                 /**< Not in the system anymore. Why did you ask ? */
 } e_surf_action_state_t;
 
+/** @ingroup SURF_vm_interface
+ * 
+ * 
+ */
 /* FIXME: Where should the VM state be defined? */
 typedef enum {
-  /* created, but not yet started */
-  SURF_VM_STATE_CREATED,
+  SURF_VM_STATE_CREATED, /**< created, but not yet started */
 
   SURF_VM_STATE_RUNNING,
   SURF_VM_STATE_MIGRATING,
 
-  /* Suspend/resume does not involve disk I/O, so we assume there is no transition states. */
-  SURF_VM_STATE_SUSPENDED,
+  SURF_VM_STATE_SUSPENDED, /**< Suspend/resume does not involve disk I/O, so we assume there is no transition states. */
 
-  /* Save/restore involves disk I/O, so there should be transition states. */
-  SURF_VM_STATE_SAVING,
+  SURF_VM_STATE_SAVING, /**< Save/restore involves disk I/O, so there should be transition states. */
   SURF_VM_STATE_SAVED,
   SURF_VM_STATE_RESTORING,
 
@@ -210,96 +211,694 @@ static inline void *surf_storage_resource_by_name(const char *name){
   return xbt_lib_get_elm_or_null(storage_lib, name);
 }
 
+
 XBT_PUBLIC(char *) surf_routing_edge_name(sg_routing_edge_t edge);
 XBT_PUBLIC(void *) surf_as_cluster_get_backbone(AS_t as);
 XBT_PUBLIC(void) surf_as_cluster_set_backbone(AS_t as, void* backbone);
+
+/** @{ @ingroup SURF_c_bindings */
+
+/** 
+ * @brief Get the name of a surf model
+ * 
+ * @param model A model
+ * @return The name of the model
+ */
 XBT_PUBLIC(const char *) surf_model_name(surf_model_t model);
+
+/**
+ * @brief Pop an action from the done actions set
+ * 
+ * @param model The model from which the action is extracted
+ * @return An action in done state
+ */
 XBT_PUBLIC(surf_action_t) surf_model_extract_done_action_set(surf_model_t model);
+
+/**
+ * @brief Pop an action from the failed actions set
+ * 
+ * @param model The model from which the action is extracted
+ * @return An action in failed state
+ */
 XBT_PUBLIC(surf_action_t) surf_model_extract_failed_action_set(surf_model_t model);
+
+/**
+ * @brief Pop an action from the ready actions set
+ * 
+ * @param model The model from which the action is extracted
+ * @return An action in ready state
+ */
 XBT_PUBLIC(surf_action_t) surf_model_extract_ready_action_set(surf_model_t model);
+
+/**
+ * @brief Pop an action from the running actions set
+ * 
+ * @param model The model from which the action is extracted
+ * @return An action in running state
+ */
 XBT_PUBLIC(surf_action_t) surf_model_extract_running_action_set(surf_model_t model);
+
+/**
+ * @brief Get the size of the running action set of a model
+ * 
+ * @param model The model
+ * @return The size of the running action set
+ */
 XBT_PUBLIC(int) surf_model_running_action_set_size(surf_model_t model);
+
+/**
+ * @brief Execute a parallel task
+ * @details [long description]
+ * 
+ * @param model The model which handle the parallelisation
+ * @param workstation_nb The number of workstations 
+ * @param workstation_list The list of workstations on which the task is executed
+ * @param computation_amount The processing amount (in flop) needed to process
+ * @param communication_amount The amount of data (in bytes) needed to transfer
+ * @param rate [description]
+ * @return The action corresponding to the parallele execution task
+ */
 XBT_PUBLIC(surf_action_t) surf_workstation_model_execute_parallel_task(surf_workstation_model_t model,
                                                    int workstation_nb,
                                             void **workstation_list,
                                             double *computation_amount,
                                             double *communication_amount,
                                             double rate);
+
+/**
+ * @brief Create a communication between two hosts
+ * 
+ * @param model The model which handle the communication
+ * @param src The source host
+ * @param dst The destination host
+ * @param size The amount of data (in bytes) needed to transfer
+ * @param rate [description]
+ * @return The action corresponding to the communication
+ */
 XBT_PUBLIC(surf_action_t) surf_workstation_model_communicate(surf_workstation_model_t model, surf_resource_t src, surf_resource_t dst, double size, double rate);
+
+/**
+ * @brief Get the route between two hosts
+ * @details [long description]
+ * 
+ * @param model The model which handle the routes
+ * @param src The source host
+ * @param dst The destination host
+ * @return The list of [TODO] from the source to the host
+ */
 XBT_PUBLIC(xbt_dynar_t) surf_workstation_model_get_route(surf_workstation_model_t model, surf_resource_t src, surf_resource_t dst);
+
+/**
+ * @brief Create a new VM on the specified host
+ * 
+ * @param name The name of the workstation
+ * @param ind_phys_host The host on which the VM is created
+ */
 XBT_PUBLIC(void) surf_vm_workstation_model_create(const char *name, surf_resource_t ind_phys_host);
+
+/**
+ * @brief Create a communication between two routing edges [TODO]
+ * @details [long description]
+ * 
+ * @param model The model which handle the communication
+ * @param src The source host
+ * @param dst The destination host
+ * @param size The amount of data (in bytes) needed to transfer
+ * @param rate [description]
+ * @return The action corresponding to the communication
+ */
 XBT_PUBLIC(surf_action_t) surf_network_model_communicate(surf_network_model_t model, sg_routing_edge_t src, sg_routing_edge_t dst, double size, double rate);
+
+/**
+ * @brief Get the name of a surf resource (cpu, workstation, network, …)
+ * 
+ * @param resource The surf resource
+ * @return The name of the surf resource
+ */
 XBT_PUBLIC(const char * ) surf_resource_name(surf_cpp_resource_t resource);
+
+/**
+ * @brief Get the properties of a surf resource (cpu, workstation, network, …)
+ * 
+ * @param resource The surf resource
+ * @return The properties of the surf resource
+ */
 XBT_PUBLIC(xbt_dict_t) surf_resource_get_properties(surf_cpp_resource_t resource);
+
+/**
+ * @brief Get the state of a surf resource (cpu, workstation, network, …)
+ * 
+ * @param resource The surf resource
+ * @return The state of the surf resource
+ */
 XBT_PUBLIC(e_surf_resource_state_t) surf_resource_get_state(surf_cpp_resource_t resource);
+
+/**
+ * @brief Set the state of a surf resource (cpu, workstation, network, …)
+ * 
+ * @param resource The surf resource
+ * @param state The new state of the surf resource
+ */
 XBT_PUBLIC(void) surf_resource_set_state(surf_cpp_resource_t resource, e_surf_resource_state_t state);
+
+/**
+ * @brief Get the speed of the cpu associtated to a workstation
+ * 
+ * @param resource The surf workstation
+ * @param load [description]
+ * 
+ * @return [description]
+ */
 XBT_PUBLIC(double) surf_workstation_get_speed(surf_resource_t resource, double load);
+
+/**
+ * @brief Get the available speed of cpu associtated to a workstation
+ * 
+ * @param resource The surf workstation
+ * @return [description]
+ */
 XBT_PUBLIC(double) surf_workstation_get_available_speed(surf_resource_t resource);
+
+/**
+ * @brief Get the number of cores of the cpu associated to a workstation
+ * 
+ * @param resource The surf workstation
+ * @return The number of cores
+ */
 XBT_PUBLIC(int) surf_workstation_get_core(surf_resource_t resource);
+
+/**
+ * @brief Execute some quantity of computation
+ *
+ * @param resource The surf workstation
+ * @param size The value of the processing amount (in flop) needed to process
+ * 
+ * @return The surf action corresponding to the processing
+ */
 XBT_PUBLIC(surf_action_t) surf_workstation_execute(surf_resource_t resource, double size);
+
+/**
+ * @brief Make the workstation sleep
+ * 
+ * @param resource The surf workstation
+ * @param duration The number of seconds to sleep
+ * @return The surf action corresponding to the sleep
+ */
 XBT_PUBLIC(surf_action_t) surf_workstation_sleep(surf_resource_t resource, double duration);
+
+/**
+ * @brief Open a file on a workstation
+ * 
+ * @param workstation The surf workstation
+ * @param mount The mount point
+ * @param path The path to the file
+ * @return The surf action corresponding to the openning
+ */
 XBT_PUBLIC(surf_action_t) surf_workstation_open(surf_resource_t workstation, const char* mount, const char* path);
+
+/**
+ * @brief Close a file descriptor on a workstation
+ * 
+ * @param workstation The surf workstation
+ * @param fd The file descriptor
+ * 
+ * @return The surf action corresponding to the closing
+ */
 XBT_PUBLIC(surf_action_t) surf_workstation_close(surf_resource_t workstation, surf_file_t fd);
+
+/**
+ * @brief Read a file
+ * 
+ * @param resource The surf workstation
+ * @param fd The file descriptor to read
+ * @param size The size in bytes to read
+ * @return The surf action corresponding to the reading
+ */
 XBT_PUBLIC(surf_action_t) surf_workstation_read(surf_resource_t resource, surf_file_t fd, sg_size_t size);
+
+/**
+ * @brief Write a file
+ * 
+ * @param resource The surf workstation
+ * @param fd The file descriptor to write
+ * @param size The size in bytes to write
+ * @return The surf action corresponding to the writing
+ */
 XBT_PUBLIC(surf_action_t) surf_workstation_write(surf_resource_t resource, surf_file_t fd, sg_size_t size);
+
+/**
+ * @brief Get the informations of a file descriptor
+ * @details The returned xbt_dynar_t contains:
+ *  - the size of the file,
+ *  - the mount point,
+ *  - the storage name,
+ *  - the storage typeId,
+ *  - the storage content type
+ * 
+ * @param resource The surf workstation
+ * @param fd The file descriptor
+ * @return An xbt_dynar_t with the file informations
+ */
 XBT_PUBLIC(xbt_dynar_t) surf_workstation_get_info(surf_resource_t resource, surf_file_t fd);
+
+/**
+ * @brief Get the available space of the storage at the mount point
+ * 
+ * @param resource The surf workstation
+ * @param name The mount point
+ * @return The amount of availble space in bytes
+ */
 XBT_PUBLIC(sg_size_t) surf_workstation_get_free_size(surf_resource_t resource, const char* name);
+
+/**
+ * @brief Get the used space of the storage at the mount point
+ * 
+ * @param resource The surf workstation
+ * @param name The mount point
+ * @return The amount of used space in bytes
+ */
 XBT_PUBLIC(sg_size_t) surf_workstation_get_used_size(surf_resource_t resource, const char* name);
+
+/**
+ * @brief Get the VMs hosted on the workstation
+ * 
+ * @param resource The surf workstation
+ * @return The list of VMs on the workstation
+ */
 XBT_PUBLIC(xbt_dynar_t) surf_workstation_get_vms(surf_resource_t resource);
+
+/**
+ * @brief [brief description]
+ * @details [long description]
+ * 
+ * @param resource [description]
+ * @param params [description]
+ */
 XBT_PUBLIC(void) surf_workstation_get_params(surf_resource_t resource, ws_params_t params);
+
+/**
+ * @brief [brief description]
+ * @details [long description]
+ * 
+ * @param resource [description]
+ * @param params [description]
+ */
 XBT_PUBLIC(void) surf_workstation_set_params(surf_resource_t resource, ws_params_t params);
+
+/**
+ * @brief Destroy a Workstation VM
+ * 
+ * @param resource The surf workstation vm
+ */
 XBT_PUBLIC(void) surf_vm_workstation_destroy(surf_resource_t resource);
+
+/**
+ * @brief Suspend a Workstation VM
+ * 
+ * @param resource The surf workstation vm
+ */
 XBT_PUBLIC(void) surf_vm_workstation_suspend(surf_resource_t resource);
+
+/**
+ * @brief Resume a Workstation VM
+ * 
+ * @param resource The surf workstation vm
+ */
 XBT_PUBLIC(void) surf_vm_workstation_resume(surf_resource_t resource);
+
+/**
+ * @brief Save the Workstation VM (Not yet implemented)
+ * 
+ * @param resource The surf workstation vm
+ */
 XBT_PUBLIC(void) surf_vm_workstation_save(surf_resource_t resource);
+
+/**
+ * @brief Restore the Workstation VM (Not yet implemented)
+ * 
+ * @param resource The surf workstation vm
+ */
 XBT_PUBLIC(void) surf_vm_workstation_restore(surf_resource_t resource);
+
+/**
+ * @brief Migrate the VM to the destination host
+ * 
+ * @param resource The surf workstation vm
+ * @param ind_vm_ws_dest The destination host
+ */
 XBT_PUBLIC(void) surf_vm_workstation_migrate(surf_resource_t resource, surf_resource_t ind_vm_ws_dest);
+
+/**
+ * @brief Get the physical machine hosting the VM
+ * 
+ * @param resource The surf workstation vm
+ * @return The physical machine hosting the VM
+ */
 XBT_PUBLIC(surf_resource_t) surf_vm_workstation_get_pm(surf_resource_t resource);
+
+/**
+ * @brief [brief description]
+ * @details [long description]
+ * 
+ * @param resource [description]
+ * @param bound [description]
+ */
 XBT_PUBLIC(void) surf_vm_workstation_set_bound(surf_resource_t resource, double bound);
+
+/**
+ * @brief [brief description]
+ * @details [long description]
+ * 
+ * @param resource [description]
+ * @param cpu [description]
+ * @param long [description]
+ */
 XBT_PUBLIC(void) surf_vm_workstation_set_affinity(surf_resource_t resource, surf_resource_t cpu, unsigned long mask);
+
+/**
+ * @brief Execute some quantity of computation
+ * 
+ * @param cpu The surf cpu
+ * @param size The value of the processing amount (in flop) needed to process
+ * @return The surf action corresponding to the processing
+ */
 XBT_PUBLIC(surf_action_t) surf_cpu_execute(surf_resource_t cpu, double size);
+
+/**
+ * @brief Make the cpu sleep for duration (in seconds)
+ * @details [long description]
+ * 
+ * @param cpu The surf cpu
+ * @param duration The number of seconds to sleep
+ * @return The surf action corresponding to the sleeping
+ */
 XBT_PUBLIC(surf_action_t) surf_cpu_sleep(surf_resource_t cpu, double duration);
+
+/**
+ * @brief Get the workstation power peak
+ * @details [long description]
+ * 
+ * @param resource The surf workstation
+ * @return The power peak
+ */
 XBT_PUBLIC(double) surf_workstation_get_current_power_peak(surf_resource_t host);
+
+/**
+ * @brief [brief description]
+ * @details [long description]
+ * 
+ * @param resource [description]
+ * @param pstate_index [description]
+ * 
+ * @return [description]
+ */
 XBT_PUBLIC(double) surf_workstation_get_power_peak_at(surf_resource_t host, int pstate_index);
+
+/**
+ * @brief [brief description]
+ * @details [long description]
+ * 
+ * @param resource [description]
+ * @return [description]
+ */
 XBT_PUBLIC(int) surf_workstation_get_nb_pstates(surf_resource_t host);
+
+/**
+ * @brief [brief description]
+ * @details [long description]
+ * 
+ * @param resource [description]
+ * @param pstate_index [description]
+ */
 XBT_PUBLIC(void) surf_workstation_set_power_peak_at(surf_resource_t host, int pstate_index);
+
+/**
+ * @brief Get the consumed energy (in joules) of a workstation
+ * 
+ * @param resource The surf workstation
+ * @return The consumed energy
+ */
 XBT_PUBLIC(double) surf_workstation_get_consumed_energy(surf_resource_t host);
+
+/**
+ * @brief Get the list of storages of a workstation
+ * 
+ * @param workstation The surf workstation
+ * @return Dictionary of mount point, Storage
+ */
 XBT_PUBLIC(xbt_dict_t) surf_workstation_get_storage_list(surf_resource_t workstation);
+
+/**
+ * @brief Unlink a file descriptor
+ * 
+ * @param workstation The surf workstation
+ * @param fd The file descriptor
+ * 
+ * @return 0 if failed to unlink, 1 otherwise
+ */
 XBT_PUBLIC(int) surf_workstation_unlink(surf_resource_t workstation, surf_file_t fd);
+
+/**
+ * @brief List directory contents of a path
+ * @details [long description]
+ * 
+ * @param workstation The surf workstation
+ * @param mount The mount point
+ * @param path The path to the directory
+ * @return The surf action corresponding to the ls action
+ */
 XBT_PUBLIC(surf_action_t) surf_workstation_ls(surf_resource_t workstation, const char* mount, const char *path);
+
+/**
+ * @brief Get the size of a file on a workstation
+ * 
+ * @param workstation The surf workstation
+ * @param fd The file descriptor
+ * 
+ * @return The size in bytes of the file
+ */
 XBT_PUBLIC(size_t) surf_workstation_get_size(surf_resource_t workstation, surf_file_t fd);
+
+/**
+ * @brief Get the current position of the file descriptor
+ * 
+ * @param workstation The surf workstation
+ * @param fd The file descriptor
+ * @return The current position of the file descriptor
+ */
 XBT_PUBLIC(size_t) surf_workstation_file_tell(surf_resource_t workstation, surf_file_t fd);
+
+/**
+ * @brief Set the position indictator assiociated with the file descriptor to a new position
+ * @details [long description]
+ * 
+ * @param workstation The surf workstation
+ * @param fd The file descriptor
+ * @param offset The offset from the origin
+ * @param origin Position used as a reference for the offset
+ *  - SEEK_SET: beginning of the file
+ *  - SEEK_CUR: current position indicator
+ *  - SEEK_END: end of the file
+ * @return MSG_OK if successful, otherwise MSG_TASK_CANCELED
+ */
 XBT_PUBLIC(int) surf_workstation_file_seek(surf_resource_t workstation, surf_file_t fd, sg_size_t offset, int origin);
+
+/**
+ * @brief [brief description]
+ * @details [long description]
+ * 
+ * @param link [description]
+ * @return [description]
+ */
 XBT_PUBLIC(int) surf_network_link_is_shared(surf_cpp_resource_t link);
+
+/**
+ * @brief Get the bandwidth of a link in bytes per second
+ * 
+ * @param link The surf link
+ * @return The bandwidth in bytes per second
+ */
 XBT_PUBLIC(double) surf_network_link_get_bandwidth(surf_cpp_resource_t link);
+
+/**
+ * @brief Get the latency of a link in seconds
+ * 
+ * @param link The surf link
+ * @return The latency in seconds
+ */
 XBT_PUBLIC(double) surf_network_link_get_latency(surf_cpp_resource_t link);
+
+/**
+ * @brief Get the content of a storage
+ * 
+ * @param resource The surf storage
+ * @return A xbt_dict_t with path as keys and size in bytes as values
+ */
 XBT_PUBLIC(xbt_dict_t) surf_storage_get_content(surf_resource_t resource);
+
+/**
+ * @brief Get the size in bytes of a storage
+ * 
+ * @param resource The surf storage
+ * @return The size in bytes of the storage
+ */
 XBT_PUBLIC(sg_size_t) surf_storage_get_size(surf_resource_t resource);
+
+/**
+ * @brief Rename a path
+ * 
+ * @param resource The surf storage
+ * @param src The old path
+ * @param dest The new path
+ */
 XBT_PUBLIC(void) surf_storage_rename(surf_resource_t resource, const char* src, const char* dest);
+
+/**
+ * @brief Get the data associated to the action
+ * 
+ * @param action The surf action
+ * @return The data associated to the action
+ */
 XBT_PUBLIC(void*) surf_action_get_data(surf_action_t action);
+
+/**
+ * @brief Set the data associated to the action
+ * @details [long description]
+ * 
+ * @param action The surf action
+ * @param data The new data associated to the action
+ */
 XBT_PUBLIC(void) surf_action_set_data(surf_action_t action, void *data);
+
+/**
+ * @brief Unreference an action
+ * 
+ * @param action The surf action
+ */
 XBT_PUBLIC(void) surf_action_unref(surf_action_t action);
+
+/**
+ * @brief Get the start time of an action
+ * 
+ * @param action The surf action
+ * @return The start time in seconds from the beginning of the simulation
+ */
 XBT_PUBLIC(double) surf_action_get_start_time(surf_action_t action);
+
+/**
+ * @brief Get the finish time of an action
+ * 
+ * @param action The surf action
+ * @return The finish time in seconds from the beginning of the simulation
+ */
 XBT_PUBLIC(double) surf_action_get_finish_time(surf_action_t action);
+
+/**
+ * @brief Get the remains amount of work to do of an action
+ * 
+ * @param action The surf action
+ * @return  The remains amount of work to do
+ */
 XBT_PUBLIC(double) surf_action_get_remains(surf_action_t action);
+
+/**
+ * @brief Suspend an action
+ * 
+ * @param action The surf action
+ */
 XBT_PUBLIC(void) surf_action_suspend(surf_action_t action);
+
+/**
+ * @brief Resume an action
+ * 
+ * @param action The surf action
+ */
 XBT_PUBLIC(void) surf_action_resume(surf_action_t action);
+
+/**
+ * @brief Cancel an action
+ * 
+ * @param action The surf action
+ */
 XBT_PUBLIC(void) surf_action_cancel(surf_action_t action);
+
+/**
+ * @brief Set the priority of an action
+ * @details [long description]
+ * 
+ * @param action The surf action
+ * @param priority The new priority [TODO]
+ */
 XBT_PUBLIC(void) surf_action_set_priority(surf_action_t action, double priority);
+
+/**
+ * @brief Set the category of an action
+ * @details [long description]
+ * 
+ * @param action The surf action
+ * @param category The new category of the action
+ */
 XBT_PUBLIC(void) surf_action_set_category(surf_action_t action, const char *category);
+
+/**
+ * @brief Get the state of an action 
+ * 
+ * @param action The surf action
+ * @return The state of the action
+ */
 XBT_PUBLIC(e_surf_action_state_t) surf_action_get_state(surf_action_t action);
+
+/**
+ * @brief Get the cost of an action
+ * 
+ * @param action The surf action
+ * @return The cost of the action
+ */
 XBT_PUBLIC(int) surf_action_get_cost(surf_action_t action);
+
+/**
+ * @brief [brief desrciption]
+ * @details [long description]
+ * 
+ * @param action The surf cpu action
+ * @param cpu [description]
+ * @param long [description]
+ */
 XBT_PUBLIC(void) surf_cpu_action_set_affinity(surf_action_t action, surf_resource_t cpu, unsigned long mask);
+
+/**
+ * @brief [brief description]
+ * @details [long description]
+ * 
+ * @param action The surf cpu action
+ * @param bound [description]
+ */
 XBT_PUBLIC(void) surf_cpu_action_set_bound(surf_action_t action, double bound);
+
+/**
+ * @brief Get the file associated to a storage action
+ * 
+ * @param action The surf storage action
+ * @return The file associated to a storage action
+ */
 XBT_PUBLIC(surf_file_t) surf_storage_action_get_file(surf_action_t action);
+
+/**
+ * @brief Get the result dictionary of an ls action
+ * 
+ * @param action The surf storage action
+ * @return The dictionry listing a path
+ */
 XBT_PUBLIC(xbt_dict_t) surf_storage_action_get_ls_dict(surf_action_t action);
+
 XBT_PUBLIC(surf_model_t) surf_resource_model(const void *host, int level);
 
+/** @} */
+
 /**************************************/
 /* Implementations of model object */
 /**************************************/
 
-
 /** \ingroup SURF_models
  *  \brief The CPU model object for the physical machine layer
  */
@@ -336,6 +935,11 @@ XBT_PUBLIC(void) surf_cpu_model_init_ti(void);
  */
 XBT_PUBLIC_DATA(s_surf_model_description_t) surf_optimization_mode_description[];
 
+/** \ingroup SURF_plugins
+ *  \brief The list of all available surf plugins
+ */
+XBT_PUBLIC_DATA(s_surf_model_description_t) surf_plugin_description[];
+
 /** \ingroup SURF_models
  *  \brief The list of all available cpu model models
  */
index 11cf929..c57b33c 100644 (file)
@@ -111,6 +111,27 @@ static void sg_config_cmd_line(int *argc, char **argv)
     sg_cfg_exit_early();
 }
 
+/* callback of the plugin variable */
+static void _sg_cfg_cb__plugin(const char *name, int pos)
+{
+  char *val;
+
+  XBT_VERB("PLUGIN");
+  xbt_assert(_sg_cfg_init_status < 2,
+              "Cannot load a plugin after the initialization");
+
+  val = xbt_cfg_get_string(_sg_cfg_set, name);
+
+  if (!strcmp(val, "help")) {
+    model_help("plugin", surf_plugin_description);
+    sg_cfg_exit_early();
+  }
+
+  /* New Module missing */
+  int plugin_id = find_model_description(surf_plugin_description, val);
+  surf_plugin_description[plugin_id].model_init_preparse();
+}
+
 /* callback of the workstation/model variable */
 static void _sg_cfg_cb__workstation_model(const char *name, int pos)
 {
@@ -435,6 +456,21 @@ void sg_config_init(int *argc, char **argv)
 
   /* Create the configuration support */
   if (_sg_cfg_init_status == 0) { /* Only create stuff if not already inited */
+
+       /* Plugins configuration */
+
+       sprintf(description,
+               "The plugins. Possible values: ");
+             p = description;
+       while (*(++p) != '\0');
+       for (i = 0; surf_plugin_description[i].name; i++)
+         p += sprintf(p, "%s%s", (i == 0 ? "" : ", "),
+                      surf_plugin_description[i].name);
+       sprintf(p,
+               ".\n       (use 'help' as a value to see the long description of each plugin)");
+       xbt_cfg_register(&_sg_cfg_set, "plugin", description,
+                        xbt_cfgelm_string, 1, 1, &_sg_cfg_cb__plugin, NULL);
+
     sprintf(description,
             "The model to use for the CPU. Possible values: ");
     p = description;
index db76cd2..7e446a9 100644 (file)
@@ -1,4 +1,4 @@
-/* Copyright (c) 2007-2013. The SimGrid Team.
+/* Copyright (c) 2007-2014. The SimGrid Team.
  * All rights reserved.                                                     */
 
 /* This program is free software; you can redistribute it and/or modify it
@@ -160,6 +160,7 @@ int smpi_process_getarg(integer * index, char *dst, ftnlen len)
   }
   return 0;
 }
+#endif
 
 int smpi_global_size(void)
 {
@@ -172,7 +173,6 @@ int smpi_global_size(void)
   }
   return atoi(value);
 }
-#endif
 
 smpi_process_data_t smpi_process_data(void)
 {
index 5c465c7..e5270a2 100755 (executable)
@@ -17,8 +17,7 @@ else
     list_add LINKARGS "@libdir@\libsimgrid.dll"
 fi
 
-list_set CMDLINE "${CC}"
-list_add_not_empty CMDLINE "${CFLAGS}"
+list_set CMDARGS
 while [ $# -gt 0 ]; do
     ARG="$1"
     shift
@@ -26,23 +25,26 @@ while [ $# -gt 0 ]; do
         -c)
             CMAKE_LINKARGS=""
             LINKARGS=""
-            list_add CMDLINE "-c"
+            list_add CMDARGS "-c"
             ;;
         *.c)
             SRCFILE="$(readlink -f ${ARG} 2>/dev/null)"
             if [ -z "$SRCFILE" ] ; then
                 SRCFILE="$ARG"
             fi
-            list_add CMDLINE "${SRCFILE}"
+            list_add CMDARGS "${SRCFILE}"
             ;;
         *)
-            list_add CMDLINE "${ARG}"
+            list_add CMDARGS "${ARG}"
       ;;
   esac
 done
 
+list_set CMDLINE "${CC}"
+list_add_not_empty CMDLINE "${CFLAGS}"
 list_add_not_empty CMDLINE ${INCLUDEARGS}
 list_add_not_empty CMDLINE ${CMAKE_LINKARGS}
+list_add_not_empty CMDLINE "${CMDARGS}"
 list_add_not_empty CMDLINE "${LINKARGS}"
 
 eval $(list_get CMDLINE)
index 93078ea..1174ac2 100644 (file)
@@ -6,6 +6,7 @@
 
 #include "cpu_cas01.hpp"
 #include "cpu_ti.hpp"
+#include "plugins/energy.hpp"
 #include "maxmin_private.hpp"
 #include "simgrid/sg_config.h"
 
@@ -199,11 +200,6 @@ CpuCas01::CpuCas01(CpuCas01ModelPtr model, const char *name, xbt_dynar_t powerPe
   p_powerPeakList = powerPeak;
   m_pstate = pstate;
 
-  p_energy = xbt_new(s_energy_cpu_cas01_t, 1);
-  p_energy->total_energy = 0;
-  p_energy->power_range_watts_list = getWattsRangeList();
-  p_energy->last_updated = surf_get_clock();
-
   XBT_DEBUG("CPU create: peak=%f, pstate=%d", m_powerPeak, m_pstate);
 
   m_core = core;
@@ -216,13 +212,7 @@ CpuCas01::CpuCas01(CpuCas01ModelPtr model, const char *name, xbt_dynar_t powerPe
 }
 
 CpuCas01::~CpuCas01(){
-  unsigned int iter;
-  xbt_dynar_t power_tuple = NULL;
-  xbt_dynar_foreach(p_energy->power_range_watts_list, iter, power_tuple)
-    xbt_dynar_free(&power_tuple);
-  xbt_dynar_free(&p_energy->power_range_watts_list);
   xbt_dynar_free(&p_powerPeakList);
-  xbt_free(p_energy);
 }
 
 bool CpuCas01::isUsed()
@@ -338,105 +328,6 @@ CpuActionPtr CpuCas01::sleep(double duration)
   return action;
 }
 
-xbt_dynar_t CpuCas01::getWattsRangeList()
-{
-       xbt_dynar_t power_range_list;
-       xbt_dynar_t power_tuple;
-       int i = 0, pstate_nb=0;
-       xbt_dynar_t current_power_values;
-       double min_power, max_power;
-
-       if (getProperties() == NULL)
-               return NULL;
-
-       char* all_power_values_str = (char*)xbt_dict_get_or_null(getProperties(), "power_per_state");
-
-       if (all_power_values_str == NULL)
-               return NULL;
-
-
-       power_range_list = xbt_dynar_new(sizeof(xbt_dynar_t), NULL);
-       xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
-
-       pstate_nb = xbt_dynar_length(all_power_values);
-       for (i=0; i< pstate_nb; i++)
-       {
-               /* retrieve the power values associated with the current pstate */
-               current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
-               xbt_assert(xbt_dynar_length(current_power_values) > 1,
-                               "Power properties incorrectly defined - could not retrieve min and max power values for host %s",
-                               getName());
-
-               /* min_power corresponds to the idle power (cpu load = 0) */
-               /* max_power is the power consumed at 100% cpu load       */
-               min_power = atof(xbt_dynar_get_as(current_power_values, 0, char*));
-               max_power = atof(xbt_dynar_get_as(current_power_values, 1, char*));
-
-               power_tuple = xbt_dynar_new(sizeof(double), NULL);
-               xbt_dynar_push_as(power_tuple, double, min_power);
-               xbt_dynar_push_as(power_tuple, double, max_power);
-
-               xbt_dynar_push_as(power_range_list, xbt_dynar_t, power_tuple);
-               xbt_dynar_free(&current_power_values);
-       }
-       xbt_dynar_free(&all_power_values);
-       return power_range_list;
-}
-
-/**
- * Computes the power consumed by the host according to the current pstate and processor load
- *
- */
-double CpuCas01::getCurrentWattsValue(double cpu_load)
-{
-       xbt_dynar_t power_range_list = p_energy->power_range_watts_list;
-
-       if (power_range_list == NULL)
-       {
-               XBT_DEBUG("No power range properties specified for host %s", getName());
-               return 0;
-       }
-       xbt_assert(xbt_dynar_length(power_range_list) == xbt_dynar_length(p_powerPeakList),
-                                               "The number of power ranges in the properties does not match the number of pstates for host %s",
-                                               getName());
-
-    /* retrieve the power values associated with the current pstate */
-    xbt_dynar_t current_power_values = xbt_dynar_get_as(power_range_list, m_pstate, xbt_dynar_t);
-
-    /* min_power corresponds to the idle power (cpu load = 0) */
-    /* max_power is the power consumed at 100% cpu load       */
-    double min_power = xbt_dynar_get_as(current_power_values, 0, double);
-    double max_power = xbt_dynar_get_as(current_power_values, 1, double);
-    double power_slope = max_power - min_power;
-
-    double current_power = min_power + cpu_load * power_slope;
-
-       XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
-    XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
-
-       return current_power;
-}
-
-/**
- * Updates the total energy consumed as the sum of the current energy and
- *                                              the energy consumed by the current action
- */
-void CpuCas01::updateEnergy(double cpu_load)
-{
-  double start_time = p_energy->last_updated;
-  double finish_time = surf_get_clock();
-
-  XBT_DEBUG("[cpu_update_energy] action time interval=(%f-%f), current power peak=%f, current pstate=%d",
-                 start_time, finish_time, m_powerPeak, m_pstate);
-  double current_energy = p_energy->total_energy;
-  double action_energy = getCurrentWattsValue(cpu_load)*(finish_time-start_time);
-
-  p_energy->total_energy = current_energy + action_energy;
-  p_energy->last_updated = finish_time;
-
-  XBT_DEBUG("[cpu_update_energy] old_energy_value=%f, action_energy_value=%f", current_energy, action_energy);
-}
-
 double CpuCas01::getCurrentPowerPeak()
 {
   return m_powerPeak;
@@ -465,11 +356,6 @@ void CpuCas01::setPowerPeakAt(int pstate_index)
   m_powerPeak = new_power_peak;
 }
 
-double CpuCas01::getConsumedEnergy()
-{
-  return p_energy->total_energy;
-}
-
 /**********
  * Action *
  **********/
@@ -489,20 +375,3 @@ CpuCas01Action::CpuCas01Action(ModelPtr model, double cost, bool failed, double
   }
   lmm_expand(model->getMaxminSystem(), constraint, getVariable(), 1.0);
 }
-
-
-/**
- * Update the CPU total energy for a finished action
- *
- */
-void CpuCas01Action::updateEnergy()
-{
-  CpuCas01Ptr cpu  = static_cast<CpuCas01Ptr>(lmm_constraint_id(lmm_get_cnst_from_var
-                                                                                 (getModel()->getMaxminSystem(),
-                                                                                                 getVariable(), 0)));
-
-  if(cpu->p_energy->last_updated < surf_get_clock()) {
-       double load = lmm_constraint_get_usage(cpu->getConstraint()) / cpu->m_powerPeak;
-    cpu->updateEnergy(load);
-  }
-}
index 7f54163..389da41 100644 (file)
@@ -60,22 +60,16 @@ public:
   CpuActionPtr execute(double size);
   CpuActionPtr sleep(double duration);
 
-  xbt_dynar_t getWattsRangeList();
-  double getCurrentWattsValue(double cpu_load);
-  void updateEnergy(double cpu_load);
-
   double getCurrentPowerPeak();
   double getPowerPeakAt(int pstate_index);
   int getNbPstates();
   void setPowerPeakAt(int pstate_index);
-  double getConsumedEnergy();
 
   bool isUsed();
 
   tmgr_trace_event_t p_powerEvent;
   xbt_dynar_t p_powerPeakList;                         /*< List of supported CPU capacities */
   int m_pstate;                                                                /*< Current pstate (index in the power_peak_list)*/
-  energy_cpu_cas01_t p_energy;                         /*< Structure with energy-consumption data */
 };
 
 /**********
@@ -89,5 +83,4 @@ public:
   CpuCas01Action(ModelPtr model, double cost, bool failed, double power, lmm_constraint_t constraint);
 
   ~CpuCas01Action() {};
-  void updateEnergy();
 };
index b496745..a55374b 100644 (file)
@@ -7,6 +7,19 @@ XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_cpu, surf,
 CpuModelPtr surf_cpu_model_pm;
 CpuModelPtr surf_cpu_model_vm;
 
+/*************
+ * Callbacks *
+ *************/
+
+CpuPtr getActionCpu(CpuActionPtr action) {
+  return static_cast<CpuPtr>(lmm_constraint_id(lmm_get_cnst_from_var
+                                        (action->getModel()->getMaxminSystem(),
+                                        action->getVariable(), 0)));
+}
+surf_callback(void, CpuPtr) createCpuCallbacks;
+surf_callback(void, CpuPtr) deleteCpuCallbacks;
+surf_callback(void, CpuActionPtr) updateCpuActionCallbacks;
+
 /*********
  * Model *
  *********/
@@ -31,7 +44,7 @@ void CpuModel::updateActionsStateLazy(double now, double /*delta*/)
     action->finish();
     XBT_CDEBUG(surf_kernel, "Action %p finished", action);
 
-    action->updateEnergy();
+    surf_callback_emit(updateCpuActionCallbacks, action);
 
     /* set the remains to 0 due to precision problems when updating the remaining amount */
     action->setRemains(0);
@@ -102,7 +115,8 @@ void CpuModel::updateActionsStateFull(double now, double delta)
       action->finish();
       action->setState(SURF_ACTION_DONE);
     }
-    action->updateEnergy();
+    surf_callback_emit(updateCpuActionCallbacks, action);
+    //action->updateEnergy();
   }
 
   return;
@@ -112,6 +126,10 @@ void CpuModel::updateActionsStateFull(double now, double delta)
  * Resource *
  ************/
 
+Cpu::Cpu(){
+  surf_callback_emit(createCpuCallbacks, this);
+}
+
 Cpu::Cpu(ModelPtr model, const char *name, xbt_dict_t props,
                 int core, double powerPeak, double powerScale)
  : Resource(model, name, props)
@@ -120,7 +138,9 @@ Cpu::Cpu(ModelPtr model, const char *name, xbt_dict_t props,
  , m_powerScale(powerScale)
  , p_constraintCore(NULL)
  , p_constraintCoreId(NULL)
-{}
+{
+  surf_callback_emit(createCpuCallbacks, this);
+}
 
 Cpu::Cpu(ModelPtr model, const char *name, xbt_dict_t props,
                 lmm_constraint_t constraint, int core, double powerPeak, double powerScale)
@@ -129,6 +149,7 @@ Cpu::Cpu(ModelPtr model, const char *name, xbt_dict_t props,
  , m_powerPeak(powerPeak)
  , m_powerScale(powerScale)
 {
+  surf_callback_emit(createCpuCallbacks, this);
   /* At now, we assume that a VM does not have a multicore CPU. */
   if (core > 1)
     xbt_assert(model == surf_cpu_model_pm);
@@ -149,6 +170,7 @@ Cpu::Cpu(ModelPtr model, const char *name, xbt_dict_t props,
 }
 
 Cpu::~Cpu(){
+  surf_callback_emit(deleteCpuCallbacks, this);
   if (p_constraintCoreId){
     for (int i = 0; i < m_core; i++) {
          xbt_free(p_constraintCoreId[i]);
index 6b8c405..7e2c9cd 100644 (file)
@@ -1,3 +1,9 @@
+/* Copyright (c) 2004-2013. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
 #include "surf_interface.hpp"
 #include "maxmin_private.hpp"
 
@@ -16,13 +22,59 @@ typedef Cpu *CpuPtr;
 class CpuAction;
 typedef CpuAction *CpuActionPtr;
 
+class CpuPlugin;
+typedef CpuPlugin *CpuPluginPtr;
+
+/*************
+ * Callbacks *
+ *************/
+CpuPtr getActionCpu(CpuActionPtr action);
+
+/** @ingroup SURF_callbacks
+ * @brief Callbacks handler which emit the callbacks after Cpu creation * 
+ * @detail Callback functions have the following signature: `void(CpuPtr)`
+ */
+extern surf_callback(void, CpuPtr) createCpuCallbacks;
+
+/** @ingroup SURF_callbacks
+ * @brief Callbacks handler which emit the callbacks after Cpu destruction * 
+ * @detail Callback functions have the following signature: `void(CpuPtr)`
+ */
+extern surf_callback(void, CpuPtr) deleteCpuCallbacks;
+
+/** @ingroup SURF_callbacks
+ * @brief Callbacks handler which emit the callbacks after CpuAction update * 
+ * @detail Callback functions have the following signature: `void(CpuActionPtr)`
+ */
+extern surf_callback(void, CpuActionPtr) updateCpuActionCallbacks;
+
 /*********
  * Model *
  *********/
+
+ /** @ingroup SURF_cpu_interface
+ * @brief SURF cpu model interface class
+ * @details A model is an object which handle the interactions between its Resources and its Actions
+ */
 class CpuModel : public Model {
 public:
+  /**
+   * @brief CpuModel constructor
+   * 
+   * @param name The name of the model
+   */
   CpuModel(const char *name) : Model(name) {};
+
+  /**
+   * @brief Create a Cpu
+   * 
+   * @param name The name of the Cpu
+   * 
+   * @return The created Cpu
+   */
   CpuPtr createResource(string name);
+
+
   void updateActionsStateLazy(double now, double delta);
   void updateActionsStateFull(double now, double delta);
 
@@ -32,26 +84,104 @@ public:
 /************
  * Resource *
  ************/
+
+/** @ingroup SURF_cpu_interface
+* @brief SURF cpu resource interface class
+* @details A Cpu represent a cpu associated to a workstation
+*/
 class Cpu : public Resource {
 public:
-  Cpu(){};
-  /*Cpu(lmm_constraint_t constraint);*/
+  /**
+   * @brief Cpu constructor
+   */
+  Cpu();
+
+  /**
+   * @brief Cpu constructor
+   * 
+   * @param model The CpuModel associated to this Cpu
+   * @param name The name of the Cpu
+   * @param props Dictionary of properties associated to this Cpu
+   * @param constraint The lmm constraint associated to this Cpu if it is part of a LMM component
+   * @param core The number of core of this Cpu
+   * @param powerPeak The power peak of this Cpu
+   * @param powerScale The power scale of this Cpu
+   */
   Cpu(ModelPtr model, const char *name, xbt_dict_t props,
          lmm_constraint_t constraint, int core, double powerPeak, double powerScale);
+
+  /**
+   * @brief Cpu constructor
+   * 
+   * @param model The CpuModel associated to this Cpu
+   * @param name The name of the Cpu
+   * @param props Dictionary of properties associated to this Cpu
+   * @param core The number of core of this Cpu
+   * @param powerPeak The power peak of this Cpu in [TODO]
+   * @param powerScale The power scale of this Cpu in [TODO]
+   */
   Cpu(ModelPtr model, const char *name, xbt_dict_t props,
          int core, double powerPeak, double powerScale);
+
+  /**
+   * @brieaf Cpu destructor
+   */
   ~Cpu();
+
+  /**
+   * @brief Execute some quantity of computation
+   * 
+   * @param size The value of the processing amount (in flop) needed to process
+   * @return The CpuAction corresponding to the processing
+   */
   virtual CpuActionPtr execute(double size)=0;
+
+  /**
+   * @brief Make a process sleep for duration (in seconds)
+   * 
+   * @param duration The number of seconds to sleep
+   * @return The CpuAction corresponding to the sleeping
+   */
   virtual CpuActionPtr sleep(double duration)=0;
+
+  /**
+   * @brief Get the number of cores of the current Cpu
+   * 
+   * @return The number of cores of the current Cpu
+   */
   virtual int getCore();
+
+  /**
+   * @brief Get the speed of the current Cpu
+   * @details [TODO] load * m_powerPeak
+   * 
+   * @param load [TODO]
+   * 
+   * @return The speed of the current Cpu
+   */
   virtual double getSpeed(double load);
+
+  /**
+   * @brief Get the available speed of the current Cpu
+   * @details [TODO]
+   * 
+   * @return The available speed of the current Cpu
+   */
   virtual double getAvailableSpeed();
 
+  /**
+   * @brief Get the current Cpu power peak
+   * 
+   * @return The current Cpu power peak
+   */
   virtual double getCurrentPowerPeak()=0;
+
+
   virtual double getPowerPeakAt(int pstate_index)=0;
+  
   virtual int getNbPstates()=0;
+  
   virtual void setPowerPeakAt(int pstate_index)=0;
-  virtual double getConsumedEnergy()=0;
 
   void addTraces(void);
   int m_core;
@@ -66,18 +196,58 @@ public:
 /**********
  * Action *
  **********/
+
+ /** @ingroup SURF_cpu_interface
+ * @brief SURF Cpu action interface class
+ * @details A CpuAction represent the execution of code on a Cpu
+ */
 class CpuAction : public Action {
+friend CpuPtr getActionCpu(CpuActionPtr action);
 public:
+  /**
+   * @brief CpuAction constructor
+   */
   CpuAction(){};
+
+  /**
+   * @brief CpuAction constructor
+   * 
+   * @param model The CpuModel associated to this CpuAction
+   * @param cost [TODO]
+   * @param failed [TODO]
+   */
   CpuAction(ModelPtr model, double cost, bool failed)
   : Action(model, cost, failed) {} //FIXME:REMOVE
+
+  /**
+   * @brief CpuAction constructor
+   * 
+   * @param model The CpuModel associated to this CpuAction
+   * @param cost [TODO]
+   * @param failed [TODO]
+   * @param var The lmm variable associated to this CpuAction if it is part of a LMM component
+   */
   CpuAction(ModelPtr model, double cost, bool failed, lmm_variable_t var)
   : Action(model, cost, failed, var) {}
+
+  /**
+   * @brief Set the affinity of the current CpuAction
+   * @details [TODO]
+   * 
+   * @param cpu [TODO]
+   * @param long [TODO]
+   */
   virtual void setAffinity(CpuPtr cpu, unsigned long mask);
+
+  /**
+   * @brief Set the bound of current CpuAction
+   * @details [TODO]
+   * 
+   * @param bound [TODO]
+   */
   virtual void setBound(double bound);
 
   void updateRemainingLazy(double now);
-  virtual void updateEnergy()=0;
   double m_bound;
 };
 
index e2e9406..53f5361 100644 (file)
@@ -71,7 +71,6 @@ public:
   tmgr_trace_t p_powerTrace;
 };
 
-
 /*********
  * Model *
  *********/
@@ -125,15 +124,10 @@ public:
   CpuActionPtr sleep(double duration);
   double getAvailableSpeed();
 
-  xbt_dynar_t getWattsRangeList() {THROW_UNIMPLEMENTED;};
-  double getCurrentWattsValue(double /*cpu_load*/) {THROW_UNIMPLEMENTED;};
-  void updateEnergy(double /*cpu_load*/) {THROW_UNIMPLEMENTED;};
-
   double getCurrentPowerPeak() {THROW_UNIMPLEMENTED;};
   double getPowerPeakAt(int /*pstate_index*/) {THROW_UNIMPLEMENTED;};
   int getNbPstates() {THROW_UNIMPLEMENTED;};
   void setPowerPeakAt(int /*pstate_index*/) {THROW_UNIMPLEMENTED;};
-  double getConsumedEnergy() {THROW_UNIMPLEMENTED;};
 
   CpuTiTgmrPtr p_availTrace;       /*< Structure with data needed to integrate trace file */
   tmgr_trace_event_t p_stateEvent;       /*< trace file with states events (ON or OFF) */
@@ -177,7 +171,6 @@ public:
   double getRemains();
   void setAffinity(CpuPtr /*cpu*/, unsigned long /*mask*/) {};
   void setBound(double /*bound*/) {};
-  void updateEnergy() {};
 
   CpuTiPtr p_cpu;
   int m_indexHeap;
diff --git a/src/surf/maxmin_private_.h b/src/surf/maxmin_private_.h
deleted file mode 100644 (file)
index bdf6fc4..0000000
+++ /dev/null
@@ -1,112 +0,0 @@
-/* Copyright (c) 2004, 2005, 2006, 2007, 2008, 2009, 2010. The SimGrid Team.
- * All rights reserved.                                                     */
-
-/* This program is free software; you can redistribute it and/or modify it
- * under the terms of the license (GNU LGPL) which comes with this package. */
-
-#ifndef _SURF_MAXMIN_PRIVATE_H
-#define _SURF_MAXMIN_PRIVATE_H
-
-#include "surf/maxmin_.h"
-#include "xbt/swag.h"
-#include "xbt/mallocator.h"
-
-
-
-typedef struct lmm_element {
-  /* hookup to constraint */
-  s_xbt_swag_hookup_t element_set_hookup;
-  s_xbt_swag_hookup_t active_element_set_hookup;
-
-  lmm_constraint_t constraint;
-  lmm_variable_t variable;
-  double value;
-} s_lmm_element_t;
-#define make_elem_active(elem) xbt_swag_insert_at_head(elem,&(elem->constraint->active_element_set))
-#define make_elem_inactive(elem) xbt_swag_remove(elem,&(elem->constraint->active_element_set))
-
-typedef struct lmm_constraint_light {
-  double remaining_over_usage;
-  lmm_constraint_t cnst;
-} s_lmm_constraint_light_t;
-
-typedef struct lmm_constraint {
-  /* hookup to system */
-  s_xbt_swag_hookup_t constraint_set_hookup;
-  s_xbt_swag_hookup_t active_constraint_set_hookup;
-  s_xbt_swag_hookup_t modified_constraint_set_hookup;
-  s_xbt_swag_hookup_t saturated_constraint_set_hookup;
-
-  s_xbt_swag_t element_set;     /* a list of lmm_element_t */
-  s_xbt_swag_t active_element_set;      /* a list of lmm_element_t */
-  double remaining;
-  double usage;
-  double bound;
-  int shared;
-  void *id;
-  int id_int;
-  double lambda;
-  double new_lambda;
-  lmm_constraint_light_t cnst_light;
-} s_lmm_constraint_t;
-
-typedef struct lmm_variable {
-  /* hookup to system */
-  s_xbt_swag_hookup_t variable_set_hookup;
-  s_xbt_swag_hookup_t saturated_variable_set_hookup;
-
-  s_lmm_element_t *cnsts;
-  int cnsts_size;
-  int cnsts_number;
-  double weight;
-  double bound;
-  double value;
-  void *id;
-  int id_int;
-  unsigned visited;             /* used by lmm_update_modified_set */
-  /* \begin{For Lagrange only} */
-  double mu;
-  double new_mu;
-  double (*func_f) (struct lmm_variable * var, double x);       /* (f)    */
-  double (*func_fp) (struct lmm_variable * var, double x);      /* (f')    */
-  double (*func_fpi) (struct lmm_variable * var, double x);     /* (f')^{-1}    */
-  /* \end{For Lagrange only} */
-} s_lmm_variable_t;
-
-typedef struct lmm_system {
-  int modified;
-  int selective_update_active;  /* flag to update partially the system only selecting changed portions */
-  unsigned visited_counter;     /* used by lmm_update_modified_set */
-  s_xbt_swag_t variable_set;    /* a list of lmm_variable_t */
-  s_xbt_swag_t constraint_set;  /* a list of lmm_constraint_t */
-
-  s_xbt_swag_t active_constraint_set;   /* a list of lmm_constraint_t */
-  s_xbt_swag_t modified_constraint_set; /* a list of modified lmm_constraint_t */
-
-  s_xbt_swag_t saturated_variable_set;  /* a list of lmm_variable_t */
-  s_xbt_swag_t saturated_constraint_set;        /* a list of lmm_constraint_t_t */
-
-  xbt_swag_t keep_track;
-
-  xbt_mallocator_t variable_mallocator;
-} s_lmm_system_t;
-
-#define extract_variable(sys) xbt_swag_extract(&(sys->variable_set))
-#define extract_constraint(sys) xbt_swag_extract(&(sys->constraint_set))
-#define insert_constraint(sys,cnst) xbt_swag_insert(cnst,&(sys->constraint_set))
-#define remove_variable(sys,var) do {xbt_swag_remove(var,&(sys->variable_set));\
-                                 xbt_swag_remove(var,&(sys->saturated_variable_set));} while(0)
-#define remove_constraint(sys,cnst) do {xbt_swag_remove(cnst,&(sys->constraint_set));\
-                                        xbt_swag_remove(cnst,&(sys->saturated_constraint_set));} while(0)
-#define make_constraint_active(sys,cnst) xbt_swag_insert(cnst,&(sys->active_constraint_set))
-#define make_constraint_inactive(sys,cnst) \
-  do { xbt_swag_remove(cnst, &sys->active_constraint_set);              \
-    xbt_swag_remove(cnst, &sys->modified_constraint_set); } while (0)
-
-void lmm_print(lmm_system_t sys);
-
-extern double (*func_f_def) (lmm_variable_t, double);
-extern double (*func_fp_def) (lmm_variable_t, double);
-extern double (*func_fpi_def) (lmm_variable_t, double);
-
-#endif                          /* _SURF_MAXMIN_PRIVATE_H */
diff --git a/src/surf/network_gtnets.c b/src/surf/network_gtnets.c
deleted file mode 100644 (file)
index 8dec8b5..0000000
+++ /dev/null
@@ -1,469 +0,0 @@
-/* Copyright (c) 2007-2013. The SimGrid Team.
- * All rights reserved.                                                     */
-
-/* This program is free software; you can redistribute it and/or modify it
- * under the terms of the license (GNU LGPL) which comes with this package. */
-
-#include "network_gtnets_private.h"
-#include "gtnets/gtnets_interface.h"
-#include "xbt/str.h"
-#include "surf/surfxml_parse_values.h"
-
-static double time_to_next_flow_completion = -1;
-
-XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_network_gtnets, surf,
-                                "Logging specific to the SURF network GTNetS module");
-
-extern routing_platf_t routing_platf;
-
-double sg_gtnets_jitter = 0.0;
-int sg_gtnets_jitter_seed = 10;
-
-static void link_new(const char *name, double bw, double lat, xbt_dict_t props)
-{
-  static int link_count = -1;
-  network_link_GTNETS_t gtnets_link;
-
-  if (xbt_lib_get_or_null(link_lib, name, SURF_LINK_LEVEL)) {
-    return;
-  }
-
-  XBT_DEBUG("Scanning link name %s", name);
-
-
-  gtnets_link = xbt_new0(s_network_link_GTNETS_t, 1);
-  gtnets_link->generic_resource.name = xbt_strdup(name);
-  gtnets_link->generic_resource.properties = props;
-  gtnets_link->bw_current = bw;
-  gtnets_link->lat_current = lat;
-
-  link_count++;
-
-  XBT_DEBUG("Adding new link, linkid %d, name %s, latency %g, bandwidth %g",
-           link_count, name, lat, bw);
-
-  if (gtnets_add_link(link_count, bw, lat)) {
-    xbt_die("Cannot create GTNetS link");
-  }
-  gtnets_link->id = link_count;
-
-  xbt_lib_set(link_lib, name, SURF_LINK_LEVEL, gtnets_link);
-}
-
-static void route_new(int src_id, int dst_id, xbt_dynar_t links,
-                      int nb_link)
-{
-  network_link_GTNETS_t link;
-  unsigned int cursor;
-  int i = 0;
-  int *gtnets_links;
-
-  XBT_IN("(src_id=%d, dst_id=%d, links=%p, nb_link=%d)",
-          src_id, dst_id, links, nb_link);
-
-  /* Build the list of gtnets link IDs */
-  gtnets_links = xbt_new0(int, nb_link);
-  i = 0;
-  xbt_dynar_foreach(links, cursor, link) {
-    gtnets_links[i++] = link->id;
-  }
-
-  if (gtnets_add_route(src_id, dst_id, gtnets_links, nb_link)) {
-    xbt_die("Cannot create GTNetS route");
-  }
-  XBT_OUT();
-}
-
-static void route_onehop_new(int src_id, int dst_id,
-                             network_link_GTNETS_t link)
-{
-  if (gtnets_add_onehop_route(src_id, dst_id, link->id)) {
-    xbt_die("Cannot create GTNetS route");
-  }
-}
-
-/* Parse the XML for a network link */
-static void parse_link_init(sg_platf_link_cbarg_t link)
-{
-  XBT_DEBUG("link_gtnets");
-
-  if (link->bandwidth_trace)
-    XBT_INFO
-        ("The GTNetS network model doesn't support bandwidth state traces");
-  if (link->latency_trace)
-    XBT_INFO("The GTNetS network model doesn't support latency state traces");
-  if (link->state_trace)
-    XBT_INFO("The GTNetS network model doesn't support link state traces");
-
-  if (link->policy == SURF_LINK_FULLDUPLEX)
-  {
-    link_new(bprintf("%s_UP",link->id), link->bandwidth, link->latency, current_property_set);
-    link_new(bprintf("%s_DOWN",link->id), link->bandwidth, link->latency, current_property_set);
-
-  }
-  else  link_new(link->id, link->bandwidth, link->latency, current_property_set);
-  current_property_set = NULL;
-}
-
-/* Create the gtnets topology based on routing strategy */
-static void create_gtnets_topology(void)
-{
-   XBT_DEBUG("Starting topology generation");
-// FIXME: We should take the list of hosts/routers (in the routing module), number the elements of this list,
-//   and then you can use the id to reimplement properly the following GTNets calls
-
-   //get the onelinks from the parsed platform
-   xbt_dynar_t onelink_routes = routing_platf->get_onelink_routes();
-   if (!onelink_routes)
-     return;
-
-   //save them in trace file
-   onelink_t onelink;
-   unsigned int iter;
-   xbt_dynar_foreach(onelink_routes, iter, onelink) {
-     void *link = onelink->link_ptr;
-
-     if(onelink->src->id != onelink->dst->id){
-     XBT_DEBUG("Link (#%p), src (#%s), dst (#%s), src_id = %d, dst_id = %d",
-         link,
-         onelink->src->name,
-         onelink->dst->name,
-         onelink->src->id,
-         onelink->dst->id);
-     XBT_DEBUG("Calling one link route");
-        if(onelink->src->rc_type == SURF_NETWORK_ELEMENT_ROUTER){
-          gtnets_add_router(onelink->src->id);
-        }
-        if(onelink->dst->rc_type == SURF_NETWORK_ELEMENT_ROUTER){
-         gtnets_add_router(onelink->dst->id);
-        }
-        route_onehop_new(onelink->src->id, onelink->dst->id, (network_link_GTNETS_t)(link));
-     }
-   }
-
-   if (XBT_LOG_ISENABLED(surf_network_gtnets, xbt_log_priority_debug)) {
-        gtnets_print_topology();
-   }
-}
-
-/* Main XML parsing */
-static void define_callbacks(void)
-{
-  /* Figuring out the network links */
-  sg_platf_link_add_cb (&parse_link_init);
-  sg_platf_postparse_add_cb(&create_gtnets_topology);
-}
-
-static int resource_used(void *resource_id)
-{
-  xbt_die("The resource_used feature is not implemented in GTNets model");
-}
-
-static int action_unref(surf_action_t action)
-{
-  action->refcount--;
-  if (!action->refcount) {
-    xbt_swag_remove(action, action->state_set);
-#ifdef HAVE_TRACING
-    xbt_free(action->category);
-#endif
-    surf_action_free(&action);
-    return 1;
-  }
-  return 0;
-}
-
-static void action_cancel(surf_action_t action)
-{
-  xbt_die("Cannot cancel GTNetS flow");
-  return;
-}
-
-static void action_recycle(surf_action_t action)
-{
-  xbt_die("Cannot recycle GTNetS flow");
-  return;
-}
-
-static double action_get_remains(surf_action_t action)
-{
-  return action->remains;
-}
-
-static void action_state_set(surf_action_t action,
-                             e_surf_action_state_t state)
-{
-  surf_action_state_set(action, state);
-}
-
-static double share_resources(surf_model_t network_model, double now)
-{
-  xbt_swag_t running_actions =
-      surf_network_model->states.running_action_set;
-
-  //get the first relevant value from the running_actions list
-  if (!xbt_swag_size(running_actions))
-    return -1.0;
-
-  xbt_assert(time_to_next_flow_completion,
-              "Time to next flow completion not initialized!\n");
-
-  XBT_DEBUG("Calling gtnets_get_time_to_next_flow_completion");
-  time_to_next_flow_completion = gtnets_get_time_to_next_flow_completion();
-  XBT_DEBUG("gtnets_get_time_to_next_flow_completion received %g",
-         time_to_next_flow_completion);
-
-  return time_to_next_flow_completion;
-}
-
-static void update_actions_state(surf_model_t network_model, double now, double delta)
-{
-  surf_action_network_GTNETS_t action = NULL;
-  xbt_swag_t running_actions =
-      network_model->states.running_action_set;
-
-  /* If there are no running flows, just return */
-  if (time_to_next_flow_completion < 0.0) {
-    return;
-  }
-
-  /* if delta == time_to_next_flow_completion, too. */
-  if (time_to_next_flow_completion <= delta) {  /* run until the first flow completes */
-    void **metadata;
-    int i, num_flows;
-
-    num_flows = 0;
-
-    if (gtnets_run_until_next_flow_completion(&metadata, &num_flows)) {
-      xbt_die("Cannot run GTNetS simulation until next flow completion");
-    }
-    if (num_flows < 1) {
-      xbt_die("GTNetS simulation couldn't find a flow that would complete");
-    }
-
-    xbt_swag_foreach(action, running_actions) {
-      XBT_DEBUG("Action (%p) remains old value: %f", action,
-             action->generic_action.remains);
-      double sent = gtnets_get_flow_rx(action);
-
-      XBT_DEBUG("Sent value returned by GTNetS : %f", sent);
-
-#ifdef HAVE_TRACING
-      action->last_remains = action->generic_action.remains;
-#endif
-
-     //need to trust this remain value
-     if (sent == 0) {
-       action->generic_action.remains = 0;
-      } else {
-        action->generic_action.remains =
-            action->generic_action.cost - sent;
-      }
-
-     // verify that this action is a finishing action.
-     int found=0;
-     for (i = 0; i < num_flows; i++) {
-       if(action == (surf_action_network_GTNETS_t) (metadata[i])){
-           found = 1;
-           break;
-       }
-     }
-
-     // indeed this action have not yet started
-     // because of that we need to fix the remaining to the
-     // original total cost
-     if(found != 1 && action->generic_action.remains == 0 ){
-         action->generic_action.remains = action->generic_action.cost;
-     }
-
-     XBT_DEBUG("Action (%p) remains new value: %f", action,
-             action->generic_action.remains);
-
-#ifdef HAVE_TRACING
-      if (TRACE_is_enabled()) {
-        double last_amount_sent = (action->generic_action.cost - action->last_remains);
-        double amount_sent = (action->generic_action.cost - action->generic_action.remains);
-
-        // tracing resource utilization
-        xbt_dynar_t route = NULL;
-
-        routing_get_route_and_latency (action->src, action->dst, &route, NULL);
-
-        unsigned int i;
-        for (i = 0; i < xbt_dynar_length (route); i++){
-          network_link_GTNETS_t *link = ((network_link_GTNETS_t*)xbt_dynar_get_ptr (route, i));
-          TRACE_surf_link_set_utilization ((*link)->generic_resource.name,
-                                            ((surf_action_t) action)->category,
-                                            (amount_sent - last_amount_sent)/(delta),
-                                            now-delta,
-                                            delta);
-      }
-      }
-#endif
-
-
-    }
-
-    for (i = 0; i < num_flows; i++) {
-      action = (surf_action_network_GTNETS_t) (metadata[i]);
-
-
-
-      action->generic_action.finish = now + time_to_next_flow_completion;
-      action_state_set((surf_action_t) action, SURF_ACTION_DONE);
-      XBT_DEBUG("----> Action (%p) just terminated", action);
-
-    }
-
-
-  } else {                      /* run for a given number of seconds */
-    if (gtnets_run(delta)) {
-      xbt_die("Cannot run GTNetS simulation");
-    }
-  }
-
-  return;
-}
-
-static void update_resource_state(void *id,
-                                  tmgr_trace_event_t event_type,
-                                  double value, double date)
-{
-  xbt_die("Cannot update model state for GTNetS simulation");
-}
-
-/* Max durations are not supported */
-static surf_action_t communicate(sg_routing_edge_t src_card,
-                                 sg_routing_edge_t dst_card,
-                                 double size, double rate)
-{
-  surf_action_network_GTNETS_t action = NULL;
-
-  int src = src_card->id;
-  int dst = dst_card->id;
-  char *src_name = src_card->name;
-  char *dst_name = dst_card->name;
-
-  xbt_assert((src >= 0
-               && dst >= 0), "Either src or dst have invalid id (id<0)");
-
-  XBT_DEBUG("Setting flow src %d \"%s\", dst %d \"%s\"", src, src_name, dst,
-         dst_name);
-
-  xbt_dynar_t route = NULL;
-
-  routing_get_route_and_latency(src_card, dst_card, &route, NULL);
-
-  route_new(src, dst, route, xbt_dynar_length(route));
-
-  action =
-      surf_action_new(sizeof(s_surf_action_network_GTNETS_t), size,
-                      surf_network_model, 0);
-
-#ifdef HAVE_TRACING
-  action->last_remains = 0;
-#endif
-
-  /* Add a flow to the GTNets Simulation, associated to this action */
-  if (gtnets_create_flow(src, dst, size, (void *) action) < 0) {
-    xbt_die("Not route between host %s and host %s", src_name, dst_name);
-  }
-#ifdef HAVE_TRACING
-  TRACE_surf_gtnets_communicate(action, src_card, dst_card);
-#endif
-
-  return (surf_action_t) action;
-}
-
-/* Suspend a flow() */
-static void action_suspend(surf_action_t action)
-{
-  THROW_UNIMPLEMENTED;
-}
-
-/* Resume a flow() */
-static void action_resume(surf_action_t action)
-{
-  THROW_UNIMPLEMENTED;
-}
-
-/* Test whether a flow is suspended */
-static int action_is_suspended(surf_action_t action)
-{
-  return 0;
-}
-
-#ifdef HAVE_TRACING
-static void gtnets_action_set_category(surf_action_t action, const char *category)
-{
-  action->category = xbt_strdup (category);
-}
-#endif
-
-static void finalize(surf_model_t network_model)
-{
-  gtnets_finalize();
-}
-
-static void surf_network_model_init_internal(void)
-{
-  surf_network_model = surf_model_init();
-
-  surf_network_model->name = "network GTNetS";
-  surf_network_model->type = SURF_MODEL_TYPE_NETWORK;
-  surf_network_model->action_unref = action_unref;
-  surf_network_model->action_cancel = action_cancel;
-  surf_network_model->action_recycle = action_recycle;
-  surf_network_model->action_state_set = action_state_set;
-  surf_network_model->get_remains = action_get_remains;
-
-  surf_network_model->model_private->resource_used = resource_used;
-  surf_network_model->model_private->share_resources = share_resources;
-  surf_network_model->model_private->update_actions_state =
-      update_actions_state;
-  surf_network_model->model_private->update_resource_state =
-      update_resource_state;
-  surf_network_model->model_private->finalize = finalize;
-
-  surf_network_model->suspend = action_suspend;
-  surf_network_model->resume = action_resume;
-  surf_network_model->is_suspended = action_is_suspended;
-#ifdef HAVE_TRACING
-  surf_network_model->set_category = gtnets_action_set_category;
-#endif
-
-  surf_network_model->extension.network.communicate = communicate;
-
-  /* Added the initialization for GTNetS interface */
-  if (gtnets_initialize(sg_tcp_gamma)) {
-    xbt_die("Impossible to initialize GTNetS interface");
-  }
-
-  routing_model_create(NULL);
-}
-
-#ifdef HAVE_LATENCY_BOUND_TRACKING
-static int get_latency_limited(surf_action_t action)
-{
-  return 0;
-}
-#endif
-
-void surf_network_model_init_GTNETS(void)
-{
-  if (surf_network_model)
-    return;
-
-  surf_network_model_init_internal();
-  define_callbacks();
-  xbt_dynar_push(model_list, &surf_network_model);
-
-#ifdef HAVE_LATENCY_BOUND_TRACKING
-  surf_network_model->get_latency_limited = get_latency_limited;
-#endif
-
-  if (sg_gtnets_jitter > 0.0) {
-    gtnets_set_jitter(sg_gtnets_jitter);
-    gtnets_set_jitter_seed(sg_gtnets_jitter_seed);
-  }
-}
diff --git a/src/surf/network_gtnets_private.h b/src/surf/network_gtnets_private.h
deleted file mode 100644 (file)
index 293ac16..0000000
+++ /dev/null
@@ -1,42 +0,0 @@
-/* Copyright (c) 2007-2012. The SimGrid Team.
- * All rights reserved.                                                     */
-
-/* This program is free software; you can redistribute it and/or modify it
- * under the terms of the license (GNU LGPL) which comes with this package. */
-
-#ifndef _SURF_NETWORK_GTNETS_PRIVATE_H
-#define _SURF_NETWORK_GTNETS_PRIVATE_H
-
-#include "surf_private.h"
-#include "xbt/dict.h"
-
-typedef struct network_link_GTNETS {
-  s_surf_resource_t generic_resource;   /* Must remain first to allow casting */
-  /* Using this object with the public part of
-     model does not make sense */
-  double bw_current;
-  double lat_current;
-  int id;
-} s_network_link_GTNETS_t, *network_link_GTNETS_t;
-
-typedef struct surf_action_network_GTNETS {
-  s_surf_action_t generic_action;
-  double latency;
-  double lat_current;
-#ifdef HAVE_TRACING
-  int last_remains;
-#endif
-  lmm_variable_t variable;
-  double rate;
-  int suspended;
-#ifdef HAVE_TRACING
-  sg_routing_edge_t src;
-  sg_routing_edge_t dst;
-#endif //HAVE_TRACING
-} s_surf_action_network_GTNETS_t, *surf_action_network_GTNETS_t;
-
-xbt_dict_t network_card_ids;
-
-
-
-#endif                          /* _SURF_NETWORK_PRIVATE_H */
index 49103ce..bb53714 100644 (file)
@@ -35,7 +35,8 @@ double NetworkModel::bandwidthConstraint(double rate, double /*bound*/, double /
 }
 
 NetworkLink::NetworkLink(NetworkModelPtr model, const char *name, xbt_dict_t props)
-: p_latEvent(NULL)
+: Resource(model, name, props)
+, p_latEvent(NULL)
 {}
 
 NetworkLink::NetworkLink(NetworkModelPtr model, const char *name, xbt_dict_t props,
index fd646bb..b9425d2 100644 (file)
@@ -1,9 +1,9 @@
-/*
- * network_interface.hpp
- *
- *  Created on: Nov 29, 2013
- *      Author: bedaride
- */
+/* Copyright (c) 2004-2013. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
 #include "surf_interface.hpp"
 #include "surf_routing.hpp"
 
@@ -31,14 +31,31 @@ void net_define_callbacks(void);
 /*********
  * Model *
  *********/
+/** @ingroup SURF_network_interface
+ * @brief SURF network model interface class
+ * @details A model is an object which handle the interactions between its Resources and its Actions
+ */
 class NetworkModel : public Model {
 public:
+  /**
+   * @brief NetworkModel constructor
+   */
   NetworkModel() : Model("network") {
   };
+
+  /**
+   * @brief NetworkModel constructor
+   * 
+   * @param name The name of the NetworkModel
+   */
   NetworkModel(const char *name) : Model(name) {
        f_networkSolve = lmm_solve;
        m_haveGap = false;
   };
+
+  /**
+   * @brief The destructor of the NetworkModel
+   */
   ~NetworkModel() {
        if (p_maxminSystem)
          lmm_system_free(p_maxminSystem);
@@ -48,6 +65,20 @@ public:
          delete p_modifiedSet;
   }
 
+  /**
+   * @brief Create a NetworkLink
+   * 
+   * @param name The name of the NetworkLink
+   * @param bw_initial The initial bandwidth of the NetworkLink in bytes per second
+   * @param bw_trace The trace associated to the NetworkLink bandwidth [TODO]
+   * @param lat_initial The initial latency of the NetworkLink in seconds
+   * @param lat_trace The trace associated to the NetworkLink latency [TODO]
+   * @param state_initial The initial NetworkLink (state)[e_surf_resource_state_t]
+   * @param state_trace The trace associated to the NetworkLink (state)[e_surf_resource_state_t] [TODO]
+   * @param policy The sharing policy of the NetworkLink
+   * @param properties Dictionary of properties associated to this Resource
+   * @return The created NetworkLink
+   */
   virtual NetworkLinkPtr createResource(const char *name,
                                    double bw_initial,
                                    tmgr_trace_t bw_trace,
@@ -58,13 +89,67 @@ public:
                                    e_surf_link_sharing_policy_t policy,
                                    xbt_dict_t properties)=0;
 
+
   virtual void gapAppend(double /*size*/, const NetworkLinkPtr /*link*/, NetworkActionPtr /*action*/) {};
+
+  /**
+   * @brief Create a communication between two [TODO]
+   * @details [TODO]
+   * 
+   * @param src The source [TODO]
+   * @param dst The destination [TODO]
+   * @param size The size of the communication in bytes
+   * @param rate The 
+   * @return The action representing the communication
+   */
   virtual ActionPtr communicate(RoutingEdgePtr src, RoutingEdgePtr dst,
                                           double size, double rate)=0;
+
+  /**
+   * @brief Get the route between two RoutingEdge
+   * @details [TODO]
+   * 
+   * @param src [TODO]
+   * @param dst [TODO]
+   * 
+   * @return A xbt_dynar_t of [TODO]
+   */
   virtual xbt_dynar_t getRoute(RoutingEdgePtr src, RoutingEdgePtr dst); //FIXME: kill field? That is done by the routing nowadays
+
+  /**
+   * @brief Function pointer to the function to use to solve the lmm_system_t
+   * 
+   * @param system The lmm_system_t to solve
+   */
   void (*f_networkSolve)(lmm_system_t);
+
+  /**
+   * @brief [brief description]
+   * @details [long description]
+   * 
+   * @param size [description]
+   * @return [description]
+   */
   virtual double latencyFactor(double size);
+
+  /**
+   * @brief [brief description]
+   * @details [long description]
+   * 
+   * @param size [description]
+   * @return [description]
+   */
   virtual double bandwidthFactor(double size);
+
+  /**
+   * @brief [brief description]
+   * @details [long description]
+   * 
+   * @param rate [description]
+   * @param bound [description]
+   * @param size [description]
+   * @return [description]
+   */
   virtual double bandwidthConstraint(double rate, double bound, double size);
   bool m_haveGap;
 };
@@ -72,17 +157,63 @@ public:
 /************
  * Resource *
  ************/
-
+ /** @ingroup SURF_network_interface
+  * @brief SURF network link interface class
+  * @details A NetworkLink represent the link between two [Workstations](\ref Workstation)
+  */
 class NetworkLink : public Resource {
 public:
+  /**
+   * @brief NetworkLink constructor
+   * 
+   * @param model The CpuModel associated to this NetworkLink
+   * @param name The name of the NetworkLink
+   * @param props Dictionary of properties associated to this NetworkLink
+   */
   NetworkLink(NetworkModelPtr model, const char *name, xbt_dict_t props);
+
+  /**
+   * @brief NetworkLink constructor
+   * 
+   * @param model The CpuModel associated to this NetworkLink
+   * @param name The name of the NetworkLink
+   * @param props Dictionary of properties associated to this NetworkLink
+   * @param constraint The lmm constraint associated to this Cpu if it is part of a LMM component
+   * @param history [TODO]
+   * @param state_trace [TODO]
+   */
   NetworkLink(NetworkModelPtr model, const char *name, xbt_dict_t props,
                      lmm_constraint_t constraint,
                  tmgr_history_t history,
                  tmgr_trace_t state_trace);
+
+  /**
+   * @brief Get the bandwidth in bytes per second of current NetworkLink
+   * 
+   * @return The bandwith in bytes per second of the current NetworkLink
+   */
   virtual double getBandwidth();
+
+  /**
+   * @brief Get the latency in seconds of current NetworkLink
+   * 
+   * @return The latency in seconds of the current NetworkLink
+   */
   virtual double getLatency();
+
+  /**
+   * @brief Check if the NetworkLink is shared
+   * @details [long description]
+   * 
+   * @return true if the current NetwokrLink is shared, false otherwise
+   */
   virtual bool isShared();
+
+  /**
+   * @brief Check if the NetworkLink is used
+   * 
+   * @return true if the current NetwokrLink is used, false otherwise
+   */
   bool isUsed();
 
   /* Using this object with the public part of
@@ -98,12 +229,33 @@ public:
 /**********
  * Action *
  **********/
+/** @ingroup SURF_network_interface
+ * @brief SURF network action interface class
+ * @details A NetworkAction represent a communication bettween two [Workstations](\ref Workstation)
+ */
 class NetworkAction : public Action {
 public:
+  /**
+   * @brief NetworkAction constructor
+   * 
+   * @param model The NetworkModel associated to this NetworkAction
+   * @param cost The cost of this  NetworkAction in [TODO]
+   * @param failed [description]
+   */
   NetworkAction(ModelPtr model, double cost, bool failed)
   : Action(model, cost, failed) {}
+
+  /**
+   * @brief NetworkAction constructor
+   * 
+   * @param model The NetworkModel associated to this NetworkAction
+   * @param cost The cost of this  NetworkAction in [TODO]
+   * @param failed [description]
+   * @param var The lmm variable associated to this Action if it is part of a LMM component
+   */
   NetworkAction(ModelPtr model, double cost, bool failed, lmm_variable_t var)
   : Action(model, cost, failed, var) {};
+
   double m_latency;
   double m_latCurrent;
   double m_weight;
diff --git a/src/surf/plugins/energy.cpp b/src/surf/plugins/energy.cpp
new file mode 100644 (file)
index 0000000..8719d9c
--- /dev/null
@@ -0,0 +1,172 @@
+/* Copyright (c) 2010, 2012-2013. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+  * under the terms of the license (GNU LGPL) which comes with this package. */
+
+#include "energy.hpp"
+#include "../cpu_cas01.hpp"
+
+/** @addtogroup SURF_plugin_energy
+ *    
+ *  
+ *  BlaBla energy
+ */
+
+XBT_LOG_EXTERNAL_CATEGORY(surf_kernel);
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(surf_energy, surf,
+                                "Logging specific to the SURF energy plugin");
+
+std::map<CpuPtr, CpuEnergyPtr> *surf_energy=NULL;
+
+static void createCpuCallback(CpuPtr cpu){
+  (*surf_energy)[cpu] = new CpuEnergy(cpu);
+}
+
+static void deleteCpuCallback(CpuPtr cpu){
+  std::map<CpuPtr, CpuEnergyPtr>::iterator cpuIt = surf_energy->find(cpu);
+  xbt_assert(cpuIt != surf_energy->end(), "The cpu is not in surf_energy.");
+  XBT_INFO("Total energy (Joules) of host %s: %f", cpu->getName(), cpuIt->second->getConsumedEnergy());
+  delete cpuIt->second;
+  surf_energy->erase(cpuIt);
+}
+
+static void updateActionEnergyCallback(CpuActionPtr action){
+  CpuPtr cpu  = getActionCpu(action);
+  CpuEnergyPtr cpu_energy = (*surf_energy)[cpu];
+
+  if(cpu_energy->last_updated < surf_get_clock()) {
+       double cpu_load = lmm_constraint_get_usage(cpu->getConstraint()) / cpu->m_powerPeak;
+    double start_time = cpu_energy->last_updated;
+    double finish_time = surf_get_clock();
+
+    /*XBT_DEBUG("[cpu_update_energy] action time interval=(%f-%f), current power peak=%f, current pstate=%d",
+                 start_time, finish_time, cpu->m_powerPeak, cpu->m_pstate);*/
+    XBT_DEBUG("[cpu_update_energy] action time interval=(%f-%f), current power peak=%f",
+                 start_time, finish_time, cpu->m_powerPeak);
+    double current_energy = cpu_energy->total_energy;
+    double action_energy = cpu_energy->getCurrentWattsValue(cpu_load)*(finish_time-start_time);
+
+    cpu_energy->total_energy = current_energy + action_energy;
+    cpu_energy->last_updated = finish_time;
+
+    XBT_DEBUG("[cpu_update_energy] old_energy_value=%f, action_energy_value=%f", current_energy, action_energy);
+  }
+}
+
+/** \ingroup SURF_plugin_energy
+ * \brief Enable energy plugin
+ * \details Enable energy plugin to get joules consumption of each cpu.
+ */
+void sg_energy_plugin_init() {
+  if (surf_energy == NULL) {
+    surf_energy = new std::map<CpuPtr, CpuEnergyPtr>();
+    surf_callback_connect(createCpuCallbacks, createCpuCallback);
+    surf_callback_connect(deleteCpuCallbacks, deleteCpuCallback);
+    surf_callback_connect(updateCpuActionCallbacks, updateActionEnergyCallback);
+  }
+}
+
+/**
+ *
+ */
+CpuEnergy::CpuEnergy(CpuPtr ptr)
+ : cpu(ptr)
+{
+  total_energy = 0;
+  power_range_watts_list = getWattsRangeList();
+  last_updated = surf_get_clock();
+}
+
+CpuEnergy::~CpuEnergy(){
+  unsigned int iter;
+  xbt_dynar_t power_tuple = NULL;
+  xbt_dynar_foreach(power_range_watts_list, iter, power_tuple)
+    xbt_dynar_free(&power_tuple);
+  xbt_dynar_free(&power_range_watts_list);
+}
+
+
+/**
+ * Computes the power consumed by the host according to the current pstate and processor load
+ *
+ */
+double CpuEnergy::getCurrentWattsValue(double cpu_load)
+{
+       xbt_dynar_t power_range_list = power_range_watts_list;
+
+       if (power_range_list == NULL)
+       {
+               XBT_DEBUG("No power range properties specified for host %s", cpu->getName());
+               return 0;
+       }
+       /*xbt_assert(xbt_dynar_length(power_range_list) == xbt_dynar_length(cpu->p_powerPeakList),
+                                               "The number of power ranges in the properties does not match the number of pstates for host %s",
+                                               cpu->getName());*/
+
+    /* retrieve the power values associated with the current pstate */
+    xbt_dynar_t current_power_values = xbt_dynar_get_as(power_range_list, static_cast<CpuCas01Ptr>(cpu)->m_pstate, xbt_dynar_t);
+
+    /* min_power corresponds to the idle power (cpu load = 0) */
+    /* max_power is the power consumed at 100% cpu load       */
+    double min_power = xbt_dynar_get_as(current_power_values, 0, double);
+    double max_power = xbt_dynar_get_as(current_power_values, 1, double);
+    double power_slope = max_power - min_power;
+
+    double current_power = min_power + cpu_load * power_slope;
+
+       XBT_DEBUG("[get_current_watts] min_power=%f, max_power=%f, slope=%f", min_power, max_power, power_slope);
+    XBT_DEBUG("[get_current_watts] Current power (watts) = %f, load = %f", current_power, cpu_load);
+
+       return current_power;
+}
+
+double CpuEnergy::getConsumedEnergy()
+{
+  return total_energy;
+}
+
+xbt_dynar_t CpuEnergy::getWattsRangeList()
+{
+       xbt_dynar_t power_range_list;
+       xbt_dynar_t power_tuple;
+       int i = 0, pstate_nb=0;
+       xbt_dynar_t current_power_values;
+       double min_power, max_power;
+
+       if (cpu->getProperties() == NULL)
+               return NULL;
+
+       char* all_power_values_str = (char*)xbt_dict_get_or_null(cpu->getProperties(), "power_per_state");
+
+       if (all_power_values_str == NULL)
+               return NULL;
+
+
+       power_range_list = xbt_dynar_new(sizeof(xbt_dynar_t), NULL);
+       xbt_dynar_t all_power_values = xbt_str_split(all_power_values_str, ",");
+
+       pstate_nb = xbt_dynar_length(all_power_values);
+       for (i=0; i< pstate_nb; i++)
+       {
+               /* retrieve the power values associated with the current pstate */
+               current_power_values = xbt_str_split(xbt_dynar_get_as(all_power_values, i, char*), ":");
+               xbt_assert(xbt_dynar_length(current_power_values) > 1,
+                               "Power properties incorrectly defined - could not retrieve min and max power values for host %s",
+                               cpu->getName());
+
+               /* min_power corresponds to the idle power (cpu load = 0) */
+               /* max_power is the power consumed at 100% cpu load       */
+               min_power = atof(xbt_dynar_get_as(current_power_values, 0, char*));
+               max_power = atof(xbt_dynar_get_as(current_power_values, 1, char*));
+
+               power_tuple = xbt_dynar_new(sizeof(double), NULL);
+               xbt_dynar_push_as(power_tuple, double, min_power);
+               xbt_dynar_push_as(power_tuple, double, max_power);
+
+               xbt_dynar_push_as(power_range_list, xbt_dynar_t, power_tuple);
+               xbt_dynar_free(&current_power_values);
+       }
+       xbt_dynar_free(&all_power_values);
+       return power_range_list;
+}
diff --git a/src/surf/plugins/energy.hpp b/src/surf/plugins/energy.hpp
new file mode 100644 (file)
index 0000000..decb552
--- /dev/null
@@ -0,0 +1,33 @@
+/*
+ * callback.hpp
+ *
+ *  Created on: Jan 10, 2014
+ *      Author: bedaride
+ */
+#include "../cpu_interface.hpp"
+#include <map>
+
+#ifndef CALLBACK_HPP_
+#define CALLBACK_HPP_
+
+class CpuEnergy;
+typedef CpuEnergy *CpuEnergyPtr;
+
+extern std::map<CpuPtr, CpuEnergyPtr> *surf_energy;
+
+class CpuEnergy {
+public:
+  CpuEnergy(CpuPtr ptr);
+  ~CpuEnergy();
+
+  double getCurrentWattsValue(double cpu_load);
+  double getConsumedEnergy();
+  xbt_dynar_t getWattsRangeList();
+
+  xbt_dynar_t power_range_watts_list;          /*< List of (min_power,max_power) pairs corresponding to each cpu pstate */
+  double total_energy;                                 /*< Total energy consumed by the host */
+  double last_updated;                                 /*< Timestamp of the last energy update event*/
+  CpuPtr cpu;
+};
+
+#endif /* CALLBACK_HPP_ */
index d11f501..c606e11 100644 (file)
@@ -1,3 +1,9 @@
+/* Copyright (c) 2004-2013. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
 #include "surf_interface.hpp"
 
 #ifndef STORAGE_INTERFACE_HPP_
@@ -27,10 +33,32 @@ typedef StorageAction *StorageActionPtr;
 /*********
  * Model *
  *********/
+/** @ingroup SURF_storage_interface
+ * @brief SURF storage model interface class
+ * @details A model is an object which handle the interactions between its Resources and its Actions
+ */
 class StorageModel : public Model {
 public:
+  /**
+   * @brief The storage model constructor
+   */
   StorageModel();
+
+  /**
+   * @brief The Storange model destructor
+   */
   ~StorageModel();
+
+  /**
+   * @brief Create a Storage
+   * 
+   * @param id [description]
+   * @param type_id [description]
+   * @param content_name [description]
+   * @param content_type [description]
+   * @param properties [description]
+   * @return The created Storage
+   */
   virtual StoragePtr createResource(const char* id, const char* type_id,
                   const char* content_name, const char* content_type, xbt_dict_t properties)=0;
 
@@ -40,17 +68,69 @@ public:
 /************
  * Resource *
  ************/
-
+/** @ingroup SURF_storage_interface
+ * @brief SURF storage interface class
+ * @details A Storage represent a storage unit (e.g.: hard drive, usb key)
+ */
 class Storage : public Resource {
 public:
+  /**
+   * @brief Storage constructor
+   * 
+   * @param model StorageModel associated to this Storage
+   * @param name The name of the Storage
+   * @param props Dictionary of properties associated to this Storage
+   * @param constraint The lmm constraint associated to this Storage if it is part of a LMM component
+   * @param model [description]
+   * @param name [description]
+   * @param props [description]
+   * @param type_id [description]
+   * @param content_name [description]
+   * @param content_type [description]
+   * @param size [description]
+   */
   Storage(ModelPtr model, const char *name, xbt_dict_t props,
                  const char* type_id, char *content_name, char *content_type, sg_size_t size);
+
+  /**
+   * @brief Storage constructor
+   * 
+   * @param model StorageModel associated to this Storage
+   * @param name The name of the Storage
+   * @param props Dictionary of properties associated to this Storage
+   * @param constraint The lmm constraint associated to this Storage if it is part of a LMM component
+   * @param maxminSystem [description]
+   * @param bread [description]
+   * @param bwrite [description]
+   * @param bconnection [description]
+   * @param type_id [description]
+   * @param content_name [description]
+   * @param content_type [description]
+   * @param size [description]
+   */
   Storage(ModelPtr model, const char *name, xbt_dict_t props,
                  lmm_system_t maxminSystem, double bread, double bwrite, double bconnection,
                  const char* type_id, char *content_name, char *content_type, sg_size_t size);
+
+  /**
+   * @brief Storage destructor
+   */
   ~Storage();
 
+  /**
+   * @brief Check if the Storage is used
+   * 
+   * @return true if the current Storage is used, false otherwise
+   */
   bool isUsed();
+
+  /**
+   * @brief Update the state of the current Storage
+   * 
+   * @param event_type [description]
+   * @param value [description]
+   * @param date [description]
+   */
   void updateState(tmgr_trace_event_t event_type, double value, double date);
 
   xbt_dict_t p_content;
@@ -59,15 +139,71 @@ public:
   sg_size_t m_usedSize;
   char * p_typeId;
 
+  /**
+   * @brief Open a file
+   * 
+   * @param mount The mount point
+   * @param path The path to the file
+   * 
+   * @return The StorageAction corresponding to the opening
+   */
   virtual StorageActionPtr open(const char* mount, const char* path)=0;
+
+  /**
+   * @brief Close a file
+   * 
+   * @param fd The file descriptor to close
+   * @return The StorageAction corresponding to the closing
+   */
   virtual StorageActionPtr close(surf_file_t fd)=0;
-  //virtual StorageActionPtr unlink(surf_file_t fd)=0;
+
+  /**
+   * @brief List directory contents of a path
+   * @details [long description]
+   * 
+   * @param path The path to the directory
+   * @return The StorageAction corresponding to the ls action
+   */
   virtual StorageActionPtr ls(const char *path)=0;
+
+  /**
+   * @brief Read a file
+   * 
+   * @param fd The file descriptor to read
+   * @param size The size in bytes to read
+   * @return The StorageAction corresponding to the reading
+   */
   virtual StorageActionPtr read(surf_file_t fd, sg_size_t size)=0;
+
+  /**
+   * @brief Write a file
+   * 
+   * @param fd The file descriptor to write
+   * @param size The size in bytes to write
+   * @return The StorageAction corresponding to the writing
+   */
   virtual StorageActionPtr write(surf_file_t fd, sg_size_t size)=0;
+
+  /**
+   * @brief Rename a path
+   * 
+   * @param src The old path
+   * @param dest The new path
+   */
   virtual void rename(const char *src, const char *dest)=0;
 
+  /**
+   * @brief Get the content of the current Storage
+   * 
+   * @return A xbt_dict_t with path as keys and size in bytes as values
+   */
   virtual xbt_dict_t getContent();
+
+  /**
+   * @brief Get the size in bytes of the current Storage
+   * 
+   * @return The size in bytes of the current Storage
+   */
   virtual sg_size_t getSize();
 
   xbt_dict_t parseContent(char *filename);
@@ -82,18 +218,52 @@ public:
  * Action *
  **********/
 
+/** @ingroup SURF_storage_interface
+ * @brief The possible type of action for the storage component
+ */
 typedef enum {
-  READ=0, WRITE, STAT, OPEN, CLOSE, LS
+  READ=0, /**< Read a file */
+  WRITE,  /**< Write in a file */
+  STAT,   /**< Stat a file */
+  OPEN,   /**< Open a file */
+  CLOSE,  /**< Close a file */
+  LS      /**< List directory contents */
 } e_surf_action_storage_type_t;
 
-
+/** @ingroup SURF_storage_interface
+ * @brief SURF storage action interface class
+ */
 class StorageAction : public Action {
 public:
+  /**
+   * @brief StorageAction constructor
+   */
   StorageAction() : m_type(READ) {};//FIXME:REMOVE
+
+  /**
+   * @brief StorageAction constructor
+   * 
+   * @param model The StorageModel associated to this StorageAction
+   * @param cost The cost of this  NetworkAction in [TODO]
+   * @param failed [description]
+   * @param storage The Storage associated to this StorageAction
+   * @param type [description]
+   */
   StorageAction(ModelPtr model, double cost, bool failed,
-                       StoragePtr storage, e_surf_action_storage_type_t type);
+                           StoragePtr storage, e_surf_action_storage_type_t type);
+
+    /**
+   * @brief StorageAction constructor
+   * 
+   * @param model The StorageModel associated to this StorageAction
+   * @param cost The cost of this  StorageAction in [TODO]
+   * @param failed [description]
+   * @param var The lmm variable associated to this StorageAction if it is part of a LMM component
+   * @param storage The Storage associated to this StorageAction
+   * @param type [description]
+   */
   StorageAction(ModelPtr model, double cost, bool failed, lmm_variable_t var,
-                       StoragePtr storage, e_surf_action_storage_type_t type);
+                           StoragePtr storage, e_surf_action_storage_type_t type);
 
   e_surf_action_storage_type_t m_type;
   StoragePtr p_storage;
index ecae88f..be22202 100644 (file)
@@ -4,6 +4,7 @@
 #include "network_interface.hpp"
 #include "surf_routing_cluster.hpp"
 #include "instr/instr_private.h"
+#include "plugins/energy.hpp"
 
 XBT_LOG_EXTERNAL_DEFAULT_CATEGORY(surf_kernel);
 
@@ -229,6 +230,7 @@ surf_action_t surf_model_extract_done_action_set(surf_model_t model){
   model->getDoneActionSet()->pop_front();
   return res;
 }
+
 surf_action_t surf_model_extract_failed_action_set(surf_model_t model){
   if (model->getFailedActionSet()->empty())
        return NULL;
@@ -236,6 +238,7 @@ surf_action_t surf_model_extract_failed_action_set(surf_model_t model){
   model->getFailedActionSet()->pop_front();
   return res;
 }
+
 surf_action_t surf_model_extract_ready_action_set(surf_model_t model){
   if (model->getReadyActionSet()->empty())
        return NULL;
@@ -243,6 +246,7 @@ surf_action_t surf_model_extract_ready_action_set(surf_model_t model){
   model->getReadyActionSet()->pop_front();
   return res;
 }
+
 surf_action_t surf_model_extract_running_action_set(surf_model_t model){
   if (model->getRunningActionSet()->empty())
        return NULL;
@@ -334,7 +338,9 @@ void surf_workstation_set_power_peak_at(surf_resource_t resource, int pstate_ind
 }
 
 double surf_workstation_get_consumed_energy(surf_resource_t resource){
-  return get_casted_workstation(resource)->getConsumedEnergy();
+  xbt_assert(surf_energy!=NULL, "The Energy plugin is not active.");
+  std::map<CpuPtr, CpuEnergyPtr>::iterator cpuIt = surf_energy->find(get_casted_workstation(resource)->p_cpu);
+  return cpuIt->second->getConsumedEnergy();
 }
 
 xbt_dict_t surf_workstation_get_storage_list(surf_resource_t workstation){
@@ -536,5 +542,3 @@ surf_file_t surf_storage_action_get_file(surf_action_t action){
 xbt_dict_t surf_storage_action_get_ls_dict(surf_action_t action){
   return static_cast<StorageActionPtr>(action)->p_lsDict;
 }
-
-
index 20622d1..fd6d090 100644 (file)
@@ -1,3 +1,9 @@
+/* Copyright (c) 2004-2014. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
 #include "surf_private.h"
 #include "surf_interface.hpp"
 #include "network_interface.hpp"
@@ -84,6 +90,13 @@ xbt_dynar_t surf_path = NULL;
 xbt_dynar_t host_that_restart = NULL;
 xbt_dict_t watched_hosts_lib;
 
+s_surf_model_description_t surf_plugin_description[] = {
+                 {"Energy",
+                  "Cpu energy consumption.",
+                  sg_energy_plugin_init},
+                 {NULL, NULL,  NULL}      /* this array must be NULL terminated */
+};
+
 /* Don't forget to update the option description in smx_config when you change this */
 s_surf_model_description_t surf_network_model_description[] = {
   {"LV08",
@@ -452,14 +465,14 @@ void surf_exit(void)
 
   NOW = 0;                      /* Just in case the user plans to restart the simulation afterward */
 }
+
 /*********
  * Model *
  *********/
 
 Model::Model(const char *name)
-  : p_name(name), p_maxminSystem(0),
-    m_resOnCB(0), m_resOffCB(0),
-    m_actCancelCB(0), m_actSuspendCB(0), m_actResumeCB(0)
+  : p_maxminSystem(NULL)
+  , p_name(name)
 {
   p_readyActionSet = new ActionList();
   p_runningActionSet = new ActionList();
@@ -497,13 +510,13 @@ double Model::shareResourcesLazy(double now)
   double value;
 
   XBT_DEBUG
-      ("Before share resources, the size of modified actions set is %d",
+      ("Before share resources, the size of modified actions set is %zd",
        p_modifiedSet->size());
 
   lmm_solve(p_maxminSystem);
 
   XBT_DEBUG
-      ("After share resources, The size of modified actions set is %d",
+      ("After share resources, The size of modified actions set is %zd",
        p_modifiedSet->size());
 
   while(!p_modifiedSet->empty()) {
@@ -568,12 +581,10 @@ double Model::shareResourcesFull(double /*now*/) {
   THROW_UNIMPLEMENTED;
 }
 
-
 double Model::shareResourcesMaxMin(ActionListPtr running_actions,
                           lmm_system_t sys,
                           void (*solve) (lmm_system_t))
 {
-  void *_action = NULL;
   ActionPtr action = NULL;
   double min = -1;
   double value = -1;
@@ -637,66 +648,12 @@ void Model::updateActionsState(double now, double delta)
 
 void Model::updateActionsStateLazy(double /*now*/, double /*delta*/)
 {
-
 }
 
 void Model::updateActionsStateFull(double /*now*/, double /*delta*/)
 {
-
-}
-
-
-void Model::addTurnedOnCallback(ResourceCallback rc)
-{
-  m_resOnCB = rc;
-}
-
-void Model::notifyResourceTurnedOn(ResourcePtr r)
-{
-  m_resOnCB(r);
-}
-
-void Model::addTurnedOffCallback(ResourceCallback rc)
-{
-  m_resOffCB = rc;
-}
-
-void Model::notifyResourceTurnedOff(ResourcePtr r)
-{
-  m_resOffCB(r);
-}
-
-void Model::addActionCancelCallback(ActionCallback ac)
-{
-  m_actCancelCB = ac;
-}
-
-void Model::notifyActionCancel(ActionPtr a)
-{
-  m_actCancelCB(a);
-}
-
-void Model::addActionResumeCallback(ActionCallback ac)
-{
-  m_actResumeCB = ac;
-}
-
-void Model::notifyActionResume(ActionPtr a)
-{
-  m_actResumeCB(a);
 }
 
-void Model::addActionSuspendCallback(ActionCallback ac)
-{
-  m_actSuspendCB = ac;
-}
-
-void Model::notifyActionSuspend(ActionPtr a)
-{
-  m_actSuspendCB(a);
-}
-
-
 /************
  * Resource *
  ************/
@@ -706,20 +663,28 @@ Resource::Resource()
 {}
 
 Resource::Resource(surf_model_t model, const char *name, xbt_dict_t props)
- : p_name(xbt_strdup(name)), p_properties(props), p_model(model)
- , m_running(true), m_stateCurrent(SURF_RESOURCE_ON)
+  : m_stateCurrent(SURF_RESOURCE_ON)
+  , p_name(xbt_strdup(name)), p_properties(props), p_model(model)
+  , m_running(true)
 {}
 
 Resource::Resource(surf_model_t model, const char *name, xbt_dict_t props, lmm_constraint_t constraint)
- : p_name(xbt_strdup(name)), p_properties(props), p_model(model)
- , m_running(true), m_stateCurrent(SURF_RESOURCE_ON), p_constraint(constraint)
+  : m_stateCurrent(SURF_RESOURCE_ON)
+  , p_name(xbt_strdup(name)), p_properties(props), p_model(model)
+  , m_running(true), p_constraint(constraint)
 {}
 
 Resource::Resource(surf_model_t model, const char *name, xbt_dict_t props, e_surf_resource_state_t stateInit)
- : p_name(xbt_strdup(name)), p_properties(props), p_model(model)
- , m_running(true), m_stateCurrent(stateInit)
+  : m_stateCurrent(stateInit)
+  , p_name(xbt_strdup(name)), p_properties(props), p_model(model)
+  , m_running(true)
 {}
 
+Resource::~Resource() {
+  xbt_free((void*)p_name);
+  xbt_dict_free(&p_properties);
+}
+
 e_surf_resource_state_t Resource::getState()
 {
   return m_stateCurrent;
@@ -739,7 +704,6 @@ void Resource::turnOn()
 {
   if (!m_running) {
     m_running = true;
-    getModel()->notifyResourceTurnedOn(this);
   }
 }
 
@@ -747,10 +711,25 @@ void Resource::turnOff()
 {
   if (m_running) {
     m_running = false;
-    getModel()->notifyResourceTurnedOff(this);
   }
 }
 
+ModelPtr Resource::getModel() {
+  return p_model;
+}
+
+const char *Resource::getName() {
+  return p_name;
+}
+
+xbt_dict_t Resource::getProperties() {
+  return p_properties;
+}
+
+lmm_constraint_t Resource::getConstraint() {
+  return p_constraint;
+}
+
 /**********
  * Action *
  **********/
@@ -770,18 +749,19 @@ Action::Action()
 
 Action::Action(ModelPtr model, double cost, bool failed)
  : m_priority(1.0)
- , m_failed(failed)
- , m_start(surf_get_clock()), m_finish(-1.0)
+ , m_refcount(1)
  , m_remains(cost)
  , m_maxDuration(NO_MAX_DURATION)
+ , m_finish(-1.0)
+ , m_failed(failed)
+ , m_start(surf_get_clock())
  , m_cost(cost)
- , p_data(NULL)
  , p_model(model)
- , m_refcount(1)
+ , p_data(NULL)
+ , p_variable(NULL)
  , m_lastValue(0)
  , m_lastUpdate(0)
  , m_suspended(false)
- , p_variable(NULL)
 {
   #ifdef HAVE_TRACING
     p_category = NULL;
@@ -798,18 +778,19 @@ Action::Action(ModelPtr model, double cost, bool failed)
 
 Action::Action(ModelPtr model, double cost, bool failed, lmm_variable_t var)
  : m_priority(1.0)
- , m_failed(failed)
- , m_start(surf_get_clock()), m_finish(-1.0)
+ , m_refcount(1)
  , m_remains(cost)
  , m_maxDuration(NO_MAX_DURATION)
+ , m_finish(-1.0)
+ , m_failed(failed)
+ , m_start(surf_get_clock())
  , m_cost(cost)
- , p_data(NULL)
  , p_model(model)
- , m_refcount(1)
+ , p_data(NULL)
+ , p_variable(var)
  , m_lastValue(0)
  , m_lastUpdate(0)
  , m_suspended(false)
- , p_variable(var)
 {
   #ifdef HAVE_TRACING
     p_category = NULL;
index 741e155..06ae981 100644 (file)
@@ -1,4 +1,8 @@
-//using namespace generic;
+/* Copyright (c) 2004-2014. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
 
 #ifndef SURF_MODEL_H_
 #define SURF_MODEL_H_
 #include "simgrid/platf_interface.h"
 #include "surf/surf.h"
 #include "surf/surf_private.h"
+#include "internal_config.h"
+
+#ifdef LIBSIGC
+#include <sigc++/sigc++.h>
+#define surf_callback(arg1, ...)  sigc::signal<arg1,__VA_ARGS__>
+#define surf_callback_connect(callback, fun_ptr) callback.connect(sigc::ptr_fun(fun_ptr))
+#define surf_callback_emit(callback, ...) callback.emit(__VA_ARGS__)
+#else
+#include <boost/signals2.hpp>
+#define surf_callback(arg1, ...)  boost::signals2::signal<arg1(__VA_ARGS__)>
+#define surf_callback_connect(callback, fun_ptr) callback.connect(fun_ptr)
+#define surf_callback_emit(callback, ...) callback(__VA_ARGS__)
+#endif
 
 extern tmgr_history_t history;
 #define NO_MAX_DURATION -1.0
 
 using namespace std;
 
-/** \ingroup SURF_simulation
- *  \brief Return the current time
- *
- *  Return the current time in millisecond.
- */
-
 /*********
  * Utils *
  *********/
@@ -62,11 +73,9 @@ typedef Model* ModelPtr;
 
 //class Resource;
 typedef Resource* ResourcePtr;
-typedef boost::function<void (ResourcePtr r)> ResourceCallback;
                        
 //class Action;
 typedef Action* ActionPtr;
-typedef boost::function<void (ActionPtr a)> ActionCallback;
 
 typedef boost::intrusive::list<Action> ActionList;
 typedef ActionList* ActionListPtr;
@@ -77,6 +86,7 @@ typedef boost::intrusive::list<Action, boost::intrusive::base_hook<boost::intrus
 typedef ActionLmmList* ActionLmmListPtr;
 typedef boost::intrusive::list_base_hook<boost::intrusive::tag<lmmTag> > actionLmmHook;
 
+
 enum heap_action_type{
   LATENCY = 100,
   MAX_DURATION,
@@ -95,125 +105,281 @@ XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_link_avail;
 XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_bandwidth; 
 XBT_PUBLIC_DATA(xbt_dict_t) trace_connect_list_latency;
 
-
 /*********
  * Model *
  *********/
 XBT_PUBLIC_DATA(xbt_dynar_t) model_list;
 
+/** @ingroup SURF_interface
+ * @brief SURF model interface class
+ * @details A model is an object which handle the interactions between its Resources and its Actions
+ */
 class Model {
-  const char *p_name;
-
-  ActionListPtr p_readyActionSet; /**< Actions in state SURF_ACTION_READY */
-  ActionListPtr p_runningActionSet; /**< Actions in state SURF_ACTION_RUNNING */
-  ActionListPtr p_failedActionSet; /**< Actions in state SURF_ACTION_FAILED */
-  ActionListPtr p_doneActionSet; /**< Actions in state SURF_ACTION_DONE */
-
-  ResourceCallback m_resOnCB, m_resOffCB;
-  ActionCallback m_actCancelCB, m_actSuspendCB, m_actResumeCB;
-
-protected:
-  ActionLmmListPtr p_modifiedSet;
-
-  lmm_system_t p_maxminSystem;
-  e_UM_t p_updateMechanism;
-  int m_selectiveUpdate;
-  xbt_heap_t p_actionHeap;
-
 public:
+  /** 
+   * @brief Model constructor
+   * 
+   * @param name the name of the model
+   */
   Model(const char *name);
+
+  /** 
+   * @brief Model destructor
+   */
   virtual ~Model();
 
+  /**
+   * @brief Get the name of the current Model
+   * 
+   * @return The name of the current Model
+   */
   const char *getName() {return p_name;}
+
+  /**
+   * @brief Get the set of [actions](@ref Action) in *ready* state 
+   * 
+   * @return The set of [actions](@ref Action) in *ready* state 
+   */
   virtual ActionListPtr getReadyActionSet() {return p_readyActionSet;}
+
+  /**
+   * @brief Get the set of [actions](@ref Action) in *running* state
+   * 
+   * @return The set of [actions](@ref Action) in *running* state
+   */
   virtual ActionListPtr getRunningActionSet() {return p_runningActionSet;}
+
+  /**
+   * @brief Get the set of [actions](@ref Action) in *failed* state
+   * 
+   * @return The set of [actions](@ref Action) in *failed* state
+   */
   virtual ActionListPtr getFailedActionSet() {return p_failedActionSet;}
+
+  /**
+   * @brief Get the set of [actions](@ref Action) in *done* state
+   * 
+   * @return The set of [actions](@ref Action) in *done* state
+   */
   virtual ActionListPtr getDoneActionSet() {return p_doneActionSet;}
+
+  /**
+   * @brief Get the set of modified [actions](@ref Action)
+   * 
+   * @return The set of modified [actions](@ref Action)
+   */
   virtual ActionLmmListPtr getModifiedSet() {return p_modifiedSet;}
+
+  /**
+   * @brief Get the maxmin system of the current Model
+   *
+   * @return The maxmin system of the current Model
+   */
   lmm_system_t getMaxminSystem() {return p_maxminSystem;}
+
+  /**
+   * @brief Get the update mechanism of the current Model
+   * @see e_UM_t
+   * 
+   * @return [description]
+   */
   e_UM_t getUpdateMechanism() {return p_updateMechanism;}
+
+  /**
+   * @brief Get Action heap
+   * @details [TODO]
+   * 
+   * @return The Action heap
+   */
   xbt_heap_t getActionHeap() {return p_actionHeap;}
 
-  ActionPtr createAction(double _cost, bool _failed);
+  /** 
+   * @brief share the resources
+   * @details Share the resources between the actions 
+   * 
+   * @param 
+   * @return the date of the next action will finish
+   */
   virtual double shareResources(double now);
   virtual double shareResourcesLazy(double now);
   virtual double shareResourcesFull(double now);
   double shareResourcesMaxMin(ActionListPtr running_actions,
                                       lmm_system_t sys,
                                       void (*solve) (lmm_system_t));
+
+  /**
+   * @brief Update state of actions
+   * @details [TODO]
+   * 
+   * @param now [TODO]
+   * @param delta [TODO]
+   */
   virtual void updateActionsState(double now, double delta);
   virtual void updateActionsStateLazy(double now, double delta);
   virtual void updateActionsStateFull(double now, double delta);
 
-  void addTurnedOnCallback(ResourceCallback rc);
-  void notifyResourceTurnedOn(ResourcePtr r);
+protected:
+  ActionLmmListPtr p_modifiedSet;
+  lmm_system_t p_maxminSystem;
+  e_UM_t p_updateMechanism;
+  int m_selectiveUpdate;
+  xbt_heap_t p_actionHeap;
 
-  void addTurnedOffCallback(ResourceCallback rc);  
-  void notifyResourceTurnedOff(ResourcePtr r);
+private:
+  const char *p_name;
 
-  void addActionCancelCallback(ActionCallback ac);
-  void notifyActionCancel(ActionPtr a);
-  void addActionResumeCallback(ActionCallback ac);
-  void notifyActionResume(ActionPtr a);
-  void addActionSuspendCallback(ActionCallback ac);  
-  void notifyActionSuspend(ActionPtr a);
+  ActionListPtr p_readyActionSet; /**< Actions in state SURF_ACTION_READY */
+  ActionListPtr p_runningActionSet; /**< Actions in state SURF_ACTION_RUNNING */
+  ActionListPtr p_failedActionSet; /**< Actions in state SURF_ACTION_FAILED */
+  ActionListPtr p_doneActionSet; /**< Actions in state SURF_ACTION_DONE */
 };
 
 /************
  * Resource *
  ************/
 
-/**
- * Resource which have a metric handled by a maxmin system
+/** @ingroup SURF_interface
+ * @brief Resource which have a metric handled by a maxmin system
  */
 typedef struct {
-  double scale;
-  double peak;
-  tmgr_trace_event_t event;
+  double scale;             /**< The scale of the metric */
+  double peak;              /**< The peak of the metric */
+  tmgr_trace_event_t event; /**< The associated trace event associated to the metric */
 } s_surf_metric_t;
 
+/** @ingroup SURF_interface
+ * @brief SURF resource interface class
+ * @details A resource represent an element of a component (e.g.: a link for the network)
+ */
 class Resource {
-  void *p_resource;
-  const char *p_name;
-  ModelPtr p_model;
-  xbt_dict_t p_properties;
-  bool m_running;
-
-protected:
-  e_surf_resource_state_t m_stateCurrent;
-
 public:
+  /** 
+   * @brief Resource constructor
+   */
   Resource();
+
+  /** 
+   * @brief Resource constructor
+   * 
+   * @param model Model associated to this Resource
+   * @param name The name of the Resource
+   * @param props Dictionary of properties associated to this Resource
+   */
   Resource(ModelPtr model, const char *name, xbt_dict_t props);
-  Resource(ModelPtr model, const char *name, xbt_dict_t props, lmm_constraint_t constraint);
-  Resource(ModelPtr model, const char *name, xbt_dict_t props, e_surf_resource_state_t stateInit);
-  Resource(ModelPtr model, const char *name, xbt_dict_t props, e_surf_resource_state_t stateInit, lmm_constraint_t constraint);
 
-  virtual ~Resource() {
-       xbt_free((void*)p_name);
-    xbt_dict_free(&p_properties);
-  };
+  /** 
+   * @brief Resource constructor
+   * 
+   * @param model Model associated to this Resource
+   * @param name The name of the Resource
+   * @param props Dictionary of properties associated to this Resource
+   * @param constraint The lmm constraint associated to this Resource if it is part of a LMM component
+   */
+  Resource(ModelPtr model, const char *name, xbt_dict_t props, lmm_constraint_t constraint);
 
-  ModelPtr getModel() {return p_model;};
-  const char *getName() {return p_name;};
-  virtual xbt_dict_t getProperties() {return p_properties;};
+  /** 
+   * @brief Resource constructor
+   * 
+   * @param model Model associated to this Resource
+   * @param name The name of the Resource
+   * @param props Dictionary of properties associated to this Resource
+   * @param stateInit the initial state of the Resource
+   */
+  Resource(ModelPtr model, const char *name, xbt_dict_t props, e_surf_resource_state_t stateInit);
 
+  /**
+   * @brief Resource destructor
+   */
+  virtual ~Resource(); 
+
+  /**
+   * @brief Get the Model of the current Resource
+   * 
+   * @return The Model of the current Resource
+   */
+  ModelPtr getModel();
+
+  /**
+   * @brief Get the name of the current Resource
+   * 
+   * @return The name of the current Resource
+   */
+  const char *getName();
+
+  /**
+   * @brief Get the properties of the current Resource
+   * 
+   * @return The properties of the current Resource
+   */
+  virtual xbt_dict_t getProperties();
+
+  /**
+   * @brief Update the state of the current Resource
+   * @details [TODO]
+   * 
+   * @param event_type [TODO]
+   * @param value [TODO]
+   * @param date [TODO]
+   */
   virtual void updateState(tmgr_trace_event_t event_type, double value, double date)=0;
+
+  /**
+   * @brief Check if the current Resource is used
+   * @return true if the current Resource is used, false otherwise
+   */
   virtual bool isUsed()=0;
+
+  /**
+   * @brief Check if the current Resource is active
+   *
+   * @return true if the current Resource is active, false otherwise
+   */
   bool isOn();
+
+  /**
+   * @brief Turn on the current Resource
+   */
   void turnOn();
+
+  /**
+   * @brief Turn off the current Resource
+   */
   void turnOff();
-  void setName(string name);
 
+  /**
+   * @brief Get the [state](\ref e_surf_resource_state_t) of the current Resource
+   *
+   * @return The state of the currenrt Resource
+   */
   virtual e_surf_resource_state_t getState();
+
+  /**
+   * @brief Set the [state](\ref e_surf_resource_state_t) of the current Resource
+   * 
+   * @param state The new state of the current Resource
+   */
   virtual void setState(e_surf_resource_state_t state);
 
+protected:
+  e_surf_resource_state_t m_stateCurrent;
+
+private:
+  const char *p_name;
+  xbt_dict_t p_properties;
+  ModelPtr p_model;
+  void *p_resource;
+  bool m_running;
+
   /* LMM */
+public:
+  /**
+   * @brief Get the lmm constraint associated to this Resource if it is part of a LMM component
+   * 
+   * @return The lmm constraint associated to this Resource
+   */
+  lmm_constraint_t getConstraint();
 private:
   lmm_constraint_t p_constraint;
-public:
-  lmm_constraint_t getConstraint() {return p_constraint;};
-
 };
 
 /**********
@@ -221,102 +387,313 @@ public:
  **********/
 void surf_action_lmm_update_index_heap(void *action, int i);
 
+/** @ingroup SURF_interface
+ * @brief SURF action interface class
+ * @details An action is an event generated by a resource (e.g.: a communication for the network)
+ */
 class Action : public actionHook, public actionLmmHook {
-  ActionLmmListPtr p_modifiedSet;
-  xbt_heap_t p_actionHeap;
-  int m_selectiveUpdate;
-  ModelPtr p_model;
-  double m_bound;   /**< the capping of the CPU use  */
-  bool m_failed;
-  double m_start; /**< start time  */
-  char *p_category;               /**< tracing category for categorized resource utilization monitoring */
-
-  #ifdef HAVE_LATENCY_BOUND_TRACKING
-  int m_latencyLimited;               /**< Set to 1 if is limited by latency, 0 otherwise */
-  #endif
-  int    m_cost;
-  void *p_data; /**< for your convenience */
-
-protected:
-  ActionListPtr p_stateSet;
-  double m_priority; /**< priority (1.0 by default) */
-  int    m_refcount;
-  double m_remains; /**< How much of that cost remains to be done in the currently running task */
-  double m_maxDuration; /*< max_duration (may fluctuate until the task is completed) */
-  double m_finish; /**< finish time : this is modified during the run and fluctuates until the task is completed */
-
-  ModelPtr getModel() {return p_model;}
-
 public:
-
+  /**
+   * @brief Action constructor
+   */
   Action();
+
+  /**
+   * @brief Action constructor
+   * 
+   * @param model The Model associated to this Action
+   * @param cost The cost of the Action
+   * @param failed If the action is impossible (e.g.: execute something on a switched off workstation)
+   */
   Action(ModelPtr model, double cost, bool failed);
+
+  /**
+   * @brief Action constructor
+   * 
+   * @param model The Model associated to this Action
+   * @param cost The cost of the Action
+   * @param failed If the action is impossible (e.g.: execute something on a switched off workstation)
+   * @param var The lmm variable associated to this Action if it is part of a LMM component
+   */
   Action(ModelPtr model, double cost, bool failed, lmm_variable_t var);
+
+  /**
+   * @brief Action destructor
+   */
   virtual ~Action();
   
+  /**
+   * @brief Finish the action
+   */
   void finish();
-  s_xbt_swag_hookup_t p_stateHookup;
 
+  /**
+   * @brief Get the [state](\ref e_surf_action_state_t) of the current Action
+   * 
+   * @return The state of the current Action
+   */
   e_surf_action_state_t getState(); /**< get the state*/
+
+  /**
+   * @brief Set the [state](\ref e_surf_action_state_t) of the current Action
+   * 
+   * @param state The new state of the current Action
+   */
   virtual void setState(e_surf_action_state_t state); /**< Change state*/
+
+  /**
+   * @brief Get the bound of the current Action
+   * 
+   * @return The bound of the current Action
+   */
   double getBound() {return m_bound;}
-  double getStartTime(); /**< Return the start time of an action */
-  double getFinishTime(); /**< Return the finish time of an action */
+
+  /**
+   * @brief Get the start time of the current action
+   * 
+   * @return The start time of the current action
+   */
+  double getStartTime();
+
+  /**
+   * @brief Get the finish time of the current action
+   * 
+   * @return The finish time of the current action
+   */
+  double getFinishTime();
+
+  /**
+   * @brief Get the data associated to the current action
+   * 
+   * @return The data associated to the current action
+   */
   void *getData() {return p_data;}
+
+  /**
+   * @brief Set the data associated to the current action
+   * 
+   * @param data The new data associated to the current action
+   */
   void setData(void* data);
+
+  /**
+   * @brief Get the maximum duration of the current action
+   * 
+   * @return The maximum duration of the current action
+   */
   double getMaxDuration() {return m_maxDuration;}
+
+  /**
+   * @brief Get the category associated to the current action
+   * 
+   * @return The category associated to the current action
+   */
   char *getCategory() {return p_category;}
+
+  /**
+   * @brief Get the cost of the current action
+   * 
+   * @return The cost of the current action
+   */
   double getCost() {return m_cost;}
+
+  /**
+   * @brief Set the cost of the current action
+   * 
+   * @param cost The new cost of the current action
+   */
   void setCost(double cost) {m_cost = cost;}
 
+  /**
+   * @brief Update the maximum duration of the current action
+   * 
+   * @param delta [TODO]
+   */
   void updateMaxDuration(double delta) {double_update(&m_maxDuration, delta);}
+
+  /**
+   * @brief Update the remaining time of the current action
+   * 
+   * @param delta [TODO]
+   */
   void updateRemains(double delta) {double_update(&m_remains, delta);}
+
+  /**
+   * @brief Set the remaining time of the current action
+   * 
+   * @param value The new remaining time of the current action
+   */
   void setRemains(double value) {m_remains = value;}
-  void setFinishTime(double value) {m_finish = value;}
 
+  /**
+   * @brief Set the finish time of the current action
+   * 
+   * @param value The new Finush time of the current action
+   */
+  void setFinishTime(double value) {m_finish = value;}
 
+  /**
+   * @brief Add a reference to the current action
+   */
   void ref();
-  virtual int unref();     /**< Specify that we don't use that action anymore. Returns true if the action was destroyed and false if someone still has references on it. */
-  virtual void cancel();     /**< Cancel a running action */
-  virtual void recycle(){};     /**< Recycle an action */
-  
-  virtual void suspend();     /**< Suspend an action */
-  virtual void resume();     /**< Resume a suspended action */
-  virtual bool isSuspended();     /**< Return whether an action is suspended */
-  virtual void setMaxDuration(double duration);     /**< Set the max duration of an action*/
-  virtual void setPriority(double priority);     /**< Set the priority of an action */
+
+  /**
+   * @brief Remove a reference to the current action
+   * @details If the Action has no more reference, we destroy it
+   * 
+   * @return true if the action was destroyed and false if someone still has references on it
+   */
+  virtual int unref();
+
+  /**
+   * @brief Cancel the current Action if running
+   */
+  virtual void cancel();
+
+  /**
+   * @brief Recycle an Action
+   */
+  virtual void recycle(){};
+
+  /**
+   * @brief Suspend the current Action
+   */
+  virtual void suspend();
+
+  /**
+   * @brief Resume the current Action
+   */
+  virtual void resume();
+
+  /**
+   * @brief Check if the current action is running
+   * 
+   * @return true if the current Action is suspended, false otherwise
+   */
+  virtual bool isSuspended();
+
+  /**
+   * @brief Set the maximum duration of the current Action
+   * 
+   * @param duration The new maximum duration of the current Action
+   */
+  virtual void setMaxDuration(double duration);
+
+  /**
+   * @brief Set the priority of the current Action
+   * 
+   * @param priority The new priority of the current Action
+   */
+  virtual void setPriority(double priority);
+
 #ifdef HAVE_TRACING
-  void setCategory(const char *category); /**< Set the category of an action */
+  /**
+   * @brief Set the category of the current Action
+   * 
+   * @param category The new category of the current Action
+   */
+  void setCategory(const char *category);
 #endif
-  virtual double getRemains();     /**< Get the remains of an action */
+
+  /**
+   * @brief Get the remaining time of the current action after updating the resource
+   * 
+   * @return The remaining time
+   */
+  virtual double getRemains();
+
+  /**
+   * @brief Get the remaining time of the current action without updating the resource
+   * 
+   * @return The remaining time
+   */
   double getRemainsNoUpdate();
 
 #ifdef HAVE_LATENCY_BOUND_TRACKING
-  int getLatencyLimited();     /**< Return 1 if action is limited by latency, 0 otherwise */
+  /**
+   * @brief Check if the action is limited by latency.
+   * 
+   * @return 1 if action is limited by latency, 0 otherwise
+   */
+  int getLatencyLimited();
 #endif
 
+  /**
+   * @brief Get the priority of the current Action
+   * 
+   * @return The priority of the current Action
+   */
   double getPriority() {return m_priority;};
+
+  /**
+   * @brief Get the state set in which the action is
+   * @details [TODO]
+   * 
+   * @return The state set in which the action is
+   */
   ActionListPtr getStateSet() {return p_stateSet;};
 
+  s_xbt_swag_hookup_t p_stateHookup;
+
+protected:
+  ActionListPtr p_stateSet;
+  double m_priority; /**< priority (1.0 by default) */
+  int    m_refcount;
+  double m_remains; /**< How much of that cost remains to be done in the currently running task */
+  double m_maxDuration; /*< max_duration (may fluctuate until the task is completed) */
+  double m_finish; /**< finish time : this is modified during the run and fluctuates until the task is completed */
+
+  ModelPtr getModel() {return p_model;}
+
 private:
   int resourceUsed(void *resource_id);
-  /* Share the resources to the actions and return in how much time
-     the next action may terminate */
+
+  /**
+   * @brief Share the resources to the actions
+   * @details [TODO]
+   * 
+   * @param now [TODO]
+   * @return in how much time the next action may terminatedescription]
+   */
   double shareResources(double now);
-  /* Update the actions' state */
+
+  /**
+   * @brief Update the current action state
+   * @details [TODO]
+   * 
+   * @param now [TODO]
+   * @param delta [TODO]
+   */
   void updateActionsState(double now, double delta);
+
+  /**
+   * @brief Update the [TODO]
+   * @details [TODO]
+   * 
+   * @param id [TODO]
+   * @param event_type [TODO]
+   * @param value [TODO]
+   * @param time [TODO]
+   */
   void updateResourceState(void *id, tmgr_trace_event_t event_type,
                                  double value, double time);
 
-  /* LMM */
-protected:
-  lmm_variable_t p_variable;
-  double m_lastUpdate;
-  double m_lastValue;
-  int m_suspended;
-  int m_indexHeap;
-  enum heap_action_type m_hat;
+  ActionLmmListPtr p_modifiedSet;
+  xbt_heap_t p_actionHeap;
+  int m_selectiveUpdate;
+  double m_bound;   /**< the capping of the CPU use  */
+  bool m_failed;
+  double m_start; /**< start time  */
+  char *p_category;               /**< tracing category for categorized resource utilization monitoring */
 
+  #ifdef HAVE_LATENCY_BOUND_TRACKING
+  int m_latencyLimited;               /**< Set to 1 if is limited by latency, 0 otherwise */
+  #endif
+  int    m_cost;
+  ModelPtr p_model;
+  void *p_data; /**< for your convenience */
+
+  /* LMM */
 public:
   virtual void updateRemainingLazy(double now);
   void heapInsert(xbt_heap_t heap, double key, enum heap_action_type hat);
@@ -328,6 +705,14 @@ public:
   enum heap_action_type getHat() {return m_hat;}
   bool is_linked() {return actionLmmHook::is_linked();}
   void gapRemove();
+
+protected:
+  lmm_variable_t p_variable;
+  double m_lastValue;
+  double m_lastUpdate;
+  int m_suspended;
+  int m_indexHeap;
+  enum heap_action_type m_hat;
 };
 
 #endif /* SURF_MODEL_H_ */
index f2a889c..25a2102 100644 (file)
@@ -23,10 +23,13 @@ extern xbt_dict_t watched_hosts_lib;
 
 extern const char *surf_action_state_names[6];
 
+/** @ingroup SURF_interface
+ * @brief Possible update mechanisms
+ */
 typedef enum {
-  UM_FULL,
-  UM_LAZY,
-  UM_UNDEFINED
+  UM_FULL,      /**< [TODO] */
+  UM_LAZY,      /**< [TODO] */
+  UM_UNDEFINED  /**< Mechanism not defined */
 } e_UM_t;
 
 /* Generic functions common to all models */
index 8c2c90f..e4d93c6 100644 (file)
@@ -14,6 +14,9 @@ xbt_edge_t new_xbt_graph_edge (xbt_graph_t graph, xbt_node_t s, xbt_node_t d, xb
 /***********
  * Classes *
  ***********/
+
+/* Note: As and RoutingEdge are declard as struct instead of class, to keep
+   compatibility with C files where they are mentioned. */
 struct As;
 typedef As *AsPtr;
 
@@ -29,6 +32,10 @@ typedef Onelink *OnelinkPtr;
 class RoutingPlatf;
 typedef RoutingPlatf *RoutingPlatfPtr;
 
+/** @ingroup SURF_routing_interface
+ * @brief The Autonomous System (AS) routing interface
+ * @details [TODO]
+ */
 struct As {
 public:
   xbt_dynar_t p_indexNetworkElm;
@@ -41,11 +48,27 @@ public:
   RoutingEdgePtr p_netElem;
   xbt_dynar_t p_linkUpDownList;
 
+  /**
+   * @brief The As constructor
+   */
   As(){};
+
+  /**
+   * @brief The As destructor
+   */
   virtual ~As(){
        xbt_free(p_name);
   };
 
+  /**
+   * @brief Get the route and latency between two RoutingEdgs
+   * @details [long description]
+   * 
+   * @param src [description]
+   * @param dst [description]
+   * @param into [description]
+   * @param latency [description]
+   */
   virtual void getRouteAndLatency(RoutingEdgePtr src, RoutingEdgePtr dst, sg_platf_route_cbarg_t into, double *latency)=0;
   virtual xbt_dynar_t getOneLinkRoutes()=0;
   virtual void getGraph(xbt_graph_t graph, xbt_dict_t nodes, xbt_dict_t edges)=0;
@@ -62,6 +85,10 @@ public:
   virtual void parseBypassroute(sg_platf_route_cbarg_t e_route)=0;
 };
 
+/** @ingroup SURF_routing_interface
+ * @brief A routing edge
+ * @details [long description]
+ */
 struct RoutingEdge {
 public:
   ~RoutingEdge() { xbt_free(p_name);};
@@ -71,8 +98,9 @@ public:
   char *p_name;
 };
 
-/*
- * Link of lenght 1, alongside with its source and destination. This is mainly usefull in the bindings to gtnets and ns3
+
+/** @ingroup SURF_routing_interface
+ * @brief Link of lenght 1, alongside with its source and destination. This is mainly usefull in the bindings to gtnets and ns3
  */
 class Onelink {
 public:
@@ -83,6 +111,9 @@ public:
   void *p_link;
 };
 
+/** @ingroup SURF_routing_interface
+ * @brief The class representing a whole routing platform
+ */
 class RoutingPlatf {
 public:
   ~RoutingPlatf();
index bb6add4..66b3c6a 100644 (file)
@@ -297,10 +297,10 @@ WorkstationVMHL13::WorkstationVMHL13(WorkstationVMModelPtr model, const char* na
 WorkstationVMHL13::~WorkstationVMHL13()
 {
   /* ind_phys_workstation equals to smx_host_t */
-  surf_resource_t ind_vm_workstation = xbt_lib_get_elm_or_null(host_lib, getName());
+  // surf_resource_t ind_vm_workstation = xbt_lib_get_elm_or_null(host_lib, getName());
 
   /* Before clearing the entries in host_lib, we have to pick up resources. */
-  CpuCas01Ptr cpu = static_cast<CpuCas01Ptr>(surf_cpu_resource_priv(ind_vm_workstation));
+  // CpuCas01Ptr cpu = static_cast<CpuCas01Ptr>(surf_cpu_resource_priv(ind_vm_workstation));
 
   /* We deregister objects from host_lib, without invoking the freeing callback
    * of each level.
@@ -332,7 +332,7 @@ WorkstationVMHL13::~WorkstationVMHL13()
        /* Free the workstation resource of the VM. */
 }
 
-void WorkstationVMHL13::updateState(tmgr_trace_event_t event_type, double value, double date) {
+void WorkstationVMHL13::updateState(tmgr_trace_event_t /*event_type*/, double /*value*/, double /*date*/) {
   THROW_IMPOSSIBLE;             /* This model does not implement parallel tasks */
 }
 
index 7217b9f..ec334ac 100644 (file)
@@ -1,9 +1,9 @@
-/*
- * vm_workstation.hpp
- *
- *  Created on: Nov 12, 2013
- *      Author: bedaride
- */
+/* Copyright (c) 2004-2013. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
 #include "workstation_interface.hpp"
 
 #ifndef VM_WORKSTATION_INTERFACE_HPP_
@@ -30,12 +30,32 @@ typedef WorkstationVMLmm *WorkstationVMLmmPtr;
 /*********
  * Model *
  *********/
-
+/** @ingroup SURF_vm_workstation_interface
+ * @brief SURF workstation VM model interface class
+ * @details A model is an object which handle the interactions between its Resources and its Actions
+ */
 class WorkstationVMModel : public WorkstationModel {
 public:
+  /**
+   * @brief WorkstationVMModel consrtuctor
+   */
   WorkstationVMModel();
+
+    /**
+   * @brief WorkstationVMModel consrtuctor
+   */
   ~WorkstationVMModel(){};
+
+  /**
+   * @brief Create a new WorkstationVM
+   * 
+   * @param name The name of the new WorkstationVM
+   * @param ind_phys_workstation The workstation hosting the VM
+   * 
+   */
   virtual void createResource(const char *name, void *ind_phys_workstation)=0;
+
+
   void adjustWeightOfDummyCpuActions() {};
 };
 
@@ -43,22 +63,62 @@ public:
  * Resource *
  ************/
 
+/** @ingroup SURF_vm_workstation_interface
+ * @brief SURF workstation VM interface class
+ * @details A workstation VM represent an virtual machine
+ */
 class WorkstationVM : public Workstation {
 public:
+  /**
+   * @brief WorkstationVM consrtructor
+   * 
+   * @param model WorkstationModel associated to this Workstation
+   * @param name The name of the Workstation
+   * @param props Dictionary of properties associated to this Workstation
+   * @param netElm The RoutingEdge associated to this Workstation
+   * @param cpu The Cpu associated to this Workstation
+   */
   WorkstationVM(ModelPtr model, const char *name, xbt_dict_t props,
                        RoutingEdgePtr netElm, CpuPtr cpu)
   : Workstation(model, name, props, NULL, netElm, cpu) {}
+
+  /**
+   * @brief WdorkstationVM estructor
+   */
   ~WorkstationVM();
 
+  /**
+   * @brief Suspend the VM
+   */
   virtual void suspend()=0;
+
+  /**
+   * @brief Resume the VM
+   */
   virtual void resume()=0;
 
+  /**
+   * @brief Save the VM (Not yet implemented)
+   */
   virtual void save()=0;
+
+  /**
+   * @brief Restore the VM (Not yet implemented)
+   */
   virtual void restore()=0;
 
-  virtual void migrate(surf_resource_t ind_vm_ws_dest)=0; // will be vm_ws_migrate()
+  /**
+   * @brief Migrate the VM to the destination host
+   * 
+   * @param ind_vm_ws_dest The destination host
+   */
+  virtual void migrate(surf_resource_t ind_vm_ws_dest)=0;
 
-  virtual surf_resource_t getPm()=0; // will be vm_ws_get_pm()
+  /**
+   * @brief Get the physical machine hosting the VM
+   * @return The physical machine hosting the VM
+   */
+  virtual surf_resource_t getPm()=0;
 
   virtual void setBound(double bound)=0;
   virtual void setAffinity(CpuPtr cpu, unsigned long mask)=0;
@@ -69,7 +129,6 @@ public:
   e_surf_vm_state_t p_currentState;
 };
 
-
 /**********
  * Action *
  **********/
index b6df595..9af820b 100644 (file)
@@ -123,17 +123,11 @@ void Workstation::setPowerPeakAt(int pstate_index)
        p_cpu->setPowerPeakAt(pstate_index);
 }
 
-double Workstation::getConsumedEnergy()
-{
-  return p_cpu->getConsumedEnergy();
-}
-
 xbt_dict_t Workstation::getProperties()
 {
   return p_cpu->getProperties();
 }
 
-
 StoragePtr Workstation::findStorageOnMountList(const char* mount)
 {
   StoragePtr st = NULL;
index 2432c0f..5045cec 100644 (file)
@@ -1,3 +1,9 @@
+/* Copyright (c) 2004-2013. The SimGrid Team.
+ * All rights reserved.                                                     */
+
+/* This program is free software; you can redistribute it and/or modify it
+ * under the terms of the license (GNU LGPL) which comes with this package. */
+
 #include "surf_interface.hpp"
 #include "storage_interface.hpp"
 #include "cpu_interface.hpp"
@@ -27,19 +33,73 @@ extern WorkstationModelPtr surf_workstation_model;
 /*********
  * Model *
  *********/
+/** @ingroup SURF_workstation_interface
+ * @brief SURF Workstation model interface class
+ * @details A model is an object which handle the interactions between its Resources and its Actions
+ */
 class WorkstationModel : public Model {
 public:
+    /** 
+   * @brief WorkstationModel constructor
+   * 
+   * @param name the name of the model
+   */
   WorkstationModel(const char *name);
+
+  /**
+   * @brief WorkstationModel constructor
+   */
   WorkstationModel();
+
+  /**
+   * @brief WorkstationModel destructor
+   */
   ~WorkstationModel();
-  virtual void adjustWeightOfDummyCpuActions();
 
+  /**
+   * @brief [brief description]
+   * @details [long description]
+   */
+  virtual void adjustWeightOfDummyCpuActions();
+  
+  /**
+   * @brief [brief description]
+   * @details [long description]
+   * 
+   * @param workstation_nb [description]
+   * @param workstation_list [description]
+   * @param computation_amount [description]
+   * @param communication_amount [description]
+   * @param rate [description]
+   * @return [description]
+   */
   virtual ActionPtr executeParallelTask(int workstation_nb,
                                         void **workstation_list,
                                         double *computation_amount,
                                         double *communication_amount,
                                         double rate)=0;
+
+ /**
+  * @brief [brief description]
+  * @details [long description]
+  * 
+  * @param src [description]
+  * @param dst [description]
+  * 
+  * @return [description]
+  */
  virtual xbt_dynar_t getRoute(WorkstationPtr src, WorkstationPtr dst)=0;
+
+ /**
+  * @brief [brief description]
+  * @details [long description]
+  * 
+  * @param src [description]
+  * @param dst [description]
+  * @param size [description]
+  * @param rate [description]
+  * @return [description]
+  */
  virtual ActionPtr communicate(WorkstationPtr src, WorkstationPtr dst, double size, double rate)=0;
 
  CpuModelPtr p_cpuModel;
@@ -48,42 +108,235 @@ public:
 /************
  * Resource *
  ************/
-
+/** @ingroup SURF_workstation_interface
+ * @brief SURF Workstation interface class
+ * @details A workstation VM represent an virtual machine with a aggregation of a Cpu, a NetworkLink and a Storage
+ */
 class Workstation : public Resource {
 public:
+  /**
+   * @brief Workstation consrtuctor
+   * @details [long description]
+   */
   Workstation(){};
+
+  /**
+   * @brief Workstation constructor
+   * 
+   * @param model WorkstationModel associated to this Workstation
+   * @param name The name of the Workstation
+   * @param props Dictionary of properties associated to this Workstation
+   * @param storage The Storage associated to this Workstation
+   * @param netElm The RoutingEdge associated to this Workstation
+   * @param cpu The Cpu associated to this Workstation
+   */
   Workstation(ModelPtr model, const char *name, xbt_dict_t props,
                      xbt_dynar_t storage, RoutingEdgePtr netElm, CpuPtr cpu);
+
+  /**
+   * @brief Workstation constructor
+   * 
+   * @param model WorkstationModel associated to this Workstation
+   * @param name The name of the Workstation
+   * @param props Dictionary of properties associated to this Workstation
+   * @param constraint The lmm constraint associated to this Workstation if it is part of a LMM component
+   * @param storage The Storage associated to this Workstation
+   * @param netElm The RoutingEdge associated to this Workstation
+   * @param cpu The Cpu associated to this Workstation
+   */
   Workstation(ModelPtr model, const char *name, xbt_dict_t props, lmm_constraint_t constraint,
                      xbt_dynar_t storage, RoutingEdgePtr netElm, CpuPtr cpu);
 
+  /**
+   * @brief Get the properties of the currenrt Workstation
+   *
+   * @return The properties of the current Workstation
+   */
   xbt_dict_t getProperties();
 
+  /**
+   * @brief Execute some quantity of computation
+   * 
+   * @param size The value of the processing amount (in flop) needed to process
+   * @return The CpuAction corresponding to the processing
+   * @see Cpu
+   */
   virtual ActionPtr execute(double size)=0;
+
+  /**
+   * @brief Make a process sleep for duration seconds
+   * 
+   * @param duration The number of seconds to sleep
+   * @return The CpuAction corresponding to the sleeping
+   * @see Cpu
+   */
   virtual ActionPtr sleep(double duration)=0;
 
+  /**
+   * @brief Get the number of cores of the associated Cpu
+   * 
+   * @return The number of cores of the associated Cpu
+   * @see Cpu
+   */
   virtual int getCore();
+
+  /**
+   * @brief Get the speed of the associated Cpu
+   * 
+   * @param load [TODO]
+   * @return The speed of the associated Cpu
+   * @see Cpu
+   */
   virtual double getSpeed(double load);
+
+  /**
+   * @brief Get the available speed of the associated Cpu
+   * @details [TODO]
+   * 
+   * @return The available speed of the associated Cpu
+   * @see Cpu
+   */
   virtual double getAvailableSpeed();
+
+  /**
+   * @brief Get the associated Cpu power peak
+   * 
+   * @return The associated Cpu power peak
+   * @see Cpu
+   */
   virtual double getCurrentPowerPeak();
+
   virtual double getPowerPeakAt(int pstate_index);
   virtual int getNbPstates();
   virtual void setPowerPeakAt(int pstate_index);
-  virtual double getConsumedEnergy();
 
+  /**
+   * @brief Return the storage of corresponding mount point
+   * 
+   * @param storage The mount point
+   * @return The corresponding Storage
+   */
   virtual StoragePtr findStorageOnMountList(const char* storage);
+
+  /**
+   * @brief Get the xbt_dict_t of mount_point: Storage
+   * 
+   * @return The xbt_dict_t of mount_point: Storage
+   */
   virtual xbt_dict_t getStorageList();
+
+  /**
+   * @brief Open a file
+   * 
+   * @param mount The mount point
+   * @param path The path to the file
+   * 
+   * @return The StorageAction corresponding to the opening
+   */
   virtual ActionPtr open(const char* mount, const char* path);
+
+  /**
+   * @brief Close a file
+   * 
+   * @param fd The file descriptor to close
+   * @return The StorageAction corresponding to the closing
+   */
   virtual ActionPtr close(surf_file_t fd);
+
+  /**
+   * @brief Unlink a file
+   * @details [long description]
+   * 
+   * @param fd [description]
+   * @return [description]
+   */
   virtual int unlink(surf_file_t fd);
+
+  /**
+   * @brief List directory contents of a path
+   * @details [long description]
+   * 
+   * @param path The path to the directory
+   * @return The StorageAction corresponding to the ls action
+   */
   virtual ActionPtr ls(const char* mount, const char *path);
+
+  /**
+   * @brief Get the size in bytes of the file
+   * 
+   * @param fd The file descriptor to read
+   * @return The size in bytes of the file
+   */
   virtual sg_size_t getSize(surf_file_t fd);
+
+  /**
+   * @brief Read a file
+   * 
+   * @param fd The file descriptor to read
+   * @param size The size in bytes to read
+   * @return The StorageAction corresponding to the reading
+   */
   virtual ActionPtr read(surf_file_t fd, sg_size_t size);
+
+  /**
+   * @brief Write a file
+   * 
+   * @param fd The file descriptor to write
+   * @param size The size in bytes to write
+   * @return The StorageAction corresponding to the writing
+   */
   virtual ActionPtr write(surf_file_t fd, sg_size_t size);
-  virtual xbt_dynar_t getInfo( surf_file_t fd);
+
+  /**
+   * @brief Get the informations of a file descriptor
+   * @details The returned xbt_dynar_t contains:
+   *  - the size of the file,
+   *  - the mount point,
+   *  - the storage name,
+   *  - the storage typeId,
+   *  - the storage content type
+   * 
+   * @param fd The file descriptor
+   * @return An xbt_dynar_t with the file informations
+   */
+  virtual xbt_dynar_t getInfo(surf_file_t fd);
+
+  /**
+   * @brief Get the current position of the file descriptor
+   *  
+   * @param fd The file descriptor
+   * @return The current position of the file descriptor
+   */
   virtual sg_size_t fileTell(surf_file_t fd);
+
+  /**
+   * @brief Get the available space of the storage at the mount point 
+   * 
+   * @param name The mount point
+   * @return The amount of availble space in bytes
+   */
   virtual sg_size_t getFreeSize(const char* name);
+
+  /**
+   * @brief Get the used space of the storage at the mount point
+   * 
+   * @param name The mount point
+   * @return The amount of used space in bytes
+   */
   virtual sg_size_t getUsedSize(const char* name);
+
+  /**
+   * @brief Set the position indictator assiociated with the file descriptor to a new position
+   * @details [long description]
+   * 
+   * @param fd The file descriptor
+   * @param offset The offset from the origin
+   * @param origin Position used as a reference for the offset
+   *  - SEEK_SET: beginning of the file
+   *  - SEEK_CUR: current position indicator
+   *  - SEEK_END: end of the file
+   * @return MSG_OK if successful, otherwise MSG_TASK_CANCELED
+   */
   virtual int fileSeek(surf_file_t fd, sg_size_t offset, int origin);
 
   xbt_dynar_t p_storage;
@@ -91,10 +344,28 @@ public:
   CpuPtr p_cpu;
   NetworkLinkPtr p_network;
 
+  /**
+   * @brief Get the list of virtual machines on the current Workstation
+   * 
+   * @return The list of VMs
+   */
   xbt_dynar_t getVms();
 
   /* common with vm */
+  /**
+   * @brief [brief description]
+   * @details [long description]
+   * 
+   * @param params [description]
+   */
   void getParams(ws_params_t params);
+
+  /**
+   * @brief [brief description]
+   * @details [long description]
+   * 
+   * @param params [description]
+   */
   void setParams(ws_params_t params);
   s_ws_params_t p_params;
 };
@@ -102,10 +373,29 @@ public:
 /**********
  * Action *
  **********/
+/** @ingroup SURF_workstation_interface
+ * @brief SURF workstation action interface class
+ */
 class WorkstationAction : public Action {
 public:
+  /**
+   * @brief WorkstationAction constructor
+   * 
+   * @param model The WorkstationModel associated to this WorkstationAction
+   * @param cost The cost of this WorkstationAction in [TODO]
+   * @param failed [description]
+   */
   WorkstationAction(ModelPtr model, double cost, bool failed)
   : Action(model, cost, failed) {}
+
+  /**
+   * @brief WorkstationAction constructor
+   * 
+   * @param model The WorkstationModel associated to this WorkstationAction
+   * @param cost The cost of this WorkstationAction in [TODO]
+   * @param failed [description]
+   * @param var The lmm variable associated to this StorageAction if it is part of a LMM component
+   */
   WorkstationAction(ModelPtr model, double cost, bool failed, lmm_variable_t var)
   : Action(model, cost, failed, var) {}
 
index 82dd39a..2f7ba6b 100644 (file)
@@ -680,6 +680,7 @@ static void xbt_log_connect_categories(void)
   XBT_LOG_CONNECT(surf_cpu);
   XBT_LOG_CONNECT(surf_cpu_cas);
   XBT_LOG_CONNECT(surf_cpu_ti);
+  XBT_LOG_CONNECT(surf_energy);
   XBT_LOG_CONNECT(surf_kernel);
   XBT_LOG_CONNECT(surf_lagrange);
   XBT_LOG_CONNECT(surf_lagrange_dichotomy);
index 01c0bce..6341fa8 100644 (file)
@@ -339,9 +339,9 @@ void *mmalloc_preinit(void)
 
 void mmalloc_postexit(void)
 {
-  /* Do not detach the default mdp or ldl won't be able to free the memory it allocated since we're in memory */
-  //  mmalloc_detach(__mmalloc_default_mdp);
-  xbt_mheap_destroy_no_free(__mmalloc_default_mdp);
+  /* Do not destroy the default mdp or ldl won't be able to free the memory it
+   * allocated since we're in memory */
+  // xbt_mheap_destroy_no_free(__mmalloc_default_mdp);
 }
 
 size_t mmalloc_get_bytes_used(xbt_mheap_t heap){
index 29e4d47..60bf0a4 100644 (file)
@@ -7,6 +7,7 @@
 
 #include "mpi.h"
 #include "mpitest.h"
+#include "smpi_cocci.h"
 #include <stdio.h>
 #include <stdlib.h>
 #ifdef HAVE_SYS_TIME_H
 #define MAX_BUF   (32 * 1024 * 1024)
 #define LOOPS 10
 
-__thread char * sbuf, * rbuf;
-__thread int * recvcounts, * displs;
-int errs = 0;
+SMPI_VARINIT_GLOBAL(sbuf, char*);
+SMPI_VARINIT_GLOBAL(rbuf, char*);
+SMPI_VARINIT_GLOBAL(recvcounts, int*);
+SMPI_VARINIT_GLOBAL(displs, int*);
+SMPI_VARINIT_GLOBAL_AND_SET(errs, int, 0);
 
 /* #define dprintf printf */
 #define dprintf(...)
@@ -56,19 +59,19 @@ int main(int argc, char ** argv)
     if (LARGE_BUF * comm_size > MAX_BUF)
         goto fn_exit;
 
-    sbuf = (void *) calloc(MAX_BUF, 1);
-    rbuf = (void *) calloc(MAX_BUF, 1);
+    SMPI_VARGET_GLOBAL(sbuf) = (void *) calloc(MAX_BUF, 1);
+    SMPI_VARGET_GLOBAL(rbuf) = (void *) calloc(MAX_BUF, 1);
 
     srand(time(NULL));
 
-    recvcounts = (void *) malloc(comm_size * sizeof(int));
-    displs = (void *) malloc(comm_size * sizeof(int));
-    if (!recvcounts || !displs || !sbuf || !rbuf) {
+    SMPI_VARGET_GLOBAL(recvcounts) = (void *) malloc(comm_size * sizeof(int));
+    SMPI_VARGET_GLOBAL(displs) = (void *) malloc(comm_size * sizeof(int));
+    if (!SMPI_VARGET_GLOBAL(recvcounts) || !SMPI_VARGET_GLOBAL(displs) || !SMPI_VARGET_GLOBAL(sbuf) || !SMPI_VARGET_GLOBAL(rbuf)) {
         fprintf(stderr, "Unable to allocate memory:\n");
-       if (!sbuf) fprintf(stderr,"\tsbuf of %d bytes\n", MAX_BUF );
-       if (!rbuf) fprintf(stderr,"\trbuf of %d bytes\n", MAX_BUF );
-       if (!recvcounts) fprintf(stderr,"\trecvcounts of %zd bytes\n", comm_size * sizeof(int) );
-       if (!displs) fprintf(stderr,"\tdispls of %zd bytes\n", comm_size * sizeof(int) );
+       if (!SMPI_VARGET_GLOBAL(sbuf)) fprintf(stderr,"\tsbuf of %d bytes\n", MAX_BUF );
+       if (!SMPI_VARGET_GLOBAL(rbuf)) fprintf(stderr,"\trbuf of %d bytes\n", MAX_BUF );
+       if (!SMPI_VARGET_GLOBAL(recvcounts)) fprintf(stderr,"\trecvcounts of %zd bytes\n", comm_size * sizeof(int) );
+       if (!SMPI_VARGET_GLOBAL(displs)) fprintf(stderr,"\tdispls of %zd bytes\n", comm_size * sizeof(int) );
         fflush(stderr);
         MPI_Abort(MPI_COMM_WORLD, -1);
         exit(-1);
@@ -109,13 +112,13 @@ int main(int argc, char ** argv)
     comm_tests(comm);
     MPI_Comm_free(&comm);
 
-    //free(sbuf);
-    //free(rbuf);
-    free(recvcounts);
-    free(displs);
+    //free(SMPI_VARGET_GLOBAL(sbuf));
+    //free(SMPI_VARGET_GLOBAL(rbuf));
+    free(SMPI_VARGET_GLOBAL(recvcounts));
+    free(SMPI_VARGET_GLOBAL(displs));
 
 fn_exit:
-    MTest_Finalize(errs);
+    MTest_Finalize(SMPI_VARGET_GLOBAL(errs));
     MPI_Finalize();
 
     return 0;
@@ -124,7 +127,8 @@ fn_exit:
 void comm_tests(MPI_Comm comm)
 {
     int comm_size, comm_rank;
-    double rtime, max_time;
+    double rtime = rtime;       /* stop warning about unused variable */
+    double max_time;
     long long msg_size;
 
     MPI_Comm_size(comm, &comm_size);
@@ -186,16 +190,16 @@ double run_test(long long msg_size, MPI_Comm comm, test_t test_type,
     MPI_Comm_size(comm, &comm_size);
     MPI_Comm_rank(comm, &comm_rank);
 
-    displs[0] = 0;
+    SMPI_VARGET_GLOBAL(displs)[0] = 0;
     for (i = 0; i < comm_size; i++) {
         if (test_type == REGULAR)
-            recvcounts[i] = msg_size;
+            SMPI_VARGET_GLOBAL(recvcounts)[i] = msg_size;
         else if (test_type == BCAST)
-            recvcounts[i] = (!i) ? msg_size : 0;
+            SMPI_VARGET_GLOBAL(recvcounts)[i] = (!i) ? msg_size : 0;
         else if (test_type == SPIKE)
-            recvcounts[i] = (!i) ? (msg_size / 2) : (msg_size / (2 * (comm_size - 1)));
+            SMPI_VARGET_GLOBAL(recvcounts)[i] = (!i) ? (msg_size / 2) : (msg_size / (2 * (comm_size - 1)));
         else if (test_type == HALF_FULL)
-            recvcounts[i] = (i < (comm_size / 2)) ? (2 * msg_size) : 0;
+            SMPI_VARGET_GLOBAL(recvcounts)[i] = (i < (comm_size / 2)) ? (2 * msg_size) : 0;
         else if (test_type == LINEAR_DECREASE) {
             tmp = 2 * msg_size * (comm_size - 1 - i) / (comm_size - 1);
            if (tmp != (int)tmp) {
@@ -203,7 +207,7 @@ double run_test(long long msg_size, MPI_Comm comm, test_t test_type,
                MPI_Abort( MPI_COMM_WORLD, 1 );
                 exit(1);
            }
-            recvcounts[i] = (int) tmp;
+            SMPI_VARGET_GLOBAL(recvcounts)[i] = (int) tmp;
 
             /* If the maximum message size is too large, don't run */
             if (tmp > MAX_BUF) return 0;
@@ -212,8 +216,8 @@ double run_test(long long msg_size, MPI_Comm comm, test_t test_type,
             for (j = 0; j < i; j++) {
                 if (i - 1 + j >= comm_size) continue;
                 tmp = msg_size * comm_size / (log(comm_size) * i);
-                recvcounts[i - 1 + j] = (int) tmp;
-                displs[i - 1 + j] = 0;
+                SMPI_VARGET_GLOBAL(recvcounts)[i - 1 + j] = (int) tmp;
+                SMPI_VARGET_GLOBAL(displs)[i - 1 + j] = 0;
 
                 /* If the maximum message size is too large, don't run */
                 if (tmp > MAX_BUF) return 0;
@@ -221,7 +225,7 @@ double run_test(long long msg_size, MPI_Comm comm, test_t test_type,
         }
 
         if (i < comm_size - 1)
-            displs[i+1] = displs[i] + recvcounts[i];
+            SMPI_VARGET_GLOBAL(displs)[i+1] = SMPI_VARGET_GLOBAL(displs)[i] + SMPI_VARGET_GLOBAL(recvcounts)[i];
     }
 
     /* Test that:
@@ -232,8 +236,8 @@ double run_test(long long msg_size, MPI_Comm comm, test_t test_type,
     MPI_Barrier(comm);
     start = MPI_Wtime();
     for (i = 0; i < LOOPS; i++) {
-        MPI_Allgatherv(sbuf, recvcounts[comm_rank], MPI_CHAR,
-                       rbuf, recvcounts, displs, MPI_CHAR, comm);
+        MPI_Allgatherv(SMPI_VARGET_GLOBAL(sbuf), SMPI_VARGET_GLOBAL(recvcounts)[comm_rank], MPI_CHAR,
+                       SMPI_VARGET_GLOBAL(rbuf), SMPI_VARGET_GLOBAL(recvcounts), SMPI_VARGET_GLOBAL(displs), MPI_CHAR, comm);
     }
     end = MPI_Wtime();
     MPI_Barrier(comm);
index fb513c3..2e96a9e 100644 (file)
@@ -93,9 +93,9 @@ int builtin_float_test(void)
 {
     int nints, nadds, ntypes, combiner;
 
-    int err, errs = 0;
+    int /* err, */ errs = 0;
 
-    err = MPI_Type_get_envelope(MPI_FLOAT,
+    /* err = */ MPI_Type_get_envelope(MPI_FLOAT,
                                &nints,
                                &nadds,
                                &ntypes,
@@ -324,17 +324,17 @@ int optimizable_vector_of_basics_test(void)
     MPI_Aint *adds = NULL;
     MPI_Datatype *types;
 
-    int err, errs = 0;
+    int /* err, */ errs = 0;
 
     /* set up type */
-    err = MPI_Type_vector(10,
+    /* err = */ MPI_Type_vector(10,
                          2,
                          2,
                          MPI_INT,
                          &parent_type);
 
     /* decode */
-    err = MPI_Type_get_envelope(parent_type,
+    /* err = */ MPI_Type_get_envelope(parent_type,
                                &nints,
                                &nadds,
                                &ntypes,
@@ -358,7 +358,7 @@ int optimizable_vector_of_basics_test(void)
     if (nadds) adds = malloc(nadds * sizeof(*adds));
     types = malloc(ntypes *sizeof(*types));
 
-    err = MPI_Type_get_contents(parent_type,
+    /* err = */ MPI_Type_get_contents(parent_type,
                                nints,
                                nadds,
                                ntypes,
@@ -407,17 +407,17 @@ int indexed_of_basics_test(void)
     MPI_Aint *adds = NULL;
     MPI_Datatype *types;
 
-    int err, errs = 0;
+    int /* err, */ errs = 0;
 
     /* set up type */
-    err = MPI_Type_indexed(s_count,
+    /* err = */ MPI_Type_indexed(s_count,
                           s_blocklengths,
                           s_displacements,
                           MPI_INT,
                           &parent_type);
 
     /* decode */
-    err = MPI_Type_get_envelope(parent_type,
+    /* err = */ MPI_Type_get_envelope(parent_type,
                                &nints,
                                &nadds,
                                &ntypes,
@@ -441,7 +441,7 @@ int indexed_of_basics_test(void)
     if (nadds) adds = malloc(nadds * sizeof(*adds));
     types = malloc(ntypes *sizeof(*types));
 
-    err = MPI_Type_get_contents(parent_type,
+    /* err = */ MPI_Type_get_contents(parent_type,
                                nints,
                                nadds,
                                ntypes,
index 66339f2..2230ac2 100644 (file)
@@ -30,7 +30,7 @@
 
       program main
       use mpi
-      integer errs, ierr, toterr
+      integer errs, ierr
       integer maxsize
       parameter (maxsize=1024)
       integer recvbuf
index 0fd3032..e922072 100644 (file)
@@ -7,6 +7,7 @@
 #include "mpi.h"
 #include "mpitestconf.h"
 #include "mpitest.h"
+#include "smpi_cocci.h"
 #if defined(HAVE_STDIO_H) || defined(STDC_HEADERS)
 #include <stdio.h>
 #endif
@@ -48,13 +49,13 @@ static void MTestResourceSummary( FILE * );
 /* Here is where we could put the includes and definitions to enable
    memory testing */
 
-static int dbgflag = 0;         /* Flag used for debugging */
-static int wrank = -1;          /* World rank */
-static int verbose = 0;         /* Message level (0 is none) */
-static int returnWithVal = 0;   /* Allow programs to return with a non-zero 
-                                  if there was an error (may cause problems
-                                  with some runtime systems) */
-static int usageOutput = 0;     /* */
+SMPI_VARINIT_GLOBAL_AND_SET(dbgflag, int, 0); /* Flag used for debugging */
+SMPI_VARINIT_GLOBAL_AND_SET(wrank, int, -1);  /* World rank */
+SMPI_VARINIT_GLOBAL_AND_SET(verbose, int, 0); /* Message level (0 is none) */
+SMPI_VARINIT_GLOBAL_AND_SET(returnWithVal, int, 0); /* Allow programs to return
+                                  with a non-zero if there was an error (may
+                                  cause problems with some runtime systems) */
+SMPI_VARINIT_GLOBAL_AND_SET(usageOutput, int, 0); /* */
 
 /* Provide backward portability to MPI 1 */
 #ifndef MPI_VERSION
@@ -98,8 +99,8 @@ void MTest_Init_thread( int *argc, char ***argv, int required, int *provided )
     }
     /* Check for debugging control */
     if (getenv( "MPITEST_DEBUG" )) {
-       dbgflag = 1;
-       MPI_Comm_rank( MPI_COMM_WORLD, &wrank );
+       SMPI_VARGET_GLOBAL(dbgflag) = 1;
+       MPI_Comm_rank( MPI_COMM_WORLD, &SMPI_VARGET_GLOBAL(wrank) );
     }
 
     /* Check for verbose control */
@@ -115,7 +116,7 @@ void MTest_Init_thread( int *argc, char ***argv, int required, int *provided )
        }
        else {
            if (val >= 0) {
-               verbose = val;
+               SMPI_VARGET_GLOBAL(verbose) = val;
            }
            else {
                fprintf( stderr, "Warning: %s not valid for MPITEST_VERBOSE\n", 
@@ -131,13 +132,13 @@ void MTest_Init_thread( int *argc, char ***argv, int required, int *provided )
            strcmp( envval, "YES" ) == 0 ||
            strcmp( envval, "true" ) == 0 ||
            strcmp( envval, "TRUE" ) == 0) {
-           returnWithVal = 1;
+           SMPI_VARGET_GLOBAL(returnWithVal) = 1;
        }
        else if (strcmp( envval, "no" ) == 0 ||
            strcmp( envval, "NO" ) == 0 ||
            strcmp( envval, "false" ) == 0 ||
            strcmp( envval, "FALSE" ) == 0) {
-           returnWithVal = 0;
+           SMPI_VARGET_GLOBAL(returnWithVal) = 0;
        }
        else {
            fprintf( stderr, 
@@ -149,7 +150,7 @@ void MTest_Init_thread( int *argc, char ***argv, int required, int *provided )
     
     /* Print rusage data if set */
     if (getenv( "MPITEST_RUSAGE" )) {
-       usageOutput = 1;
+       SMPI_VARGET_GLOBAL(usageOutput) = 1;
     }
 }
 /* 
@@ -219,7 +220,7 @@ void MTest_Finalize( int errs )
        fflush( stdout );
     }
     
-    if (usageOutput) 
+    if (SMPI_VARGET_GLOBAL(usageOutput))
        MTestResourceSummary( stdout );
 
 
@@ -232,7 +233,7 @@ void MTest_Finalize( int errs )
  */
 int MTestReturnValue( int errors )
 {
-    if (returnWithVal) return errors ? 1 : 0;
+    if (SMPI_VARGET_GLOBAL(returnWithVal)) return errors ? 1 : 0;
     return 0;
 }
 /* ------------------------------------------------------------------------ */
@@ -277,7 +278,7 @@ void MTestSleep( int sec )
  *    Indexed  - Indexed datatype.  Only for a count of 1 instance of the 
  *               datatype
  */
-static int datatype_index = 0;
+SMPI_VARINIT_GLOBAL_AND_SET(datatype_index, int, 0);
 
 /* ------------------------------------------------------------------------ */
 /* Datatype routines for contiguous datatypes                               */
@@ -636,7 +637,7 @@ int MTestGetDatatypes( MTestDatatype *sendtype, MTestDatatype *recvtype,
     recvtype->count      = count;
     /* Use datatype_index to choose a datatype to use.  If at the end of the
        list, return 0 */
-    switch (datatype_index) {
+    switch (SMPI_VARGET_GLOBAL(datatype_index)) {
     case 0:
        sendtype->datatype = MPI_INT;
        sendtype->isBasic  = 1;
@@ -858,7 +859,7 @@ int MTestGetDatatypes( MTestDatatype *sendtype, MTestDatatype *recvtype,
        break;
 #endif
     default:
-       datatype_index = -1;
+       SMPI_VARGET_GLOBAL(datatype_index) = -1;
     }
 
     if (!sendtype->InitBuf) {
@@ -869,29 +870,29 @@ int MTestGetDatatypes( MTestDatatype *sendtype, MTestDatatype *recvtype,
        sendtype->CheckBuf = MTestTypeContigCheckbuf;
        recvtype->CheckBuf = MTestTypeContigCheckbuf;
     }
-    datatype_index++;
+    SMPI_VARGET_GLOBAL(datatype_index)++;
 
-    if (dbgflag && datatype_index > 0) {
+    if (SMPI_VARGET_GLOBAL(dbgflag) && SMPI_VARGET_GLOBAL(datatype_index) > 0) {
        int typesize;
-       fprintf( stderr, "%d: sendtype is %s\n", wrank, MTestGetDatatypeName( sendtype ) );
+       fprintf( stderr, "%d: sendtype is %s\n", SMPI_VARGET_GLOBAL(wrank), MTestGetDatatypeName( sendtype ) );
        merr = MPI_Type_size( sendtype->datatype, &typesize );
        if (merr) MTestPrintError( merr );
-       fprintf( stderr, "%d: sendtype size = %d\n", wrank, typesize );
-       fprintf( stderr, "%d: recvtype is %s\n", wrank, MTestGetDatatypeName( recvtype ) );
+       fprintf( stderr, "%d: sendtype size = %d\n", SMPI_VARGET_GLOBAL(wrank), typesize );
+       fprintf( stderr, "%d: recvtype is %s\n", SMPI_VARGET_GLOBAL(wrank), MTestGetDatatypeName( recvtype ) );
        merr = MPI_Type_size( recvtype->datatype, &typesize );
        if (merr) MTestPrintError( merr );
-       fprintf( stderr, "%d: recvtype size = %d\n", wrank, typesize );
+       fprintf( stderr, "%d: recvtype size = %d\n", SMPI_VARGET_GLOBAL(wrank), typesize );
        fflush( stderr );
        
     }
-    else if (verbose && datatype_index > 0) {
+    else if (SMPI_VARGET_GLOBAL(verbose) && SMPI_VARGET_GLOBAL(datatype_index) > 0) {
        printf( "Get new datatypes: send = %s, recv = %s\n", 
                MTestGetDatatypeName( sendtype ), 
                MTestGetDatatypeName( recvtype ) );
        fflush( stdout );
     }
 
-    return datatype_index;
+    return SMPI_VARGET_GLOBAL(datatype_index);
 }
 
 /* Reset the datatype index (start from the initial data type.
@@ -900,13 +901,13 @@ int MTestGetDatatypes( MTestDatatype *sendtype, MTestDatatype *recvtype,
 */
 void MTestResetDatatypes( void )
 {
-    datatype_index = 0;
+    SMPI_VARGET_GLOBAL(datatype_index) = 0;
 }
 /* Return the index of the current datatype.  This is rarely needed and
    is provided mostly to enable debugging of the MTest package itself */
 int MTestGetDatatypeIndex( void )
 {
-    return datatype_index;
+    return SMPI_VARGET_GLOBAL(datatype_index);
 }
 
 /* Free the storage associated with a datatype */
@@ -953,14 +954,15 @@ int MTestCheckRecv( MPI_Status *status, MTestDatatype *recvtype )
    simplify the use of the routine */
 const char *MTestGetDatatypeName( MTestDatatype *dtype )
 {
-    static char name[4][MPI_MAX_OBJECT_NAME];
-    static int sp=0;
+    typedef char name_type[4][MPI_MAX_OBJECT_NAME];
+    SMPI_VARINIT_STATIC(name, name_type);
+    SMPI_VARINIT_STATIC_AND_SET(sp, int, 0);
     int rlen, merr;
 
-    if (sp >= 4) sp = 0;
-    merr = MPI_Type_get_name( dtype->datatype, name[sp], &rlen );
+    if (SMPI_VARGET_STATIC(sp) >= 4) SMPI_VARGET_STATIC(sp) = 0;
+    merr = MPI_Type_get_name( dtype->datatype, SMPI_VARGET_STATIC(name)[SMPI_VARGET_STATIC(sp)], &rlen );
     if (merr) MTestPrintError( merr );
-    return (const char *)name[sp++];
+    return (const char *)SMPI_VARGET_STATIC(name)[SMPI_VARGET_STATIC(sp)++];
 }
 /* ----------------------------------------------------------------------- */
 
@@ -971,10 +973,10 @@ const char *MTestGetDatatypeName( MTestDatatype *dtype )
  * that return value as well.
  * 
  */
-static __thread int interCommIdx = 0;
-static __thread int intraCommIdx = 0;
-static __thread const char *intraCommName = 0;
-static __thread const char *interCommName = 0;
+SMPI_VARINIT_GLOBAL_AND_SET(interCommIdx, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(intraCommIdx, int, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(intraCommName, const char *, 0);
+SMPI_VARINIT_GLOBAL_AND_SET(interCommName, const char *, 0);
 
 /* 
  * Get an intracommunicator with at least min_size members.  If "allowSmaller"
@@ -992,18 +994,18 @@ int MTestGetIntracommGeneral( MPI_Comm *comm, int min_size, int allowSmaller )
        MPI_COMM_NULL is always considered large enough */
     while (!done) {
        isBasic = 0;
-       intraCommName = "";
-       switch (intraCommIdx) {
+       SMPI_VARGET_GLOBAL(intraCommName) = "";
+       switch (SMPI_VARGET_GLOBAL(intraCommIdx)) {
        case 0:
            *comm = MPI_COMM_WORLD;
            isBasic = 1;
-           intraCommName = "MPI_COMM_WORLD";
+           SMPI_VARGET_GLOBAL(intraCommName) = "MPI_COMM_WORLD";
            break;
        case 1:
            /* dup of world */
            merr = MPI_Comm_dup(MPI_COMM_WORLD, comm );
            if (merr) MTestPrintError( merr );
-           intraCommName = "Dup of MPI_COMM_WORLD";
+           SMPI_VARGET_GLOBAL(intraCommName) = "Dup of MPI_COMM_WORLD";
            break;
        case 2:
            /* reverse ranks */
@@ -1013,7 +1015,7 @@ int MTestGetIntracommGeneral( MPI_Comm *comm, int min_size, int allowSmaller )
            if (merr) MTestPrintError( merr );
            merr = MPI_Comm_split( MPI_COMM_WORLD, 0, size-rank, comm );
            if (merr) MTestPrintError( merr );
-           intraCommName = "Rank reverse of MPI_COMM_WORLD";
+           SMPI_VARGET_GLOBAL(intraCommName) = "Rank reverse of MPI_COMM_WORLD";
            break;
        case 3:
            /* subset of world, with reversed ranks */
@@ -1024,12 +1026,12 @@ int MTestGetIntracommGeneral( MPI_Comm *comm, int min_size, int allowSmaller )
            merr = MPI_Comm_split( MPI_COMM_WORLD, ((rank < size/2) ? 1 : MPI_UNDEFINED),
                                   size-rank, comm );
            if (merr) MTestPrintError( merr );
-           intraCommName = "Rank reverse of half of MPI_COMM_WORLD";
+           SMPI_VARGET_GLOBAL(intraCommName) = "Rank reverse of half of MPI_COMM_WORLD";
            break;
        case 4:
            *comm = MPI_COMM_SELF;
            isBasic = 1;
-           intraCommName = "MPI_COMM_SELF";
+           SMPI_VARGET_GLOBAL(intraCommName) = "MPI_COMM_SELF";
            break;
 
            /* These next cases are communicators that include some
@@ -1042,7 +1044,7 @@ int MTestGetIntracommGeneral( MPI_Comm *comm, int min_size, int allowSmaller )
            int newsize;
            merr = MPI_Comm_size( MPI_COMM_WORLD, &size );
            if (merr) MTestPrintError( merr );
-           newsize = size - (intraCommIdx - 4);
+           newsize = size - (SMPI_VARGET_GLOBAL(intraCommIdx) - 4);
            
            if (allowSmaller && newsize >= min_size) {
                merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank );
@@ -1056,13 +1058,13 @@ int MTestGetIntracommGeneral( MPI_Comm *comm, int min_size, int allowSmaller )
                    *comm = MPI_COMM_NULL;
                }
                else {
-                   intraCommName = "Split of WORLD";
+                   SMPI_VARGET_GLOBAL(intraCommName) = "Split of WORLD";
                }
            }
            else {
                /* Act like default */
                *comm = MPI_COMM_NULL;
-               intraCommIdx = -1;
+               SMPI_VARGET_GLOBAL(intraCommIdx) = -1;
            }
        }
        break;
@@ -1070,7 +1072,7 @@ int MTestGetIntracommGeneral( MPI_Comm *comm, int min_size, int allowSmaller )
            /* Other ideas: dup of self, cart comm, graph comm */
        default:
            *comm = MPI_COMM_NULL;
-           intraCommIdx = -1;
+           SMPI_VARGET_GLOBAL(intraCommIdx) = -1;
            break;
        }
 
@@ -1081,7 +1083,7 @@ int MTestGetIntracommGeneral( MPI_Comm *comm, int min_size, int allowSmaller )
                done = 1;
        }
         else {
-            intraCommName = "MPI_COMM_NULL";
+            SMPI_VARGET_GLOBAL(intraCommName) = "MPI_COMM_NULL";
             isBasic = 1;
             done = 1;
         }
@@ -1092,7 +1094,7 @@ done2=done;
         /* Advance the comm index whether we are done or not, otherwise we could
          * spin forever trying to allocate a too-small communicator over and
          * over again. */
-        intraCommIdx++;
+        SMPI_VARGET_GLOBAL(intraCommIdx)++;
 
         if (!done && !isBasic && *comm != MPI_COMM_NULL) {
             /* avoid leaking communicators */
@@ -1101,7 +1103,7 @@ done2=done;
         }
     }
 
-    return intraCommIdx;
+    return SMPI_VARGET_GLOBAL(intraCommIdx);
 }
 
 /* 
@@ -1115,7 +1117,7 @@ int MTestGetIntracomm( MPI_Comm *comm, int min_size )
 /* Return the name of an intra communicator */
 const char *MTestGetIntracommName( void )
 {
-    return intraCommName;
+    return SMPI_VARGET_GLOBAL(intraCommName);
 }
 
 /* 
@@ -1136,9 +1138,9 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
     while (!done) {
         *comm = MPI_COMM_NULL;
         *isLeftGroup = 0;
-        interCommName = "MPI_COMM_NULL";
+        SMPI_VARGET_GLOBAL(interCommName) = "MPI_COMM_NULL";
 
-       switch (interCommIdx) {
+       switch (SMPI_VARGET_GLOBAL(interCommIdx)) {
        case 0:
            /* Split comm world in half */
            merr = MPI_Comm_rank( MPI_COMM_WORLD, &rank );
@@ -1164,7 +1166,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
                merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader,
                                             12345, comm );
                if (merr) MTestPrintError( merr );
-               interCommName = "Intercomm by splitting MPI_COMM_WORLD";
+               SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD";
            }
            else 
                *comm = MPI_COMM_NULL;
@@ -1194,7 +1196,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
                merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, 
                                             rleader, 12346, comm );
                if (merr) MTestPrintError( merr );
-               interCommName = "Intercomm by splitting MPI_COMM_WORLD into 1, rest";
+               SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD into 1, rest";
            }
            else
                *comm = MPI_COMM_NULL;
@@ -1225,7 +1227,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
                merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, 
                                             rleader, 12347, comm );
                if (merr) MTestPrintError( merr );
-               interCommName = "Intercomm by splitting MPI_COMM_WORLD into 2, rest";
+               SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD into 2, rest";
            }
            else 
                *comm = MPI_COMM_NULL;
@@ -1264,7 +1266,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
                mcomm = *comm;
                merr = MPI_Comm_dup(mcomm, comm);
                if (merr) MTestPrintError( merr );
-               interCommName = "Intercomm by splitting MPI_COMM_WORLD then dup'ing";
+               SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD then dup'ing";
            }
            else 
                *comm = MPI_COMM_NULL;
@@ -1306,7 +1308,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
                /* this split is effectively a dup but tests the split code paths */
                merr = MPI_Comm_split(mcomm, 0, rank, comm);
                if (merr) MTestPrintError( merr );
-               interCommName = "Intercomm by splitting MPI_COMM_WORLD then then splitting again";
+               SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD then then splitting again";
            }
            else
                *comm = MPI_COMM_NULL;
@@ -1343,7 +1345,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
                     merr = MPI_Intercomm_create( mcomm, 0, MPI_COMM_WORLD, rleader, 12345, comm );
                     if (merr) MTestPrintError( merr );
                 }
-                interCommName = "Intercomm by splitting MPI_COMM_WORLD (discarding rank 0 in the left group) then MPI_Intercomm_create'ing";
+                SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD (discarding rank 0 in the left group) then MPI_Intercomm_create'ing";
             }
             else {
                 *comm = MPI_COMM_NULL;
@@ -1396,7 +1398,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
                 merr = MPI_Group_free(&newgroup);
                 if (merr) MTestPrintError( merr );
 
-                interCommName = "Intercomm by splitting MPI_COMM_WORLD then discarding 0 ranks with MPI_Comm_create";
+                SMPI_VARGET_GLOBAL(interCommName) = "Intercomm by splitting MPI_COMM_WORLD then discarding 0 ranks with MPI_Comm_create";
             }
             else {
                 *comm = MPI_COMM_NULL;
@@ -1405,7 +1407,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
 
        default:
            *comm = MPI_COMM_NULL;
-           interCommIdx = -1;
+           SMPI_VARGET_GLOBAL(interCommIdx) = -1;
            break;
        }
 
@@ -1417,7 +1419,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
            if (size + remsize >= min_size) done = 1;
        }
        else {
-           interCommName = "MPI_COMM_NULL";
+           SMPI_VARGET_GLOBAL(interCommName) = "MPI_COMM_NULL";
            done = 1;
         }
 
@@ -1427,7 +1429,7 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
         /* Advance the comm index whether we are done or not, otherwise we could
          * spin forever trying to allocate a too-small communicator over and
          * over again. */
-        interCommIdx++;
+        SMPI_VARGET_GLOBAL(interCommIdx)++;
 
         if (!done && *comm != MPI_COMM_NULL) {
             /* avoid leaking communicators */
@@ -1446,12 +1448,12 @@ int MTestGetIntercomm( MPI_Comm *comm, int *isLeftGroup, int min_size )
         }
     }
 
-    return interCommIdx;
+    return SMPI_VARGET_GLOBAL(interCommIdx);
 }
 /* Return the name of an intercommunicator */
 const char *MTestGetIntercommName( void )
 {
-    return interCommName;
+    return SMPI_VARGET_GLOBAL(interCommName);
 }
 
 /* Get a communicator of a given minimum size.  Both intra and inter 
@@ -1459,19 +1461,19 @@ const char *MTestGetIntercommName( void )
 int MTestGetComm( MPI_Comm *comm, int min_size )
 {
     int idx=0;
-    static __thread int getinter = 0;
+    SMPI_VARINIT_STATIC_AND_SET(getinter, int, 0);
 
-    if (!getinter) {
+    if (!SMPI_VARGET_STATIC(getinter)) {
        idx = MTestGetIntracomm( comm, min_size );
        if (idx == 0) {
-           getinter = 1;
+           SMPI_VARGET_STATIC(getinter) = 1;
        }
     }
-    if (getinter) {
+    if (SMPI_VARGET_STATIC(getinter)) {
        int isLeft;
        idx = MTestGetIntercomm( comm, &isLeft, min_size );
        if (idx == 0) {
-           getinter = 0;
+           SMPI_VARGET_STATIC(getinter) = 0;
        }
     }
 
@@ -1521,7 +1523,7 @@ void MTestPrintfMsg( int level, const char format[], ... )
 {
     va_list list;
 
-    if (verbose && level >= verbose) {
+    if (SMPI_VARGET_GLOBAL(verbose) && level >= SMPI_VARGET_GLOBAL(verbose)) {
        va_start(list,format);
        vprintf( format, list );
        va_end(list);
@@ -1541,20 +1543,20 @@ static void MTestResourceSummary( FILE *fp )
 {
 #ifdef HAVE_GETRUSAGE
     struct rusage ru;
-    static __thread int pfThreshold = -2;
+    SMPI_VARINIT_STATIC_AND_SET(pfThreshold, int, -2);
     int doOutput = 1;
     if (getrusage( RUSAGE_SELF, &ru ) == 0) {
        /* There is an option to generate output only when a resource
           exceeds a threshold.  To date, only page faults supported. */
-       if (pfThreshold == -2) {
+       if (SMPI_VARGET_STATIC(pfThreshold) == -2) {
            char *p = getenv("MPITEST_RUSAGE_PF");
-           pfThreshold = -1;
+           SMPI_VARGET_STATIC(pfThreshold) = -1;
            if (p) {
-               pfThreshold = strtol( p, 0, 0 );
+               SMPI_VARGET_STATIC(pfThreshold) = strtol( p, 0, 0 );
            }
        }
-       if (pfThreshold > 0) {
-           doOutput = ru.ru_minflt > pfThreshold;
+       if (SMPI_VARGET_STATIC(pfThreshold) > 0) {
+           doOutput = ru.ru_minflt > SMPI_VARGET_STATIC(pfThreshold);
        }
        if (doOutput) {
            /* Cast values to long in case some system has defined them
@@ -1582,47 +1584,48 @@ static void MTestResourceSummary( FILE *fp )
 /*
  * Create MPI Windows
  */
-static __thread int win_index = 0;
-static const char *winName;
+SMPI_VARINIT_GLOBAL_AND_SET(win_index, int, 0);
+SMPI_VARINIT_GLOBAL(winName, const char *);
 /* Use an attribute to remember the type of memory allocation (static,
    malloc, or MPI_Alloc_mem) */
-static __thread int mem_keyval = MPI_KEYVAL_INVALID;
+SMPI_VARINIT_GLOBAL_AND_SET(mem_keyval, int, MPI_KEYVAL_INVALID);
 int MTestGetWin( MPI_Win *win, int mustBePassive )
 {
-    static char actbuf[1024];
-    static char *pasbuf;
+    typedef char actbuf_type[1024];
+    SMPI_VARINIT_STATIC(actbuf, actbuf_type);
+    SMPI_VARINIT_STATIC(pasbuf, char *);
     char        *buf;
     int         n, rank, merr;
     MPI_Info    info;
 
-    if (mem_keyval == MPI_KEYVAL_INVALID) {
+    if (SMPI_VARGET_GLOBAL(mem_keyval) == MPI_KEYVAL_INVALID) {
        /* Create the keyval */
        merr = MPI_Win_create_keyval( MPI_WIN_NULL_COPY_FN, 
                                      MPI_WIN_NULL_DELETE_FN, 
-                                     &mem_keyval, 0 );
+                                     &SMPI_VARGET_GLOBAL(mem_keyval), 0 );
        if (merr) MTestPrintError( merr );
 
     }
 
-    switch (win_index) {
+    switch (SMPI_VARGET_GLOBAL(win_index)) {
     case 0:
        /* Active target window */
-       merr = MPI_Win_create( actbuf, 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD, 
+       merr = MPI_Win_create( SMPI_VARGET_STATIC(actbuf), 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD,
                               win );
        if (merr) MTestPrintError( merr );
-       winName = "active-window";
-       merr = MPI_Win_set_attr( *win, mem_keyval, (void *)0 );
+       SMPI_VARGET_GLOBAL(winName) = "active-window";
+       merr = MPI_Win_set_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), (void *)0 );
        if (merr) MTestPrintError( merr );
        break;
     case 1:
        /* Passive target window */
-       merr = MPI_Alloc_mem( 1024, MPI_INFO_NULL, &pasbuf );
+       merr = MPI_Alloc_mem( 1024, MPI_INFO_NULL, &SMPI_VARGET_STATIC(pasbuf) );
        if (merr) MTestPrintError( merr );
-       merr = MPI_Win_create( pasbuf, 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD, 
+       merr = MPI_Win_create( SMPI_VARGET_STATIC(pasbuf), 1024, 1, MPI_INFO_NULL, MPI_COMM_WORLD,
                               win );
        if (merr) MTestPrintError( merr );
-       winName = "passive-window";
-       merr = MPI_Win_set_attr( *win, mem_keyval, (void *)2 );
+       SMPI_VARGET_GLOBAL(winName) = "passive-window";
+       merr = MPI_Win_set_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), (void *)2 );
        if (merr) MTestPrintError( merr );
        break;
     case 2:
@@ -1637,8 +1640,8 @@ int MTestGetWin( MPI_Win *win, int mustBePassive )
        merr = MPI_Win_create( buf, n, 1, MPI_INFO_NULL, MPI_COMM_WORLD, 
                               win );
        if (merr) MTestPrintError( merr );
-       winName = "active-all-different-win";
-       merr = MPI_Win_set_attr( *win, mem_keyval, (void *)1 );
+       SMPI_VARGET_GLOBAL(winName) = "active-all-different-win";
+       merr = MPI_Win_set_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), (void *)1 );
        if (merr) MTestPrintError( merr );
        break;
     case 3:
@@ -1658,20 +1661,20 @@ int MTestGetWin( MPI_Win *win, int mustBePassive )
        if (merr) MTestPrintError( merr );
        merr = MPI_Info_free( &info );
        if (merr) MTestPrintError( merr );
-       winName = "active-nolocks-all-different-win";
-       merr = MPI_Win_set_attr( *win, mem_keyval, (void *)1 );
+       SMPI_VARGET_GLOBAL(winName) = "active-nolocks-all-different-win";
+       merr = MPI_Win_set_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), (void *)1 );
        if (merr) MTestPrintError( merr );
        break;
     default:
-       win_index = -1;
+       SMPI_VARGET_GLOBAL(win_index) = -1;
     }
-    win_index++;
-    return win_index;
+    SMPI_VARGET_GLOBAL(win_index)++;
+    return SMPI_VARGET_GLOBAL(win_index);
 }
 /* Return a pointer to the name associated with a window object */
 const char *MTestGetWinName( void )
 {
-    return winName;
+    return SMPI_VARGET_GLOBAL(winName);
 }
 /* Free the storage associated with a window object */
 void MTestFreeWin( MPI_Win *win )
@@ -1686,7 +1689,7 @@ void MTestFreeWin( MPI_Win *win )
     }
     if (addr) {
        void *val;
-       merr = MPI_Win_get_attr( *win, mem_keyval, &val, &flag );
+       merr = MPI_Win_get_attr( *win, SMPI_VARGET_GLOBAL(mem_keyval), &val, &flag );
        if (merr) MTestPrintError( merr );
        if (flag) {
            if (val == (void *)1) {
@@ -1704,8 +1707,8 @@ void MTestFreeWin( MPI_Win *win )
 }
 static void MTestRMACleanup( void )
 {
-    if (mem_keyval != MPI_KEYVAL_INVALID) {
-       MPI_Win_free_keyval( &mem_keyval );
+    if (SMPI_VARGET_GLOBAL(mem_keyval) != MPI_KEYVAL_INVALID) {
+       MPI_Win_free_keyval( &SMPI_VARGET_GLOBAL(mem_keyval) );
     }
 }
 #else 
index 6112c8f..629089f 100644 (file)
@@ -43,5 +43,6 @@
 
 + tools/check_dist_archive
 + tools/check_dist_archive\.exclude
++ tools/normalize-pointers\.py
 
 + tools/spell/.*