[lttv.git] / ltt / branches / poly / ltt / event.c


#include <ltt/event.h>
#include <ltt/ltt-types.h>
#include <ltt/ltt-private.h>

/*****************************************************************************
 *Function name
 *    ltt_event_position_get : get the event position data
 *Input params
 *    e                  : an instance of an event type   
 *    ep                 : a pointer to event's position structure
 *    tf                 : tracefile pointer
 *    block              : current block
 *    offset             : current offset
 *    tsc                : current tsc
 ****************************************************************************/
void ltt_event_position_get(LttEventPosition *ep, LttTracefile **tf,
        guint *block, guint *offset, guint64 *tsc)
{
  *tf = ep->tracefile;
  *block = ep->block;
  *offset = ep->offset;
  *tsc = ep->tsc;
}


void ltt_event_position_set(LttEventPosition *ep, LttTracefile *tf,
        guint block, guint offset, guint64 tsc)
{
  ep->tracefile = tf;
  ep->block = block;
  ep->offset = offset;
  ep->tsc = tsc;
}


/*****************************************************************************
 *Function name
 *    ltt_event_position : get the event's position
 *Input params
 *    e                  : an instance of an event type   
 *    ep                 : a pointer to event's position structure
 ****************************************************************************/

void ltt_event_position(LttEvent *e, LttEventPosition *ep)
{
  ep->tracefile = e->tracefile;
  ep->block = e->block;
  ep->offset = e->offset;
  ep->tsc = e->tsc;
}

LttEventPosition * ltt_event_position_new()
{
  return g_new(LttEventPosition, 1);
}


/*****************************************************************************
 * Function name
 *    ltt_event_position_compare : compare two positions
 *    A NULL value is infinite.
 * Input params
 *    ep1                    : a pointer to event's position structure
 *    ep2                    : a pointer to event's position structure
 * Return
 *    -1 is ep1 < ep2
 *    1 if ep1 > ep2
 *    0 if ep1 == ep2
 ****************************************************************************/


gint ltt_event_position_compare(const LttEventPosition *ep1,
                                const LttEventPosition *ep2)
{
  if(ep1 == NULL && ep2 == NULL)
      return 0;
  if(ep1 != NULL && ep2 == NULL)
      return -1;
  if(ep1 == NULL && ep2 != NULL)
      return 1;

   if(ep1->tracefile != ep2->tracefile)
    g_error("ltt_event_position_compare on different tracefiles makes no sense");
   
  if(ep1->block < ep2->block)
    return -1;
  if(ep1->block > ep2->block)
    return 1;
  if(ep1->offset < ep2->offset)
    return -1;
  if(ep1->offset > ep2->offset)
    return 1;
  return 0;
}

/*****************************************************************************
 * Function name
 *    ltt_event_position_copy : copy position
 * Input params
 *    src                    : a pointer to event's position structure source
 *    dest                   : a pointer to event's position structure dest
 * Return
 *    void
 ****************************************************************************/
void ltt_event_position_copy(LttEventPosition *dest,
                             const LttEventPosition *src)
{
  if(src == NULL)
    dest = NULL;
  else
    *dest = *src;
}


LttTracefile *ltt_event_position_tracefile(LttEventPosition *ep)
{
  return ep->tracefile;
}

/*****************************************************************************
 * These functions extract data from an event after architecture specific
 * conversions
 ****************************************************************************/
guint32 ltt_event_get_unsigned(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    reverse_byte_order = LTT_GET_BO(e->tracefile);
  }

  switch(f->size) {
  case 1:
    {
      guint8 x = *(guint8 *)(e->data + f->offset);
      return (guint32) x;    
    }
    break;
  case 2:
    return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset);
    break;
  case 4:
    return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset);
    break;
  case 8:
  default:
    g_critical("ltt_event_get_unsigned : field size %i unknown", f->size);
    return 0;
    break;
  }
}

gint32 ltt_event_get_int(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    reverse_byte_order = LTT_GET_BO(e->tracefile);
  }

  switch(f->size) {
  case 1:
    {
      gint8 x = *(gint8 *)(e->data + f->offset);
      return (gint32) x;    
    }
    break;
  case 2:
    return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset);
    break;
  case 4:
    return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset);
    break;
  case 8:
  default:
    g_critical("ltt_event_get_int : field size %i unknown", f->size);
    return 0;
    break;
  }
}

