ermyth/test/balloc.C

/*
 * balloc.C: Test and time the block allocator
 * Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
 * Rights to this code are documented in doc/poddoc/license.pod
 *
 * $Id: balloc.C,v 1.2 2007-08-30 19:56:26 pippijn Exp $
 */

#include "unit/test.h"

#ifndef TIMING
#define TIMING 0
#endif
#ifndef SHOWSIZE
#define SHOWSIZE 0
#endif

/**
 * Enabling TIMING will benchmark the block allocator against system malloc ().
 * Enabling SHOWSIZE will show you the compiler's idea of each structure's size.
 */

struct myuser_balloc : object, balloc<myuser_balloc>, has_metadata
{
  typedef indexing_vector<user_t, &user_t::mu_index> login_vector;
  typedef indexing_vector<mymemo_t, &mymemo_t::mu_index> memo_vector;
  typedef unordered_vector<char *> mzignore_vector; // memo ignores

  myuser_balloc ()
  : has_metadata (metadata::MYUSER)
  {
  }

  char name[NICKLEN];
  char pass[NICKLEN];
  char email[EMAILLEN];

  login_vector logins;          /* user_t's currently logged in to this */
  time_t registered;
  time_t lastlogin;

  list_t chanacs;
  soper_t *soper;

  unsigned int flags;

  memo_vector memos;                    /* store memos */
  unsigned int memoct_new;
  unsigned int memo_ratelimit_num;      /* memos sent recently */
  time_t memo_ratelimit_time;   /* last time a memo was sent */
  mzignore_vector memo_ignores;

  /* openservices patch */
  list_t access_list;

  list_t nicks;                 /* registered nicks, must include mu->name if nonempty */

  list_t subscriptions;         /* presence subscriptors */

protected:
  void _destroy ()
  {
    delete this;
  }
};

struct myuser_noballoc : object, has_metadata
{
  typedef indexing_vector<user_t, &user_t::mu_index> login_vector;
  typedef indexing_vector<mymemo_t, &mymemo_t::mu_index> memo_vector;
  typedef unordered_vector<char *> mzignore_vector; // memo ignores

  myuser_noballoc ()
  : has_metadata (metadata::MYUSER)
  {
  }

  char name[NICKLEN];
  char pass[NICKLEN];
  char email[EMAILLEN];

  login_vector logins;          /* user_t's currently logged in to this */
  time_t registered;
  time_t lastlogin;

  list_t chanacs;
  soper_t *soper;

  unsigned int flags;

  memo_vector memos;                    /* store memos */
  unsigned int memoct_new;
  unsigned int memo_ratelimit_num;      /* memos sent recently */
  time_t memo_ratelimit_time;   /* last time a memo was sent */
  mzignore_vector memo_ignores;

  /* openservices patch */
  list_t access_list;

  list_t nicks;                 /* registered nicks, must include mu->name if nonempty */

  list_t subscriptions;         /* presence subscriptors */

protected:
  void _destroy ()
  {
    delete this;
  }
};

struct hugestruct : balloc<hugestruct>
{
  char buf[20000];
  char otherbuf[20000];
  char hugebuf[20000];
};

struct hugestruct_noballoc
{
  char buf[20000];
  char otherbuf[20000];
  char hugebuf[20000];
};

struct tinystruct : balloc<tinystruct>
{
  char onebyte;
};

struct tinystruct_noballoc
{
  char onebyte;
};

// not inline because otherwise the compiler might optimise the loop away
static hugestruct *
create ()
{
  return new hugestruct;
}

#if TIMING
static hugestruct_noballoc *
create_noballoc ()
{
  return new hugestruct_noballoc;
}

static tinystruct *
create_tinystruct ()
{
  return new tinystruct;
}

static tinystruct_noballoc *
create_tinystruct_noballoc ()
{
  return new tinystruct_noballoc;
}

static myuser_balloc *
create_myuser_balloc ()
{
  return new myuser_balloc;
}

