(documenting all internals this way is overkill + doxygen scales badly)
- New tutorial on S4U (highly inspired from the old MSG one, but with
a git repository to fork as a starting point, and a docker image)
- - Started but not finished a SMPI tutorial inspired from the JLPC'14 one.
+ - Started but not finished an SMPI tutorial inspired from the JLPC'14 one.
- The Developper manual is still to be converted (not compiled until then)
- Some parts are still missing in this conversion (such as the
platform and deployment sections) while others were blindly converted
* This is (mainly) a backward compatible change: v4 are valid v4.1 files
- <zone> can be used as a synonym for the now deprecated <as>
- <zoneRoute> can be used as a synonym for the now deprecated <asroute>
- - <bypassZoneRoute> an be used as a synonym for the now deprecated <bypassAsRoute>
+ - <bypassZoneRoute> can be used as a synonym for the now deprecated <bypassAsRoute>
- <actor> can be used as a synonym for the now deprecated <process>
- state_file and avail_file periodicity is now easier to express
(check the documentation) the old behavior should still work.
TRACE:
* Two new tracing options for adding comments to trace file so you
can track your experiments (see --help-tracing for details).
- * New option to generate a impoverished trace file (--cfg=tracing/basic:1)
+ * New option to generate an impoverished trace file (--cfg=tracing/basic:1)
* Adding the SimGrid version that generated the trace file as a comment.
* Instrumenting other MSG functions (MSG_task_isend_with_matching and MSG_task_dsend)
* Fix to avoid key clashes on Paje links
MSG but a few things really had to disappear. The main differences
with the previous version are:
1) no more m_links_t and the corresponding functions. Platforms are
- directly read from a XML description and cannot be hard-coded
+ directly read from an XML description and cannot be hard-coded
anymore. The same format is used for application deployment
description. The new format is described in the documentation.
Have a look in tools/platform_generation. There is a tiny script
PROJECT_BRIEF = "Versatile Simulation of Distributed Systems"
-# With the PROJECT_LOGO tag one can specify an logo or icon that is
+# With the PROJECT_LOGO tag one can specify a logo or icon that is
# included in the documentation. The maximum height of the logo should not
# exceed 55 pixels and the maximum width should not exceed 200 pixels.
# Doxygen will copy the logo to the output directory.
#---------------------------------------------------------------------------
# If the CLASS_DIAGRAMS tag is set to YES (the default) Doxygen will
-# generate a inheritance diagram (in HTML, RTF and LaTeX) for classes with base
+# generate an inheritance diagram (in HTML, RTF and LaTeX) for classes with base
# or super classes. Setting the tag to NO turns the diagrams off. Note that
# this option also works with HAVE_DOT disabled, but it is recommended to
# install and use dot, since it yields more powerful graphs.
For instance, if you want to add a new cup model called `Plop`, create two files
cpu_plop.hpp and cpu_plop_cpp which contains classes CpuPlopModel, CpuPlop and
CpuPlopAction implementing respectively the interfaces CpuModel, Cpu and
-CpuAction. You also need to define a initializing function like this:
+CpuAction. You also need to define an initializing function like this:
~~~~
void surf_cpu_model_init_plop()
There are two tags at all times available to represent network entities and
several other tags that are available only in certain contexts.
-1. ``<link>``: Represents a entity that has a limited bandwidth, a
+1. ``<link>``: Represents an entity that has a limited bandwidth, a
latency, and that can be shared according to TCP way to share this
bandwidth.
@remark
point to reach within that zone to reach the netzone), and the list of
links in the ancestor zone to go from one zone to another.
-So, to go from an host @c src_host that is within zone @c src, to an
+So, to go from a host @c src_host that is within zone @c src, to a
host @c dst_host that is within @c dst, you need to:
- move within zone @c src, from @c src_host to the specified @c gw_src;
@subsection pb_baroex Basic Routing Example
-Let's say you have an zone named zone_Big that contains two other zone, zone_1
+Let's say you have a zone named zone_Big that contains two other zones, zone_1
and zone_2. If you want to make a host (h1) from zone_1 with another one
(h2) from zone_2 then you'll have to proceed as follows:
@li First, you have to ensure that a route is defined from h1 to the
In the zone_4, you have an exitzone_4 defined, containing only one router,
and routes defined to that zone from all other zone (as cluster is only a
-shortcut for an zone, see cluster description for details). If there was
+shortcut for a zone, see cluster description for details). If there was
an upper zone, it would define routes to and from zone_4 with the gateway
router_4. It's just because, as we did not allowed (for performances
-issues) to have routes from an zone to a single host/router, you have to
-enclose your gateway, when you have zone included in your zone, within an
+issues) to have routes from a zone to a single host/router, you have to
+enclose your gateway, when you have zone included in your zone, within a
zone to define routes to it.
@subsection pf_P2P_tags P2P or how to use coordinates
In such a case though, we connect the zone created by the <b>peer</b> tag with the Vivaldi routing mechanism.
This means that to route between zone1 and zone2, it will use the coordinates of router_zone1 and router_zone2.
This is currently a convention and we may offer to change this convention in the DTD later if needed.
-You may have noted that conveniently, a peer named FOO defines an zone named FOO and a router named router_FOO, which is why it works seamlessly with the <b>peer</b> tag.
+You may have noted that conveniently, a peer named FOO defines a zone named FOO and a router named router_FOO, which is why it works seamlessly with the <b>peer</b> tag.
@subsection pf_routing_howto_choose_wisely Choosing wisely the routing model to use
`intrusive_ptr_release(p)` (which is the interface used by
[`boost::intrusive_ptr`](http://www.boost.org/doc/libs/1_61_0/libs/smart_ptr/intrusive_ptr.html));
-- delegation of the operations to a opaque `pimpl` (which is the Maestro object);
+- delegation of the operations to an opaque `pimpl` (which is the Maestro object);
- the Maestro object and the corresponding S4U object have the same lifetime
(and share the same reference count).
not have reference counts. We still provide dummy `intrusive_ptr_add_ref(p)`,
`intrusive_ptr_release(p)` and `FooPtr` for consistency.
-In many cases, we try to have a API which is consistent with the API or
+In many cases, we try to have an API which is consistent with the API or
corresponding C++ standard classes. For example, the methods of
`simgrid::s4u::Mutex` are based on [`std::mutex`](http://en.cppreference.com/w/cpp/thread/mutex).
This has several benefits:
using ActorPtr = Actor::Ptr;
~~~
-It uses the `simgrid::simix::Process` as a opaque pimple:
+It uses the `simgrid::simix::Process` as an opaque pimple:
~~~
class Process {
technical issues of real platforms are masked here. Check the @ref
MSG_API section for more information.
- - If you want to study the behavior of a MPI application using emulation,
+ - If you want to study the behavior of an MPI application using emulation,
you should have a look at the <b>@ref SMPI_API</b> (Simulated
MPI) programming environment. Unfortunately, this work is still underway.
Check the @ref SMPI_API section for more information.
This type of approach might be useful for other libraries which define
their own contexts. An example of this is
-[Mordor](https://github.com/mozy/mordor), a I/O library using fibers
+[Mordor](https://github.com/mozy/mordor), an I/O library using fibers
(cooperative scheduling): it implements cooperative/fiber
[mutex](https://github.com/mozy/mordor/blob/4803b6343aee531bfc3588ffc26a0d0fdf14b274/mordor/fibersynchronization.h#L70),
[recursive
of a file in which to write a dot file of the path leading to the
property violation discovered (safety or liveness violation), as well
as the cycle for liveness properties. This dot file can then be fed to the
-graphviz dot tool to generate an corresponding graphical representation.
+graphviz dot tool to generate a corresponding graphical representation.
.. _cfg=model-check/max-depth:
Describing Your Platform
------------------------
-As a SMPI user, you are supposed to provide a description of your
+As an SMPI user, you are supposed to provide a description of your
simulated platform, that is mostly a set of simulated hosts and network
links with some performance characteristics. SimGrid provides a plenty
of :ref:`documentation <platform>` and examples (in the
---------
It is time to start using SMPI yourself. For that, you first need to
-install it somehow, and then you will need a MPI application to play with.
+install it somehow, and then you will need an MPI application to play with.
Using Docker
............
handy to model situations where hosts have an asymmetric
connectivity. Computers connected through set-top-boxes usually have a
much better download rate than their upload rate. To model this,
-<peer> creates and connects several elements: an host, an upload link
+<peer> creates and connects several elements: a host, an upload link
and a download link.
**Parent tags:** :ref:`pf_tag_zone` (only with Vivaldi routing) |br|
that marked as permanent receiver, you should call
``mailbox->set_receiver(nullptr)`` by the end of the actors so that their
memory gets properly reclaimed. This call should be at the end of the
-actor's function, not in a on_exit callback.
+actor's function, not in an on_exit callback.
.. _s4u_raii:
Note that Mailboxes, Hosts and Links are not handled thought smart
pointers (yet?). This means that it is currently impossible to destroy a
-mailbox or a link. You can still destroy an host (but probably
+mailbox or a link. You can still destroy a host (but probably
shouldn't), using :cpp:func:`simgrid::s4u::Host::destroy`.
.. THE EXAMPLES
difficult to write new algorithms and difficult to understand, debug, and modify
the existing ones. We need a clean API to express the model-checking algorithms
in a form which is closer to the text-book/paper description. This API must
-be exposed in a a language which is more adequate to this task.
+be exposed in a language which is more adequate to this task.
Tasks:
Not all ns-3 models are available from SimGrid (only the TCP and WiFi ones are),
while not all SimGrid platform files can be used in conjunction ns-3 (routes
must be of length 1). Also, the platform built in ns-3 from the SimGrid
-description is very basic. Finally, communicating from an host to
+description is very basic. Finally, communicating from a host to
itself is forbidden in ns-3, so every such communication completes
immediately upon startup.
The performance of a wifi network is controlled by 3 property that can be added
-to the an host connected to the wifi zone:
+to the a host connected to the wifi zone:
* ``wifi_mcs`` (`Modulation and Coding Scheme <https://en.wikipedia.org/wiki/Link_adaptation>`_)
Roughly speaking, it defines the speed at which the access point is
- **Using Pstates on a host:**
This example shows how define a set of pstates in the XML. The current pstate
- of an host can then be accessed and changed from the program.
+ of a host can then be accessed and changed from the program.
.. tabs::
xbt_free(answer);
}
-/** @brief Prints a answer_t, for debugging purposes */
+/** @brief Prints an answer_t, for debugging purposes */
void answer_print(const_answer_t answer)
{
unsigned int cpt;
return 1;
}
-/** @brief Sorts a answer_t, by node distance.
+/** @brief Sorts an answer_t, by node distance.
* @param answer the answer to sort
* @param destination_id the id of the guy we are trying to find
*/
xbt_dynar_sort(answer->nodes, &_answer_sort_function);
}
-/** @brief Trims a answer_t, in order for it to have a size of less or equal to "BUCKET_SIZE"
+/** @brief Trims an answer_t, in order for it to have a size of less or equal to "BUCKET_SIZE"
* @param answer the answer_t to trim
*/
void answer_trim(answer_t answer)
xbt_assert(xbt_dynar_length(answer->nodes) == answer->size, "Wrong size for the answer");
}
-/** @brief Adds the content of a bucket unsigned into a answer object.
+/** @brief Adds the content of a bucket unsigned into an answer object.
* @param bucket the bucket we have to had unsigned into
* @param answer the answer object we're going to put the data in
* @param destination_id the id of the guy we are trying to find.
}
} while (got_answer == 0);
- /* Second step: Send a FIND_NODE to a a random node in buckets */
+ /* Second step: Send a FIND_NODE to a random node in buckets */
unsigned int bucket_id = routing_table_find_bucket(node->table, id_known)->id;
xbt_assert(bucket_id <= IDENTIFIER_SIZE);
for (i = 0; ((bucket_id > i) || (bucket_id + i) <= IDENTIFIER_SIZE) && i < JOIN_BUCKETS_QUERIES; i++) {
show_info(disk_count, disks);
- // Open an non-existing file to create it
+ // Open a non-existing file to create it
const char* filename = "/scratch/tmp/data.txt";
sg_file_t file = sg_file_open(filename, NULL);
return nodes.get(id);
}
- /* Add the content of the bucket into a answer object. */
+ /* Add the content of the bucket into an answer object. */
public void addToAnswer(Answer answer, int destination) {
for (int nodeId : this.nodes) {
answer.getNodes().add(new Contact(nodeId,nodeId ^ destination));
@subsection msg_ex_tracing_user_variables Tracing user variables
-You can also attach your own variables to a any resource described in
+You can also attach your own variables to any resource described in
the platform file. The following examples illustrate this feature.
They have to be run with the following options:
@verbatim --cfg=tracing:yes --cfg=tracing/platform:yes
MSG_create_environment(argv[1]);
- //declaring link user variables (one without, another with a RGB color)
+ // declaring link user variables (one without, another with an RGB color)
TRACE_link_variable_declare("Link_Capacity");
TRACE_link_variable_declare_with_color ("Link_Utilization", "0.9 0.1 0.1");
MSG_create_environment(argv[1]);
- //declaring link user variables (one without, another with a RGB color)
+ // declaring link user variables (one without, another with an RGB color)
TRACE_link_variable_declare("Link_Capacity");
TRACE_link_variable_declare_with_color ("Link_Utilization", "0.9 0.1 0.1");
namespace kademlia {
-/** @brief Prints a answer_t, for debugging purposes */
+/** @brief Prints an Answer, for debugging purposes */
void Answer::print() const
{
XBT_INFO("Searching %08x, size %zu", destination_id_, nodes_.size());
return not nodes_.empty() && nodes_.begin()->second == 0;
}
-/** @brief Adds the content of a bucket unsigned into a answer object.
- * @param bucket the bucket we have to had unsigned into
- */
+/** @brief Adds the content of a bucket unsigned into an answer object.
+ * @param bucket the bucket we have to had unsigned into
+ */
void Answer::addBucket(const Bucket* bucket)
{
xbt_assert((bucket != nullptr), "Provided a NULL bucket");
simgrid::s4u::this_actor::sleep_for(1);
} while (not got_answer);
- /* Second step: Send a FIND_NODE to a a random node in buckets */
+ /* Second step: Send a FIND_NODE to a random node in buckets */
unsigned int bucket_id = table.findBucket(known_id)->getId();
xbt_assert(bucket_id <= IDENTIFIER_SIZE);
for (unsigned int i = 0; ((bucket_id > i) || (bucket_id + i) <= IDENTIFIER_SIZE) && i < JOIN_BUCKETS_QUERIES; i++) {
show_info(disks);
- // Open an non-existing file to create it
+ // Open a non-existing file to create it
std::string filename = "/scratch/tmp/data.txt";
auto* file = new simgrid::s4u::File(filename, nullptr);
/* 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. */
-/* This example shows how to work with the state profile of an host or a link,
+/* This example shows how to work with the state profile of a host or a link,
* specifying when the resource must be turned on or off.
*
* To set such a profile, the first way is to use a file in the XML, while the second is to use the programmatic
* interface. Once this profile is in place, the resource will automatically be turned on and off.
*
- * The actors running on an host that is turned off are forcefully killed
+ * The actors running on a host that is turned off are forcefully killed
* once their on_exit callbacks are executed. They cannot avoid this fate.
* Since we specified on_failure="RESTART" for each actors in the XML file,
* they will be automatically restarted when the host starts again.
#include "simgrid/s4u.hpp"
-/* This example demonstrates how to attach a profile to an host or a link,
+/* This example demonstrates how to attach a profile to a host or a link,
* to specify external changes to the resource speed. The first way to do
* so is to use a file in the XML, while the second is to use the programmatic interface.
*/
* simgrid::s4u::this_actor::execute(100000);
* } catch (simgrid::kernel::context::ForcefulKillException& e) { // oops, my host just turned off
* free(malloc);
- * throw; // I shall never survive on an host that was switched off
+ * throw; // I shall never survive on a host that was switched off
* }
* @endverbatim
*/
XBT_PUBLIC size_t sg_host_extension_create(void (*deleter)(void*));
XBT_PUBLIC void* sg_host_extension_get(const_sg_host_t host, size_t rank);
-/** Finds an host from its name */
+/** Finds a host from its name */
XBT_PUBLIC sg_host_t sg_host_by_name(const char* name);
/** @brief Return the name of the sg_host_t. */
#endif
// ========= storage related functions ============
-/** @brief Return the list of mount point names on an host.
+/** @brief Return the list of mount point names on a host.
* @param host a host
* @return a dict containing all mount point on the host (mount_name => sg_storage_t)
*/
XBT_PUBLIC xbt_dict_t sg_host_get_mounted_storage_list(sg_host_t host);
-/** @brief Return the list of storages attached to an host.
+/** @brief Return the list of storages attached to a host.
* @param host a host
* @return a dynar containing all storages (name) attached to the host
*/
* Note that being permanent receivers of a mailbox prevents actors to be garbage-collected.
* If your simulation creates many short-lived actors that marked as permanent receiver, you
* should call mailbox->set_receiver(nullptr) by the end of the actors so that their memory gets
- * properly reclaimed. This call should be at the end of the actor's function, not in a on_exit
+ * properly reclaimed. This call should be at the end of the actor's function, not in an on_exit
* callback.
*/
void set_receiver(ActorPtr actor);
int simcall_comm_testany(simgrid::kernel::activity::ActivityImplPtr comms[], size_t count);
XBT_PUBLIC int simcall_comm_testany(simgrid::kernel::activity::CommImpl* comms[], size_t count);
-XBT_ATTRIB_DEPRECATED_v330("Please use a ActivityImpl* for first parameter") inline void simcall_comm_wait(
+XBT_ATTRIB_DEPRECATED_v330("Please use an ActivityImpl* for first parameter") inline void simcall_comm_wait(
const simgrid::kernel::activity::ActivityImplPtr& comm, double timeout)
{
simcall_comm_wait(comm.get(), timeout);
}
-XBT_ATTRIB_DEPRECATED_v330("Please use a ActivityImpl* for first parameter") inline bool simcall_comm_test(
+XBT_ATTRIB_DEPRECATED_v330("Please use an ActivityImpl* for first parameter") inline bool simcall_comm_test(
const simgrid::kernel::activity::ActivityImplPtr& comm)
{
return simcall_comm_test(comm.get());
// Execute the code in the kernel and get the kernel future:
simgrid::kernel::Future<T> future = simgrid::kernel::actor::simcall(std::move(code));
- // Wrap the kernel future in a actor future:
+ // Wrap the kernel future in an actor future:
return simgrid::simix::Future<T>(std::move(future));
}
}
extensions_[0]=data;
}
void* get_data() const { return extensions_[0]; }
- // Convenience extension access when the type has a associated EXTENSION ID:
+ // Convenience extension access when the type has an associated EXTENSION ID:
template <class U> U* extension() const { return extension<U>(U::EXTENSION_ID); }
template<class U> void extension_set(U* p) { extension_set<U>(U::EXTENSION_ID, p); }
};
/** A `error_category` suitable to be used with `errno`
*
* It is not clear which error we are supposed to generate
- * when getting a errno:
+ * when getting an errno:
*
* * `system_error` clearly cannot be used for this on Windows;
*
#endif
/* end of eclipse-mandated pimple */
-/** Returns a new java instance of an host. */
+/** Returns a new java instance of a host. */
jobject jhost_new_instance(JNIEnv * env);
/** Take a ref onto the java instance (to prevent its collection) */
* platform file which describes all elements of the platform (host, link, root..).
* You cannot create a host yourself.
*
- * The best way to get an host instance is to call the static method
+ * The best way to get a host instance is to call the static method
* Host.getByName().
*
* For example to get the instance of the host. If your platform
- * file description contains an host named "Jacquelin" :
+ * file description contains a host named "Jacquelin" :
*
* \verbatim
Host jacquelin;
}
/**
- * This static method gets an host instance associated with a native
+ * This static method gets a host instance associated with a native
* host of your platform. This is the best way to get a java host object.
*
* @param name The name of the host to get.
public native String getProperty(String name);
public native void setProperty(String name, String value);
- /** Tests if an host is up and running. */
+ /** Tests if a host is up and running. */
public native boolean isOn();
- /** Returns the list of mount point names on an host */
+ /** Returns the list of mount point names on a host */
public native Storage[] getMountedStorage();
- /** This methods returns the list of storages (names) attached to an host */
+ /** This methods returns the list of storages (names) attached to a host */
public native String[] getAttachedStorage();
/** After this call, sg_host_get_consumed_energy() will not interrupt your process
/** @ingroup TRACE_category
* @brief Declare a new category with a color.
*
- * Same as #TRACE_category, but let user specify a color encoded as a RGB-like string with three floats from 0 to 1.
+ * Same as #TRACE_category, but let user specify a color encoded as an RGB-like string with three floats from 0 to 1.
* So, to specify a red color, pass "1 0 0" as color parameter. A light-gray color can be specified using "0.7 0.7 0.7"
* as color. This function has no effect if a category with the same name has been already declared.
*
xbt_assert(dst, "Cannot add a route from %s to %s: %s does not exist.", srcName, dstName, dstName);
xbt_assert(not link_list.empty(), "Empty route (between %s and %s) forbidden.", srcName, dstName);
xbt_assert(not src->is_netzone(),
- "When defining a route, src cannot be a netzone such as '%s'. Did you meant to have an NetzoneRoute?",
+ "When defining a route, src cannot be a netzone such as '%s'. Did you meant to have a NetzoneRoute?",
srcName);
xbt_assert(not dst->is_netzone(),
- "When defining a route, dst cannot be a netzone such as '%s'. Did you meant to have an NetzoneRoute?",
+ "When defining a route, dst cannot be a netzone such as '%s'. Did you meant to have a NetzoneRoute?",
dstName);
} else {
XBT_DEBUG("Load NetzoneRoute from %s@%s to %s@%s", srcName, gw_src->get_cname(), dstName, gw_dst->get_cname());
xbt_assert(gw_dst->is_host() || gw_dst->is_router(),
"When defining a NetzoneRoute, gw_dst must be a host or a router but '%s' is not.", dstName);
- xbt_assert(gw_src != gw_dst, "Cannot define an NetzoneRoute from '%s' to itself", gw_src->get_cname());
+ xbt_assert(gw_src != gw_dst, "Cannot define a NetzoneRoute from '%s' to itself", gw_src->get_cname());
xbt_assert(src, "Cannot add a route from %s@%s to %s@%s: %s does not exist.", srcName, gw_src->get_cname(), dstName,
gw_dst->get_cname(), srcName);
xbt_assert(access_point_ != nullptr, "Access point '%s' of WIFI zone '%s' does not exist: no such host or router.",
AP_name, get_cname());
xbt_assert(access_point_->is_host() || access_point_->is_router(),
- "Access point '%s' of WIFI zone '%s' must be either an host or a router.", AP_name, get_cname());
+ "Access point '%s' of WIFI zone '%s' must be either a host or a router.", AP_name, get_cname());
}
}
"Please use the dlopen privatization schema when model-checking SMPI code");
#endif
- // Create a AF_LOCAL socketpair used for exchanging messages
+ // Create an AF_LOCAL socketpair used for exchanging messages
// between the model-checker process (ourselves) and the model-checked
// process:
int sockets[2];
*/
void* ObjectInformation::base_address() const
{
- // For an executable (more precisely for a ET_EXEC) the base it 0:
+ // For an executable (more precisely for an ET_EXEC) the base it 0:
if (this->executable())
return nullptr;
return upper_bound - lower_bound + 1;
}
-/** @brief Finds the number of elements in a array type (DW_TAG_array_type)
+/** @brief Finds the number of elements in an array type (DW_TAG_array_type)
*
* The compilation unit might be needed because the default lower
* bound depends on the language of the compilation unit.
/** @file
* Libunwind implementation for the model-checker
*
- * Libunwind provides an pluggable stack unwinding API: the way the current
+ * Libunwind provides a pluggable stack unwinding API: the way the current
* registers and memory is accessed, the way unwinding information is found
* is pluggable.
*
*
* This file contains the MC replay/record functionality.
* The recorded path is written in the log output and can be replayed with MC disabled
- * (even with an non-MC build) using `--cfg=model-check/replay:$replayPath`.
+ * (even with a non-MC build) using `--cfg=model-check/replay:$replayPath`.
*
* The same version of Simgrid should be used and the same arguments should be
* passed to the application (without the MC specific arguments).
typedef std::vector<Transition> RecordTrace;
-/** Convert a string representation of the path into a array of `simgrid::mc::Transition`
+/** Convert a string representation of the path into an array of `simgrid::mc::Transition`
*/
XBT_PRIVATE RecordTrace parseRecordTrace(const char* data);
XBT_PRIVATE std::string traceToString(simgrid::mc::RecordTrace const& trace);
using simgrid::mc::remote;
-/** HACK, Statically "upcast" a s_smx_actor_t into a ActorInformation
+/** HACK, Statically "upcast" a s_smx_actor_t into an ActorInformation
*
* This gets 'actorInfo' from '&actorInfo->copy'. It upcasts in the
* sense that we could achieve the same thing by having ActorInformation
* an actor cannot have more than one enabled transition at a given time.
*/
class ActorState {
- /* Possible exploration status of a actor transition in a state.
+ /* Possible exploration status of an actor transition in a state.
* Either the checker did not consider the transition, or it was considered and still to do, or considered and done.
*/
enum class InterleavingType {
/** Get a view of the chunk indices */
const std::size_t* pagenos() const { return pagenos_.data(); }
- /** Get a a pointer to a chunk */
+ /** Get a pointer to a chunk */
void* page(std::size_t i) const { return store_->get_page(pagenos_[i]); }
ChunkedData(PageStore& store, const AddressSpace& as, RemotePtr<void> addr, std::size_t page_count);
XBT_CRITICAL("bug");
} catch (const Exception&) {
// hostfailure (if you want to know whether this is the SRC or the DST check directly in send_migration_data code)
- // Stop the dirty page tracking an return (there is no memory space to release)
+ // Stop the dirty page tracking and return (there is no memory space to release)
sg_vm_stop_dirty_page_tracking(vm_);
return;
}
} catch (const Exception&) {
// hostfailure (if you want to know whether this is the SRC or the DST check directly in send_migration_data
// code)
- // Stop the dirty page tracking an return (there is no memory space to release)
+ // Stop the dirty page tracking and return (there is no memory space to release)
sg_vm_stop_dirty_page_tracking(vm_);
return;
}
sendMigrationData(remaining_size, 3, 0, mig_speed, -1);
} catch (const Exception&) {
// hostfailure (if you want to know whether this is the SRC or the DST check directly in send_migration_data code)
- // Stop the dirty page tracking an return (there is no memory space to release)
+ // Stop the dirty page tracking and return (there is no memory space to release)
vm_->resume();
return;
}
return link->second->get_iface();
}
-/** @brief Find an link from its name (or nullptr if that link does not exist) */
+/** @brief Find a link from its name (or nullptr if that link does not exist) */
Link* Engine::link_by_name_or_null(const std::string& name) const
{
auto link = pimpl->links_.find(name);
kernel::actor::simcall([this, &properties] { this->pimpl_->set_properties(properties); });
}
-/** Specify a profile turning the host on and off according to a exhaustive list or a stochastic law.
+/** Specify a profile turning the host on and off according to an exhaustive list or a stochastic law.
* The profile must contain boolean values. */
void Host::set_state_profile(kernel::profile::Profile* p)
{
return kernel::actor::simcall([this, p] { pimpl_cpu->set_state_profile(p); });
}
-/** Specify a profile modeling the external load according to a exhaustive list or a stochastic law.
+/** Specify a profile modeling the external load according to an exhaustive list or a stochastic law.
*
* Each event of the profile represent a peak speed change that is due to external load. The values are given as a rate
* of the initial value. This means that the actual value is obtained by multiplying the initial value (the peek speed
return task;
}
-/** @brief create a end-to-end communication task that can then be auto-scheduled
+/** @brief create an end-to-end communication task that can then be auto-scheduled
*
* Auto-scheduling mean that the task can be used with SD_task_schedulev(). This allows one to specify the task costs at
* creation, and decouple them from the scheduling process where you just specify which resource should deliver the
break;
}
if(index < rank) {
- // #Request is below rank: it's a irecv
+ // #Request is below rank: it's an irecv
op->apply( tmpbufs[index], recvbuf, &count, datatype);
}
}
Datatype::copy(tmpbufs[index], count, datatype, recvbuf, count, datatype);
recvbuf_is_empty=0;
} else
- // #Request is below rank: it's a irecv
+ // #Request is below rank: it's an irecv
op->apply( tmpbufs[index], recvbuf, &count, datatype);
}
}
*/
static int intel_barrier_gather_scatter(MPI_Comm comm){
- //our default barrier performs a antibcast/bcast
- barrier__default(comm);
- return MPI_SUCCESS;
+ // our default barrier performs an antibcast/bcast
+ barrier__default(comm);
+ return MPI_SUCCESS;
}
int (*intel_barrier_functions_table[])(MPI_Comm comm) ={
if (smpi_process()->sampling()) {
XBT_CRITICAL("Cannot do recursive benchmarks.");
- XBT_CRITICAL("Are you trying to make a call to MPI within a SMPI_SAMPLE_ block?");
+ XBT_CRITICAL("Are you trying to make a call to MPI within an SMPI_SAMPLE_ block?");
xbt_backtrace_display_current();
xbt_die("Aborting.");
}
static std::map<std::string, Instance> smpi_instances;
/** @ingroup smpi_simulation
- * @brief Registers a running instance of a MPI program.
+ * @brief Registers a running instance of an MPI program.
*
* @param name the reference name of the function.
* @param code either the main mpi function
return mem;
}
-/** Map a given SMPI privatization segment (make a SMPI process active)
+/** Map a given SMPI privatization segment (make an SMPI process active)
*
* When doing a state restoration, the state of the restored variables might not be consistent with the state of the
* virtual memory. In this case, we to change the data segment.
req_storage.remove(request);
if (request == MPI_REQUEST_NULL) {
- /* Assume that the trace is well formed, meaning the comm might have been caught by a MPI_test. Then just
+ /* Assume that the trace is well formed, meaning the comm might have been caught by an MPI_test. Then just
* return.*/
return;
}
************/
/** @ingroup SURF_host_interface
* @brief SURF Host interface class
- * @details An host represents a machine with a aggregation of a Cpu, a RoutingEdge and a Storage
+ * @details A host represents a machine with an aggregation of a Cpu, a RoutingEdge and a Storage
*/
class XBT_PRIVATE HostImpl : public xbt::PropertyHolder {
std::vector<kernel::actor::ProcessArg*> actors_at_boot_;
if (src == dst) {
static bool warned = false;
if (not warned) {
- XBT_WARN("Sending from an host %s to itself is not supported by ns-3. Every such communication finishes "
+ XBT_WARN("Sending from a host %s to itself is not supported by ns-3. Every such communication finishes "
"immediately upon startup.",
src->get_cname());
warned = true;
return NOW;
}
-/* returns whether #file_path is a absolute file path. Surprising, isn't it ? */
+/* returns whether #file_path is an absolute file path. Surprising, isn't it ? */
static bool is_absolute_file_path(const std::string& file_path)
{
#ifdef _WIN32
* New in DTD version 4.1 (in SimGrid 3.16): backward compatible change (v4 files are valid v4.1 files)
- <zone> can be used as a synonym for the now deprecated <as>
- <zoneRoute> can be used as a synonym for the now deprecated <asroute>
- - <bypassZoneRoute> an be used as a synonym for the now deprecated <bypassAsRoute>
+ - <bypassZoneRoute> can be used as a synonym for the now deprecated <bypassAsRoute>
- <actor> can be used as a synonym for the now deprecated <process>
Other backward-compatible changes for which we did not bump the DTD version.
- SPLITDUPLEX is the new spelling of the deprecated FULLDUPLEX (SimGrid v3.19)
* * New in DTD version 4.1 (in SimGrid 3.16): backward compatible change (v4 files are valid v4.1 files)
* - <zone> can be used as a synonym for the now deprecated <as>
* - <zoneRoute> can be used as a synonym for the now deprecated <asroute>
- * - <bypassZoneRoute> an be used as a synonym for the now deprecated <bypassAsRoute>
+ * - <bypassZoneRoute> can be used as a synonym for the now deprecated <bypassAsRoute>
* - <actor> can be used as a synonym for the now deprecated <process>
* Other backward-compatible changes for which we did not bump the DTD version.
* - SPLITDUPLEX is the new spelling of the deprecated FULLDUPLEX (SimGrid v3.19)
node->data = data;
}
-/** @brief Get the user data associated to a edge */
+/** @brief Get the user data associated to an edge */
void* xbt_graph_edge_get_data(const s_xbt_edge_t* edge)
{
return edge->data;
}
-/** @brief Set the user data associated to a edge */
+/** @brief Set the user data associated to an edge */
void xbt_graph_edge_set_data(xbt_edge_t edge, void *data)
{
edge->data = data;
/*
* Darwin do not give us the number of mappings, so we read entries until
- * we get an KERN_INVALID_ADDRESS return.
+ * we get a KERN_INVALID_ADDRESS return.
*/
mach_vm_address_t address = VM_MIN_ADDRESS;
while (true) {
return (NULL);
else if (sbuf.st_size > 0) {
- /* We were given an valid file descriptor on an open file, so try to remap
+ /* We were given a valid file descriptor on an open file, so try to remap
it into the current process at the same address to which it was previously
mapped. It naturally have to pass some sanity checks for that.
BEGIN_SECTION("exec")
{
- XBT_INFO("Launch a execute(5s), and let it proceed");
+ XBT_INFO("Launch an execute(5s), and let it proceed");
bool global = false;
simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5", all_hosts[1], [&global]() {
BEGIN_SECTION("exec killed at start")
{
- XBT_INFO("Launch a execute(5s), and kill it right after start");
+ XBT_INFO("Launch an execute(5s), and kill it right after start");
simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5_killed", all_hosts[1], []() {
assert_exit(false, 0);
simgrid::s4u::this_actor::execute(500000000);
BEGIN_SECTION("exec killed in middle")
{
- XBT_INFO("Launch a execute(5s), and kill it after 2 secs");
+ XBT_INFO("Launch an execute(5s), and kill it after 2 secs");
simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5_killed", all_hosts[1], []() {
assert_exit(false, 2);
simgrid::s4u::this_actor::execute(500000000);
BEGIN_SECTION("exec restarted at start")
{
- XBT_INFO("Launch a execute(5s), and restart its host right after start");
+ XBT_INFO("Launch an execute(5s), and restart its host right after start");
simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5_restarted", all_hosts[1], []() {
assert_exit(false, 0);
simgrid::s4u::this_actor::execute(500000000);
BEGIN_SECTION("exec restarted in middle")
{
- XBT_INFO("Launch a execute(5s), and restart its host after 2 secs");
+ XBT_INFO("Launch an execute(5s), and restart its host after 2 secs");
simgrid::s4u::ActorPtr exec5 = simgrid::s4u::Actor::create("exec5_restarted", all_hosts[1], []() {
assert_exit(false, 2);
simgrid::s4u::this_actor::execute(500000000);
BEGIN_SECTION("exec restarted at end")
{
- XBT_INFO("Launch a execute(5s), and restart its host right when it stops");
+ XBT_INFO("Launch an execute(5s), and restart its host right when it stops");
bool execution_done = false;
simgrid::s4u::Actor::create("exec5_restarted", all_hosts[1], [&execution_done]() {
$ ./ns3-from-src-to-itself ${platfdir}/ns3-big-cluster.xml --cfg=network/model:ns-3 "--log=root.fmt:[%h:%P(%i)]%e[%c/%p]%e%m%n"
> [:maestro(0)] [xbt_cfg/INFO] Configuration change: Set 'network/model' to 'ns-3'
-> [:maestro(0)] [ns3/WARNING] Sending from an host c-01.rennes to itself is not supported by ns-3. Every such communication finishes immediately upon startup.
+> [:maestro(0)] [ns3/WARNING] Sending from a host c-01.rennes to itself is not supported by ns-3. Every such communication finishes immediately upon startup.
> [c-01.rennes:receiver(1)] [s4u_test/INFO] Done receiving from 2 senders, each of them sending 5 messages
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-# git pre-commit hook that runs an clang-format stylecheck.
+# git pre-commit hook that runs a clang-format stylecheck.
# Features:
# - abort commit when commit does not comply with the style guidelines
# - create a patch of the proposed style changes
