/** Helper class loading the native functions of SimGrid that we use for downcalls
*
- * Almost all org.simgrid.msg.* classes contain a static bloc (thus executed when the class is loaded)
+ * Almost all org.simgrid.msg.* classes contain a static block (thus executed when the class is loaded)
* containing a call to this.
*/
public final class NativeLib {
* If 0, then it cannot be executed with the execute() method.
* This value has to be ≥ 0.
*
- * @param bytesAmount A value of amount of data (in bytes) needed to transfert this task.
+ * @param bytesAmount A value of amount of data (in bytes) needed to transfer this task.
* If 0, then it cannot be transferred with the get() and put() methods.
* This value has to be ≥ 0.
*/
* @param flopsAmount A value of the processing amount (in flop) needed
* to process the task. If 0, then it cannot be executed
* with the execute() method. This value has to be >= 0.
- * @param bytesAmount A value of amount of data (in bytes) needed to transfert
+ * @param bytesAmount A value of amount of data (in bytes) needed to transfer
* this task. If 0, then it cannot be transferred this task.
* If 0, then it cannot be transferred with the get() and put()
* methods. This value has to be >= 0.
Msg.info("Migration of VM "+this.getName()+" to "+destination.getName()+" is impossible ("+e.getMessage()+")");
throw new HostFailureException(e.getMessage());
}
- // If the migration correcly returned, then we should change the currentHost value.
+ // If the migration correctly returned, then we should change the currentHost value.
this.currentHost = destination;
}
private native void nativeMigration(Host destination) throws MsgException;
#include <lua.hpp>
/* ********************************************************************************* */
-/* Plaftorm functions */
+/* Platform functions */
/* ********************************************************************************* */
extern "C" {
/* Class Host */
py::class_<simgrid::s4u::Host, std::unique_ptr<Host, py::nodelete>>(m, "Host", "Simulated host")
.def("by_name", &Host::by_name, "Retrieves a host from its name, or die")
- .def("get_pstate_count", &Host::get_pstate_count, "Retrieve the cound of defined pstate levels")
+ .def("get_pstate_count", &Host::get_pstate_count, "Retrieve the count of defined pstate levels")
.def("get_pstate_speed", &Host::get_pstate_speed, "Retrieve the maximal speed at the given pstate")
.def_property(
"pstate", &Host::get_pstate,
Constraint* get_constraint(unsigned num) const { return num < cnsts_.size() ? cnsts_[num].constraint : nullptr; }
/**
- * @brief Get the weigth of the numth constraint associated to the variable
+ * @brief Get the weight of the numth constraint associated to the variable
* @param num The rank of constraint we want to get
* @return The numth constraint
*/
/** The process of this address space
*
- * This is where we can get debug informations, memory layout, etc.
+ * This is where we can get debug information, memory layout, etc.
*/
simgrid::mc::RemoteSimulation* get_remote_simulation() const { return remote_simulation_; }
void ModelChecker::shutdown()
{
- XBT_DEBUG("Shuting down model-checker");
+ XBT_DEBUG("Shutting down model-checker");
RemoteSimulation* process = &this->get_remote_simulation();
if (process->running()) {
case MC_MESSAGE_IGNORE_HEAP:
{
s_mc_message_ignore_heap_t message;
- xbt_assert(size == sizeof(message), "Broken messsage");
+ xbt_assert(size == sizeof(message), "Broken message");
memcpy(&message, buffer, sizeof(message));
IgnoredHeapRegion region;
case MC_MESSAGE_UNIGNORE_HEAP:
{
s_mc_message_ignore_memory_t message;
- xbt_assert(size == sizeof(message), "Broken messsage");
+ xbt_assert(size == sizeof(message), "Broken message");
memcpy(&message, buffer, sizeof(message));
get_remote_simulation().unignore_heap((void*)(std::uintptr_t)message.addr, message.size);
break;
case MC_MESSAGE_IGNORE_MEMORY:
{
s_mc_message_ignore_memory_t message;
- xbt_assert(size == sizeof(message), "Broken messsage");
+ xbt_assert(size == sizeof(message), "Broken message");
memcpy(&message, buffer, sizeof(message));
this->get_remote_simulation().ignore_region(message.addr, message.size);
break;
case MC_MESSAGE_STACK_REGION:
{
s_mc_message_stack_region_t message;
- xbt_assert(size == sizeof(message), "Broken messsage");
+ xbt_assert(size == sizeof(message), "Broken message");
memcpy(&message, buffer, sizeof(message));
this->get_remote_simulation().stack_areas().push_back(message.stack_region);
}
case xbt_automaton_exp_label::AUT_ONE:
return true;
default:
- xbt_die("Unexpected vaue for automaton");
+ xbt_die("Unexpected value for automaton");
}
}
continue;
}
- xbt_assert(heapinfo1->type >= 0, "Unkown mmalloc block type: %d", heapinfo1->type);
+ xbt_assert(heapinfo1->type >= 0, "Unknown mmalloc block type: %d", heapinfo1->type);
void* addr_block1 = ((void*)(((ADDR2UINT(i1)) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase));
continue;
}
- xbt_assert(heapinfo2b->type >= 0, "Unkown mmalloc block type: %d", heapinfo2b->type);
+ xbt_assert(heapinfo2b->type >= 0, "Unknown mmalloc block type: %d", heapinfo2b->type);
for (size_t j2 = 0; j2 < (size_t)(BLOCKSIZE >> heapinfo2b->type); j2++) {
if (i2 == i1 && j2 == j1)
/** Context of evaluation of a DWARF expression
*
* Some DWARF instructions need to read the CPU registers,
- * the process memory, etc. All those informations are gathered in
+ * the process memory, etc. All those information are gathered in
* the evaluation context.
*/
struct ExpressionContext {
public:
ObjectInformation() = default;
- // Not copyable:
+ // Not copiable:
ObjectInformation(ObjectInformation const&) = delete;
ObjectInformation& operator=(ObjectInformation const&) = delete;
XBT_PRIVATE std::shared_ptr<ObjectInformation> createObjectInformation(std::vector<simgrid::xbt::VmMap> const& maps,
const char* name);
-/** Augment the current module with informations about the other ones */
+/** Augment the current module with information about the other ones */
XBT_PRIVATE void postProcessObjectInformation(const simgrid::mc::RemoteSimulation* process,
simgrid::mc::ObjectInformation* info);
} // namespace mc
/** @brief Process a DIE
*
- * @param info the resulting object fot the library/binary file (output)
+ * @param info the resulting object for the library/binary file (output)
* @param die the current DIE
* @param unit the DIE of the compile unit of the current DIE
* @param frame containing frame if any
/** @brief Calls MC_dwarf_handle_die on all children of the given die
*
- * @param info the resulting object fot the library/binary file (output)
+ * @param info the resulting object for the library/binary file (output)
* @param die the current DIE
* @param unit the DIE of the compile unit of the current DIE
* @param frame containing frame if any
/** @brief Handle a variable (DW_TAG_variable or other)
*
- * @param info the resulting object fot the library/binary file (output)
+ * @param info the resulting object for the library/binary file (output)
* @param die the current DIE
* @param unit the DIE of the compile unit of the current DIE
* @param frame containing frame if any
return std::string();
}
-/** @brief Populate the debugging informations of the given ELF object
+/** @brief Populate the debugging information of the given ELF object
*
* Read the DWARf information of the EFFL object and populate the
* lists of types, variables, functions.
dwarf_end(dwarf);
// If there was no DWARF in the file, try to find it in a separate file.
- // Different methods might be used to store the DWARF informations:
+ // Different methods might be used to store the DWARF information:
// * GNU NT_GNU_BUILD_ID
// * .gnu_debuglink
// See https://sourceware.org/gdb/onlinedocs/gdb/Separate-Debug-Files.html
namespace simgrid {
namespace mc {
-/** @brief Finds informations about a given shared object/executable */
+/** @brief Finds information about a given shared object/executable */
std::shared_ptr<ObjectInformation> createObjectInformation(std::vector<xbt::VmMap> const& maps, const char* name)
{
std::shared_ptr<ObjectInformation> result = std::make_shared<ObjectInformation>();
return 0;
}
-/** Find informations about a function (libunwind method)
+/** Find information about a function (libunwind method)
*/
int UnwindContext::get_proc_name(unw_addr_space_t /*as*/, unw_word_t addr, char* bufp, size_t buf_len, unw_word_t* offp,
void* arg) noexcept
* Libunwind implementation for the model-checker
*
* Libunwind provides an pluggable stack unwinding API: the way the current
- * registers and memory is accessed, the way unwinding informations is found
+ * registers and memory is accessed, the way unwinding information is found
* is pluggable.
*
* This component implements the libunwind API for he model-checker:
/** \file mc_record.hpp
*
- * This file contains the MC replay/record functionnality.
+ * 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`.
*
message.addr = (std::uintptr_t)addr;
message.size = size;
if (channel_.send(message))
- xbt_die("Could not send IGNORE_MEMORY mesage to model-checker");
+ xbt_die("Could not send IGNORE_MEMORY message to model-checker");
}
void AppSide::ignore_heap(void* address, std::size_t size)
/** @brief Storage for snapshot memory pages
*
* The first (lower) layer of the per-page snapshot mechanism is a page store:
- * its responsibility is to store immutable sharable reference-counted memory
+ * its responsibility is to store immutable shareable reference-counted memory
* pages independently of the snapshotting logic. Snapshot management and
* representation is handled to an higher layer. READMORE
*
MPI_Request savedreq = *request;
if (savedreq != MPI_REQUEST_NULL && not(savedreq->flags() & MPI_REQ_FINISHED)
&& not(savedreq->flags() & MPI_REQ_GENERALIZED))
- savedreq->ref();//don't erase te handle in Request::wait, we'll need it later
+ savedreq->ref();//don't erase the handle in Request::wait, we'll need it later
else
savedreq = MPI_REQUEST_NULL;
MPI_Request* rrequest_array = new MPI_Request[size];
MPI_Request* srequest_array = new MPI_Request[size];
- // irregular case use default MPI fucntions
+ // irregular case use default MPI functions
if (scount * sextent != rcount * rextent) {
XBT_WARN("MPI_allgather_NTSLR_NB use default MPI_allgather.");
allgather__default(sbuf, scount, stype, rbuf, rcount, rtype, comm);
rextent = rtype->get_extent();
sextent = stype->get_extent();
- // irregular case use default MPI fucntions
+ // irregular case use default MPI functions
if (scount * sextent != rcount * rextent) {
XBT_WARN("MPI_allgather_NTSLR use default MPI_allgather.");
allgather__default(sbuf, scount, stype, rbuf, rcount, rtype, comm);
- Rest of the steps:
update recv_data_from according to offset, and
exchange two blocks with appropriate neighbor.
- the send location becomes previous receve location.
+ the send location becomes previous receive location.
*/
tmprecv = (char*)rbuf + neighbor[0] * rcount * rext;
tmpsend = (char*)rbuf + rank * rcount * rext;
- Rest of the steps:
update recv_data_from according to offset, and
exchange two blocks with appropriate neighbor.
- the send location becomes previous receve location.
+ the send location becomes previous receive location.
Note, we need to create indexed datatype to send and receive these
blocks properly.
*/
}
}
- /* Broadcasting the mesage from leader to the rest */
+ /* Broadcasting the message from leader to the rest */
/* Note: shared memory broadcast could improve the performance */
mpi_errno = colls::bcast(recvbuf, count, datatype, 0, shmem_comm);
* [02b] [12b] [22b]
*
* COMPUTATION PHASE 0 (a)
- * Step 0: rank r sends block ra to rank (r+1) and receives bloc (r-1)a
+ * Step 0: rank r sends block ra to rank (r+1) and receives block (r-1)a
* from rank (r-1) [with wraparound].
* # 0 1 2
* [00a] [00a+10a] [20a]
* [22a+02a] [12a] [22a]
* [02b] [12b] [22b]
*
- * Step 1: rank r sends block (r-1)a to rank (r+1) and receives bloc
+ * Step 1: rank r sends block (r-1)a to rank (r+1) and receives block
* (r-2)a from rank (r-1) [with wraparound].
* # 0 1 2
* [00a] [00a+10a] [00a+10a+20a]
* [02b] [12b] [22b]
*
* COMPUTATION PHASE 1 (b)
- * Step 0: rank r sends block rb to rank (r+1) and receives bloc (r-1)b
+ * Step 0: rank r sends block rb to rank (r+1) and receives block (r-1)b
* from rank (r-1) [with wraparound].
* # 0 1 2
* [00a] [00a+10a] [20a]
* [22a+02a] [12a] [22a]
* [22b+02b] [12b] [22b]
*
- * Step 1: rank r sends block (r-1)b to rank (r+1) and receives bloc
+ * Step 1: rank r sends block (r-1)b to rank (r+1) and receives block
* (r-2)b from rank (r-1) [with wraparound].
* # 0 1 2
* [00a] [00a+10a] [00a+10a+20a]
*/
/*
-This fucntion performs all-reduce operation as follow. ** in a pipeline fashion **
+This function performs all-reduce operation as follow. ** in a pipeline fashion **
1) binomial_tree reduce inside each SMP node
2) binomial_tree reduce intra-communication between root of each SMP node
3) binomial_tree bcast intra-communication between root of each SMP node
//#include <star-reduction.c>
/*
-This fucntion performs all-reduce operation as follow.
+This function performs all-reduce operation as follow.
1) binomial_tree reduce inside each SMP node
2) binomial_tree reduce intra-communication between root of each SMP node
3) binomial_tree bcast intra-communication between root of each SMP node
//#include <star-reduction.c>
/*
-This fucntion performs all-reduce operation as follow.
+This function performs all-reduce operation as follow.
1) binomial_tree reduce inside each SMP node
2) Recursive doubling intra-communication between root of each SMP node
3) binomial_tree bcast inside each SMP node
//#include <star-reduction.c>
/*
-This fucntion performs all-reduce operation as follow.
+This function performs all-reduce operation as follow.
1) binomial_tree reduce inside each SMP node
2) reduce-scatter -inter between root of each SMP node
3) allgather - inter between root of each SMP node
/*
-This fucntion performs all-reduce operation as follow.
+This function performs all-reduce operation as follow.
1) binomial_tree reduce inside each SMP node
2) reduce-scatter -inter between root of each SMP node
3) allgather - inter between root of each SMP node
#include "../colls_private.hpp"
/*
-This fucntion performs all-reduce operation as follow.
+This function performs all-reduce operation as follow.
1) binomial_tree reduce inside each SMP node
2) reduce-scatter -inter between root of each SMP node
3) allgather - inter between root of each SMP node
#include "../colls_private.hpp"
/*
- * Barrier is ment to be a synchronous operation, as some BTLs can mark
+ * Barrier is meant to be a synchronous operation, as some BTLs can mark
* a request done before its passed to the NIC and progress might not be made
* elsewhere we cannot allow a process to exit the barrier until its last
* [round of] sends are completed.
int segindex, i, lr, pair;
int segcount[2]; /* Number ompi_request_wait_allof elements sent with each segment */
uint32_t counts[2];
- int num_segments[2]; /* Number of segmenets */
+ int num_segments[2]; /* Number of segments */
int sendcount[2]; /* the same like segcount, except for the last segment */
size_t realsegsize[2];
char *tmpbuf[2];
Request::send(tmpbuf[lr], segcount[lr], datatype, tree->tree_next[i], COLL_TAG_BCAST, comm);
} /* end of for each child */
- /* upate the base request */
+ /* update the base request */
base_req = new_req;
/* go to the next buffer (ie. the one corresponding to the next recv) */
tmpbuf[lr] += realsegsize[lr];
}
// This process is responsible for all processes that have bits
- // set from the LSB upto (but not including) mask. Because of
+ // set from the LSB up to (but not including) mask. Because of
// the "not including", we start by shifting mask back down
// one.
}
/* This process is responsible for all processes that have bits
- set from the LSB upto (but not including) mask. Because of
+ set from the LSB up to (but not including) mask. Because of
the "not including", we start by shifting mask back down
one. */
*/
else {
- /* If the number of segments is less than a maximum number of oustanding
+ /* If the number of segments is less than a maximum number of outstanding
requests or there is no limit on the maximum number of outstanding
requests, we send data to the parent using blocking send */
if ((0 == max_outstanding_reqs) ||
otherwise the new protocol is used (see variable Ldb).
3) These lines show the bandwidth (= buffer length / execution time)
for both protocols.
- 4) This line shows that the limit is choosen well if the ratio is
- between 0.95 (loosing 5% for buffer length near and >=limit)
+ 4) This line shows that the limit is chosen well if the ratio is
+ between 0.95 (losing 5% for buffer length near and >=limit)
and 1.10 (not gaining 10% for buffer length near and <limit).
5) This line shows that the new protocol is 2..7 times faster
for long counts.
constexpr unsigned DT_FLAG_NO_GAPS = 0x0080; /**< no gaps around the datatype */
constexpr unsigned DT_FLAG_DATA = 0x0100; /**< data or control structure */
constexpr unsigned DT_FLAG_ONE_SIDED = 0x0200; /**< datatype can be used for one sided operations */
-constexpr unsigned DT_FLAG_UNAVAILABLE = 0x0400; /**< datatypes unavailable on the build (OS or compiler dependant) */
+constexpr unsigned DT_FLAG_UNAVAILABLE = 0x0400; /**< datatypes unavailable on the build (OS or compiler dependent) */
constexpr unsigned DT_FLAG_DERIVED = 0x0800; /**< is the datatype derived ? */
/*
* We should make the difference here between the predefined contiguous and non contiguous
-/* Handle Fortan - C conversion for MPI Types*/
+/* Handle Fortran - C conversion for MPI Types*/
/* Copyright (c) 2010-2020. The SimGrid Team.
* All rights reserved. */
arg_size = status.count;
}
- bool is_recv = false; // Help analyzers understanding that status is not used unintialized
+ bool is_recv = false; // Help analyzers understanding that status is not used uninitialized
if (get_name() == "recv") {
is_recv = true;
Request::recv(nullptr, arg_size, args.datatype1, args.partner, args.tag, MPI_COMM_WORLD, &status);
// after a host got another actor assigned (or moved from).
// We can't use std::priorityQueue here because we modify *two* elements: The top element, which
// we can access and which has the lowest load, gets a new actor assigned.
- // However, the host loosing that actor must be updated as well.
+ // However, the host losing that actor must be updated as well.
// std::priorityQueue is immutable and hence doesn't work for us.
//
// This heap contains the least loaded host at the top
if (action->latency_ > 0) {
action->set_variable(get_maxmin_system()->variable_new(action, 0.0, -1.0, constraints_per_variable));
if (is_update_lazy()) {
- // add to the heap the event when the latency is payed
+ // add to the heap the event when the latency is paid
double date = action->latency_ + action->get_last_update();
ActionHeap::Type type = route.empty() ? ActionHeap::Type::normal : ActionHeap::Type::latency;
// WIFI links are handled manually just above, so skip them now
if (link->get_sharing_policy() == s4u::Link::SharingPolicy::WIFI) {
xbt_assert(link == src_wifi_link || link == dst_wifi_link,
- "Wifi links can only occure at the beginning of the route (meaning that it's attached to the src) or "
+ "Wifi links can only occur at the beginning of the route (meaning that it's attached to the src) or "
"at its end (meaning that it's attached to the dst");
} else {
get_maxmin_system()->expand(link->get_constraint(), action->get_variable(), 1.0);
std::vector<Metric> new_bandwidths;
for (auto bandwidth : bandwidths_){
- // Instanciate decay model relatively to the actual bandwidth
+ // Instantiate decay model relatively to the actual bandwidth
double max_bw=bandwidth.peak;
double min_bw=bandwidth.peak-(wifi_max_rate_-wifi_min_rate_);
double model_rate=bandwidth.peak-(wifi_max_rate_-model_rate_);
/** @brief Hold every rates association between host and links (host name, rates id) */
std::map<xbt::string, int> host_rates_;
- /** @brief A link can have several bandwith attach to it (mostly use by wifi model) */
+ /** @brief A link can have several bandwidths attached to it (mostly use by wifi model) */
std::vector<Metric> bandwidths_;
/** @brief Should we use the decay model ? */
va_start(ev->ap, fmt);
done = cat->layout->do_layout(cat->layout, ev, fmt);
va_end(ev->ap);
- ev->buffer = nullptr; // Calm down, static analyzers, this pointer to local array wont leak out of the scope.
+ ev->buffer = nullptr; // Calm down, static analyzers, this pointer to local array won't leak out of the scope.
if (done) {
appender->do_append(appender, buff);
} else {
default:
if (type < 0) {
- fprintf(stderr, "Unkown mmalloc block type.\n");
+ fprintf(stderr, "Unknown mmalloc block type.\n");
abort();
}
default: /* Fragment -> ??; type=logarithm to base two of the fragment size. */
if (type < 0) {
- fprintf(stderr, "Unkown mmalloc block type.\n");
+ fprintf(stderr, "Unknown mmalloc block type.\n");
abort();
}
test_split_quoted("Protected space", "toto\\ tutu", {"toto tutu"});
test_split_quoted("Several spaces", "toto tutu", {"toto", "tutu"});
test_split_quoted("LTriming", " toto tatu", {"toto", "tatu"});
- test_split_quoted("Triming", " toto tutu ", {"toto", "tutu"});
+ test_split_quoted("Trimming", " toto tutu ", {"toto", "tutu"});
test_split_quoted("Single quotes", "'toto tutu' tata", {"toto tutu", "tata"});
test_split_quoted("Double quotes", "\"toto tutu\" tata", {"toto tutu", "tata"});
test_split_quoted("Mixed quotes", "\"toto' 'tutu\" tata", {"toto' 'tutu", "tata"});
