\li ccmake for graphical used of CMake
\li cmake <a href="http://www.cmake.org/cmake/resources/software.html">(download page)</a>
-For windows only :
- \li Visual C++ 2010 Express <a href="http://www.microsoft.com/express/Downloads/#2010-Visual-CPP">(download page)</a>
- \li cmake <a href="http://www.cmake.org/cmake/resources/software.html">(download page)</a>
- \li Set CC, CXX, INCLUDE, LIB and RC to environment variables.
-\verbatim
-SET --> CC TO --> C:\MicrosoftVisualStudio10\VC\bin\cl
- --> CXX --> C:\MicrosoftVisualStudio10\VC\bin\cl
- --> INCLUDE --> C:\MicrosoftVisualStudio10\VC\include;C:\Program Files\Microsoft SDKs\Windows\v7.OA\Include
- --> LIB --> C:\MicrosoftVisualStudio10\VC\lib;C:\Program Files\Microsoft SDKs\Windows\v7.OA\Lib
- --> RC --> C:\Program Files\Microsoft SDKs\Windows\v7.OA\bin\RC
-\endverbatim
- \li Add to environment variable "Path" the path where to find nmake executable and some needed files.
-\verbatim
-......
-;C\MicrosoftVisualStudio10\VC\bin
-;C\MicrosoftVisualStudio10\Common7\IDE
-;C:\Program Files\Microsoft SDKs\Windows\v7.OA\bin
-;C:\Program Files\Microsoft SDKs\Windows\v7.OA\Lib
-;C:\Program Files\Microsoft SDKs\Windows\v7.OA\bInclude
-\endverbatim
-\subsection faq_cmakeoption Cmake options
-
\subsubsection faq_cmakeoption1 Liste of options
\verbatim
\subsubsection faq_cmakeinstall2 From a distrib
\verbatim
-cmake -Dprefix=/home/navarrop/Bureau/install_simgrid ./
-make
-make install
+For version 3.4.1 and 3.4
+ cmake -Dprefix=/home/navarrop/Bureau/install_simgrid ./
+ make
+ make install-simgrid
+Since version 3.5
+ cmake -Dprefix=/home/navarrop/Bureau/install_simgrid ./
+ make
+ make install
\endverbatim
\subsection faq_cmakehowto How to modified sources files for developers
cmake_minimum_required(VERSION 2.6)
set(EXECUTABLE_OUTPUT_PATH "./")
-set(LIBRARY_OUTPUT_PATH "${PROJECT_DIRECTORY}/lib")
+set(LIBRARY_OUTPUT_PATH "${CMAKE_HOME_DIRECTORY}/lib")
add_executable(get_sender get_sender.c) #add_executable(<name_of_target> <src list>)
### Add definitions for compile
-target_link_libraries(get_sender simgrid m pthread -fprofile-arcs) #target_link_libraries(<name_of_targe> <dependencies>)
+target_link_libraries(get_sender simgrid m pthread) #target_link_libraries(<name_of_targe> <dependencies>)
\endverbatim
Then you have to modified <project/directory>/buildtools/Cmake/MakeExeLib.cmake and add
this line :
\verbatim
-add_subdirectory(${
PROJECT_DIRECTORY}/<path_where_is_CMakeList.txt>)
+add_subdirectory(${
CMAKE_HOME_DIRECTORY}/<path_where_is_CMakeList.txt>)
\endverbatim
\subsubsection faq_cmakehowto2 Delete/add sources to lib.
\verbatim
set(JMSG_JAVA_SRC
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/MsgException.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/JniException.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/NativeException.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/HostNotFoundException.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/ProcessNotFoundException.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/Msg.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/Process.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/Host.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/Task.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/MsgNative.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/ApplicationHandler.java
- ${PROJECT_DIRECTORY}/src/java/simgrid/msg/Sem.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/MsgException.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/JniException.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/NativeException.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/HostNotFoundException.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/ProcessNotFoundException.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/Msg.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/Process.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/Host.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/Task.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/MsgNative.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/ApplicationHandler.java
+ ${CMAKE_HOME_DIRECTORY}/src/java/simgrid/msg/Sem.java
)
\endverbatim
with this function : ADD_TEST(<name> <bin> <ARGS>)
\verbatim
-add_test(test-simdag-1 ${PROJECT_DIRECTORY}/testsuite/simdag/sd_test --cfg=path:${PROJECT_DIRECTORY}/testsuite/simdag small_platform_variable.xml)
+add_test(test-simdag-1 ${CMAKE_HOME_DIRECTORY}/testsuite/simdag/sd_test --cfg=path:${CMAKE_HOME_DIRECTORY}/testsuite/simdag small_platform_variable.xml)
\endverbatim
\subsection faq_PIPOL Pipol-remote
<tt>tools/platform_generation/</tt> directory of the SVN. Dinda et Al.
released a very comparable tool, and called it GridG.
-\subsubsection faq_SURF_dynamic Expressing dynamic resource availability in platform files
+\subsubsection faq_SURF_multicore Modeling multi-core resources
+
+There is currently no native support for multi-core or SMP machines in
+SimGrid. We are currently working on it, but coming up with the right
+model is very hard: Cores share caches and bus to access memory and
+thus interfere with each others. Memory contention is a crucial
+component of multi-core modeling.
+
+In the meanwhile, some user-level tricks can reveal sufficient for
+you. For example, you may model each core by a CPU and add some very
+high speed links between them. This complicates a bit the user code
+since you have to remember that when you assign something to a (real)
+host, it can be any of the (fake) hosts representing the cores of a
+given machine. For that, you can use the prop tag of the XML files as
+follows. Your code should then look at the ‘machine’ property
+associated with each workstation, and run parallel tasks over all
+cores of the machine.
+
+\verbatim
+ <host id="machine0/core0" power="91500E6">
+ <prop id="machine" value="machine0"/>
+ <prop id="core" value="0"/>
+ </host>
+ <host id="machine0/core1" power="91500E6">
+ <prop id="machine" value="machine0"/>
+ <prop id="core" value="1"/>
+</host>
+
+
+\endverbatim
+
+\subsubsection faq_SURF_dynamic Modeling dynamic resource availability
A nice feature of SimGrid is that it enables you to seamlessly have
resources whose availability change over time. When you build a
two-step fashion: the user instruments the application and the traces are
analyzed after the end of the execution. The visualization itself can highlights
unexpected behaviors, bottlenecks and sometimes can be used to correct
-distributed algorithms. The SimGrid team is currently instrumenting the library
+distributed algorithms. The SimGrid team has instrumented the library
in order to let users trace their simulations and analyze them. This part of the
user manual explains how the tracing-related features can be enabled and used
during the development of simulators using the SimGrid library.
\subsubsection faq_tracing_howitworks How it works
For now, the SimGrid library is instrumented so users can trace the <b>platform
-utilization</b> using the MSG interface. This means that the tracing will
+utilization</b> using the MSG, SimDAG and SMPI interface. This means that the tracing will
register how much power is used for each host and how much bandwidth is used for
each link of the platform. The idea with this type of tracing is to observe the
overall view of resources utilization in the first place, especially the
identification of bottlenecks, load-balancing among hosts, and so on.
-The idea of the instrumentation is to classify the MSG tasks by category,
-and trace
-the platform utilization (hosts and links) for each of the categories. For that,
+The idea of the tracing facilities is to give SimGrid users to possibility to
+classify MSG and SimDAG tasks by category, tracing the platform utilization
+(hosts and links) for each of the categories. For that,
the tracing interface enables the declaration of categories and a function to
mark a task with a previously declared category. <em>The tasks that are not
-classified according to a category are not traced</em>.
+classified according to a category are not traced</em>. Even if the user
+does not specify any category, the simulations can still be traced in terms
+of resource utilization by using a special parameter that is detailed below.
\subsubsection faq_tracing_enabling Enabling using CMake
With the sources of SimGrid, it is possible to enable the tracing
-using the parameter <b>-Dtracing=on</b> when the cmake is executed.
+using the parameter <b>-Denable_tracing=ON</b> when the cmake is executed.
The section \ref faq_tracing_functions describes all the functions available
when this Cmake options is activated. These functions will have no effect
if SimGrid is configured without this option (they are wiped-out by the
C-preprocessor).
\verbatim
-$ cmake -Dtracing=on .
+$ cmake -Denable_tracing=ON .
$ make
\endverbatim
\subsubsection faq_tracing_functions Tracing Functions
-\subsubsubsection Mandatory Functions
-
-\li <b>\c TRACE_start ()</b>: This is the first function to
-be called. It returns 0 if everything was properly initialized, 1 otherwise.
-All trace functions called before TRACE_start do nothing.
-
\li <b>\c TRACE_category (const char *category)</b>: This function should be used
to define a user category. The category can be used to differentiate the tasks
that are created during the simulation (for example, tasks from server1,
category are not traced.
\li <b>\c TRACE_msg_set_task_category (m_task_t task, const char *category)</b>:
-This function should be called after the creation of a task, to define the
+This function should be called after the creation of a MSG task, to define the
category of that task. The first parameter \c task must contain a task that was
created with the function \c MSG_task_create. The second parameter
\c category must contain a category that was previously defined by the function
\c TRACE_category.
-\li <b>\c TRACE_end ()</b>: This is the last function to be called. It closes
-the trace file and stops the tracing of the simulation. All tracing will be
-completely disabled after the calling this function. Although we recommend
-the use of this function somewhere in the end of program, it can be used
-anywhere in the code. This function returns 0 if everything is ok, 1 otherwise.
-
-\subsubsubsection Optional Functions
+\li <b>\c TRACE_sd_set_task_category (SD_task_t task, const char *category)</b>:
+This function should be called after the creation of a SimDAG task, to define the
+category of that task. The first parameter \c task must contain a task that was
+created with the function \c MSG_task_create. The second parameter
+\c category must contain a category that was previously defined by the function
+\c TRACE_category.
\li <b>\c TRACE_host_variable_declare (const char *variable)</b>:
Declare a user variable that will be associated to hosts. A variable can
These are the options accepted by the tracing system of SimGrid:
-\li <b>\c tracing/filename</b>: use this to specify the name of the trace file
-that will be created during the simulation. For example, after the binary
-of your simulator, you can pass as parameter this:
-\verbatim
---cfg=tracing/filename:mytracefile.trace
-\endverbatim
-in order to trace the behavior of the simulation in a file with the name
-mytracefile.trace.
-
-\li <b>\c tracing/platform</b>: use this to activate the tracing of the
-platform. For example, you can pass as parameter to your simulator:
-\verbatim
---cfg=tracing/platform:1
-\endverbatim
-to trace the platform utilization by the categories you declared in your
-simulator. By default, this options is set to 0.
+\li <b>\c
+tracing
+</b>:
+ It activates the tracing system and register the simulation platform
+ in the trace file. You have to enable this option to others take effect.
+
+\li <b>\c
+tracing/categorized
+</b>:
+ It activates the categorized resource utilization tracing. It should
+ be enabled if tracing categories are used by this simulator.
+
+\li <b>\c
+tracing/uncategorized
+</b>:
+ It activates the uncategorized resource utilization tracing. Use it if
+ this simulator do not use tracing categories and resource use have to be
+ traced.
+
+\li <b>\c
+tracing/platform/method
+</b>:
+ It changes the way resource utilization (categorized or not) is traced
+ inside the simulation core. Method 'a' (default) traces all updates defined
+ by the CPU/network model of a given resource. Depending on the interface used
+ by this simulator (MSG, SMPI, SimDAG), the default method can generate large
+ trace files. Method 'b' tries to make smaller tracefiles using clever updates,
+ without losing details of resource utilization. Method 'c' generates even
+ smaller files by doing time integration during the simulation, but it loses
+ precision. If this last method is used, the smallest timeslice used in the
+ tracefile analysis must be bigger than the smaller resource utilization. If
+ unsure, do not change this option.
+
+\li <b>\c
+tracing/filename
+</b>:
+ A file with this name will be created to register the simulation. The file
+ is in the Paje format and can be analyzed using Triva or Paje visualization
+ tools. More information can be found in these webpages:
+ <a href="http://triva.gforge.inria.fr/">http://triva.gforge.inria.fr/</a>
+ <a href="http://paje.sourceforge.net/">http://paje.sourceforge.net/</a>
+
+\li <b>\c
+tracing/smpi
+</b>:
+ This option only has effect if this simulator is SMPI-based. Traces the MPI
+ interface and generates a trace that can be analyzed using Gantt-like
+ visualizations. Every MPI function (implemented by SMPI) is transformed in a
+ state, and point-to-point communications can be analyzed with arrows.
+
+\li <b>\c
+tracing/smpi/group
+</b>:
+ This option only has effect if this simulator is SMPI-based. The processes
+ are grouped by the hosts where they were executed.
+
+\li <b>\c
+tracing/msg/task
+</b>:
+ This option only has effect if this simulator is MSG-based. It traces the
+ behavior of all categorized MSG tasks, grouping them by hosts.
+
+\li <b>\c
+tracing/msg/process
+</b>:
+ This option only has effect if this simulator is MSG-based. It traces the
+ behavior of all categorized MSG processes, grouping them by hosts. This option
+ can be used to track process location if this simulator has process migration.
+
+\li <b>\c
+tracing/msg/volume
+</b>:
+ This experimental option only has effect if this simulator is MSG-based.
+ It traces the communication volume of MSG send/receive.
\subsubsection faq_tracing_example Example of Instrumentation
MSG_global_init (&argc, &argv);
//note that TRACE_start must be called after MSG_global_init
- TRACE_start ();
- TRACE_category ("request");
- TRACE_category ("computation");
+ TRACE_category_with_color ("request", "1 0 0");
+ TRACE_category_with_color ("computation", "0.3 1 0.4");
TRACE_category ("finalize");
//(... after deployment ...)
//(...)
MSG_clean();
-
- TRACE_end();
return 0;
}
\endverbatim
- <b>Installing Triva</b>: the tool is available in the INRIAGforge,
at <a href="http://triva.gforge.inria.fr">http://triva.gforge.inria.fr</a>.
Use the following command to get the sources, and then check the file
-<i>INSTALL.simplified</i>. This file contains instructions to install
-the tool's dependencies in a Ubuntu/Debian Linux.
+<i>INSTALL</i>. This file contains instructions to install
+the tool's dependencies in a Ubuntu/Debian Linux. The tool can also
+be compiled in MacOSes natively, check <i>INSTALL.mac</i> file.
\verbatim
$ svn checkout svn://scm.gforge.inria.fr/svn/triva
$ cd triva
-$ cat INSTALL.simplified
+$ cat INSTALL
\endverbatim
- <b>Executing Triva</b>: a binary called <i>Triva</i> is available after the
installation (you can execute it passing <em>--help</em> to check its
options). If the triva binary is not available after following the
installation instructions, you may want to execute the following command to
-initialize the GNUstep environment variables (note that the location of the
-<i>GNUstep.sh</i> file may vary depending on your GNUstep installation - the
-command is known to work in Ubuntu and Debian Linux):
+initialize the GNUstep environment variables. We strongly recommend that you
+use the latest GNUstep packages, and not the packages available through apt-get
+in Ubuntu/Debian packaging systems. If you install GNUstep using the latest
+available packages, you can execute this command:
\verbatim
-$ source /usr/share/GNUstep/Makefiles/GNUstep.sh
+$ source /usr/GNUstep/System/Library/Makefiles/GNUstep.sh
\endverbatim
You should be able to see this output after the installation of triva:
\verbatim
$ ./Triva.app/Triva --help
-Usage: Triva [OPTION...] TRACEFILE
+Usage: Triva [OPTIONS...] TRACE0 [TRACE1]
Trace Analysis through Visualization
- You need to use one of the following options:
- -g, --graph Graph Analysis
- -t, --treemap Treemap Analysis
-
- Other auxiliary options to check the trace file:
- -c, --check Check the integrity of trace file
- -h, --hierarchy Export the trace type hierarchy
- -l, --list List entity types
-
- -?, --help Give this help list
- --usage Give a short usage message
+TimeInterval
+ --ti_frequency {double} Animation: frequency of updates
+ --ti_hide Hide the TimeInterval window
+ --ti_forward {double} Animation: value to move time-slice
+ --ti_apply Apply the configuration
+ --ti_update Update on slider change
+ --ti_animate Start animation
+ --ti_start {double} Start of time slice
+ --ti_size {double} Size of time slice
+Triva
+ --comparison Compare Trace Files (Experimental)
+ --graph Configurable Graph
+ --list Print Trace Type Hierarchy
+ --hierarchy Export Trace Type Hierarchy (dot)
+ --stat Trace Statistics and Memory Utilization
+ --instances List All Trace Entities
+ --linkview Link View (Experimental)
+ --treemap Squarified Treemap
+ --merge Merge Trace Files (Experimental)
+ --check Check Trace File Integrity
+GraphConfiguration
+ --gc_conf {file} Graph Configuration in Property List Format
+ --gc_apply Apply the configuration
+ --gc_hide Hide the GraphConfiguration window
\endverbatim
Triva expects that the user choose one of the available options
(currently <em>--graph</em> or <em>--treemap</em> for a visualization analysis)
\endverbatim
\subsection faq_binding_lua Lua Binding
-Most of Simgrid modules require a good level in C programming ,
- since simgrid is used to be as standard C library .
- Sometime ( for some reason or another ) developers prefer using some kind of « easy scripts »
- (something like … lua ? Ruby ? ...?) or a language easier to code with ( Java ? ) for their works,
- which avoid dealing with C errors , and sometime an important gain of time (coding-time?) .
-Besides Java Binding, Lua and Ruby bindings are available now( since version 3.4 of Simgrid )
-for MSG Module, and we are currenlty working on bindings for other modules .
+Most of Simgrid modules require a good level in C programming, since simgrid is used to be as standard C library.
+ Sometime users prefer using some kind of « easy scripts » or a language easier to code with, for their works,
+ which avoid dealing with C errors, and sometime an important gain of time.
+Besides Java Binding, Lua and Ruby bindings are available since version 3.4 of Simgrid
+for MSG Module, and we are currenlty working on bindings for other modules.
\subsubsection faq_binding_lua_about What is lua ?
-Lua (Moon for portuguese !) is a lightweight, reflective, imperative and functional programming language,
- designed as a scripting language with extensible semantics as a primary goal.(see official web site <a href="http://www.lua.org">here</a>)
+Lua is a lightweight, reflective, imperative and functional programming language,
+ designed as a scripting language with extensible semantics as a primary goal (see official web site <a href="http://www.lua.org">here</a>).
\subsubsection faq_binding_lua_why Why lua ?
-Lua is a fast,portable and powerful script language, quite simple to use for developpers .
+Lua is a fast, portable and powerful script language, quite simple to use for developpers.
it combines procedural features with powerful data description facilities,
by using a simple, yet powerful, mechanism of tables.
Lua has a relatively simple C API compared to other scripting languages,
and accordingly it provides a robust, easy to use it.
\subsubsection faq_binding_lua_simgrid How to use lua in Simgrid ?
-Actually , the use of lua in Simgrid is quite simple, you have just to follow the same steps as coding with C in Simgird,
- but this time, code with Lua ;) :
+Actually, the use of lua in Simgrid is quite simple, you have just to follow the same steps as coding with C in Simgird :
- Coding functions coresponding to each process
- loading the platforme/deployment XML file that describe the environment of simulation
- - and … Running the Simulation !!!
+ - and … Running the Simulation.
\dontinclude lua/master_slave.lua
\subsubsection faq_binding_lua_example_master_slave Master/Slave Example
\until end_of_master
we mainly use simgrid.Task.new(task_name,computation_size,communication_size) to create our MSG Task,
then simgrid.Task.send(task,alias) to send it.
-we use also simgrid.Task.name(task), to get the task's name .
+we use also simgrid.Task.name(task), to get the task's name.
\li Slave Code
\until end_of_slave
-Here, we could see how we use simgrid.Task.recv(alias) to receive a task with a specific alias,
-this function return directly the task recevied .
+Here, we see the use of simgrid.Task.recv(alias) to receive a task with a specific alias,
+this function return directly the task recevied.
\li Set Environmenet and run application
\until simgrid.clean()
\subsubsection faq_binding_lua_example_data Exchanging Data
You can also exchange data between Process using lua. for that, you have to deal with lua task as a table,
since lua is based itself on a mechanism of tables,
-so you can exchange any kind of data ( tables, matrix, strings … ) between process via tasks.
+so you can exchange any kind of data (tables, matrix, strings,…) between process via tasks.
\li Sender process
\verbatim
…
simgrid.Task.send(task,alias)
\endverbatim
- After creating task, we associate to it various kind of data with a specific key,( string in this case)
- to distinguish between data variables. Via this key the receiver could access easily to datas.
+ After creating task, we associate to it various kind of data with a specific key (string in this case)
+ to distinguish between data variables. The receiver will use this key to access easily to datas.
\li Receiver processe
sender_message = task['message']
...
\endverbatim
- Note that in lua, both sender and receiver share the same lua task!
+ Note that in lua, both sender and receiver share the same lua task.
So that the receiver could joint data directly on the received task without sending it back.
- You can find a complet example ( matrix multiplication case ) in the file example/lua/mult_matrix.lua
+ You can find a complet example (matrix multiplication case) in the file example/lua/mult_matrix.lua.
\subsubsection faq_binding_lua_example_bypass Bypass XML
( this can be useful for large platforms, so a simple for loop will avoid you to deal with an annoying XML File ;) )
+\li set Routing mode
+\verbatim
+ simgrid.AS.new{id="AS0",mode="Full"};
+\endverbatim
+
\li set Hosts
\verbatim
simgrid.Host.new{id="Tremblay",power=98095000};
