[lttv.git] / genevent-new / gentest.c


#include <assert.h>
#include <sys/types.h>
#include <stdint.h>
#include <stdlib.h>

#define min(a,b) (((a)<(b))?a:b)
#define max(a,b) (((a)>(b))?a:b)
#define BUG_ON(a) assert(!(a))

/* Calculate the offset needed to align the type */
static inline unsigned int ltt_align(size_t align_drift,
																		 size_t size_of_type)
{
	size_t alignment = min(sizeof(void*), size_of_type);

	return ((alignment - align_drift) & (alignment-1));
}


/* TEMPLATE */

enum lttng_tasklet_priority {
	LTTNG_LOW,
	LTTNG_HIGH,
};

enum lttng_irq_mode {
	LTTNG_user,
	LTTNG_kernel,
};

struct lttng_mystruct2 {
	unsigned int irq_id;
	enum lttng_irq_mode mode;
	//struct lttng_mystruct teststr1;
};


static inline size_t lttng_get_size_mystruct2(
		struct lttng_mystruct2 * obj)
{
	size_t size=0, locsize;
	
	locsize = sizeof(unsigned int);
	size += ltt_align(size, locsize) + locsize;
	
	locsize = sizeof(enum lttng_irq_mode);
	size += ltt_align(size, locsize) + locsize;

	BUG_ON(sizeof(struct lttng_mystruct2) != size);

	return sizeof(struct lttng_mystruct2);
}

static inline size_t lttng_get_alignment_mystruct2(
		struct lttng_mystruct2 *obj)
{
	size_t align=0, localign;
	
	localign = sizeof(unsigned int);
	align = max(align, localign);
	
	localign = sizeof(enum lttng_irq_mode);
	align = max(align, localign);

	return align;
}

static inline size_t lttng_write_mystruct2(
		void *buf,
		size_t *to,
		void **from,
		size_t *len,
		struct lttng_mystruct2 *obj)
{
	size_t align, size, varalign;

	align = lttng_get_alignment_mystruct2(obj);
	size = lttng_get_size_mystruct2(obj);

	if(*len == 0) {
		varalign = ltt_align(*to, align);	/* align output */
		*to += varalign;
	} else {
		varalign = ltt_align(*to+*len, align);	/* C alignment, ok to do a memcpy of it */
		*len += varalign;
	}
	
	*len += size;

	return varalign+size;
}


#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];

static inline size_t lttng_get_size_array_mystruct_myarray(
		lttng_array_mystruct_myarray obj)
{
	size_t size=0, locsize;
	
	locsize = sizeof(uint64_t);
	/* ltt_align == 0 always*/
	//size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
	BUG_ON(ltt_align(size, locsize) != 0);
	size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;

	BUG_ON(size != LTTNG_ARRAY_SIZE_mystruct_myarray * sizeof(uint64_t));

	return size;
}

static inline size_t lttng_get_alignment_array_mystruct_myarray(
		lttng_array_mystruct_myarray obj)
{
	size_t align=0, localign;
	
	localign = sizeof(uint64_t);
	align = max(align, localign);

	return align;
}


static inline size_t lttng_write_array_mystruct_myarray(
		void *buf,
		size_t *to,
		void **from,
		size_t *len,
		lttng_array_mystruct_myarray obj)
{
	size_t align, size, varalign;
	
	align = lttng_get_alignment_array_mystruct_myarray(obj);
	size = lttng_get_size_array_mystruct_myarray(obj);

	if(*len == 0) {
		varalign = ltt_align(*to, align);	/* align output */
		*to += varalign;
	} else {
		varalign = ltt_align(*to+*len, align);	/* C alignment, ok to do a memcpy of it */
		*len += varalign;
	}
	
	*len += size;

	return varalign + size; /* offset in the from */
}


typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
struct lttng_sequence_mystruct_mysequence {
	unsigned int len;
	double *array;
};


static inline size_t lttng_get_size_sequence_mystruct_mysequence(
																 lttng_sequence_mystruct_mysequence *obj)
{
	size_t size=0, locsize;
	
	locsize = sizeof(unsigned int);
	size += ltt_align(size, locsize) + locsize;

	locsize = sizeof(double);
	size += ltt_align(size, locsize) + (obj->len * locsize);

	return size;
}

static inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
																 lttng_sequence_mystruct_mysequence *obj)
{
	size_t align=0, localign;
	
	localign = sizeof(unsigned int);
	align = max(align, localign);

	localign = sizeof(double);
	align = max(align, localign);

	return align;
}


static inline size_t lttng_write_sequence_mystruct_mysequence(
		void *buf,
		size_t *to,
		void **from,
		size_t *len,
		lttng_sequence_mystruct_mysequence *obj)
{
	size_t align;
	size_t size=0;
	void *varfrom;
	size_t varlen=0;
	size_t varalign=0;
	
	/* Flush pending memcpy */
	if(*len != 0) {
		memcpy(buf+*to, *from, *len);
		*to += *len;
		*len = 0;
	}

	align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
	//no need size = lttng_get_size_sequence_mystruct_mysequence(obj);

	/* Align output */
	varalign = ltt_align((size_t)(*to), align);
	size += varalign;
	
	/* Copy members */
	varalign = ltt_align(size, sizeof(unsigned int));
	size += varalign;
	varfrom = &obj->len;
	varlen += sizeof(unsigned int);
	memcpy(buf+*to+size, varfrom, varlen);
	size += varlen;
	varlen = 0;

	varalign = ltt_align(size, sizeof(double));
	size += varalign;
	varfrom = obj->array;
	varlen += obj->len * sizeof(double);
	memcpy(buf+*to+size, varfrom, varlen);
	size += varlen;
	varlen = 0;

	*to += size;

	/* Put source *from just after the C sequence */
	*from = obj+1;

	return size;
}


union lttng_mystruct_myunion {
	double myfloat;
	unsigned long myulong;
};


static inline size_t lttng_get_size_mystruct_myunion(
																 union lttng_mystruct_myunion *obj)
{
	size_t size=0, locsize;
	
	locsize = sizeof(double);
	size = max(size, locsize);

	locsize = sizeof(unsigned long);
	size = max(size, locsize);

	BUG_ON(size != sizeof(union lttng_mystruct_myunion));

	return size;
}


static inline size_t lttng_get_alignment_mystruct_myunion(
																 union lttng_mystruct_myunion *obj)
{
	size_t align=0, localign;
	
	localign = sizeof(double);
	align = max(align, localign);

	localign = sizeof(unsigned long);
	align = max(align, localign);

	return align;
}


static inline size_t lttng_write_mystruct_myunion(
		void *buf,
		size_t *to,
		void **from,
		size_t *len,
		union lttng_mystruct_myunion *obj)
{
	size_t align, size, varalign;
	
	align = lttng_get_alignment_mystruct_myunion(obj);
	size = lttng_get_size_mystruct_myunion(obj);

	if(*len == 0) {
		varalign = ltt_align(*to, align);	/* align output */
		*to += varalign;
	} else {
		varalign = ltt_align(*to+*len, align);	/* C alignment, ok to do a memcpy of it */
		*len += varalign;
	}
	
	*len += size;

	return varalign + size;
}


struct lttng_mystruct {
	unsigned int irq_id;
	enum lttng_irq_mode mode;
	struct lttng_mystruct2 teststr;
	lttng_array_mystruct_myarray myarray;
	lttng_sequence_mystruct_mysequence mysequence;
	union lttng_mystruct_myunion myunion;
};

static inline size_t lttng_get_size_mystruct(
		struct lttng_mystruct *obj)
{
	size_t size=0, locsize, localign;
	
	locsize = sizeof(unsigned int);
	size += ltt_align(size, locsize) + locsize;
	
	locsize = sizeof(enum lttng_irq_mode);
	size += ltt_align(size, locsize) + locsize;

	localign = lttng_get_alignment_mystruct2(&obj->teststr);
	locsize = lttng_get_size_mystruct2(&obj->teststr);
	size += ltt_align(size, localign) + locsize;
	
	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
	locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
	size += ltt_align(size, localign) + locsize;
	
	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
	locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
	size += ltt_align(size, localign) + locsize;
	
	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
	locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
	size += ltt_align(size, localign) + locsize;

	return size;
}


static inline size_t lttng_get_alignment_mystruct(
		struct lttng_mystruct *obj)
{
	size_t align=0, localign;
	
	localign = sizeof(unsigned int);
	align = max(align, localign);
	
	localign = sizeof(enum lttng_irq_mode);
	align = max(align, localign);

