519 lines
15 KiB
C
519 lines
15 KiB
C
/*
|
|
* Copyright (c) 2021 Barcelona Supercomputing Center (BSC)
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "pcf.h"
|
|
#include "prv.h"
|
|
#include "emu.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdint.h>
|
|
#include <errno.h>
|
|
|
|
const char *pcf_def_header =
|
|
"DEFAULT_OPTIONS\n"
|
|
"\n"
|
|
"LEVEL THREAD\n"
|
|
"UNITS NANOSEC\n"
|
|
"LOOK_BACK 100\n"
|
|
"SPEED 1\n"
|
|
"FLAG_ICONS ENABLED\n"
|
|
"NUM_OF_STATE_COLORS 1000\n"
|
|
"YMAX_SCALE 37\n"
|
|
"\n"
|
|
"\n"
|
|
"DEFAULT_SEMANTIC\n"
|
|
"\n"
|
|
"THREAD_FUNC State As Is\n";
|
|
|
|
#define RGB(r, g, b) (r<<16 | g<<8 | b)
|
|
#define ARRAY_LEN(x) (sizeof(x) / sizeof((x)[0]))
|
|
|
|
/* Define colors for the trace */
|
|
#define DEEPBLUE RGB( 0, 0, 255)
|
|
#define LIGHTGREY RGB(217, 217, 217)
|
|
#define RED RGB(230, 25, 75)
|
|
#define GREEN RGB(60, 180, 75)
|
|
#define YELLOW RGB(255, 225, 25)
|
|
#define ORANGE RGB(245, 130, 48)
|
|
#define PURPLE RGB(145, 30, 180)
|
|
#define CYAN RGB( 70, 240, 240)
|
|
#define MAGENTA RGB(240, 50, 230)
|
|
#define LIME RGB(210, 245, 60)
|
|
#define PINK RGB(250, 190, 212)
|
|
#define TEAL RGB( 0, 128, 128)
|
|
#define LAVENDER RGB(220, 190, 255)
|
|
#define BROWN RGB(170, 110, 40)
|
|
#define BEIGE RGB(255, 250, 200)
|
|
#define MAROON RGB(128, 0, 0)
|
|
#define MINT RGB(170, 255, 195)
|
|
#define OLIVE RGB(128, 128, 0)
|
|
#define APRICOT RGB(255, 215, 180)
|
|
#define NAVY RGB( 0, 0, 128)
|
|
#define BLUE RGB( 0, 130, 200)
|
|
#define GREY RGB(128, 128, 128)
|
|
#define BLACK RGB( 0, 0, 0)
|
|
|
|
const uint32_t pcf_def_palette[] = {
|
|
BLACK, /* (never shown anyways) */
|
|
BLUE, /* runtime */
|
|
LIGHTGREY, /* busy wait */
|
|
RED, /* task */
|
|
GREEN,
|
|
YELLOW, ORANGE, PURPLE, CYAN, MAGENTA, LIME, PINK,
|
|
TEAL, GREY, LAVENDER, BROWN, BEIGE, MAROON, MINT,
|
|
OLIVE, APRICOT, NAVY, DEEPBLUE
|
|
};
|
|
|
|
const uint32_t *pcf_palette = pcf_def_palette;
|
|
const int pcf_palette_len = ARRAY_LEN(pcf_def_palette);
|
|
|
|
/* ------------------ Value labels --------------------- */
|
|
|
|
struct pcf_value_label default_values[] = {
|
|
{ ST_TOO_MANY_TH, "Unknown: Multiple threads running" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label ovni_state_values[] = {
|
|
{ TH_ST_UNKNOWN, "Unknown" },
|
|
{ TH_ST_RUNNING, "Running" },
|
|
{ TH_ST_PAUSED, "Paused" },
|
|
{ TH_ST_DEAD, "Dead" },
|
|
{ TH_ST_COOLING, "Cooling" },
|
|
{ TH_ST_WARMING, "Warming" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label ovni_flush_values[] = {
|
|
{ 0, "None" },
|
|
{ ST_OVNI_FLUSHING, "Flushing" },
|
|
{ ST_TOO_MANY_TH, "Unknown flushing state: Multiple threads running" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label nosv_ss_values[] = {
|
|
/* Errors */
|
|
{ ST_BAD, "Unknown: bad happened (report bug)" },
|
|
{ ST_TOO_MANY_TH, "Unknown: multiple threads running" },
|
|
/* Good values */
|
|
{ ST_NULL, "No subsystem" },
|
|
{ ST_NOSV_SCHED_HUNGRY, "Scheduler: Hungry" },
|
|
{ ST_NOSV_SCHED_SERVING, "Scheduler: Serving" },
|
|
{ ST_NOSV_SCHED_SUBMITTING, "Scheduler: Submitting" },
|
|
{ ST_NOSV_MEM_ALLOCATING, "Memory: Allocating" },
|
|
{ ST_NOSV_MEM_FREEING, "Memory: Freeing" },
|
|
{ ST_NOSV_TASK_RUNNING, "Task: Running" },
|
|
{ ST_NOSV_API_SUBMIT, "API: Submit" },
|
|
{ ST_NOSV_API_PAUSE, "API: Pause" },
|
|
{ ST_NOSV_API_YIELD, "API: Yield" },
|
|
{ ST_NOSV_API_WAITFOR, "API: Waitfor" },
|
|
{ ST_NOSV_API_SCHEDPOINT, "API: Scheduling point" },
|
|
{ ST_NOSV_ATTACH, "Thread: Attached" },
|
|
{ ST_NOSV_WORKER, "Thread: Worker" },
|
|
{ ST_NOSV_DELEGATE, "Thread: Delegate" },
|
|
{ EV_NOSV_SCHED_SEND, "EV Scheduler: Send task" },
|
|
{ EV_NOSV_SCHED_RECV, "EV Scheduler: Recv task" },
|
|
{ EV_NOSV_SCHED_SELF, "EV Scheduler: Self-assign task" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label tampi_mode_values[] = {
|
|
{ ST_NULL, "NULL" },
|
|
{ ST_TOO_MANY_TH, "TAMPI: Unknown, multiple threads running" },
|
|
{ ST_TAMPI_SEND, "TAMPI: Send" },
|
|
{ ST_TAMPI_RECV, "TAMPI: Recv" },
|
|
{ ST_TAMPI_ISEND, "TAMPI: Isend" },
|
|
{ ST_TAMPI_IRECV, "TAMPI: Irecv" },
|
|
{ ST_TAMPI_WAIT, "TAMPI: Wait" },
|
|
{ ST_TAMPI_WAITALL, "TAMPI: Waitall" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label openmp_mode_values[] = {
|
|
{ ST_NULL, "NULL" },
|
|
{ ST_TOO_MANY_TH, "OpenMP: Unknown, multiple threads running" },
|
|
{ ST_OPENMP_TASK, "OpenMP: Task" },
|
|
{ ST_OPENMP_PARALLEL, "OpenMP: Parallel" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label nodes_mode_values[] = {
|
|
{ ST_NULL, "NULL" },
|
|
{ ST_TOO_MANY_TH, "NODES: Multiple threads running" },
|
|
{ ST_NODES_REGISTER, "Dependencies: Registering task accesses" },
|
|
{ ST_NODES_UNREGISTER, "Dependencies: Unregistering task accesses" },
|
|
{ ST_NODES_IF0_WAIT, "If0: Waiting for an If0 task" },
|
|
{ ST_NODES_IF0_INLINE, "If0: Executing an If0 task inline" },
|
|
{ ST_NODES_TASKWAIT, "Taskwait: Taskwait" },
|
|
{ ST_NODES_CREATE, "Add Task: Creating a task" },
|
|
{ ST_NODES_SUBMIT, "Add Task: Submitting a task" },
|
|
{ ST_NODES_SPAWN, "Spawn Function: Spawning a function" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label kernel_cs_values[] = {
|
|
{ ST_NULL, "NULL" },
|
|
{ ST_TOO_MANY_TH, "Unknown: multiple threads running" },
|
|
{ ST_KERNEL_CSOUT, "Context switch: Out of the CPU" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label nanos6_ss_values[] = {
|
|
{ ST_NULL, "No subsystem" },
|
|
{ ST_TOO_MANY_TH, "Unknown: multiple threads running" },
|
|
{ ST_NANOS6_TASK_BODY, "Task: Running body" },
|
|
{ ST_NANOS6_TASK_CREATING, "Task: Creating" },
|
|
{ ST_NANOS6_TASK_SUBMIT, "Task: Submitting" },
|
|
{ ST_NANOS6_TASK_SPAWNING, "Task: Spawning function" },
|
|
{ ST_NANOS6_SCHED_SERVING, "Scheduler: Serving tasks" },
|
|
{ ST_NANOS6_SCHED_ADDING, "Scheduler: Adding ready tasks" },
|
|
{ ST_NANOS6_DEP_REG, "Dependency: Registering" },
|
|
{ ST_NANOS6_DEP_UNREG, "Dependency: Unregistering" },
|
|
{ ST_NANOS6_BLK_TASKWAIT, "Blocking: Taskwait" },
|
|
{ ST_NANOS6_BLK_BLOCKING, "Blocking: Blocking current task" },
|
|
{ ST_NANOS6_BLK_UNBLOCKING, "Blocking: Unblocking remote task" },
|
|
{ ST_NANOS6_BLK_WAITFOR, "Blocking: Wait For" },
|
|
{ ST_NANOS6_HANDLING_TASK, "Worker: Handling task" },
|
|
{ ST_NANOS6_WORKER_LOOP, "Worker: Looking for work" },
|
|
{ ST_NANOS6_SWITCH_TO, "Worker: Switching to another thread" },
|
|
{ ST_NANOS6_MIGRATE, "Worker: Migrating CPU" },
|
|
{ ST_NANOS6_SUSPEND, "Worker: Suspending thread" },
|
|
{ ST_NANOS6_RESUME, "Worker: Resuming another thread" },
|
|
{ ST_NANOS6_ALLOCATING, "Memory: Allocating" },
|
|
{ ST_NANOS6_FREEING, "Memory: Freeing" },
|
|
{ EV_NANOS6_SCHED_SEND, "EV Scheduler: Send task" },
|
|
{ EV_NANOS6_SCHED_RECV, "EV Scheduler: Recv task" },
|
|
{ EV_NANOS6_SCHED_SELF, "EV Scheduler: Self-assign task" },
|
|
{ EV_NANOS6_CPU_IDLE, "EV CPU: Becomes idle" },
|
|
{ EV_NANOS6_CPU_ACTIVE, "EV CPU: Becomes active" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label nanos6_thread_type[] = {
|
|
{ ST_NULL, "No type" },
|
|
{ ST_TOO_MANY_TH, "Unknown: multiple threads running" },
|
|
{ ST_NANOS6_TH_EXTERNAL, "External" },
|
|
{ ST_NANOS6_TH_WORKER, "Worker" },
|
|
{ ST_NANOS6_TH_LEADER, "Leader" },
|
|
{ ST_NANOS6_TH_MAIN, "Main" },
|
|
{ -1, NULL },
|
|
};
|
|
|
|
struct pcf_value_label (*pcf_chan_value_labels[CHAN_MAX])[] = {
|
|
[CHAN_OVNI_PID] = &default_values,
|
|
[CHAN_OVNI_TID] = &default_values,
|
|
[CHAN_OVNI_NRTHREADS] = &default_values,
|
|
[CHAN_OVNI_STATE] = &ovni_state_values,
|
|
[CHAN_OVNI_APPID] = &default_values,
|
|
[CHAN_OVNI_CPU] = &default_values,
|
|
[CHAN_OVNI_FLUSH] = &ovni_flush_values,
|
|
|
|
[CHAN_NOSV_TASKID] = &default_values,
|
|
[CHAN_NOSV_TYPE] = &default_values,
|
|
[CHAN_NOSV_APPID] = &default_values,
|
|
[CHAN_NOSV_SUBSYSTEM] = &nosv_ss_values,
|
|
[CHAN_NOSV_RANK] = &default_values,
|
|
|
|
[CHAN_TAMPI_MODE] = &tampi_mode_values,
|
|
[CHAN_OPENMP_MODE] = &openmp_mode_values,
|
|
[CHAN_NODES_SUBSYSTEM] = &nodes_mode_values,
|
|
|
|
[CHAN_NANOS6_TASKID] = &default_values,
|
|
[CHAN_NANOS6_TYPE] = &default_values,
|
|
[CHAN_NANOS6_SUBSYSTEM] = &nanos6_ss_values,
|
|
[CHAN_NANOS6_RANK] = &default_values,
|
|
[CHAN_NANOS6_THREAD] = &nanos6_thread_type,
|
|
|
|
[CHAN_KERNEL_CS] = &kernel_cs_values,
|
|
};
|
|
|
|
/* ------------------ Type labels --------------------- */
|
|
|
|
char *pcf_chan_name[CHAN_MAX] = {
|
|
[CHAN_OVNI_PID] = "PID",
|
|
[CHAN_OVNI_TID] = "TID",
|
|
[CHAN_OVNI_NRTHREADS] = "Number of RUNNING threads",
|
|
[CHAN_OVNI_STATE] = "Execution state",
|
|
[CHAN_OVNI_APPID] = "AppID",
|
|
[CHAN_OVNI_CPU] = "CPU affinity",
|
|
[CHAN_OVNI_FLUSH] = "Flushing state",
|
|
|
|
[CHAN_NOSV_TASKID] = "nOS-V TaskID",
|
|
[CHAN_NOSV_TYPE] = "nOS-V task type",
|
|
[CHAN_NOSV_APPID] = "nOS-V task AppID",
|
|
[CHAN_NOSV_SUBSYSTEM] = "nOS-V subsystem",
|
|
[CHAN_NOSV_RANK] = "nOS-V task MPI rank",
|
|
|
|
[CHAN_TAMPI_MODE] = "TAMPI mode",
|
|
[CHAN_OPENMP_MODE] = "OpenMP mode",
|
|
[CHAN_NODES_SUBSYSTEM] = "NODES subsystem",
|
|
|
|
[CHAN_NANOS6_TASKID] = "Nanos6 task ID",
|
|
[CHAN_NANOS6_TYPE] = "Nanos6 task type",
|
|
[CHAN_NANOS6_SUBSYSTEM] = "Nanos6 subsystem",
|
|
[CHAN_NANOS6_RANK] = "Nanos6 task MPI rank",
|
|
[CHAN_NANOS6_THREAD] = "Nanos6 thread type",
|
|
|
|
[CHAN_KERNEL_CS] = "Context switches",
|
|
};
|
|
|
|
enum pcf_suffix { NONE = 0, CUR_TH, RUN_TH, ACT_TH, SUFFIX_MAX };
|
|
|
|
char *pcf_suffix_name[SUFFIX_MAX] = {
|
|
[NONE] = "",
|
|
[CUR_TH] = "of the CURRENT thread",
|
|
[RUN_TH] = "of the RUNNING thread",
|
|
[ACT_TH] = "of the ACTIVE thread",
|
|
};
|
|
|
|
int pcf_chan_suffix[CHAN_MAX][CHAN_MAXTYPE] = {
|
|
/* Thread CPU */
|
|
[CHAN_OVNI_PID] = { CUR_TH, CUR_TH },
|
|
[CHAN_OVNI_TID] = { CUR_TH, CUR_TH },
|
|
[CHAN_OVNI_NRTHREADS] = { NONE, NONE },
|
|
[CHAN_OVNI_STATE] = { CUR_TH, NONE },
|
|
[CHAN_OVNI_APPID] = { NONE, RUN_TH },
|
|
[CHAN_OVNI_CPU] = { CUR_TH, NONE },
|
|
[CHAN_OVNI_FLUSH] = { CUR_TH, RUN_TH },
|
|
|
|
[CHAN_NOSV_TASKID] = { RUN_TH, RUN_TH },
|
|
[CHAN_NOSV_TYPE] = { RUN_TH, RUN_TH },
|
|
[CHAN_NOSV_APPID] = { RUN_TH, RUN_TH },
|
|
[CHAN_NOSV_SUBSYSTEM] = { ACT_TH, RUN_TH },
|
|
[CHAN_NOSV_RANK] = { RUN_TH, RUN_TH },
|
|
|
|
[CHAN_TAMPI_MODE] = { RUN_TH, RUN_TH },
|
|
[CHAN_OPENMP_MODE] = { RUN_TH, RUN_TH },
|
|
[CHAN_NODES_SUBSYSTEM] = { RUN_TH, RUN_TH },
|
|
|
|
[CHAN_NANOS6_TASKID] = { RUN_TH, RUN_TH },
|
|
[CHAN_NANOS6_TYPE] = { RUN_TH, RUN_TH },
|
|
[CHAN_NANOS6_SUBSYSTEM] = { ACT_TH, RUN_TH },
|
|
[CHAN_NANOS6_RANK] = { RUN_TH, RUN_TH },
|
|
[CHAN_NANOS6_THREAD] = { ACT_TH, NONE },
|
|
|
|
[CHAN_KERNEL_CS] = { RUN_TH, ACT_TH },
|
|
};
|
|
|
|
/* ----------------------------------------------- */
|
|
|
|
static void
|
|
decompose_rgb(uint32_t col, uint8_t *r, uint8_t *g, uint8_t *b)
|
|
{
|
|
*r = (col>>16) & 0xff;
|
|
*g = (col>>8) & 0xff;
|
|
*b = (col>>0) & 0xff;
|
|
}
|
|
|
|
static void
|
|
write_header(FILE *f)
|
|
{
|
|
fprintf(f, "%s", pcf_def_header);
|
|
}
|
|
|
|
static void
|
|
write_colors(FILE *f, const uint32_t *palette, int n)
|
|
{
|
|
int i;
|
|
uint8_t r, g, b;
|
|
|
|
fprintf(f, "\n\n");
|
|
fprintf(f, "STATES_COLOR\n");
|
|
|
|
for(i=0; i<n; i++)
|
|
{
|
|
decompose_rgb(palette[i], &r, &g, &b);
|
|
fprintf(f, "%-3d {%3d, %3d, %3d}\n", i, r, g, b);
|
|
}
|
|
}
|
|
|
|
static void
|
|
write_type(FILE *f, struct pcf_type *type)
|
|
{
|
|
fprintf(f, "\n\n");
|
|
fprintf(f, "EVENT_TYPE\n");
|
|
fprintf(f, "0 %-10d %s\n", type->id, type->label);
|
|
fprintf(f, "VALUES\n");
|
|
|
|
for(struct pcf_value *v = type->values; v != NULL; v = v->hh.next)
|
|
fprintf(f, "%-4d %s\n", v->value, v->label);
|
|
}
|
|
|
|
static void
|
|
write_types(struct pcf_file *pcf)
|
|
{
|
|
struct pcf_type *t;
|
|
|
|
for(t = pcf->types; t != NULL; t = t->hh.next)
|
|
write_type(pcf->f, t);
|
|
}
|
|
|
|
static void
|
|
create_values(struct pcf_type *t, enum chan c)
|
|
{
|
|
struct pcf_value_label (*q)[] = pcf_chan_value_labels[c];
|
|
|
|
if(q == NULL)
|
|
return;
|
|
|
|
for(struct pcf_value_label *p = *q; p->label != NULL; p++)
|
|
pcf_add_value(t, p->value, p->label);
|
|
}
|
|
|
|
static void
|
|
create_type(struct pcf_file *pcf, enum chan c)
|
|
{
|
|
char label[MAX_PCF_LABEL];
|
|
enum chan_type ct = pcf->chantype;
|
|
int prv_type = chan_to_prvtype[c];
|
|
|
|
if(prv_type == -1)
|
|
return;
|
|
|
|
/* Compute the label by joining the two parts */
|
|
char *prefix = pcf_chan_name[c];
|
|
int isuffix = pcf_chan_suffix[c][ct];
|
|
char *suffix = pcf_suffix_name[isuffix];
|
|
|
|
int ret = snprintf(label, MAX_PCF_LABEL, "%s %s",
|
|
prefix, suffix);
|
|
|
|
if(ret >= MAX_PCF_LABEL)
|
|
die("computed type label too long\n");
|
|
|
|
struct pcf_type *t = pcf_add_type(pcf, prv_type, label);
|
|
|
|
create_values(t, c);
|
|
}
|
|
|
|
/** Open the given PCF file and create the default events. */
|
|
void
|
|
pcf_open(struct pcf_file *pcf, char *path, int chantype)
|
|
{
|
|
memset(pcf, 0, sizeof(*pcf));
|
|
|
|
pcf->f = fopen(path, "w");
|
|
pcf->chantype = chantype;
|
|
|
|
if(pcf->f == NULL)
|
|
{
|
|
die("cannot open PCF file '%s': %s\n",
|
|
path, strerror(errno));
|
|
}
|
|
|
|
/* Create default types and values */
|
|
for(enum chan c = 0; c < CHAN_MAX; c++)
|
|
create_type(pcf, c);
|
|
}
|
|
|
|
struct pcf_type *
|
|
pcf_find_type(struct pcf_file *pcf, int type_id)
|
|
{
|
|
struct pcf_type *type;
|
|
|
|
HASH_FIND_INT(pcf->types, &type_id, type);
|
|
|
|
return type;
|
|
}
|
|
|
|
/** Creates a new pcf_type with the given type_id and label. The label
|
|
* can be disposed after return.
|
|
*
|
|
* @return The pcf_type created.
|
|
*/
|
|
struct pcf_type *
|
|
pcf_add_type(struct pcf_file *pcf, int type_id, const char *label)
|
|
{
|
|
struct pcf_type *pcftype;
|
|
|
|
pcftype = pcf_find_type(pcf, type_id);
|
|
|
|
if(pcftype != NULL)
|
|
die("PCF type %d already defined\n", type_id);
|
|
|
|
pcftype = calloc(1, sizeof(struct pcf_type));
|
|
if(pcftype == NULL)
|
|
die("calloc failed: %s\n", strerror(errno));
|
|
|
|
pcftype->id = type_id;
|
|
pcftype->values = NULL;
|
|
pcftype->nvalues = 0;
|
|
|
|
int len = snprintf(pcftype->label, MAX_PCF_LABEL, "%s", label);
|
|
if(len >= MAX_PCF_LABEL)
|
|
die("PCF type label too long\n");
|
|
|
|
HASH_ADD_INT(pcf->types, id, pcftype);
|
|
|
|
return pcftype;
|
|
}
|
|
|
|
struct pcf_value *
|
|
pcf_find_value(struct pcf_type *type, int value)
|
|
{
|
|
struct pcf_value *pcfvalue;
|
|
|
|
HASH_FIND_INT(type->values, &value, pcfvalue);
|
|
|
|
return pcfvalue;
|
|
}
|
|
|
|
/** Adds a new value to the given pcf_type. The label can be disposed
|
|
* after return.
|
|
*
|
|
* @return The new pcf_value created
|
|
*/
|
|
struct pcf_value *
|
|
pcf_add_value(struct pcf_type *type, int value, const char *label)
|
|
{
|
|
struct pcf_value *pcfvalue = pcf_find_value(type, value);
|
|
|
|
if(pcfvalue != NULL)
|
|
die("PCF value %d already in type %d\n", value, type->id);
|
|
|
|
pcfvalue = calloc(1, sizeof(struct pcf_value));
|
|
if(pcfvalue == NULL)
|
|
die("calloc failed: %s\n", strerror(errno));
|
|
|
|
pcfvalue->value = value;
|
|
|
|
int len = snprintf(pcfvalue->label, MAX_PCF_LABEL, "%s", label);
|
|
if(len >= MAX_PCF_LABEL)
|
|
die("PCF value label too long\n");
|
|
|
|
HASH_ADD_INT(type->values, value, pcfvalue);
|
|
|
|
type->nvalues++;
|
|
|
|
return pcfvalue;
|
|
}
|
|
|
|
/** Writes the defined event and values to the PCF file. */
|
|
void
|
|
pcf_write(struct pcf_file *pcf)
|
|
{
|
|
write_header(pcf->f);
|
|
write_colors(pcf->f, pcf_palette, pcf_palette_len);
|
|
write_types(pcf);
|
|
}
|
|
|
|
void
|
|
pcf_close(struct pcf_file *pcf)
|
|
{
|
|
fclose(pcf->f);
|
|
}
|