INPUT = @srcdir@/index.doc \
@srcdir@/FAQ.doc \
+ @srcdir@/publis.doc \
@srcdir@/index-API.doc \
\
@srcdir@/modules.doc \
Note however that SURF will be slower than the old SG to handle traces with
a lots of variations (there is no trace integration anymore).
+\subsection faq_SG_future Is there a chance for SG to come back one day in the maintained branch?
+
+Sure. In fact, we already have thought about a new and cleaner API:
+\verbatim
+void* SG_link_get_data(SG_link_t link);
+void SG_link_set_data(SG_link_t link, void *data);
+const char* SG_link_get_name(SG_link_t link);
+double SG_link_get_capacity(SG_link_t link);
+double SG_link_get_current_bandwidth(SG_link_t link);
+double SG_link_get_current_latency(SG_link_t link);
+
+SG_workstation_t SG_workstation_get_by_name(const char *name);
+SG_workstation_t* SG_workstation_get_list(void);
+int SG_workstation_get_number(void);
+void SG_workstation_set_data(SG_workstation_t workstation, void *data);
+void * SG_workstation_get_data(SG_workstation_t workstation);
+const char* SG_workstation_get_name(SG_workstation_t workstation);
+SG_link_t* SG_workstation_route_get_list(SG_workstation_t src, SG_workstation_t dst);
+int SG_workstation_route_get_size(SG_workstation_t src, SG_workstation_t dst);
+double SG_workstation_get_power(SG_workstation_t workstation);
+double SG_workstation_get_available_power(SG_workstation_t workstation);
+
+SG_task_t SG_task_create(const char *name, void *data, double amount);
+int SG_task_schedule(SG_task_t task, int workstation_nb,
+ SG_workstation_t **workstation_list, double *computation_amount,
+ double *communication_amount, double rate);
+
+void* SG_task_get_data(SG_task_t task);
+void SG_task_set_data(SG_task_t task, void *data);
+const char* SG_task_get_name(SG_task_t task);
+double SG_task_get_amount(SG_task_t task);
+double SG_task_get_remaining_amount(SG_task_t task);
+void SG_task_dependency_add(const char *name, void *data, SG_task_t src, SG_task_t dst);
+void SG_task_dependency_remove(SG_task_t src, SG_task_t dst);
+e_SG_task_state_t SG_task_state_get(SG_task_t task); /* e_SG_task_state_t can be either SG_SCHEDULED, SG_RUNNING, SG_DONE, or SG_FAILED */
+void SG_task_watch(SG_task_t task, e_SG_task_state_t state); /* SG_simulate will stop as soon as the state of this task is the one given in argument. Watch-poin
+t is then automatically removed */
+void SG_task_unwatch(SG_task_t task, e_SG_task_state_t state);
+
+void SG_task_unschedule(SG_task_t task); /* change state and rerun.. */
+
+SG_task_t *SG_simulate(double how_long); /* returns a NULL-terminated array of SG_task_t whose state has changed */
+\endverbatim
+
+We're just looking for somebody to implement it... :)
+
\section faq_dynamic Dynamic resources and platform building
\subsection faq_platform Building a realistic platform
$(shell find @srcdir@ -name "*.doc")
EXTRA_DIST = html Doxyfile \
- modules.doc FAQ.doc index.doc footer.html simgrid_logo.png simgrid_modules.png
+ modules.doc FAQ.doc index.doc publis.doc footer.html simgrid_logo.png simgrid_modules.png
DISTCLEANFILES = index-API.doc simgrid.tag
MAINTAINERCLEANFILES = html
doxygen Doxyfile >/dev/null
../tools/doxygen/index_create.pl simgrid.tag index-API.doc
../tools/doxygen/toc_create.pl FAQ.doc FAQ.toc
+ ../tools/doxygen/toc_create.pl index.doc index.toc
doxygen Doxyfile >/dev/null
cp @srcdir@/simgrid_logo.png @srcdir@/simgrid_modules.png html/
cp @srcdir@/Paje_MSG_screenshot_thn.jpg @srcdir@/Paje_MSG_screenshot.jpg html/
- for i in `find html -name '*.html'` ; do cp $$i $$i.bak ; sed 's|<li><a href="index.html"><span>Main\ Page</span></a></li>|<li><a href="index.html"><span>Main\ Page</span></a></li> <li><a href="faq.html"><span>FAQ</span></a></li>|' $$i.bak > $$i ; rm $$i.bak ; done
+ for i in `find html -name '*.html'` ; do \
+ cp $$i $$i.bak ; \
+ cat $$i.bak | \
+ sed -e 's|<li><a href="index.html"><span>Main\ Page</span></a></li>|<li><a href="index.html"><span>Main\ Page</span></a></li> <li><a href="faq.html"><span>FAQ</span></a></li>|' \
+ -e 's|<li><a href="annotated.html"><span>Data\ Structures</span></a></li>|<li><a href="publis.html"><span>Publications</span></a></li>|g' \
+ -e 's|<span>Modules</span>|<span>Modules API</span>|g' \
+ -e 's|<li><a href="dirs.html"><span>Directories</span></a></li>||g' \
+ > $$i ; \
+ rm $$i.bak ; \
+ done
endif
# for i in `find html -name '*.html'` ; do cp $$i $$i.bak ; sed 's/Modules<\/a> | <a class="qindex" href="annotated.html">.*Fields<\/a>/Modules Tree<\/a> /g' $$i.bak > $$i ; rm $$i.bak ; done
\endhtmlonly
</center>
+\htmlinclude index.toc
+
\section hot_news HOT NEWS
<b>SimGrid 3.0.1 was released on 22st of October 2005. Get it from
<hr>
-\section publications Selected publications
-
-When citing SimGrid, the prefered reference paper is <i>Scheduling
-Distributed Applications: the SimGrid Simulation Framework</i>, even if it's
-a bit old now. We are actively working on improving this.
-
-\subsection simulation About simulation
-
-\li <b>Scheduling Distributed Applications: the
- SimGrid Simulation Framework</b>\n
- by <em>Henri Casanova and Arnaud Legrand and Loris Marchal</em>\n
- Proceedings of the third IEEE International Symposium
- on Cluster Computing and the Grid (CCGrid'03)\n
- Since the advent of distributed computer systems an active field
- of research has been the investigation of scheduling strategies
- for parallel applications. The common approach is to employ
- scheduling heuristics that approximate an optimal
- schedule. Unfortunately, it is often impossible to obtain
- analytical results to compare the efficacy of these heuristics.
- One possibility is to conducts large numbers of back-to-back
- experiments on real platforms. While this is possible on
- tightly-coupled platforms, it is infeasible on modern distributed
- platforms (i.e. Grids) as it is labor-intensive and does not
- enable repeatable results. The solution is to resort to
- simulations. Simulations not only enables repeatable results but
- also make it possible to explore wide ranges of platform and
- application scenarios.\n
- In this paper we present the SimGrid framework which enables the
- simulation of distributed applications in distributed computing
- environments for the specific purpose of developing and evaluating
- scheduling algorithms. This paper focuses on SimGrid v2, which
- greatly improves on the first version of the software with more
- realistic network models and topologies. SimGrid v2 also enables
- the simulation of distributed scheduling agents, which has become
- critical for current scheduling research in large-scale platforms.
- After describing and validating these features, we present a case
- study by which we demonstrate the usefulness of SimGrid for
- conducting scheduling research.
-
-
-\li <b>A Network Model for Simulation of Grid Application</b>\n
- by <em>Henri Casanova and Loris Marchal</em>\n
- \anchor paper_tcp
- In this work we investigate network models that can be
- potentially employed in the simulation of scheduling algorithms for
- distributed computing applications. We seek to develop a model of TCP
- communication which is both high-level and realistic. Previous research
- works show that accurate and global modeling of wide-area networks, such
- as the Internet, faces a number of challenging issues. However, some
- global models of fairness and bandwidth-sharing exist, and can be link
- withthe behavior of TCP. Using both previous results and simulation (with
- NS), we attempt to understand the macroscopic behavior of
- TCP communications. We then propose a global model of the network for the
- Grid platform. We perform partial validation of this model in
- simulation. The model leads to an algorithm for computing
- bandwidth-sharing. This algorithm can then be implemented as part of Grid
- application simulations. We provide such an implementation for the
- SimGrid simulation toolkit.\n
- ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/RR/RR2002/RR2002-40.ps.gz
-
-
-\li <b>MetaSimGrid : Towards realistic scheduling simulation of
- distributed applications</b>\n
- by <em>Arnaud Legrand and Julien Lerouge</em>\n
- Most scheduling problems are already hard on homogeneous
- platforms, they become quite intractable in an heterogeneous
- framework such as a metacomputing grid. In the best cases, a
- guaranteed heuristic can be found, but most of the time, it is
- not possible. Real experiments or simulations are often
- involved to test or to compare heuristics. However, on a
- distributed heterogeneous platform, such experiments are
- technically difficult to drive, because of the genuine
- instability of the platform. It is almost impossible to
- guarantee that a platform which is not dedicated to the
- experiment, will remain exactly the same between two tests,
- thereby forbidding any meaningful comparison. Simulations are
- then used to replace real experiments, so as to ensure the
- reproducibility of measured data. A key issue is the
- possibility to run the simulations against a realistic
- environment. The main idea of trace-based simulation is to
- record the platform parameters today, and to simulate the
- algorithms tomorrow, against the recorded data: even though it
- is not the current load of the platform, it is realistic,
- because it represents a fair summary of what happened
- previously. A good example of a trace-based simulation tool is
- SimGrid, a toolkit providing a set of core abstractions and
- functionalities that can be used to easily build simulators for
- specific application domains and/or computing environment
- topologies. Nevertheless, SimGrid lacks a number of convenient
- features to craft simulations of a distributed application
- where scheduling decisions are not taken by a single
- process. Furthermore, modeling a complex platform by hand is
- fastidious for a few hosts and is almost impossible for a real
- grid. This report is a survey on simulation for scheduling
- evaluation purposes and present MetaSimGrid, a simulator built
- on top of SimGrid.\n
- ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/RR/RR2002/RR2002-28.ps.gz
-
-\li <b>SimGrid: A Toolkit for the Simulation of Application
- Scheduling</b>\n
- by <em>Henri Casanova</em>\n
- Advances in hardware and software technologies have made it
- possible to deploy parallel applications over increasingly large
- sets of distributed resources. Consequently, the study of
- scheduling algorithms for such applications has been an active area
- of research. Given the nature of most scheduling problems one must
- resort to simulation to effectively evaluate and compare their
- efficacy over a wide range of scenarios. It has thus become
- necessary to simulate those algorithms for increasingly complex
- distributed, dynamic, heterogeneous environments. In this paper we
- present SimGrid, a simulation toolkit for the study of scheduling
- algorithms for distributed application. This paper gives the main
- concepts and models behind SimGrid, describes its API and
- highlights current implementation issues. We also give some
- experimental results and describe work that builds on SimGrid's
- functionalities.\n
- http://grail.sdsc.edu/papers/simgrid_ccgrid01.ps.gz
-
-\subsection research Papers using SimGrid results
-
-\li <b> A study of meta-scheduling architectures for high throughput
- computing: Pull vs. Push</b>\n
- by <em> Vincent Garonne, Andrei Tsaregorodtsev, and Eddy Caron </em>\n
- Proceedings of 4th Internationnal Symposium on Parallel and
- Distributed Computing Job Scheduling Strategies for Parallel
- Processing (ISPDC'05), July 2005.\n
- Preliminary version in http://marwww.in2p3.fr/~garonne/garonne-meta.pdf
-
-\li <b>Exploiting Replication and Data Reuse to Efficiently Schedule
- Data-intensive Applications on Grids</b>\n
- by <em> E. Santos-Neto, W. Cirne, F. Brasileiro, A. Lima.</em>\n
- Proceedings of 10th Job Scheduling Strategies for Parallel Processing, June 2004.\n
- http://www.lsd.ufcg.edu.br/~elizeu/articles/jsspp.v6.pdf
-
-\li <b>Optimal algorithms for scheduling divisible workloads on
- heterogeneous systems</b>\n
- by <em>Olivier Beaumont and Arnaud Legrand and Yves Robert</em>\n
- in Proceedings of the 17th International Parallel and Distributed Processing Symposium (IPDPS'03).\n
- Preliminary version on ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/RR/RR2002/RR2002-36.ps.gz
-
-\li <b>On-line Parallel Tomography</b>\n
- by <em>Shava Smallen</em>\n
- Masters Thesis, UCSD, May 2001
-\li <b>Applying Scheduling and Tuning to On-line Parallel Tomography </b>\n
- by <em>Shava Smallen, Henri Casanova, Francine Berman</em>\n
- in Proceedings of Supercomputing 2001
-\li <b>Heuristics for Scheduling Parameter Sweep applications in
- Grid environments</b>\n
- by <em>Henri Casanova, Arnaud Legrand, Dmitrii Zagorodnov and
- Francine Berman</em>\n
- in Proceedings of the 9th Heterogeneous Computing workshop
- (HCW'2000), pp349-363.
*/
--- /dev/null
+/*! \page publis Publications
+
+When citing SimGrid, the prefered reference paper is <i>Scheduling
+Distributed Applications: the SimGrid Simulation Framework</i>, even if it's
+a bit old now. We are actively working on improving this.
+
+\subsection pub_simulation About simulation
+
+\li <b>Scheduling Distributed Applications: the
+ SimGrid Simulation Framework</b>\n
+ by <em>Henri Casanova and Arnaud Legrand and Loris Marchal</em>\n
+ Proceedings of the third IEEE International Symposium
+ on Cluster Computing and the Grid (CCGrid'03)\n
+ Since the advent of distributed computer systems an active field
+ of research has been the investigation of scheduling strategies
+ for parallel applications. The common approach is to employ
+ scheduling heuristics that approximate an optimal
+ schedule. Unfortunately, it is often impossible to obtain
+ analytical results to compare the efficacy of these heuristics.
+ One possibility is to conducts large numbers of back-to-back
+ experiments on real platforms. While this is possible on
+ tightly-coupled platforms, it is infeasible on modern distributed
+ platforms (i.e. Grids) as it is labor-intensive and does not
+ enable repeatable results. The solution is to resort to
+ simulations. Simulations not only enables repeatable results but
+ also make it possible to explore wide ranges of platform and
+ application scenarios.\n
+ In this paper we present the SimGrid framework which enables the
+ simulation of distributed applications in distributed computing
+ environments for the specific purpose of developing and evaluating
+ scheduling algorithms. This paper focuses on SimGrid v2, which
+ greatly improves on the first version of the software with more
+ realistic network models and topologies. SimGrid v2 also enables
+ the simulation of distributed scheduling agents, which has become
+ critical for current scheduling research in large-scale platforms.
+ After describing and validating these features, we present a case
+ study by which we demonstrate the usefulness of SimGrid for
+ conducting scheduling research.
+
+
+\li <b>A Network Model for Simulation of Grid Application</b>\n
+ by <em>Henri Casanova and Loris Marchal</em>\n
+ \anchor paper_tcp
+ In this work we investigate network models that can be
+ potentially employed in the simulation of scheduling algorithms for
+ distributed computing applications. We seek to develop a model of TCP
+ communication which is both high-level and realistic. Previous research
+ works show that accurate and global modeling of wide-area networks, such
+ as the Internet, faces a number of challenging issues. However, some
+ global models of fairness and bandwidth-sharing exist, and can be link
+ withthe behavior of TCP. Using both previous results and simulation (with
+ NS), we attempt to understand the macroscopic behavior of
+ TCP communications. We then propose a global model of the network for the
+ Grid platform. We perform partial validation of this model in
+ simulation. The model leads to an algorithm for computing
+ bandwidth-sharing. This algorithm can then be implemented as part of Grid
+ application simulations. We provide such an implementation for the
+ SimGrid simulation toolkit.\n
+ ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/RR/RR2002/RR2002-40.ps.gz
+
+
+\li <b>MetaSimGrid : Towards realistic scheduling simulation of
+ distributed applications</b>\n
+ by <em>Arnaud Legrand and Julien Lerouge</em>\n
+ Most scheduling problems are already hard on homogeneous
+ platforms, they become quite intractable in an heterogeneous
+ framework such as a metacomputing grid. In the best cases, a
+ guaranteed heuristic can be found, but most of the time, it is
+ not possible. Real experiments or simulations are often
+ involved to test or to compare heuristics. However, on a
+ distributed heterogeneous platform, such experiments are
+ technically difficult to drive, because of the genuine
+ instability of the platform. It is almost impossible to
+ guarantee that a platform which is not dedicated to the
+ experiment, will remain exactly the same between two tests,
+ thereby forbidding any meaningful comparison. Simulations are
+ then used to replace real experiments, so as to ensure the
+ reproducibility of measured data. A key issue is the
+ possibility to run the simulations against a realistic
+ environment. The main idea of trace-based simulation is to
+ record the platform parameters today, and to simulate the
+ algorithms tomorrow, against the recorded data: even though it
+ is not the current load of the platform, it is realistic,
+ because it represents a fair summary of what happened
+ previously. A good example of a trace-based simulation tool is
+ SimGrid, a toolkit providing a set of core abstractions and
+ functionalities that can be used to easily build simulators for
+ specific application domains and/or computing environment
+ topologies. Nevertheless, SimGrid lacks a number of convenient
+ features to craft simulations of a distributed application
+ where scheduling decisions are not taken by a single
+ process. Furthermore, modeling a complex platform by hand is
+ fastidious for a few hosts and is almost impossible for a real
+ grid. This report is a survey on simulation for scheduling
+ evaluation purposes and present MetaSimGrid, a simulator built
+ on top of SimGrid.\n
+ ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/RR/RR2002/RR2002-28.ps.gz
+
+\li <b>SimGrid: A Toolkit for the Simulation of Application
+ Scheduling</b>\n
+ by <em>Henri Casanova</em>\n
+ Advances in hardware and software technologies have made it
+ possible to deploy parallel applications over increasingly large
+ sets of distributed resources. Consequently, the study of
+ scheduling algorithms for such applications has been an active area
+ of research. Given the nature of most scheduling problems one must
+ resort to simulation to effectively evaluate and compare their
+ efficacy over a wide range of scenarios. It has thus become
+ necessary to simulate those algorithms for increasingly complex
+ distributed, dynamic, heterogeneous environments. In this paper we
+ present SimGrid, a simulation toolkit for the study of scheduling
+ algorithms for distributed application. This paper gives the main
+ concepts and models behind SimGrid, describes its API and
+ highlights current implementation issues. We also give some
+ experimental results and describe work that builds on SimGrid's
+ functionalities.\n
+ http://grail.sdsc.edu/papers/simgrid_ccgrid01.ps.gz
+
+\subsection pub_research Papers using SimGrid results
+
+\li <b> A study of meta-scheduling architectures for high throughput
+ computing: Pull vs. Push</b>\n
+ by <em> Vincent Garonne, Andrei Tsaregorodtsev, and Eddy Caron </em>\n
+ Proceedings of 4th Internationnal Symposium on Parallel and
+ Distributed Computing Job Scheduling Strategies for Parallel
+ Processing (ISPDC'05), July 2005.\n
+ Preliminary version in http://marwww.in2p3.fr/~garonne/garonne-meta.pdf
+
+\li <b>Exploiting Replication and Data Reuse to Efficiently Schedule
+ Data-intensive Applications on Grids</b>\n
+ by <em> E. Santos-Neto, W. Cirne, F. Brasileiro, A. Lima.</em>\n
+ Proceedings of 10th Job Scheduling Strategies for Parallel Processing, June 2004.\n
+ http://www.lsd.ufcg.edu.br/~elizeu/articles/jsspp.v6.pdf
+
+\li <b>Optimal algorithms for scheduling divisible workloads on
+ heterogeneous systems</b>\n
+ by <em>Olivier Beaumont and Arnaud Legrand and Yves Robert</em>\n
+ in Proceedings of the 17th International Parallel and Distributed Processing Symposium (IPDPS'03).\n
+ Preliminary version on ftp://ftp.ens-lyon.fr/pub/LIP/Rapports/RR/RR2002/RR2002-36.ps.gz
+
+\li <b>On-line Parallel Tomography</b>\n
+ by <em>Shava Smallen</em>\n
+ Masters Thesis, UCSD, May 2001
+\li <b>Applying Scheduling and Tuning to On-line Parallel Tomography </b>\n
+ by <em>Shava Smallen, Henri Casanova, Francine Berman</em>\n
+ in Proceedings of Supercomputing 2001
+\li <b>Heuristics for Scheduling Parameter Sweep applications in
+ Grid environments</b>\n
+ by <em>Henri Casanova, Arnaud Legrand, Dmitrii Zagorodnov and
+ Francine Berman</em>\n
+ in Proceedings of the 9th Heterogeneous Computing workshop
+ (HCW'2000), pp349-363.
+*/
\ No newline at end of file