	localign = lttng_get_alignment_mystruct2(&obj->teststr);
	align = max(align, localign);
	
	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
	align = max(align, localign);
	
	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
	align = max(align, localign);
	
	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
	align = max(align, localign);

	return align;
}

static inline void lttng_write_mystruct(
		void *buf,
		size_t *to,
		void **from,
		size_t *len,
		struct lttng_mystruct *obj)
{
	size_t align, size=0, locsize;
	
	align = lttng_get_alignment_mystruct(obj);
	// no need : contains variable size fields.
	// locsize = lttng_get_size_mystruct(obj);

	if(*len == 0) {
		*to += ltt_align(*to, align);	/* align output */
	} else {
		*len += ltt_align(*to+*len, align);	/* C alignment, ok to do a memcpy of it */
	}
	
	/* Contains variable sized fields : must explode the structure */
	
	locsize = sizeof(unsigned int);
	locsize += ltt_align(size, locsize) + locsize;
	*len += locsize;
	size += locsize;
	
	locsize = sizeof(enum lttng_irq_mode);
	locsize += ltt_align(size, locsize) + locsize;
	*len += locsize;
	size += locsize;

	size += lttng_write_mystruct2(buf, to, from, len, &obj->teststr);

	size += lttng_write_array_mystruct_myarray(buf, to, from, len, obj->myarray);

	/* Variable length field */
	size += lttng_write_sequence_mystruct_mysequence(buf, to, from, len, &obj->mysequence);
	
	size += lttng_write_mystruct_myunion(buf, to, from, len, &obj->myunion);

	/* Don't forget to flush last write..... */
}


//void main()
void test()
{
	struct lttng_mystruct test;
	test.mysequence.len = 20;
	test.mysequence.array = malloc(20);

	size_t size = lttng_get_size_mystruct(&test);
	size_t align = lttng_get_alignment_mystruct(&test);

	/* the buffer is allocated on arch_size alignment */
	void *buf = malloc(align + size);
	size_t to = 0;
	void *from = &test;
	size_t len = 0;

	lttng_write_mystruct(buf, &to, &from, &len, &test);
	/* Final flush */
	/* Flush pending memcpy */
	if(len != 0) {
		memcpy(buf+to, from, len);
		to += len;
		from += len;
		len = 0;
	}
	
	free(test.mysequence.array);
	free(buf);
}
Commit	Line	Data
6ef4987c	1
	2	#include <assert.h>
	3	#include <sys/types.h>
	4	#include <stdint.h>
	5	#include <stdlib.h>
	6
	7	#define min(a,b) (((a)<(b))?a:b)
	8	#define max(a,b) (((a)>(b))?a:b)
	9	#define BUG_ON(a) assert(!(a))
	10
	11	/* Calculate the offset needed to align the type */
	12	static inline unsigned int ltt_align(size_t align_drift,
	13	size_t size_of_type)
	14	{
	15	size_t alignment = min(sizeof(void*), size_of_type);
	16
	17	return ((alignment - align_drift) & (alignment-1));
	18	}
	19
	20
	21	/* TEMPLATE */
	22
	23	enum lttng_tasklet_priority {
	24	LTTNG_LOW,
	25	LTTNG_HIGH,
	26	};
	27
	28	enum lttng_irq_mode {
	29	LTTNG_user,
	30	LTTNG_kernel,
	31	};
	32
	33	struct lttng_mystruct2 {
	34	unsigned int irq_id;
	35	enum lttng_irq_mode mode;
	36	//struct lttng_mystruct teststr1;
	37	};
	38
	39
257d03bc	40	static inline size_t lttng_get_size_mystruct2(
257d03bc	41	struct lttng_mystruct2 * obj)
6ef4987c	42	{
	43	size_t size=0, locsize;
	44
	45	locsize = sizeof(unsigned int);
	46	size += ltt_align(size, locsize) + locsize;
	47
	48	locsize = sizeof(enum lttng_irq_mode);
	49	size += ltt_align(size, locsize) + locsize;
	50
	51	BUG_ON(sizeof(struct lttng_mystruct2) != size);
	52
	53	return sizeof(struct lttng_mystruct2);
	54	}
	55
257d03bc	56	static inline size_t lttng_get_alignment_mystruct2(
6ef4987c	57	struct lttng_mystruct2 *obj)
	58	{
	59	size_t align=0, localign;
	60
	61	localign = sizeof(unsigned int);
	62	align = max(align, localign);
	63
	64	localign = sizeof(enum lttng_irq_mode);
	65	align = max(align, localign);
	66
	67	return align;
	68	}
	69
