\section faq_simgrid I'm new to SimGrid. I have some questions. Where should I start?
-You are at the right place... Having a look to these
-<a href="http://www.loria.fr/~quinson/articles/simgrid-tutorial.pdf">the tutorial slides</a>
-(or to these <a href="http://graal.ens-lyon.fr/~alegrand/articles/slides_g5k_simul.pdf">old slides</a>,
-or to these
+You are at the right place... Having a look to these
+<a href="http://www.loria.fr/~quinson/blog/2010/06/28/Tutorial_at_HPCS/">the slides of the HPCS'10 tutorial</a>
+(or to these <a href="http://graal.ens-lyon.fr/~alegrand/articles/slides_g5k_simul.pdf">ancient
+slides</a>, or to these
<a href="http://graal.ens-lyon.fr/~alegrand/articles/Simgrid-Introduction.pdf">"obsolete" slides</a>)
may give you some insights on what SimGrid can help you to do and what
are its limitations. Then you definitely should read the \ref
With SimDag, you express your code as a collection of interdependent
parallel tasks. So, in this model, applications can be seen as a DAG of
tasks. This is the interface of choice for people wanting to port old
-code designed for SimGrid v1 or v2 to the lastest framework.
+code designed for SimGrid v1 or v2 to the framework current version.
With both GRAS and MSG, your application is seen as a set of communicating
processes, exchanging data by the way of messages and performing computation
on their own.
The difference between both is that MSG is somehow easier to use, but GRAS
-is not limitated to the simulator. Once you're done writing your GRAS code,
+is not limited to the simulator. Once you're done writing your GRAS code,
you can run your code both in the simulator or on a real platform. For this,
there is two implementations of the GRAS interface, one for simulation, one
for real execution. So, you just have to relink your code to chose one of
both world.
-\subsection faq_generic First steps with SimGrid
-
-If you decide to go for the MSG interface, please read carefully the
-\ref MSG_examples. You'll find in \ref MSG_ex_master_slave a very
-simple consisting of a master (that owns a bunch of tasks and
-distributes them) , some slaves (that process tasks whenever they
-receive one) and some forwarder agents (that simply pass the tasks
-they receive to some slaves).
-
-If you decide to go for the GRAS interface, you should definitively
-read the \ref GRAS_tut. The first section constitutes an introduction
-to the tool and presents the model we use. The second section
-constitutes a complete step-by-step tutorial building a distributed
-application from the begining and exemplifying most of the GRAS
-features in the process. The last section groups some HOWTOS
-highlighting a given feature of the framework in a more concise way.
-
-If you decide to go for another interface, I'm afraid your only sources
-of information will be the source code and the mailing lists...
-
\subsection faq_visualization Visualizing and analyzing the results
It is sometime convenient to "see" how the agents are behaving. If you
./msg_test small_platform.xml small_deployment.xml 2>&1 | ../../tools/MSG_visualization/colorize.pl
\endverbatim
-We also have a more graphical output. Have a look at MSG_paje_output(). It
-generates an input to <a href="http://www-id.imag.fr/Logiciels/paje/">Paje</a>.
-<center>
-\htmlonly
- <a href="Paje_MSG_screenshot.jpg"><img src="Paje_MSG_screenshot_thn.jpg"></a>
-\endhtmlonly
-</center>
-
-Vizualization with Paje can be seen as a kind of postmortem
-analysis. However, as soon as you start playing with big simulations,
-you'll realize that processing such output is kind of tricky. There is
-so much generic informations that it is hard to find the information
-you are looking for.
-
-As a matter of fact, loging really depends on simulations (e.g. what
-kind of events is important...). That is why we do not propose a big
-dump of your whole simulation (it would slow everything down) but give
-you neat tools to structure you logs. Have a look at \ref XBT_log. In
-fact, rather than a post-mortem analysis, you may want to do it on the
-fly. The process you are running can do whatever you want. Have you
-thought about adding a global structure where you directly compute the
-informations that are really important rather than writing everything
-down and then processing huge files?
+We also have a more graphical output. Have a look at section \ref options_tracing.
\subsection faq_C Argh! Do I really have to code in C?
fast forward [2006/05/13]. More languages are evaluated, but for now,
we do not feel a real demand for any other language. Please speak up!
-\section faq_installation Installing the SimGrid library
-
-Many people have been asking me questions on how to use SimGrid. Quite
-often, the questions were not really about SimGrid but on the
-installation process. This section is intended to help people that are
-not familiar with compiling C files under UNIX. If you follow these
-instructions and still have some troubles, drop an e-mail to
-<simgrid-user@lists.gforge.inria.fr>.
-
-\subsection faq_compiling Compiling SimGrid from a stable archive
-
-First of all, you need to download the latest version of SimGrid from
-<a href="http://gforge.inria.fr/frs/?group_id=12">here</a>.
-Suppose you have uncompressed SimGrid in some temporary location of
-your home directory (say <tt>/home/joe/tmp/simgrid-3.0.1 </tt>). The
-simplest way to use SimGrid is to install it in your home
-directory. Change your directory to
-<tt>/home/joe/tmp/simgrid-3.0.1</tt> and type
-
-\verbatim./configure --prefix=$HOME
-make
-make install
-\endverbatim
-
-If at some point, something fails, check the section "\ref
-faq_trouble_compil". If it does not help, you can report this problem to the
-list but, please, avoid sending a laconic mail like "There is a problem. Is it
-okay?". Send the config.log file which is automatically generated by
-configure. Try to capture both the standard output and the error output of the
-<tt>make</tt> command with <tt>script</tt>. There is no way for us to help you
-without the relevant bits of information.
-
-Now, the following directory should have been created :
-
- \li <tt>/home/joe/doc/simgrid/html/</tt>
- \li <tt>/home/joe/lib/</tt>
- \li <tt>/home/joe/include/</tt>
-
-SimGrid is not a binary, it is a library. Both a static and a dynamic
-version are available. Here is what you can find if you try a <tt>ls
-/home/joe/lib</tt>:
-
-\verbatim libsimgrid.a libsimgrid.la libsimgrid.so libsimgrid.so.0 libsimgrid.so.0.0.1
-\endverbatim
-
-Thus, there is two ways to link your program with SimGrid:
- \li Either you use the static version, e.g
-\verbatim gcc libsimgrid.a -o MainProgram MainProgram.c
-\endverbatim
- In this case, all the SimGrid functions are directly
- included in <tt>MainProgram</tt> (hence a bigger binary).
- \li Either you use the dynamic version (the preferred method)
-\verbatim gcc -lsimgrid -o MainProgram MainProgram.c
-\endverbatim
- In this case, the SimGrid functions are not included in
- <tt>MainProgram</tt> and you need to set your environment
- variable in such a way that <tt>libsimgrid.so</tt> will be
- found at runtime. This can be done by adding the following
- line in your .bashrc (if you use bash and if you have
- installed the SimGrid libraries in your home directory):
-\verbatim export LD_LIBRARY_PATH=$HOME/lib/:$LD_LIBRARY_PATH
-\endverbatim
-
-\subsection faq_compiling_snapshoot SimGrid development snapshots
-
-We have very high standards on software quality, and we are reluctant releasing
-a stable release as long as there is still some known bug in the code base. In
-addition, we added quite an extensive test base, making sure that we correctly
-test the most important parts of the tool.
-
-As an infortunate conclusion, there may be some time between the stable
-releases. If you want to benefit from the most recent features we introduced,
-but don't want to take the risk of an untested version from the SVN, then
-development snapshots are done for you.
-
-These are pre-releases of SimGrid that still fail some tests about features
-that almost nobody use, or on platforms not being in our core target (which is
-linux, mac, other unixes and windows, from the most important to the less
-one). That means that using this development releases should be safe for most
-users.
-
-These archives can be found on
-<a href="http://www.loria.fr/~quinson/simgrid.html">this web page</a>. Once you
-got the lastest archive, you can compile it just like any archive (see above).
-
-\subsection faq_compiling_svn Compiling SimGrid from the SVN
-
-The project development takes place in the svn, where all changes are
-commited when they happen. Then every once in a while, we make sure that the
-code quality meets our standard and release an archive from the code in the
-SVN. We afterward go back to the development in the SVN. So, if you need a
-recently added feature and can afford some little problem with the stability
-of the lastest features, you may want to use the SVN version instead of a
-released one.
-
-For that, you first need to get the "simgrid" module from
-<a href="http://gforge.inria.fr/scm/?group_id=12">here</a>.
-
-You won't find any <tt>configure</tt> and a few other things
-(<tt>Makefile.in</tt>'s, documentation, ...) will be missing as well. The
-reason for that is that all these files have to be regenerated using the
-latest versions of <tt>autoconf</tt>, <tt>libtool</tt>, <tt>automake</tt>
-(>1.9) and <tt>doxygen</tt> (>1.4). To generate the <tt>configure</tt> and
-the <tt>Makefile.in</tt>'s, you just have to launch the <tt>bootstrap</tt>
-command that resides in the top of the source tree. Then just follow the
-instructions of Section \ref faq_compiling.
-
-We insist on the fact that you really need the latest versions of
-autoconf, automake and libtool. Doing this step on exotic architectures/systems
-(i.e. anything different from a recent linux distribution) may be
-... uncertain. If you need to compile the SVN version on a machine where all these
-dependencies are not met, the easiest is to do <tt>make dist</tt> in the SVN
-dir of another machine where all dependencies are met. It will create an
-archive you may deploy on other sites just as a regular stable release.
-
-In summary, the following commands will checkout the SVN, regenerate the
-configure script and friends, configure SimGrid and build it.
-
-\verbatim svn checkout svn://scm.gforge.inria.fr/svn/simgrid/simgrid/trunk simgrid
-cd simgrid
-./bootstrap
-./configure --enable-maintainer-mode --prefix=<where to install SimGrid>
-make \endverbatim
-
-Then, if you want to install SimGrid on the current box, just do:
-\verbatim make install \endverbatim
-
-If you want to build an snapshot of the SVN to deploy it on another box (for
-example because the other machine don't have the autotools), do:
-\verbatim make dist \endverbatim
-
-Moreover, you should never call the autotools manually since you must run
-them in a specific order with specific arguments. Most of the times, the
-makefiles will automatically call the tools for you. When it's not possible
-(such as the first time you checkout the SVN), use the ./bootstrap command
-to call them explicitely.
-
-
-\subsection faq_setting_MSG Setting up your own MSG code
-
-Do not build your simulator by modifying the SimGrid examples. Go
-outside the SimGrid source tree and create your own working directory
-(say <tt>/home/joe/SimGrid/MyFirstScheduler/</tt>).
-
-Suppose your simulation has the following structure (remember it is
-just an example to illustrate a possible way to compile everything;
-feel free to organize it as you want).
-
- \li <tt>sched.h</tt>: a description of the core of the
- scheduler (i.e. which functions are can be used by the
- agents). For example we could find the following functions
- (master, forwarder, slave).
-
- \li <tt>sched.c</tt>: a C file including <tt>sched.h</tt> and
- implementing the core of the scheduler. Most of these
- functions use the MSG functions defined in section \ref
- msg_gos_functions.
-
- \li <tt>masterslave.c</tt>: a C file with the main function, i.e.
- the MSG initialization (MSG_global_init()), the platform
- creation (e.g. with MSG_create_environment()), the
- deployment phase (e.g. with MSG_function_register() and
- MSG_launch_application()) and the call to
- MSG_main()).
-
-To compile such a program, we suggest to use the following
-Makefile. It is a generic Makefile that we have used many times with
-our students when we teach the C language.
-
-\verbatim
-all: masterslave
-masterslave: masterslave.o sched.o
-
-INSTALL_PATH = $$HOME
-CC = gcc
-PEDANTIC_PARANOID_FREAK = -O0 -Wshadow -Wcast-align \
- -Waggregate-return -Wmissing-prototypes -Wmissing-declarations \
- -Wstrict-prototypes -Wmissing-prototypes -Wmissing-declarations \
- -Wmissing-noreturn -Wredundant-decls -Wnested-externs \
- -Wpointer-arith -Wwrite-strings -finline-functions
-REASONABLY_CAREFUL_DUDE = -Wall
-NO_PRAYER_FOR_THE_WICKED = -w -O2
-WARNINGS = $(REASONABLY_CAREFUL_DUDE)
-CFLAGS = -g $(WARNINGS)
-
-INCLUDES = -I$(INSTALL_PATH)/include
-DEFS = -L$(INSTALL_PATH)/lib/
-LDADD = -lm -lsimgrid
-LIBS =
-
-%: %.o
- $(CC) $(INCLUDES) $(DEFS) $(CFLAGS) $^ $(LIBS) $(LDADD) -o $@
-
-%.o: %.c
- $(CC) $(INCLUDES) $(DEFS) $(CFLAGS) -c -o $@ $<
-
-clean:
- rm -f $(BIN_FILES) *.o *~
-.SUFFIXES:
-.PHONY : clean
-
-\endverbatim
-
-The first two lines indicates what should be build when typing make
-(<tt>masterslave</tt>) and of which files it is to be made of
-(<tt>masterslave.o</tt> and <tt>sched.o</tt>). This makefile assumes
-that you have set up correctly your <tt>LD_LIBRARY_PATH</tt> variable
-(look, there is a <tt>LDADD = -lm -lsimgrid</tt>). If you prefer using
-the static version, remove the <tt>-lsimgrid</tt> and add a
-<tt>$(INSTALL_PATH)/lib/libsimgrid.a</tt> on the next line, right
-after the <tt>LIBS = </tt>.
-
-More generally, if you have never written a Makefile by yourself, type
-in a terminal : <tt>info make</tt> and read the introduction. The
-previous example should be enough for a first try but you may want to
-perform some more complex compilations...
-
-\subsection faq_setting_GRAS Setting up your own GRAS code
-
-If you use the GRAS interface instead of the MSG one, then previous section
-is not the better source of information. Instead, you should check the GRAS
-tutorial in general, and the \ref GRAS_tut_tour_setup in particular.
-
-
\section faq_howto Feature related questions
\subsection faq_MIA "Could you please add (your favorite feature here) to SimGrid?"
Here is the deal. The whole SimGrid project (MSG, SURF, GRAS, ...) is
meant to be kept as simple and generic as possible. We cannot add
-functions for everybody's need when these functions can easily be
+functions for everybody's needs when these functions can easily be
built from the ones already in the API. Most of the time, it is
possible and when it was not possible we always have upgraded the API
accordingly. When somebody asks us a question like "How to do that?
We know. We should add some more examples, but not really some more
complex ones... We should add some examples that illustrate some other
-functionalities (like how to simply encode asynchronous
+functionalists (like how to simply encode asynchronous
communications, RPC, process migrations, thread synchronization, ...)
and we will do it when we will have a little bit more time. We have
tried to document the examples so that they are understandable. Tell
MSG_task_get_remaining_computation(), MSG_task_get_data_size(),
and MSG_task_get_data().
-You could use a dictionnary (#xbt_dict_t) of dynars (#xbt_dynar_t). If
+You could use a dictionary (#xbt_dict_t) of dynars (#xbt_dynar_t). If
you still don't see how to do it, please come back to us...
\subsubsection faq_MIA_asynchronous I want to do asynchronous communications in MSG
-Up until now, there is no asynchronous communications in MSG. However,
-you can create as many process as you want so you should be able to do
-whatever you want... I've written a queue module to help implementing
-some asynchronous communications at low cost (creating thousands of
-process only to handle communications may be problematic in term of
-performance at some point). I'll add it in the distribution asap.
+In the past (version <= 3.4), there was no function to perform asynchronous communications.
+It could easily be implemented by creating new process when needed though. Since version 3.5,
+we have introduced the following functions:
+ - MSG_task_isend()
+ - MSG_task_irecv()
+ - MSG_comm_test()
+ - MSG_comm_wait()
+ - MSG_comm_waitall()
+ - MSG_comm_waitany()
+ - MSG_comm_destroy()
+
+We refer you to the description of these functions for more details on their usage as well
+as to the exemple section on \ref MSG_ex_asynchronous_communications.
\subsubsection faq_MIA_thread_synchronization I need to synchronize my MSG processes
-You obviously cannot use pthread_mutexes of pthread_conds. The best
-thing would be to propose similar structures. Unfortunately, we
-haven't found time to do it yet. However you can try to play with
-MSG_process_suspend() and MSG_process_resume(). You can even do some
-synchronization with fake communications (using MSG_task_get(),
+You obviously cannot use pthread_mutexes of pthread_conds since we handle every
+scheduling related decision within SimGrid.
+
+In the past (version <=3.3.4) you could do it by playing with
+MSG_process_suspend() and MSG_process_resume() or with fake communications (using MSG_task_get(),
MSG_task_put() and MSG_task_Iprobe()).
+Since version 3.4, you can use classical synchronization structures. See page \ref XBT_synchro or simply check in
+include/xbt/synchro_core.h.
+
\subsubsection faq_MIA_host_load Where is the get_host_load function hidden in MSG?
There is no such thing because its semantic wouldn't be really
calloc(1,sizeof(double)));
*((double*) task->data) = MSG_get_clock();
MSG_task_put(task, slaves[i % slaves_count], PORT_22);
- INFO0("Send completed");
+ XBT_INFO("Send completed");
return 0;
}
int receiver()
time2 = MSG_get_clock();
if(time1<*((double *)task->data))
time1 = *((double *) task->data);
- INFO1("Communication time : \"%f\" ", time2-time1);
+ XBT_INFO("Communication time : \"%f\" ", time2-time1);
free(task->data);
MSG_task_destroy(task);
return 0;
\subsubsection faq_SG_comm Implementing communication delays between tasks.
-A classic question of SimDag newcommers is about how to express a
+A classic question of SimDag newcomers is about how to express a
communication delay between tasks. The thing is that in SimDag, both
computation and communication are seen as tasks. So, if you want to
model a data dependency between two DAG tasks t1 and t2, you have to
generic way is thus very hard). However some people have implemented
their own batch schedulers. Vincent Garonne wrote one during his PhD
and put his code in the contrib directory of our SVN so that other can
-keep working on it. You may find inspinring ideas in it.
+keep working on it. You may find inspiring ideas in it.
\subsubsection faq_MIA_checkpointing I need a checkpointing thing
<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
</route>
\endverbatim
-Althrough it is perfectly valid, it does not mean that data traveling
+Although it is perfectly valid, it does not mean that data traveling
from A to C can either go directly (using link 3) or through B (using
links 1 and 2). It simply means that the routing on the graph is not
trivial, and that data do not following the shortest path in number of
the provided ones.
You are also free to declare platform where the routing is not
-symetric. For example, add the following to the previous file:
+symmetric. For example, add the following to the previous file:
\verbatim
<route src="C" dst="A">
\subsubsection faq_flexml_bypassing Bypassing the XML parser with your own C functions
-So you want to bypass the XML files parser, uh? Maybe doin some parameter
+So you want to bypass the XML files parser, uh? Maybe doing some parameter
sweep experiments on your simulations or so? This is possible, and
it's not even really difficult (well. Such a brutal idea could be
harder to implement). Here is how it goes.
/* Parse the file */
surf_parse_open(file);
- xbt_assert1((!surf_parse()), "Parse error in %s", file);
+ xbt_assert(!surf_parse(), "Parse error in %s", file);
surf_parse_close();
\endverbatim
functions. An example of this trick is distributed in the file
examples/msg/masterslave/masterslave_bypass.c
-\subsection faq_simgrid_configuration Changing SimGrid's behavior
-
-A number of options can be given at runtime to change the default
-SimGrid behavior. In particular, you can change the default cpu and
-network models...
-
-\subsubsection faq_simgrid_configuration_gtnets Using GTNetS
-
-For example, it is possible to use a packet-level network simulator
-instead of the default flow-based simulation. You may want to use such
-an approach if you have doubts about the validity of the default model
-or if you want to perform some validation experiments. At the moment,
-we support the GTNetS simulator (it is still rather experimental
-though, so leave us a message if you play with it).
-
-Everything you need to use this feature is in the
-<a href="http://gforge.inria.fr/plugins/scmsvn/viewcvs.php/contrib/trunk/GTNetS/?root=simgrid">SVN</a>.
-
-Once you have followed all the instructions for compiling and
-installing given in the corresponding
-<a href='http://gforge.inria.fr/plugins/scmsvn/viewcvs.php/contrib/trunk/GTNetS/README?root=simgrid'>README</a>,
-you can activate this feature at runtime with the following options:
-
-\verbatim
-gtnets/gtnets gtnets/onelink-p.xml gtnets/onelink-d.xml --cfg=workstation_model:compound --cfg=network_model:GTNets --cfg=cpu_model:Cas01
-\endverbatim
-
-\subsubsection faq_simgrid_configuration_alternate_network Using alternative flow models
-
-The default simgrid network model uses a max-min based aproach as
-explained in the research report
-<a href="ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/RR/RR2002/RR2002-40.ps.gz">A Network Model for Simulation of Grid Application</a>.
-Other models have been proposed and implemented since then (see for example
-<a href="http://mescal.imag.fr/membres/arnaud.legrand/articles/simutools09.pdf">Accuracy Study and Improvement of Network Simulation in the SimGrid Framework</a>)
-and can be activated at runtime. For example:
-\verbatim
-./mycode platform.xml deployment.xml --cfg=workstation_model:compound --cfg=network_model:LegrandVelho --cfg=cpu_model:Cas01
-\endverbatim
-
-Possible models for the network are currently "Constant", "CM02",
-"LegrandVelho", "GTNets", Reno", "Reno2", "Vegas". Others will
-probably be added in the future and many of the previous ones are
-experimental and are likely to disappear without notice...
-
\section faq_troubleshooting Troubleshooting
\subsection faq_trouble_lib_compil SimGrid compilation and installation problems
-\subsubsection faq_trouble_lib_config ./configure fails!
+\subsubsection faq_trouble_lib_config cmake fails!
-We now only one reason for the configure to fail:
+We know only one reason for the configure to fail:
- - <b>You are using a borken build environment</b>\n
- If symptom is that configure complains about gcc not being able to build
+ - <b>You are using a broken build environment</b>\n
+ If symptom is that the configury magic complains about gcc not being able to build
executables, you are probably missing the libc6-dev package. Damn Ubuntu.
If you experience other kind of issue, please get in touch with us. We are
always interested in improving our portability to new systems.
-\subsubsection faq_trouble_distcheck Dude! "make check" fails on my machine!
+\subsubsection faq_trouble_distcheck Dude! "ctest" fails on my machine!
Don't assume we never run this target, because we do. Check
-http://bob.loria.fr:8010 if you don't believe us.
-
-There is several reasons which may cause the make check to fail on your
-machine:
-
- - <b>You are using a borken libc (probably concerning the contextes)</b>.\n
- The symptom is that the "make check" fails within the examples/msg directory.\n
- By default, SimGrid uses something called ucontexts. This is part of the
- libc, but it's quite undertested. For example, some (old) versions of the
- glibc on alpha do not implement these functions, but provide the stubs
- (which return ENOSYS: not implemented). It may fool our detection mecanism
- and leads to segfaults. There is not much we can do to fix the bug.
- A workaround is to compile with --with-context=pthread to avoid
- ucontext completely. You'll be a bit more limitated in the number
- of simulated processes you can start concurently, but 5000
- processes is still enough for most purposes, isn't it?\n
- This limitation is the reason why we insist on using this piece of ...
- software even if it's so troublesome.\n
- <b>=> use --with-pthread on AMD64 architecture that do not have an
- ultra-recent libc.</b>
-
- - <b>There is a bug in SimGrid we aren't aware of</b>.\n
- If none of the above apply, please drop us a mail on the mailing list so
- that we can check it out. Make sure to read \ref faq_bugrepport
- before you do so.
+http://cdash.inria.fr/CDash/index.php?project=Simgrid (click on
+previous if there is no result for today: results are produced only by
+11am, French time) and
+https://buildd.debian.org/status/logs.php?pkg=simgrid if you don't believe us.
+
+If it's failing on your machine in a way not experienced by the
+autobuilders above, please drop us a mail on the mailing list so that
+we can check it out. Make sure to read \ref faq_bugrepport before you
+do so.
\subsection faq_trouble_compil User code compilation problems
for all the details, but you simply forgot to call one of
XBT_LOG_NEW_DEFAULT_CATEGORY() or XBT_LOG_NEW_DEFAULT_SUBCATEGORY().
-\subsubsection faq_trouble_pthreadstatic "gcc: undefinded reference to pthread_key_create"
+\subsubsection faq_trouble_pthreadstatic "gcc: undefined reference to pthread_key_create"
This indicates that one of the library SimGrid depends on (libpthread
here) was missing on the linking command line. Dependencies of
Actually, the message comes directly from FleXML, the technology on top of
which the parser is built. FleXML has the bad idea of fetching the whole
document in memory before parsing it. And moreover, the memory buffer size
-must be determinded at compilation time.
+must be determined at compilation time.
We use a value which seems big enough for our need without bloating the
simulators footprints. But of course your mileage may vary. In this case,
Flex is recent enough (>= 2.5.31). If not the compilation process should
warn you.
-A while ago, we worked on FleXML to reduce a bit its memory consumtion, but
+A while ago, we worked on FleXML to reduce a bit its memory consumption, but
these issues remain. There is two things we should do:
- use a dynamic buffer instead of a static one so that the only limit
and it breaks the hack we devised to bypass the parser, as explained in
\ref faq_flexml_bypassing. Indeed, this is not a classical usage of the
parser, and Will didn't imagine that we may have used (and even documented)
-such a crude usage of FleXML. So, we now have to repare the bypassing
-functionnality to use the lastest FleXML version and fix the memory usage in
+such a crude usage of FleXML. So, we now have to repair the bypassing
+functionality to use the lastest FleXML version and fix the memory usage in
SimGrid.
\subsubsection faq_trouble_gras_transport GRAS spits networking error messages
Gras, on real platforms, naturally use regular sockets to communicate. They
-are deeply hiden in the gras abstraction, but when things go wrong, you may
+are deeply hidden in the gras abstraction, but when things go wrong, you may
get some weird error messages. Here are some example, with the probable
reason:
- <b>Socket closed by remote side</b>: if the remote process is not
supposed to close the socket at this point, it may be dead.
- - <b>Connection reset by peer</b>: I found this on internet about this
+ - <b>Connection reset by peer</b>: I found this on Internet about this
error. I think it's what's happening here, too:\n
<i>This basically means that a network error occurred while the client was
receiving data from the server. But what is really happening is that the
When debugging SimGrid, it's easier to pass the
--disable-compiler-optimization flag to the configure if valgrind or
gdb get fooled by the optimization done by the compiler. But you
-should remove these flages when everything works before going in
+should remove these flag when everything works before going in
production (before launching your 1252135 experiments), or everything
will run only one half of the true SimGrid potential.
******************************************************************
-\subsection faq_crosscompile Cross-compiling a Windows DLL of SimGrid from linux
+subsection faq_crosscompile Cross-compiling a Windows DLL of SimGrid from linux
At the moment, we do not distribute Windows pre-compiled version of SimGrid
because the support for this platform is still experimental. We know that
gunzip ~/.wine/c/windows/system/mingwm10.dll.gz
\endverbatim
-The DLL is builded in src/.libs, and installed in the <i>prefix</i>/bin directory
+The DLL is built in src/.libs, and installed in the <i>prefix</i>/bin directory
when you run make install.
If you want to use it in a native project on windows, you need to use
Nowadays, functions get automatically exported, so we don't need to load our
header files with tons of __declspec(dllexport) cruft. We only need to do so
for data, but there is no public data in SimGrid so we are good.
-
