[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;
};


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);
}

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;
}

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

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

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


#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];

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;
}

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;
}


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

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


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


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;
}

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;
}


void lttng_write_sequence_mystruct_mysequence(void **to,
		void **from,
		size_t *len,
		lttng_sequence_mystruct_mysequence *obj)
{
	size_t align, size;
	void *varfrom;
	size_t varlen=0;
	
	/* Flush pending memcpy */
	if(*len != 0) {
		memcpy(*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 */
	*to += ltt_align((size_t)(*to), align);
	
	/* Copy members */
	*to += ltt_align((size_t)*to, sizeof(unsigned int));
	varfrom = &obj->len;
	varlen += sizeof(unsigned int);
	memcpy(*to, varfrom, varlen);
	*to += varlen;
	varlen = 0;

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

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


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


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;
}


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;
}


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

	if(*len == 0) {
		*to += ltt_align((size_t)(*to), align);	/* align output */
	} else {
		*len += ltt_align((size_t)(*to+*len), align);	/* C alignment, ok to do a memcpy of it */
	}
	
	*len += 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;
};

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;
}


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;
}

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

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

	lttng_write_mystruct2(to, from, len, &obj->teststr);

	lttng_write_array_mystruct_myarray(to, from, len, obj->myarray);

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

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


void main()
{
	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);

	void *buf = malloc(align + size);
	void *to = buf;
	void *from = &test;
	size_t len = 0;

	lttng_write_mystruct(&to, &from, &len, &test);
	/* Final flush */
	/* Flush pending memcpy */
	if(len != 0) {
		memcpy(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
	40	size_t lttng_get_size_mystruct2(
	41	struct lttng_mystruct2 *obj)
	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
	56	size_t lttng_get_alignment_mystruct2(
	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
70	void lttng_write_mystruct2(void **to,
71	void **from,
72	size_t *len,
73	struct lttng_mystruct2 *obj)
74	{
75	size_t align, size;
76
77	align = lttng_get_alignment_mystruct2(obj);
78	size = lttng_get_size_mystruct2(obj);
79
80	if(*len == 0) {
81	to += ltt_align((size_t)(to), align); /* align output */
82	} else {
83	len += ltt_align((size_t)(to+len), align); / C alignment, ok to do a memcpy of it */
84	}
85
86	*len += size;
87	}
88
89
90
91	#define LTTNG_ARRAY_SIZE_mystruct_myarray 10
92	typedef uint64_t lttng_array_mystruct_myarray[LTTNG_ARRAY_SIZE_mystruct_myarray];
93
94	size_t lttng_get_size_array_mystruct_myarray(
95	lttng_array_mystruct_myarray obj)
96	{
97	size_t size=0, locsize;
98
99	locsize = sizeof(uint64_t);
100	/* ltt_align == 0 always*/
101	//size += ltt_align(size, locsize) + (LTTNG_ARRAY_SIZE_mystruct_myarray * locsize);
102	BUG_ON(ltt_align(size, locsize) != 0);
103	size += LTTNG_ARRAY_SIZE_mystruct_myarray * locsize;
104
105	BUG_ON(size != LTTNG_ARRAY_SIZE_mystruct_myarray * sizeof(uint64_t));
106
107	return size;
108	}
109
110	size_t lttng_get_alignment_array_mystruct_myarray(
111	lttng_array_mystruct_myarray obj)
112	{
113	size_t align=0, localign;
114
115	localign = sizeof(uint64_t);
116	align = max(align, localign);
117
118	return align;
119	}
120
121
122	void lttng_write_array_mystruct_myarray(void **to,
123	void **from,
124	size_t *len,
125	lttng_array_mystruct_myarray obj)
126	{
127	size_t align, size;
128
129	align = lttng_get_alignment_array_mystruct_myarray(obj);
130	size = lttng_get_size_array_mystruct_myarray(obj);
131
132	if(*len == 0) {
133	to += ltt_align((size_t)(to), align); /* align output */
134	} else {
135	len += ltt_align((size_t)(to+len), align); / C alignment, ok to do a memcpy of it */
136	}
137
138	*len += size;
139	}
140
141
142	typedef struct lttng_sequence_mystruct_mysequence lttng_sequence_mystruct_mysequence;
143	struct lttng_sequence_mystruct_mysequence {
144	unsigned int len;
145	double *array;
146	};
147
148
149	size_t lttng_get_size_sequence_mystruct_mysequence(
150	lttng_sequence_mystruct_mysequence *obj)
151	{
152	size_t size=0, locsize;
153
154	locsize = sizeof(unsigned int);
155	size += ltt_align(size, locsize) + locsize;
156
157	locsize = sizeof(double);
158	size += ltt_align(size, locsize) + (obj->len * locsize);
159
160	return size;
161	}
162
163	size_t lttng_get_alignment_sequence_mystruct_mysequence(
164	lttng_sequence_mystruct_mysequence *obj)
165	{
166	size_t align=0, localign;
167
168	localign = sizeof(unsigned int);
169	align = max(align, localign);
170
171	localign = sizeof(double);
172	align = max(align, localign);
173
174	return align;
175	}
176
177
178	void lttng_write_sequence_mystruct_mysequence(void **to,
179	void **from,
180	size_t *len,
181	lttng_sequence_mystruct_mysequence *obj)
182	{
183	size_t align, size;
184	void *varfrom;
185	size_t varlen=0;
186
187	/* Flush pending memcpy */
188	if(*len != 0) {
189	memcpy(to, from, *len);
190	to += len;
191	*len = 0;
192	}
193
194	align = lttng_get_alignment_sequence_mystruct_mysequence(obj);
195	//no need size = lttng_get_size_sequence_mystruct_mysequence(obj);
196
197	/* Align output */
198	to += ltt_align((size_t)(to), align);
199
200	/* Copy members */
201	to += ltt_align((size_t)to, sizeof(unsigned int));
202	varfrom = &obj->len;
203	varlen += sizeof(unsigned int);
204	memcpy(*to, varfrom, varlen);
205	*to += varlen;
206	varlen = 0;
207
208	to += ltt_align((size_t)to, sizeof(double));
209	varfrom = obj->array;
210	varlen += obj->len * sizeof(double);
211	memcpy(*to, varfrom, varlen);
212	*to += varlen;
213	varlen = 0;
214
215	/* Put source from just after the C sequence /
216	*from = obj+1;
217	}
218
219
220
221	union lttng_mystruct_myunion {
222	double myfloat;
223	unsigned long myulong;
224	};
225
226
227	size_t lttng_get_size_mystruct_myunion(
228	union lttng_mystruct_myunion *obj)
229	{
230	size_t size=0, locsize;
231
232	locsize = sizeof(double);
233	size = max(size, locsize);
234
235	locsize = sizeof(unsigned long);
236	size = max(size, locsize);
237
238	BUG_ON(size != sizeof(union lttng_mystruct_myunion));
239
240	return size;
241	}
242
243
244	size_t lttng_get_alignment_mystruct_myunion(
245	union lttng_mystruct_myunion *obj)
246	{
247	size_t align=0, localign;
248
249	localign = sizeof(double);
250	align = max(align, localign);
251
252	localign = sizeof(unsigned long);
253	align = max(align, localign);
254
255	return align;
256	}
257
258
259	void lttng_write_mystruct_myunion(void **to,
260	void **from,
261	size_t *len,
262	union lttng_mystruct_myunion *obj)
263	{
264	size_t align, size;
265
266	align = lttng_get_alignment_mystruct_myunion(obj);
267	size = lttng_get_size_mystruct_myunion(obj);
268
269	if(*len == 0) {
270	to += ltt_align((size_t)(to), align); /* align output */
271	} else {
272	len += ltt_align((size_t)(to+len), align); / C alignment, ok to do a memcpy of it */
273	}
274
275	*len += size;
276	}
277
278
279	struct lttng_mystruct {
280	unsigned int irq_id;
281	enum lttng_irq_mode mode;
282	struct lttng_mystruct2 teststr;
283	lttng_array_mystruct_myarray myarray;
284	lttng_sequence_mystruct_mysequence mysequence;
285	union lttng_mystruct_myunion myunion;
286	};
287
288	size_t lttng_get_size_mystruct(
289	struct lttng_mystruct *obj)
290	{
291	size_t size=0, locsize, localign;
292
293	locsize = sizeof(unsigned int);
294	size += ltt_align(size, locsize) + locsize;
295
296	locsize = sizeof(enum lttng_irq_mode);
297	size += ltt_align(size, locsize) + locsize;
298
299	localign = lttng_get_alignment_mystruct2(&obj->teststr);
300	locsize = lttng_get_size_mystruct2(&obj->teststr);
301	size += ltt_align(size, localign) + locsize;
302
303	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
304	locsize = lttng_get_size_array_mystruct_myarray(obj->myarray);
305	size += ltt_align(size, localign) + locsize;
306
307	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
308	locsize = lttng_get_size_sequence_mystruct_mysequence(&obj->mysequence);
309	size += ltt_align(size, localign) + locsize;
310
311	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
312	locsize = lttng_get_size_mystruct_myunion(&obj->myunion);
313	size += ltt_align(size, localign) + locsize;
314
315	return size;
316	}
317
318
319	size_t lttng_get_alignment_mystruct(
320	struct lttng_mystruct *obj)
321	{
322	size_t align=0, localign;
323
324	localign = sizeof(unsigned int);
325	align = max(align, localign);
326
327	localign = sizeof(enum lttng_irq_mode);
328	align = max(align, localign);
329
330	localign = lttng_get_alignment_mystruct2(&obj->teststr);
331	align = max(align, localign);
332
333	localign = lttng_get_alignment_array_mystruct_myarray(obj->myarray);
334	align = max(align, localign);
335
336	localign = lttng_get_alignment_sequence_mystruct_mysequence(&obj->mysequence);
337	align = max(align, localign);
338
339	localign = lttng_get_alignment_mystruct_myunion(&obj->myunion);
340	align = max(align, localign);
341
342	return align;
343	}
344
345	void lttng_write_mystruct(void **to,
346	void **from,
347	size_t *len,
348	struct lttng_mystruct *obj)
349	{
350	size_t align, size;
351
352	align = lttng_get_alignment_mystruct(obj);
353	// no need : contains variable size fields.
354	// locsize = lttng_get_size_mystruct(obj);
355
356	if(*len == 0) {
357	to += ltt_align((size_t)(to), align); /* align output */
358	} else {
359	len += ltt_align((size_t)(to+len), align); / C alignment, ok to do a memcpy of it */
360	}
361
362	/* Contains variable sized fields : must explode the structure */
363
364	size = sizeof(unsigned int);
365	len += ltt_align((size_t)(to+*len), size) + size;
366
367	size = sizeof(enum lttng_irq_mode);
368	len += ltt_align((size_t)(to+*len), size) + size;
369
370	lttng_write_mystruct2(to, from, len, &obj->teststr);
371
372	lttng_write_array_mystruct_myarray(to, from, len, obj->myarray);
373
374	/* Variable length field */
375	lttng_write_sequence_mystruct_mysequence(to, from, len, &obj->mysequence);
376
377	lttng_write_mystruct_myunion(to, from, len, &obj->myunion);
378
379	/* Don't forget to flush last write..... */
380	}
381
382
383
384
385
386
387	void main()
388	{
389	struct lttng_mystruct test;
390	test.mysequence.len = 20;
391	test.mysequence.array = malloc(20);
392
393	size_t size = lttng_get_size_mystruct(&test);
394	size_t align = lttng_get_alignment_mystruct(&test);
395
396	void *buf = malloc(align + size);
397	void *to = buf;
398	void *from = &test;
399	size_t len = 0;
400
401	lttng_write_mystruct(&to, &from, &len, &test);
402	/* Final flush */
403	/* Flush pending memcpy */
404	if(len != 0) {
405	memcpy(to, from, len);
406	to += len;
407	from += len;
408	len = 0;
409	}
410
411	free(test.mysequence.array);
412	free(buf);
413	}