{
if (!cmd)
return;
- if (cmd->who)
- free(cmd->who);
- if (cmd->comment)
- free(cmd->comment);
- if (cmd->str_arg)
- free(cmd->str_arg);
+ free(cmd->who);
+ free(cmd->comment);
+ free(cmd->str_arg);
free(cmd);
}
XBT_VERB("%s %f", name, MSG_get_clock() - clock);
- if (XBT_LOG_ISENABLED(actions, xbt_log_priority_verbose))
- free(name);
+ free(name);
#ifdef HAVE_TRACING
TRACE_smpi_ptp_out(rank, rank, dst_traced, "send");
MSG_task_destroy(task);
}
- if (XBT_LOG_ISENABLED(actions, xbt_log_priority_verbose))
- free(name);
+ free(name);
#ifdef HAVE_TRACING
TRACE_smpi_ptp_out(rank, src_traced, rank, "recv");
TRACE_smpi_recv(rank, src_traced, rank);
MSG_task_destroy(task);
XBT_VERB("%s %f", name, MSG_get_clock() - clock);
- if (XBT_LOG_ISENABLED(actions, xbt_log_priority_verbose))
- free(name);
+ free(name);
#ifdef HAVE_TRACING
TRACE_smpi_ptp_out(rank, src_traced, rank, "wait");
TRACE_smpi_recv(rank, src_traced, rank);
mutex=NULL;
}
- if (XBT_LOG_ISENABLED(actions, xbt_log_priority_verbose))
- free(name);
+ free(name);
}
MSG_process_sleep(parse_double(duration));
XBT_VERB("%s %f ", name, MSG_get_clock() - clock);
- if (XBT_LOG_ISENABLED(actions, xbt_log_priority_verbose))
- free(name);
+ free(name);
}
static void action_allReduce(const char *const *action) {
name = xbt_str_join_array(action, " ");
communicator_size = parse_double(size);
XBT_VERB("%s %f", name, MSG_get_clock() - clock);
- if (XBT_LOG_ISENABLED(actions, xbt_log_priority_verbose))
- free(name);
+ free(name);
}
static void action_compute(const char *const *action)
MSG_task_execute(task);
MSG_task_destroy(task);
XBT_VERB("%s %f", name, MSG_get_clock() - clock);
- if (XBT_LOG_ISENABLED(actions, xbt_log_priority_verbose))
- free(name);
+ free(name);
}
static void action_init(const char *const *action)
res = xbt_malloc(s);
}
} else {
- if (p) {
- free(p);
- }
+ free(p);
}
return res;
}
/* moddata */
amok_pm_moddata_t mod = (amok_pm_moddata_t) p;
- if (mod->groups)
- xbt_dict_free(&mod->groups);
+ xbt_dict_free(&mod->groups);
/* callbacks */
gras_cb_unregister("amok_pm_kill", &amok_pm_cb_kill);
"\n"
" /* cleanup the place */\n"
" gras_clean();\n"
- " if (gras_log)\n" " free(gras_log);\n" " return 0;\n" "}\n";
+ " free(gras_log);\n"
+ " return 0;\n"
+ "}\n";
/***************************************
xbt_dynar_free_container(&varstack); /*already empty, save a test ;) */
}
- if (var->data)
- free(var->data);
+ free(var->data);
free(var);
free(name);
}
gras_dd_cat_field_t field = *(gras_dd_cat_field_t *) f;
XBT_IN("");
if (field) {
- if (field->name)
- free(field->name);
+ free(field->name);
free(field);
}
XBT_OUT();
("socket_close called on the unknown incoming socket %p (port=%d)",
sock, sockdata->server_port);
}
- if (sock->data) {
- /* FIXME: kill the rdv point if receiver side */
- free(sock->data);
- }
+ /* FIXME: kill the rdv point if receiver side */
+ free(sock->data);
XBT_OUT();
}
if (data)
memcpy(data, msg_got->payl, size);
- if (msg_got->payl)
- xbt_free(msg_got->payl);
+ xbt_free(msg_got->payl);
xbt_free(msg_got);
SIMIX_req_mutex_unlock(remote_sock_data->mutex);
if (!sock)
return; /* close only once */
- if (((gras_trp_tcp_sock_data_t)sock->data)->peer_name)
- free(((gras_trp_tcp_sock_data_t)sock->data)->peer_name);
+ free(((gras_trp_tcp_sock_data_t)sock->data)->peer_name);
free(sock->data);
XBT_VERB("close tcp connection %d", sock->sd);
data->in_buf.size - data->in_buf.pos,
data->in_buf.size, data->in_buf.pos);
}
- if (data->in_buf.data)
- free(data->in_buf.data);
+ free(data->in_buf.data);
if (data->out_buf.size != data->out_buf.pos) {
XBT_DEBUG("Flush the socket before closing (in=%d,out=%d)",
data->in_buf.size, data->out_buf.size);
gras_trp_bufiov_flush(sock);
}
- if (data->out_buf.data)
- free(data->out_buf.data);
+ free(data->out_buf.data);
#ifdef HAVE_READV
if (data->in_buf_v) {
const char *gras_os_hostport()
{
static char *res = NULL;
- if (res)
- free(res); /* my port may have changed */
+ free(res); /* my port may have changed */
res = bprintf("%s:%d", gras_os_myname(), gras_os_myport());
return (const char *) res;
}
void gras_emul_exit(void)
{
- if (locbuf)
- free(locbuf);
+ free(locbuf);
xbt_dict_free(&benchmark_set);
xbt_os_timer_free(timer);
}
int begin, increment;
if (buffsize < 5 * (size + 1)) {
- if (buff)
- free(buff);
+ free(buff);
buffsize = 5 * (size + 1);
buff = xbt_malloc(buffsize);
}
static XBT_INLINE void surf_resource_free(void *r)
{
surf_resource_t resource = r;
- if (resource->name)
- free(resource->name);
- if (resource->properties)
- xbt_dict_free(&resource->properties);
+ free(resource->name);
+ xbt_dict_free(&resource->properties);
free(resource);
}
static void jed_free_container(jed_simgrid_container_t container) {
xbt_dict_free(&container->name2id);
- if( container->resource_list != NULL ) {
- xbt_dynar_free(&container->resource_list);
- }
+ xbt_dynar_free(&container->resource_list);
if( container->container_children != NULL ) {
unsigned int iter;
ret->mapsize++;
}
- if (line)
- free(line);
+ free(line);
return ret;
}
}
}
- if (action_line)
- free(action_line);
+ free(action_line);
if (path)
fclose(action_fp);
xbt_dict_free(&action_queues);
{
if (*p == NULL)
return;
- if ((*p)->name != NULL)
- free ((*p)->name);
+ free((*p)->name);
free (*p);
*p = NULL;
}
xbt_mallocator_free(sd_global->task_mallocator);
- XBT_DEBUG("Destroying workstation and link arrays if necessary...");
- if (sd_global->workstation_list != NULL)
- xbt_free(sd_global->workstation_list);
-
- if (sd_global->link_list != NULL)
- xbt_free(sd_global->link_list);
-
- if (sd_global->recyclable_route != NULL)
- xbt_free(sd_global->recyclable_route);
+ XBT_DEBUG("Destroying workstation and link arrays...");
+ xbt_free(sd_global->workstation_list);
+ xbt_free(sd_global->link_list);
+ xbt_free(sd_global->recyclable_route);
XBT_DEBUG("Destroying the swags...");
xbt_swag_free(sd_global->not_scheduled_task_set);
*/
static void __SD_task_dependency_destroy(void *dependency)
{
- if (((SD_dependency_t) dependency)->name != NULL)
- xbt_free(((SD_dependency_t) dependency)->name);
+ xbt_free(((SD_dependency_t)dependency)->name);
xbt_free(dependency);
}
/* free argv */
if (context->argv) {
for (i = 0; i < context->argc; i++)
- if (context->argv[i])
- free(context->argv[i]);
+ free(context->argv[i]);
free(context->argv);
}
SIMIX_context_free(process->context);
/* Free the exception allocated at creation time */
- if (process->running_ctx)
- free(process->running_ctx);
- if (process->properties)
- xbt_dict_free(&process->properties);
+ free(process->running_ctx);
+ xbt_dict_free(&process->properties);
xbt_fifo_free(process->comms);
free(process->name);
- process->name = NULL;
free(process);
}
}
void smpi_bench_destroy(void)
{
- if (allocs) {
- xbt_dict_free(&allocs);
- }
- if (samples) {
- xbt_dict_free(&samples);
- }
- if(calls) {
- xbt_dict_free(&calls);
- }
+ xbt_dict_free(&allocs);
+ xbt_dict_free(&samples);
+ xbt_dict_free(&calls);
}
static void smpi_execute_flops(double flops)
lmm_variable_free(cpu_maxmin_system,
((surf_action_cpu_Cas01_t) action)->variable);
#ifdef HAVE_TRACING
- if (action->category)
- xbt_free(action->category);
+ xbt_free(action->category);
#endif
surf_action_free(&action);
return 1;
((cpu_Cas01_im_t) ACTION_GET_CPU(action))->action_set);
xbt_swag_insert(ACTION_GET_CPU(action), cpu_im_modified_cpu);
#ifdef HAVE_TRACING
- if (action->category)
- xbt_free(action->category);
+ xbt_free(action->category);
#endif
surf_action_free(&action);
return 1;
static void surf_cpu_ti_free_trace(surf_cpu_ti_trace_t trace)
{
- if (trace->time_points)
- xbt_free(trace->time_points);
- if (trace->integral)
- xbt_free(trace->integral);
+ xbt_free(trace->time_points);
+ xbt_free(trace->integral);
xbt_free(trace);
}
#ifdef HAVE_TRACING
xbt_free(((surf_action_network_CM02_t) action)->src_name);
xbt_free(((surf_action_network_CM02_t) action)->dst_name);
- if (action->category)
- xbt_free(action->category);
+ xbt_free(action->category);
#endif
surf_action_free(&action);
return 1;
if (!action->refcount) {
xbt_swag_remove(action, action->state_set);
#ifdef HAVE_TRACING
- if (action->category)
- xbt_free(action->category);
+ xbt_free(action->category);
#endif
surf_action_free(&action);
return 1;
#ifdef HAVE_TRACING
xbt_free(((surf_action_network_CM02_im_t) action)->src_name);
xbt_free(((surf_action_network_CM02_im_t) action)->dst_name);
- if (action->category)
- xbt_free(action->category);
+ xbt_free(action->category);
#endif
surf_action_free(&action);
return 1;
}
static void ns3_free_dynar(void * elmts){
- if(elmts)
- free(elmts);
+ free(elmts);
return;
}
#ifdef HAVE_TRACING
xbt_free(((surf_action_network_ns3_t)action)->src_name);
xbt_free(((surf_action_network_ns3_t)action)->dst_name);
- if (action->category)
- xbt_free(action->category);
+ xbt_free(action->category);
#endif
XBT_DEBUG ("Removing action %p", action);
surf_action_free(&action);
}
surf_action_exit();
- if (surf_path)
- xbt_dynar_free(&surf_path);
+ xbt_dynar_free(&surf_path);
xbt_lib_free(&host_lib);
xbt_lib_free(&link_lib);
{
if (e_route) {
xbt_dynar_free(&(e_route->generic_route.link_list));
- if (e_route->src_gateway)
- xbt_free(e_route->src_gateway);
- if (e_route->dst_gateway)
- xbt_free(e_route->dst_gateway);
+ xbt_free(e_route->src_gateway);
+ xbt_free(e_route->dst_gateway);
xbt_free(e_route);
}
}
bprintf("%s%s_router%s", struct_cluster->prefix, struct_cluster->id,
struct_cluster->suffix);
sg_platf_new_router(&router);
- if (newid)
- free(newid);
+ free(newid);
//Make the backbone
if ((struct_cluster->bb_bw != 0) && (struct_cluster->bb_lat != 0)) {
static void graph_node_map_elem_free(void *e)
{
graph_node_map_element_t elm = (graph_node_map_element_t) e;
- if (elm) {
- xbt_free(elm);
- }
+ xbt_free(elm);
}
static void graph_edge_data_free(void *e)
route_extended_t e_route = (route_extended_t) e;
if (e_route) {
xbt_dynar_free(&(e_route->generic_route.link_list));
- if (e_route->src_gateway)
- xbt_free(e_route->src_gateway);
- if (e_route->dst_gateway)
- xbt_free(e_route->dst_gateway);
+ xbt_free(e_route->src_gateway);
+ xbt_free(e_route->dst_gateway);
xbt_free(e_route);
}
}
void surf_parse_close(void)
{
- if (surf_input_buffer_stack)
- xbt_dynar_free(&surf_input_buffer_stack);
- if (surf_file_to_parse_stack)
- xbt_dynar_free(&surf_file_to_parse_stack);
+ xbt_dynar_free(&surf_input_buffer_stack);
+ xbt_dynar_free(&surf_file_to_parse_stack);
if (surf_file_to_parse) {
surf_parse__delete_buffer(surf_input_buffer);
static void ptask_finalize(void)
{
- if (ptask_parallel_task_link_set != NULL)
- xbt_dict_free(&ptask_parallel_task_link_set);
+ xbt_dict_free(&ptask_parallel_task_link_set);
surf_model_exit(surf_workstation_model);
surf_workstation_model = NULL;
char *data;
xbt_dynar_foreach(path, cpt, data) {
- if (binary_name)
- free(binary_name);
+ free(binary_name);
binary_name = bprintf("%s/%s", data, xbt_binary_name);
if (!stat(binary_name, &stat_buf)) {
/* Found. */
*/
XBT_INLINE void xbt_dict_cursor_free(xbt_dict_cursor_t * cursor)
{
- if (*cursor) {
- xbt_free(*cursor);
- *cursor = NULL;
- }
+ xbt_free(*cursor);
+ *cursor = NULL;
}
/*
_dynar_map(dynar, dynar->free_f);
}
/*
- if (dynar->data)
free(dynar->data);
dynar->size = 0;
{
int i;
- if (e.msg)
- free(e.msg);
+ free(e.msg);
if (e.remote) {
free(e.procname);
free(e.file);
if (e.bt_strings) {
for (i = 0; i < e.used; i++)
- free((char *) e.bt_strings[i]);
- free((char **) e.bt_strings);
+ free(e.bt_strings[i]);
+ free(e.bt_strings);
}
/* memset(e,0,sizeof(xbt_ex_t)); */
}
strcpy(cp2, "bar");
}
TRY_CLEANUP {
- if (cp3 != NULL)
- free(cp3);
- if (cp2 != NULL)
- free(cp2);
- if (cp1 != NULL)
- free(cp1);
+ free(cp3);
+ free(cp2);
+ free(cp1);
}
CATCH_ANONYMOUS {
printf("cp3=%s", cp3);
}
TRY_CLEANUP { /*04 */
printf("cp3=%s", cp3 == NULL /*02 */ ? "" : cp3);
- if (cp3 != NULL)
- free(cp3);
- if (cp2 != NULL)
- free(cp2);
+ free(cp3);
+ free(cp2);
/*05 cp1 was given away */
}
CATCH_ANONYMOUS {
void xbt_graph_parse_close(void)
{
- if (xbt_graph_input_buffer_stack)
- xbt_dynar_free(&xbt_graph_input_buffer_stack);
- if (xbt_graph_file_to_parse_stack)
- xbt_dynar_free(&xbt_graph_file_to_parse_stack);
+ xbt_dynar_free(&xbt_graph_input_buffer_stack);
+ xbt_dynar_free(&xbt_graph_file_to_parse_stack);
if (xbt_graph_file_to_parse) {
xbt_graph_parse__delete_buffer(xbt_graph_input_buffer);
static void xbt_lib_cursor_free(xbt_lib_cursor_t * cursor)
{
- if (*cursor) {
- xbt_free(*cursor);
- *cursor = NULL;
- }
+ xbt_free(*cursor);
+ *cursor = NULL;
}
void xbt_lib_cursor_step(xbt_lib_cursor_t cursor)
xbt_log_setting_t set = *(xbt_log_setting_t *) s;
if (set) {
free(set->catname);
- if (set->fmt)
- free(set->fmt);
+ free(set->fmt);
free(set);
}
}
else
ret = mmalloc(mdp, s);
} else {
- if (p)
- mfree(mdp, p);
+ mfree(mdp, p);
}
UNLOCK(mdp);
CloseHandle(thread->handle);
- if (thread->name)
- free(thread->name);
+ free(thread->name);
free(thread);
}
void xbt_peer_free(xbt_peer_t peer)
{
if (peer) {
- if (peer->name)
- free(peer->name);
+ free(peer->name);
free(peer);
}
}
const char *xbt_replay_trace_reader_position(xbt_replay_trace_reader_t reader)
{
- if (reader->position)
- free(reader->position);
+ free(reader->position);
reader->position = bprintf("%s:%d",reader->filename,reader->linenum);
return reader->position;
}
void xbt_replay_trace_reader_free(xbt_replay_trace_reader_t *reader)
{
free((*reader)->filename);
- if ((*reader)->position)
- free((*reader)->position);
+ free((*reader)->position);
fclose((*reader)->fp);
free((*reader)->line);
free(*reader);
XBT_INLINE void xbt_strbuff_free(xbt_strbuff_t b)
{
if (b) {
- if (b->data)
- free(b->data);
+ free(b->data);
free(b);
}
}
}
free(value);
- if (default_value)
- free(default_value);
+ free(default_value);
end--; /* compensate the next end++ */
}
generate_simulation_dsp_file(project_name);
generate_real_live_dsp_file(project_name);
- if (__gras_path)
- xbt_free(__gras_path);
+ xbt_free(__gras_path);
#endif
free(warning);
char **env_it;
void *filepos;
- if (rc->cmd)
- free(rc->cmd);
+ free(rc->cmd);
rc->cmd = NULL;
/* avoid race with rctx_armageddon log messages */
filepos = rc->filepos;
rc->filepos = NULL;
- if (filepos)
- free(filepos);
+ free(filepos);
for (i = 0, env_it = environ; *env_it; i++, env_it++);
if (rc->env) {
for (env_it = rctx->env + i; *env_it; env_it++)
if (!rctx)
return;
- if (rctx->cmd)
- free(rctx->cmd);
- if (rctx->filepos)
- free(rctx->filepos);
+ free(rctx->cmd);
+ free(rctx->filepos);
if (rctx->env) {
int i;
char **env_it;
xbt_dynar_t path = xbt_str_split(environ[i] + 5, ":");
xbt_dynar_foreach(path, it, str) {
- if (binary_name)
- free(binary_name);
+ free(binary_name);
binary_name = bprintf("%s/%s", str, args[0]);
if (!stat(binary_name, &stat_buf)) {
/* Found. */
}
rctx->expected_return = 0;
- if (rctx->expected_signal) {
- free(rctx->expected_signal);
- rctx->expected_signal = NULL;
- }
+ free(rctx->expected_signal);
+ rctx->expected_signal = NULL;
}
if ((errcode && errcode != 1) || rctx->interrupted) {
rctx_free(rctx);
/* Clear buffers */
- if (line)
- free(line);
+ free(line);
xbt_strbuff_free(buff);
}
if (NULL == buffer)
return;
- if (NULL != buffer->data)
- free(buffer->data);
+ free(buffer->data);
- if (NULL != buffer)
- free(buffer);
+ free(buffer);
}
/*
if ((NULL != ptr->file) && (stdin != ptr->file))
fclose(ptr->file);
- if (NULL != ptr->line)
- free(ptr->line);
+ free(ptr->line);
DeleteCriticalSection(&cs);
*/
}
- if (__date)
- free(__date);
+ free(__date);
Stream_unlock(stream);
}
{
size_t size;
- if (NULL != context->name) {
- free(context->name);
- }
+ free(context->name);
context->name = strdup(name);
size = strlen(name);
{
ThreadDynarray_lock(ptr);
- if (ptr->threads) {
- free(ptr->threads);
- ptr->threads = NULL;
- }
+ free(ptr->threads);
+ ptr->threads = NULL;
ptr->count = 0;
ptr->capacity = 0;