257d03bc	70	static inline size_t lttng_write_mystruct2(
	71	void *buf,
	72	size_t *to,
6ef4987c	73	void **from,
	74	size_t *len,
	75	struct lttng_mystruct2 *obj)
	76	{
257d03bc	77	size_t align, size, varalign;
6ef4987c	78
	79	align = lttng_get_alignment_mystruct2(obj);
	80	size = lttng_get_size_mystruct2(obj);
	81
	82	if(*len == 0) {
257d03bc	83	varalign = ltt_align(to, align); / align output */
257d03bc	84	*to += varalign;
6ef4987c	85	} else {
257d03bc	86	varalign = ltt_align(to+len, align); /* C alignment, ok to do a memcpy of it */
257d03bc	87	*len += varalign;
6ef4987c	88	}
	89
	90	*len += size;
257d03bc	91
257d03bc	92	return varalign+size;
6ef4987c	93	}
	94
	95
	96
	97	#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
	98	typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];
	99
257d03bc	100	static inline size_t lttng_get_size_array_mystruct_myarray(
6ef4987c	101	lttng_array_mystruct_myarray obj)
	102	{
	103	size_t size=0, locsize;
	104
	105	locsize = sizeof(uint64_t);
	106	/* ltt_align == 0 always*/
	107	//size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
	108	BUG_ON(ltt_align(size, locsize) != 0);
	109	size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;
	110
	111	BUG_ON(size != LTTNG_ARRAY_SIZE_mystruct_myarray * sizeof(uint64_t));
	112
	113	return size;
	114	}
	115
257d03bc	116	static inline size_t lttng_get_alignment_array_mystruct_myarray(
6ef4987c	117	lttng_array_mystruct_myarray obj)
	118	{
	119	size_t align=0, localign;
	120
	121	localign = sizeof(uint64_t);
	122	align = max(align, localign);
	123
	124	return align;
	125	}
	126
	127
257d03bc	128	static inline size_t lttng_write_array_mystruct_myarray(
	129	void *buf,
	130	size_t *to,
6ef4987c	131	void **from,
	132	size_t *len,
	133	lttng_array_mystruct_myarray obj)
	134	{
257d03bc	135	size_t align, size, varalign;
6ef4987c	136
	137	align = lttng_get_alignment_array_mystruct_myarray(obj);
	138	size = lttng_get_size_array_mystruct_myarray(obj);
	139
	140	if(*len == 0) {
257d03bc	141	varalign = ltt_align(to, align); / align output */
257d03bc	142	*to += varalign;
6ef4987c	143	} else {
257d03bc	144	varalign = ltt_align(to+len, align); /* C alignment, ok to do a memcpy of it */
257d03bc	145	*len += varalign;
6ef4987c	146	}
	147
	148	*len += size;
257d03bc	149
257d03bc	150	return varalign + size; /* offset in the from */
6ef4987c	151	}
	152
	153
	154	typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
	155	struct lttng_sequence_mystruct_mysequence {
	156	unsigned int len;
	157	double *array;
	158	};
	159
	160
257d03bc	161	static inline size_t lttng_get_size_sequence_mystruct_mysequence(
6ef4987c	162	lttng_sequence_mystruct_mysequence *obj)
	163	{
	164	size_t size=0, locsize;
	165
	166	locsize = sizeof(unsigned int);
	167	size += ltt_align(size, locsize) + locsize;
	168
	169	locsize = sizeof(double);
	170	size += ltt_align(size, locsize) + (obj->len * locsize);
	171
	172	return size;
	173	}
	174
257d03bc	175	static inline size_t lttng_get_alignment_sequence_mystruct_mysequence(
6ef4987c	176	lttng_sequence_mystruct_mysequence *obj)
	177	{
	178	size_t align=0, localign;
	179
	180	localign = sizeof(unsigned int);
	181	align = max(align, localign);
	182
	183	localign = sizeof(double);
	184	align = max(align, localign);
	185
	186	return align;
	187	}
	188
	189
