[lttv.git] / ltt / branches / poly / include / ltt / trace.h

#ifndef TRACE_H
#define TRACE_H

#include <ltt/ltt.h>

/* A trace is specified as a pathname to the directory containing all the
   associated data (control tracefiles, per cpu tracefiles, event 
   descriptions...).

   When a trace is closed, all the associated facilities, types and fields
   are released as well. */

LttTrace *ltt_trace_open(const char *pathname);

/* copy reopens a trace */
LttTrace *ltt_trace_copy(LttTrace *self);

char * ltt_trace_name(LttTrace *t);

void ltt_trace_close(LttTrace *t); 


/* The characteristics of the system on which the trace was obtained
   is described in a LttSystemDescription structure. */

struct _LttSystemDescription {
  char *description;
  char *node_name;
  char *domain_name;
  unsigned nb_cpu;
  LttArchSize size;
  LttArchEndian endian;
  char *kernel_name;
  char *kernel_release;
  char *kernel_version;
  char *machine;
  char *processor;
  char *hardware_platform;
  char *operating_system;
  unsigned ltt_major_version;
  unsigned ltt_minor_version;
  unsigned ltt_block_size;
  LttTime trace_start;
  LttTime trace_end;
};

LttSystemDescription *ltt_trace_system_description(LttTrace *t);


/* Functions to discover the facilities in the trace. Once the number
   of facilities is known, they may be accessed by position. Multiple
   versions of a facility (same name, different checksum) have consecutive
   positions. */

unsigned ltt_trace_facility_number(LttTrace *t);

LttFacility *ltt_trace_facility_get(LttTrace *t, unsigned i);


/* Look for a facility by name. It returns the number of facilities found
   and sets the position argument to the first found. Returning 0, the named
   facility is unknown, returning 1, the named facility is at the specified
   position, returning n, the facilities are from position to 
   position + n - 1. */

unsigned ltt_trace_facility_find(LttTrace *t, char *name, unsigned *position);


/* Functions to discover all the event types in the trace */

unsigned ltt_trace_eventtype_number(LttTrace *t);

LttEventType *ltt_trace_eventtype_get(LttTrace *t, unsigned i);


/* There is one "per cpu" tracefile for each CPU, numbered from 0 to
   the maximum number of CPU in the system. When the number of CPU installed
   is less than the maximum, some positions are unused. There are also a
   number of "control" tracefiles (facilities, interrupts...). */

unsigned ltt_trace_control_tracefile_number(LttTrace *t);

unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t);


/* It is possible to search for the tracefiles by name or by CPU position.
   The index within the tracefiles of the same type is returned if found
   and a negative value otherwise. */

int ltt_trace_control_tracefile_find(LttTrace *t, char *name);

int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i);


/* Get a specific tracefile */

LttTracefile *ltt_trace_control_tracefile_get(LttTrace *t, unsigned i);

LttTracefile *ltt_trace_per_cpu_tracefile_get(LttTrace *t, unsigned i);


/* Get the start time and end time of the trace */

void ltt_trace_time_span_get(LttTrace *t, LttTime *start, LttTime *end);


/* Get the name of a tracefile */

char *ltt_tracefile_name(LttTracefile *tf);


/* Get the number of blocks in the tracefile */

unsigned ltt_tracefile_block_number(LttTracefile *tf);


/* Seek to the first event of the trace with time larger or equal to time */

void ltt_tracefile_seek_time(LttTracefile *t, LttTime time);

/* Seek to the first event with position equal or larger to ep */

void ltt_tracefile_seek_position(LttTracefile *t,
    LttEventPosition *ep);

/* Read the next event */

LttEvent *ltt_tracefile_read(LttTracefile *t);

