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


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