257d03bc	190	static inline size_t lttng_write_sequence_mystruct_mysequence(
	191	void *buf,
	192	size_t *to,
6ef4987c	193	void **from,
	194	size_t *len,
	195	lttng_sequence_mystruct_mysequence *obj)
	196	{
257d03bc	197	size_t align;
257d03bc	198	size_t size=0;
6ef4987c	199	void *varfrom;
6ef4987c	200	size_t varlen=0;
257d03bc	201	size_t varalign=0;
6ef4987c	202
	203	/* Flush pending memcpy */
	204	if(*len != 0) {
257d03bc	205	memcpy(buf+to, from, *len);
6ef4987c	206	to += len;
	207	*len = 0;
	208	}
	209
	210	align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
	211	//no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
	212
	213	/* Align output */
257d03bc	214	varalign = ltt_align((size_t)(*to), align);
257d03bc	215	size += varalign;
6ef4987c	216
6ef4987c	217	/* Copy members */
257d03bc	218	varalign = ltt_align(size, sizeof(unsigned int));
257d03bc	219	size += varalign;
6ef4987c	220	varfrom = &obj->len;
6ef4987c	221	varlen += sizeof(unsigned int);
257d03bc	222	memcpy(buf+*to+size, varfrom, varlen);
257d03bc	223	size += varlen;
6ef4987c	224	varlen = 0;
6ef4987c	225
257d03bc	226	varalign = ltt_align(size, sizeof(double));
257d03bc	227	size += varalign;
6ef4987c	228	varfrom = obj->array;
6ef4987c	229	varlen += obj->len * sizeof(double);
257d03bc	230	memcpy(buf+*to+size, varfrom, varlen);
257d03bc	231	size += varlen;
6ef4987c	232	varlen = 0;
6ef4987c	233
257d03bc	234	*to += size;
257d03bc	235
6ef4987c	236	/* Put source from just after the C sequence /
6ef4987c	237	*from = obj+1;
257d03bc	238
257d03bc	239	return size;
6ef4987c	240	}
	241
	242
	243
	244	union lttng_mystruct_myunion {
	245	double myfloat;
	246	unsigned long myulong;
	247	};
	248
	249
257d03bc	250	static inline size_t lttng_get_size_mystruct_myunion(
6ef4987c	251	union lttng_mystruct_myunion *obj)
	252	{
	253	size_t size=0, locsize;
	254
	255	locsize = sizeof(double);
	256	size = max(size, locsize);
	257
	258	locsize = sizeof(unsigned long);
	259	size = max(size, locsize);
	260
	261	BUG_ON(size != sizeof(union lttng_mystruct_myunion));
	262
	263	return size;
	264	}
	265
	266
257d03bc	267	static inline size_t lttng_get_alignment_mystruct_myunion(
6ef4987c	268	union lttng_mystruct_myunion *obj)
	269	{
	270	size_t align=0, localign;
	271
	272	localign = sizeof(double);
	273	align = max(align, localign);
	274
	275	localign = sizeof(unsigned long);
	276	align = max(align, localign);
	277
	278	return align;
	279	}
	280
	281
257d03bc	282	static inline size_t lttng_write_mystruct_myunion(
	283	void *buf,
	284	size_t *to,
6ef4987c	285	void **from,
	286	size_t *len,
	287	union lttng_mystruct_myunion *obj)
	288	{
257d03bc	289	size_t align, size, varalign;
6ef4987c	290
	291	align = lttng_get_alignment_mystruct_myunion(obj);
	292	size = lttng_get_size_mystruct_myunion(obj);
	293
	294	if(*len == 0) {
257d03bc	295	varalign = ltt_align(to, align); / align output */
257d03bc	296	*to += varalign;
6ef4987c	297	} else {
257d03bc	298	varalign = ltt_align(to+len, align); /* C alignment, ok to do a memcpy of it */
257d03bc	299	*len += varalign;
6ef4987c	300	}
	301
	302	*len += size;
257d03bc	303
257d03bc	304	return varalign + size;
6ef4987c	305	}
	306
	307
	308	struct lttng_mystruct {
	309	unsigned int irq_id;
	310	enum lttng_irq_mode mode;
	311	struct lttng_mystruct2 teststr;
	312	lttng_array_mystruct_myarray myarray;
	313	lttng_sequence_mystruct_mysequence mysequence;
	314	union lttng_mystruct_myunion myunion;
	315	};
	316
