static void action_compute(const char *const *action)
{
- const char *amout = action[2];
- msg_task_t task = MSG_task_create("task", parse_double(amout), 0, NULL);
+ const char *amount = action[2];
+ msg_task_t task = MSG_task_create("task", parse_double(amount), 0, NULL);
double clock = MSG_get_clock();
ACT_DEBUG("Entering %s", NAME);
xbt_dict_t peers; //peers list
xbt_dict_t active_peers; //active peers list
- int round; //current round for the chocking algortihm.
+ int round; //current round for the chocking algorithm.
char mailbox[MAILBOX_SIZE]; //peer mailbox.
/* This example should always be executed using a deployment of
* GRID_SIZE * GRID_SIZE nodes. */
#define GRID_SIZE 3 /* Modify to adjust the grid's size */
-#define NODE_MATRIX_SIZE 300 /* Ammount of work done by each node*/
+#define NODE_MATRIX_SIZE 300 /* Amount of work done by each node*/
#define GRID_NUM_NODES GRID_SIZE * GRID_SIZE
#define MATRIX_SIZE NODE_MATRIX_SIZE * GRID_SIZE
void *data,
double amount);
-XBT_PUBLIC(void) SD_task_distribute_comp_amdhal(SD_task_t task, int ws_count);
+XBT_PUBLIC(void) SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count);
XBT_PUBLIC(void) SD_task_schedulev(SD_task_t task, int count,
const SD_workstation_t * list);
XBT_PUBLIC(void) SD_task_schedulel(SD_task_t task, int count, ...);
*
* Any exception thrown directly from the TRIED_BLOCK block or from called
* subroutines is caught. Cleanups which must be done after this block
- * (whenever an exception arised or not) should be placed into the optionnal
+ * (whenever an exception arose or not) should be placed into the optionnal
* CLEANUP_BLOCK. The code dealing with the exceptions when they arise should
* be placed into the (mandatory) CATCH_BLOCK.
*
/* 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. */
-/* splited away from synchro.h since we areused by dynar.h, and synchro.h uses dynar */
+/* splited away from synchro.h since we are used by dynar.h, and synchro.h uses dynar */
#ifndef _XBT_THREAD_H
void jxbt_throw_process_not_found(JNIEnv * env, const char *invalid_name);
/** Thrown when a transfer failure accure while Sending task */
void jxbt_throw_transfer_failure(JNIEnv * env, char *detail);
-/** Thrown when a host failure accures while Sending task*/
+/** Thrown when a host failure occurs while Sending a task*/
void jxbt_throw_host_failure(JNIEnv * env, char *details);
-/** Thrown when a time out accures While Sending task */
+/** Thrown when a timeout occurs while Sending a task */
void jxbt_throw_time_out_failure(JNIEnv * env, char *details);
/**Thrown when a task is canceled */
void jxbt_throw_task_cancelled(JNIEnv * env, char *details);
}
/**
- * Register applicaiton for MSG
+ * Register application for MSG
*/
static int msg_register_application(lua_State * L)
{
void *start_addr; /* Start address of the map */
void *end_addr; /* End address of the map */
int prot; /* Memory protection */
- int flags; /* Aditional memory flags */
+ int flags; /* Additional memory flags */
void *offset; /* Offset in the file/whatever */
char dev_major; /* Major of the device */
char dev_minor; /* Minor of the device */
* mandatory power.
*
* A parallel computation can be scheduled on any number of host.
- * The underlying speedup model is Amdahl's law.
- * To be auto-scheduled, \see SD_task_distribute_comp_amdhal has to be called
+ * The underlying speedup model is Amdahl's law.
+ * To be auto-scheduled, \see SD_task_distribute_comp_amdahl has to be called
* first.
* \param name the name of the task (can be \c NULL)
* \param data the user data you want to associate with the task (can be \c NULL)
/** @brief Blah
*
*/
-void SD_task_distribute_comp_amdhal(SD_task_t task, int ws_count)
+void SD_task_distribute_comp_amdahl(SD_task_t task, int ws_count)
{
int i;
xbt_assert(task->kind == SD_TASK_COMP_PAR_AMDAHL,
SD_task_get_name(task));
switch (task->kind) {
case SD_TASK_COMP_PAR_AMDAHL:
- SD_task_distribute_comp_amdhal(task, count);
+ SD_task_distribute_comp_amdahl(task, count);
case SD_TASK_COMM_E2E:
case SD_TASK_COMP_SEQ:
xbt_assert(task->workstation_nb == count,
* located (and start them if runnable) */
if (task->kind == SD_TASK_COMP_PAR_AMDAHL) {
XBT_VERB("Schedule computation task %s on %d workstations. %.f flops"
- " will be distributed following Amdahl'Law",
+ " will be distributed following Amdahl's Law",
SD_task_get_name(task), task->workstation_nb,
task->computation_amount[0]);
xbt_dynar_foreach(task->tasks_before, cpt, dep) {
*
* \param workstation a workstation
* \param computation_amount the computation amount you want to evaluate (in flops)
- * \return an approximative astimated computation time for the given computation amount on this workstation (in seconds)
+ * \return an approximative estimated computation time for the given computation amount on this workstation (in seconds)
*/
double SD_workstation_get_computation_time(SD_workstation_t workstation,
double computation_amount)
* \param src the first workstation
* \param dst the second workstation
* \param communication_amount the communication amount you want to evaluate (in bytes)
- * \return an approximative astimated computation time for the given communication amount
+ * \return an approximative estimated computation time for the given communication amount
* between the workstations (in seconds)
*/
double SD_route_get_communication_time(SD_workstation_t src,
#ifdef TIME_BENCH_AMDAHL
xbt_os_cputimer_stop(simix_global->timer_seq);
- XBT_INFO("Amdhal timing informations. Sequential time: %lf; Parallel time: %lf",
+ XBT_INFO("Amdahl timing informations. Sequential time: %lf; Parallel time: %lf",
xbt_os_timer_elapsed(simix_global->timer_seq),
xbt_os_timer_elapsed(simix_global->timer_par));
xbt_os_timer_free(simix_global->timer_seq);
}
total_send = scount;
} else if (!(vrank % 2)) {
- /* non-root, non-leaf nodes, allocte temp buffer for recv
+ /* non-root, non-leaf nodes, allocate temp buffer for recv
* the most we need is rcount*size/2 */
tempbuf = (char *) malloc(rtrue_extent + (rcount*size - 1) * rextent);
if (NULL == tempbuf) {
int comm_size, i;
size_t total_message_size;
- if(sbuf==rbuf)sbuf=MPI_IN_PLACE; //restore MPI_IN_PLACE as these algos handle it
+ if(sbuf==rbuf)sbuf=MPI_IN_PLACE; //restore MPI_IN_PLACE as these algorithms handle it
XBT_DEBUG("smpi_coll_tuned_reduce_scatter_mpich");
if (!power_trace) {
trace->type = TRACE_FIXED;
trace->value = value;
- XBT_DEBUG("No availabily trace. Constant value = %lf", value);
+ XBT_DEBUG("No availability trace. Constant value = %lf", value);
return trace;
}
/* set the remains to 0 due to precision problems when updating the remaining amount */
GENERIC_ACTION(action).remains = 0;
cpu_ti_action_state_set((surf_action_t) action, SURF_ACTION_DONE);
- /* update remaining amout of all actions */
+ /* update remaining amount of all actions */
cpu_ti_update_remaining_amount(surf_cpu_resource_priv(action->cpu), surf_get_clock());
}
#undef GENERIC_ACTION
surf_cpu_ti_tgmr_t avail_trace; /*< Structure with data needed to integrate trace file */
e_surf_resource_state_t state_current; /*< CPU current state (ON or OFF) */
tmgr_trace_event_t state_event; /*< trace file with states events (ON or OFF) */
- tmgr_trace_event_t power_event; /*< trace file with availabitly events */
+ tmgr_trace_event_t power_event; /*< trace file with availability events */
xbt_swag_t action_set; /*< set with all actions running on cpu */
s_xbt_swag_hookup_t modified_cpu_hookup; /*< hookup to swag that indicacates whether share resources must be recalculated or not */
double sum_priority; /*< the sum of actions' priority that are running on cpu */
lmm_variable_t var = NULL;
/*
- * Auxiliar variables.
+ * Auxiliary variables.
*/
int iteration = 0;
double tmp = 0;
typedef struct {
s_as_t generic_routing;
- /* vars for calculate the floyd algorith. */
+ /* vars for calculate the floyd algorithm. */
int *predecessor_table;
double *cost_table;
sg_platf_route_cbarg_t *link_table;
static void add_randomness(void)
{
- /* If needed aditional properties can be added by using the prop tag */
+ /* If needed, additional properties can be added by using the prop tag */
random_data_t random =
random_new(random_generator, 0, random_min, random_max, random_mean,
random_std_deviation);
xbt_test_assert(elm, "Dude ! Got a null elm during traversal!");
xbt_test_log("Id(%u): %s->%s\n", elm->ID, elm->name, elm->data);
xbt_test_assert(!strcmp(elm->name, elm->data),
- "Key(%s) != value(%s). Abording", elm->name,
+ "Key(%s) != value(%s). Aborting", elm->name,
elm->data);
}
}
}
else if (val_p != &attrval[i]) {
errs++;
- fprintf( stderr, "Atribute value for key %d not correct\n",
+ fprintf( stderr, "Attribute value for key %d not correct\n",
i );
}
}
}
else if (val_p != &attrval[i]) {
errs++;
- fprintf( stderr, "Atribute value for key %d not correct\n",
+ fprintf( stderr, "Attribute value for key %d not correct\n",
i );
}
}
}
else if (val_p != &attrval[i]) {
errs++;
- fprintf( stderr, "Atribute value for key %d not correct\n",
+ fprintf( stderr, "Attribute value for key %d not correct\n",
i );
}
}
}
else if (val_p != &attrval[i]) {
lerrs++;
- fprintf( stderr, "Atribute value for key %d not correct\n",
+ fprintf( stderr, "Attribute value for key %d not correct\n",
i );
}
}
#include "mpi.h"
#include "mpitest.h"
-/* Test bsend with a buffer with arbitray alignment */
+/* Test bsend with a buffer with arbitrary alignment */
#define BUFSIZE 2000*4
int main( int argc, char *argv[] )
{
sigwaiter_mutex = xbt_os_mutex_init();
sigwaiter_cond = xbt_os_cond_init();
xbt_os_mutex_acquire(sigwaiter_mutex);
- sigwaiter_thread = xbt_os_thread_create("Armaggedon request waiter",
+ sigwaiter_thread = xbt_os_thread_create("Armageddon request waiter",
armageddon_sigwaiter, NULL, NULL);
/* Wait for thread to start... */
xbt_os_cond_wait(sigwaiter_cond, sigwaiter_mutex);
