glib/tests/slice-color.c
2022-03-22 11:42:33 +00:00

134 lines
3.3 KiB
C

/* GLIB sliced memory - fast threaded memory chunk allocator
* Copyright (C) 2005 Tim Janik
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include <glib.h>
#define ALIGN(size, base) \
((base) * (gsize) (((size) + (base) - 1) / (base)))
static void
fill_memory (guint **mem,
guint n,
guint val)
{
guint j;
for (j = 0; j < n; j++)
mem[j][0] = val;
}
static guint64
access_memory3 (guint **mema,
guint **memb,
guint **memd,
guint n,
guint64 repeats)
{
guint64 accu = 0, i, j;
for (i = 0; i < repeats; i++)
{
for (j = 1; j < n; j += 2)
memd[j][0] = mema[j][0] + memb[j][0];
}
for (i = 0; i < repeats; i++)
for (j = 0; j < n; j++)
accu += memd[j][0];
return accu;
}
static void
touch_mem (guint64 block_size,
guint64 n_blocks,
guint64 repeats)
{
GTimer *timer;
guint **mema, **memb, **memc;
guint64 j, accu, n = n_blocks;
mema = g_new (guint*, n);
for (j = 0; j < n; j++)
mema[j] = g_slice_alloc (block_size);
memb = g_new (guint*, n);
for (j = 0; j < n; j++)
memb[j] = g_slice_alloc (block_size);
memc = g_new (guint*, n);
for (j = 0; j < n; j++)
memc[j] = g_slice_alloc (block_size);
timer = g_timer_new();
fill_memory (mema, n, 2);
fill_memory (memb, n, 3);
fill_memory (memc, n, 4);
access_memory3 (mema, memb, memc, n, 3);
g_timer_start (timer);
accu = access_memory3 (mema, memb, memc, n, repeats);
g_timer_stop (timer);
g_test_message ("Access-time = %fs", g_timer_elapsed (timer, NULL));
g_assert_cmpuint (accu / repeats, ==, (2 + 3) * n / 2 + 4 * n / 2);
for (j = 0; j < n; j++)
{
g_slice_free1 (block_size, mema[j]);
g_slice_free1 (block_size, memb[j]);
g_slice_free1 (block_size, memc[j]);
}
g_timer_destroy (timer);
g_free (mema);
g_free (memb);
g_free (memc);
}
static void
test_slice_colors (void)
{
guint64 block_size = 512;
guint64 area_size = 1024 * 1024;
guint64 n_blocks, repeats = 1000000;
/* figure number of blocks from block and area size.
* divide area by 3 because touch_mem() allocates 3 areas */
n_blocks = area_size / 3 / ALIGN (block_size, sizeof (gsize) * 2);
g_test_message ("Allocate and touch %" G_GUINT64_FORMAT
" blocks of %" G_GUINT64_FORMAT " bytes"
" (= %" G_GUINT64_FORMAT " bytes) %" G_GUINT64_FORMAT
" times with color increment",
n_blocks, block_size, n_blocks * block_size, repeats);
touch_mem (block_size, n_blocks, repeats);
}
int
main (int argc, char **argv)
{
g_test_init (&argc, &argv, NULL);
g_test_add_func ("/slice/colors", test_slice_colors);
return g_test_run ();
}