257d03bc	317	static inline size_t lttng_get_size_mystruct(
6ef4987c	318	struct lttng_mystruct *obj)
	319	{
	320	size_t size=0, locsize, localign;
	321
	322	locsize = sizeof(unsigned int);
	323	size += ltt_align(size, locsize) + locsize;
	324
	325	locsize = sizeof(enum lttng_irq_mode);
	326	size += ltt_align(size, locsize) + locsize;
	327
	328	localign = lttng_get_alignment_mystruct2(&obj->teststr);
	329	locsize = lttng_get_size_mystruct2(&obj->teststr);
	330	size += ltt_align(size, localign) + locsize;
	331
	332	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
	333	locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
	334	size += ltt_align(size, localign) + locsize;
	335
	336	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
	337	locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
	338	size += ltt_align(size, localign) + locsize;
	339
	340	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
	341	locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
	342	size += ltt_align(size, localign) + locsize;
	343
	344	return size;
	345	}
	346
	347
257d03bc	348	static inline size_t lttng_get_alignment_mystruct(
6ef4987c	349	struct lttng_mystruct *obj)
	350	{
	351	size_t align=0, localign;
	352
	353	localign = sizeof(unsigned int);
	354	align = max(align, localign);
	355
	356	localign = sizeof(enum lttng_irq_mode);
	357	align = max(align, localign);
	358
	359	localign = lttng_get_alignment_mystruct2(&obj->teststr);
	360	align = max(align, localign);
	361
	362	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
	363	align = max(align, localign);
	364
	365	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
	366	align = max(align, localign);
	367
	368	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
	369	align = max(align, localign);
	370
	371	return align;
	372	}
	373
257d03bc	374	static inline void lttng_write_mystruct(
	375	void *buf,
	376	size_t *to,
6ef4987c	377	void **from,
	378	size_t *len,
	379	struct lttng_mystruct *obj)
	380	{
257d03bc	381	size_t align, size=0, locsize;
6ef4987c	382
	383	align = lttng_get_alignment_mystruct(obj);
	384	// no need : contains variable size fields.
	385	// locsize = lttng_get_size_mystruct(obj);
	386
	387	if(*len == 0) {
257d03bc	388	to += ltt_align(to, align); /* align output */
6ef4987c	389	} else {
257d03bc	390	len += ltt_align(to+len, align); / C alignment, ok to do a memcpy of it */
6ef4987c	391	}
	392
	393	/* Contains variable sized fields : must explode the structure */
	394
257d03bc	395	locsize = sizeof(unsigned int);
	396	locsize += ltt_align(size, locsize) + locsize;
	397	*len += locsize;
	398	size += locsize;
6ef4987c	399
257d03bc	400	locsize = sizeof(enum lttng_irq_mode);
	401	locsize += ltt_align(size, locsize) + locsize;
	402	*len += locsize;
	403	size += locsize;
6ef4987c	404
257d03bc	405	size += lttng_write_mystruct2(buf, to, from, len, &obj->teststr);
6ef4987c	406
257d03bc	407	size += lttng_write_array_mystruct_myarray(buf, to, from, len, obj->myarray);
6ef4987c	408
6ef4987c	409	/* Variable length field */
257d03bc	410	size += lttng_write_sequence_mystruct_mysequence(buf, to, from, len, &obj->mysequence);
6ef4987c	411
257d03bc	412	size += lttng_write_mystruct_myunion(buf, to, from, len, &obj->myunion);
6ef4987c	413
	414	/* Don't forget to flush last write..... */
	415	}
	416
	417
	418
	419
	420
	421
257d03bc	422	//void main()
257d03bc	423	void test()
6ef4987c	424	{
	425	struct lttng_mystruct test;
	426	test.mysequence.len = 20;
	427	test.mysequence.array = malloc(20);
	428
	429	size_t size = lttng_get_size_mystruct(&test);
	430	size_t align = lttng_get_alignment_mystruct(&test);
	431
dc7da603	432	/* the buffer is allocated on arch_size alignment */
6ef4987c	433	void *buf = malloc(align + size);
257d03bc	434	size_t to = 0;
6ef4987c	435	void *from = &test;
	436	size_t len = 0;
	437
257d03bc	438	lttng_write_mystruct(buf, &to, &from, &len, &test);
6ef4987c	439	/* Final flush */
	440	/* Flush pending memcpy */
	441	if(len != 0) {
257d03bc	442	memcpy(buf+to, from, len);
6ef4987c	443	to += len;
	444	from += len;
	445	len = 0;
	446	}
	447
	448	free(test.mysequence.array);
	449	free(buf);
	450	}