guint64 ltt_event_get_long_unsigned(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    reverse_byte_order = LTT_GET_BO(e->tracefile);
  }
  
  switch(f->size) {
  case 1:
    {
      guint8 x = *(guint8 *)(e->data + f->offset);
      return (guint64) x;    
    }
    break;
  case 2:
    return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset);
    break;
  case 4:
    return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset);
    break;
  case 8:
    return ltt_get_uint64(reverse_byte_order, e->data + f->offset);
    break;
  default:
    g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->size);
    return 0;
    break;
  }
}

gint64 ltt_event_get_long_int(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    reverse_byte_order = LTT_GET_BO(e->tracefile);
  }
  
  switch(f->size) {
  case 1:
    {
      gint8 x = *(gint8 *)(e->data + f->offset);
      return (gint64) x;    
    }
    break;
  case 2:
    return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset);
    break;
  case 4:
    return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset);
    break;
  case 8:
    return ltt_get_int64(reverse_byte_order, e->data + f->offset);
    break;
  default:
    g_critical("ltt_event_get_long_int : field size %i unknown", f->size);
    return 0;
    break;
  }
}

#if 0
float ltt_event_get_float(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    g_assert(LTT_HAS_FLOAT(e->tracefile));
    reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
  }

  g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 4);

  if(reverse_byte_order == 0) return *(float *)(e->data + f->offset);
  else{
    void *ptr = e->data + f->offset;
    guint32 value = bswap_32(*(guint32*)ptr);
    return *(float*)&value;
  }
}

double ltt_event_get_double(LttEvent *e, struct marker_field *f)
{
  gboolean reverse_byte_order;
  if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
    reverse_byte_order = (g_ntohs(0x1) != 0x1);
  } else {
    g_assert(LTT_HAS_FLOAT(e->tracefile));
    reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
  }

  if(f->size == 4)
    return ltt_event_get_float(e, f);
    
  g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 8);

  if(reverse_byte_order == 0) return *(double *)(e->data + f->offset);
  else {
    void *ptr = e->data + f->offset;
    guint64 value = bswap_64(*(guint64*)ptr);
    return *(double*)&value;
  }
}
#endif

/*****************************************************************************
 * The string obtained is only valid until the next read from
 * the same tracefile.
 ****************************************************************************/
char *ltt_event_get_string(LttEvent *e, struct marker_field *f)
{
  g_assert(f->type == LTT_TYPE_STRING);

  return (gchar*)g_strdup((gchar*)(e->data + f->offset));
}
Commit	Line	Data
449cb9d7	1
6cd62ccf	2	#include <ltt/event.h>
d27446d1	3	#include <ltt/ltt-types.h>
a7074914	4	#include <ltt/ltt-private.h>
6cd62ccf	5
eed2ef37	6	/*****************************************************************************
	7	*Function name
	8	* ltt_event_position_get : get the event position data
	9	*Input params
	10	* e : an instance of an event type
	11	* ep : a pointer to event's position structure
	12	* tf : tracefile pointer
	13	* block : current block
	14	* offset : current offset
	15	* tsc : current tsc
	16	****************************************************************************/
	17	void ltt_event_position_get(LttEventPosition ep, LttTracefile *tf,
	18	guint block, guint offset, guint64 *tsc)
	19	{
	20	*tf = ep->tracefile;
	21	*block = ep->block;
	22	*offset = ep->offset;
	23	*tsc = ep->tsc;
	24	}
	25
	26
6d0cdf22	27	void ltt_event_position_set(LttEventPosition ep, LttTracefile tf,
	28	guint block, guint offset, guint64 tsc)
	29	{
	30	ep->tracefile = tf;
	31	ep->block = block;
	32	ep->offset = offset;
	33	ep->tsc = tsc;
	34	}
	35
	36
80da81ad	37	/*****************************************************************************
	38	*Function name
	39	* ltt_event_position : get the event's position
	40	*Input params
	41	* e : an instance of an event type
	42	* ep : a pointer to event's position structure
	43	****************************************************************************/
	44
	45	void ltt_event_position(LttEvent e, LttEventPosition ep)
	46	{
3aee1200	47	ep->tracefile = e->tracefile;
	48	ep->block = e->block;
	49	ep->offset = e->offset;
	50	ep->tsc = e->tsc;
80da81ad	51	}
80da81ad	52
a5dcde2f	53	LttEventPosition * ltt_event_position_new()
	54	{
	55	return g_new(LttEventPosition, 1);
	56	}
	57