#endif // TRACE_H
Commit	Line	Data
	1	#ifndef TRACE_H
	2	#define TRACE_H
	3
	4	#include <ltt/ltt.h>
	5
	6	/* A trace is specified as a pathname to the directory containing all the
	7	associated data (control tracefiles, per cpu tracefiles, event
	8	descriptions...).
	9
	10	When a trace is closed, all the associated facilities, types and fields
	11	are released as well. */
	12
	13	LttTrace ltt_trace_open(const char pathname);
	14
	15	/* copy reopens a trace */
	16	LttTrace ltt_trace_copy(LttTrace self);
	17
	18	char * ltt_trace_name(LttTrace *t);
	19
	20	void ltt_trace_close(LttTrace *t);
	21
	22
	23	/* The characteristics of the system on which the trace was obtained
	24	is described in a LttSystemDescription structure. */
	25
	26	struct _LttSystemDescription {
	27	char *description;
	28	char *node_name;
	29	char *domain_name;
	30	unsigned nb_cpu;
	31	LttArchSize size;
	32	LttArchEndian endian;
	33	char *kernel_name;
	34	char *kernel_release;
	35	char *kernel_version;
	36	char *machine;
	37	char *processor;
	38	char *hardware_platform;
	39	char *operating_system;
	40	unsigned ltt_major_version;
	41	unsigned ltt_minor_version;
	42	unsigned ltt_block_size;
	43	LttTime trace_start;
	44	LttTime trace_end;
	45	};
	46
	47	LttSystemDescription ltt_trace_system_description(LttTrace t);
	48
	49
	50	/* Functions to discover the facilities in the trace. Once the number
	51	of facilities is known, they may be accessed by position. Multiple
	52	versions of a facility (same name, different checksum) have consecutive
	53	positions. */
	54
	55	unsigned ltt_trace_facility_number(LttTrace *t);
	56
	57	LttFacility ltt_trace_facility_get(LttTrace t, unsigned i);
	58
	59
	60	/* Look for a facility by name. It returns the number of facilities found
	61	and sets the position argument to the first found. Returning 0, the named
	62	facility is unknown, returning 1, the named facility is at the specified
	63	position, returning n, the facilities are from position to
	64	position + n - 1. */
	65
	66	unsigned ltt_trace_facility_find(LttTrace t, char name, unsigned *position);
	67
	68
	69	/* Functions to discover all the event types in the trace */
	70
	71	unsigned ltt_trace_eventtype_number(LttTrace *t);
	72
	73	LttEventType ltt_trace_eventtype_get(LttTrace t, unsigned i);
	74
	75
	76	/* There is one "per cpu" tracefile for each CPU, numbered from 0 to
	77	the maximum number of CPU in the system. When the number of CPU installed
	78	is less than the maximum, some positions are unused. There are also a
	79	number of "control" tracefiles (facilities, interrupts...). */
	80
	81	unsigned ltt_trace_control_tracefile_number(LttTrace *t);
	82
	83	unsigned ltt_trace_per_cpu_tracefile_number(LttTrace *t);
	84
	85
	86	/* It is possible to search for the tracefiles by name or by CPU position.
	87	The index within the tracefiles of the same type is returned if found
	88	and a negative value otherwise. */
	89
	90	int ltt_trace_control_tracefile_find(LttTrace t, char name);
	91
	92	int ltt_trace_per_cpu_tracefile_find(LttTrace *t, unsigned i);
	93
	94
	95	/* Get a specific tracefile */
	96
	97	LttTracefile ltt_trace_control_tracefile_get(LttTrace t, unsigned i);
	98
	99	LttTracefile ltt_trace_per_cpu_tracefile_get(LttTrace t, unsigned i);
	100
	101
	102	/* Get the start time and end time of the trace */
	103
	104	void ltt_trace_time_span_get(LttTrace t, LttTime start, LttTime *end);
	105
	106
	107	/* Get the name of a tracefile */
	108
	109	char ltt_tracefile_name(LttTracefile tf);
	110
	111
	112	/* Get the number of blocks in the tracefile */
	113
	114	unsigned ltt_tracefile_block_number(LttTracefile *tf);
	115
	116
	117	/* Seek to the first event of the trace with time larger or equal to time */
	118
	119	void ltt_tracefile_seek_time(LttTracefile *t, LttTime time);
	120
	121	/* Seek to the first event with position equal or larger to ep */
	122
	123	void ltt_tracefile_seek_position(LttTracefile *t,
	124	LttEventPosition *ep);
	125
	126	/* Read the next event */
	127
	128	LttEvent ltt_tracefile_read(LttTracefile t);
	129
	130	#endif // TRACE_H