static myuser_noballoc *
create_myuser_noballoc ()
{
  return new myuser_noballoc;
}
#endif

test<1> ()
{
  hugestruct *v[3000];
#if TIMING
  hugestruct_noballoc *n[3000];
  tinystruct *t[3000];
  tinystruct_noballoc *tn[3000];
  myuser_balloc *mub[3000];
  myuser_noballoc *munb[3000];
  int i = 1000;
#if SHOWSIZE
  std::cout << "sizeof (hugestruct)          == " << sizeof (hugestruct) << " (~60KB)\n";
  std::cout << "sizeof (hugestruct_noballoc) == " << sizeof (hugestruct_noballoc) << " (~60KB)\n";
  std::cout << "sizeof (tinystruct)          == " << sizeof (tinystruct) << " (~16B)\n";
  std::cout << "sizeof (tinystruct_noballoc) == " << sizeof (tinystruct_noballoc) << " (~1B)\n";
  std::cout << "sizeof (myuser_balloc)       == " << sizeof (myuser_balloc) << " (~500B)\n";
  std::cout << "sizeof (myuser_noballoc)     == " << sizeof (myuser_noballoc) << " (~500B)\n";
#endif

  double start = now ();
  while (--i)
    {
#endif
      for (int j = 0; j < 3000; j++)
        v[j] = create ();
      for (int j = 0; j < 3000; j++)
        delete v[j];
#if TIMING
    }
  double end = now ();
  std::cout << end - start << " seconds (huge struct balloc)\n";

  i = 1000;
  start = now ();
  while (--i)
    {
      for (int j = 0; j < 3000; j++)
        n[j] = create_noballoc ();
      for (int j = 0; j < 3000; j++)
        delete n[j];
    }
  end = now ();
  std::cout << end - start << " seconds (huge struct system malloc)\n";

  i = 1000;
  start = now ();
  while (--i)
    {
      for (int j = 0; j < 3000; j++)
        t[j] = create_tinystruct ();
      for (int j = 0; j < 3000; j++)
        delete t[j];
    }
  end = now ();
  std::cout << end - start << " seconds (tiny struct balloc)\n";

  i = 1000;
  start = now ();
  while (--i)
    {
      for (int j = 0; j < 3000; j++)
        tn[j] = create_tinystruct_noballoc ();
      for (int j = 0; j < 3000; j++)
        delete tn[j];
    }
  end = now ();
  std::cout << end - start << " seconds (tiny struct system malloc)\n";

  i = 1000;
  start = now ();
  while (--i)
    {
      for (int j = 0; j < 3000; j++)
        mub[j] = create_myuser_balloc ();
      for (int j = 0; j < 3000; j++)
        delete mub[j];
    }
  end = now ();
  std::cout << end - start << " seconds (myuser balloc)\n";

  i = 1000;
  start = now ();
  while (--i)
    {
      for (int j = 0; j < 3000; j++)
        munb[j] = create_myuser_noballoc ();
      for (int j = 0; j < 3000; j++)
        delete munb[j];
    }
  end = now ();
  std::cout << end - start << " seconds (myuser system malloc)\n";
#endif

  hugestruct::finalise ();
  tinystruct::finalise ();
  myuser_balloc::finalise ();
}