80da81ad	58
96da5c0d	59	/*****************************************************************************
	60	* Function name
	61	* ltt_event_position_compare : compare two positions
a00149f6	62	* A NULL value is infinite.
96da5c0d	63	* Input params
	64	* ep1 : a pointer to event's position structure
	65	* ep2 : a pointer to event's position structure
	66	* Return
	67	* -1 is ep1 < ep2
	68	* 1 if ep1 > ep2
	69	* 0 if ep1 == ep2
	70	****************************************************************************/
	71
	72
	73	gint ltt_event_position_compare(const LttEventPosition *ep1,
	74	const LttEventPosition *ep2)
	75	{
a00149f6	76	if(ep1 == NULL && ep2 == NULL)
	77	return 0;
	78	if(ep1 != NULL && ep2 == NULL)
	79	return -1;
	80	if(ep1 == NULL && ep2 != NULL)
	81	return 1;
96da5c0d	82
3aee1200	83	if(ep1->tracefile != ep2->tracefile)
	84	g_error("ltt_event_position_compare on different tracefiles makes no sense");
	85
	86	if(ep1->block < ep2->block)
96da5c0d	87	return -1;
3aee1200	88	if(ep1->block > ep2->block)
96da5c0d	89	return 1;
3aee1200	90	if(ep1->offset < ep2->offset)
96da5c0d	91	return -1;
3aee1200	92	if(ep1->offset > ep2->offset)
96da5c0d	93	return 1;
	94	return 0;
	95	}
	96
2a74fbf4	97	/*****************************************************************************
	98	* Function name
	99	* ltt_event_position_copy : copy position
	100	* Input params
	101	* src : a pointer to event's position structure source
	102	* dest : a pointer to event's position structure dest
	103	* Return
	104	* void
	105	****************************************************************************/
	106	void ltt_event_position_copy(LttEventPosition *dest,
	107	const LttEventPosition *src)
	108	{
a00149f6	109	if(src == NULL)
	110	dest = NULL;
	111	else
	112	dest = src;
2a74fbf4	113	}
96da5c0d	114
96da5c0d	115
27304273	116
	117	LttTracefile ltt_event_position_tracefile(LttEventPosition ep)
	118	{
	119	return ep->tracefile;
	120	}
	121
c37440c8	122	/*****************************************************************************
	123	* These functions extract data from an event after architecture specific
	124	* conversions
	125	****************************************************************************/
	126	guint32 ltt_event_get_unsigned(LttEvent e, struct marker_field f)
	127	{
	128	gboolean reverse_byte_order;
	129	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
	130	reverse_byte_order = (g_ntohs(0x1) != 0x1);
	131	} else {
	132	reverse_byte_order = LTT_GET_BO(e->tracefile);
	133	}
	134
	135	switch(f->size) {
	136	case 1:
	137	{
	138	guint8 x = (guint8 )(e->data + f->offset);
	139	return (guint32) x;
	140	}
	141	break;
	142	case 2:
	143	return (guint32)ltt_get_uint16(reverse_byte_order, e->data + f->offset);
	144	break;
	145	case 4:
	146	return (guint32)ltt_get_uint32(reverse_byte_order, e->data + f->offset);
	147	break;
	148	case 8:
	149	default:
	150	g_critical("ltt_event_get_unsigned : field size %i unknown", f->size);
	151	return 0;
	152	break;
	153	}
	154	}
	155
	156	gint32 ltt_event_get_int(LttEvent e, struct marker_field f)
	157	{
	158	gboolean reverse_byte_order;
	159	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
	160	reverse_byte_order = (g_ntohs(0x1) != 0x1);
	161	} else {
	162	reverse_byte_order = LTT_GET_BO(e->tracefile);
	163	}
	164
	165	switch(f->size) {
	166	case 1:
	167	{
	168	gint8 x = (gint8 )(e->data + f->offset);
	169	return (gint32) x;
	170	}
	171	break;
	172	case 2:
	173	return (gint32)ltt_get_int16(reverse_byte_order, e->data + f->offset);
	174	break;
	175	case 4:
	176	return (gint32)ltt_get_int32(reverse_byte_order, e->data + f->offset);
	177	break;
	178	case 8:
	179	default:
	180	g_critical("ltt_event_get_int : field size %i unknown", f->size);
	181	return 0;
	182	break;
	183	}
	184	}
	185
