void denormalize_summary(struct rmDsummary *s)
{
struct field *f;
for(f = &fields[WALL_TIME]; f->name != NULL; f++)
{
if(f->active)
{
if(value_of_field(max_values, f) > 0)
assign_to_field(s, f, value_of_field(s, f) * value_of_field(max_values, f));
}
}
}
struct rmDsummary *summary_unit_op(struct rmDsummary *s, struct rmDsummary *a, double u, double (*op)(double, double))
{
struct field *f;
for(f = &fields[WALL_TIME]; f->name != NULL; f++)
{
if(f->active)
{
assign_to_field(s, f, op(value_of_field(a, f), u));
}
}
return s;
}
struct rmDsummary *find_max_summary(struct list *summaries)
{
struct rmDsummary *s;
struct rmDsummary *max = calloc(1, sizeof(struct rmDsummary));
list_first_item(summaries);
while( (s = list_next_item(summaries)) )
{
struct field *f;
for(f = &fields[WALL_TIME]; f->name != NULL; f++)
{
if(f->active)
{
if(value_of_field(max, f) < value_of_field(s, f))
assign_to_field(max, f, value_of_field(s, f));
}
}
}
return max;
}
struct rmDsummary *rmsummary_to_rmDsummary(struct rmsummary *so) {
struct rmDsummary *s = malloc(sizeof(struct rmDsummary));
bzero(s, sizeof(*s));
if(so->command) {
s->command = xxstrdup(so->command);
}
if(so->category)
{
s->category = xxstrdup(so->category);
}
else if(so->command)
{
s->category = parse_executable_name(so->command);
}
else
{
s->category = xxstrdup(DEFAULT_CATEGORY);
s->command = xxstrdup(DEFAULT_CATEGORY);
}
if(so->task_id)
{
s->task_id = xxstrdup(so->task_id);
}
to_external(s, so, start);
to_external(s, so, end);
to_external(s, so, wall_time);
to_external(s, so, cpu_time);
to_external(s, so, cores);
to_external(s, so, total_processes);
to_external(s, so, max_concurrent_processes);
to_external(s, so, memory);
to_external(s, so, virtual_memory);
to_external(s, so, swap_memory);
to_external(s, so, bytes_read);
to_external(s, so, bytes_written);
to_external(s, so, bytes_received);
to_external(s, so, bytes_sent);
to_external(s, so, bandwidth);
to_external(s, so, disk);
to_external(s, so, total_files);
struct field *f;
for(f = &fields[WALL_TIME]; f->name != NULL; f++)
{
if(value_of_field(s, f) < 0)
{
assign_to_field(s, f, 0);
}
}
return s;
}
struct rmDsummary *parse_summary(FILE *stream, char *filename)
{
static FILE *last_stream = NULL;
static int summ_id = 1;
if(last_stream != stream)
{
last_stream = stream;
summ_id = 1;
}
else
{
summ_id++;
}
struct rmsummary *so = rmsummary_parse_next(stream);
if(!so)
return NULL;
struct rmDsummary *s = malloc(sizeof(struct rmDsummary));
s->command = so->command;
s->file = xxstrdup(filename);
if(so->category)
{
s->category = so->category;
}
else if(so->command)
{
s->category = parse_executable_name(so->command);
}
else
{
s->category = xxstrdup(DEFAULT_CATEGORY);
s->command = xxstrdup(DEFAULT_CATEGORY);
}
s->start = usecs_to_secs(so->start);
s->end = usecs_to_secs(so->end);
s->wall_time = usecs_to_secs(so->wall_time);
s->cpu_time = usecs_to_secs(so->cpu_time);
s->cores = so->cores;
s->total_processes = so->total_processes;
s->max_concurrent_processes = so->max_concurrent_processes;
s->virtual_memory = so->virtual_memory;
s->resident_memory = so->resident_memory;
s->swap_memory = so->swap_memory;
s->bytes_read = bytes_to_Mbytes(so->bytes_read);
s->bytes_written = bytes_to_Mbytes(so->bytes_written);
s->workdir_num_files = so->workdir_num_files;
s->workdir_footprint = so->workdir_footprint;
s->task_id = so->task_id;
if(s->task_id < 0)
{
s->task_id = get_rule_number(filename);
}
struct field *f;
for(f = &fields[WALL_TIME]; f->name != NULL; f++)
{
if(value_of_field(s, f) < 0)
{
assign_to_field(s, f, 0);
}
}
free(so); //we do not free so->command on purpouse.
return s;
}