#include "unit/runtest.h"
Revision:	1.3
Committed:	Wed Sep 5 11:23:15 2007 UTC (18 years, 7 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.2:	+2 -2 lines
Log Message:	removed GPLed code and put license back to BSD
#	Content
1	/*
2	* balloc.C: Test and time the block allocator
3	* Copyright © 2007 Pippijn van Steenhoven / The Ermyth Team
4	* Rights to this code are documented in doc/poddoc/license.pod
5	*
6	* $Id: balloc.C,v 1.2 2007-08-30 19:56:26 pippijn Exp $
7	*/
8
9	#include "unit/test.h"
10
11	#ifndef TIMING
12	#define TIMING 0
13	#endif
14	#ifndef SHOWSIZE
15	#define SHOWSIZE 0
16	#endif
17
18	/**
19	* Enabling TIMING will benchmark the block allocator against system malloc ().
20	* Enabling SHOWSIZE will show you the compiler's idea of each structure's size.
21	*/
22
23	struct myuser_balloc : object, balloc<myuser_balloc>, has_metadata
24	{
25	typedef indexing_vector<user_t, &user_t::mu_index> login_vector;
26	typedef indexing_vector<mymemo_t, &mymemo_t::mu_index> memo_vector;
27	typedef unordered_vector<char *> mzignore_vector; // memo ignores
28
29	myuser_balloc ()
30	: has_metadata (metadata::MYUSER)
31	{
32	}
33
34	char name[NICKLEN];
35	char pass[NICKLEN];
36	char email[EMAILLEN];
37
38	login_vector logins; /* user_t's currently logged in to this */
39	time_t registered;
40	time_t lastlogin;
41
42	list_t chanacs;
43	soper_t *soper;
44
45	unsigned int flags;
46
47	memo_vector memos; /* store memos */
48	unsigned int memoct_new;
49	unsigned int memo_ratelimit_num; /* memos sent recently */
50	time_t memo_ratelimit_time; /* last time a memo was sent */
51	mzignore_vector memo_ignores;
52
53	/* openservices patch */
54	list_t access_list;
55
56	list_t nicks; /* registered nicks, must include mu->name if nonempty */
57
58	list_t subscriptions; /* presence subscriptors */
59
60	protected:
61	void _destroy ()
62	{
63	delete this;
64	}
65	};
66
67	struct myuser_noballoc : object, has_metadata
68	{
69	typedef indexing_vector<user_t, &user_t::mu_index> login_vector;
70	typedef indexing_vector<mymemo_t, &mymemo_t::mu_index> memo_vector;
71	typedef unordered_vector<char *> mzignore_vector; // memo ignores
72
73	myuser_noballoc ()
74	: has_metadata (metadata::MYUSER)
75	{
76	}
77
78	char name[NICKLEN];
79	char pass[NICKLEN];
80	char email[EMAILLEN];
81
82	login_vector logins; /* user_t's currently logged in to this */
83	time_t registered;
84	time_t lastlogin;
85
86	list_t chanacs;
87	soper_t *soper;
88
89	unsigned int flags;
90
91	memo_vector memos; /* store memos */
92	unsigned int memoct_new;
93	unsigned int memo_ratelimit_num; /* memos sent recently */
94	time_t memo_ratelimit_time; /* last time a memo was sent */
95	mzignore_vector memo_ignores;
96
97	/* openservices patch */
98	list_t access_list;
99
100	list_t nicks; /* registered nicks, must include mu->name if nonempty */
101
102	list_t subscriptions; /* presence subscriptors */
103
104	protected:
105	void _destroy ()
106	{
107	delete this;
108	}
109	};
110
111	struct hugestruct : balloc<hugestruct>
112	{
113	char buf[20000];
114	char otherbuf[20000];
115	char hugebuf[20000];
116	};
117
118	struct hugestruct_noballoc
119	{
120	char buf[20000];
121	char otherbuf[20000];
122	char hugebuf[20000];
123	};
124
125	struct tinystruct : balloc<tinystruct>
126	{
127	char onebyte;
128	};
129
130	struct tinystruct_noballoc
131	{
132	char onebyte;
133	};
134
135	// not inline because otherwise the compiler might optimise the loop away
136	static hugestruct *
137	create ()
138	{
139	return new hugestruct;
140	}
141
142	#if TIMING
143	static hugestruct_noballoc *
144	create_noballoc ()
145	{
146	return new hugestruct_noballoc;
147	}
148
149	static tinystruct *
150	create_tinystruct ()
151	{
152	return new tinystruct;
153	}
154
155	static tinystruct_noballoc *
156	create_tinystruct_noballoc ()
157	{
158	return new tinystruct_noballoc;
159	}
160
161	static myuser_balloc *
162	create_myuser_balloc ()
163	{
164	return new myuser_balloc;
165	}
166
167	static myuser_noballoc *
168	create_myuser_noballoc ()
169	{
170	return new myuser_noballoc;
171	}
172	#endif
173
174	test<1> ()
175	{
176	hugestruct *v[3000];
177	#if TIMING
178	hugestruct_noballoc *n[3000];
179	tinystruct *t[3000];
180	tinystruct_noballoc *tn[3000];
181	myuser_balloc *mub[3000];
182	myuser_noballoc *munb[3000];
183	int i = 1000;
184	#if SHOWSIZE
185	std::cout << "sizeof (hugestruct) == " << sizeof (hugestruct) << " (~60KB)\n";
186	std::cout << "sizeof (hugestruct_noballoc) == " << sizeof (hugestruct_noballoc) << " (~60KB)\n";
187	std::cout << "sizeof (tinystruct) == " << sizeof (tinystruct) << " (~16B)\n";
188	std::cout << "sizeof (tinystruct_noballoc) == " << sizeof (tinystruct_noballoc) << " (~1B)\n";
189	std::cout << "sizeof (myuser_balloc) == " << sizeof (myuser_balloc) << " (~500B)\n";
190	std::cout << "sizeof (myuser_noballoc) == " << sizeof (myuser_noballoc) << " (~500B)\n";
191	#endif
192
193	double start = now ();
194	while (--i)
195	{
196	#endif
197	for (int j = 0; j < 3000; j++)
198	v[j] = create ();
199	for (int j = 0; j < 3000; j++)
200	delete v[j];
201	#if TIMING
202	}
203	double end = now ();
204	std::cout << end - start << " seconds (huge struct balloc)\n";
205
206	i = 1000;
207	start = now ();
208	while (--i)
209	{
210	for (int j = 0; j < 3000; j++)
211	n[j] = create_noballoc ();
212	for (int j = 0; j < 3000; j++)
213	delete n[j];
214	}
215	end = now ();
216	std::cout << end - start << " seconds (huge struct system malloc)\n";
217
218	i = 1000;
219	start = now ();
220	while (--i)
221	{
222	for (int j = 0; j < 3000; j++)
223	t[j] = create_tinystruct ();
224	for (int j = 0; j < 3000; j++)
225	delete t[j];
226	}
227	end = now ();
228	std::cout << end - start << " seconds (tiny struct balloc)\n";
229
230	i = 1000;
231	start = now ();
232	while (--i)
233	{
234	for (int j = 0; j < 3000; j++)
235	tn[j] = create_tinystruct_noballoc ();
236	for (int j = 0; j < 3000; j++)
237	delete tn[j];
238	}
239	end = now ();
240	std::cout << end - start << " seconds (tiny struct system malloc)\n";
241
242	i = 1000;
243	start = now ();
244	while (--i)
245	{
246	for (int j = 0; j < 3000; j++)
247	mub[j] = create_myuser_balloc ();
248	for (int j = 0; j < 3000; j++)
249	delete mub[j];
250	}
251	end = now ();
252	std::cout << end - start << " seconds (myuser balloc)\n";
253
254	i = 1000;
255	start = now ();
256	while (--i)
257	{
258	for (int j = 0; j < 3000; j++)
259	munb[j] = create_myuser_noballoc ();
260	for (int j = 0; j < 3000; j++)
261	delete munb[j];
262	}
263	end = now ();
264	std::cout << end - start << " seconds (myuser system malloc)\n";
265	#endif
266
267	hugestruct::finalise ();
268	tinystruct::finalise ();
269	myuser_balloc::finalise ();
270	}
271
272	#include "unit/runtest.h"