186	guint64 ltt_event_get_long_unsigned(LttEvent e, struct marker_field f)
187	{
188	gboolean reverse_byte_order;
189	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
190	reverse_byte_order = (g_ntohs(0x1) != 0x1);
191	} else {
192	reverse_byte_order = LTT_GET_BO(e->tracefile);
193	}
194
195	switch(f->size) {
196	case 1:
197	{
198	guint8 x = (guint8 )(e->data + f->offset);
199	return (guint64) x;
200	}
201	break;
202	case 2:
203	return (guint64)ltt_get_uint16(reverse_byte_order, e->data + f->offset);
204	break;
205	case 4:
206	return (guint64)ltt_get_uint32(reverse_byte_order, e->data + f->offset);
207	break;
208	case 8:
209	return ltt_get_uint64(reverse_byte_order, e->data + f->offset);
210	break;
211	default:
212	g_critical("ltt_event_get_long_unsigned : field size %i unknown", f->size);
213	return 0;
214	break;
215	}
216	}
217
218	gint64 ltt_event_get_long_int(LttEvent e, struct marker_field f)
219	{
220	gboolean reverse_byte_order;
221	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
222	reverse_byte_order = (g_ntohs(0x1) != 0x1);
223	} else {
224	reverse_byte_order = LTT_GET_BO(e->tracefile);
225	}
226
227	switch(f->size) {
228	case 1:
229	{
230	gint8 x = (gint8 )(e->data + f->offset);
231	return (gint64) x;
232	}
233	break;
234	case 2:
235	return (gint64)ltt_get_int16(reverse_byte_order, e->data + f->offset);
236	break;
237	case 4:
238	return (gint64)ltt_get_int32(reverse_byte_order, e->data + f->offset);
239	break;
240	case 8:
241	return ltt_get_int64(reverse_byte_order, e->data + f->offset);
242	break;
243	default:
244	g_critical("ltt_event_get_long_int : field size %i unknown", f->size);
245	return 0;
246	break;
247	}
248	}
249
250	#if 0
251	float ltt_event_get_float(LttEvent e, struct marker_field f)
252	{
253	gboolean reverse_byte_order;
254	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
255	reverse_byte_order = (g_ntohs(0x1) != 0x1);
256	} else {
257	g_assert(LTT_HAS_FLOAT(e->tracefile));
258	reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
259	}
260
261	g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 4);
262
263	if(reverse_byte_order == 0) return (float )(e->data + f->offset);
264	else{
265	void *ptr = e->data + f->offset;
266	guint32 value = bswap_32((guint32)ptr);
267	return (float)&value;
268	}
269	}
270
271	double ltt_event_get_double(LttEvent e, struct marker_field f)
272	{
273	gboolean reverse_byte_order;
274	if(unlikely(f->attributes & LTT_ATTRIBUTE_NETWORK_BYTE_ORDER)) {
275	reverse_byte_order = (g_ntohs(0x1) != 0x1);
276	} else {
277	g_assert(LTT_HAS_FLOAT(e->tracefile));
278	reverse_byte_order = LTT_GET_FLOAT_BO(e->tracefile);
279	}
280
281	if(f->size == 4)
282	return ltt_event_get_float(e, f);
283
284	g_assert(f->field_type.type_class == LTT_FLOAT && f->size == 8);
285
286	if(reverse_byte_order == 0) return (double )(e->data + f->offset);
287	else {
288	void *ptr = e->data + f->offset;
289	guint64 value = bswap_64((guint64)ptr);
290	return (double)&value;
291	}
292	}
293	#endif
294
295	/*****************************************************************************
296	* The string obtained is only valid until the next read from
297	* the same tracefile.
298	****************************************************************************/
299	char ltt_event_get_string(LttEvent e, struct marker_field *f)
300	{
301	g_assert(f->type == LTT_TYPE_STRING);
302
303	return (gchar)g_strdup((gchar)(e->data + f->offset));
304	}
305
306