From: Mathieu Desnoyers <compudj@krystal.dyndns.org>
To: Christoph Lameter <clameter@sgi.com>
Cc: akpm@linux-foundation.org, linux-kernel@vger.kernel.org,
mingo@redhat.com
Subject: Re: [PATCH] SLUB use cmpxchg_local
Date: Tue, 21 Aug 2007 13:44:24 -0400 [thread overview]
Message-ID: <20070821174424.GB8360@Krystal> (raw)
In-Reply-To: <20070821173849.GA8360@Krystal>
Hi Christoph,
If you are interested in the raw numbers:
The (very basic) test module follows. Make sure you change get_cycles()
for get_cycles_sync() if you plan to run this on x86_64.
(tests taken on a 3GHz Pentium 4)
* slub HEAD, test 1
[ 99.774699] SLUB Performance testing
[ 99.785431] ========================
[ 99.796099] 1. Kmalloc: Repeatedly allocate then free test
[ 99.813159] 10000 times kmalloc(8) =
[ 99.824072] number of loops: 10000
[ 99.834207] total time: 2019990
[ 99.843562] -> 201 cycles
[ 99.852535] 10000 times kfree =
[ 99.862167] number of loops: 10000
[ 99.872310] total time: 3519982
[ 99.881669] -> 351 cycles
[ 99.890128] 10000 times kmalloc(16) =
[ 99.901298] number of loops: 10000
[ 99.911433] total time: 1986503
[ 99.920786] -> 198 cycles
[ 99.929784] 10000 times kfree =
[ 99.939397] number of loops: 10000
[ 99.949532] total time: 3596775
[ 99.958885] -> 359 cycles
[ 99.967352] 10000 times kmalloc(32) =
[ 99.978522] number of loops: 10000
[ 99.988657] total time: 2009003
[ 99.998098] -> 200 cycles
[ 100.007171] 10000 times kfree =
[ 100.016786] number of loops: 10000
[ 100.026919] total time: 3814418
[ 100.036296] -> 381 cycles
[ 100.044844] 10000 times kmalloc(64) =
[ 100.056016] number of loops: 10000
[ 100.066150] total time: 2242620
[ 100.075504] -> 224 cycles
[ 100.084619] 10000 times kfree =
[ 100.094234] number of loops: 10000
[ 100.104369] total time: 3941348
[ 100.113722] -> 394 cycles
[ 100.122475] 10000 times kmalloc(128) =
[ 100.133914] number of loops: 10000
[ 100.144049] total time: 2857560
[ 100.153485] -> 285 cycles
[ 100.162705] 10000 times kfree =
[ 100.172332] number of loops: 10000
[ 100.182468] total time: 4241543
[ 100.191821] -> 424 cycles
[ 100.200996] 10000 times kmalloc(256) =
[ 100.212437] number of loops: 10000
[ 100.222571] total time: 4119900
[ 100.231949] -> 411 cycles
[ 100.241570] 10000 times kfree =
[ 100.251218] number of loops: 10000
[ 100.261353] total time: 5462655
[ 100.270705] -> 546 cycles
[ 100.280105] 10000 times kmalloc(512) =
[ 100.291548] number of loops: 10000
[ 100.301683] total time: 4802820
[ 100.311037] -> 480 cycles
[ 100.320899] 10000 times kfree =
[ 100.330518] number of loops: 10000
[ 100.340661] total time: 6191827
[ 100.350040] -> 619 cycles
[ 100.359917] 10000 times kmalloc(1024) =
[ 100.371633] number of loops: 10000
[ 100.381767] total time: 6235890
[ 100.391120] -> 623 cycles
[ 100.401419] 10000 times kfree =
[ 100.411034] number of loops: 10000
[ 100.421170] total time: 7504095
[ 100.430523] -> 750 cycles
[ 100.440608] 10000 times kmalloc(2048) =
[ 100.452300] number of loops: 10000
[ 100.462433] total time: 6863955
[ 100.471786] -> 686 cycles
[ 100.482287] 10000 times kfree =
[ 100.491922] number of loops: 10000
[ 100.502065] total time: 8110590
[ 100.511419] -> 811 cycles
[ 100.520824] 10000 times kmalloc(4096) =
[ 100.532537] number of loops: 10000
[ 100.542670] total time: 4824007
[ 100.552023] -> 482 cycles
[ 100.561618] 10000 times kfree =
[ 100.571255] number of loops: 10000
[ 100.581390] total time: 5387670
[ 100.590768] -> 538 cycles
[ 100.600835] 10000 times kmalloc(8192) =
[ 100.612549] number of loops: 10000
[ 100.622684] total time: 6808680
[ 100.632037] -> 680 cycles
[ 100.642285] 10000 times kfree =
[ 100.651898] number of loops: 10000
[ 100.662031] total time: 7349797
[ 100.671385] -> 734 cycles
[ 100.681563] 10000 times kmalloc(16384) =
[ 100.693523] number of loops: 10000
[ 100.703658] total time: 7133790
[ 100.713036] -> 713 cycles
[ 100.723654] 10000 times kfree =
[ 100.733299] number of loops: 10000
[ 100.743434] total time: 8431725
[ 100.752788] -> 843 cycles
[ 100.760588] 2. Kmalloc: alloc/free test
[ 100.773091] 10000 times kmalloc(8)/kfree =
[ 100.785558] number of loops: 10000
[ 100.795694] total time: 3223072
[ 100.805046] -> 322 cycles
[ 100.813904] 10000 times kmalloc(16)/kfree =
[ 100.826629] number of loops: 10000
[ 100.836763] total time: 3181702
[ 100.846116] -> 318 cycles
[ 100.854975] 10000 times kmalloc(32)/kfree =
[ 100.867725] number of loops: 10000
[ 100.877860] total time: 3183517
[ 100.887296] -> 318 cycles
[ 100.896179] 10000 times kmalloc(64)/kfree =
[ 100.908905] number of loops: 10000
[ 100.919039] total time: 3253335
[ 100.928418] -> 325 cycles
[ 100.937277] 10000 times kmalloc(128)/kfree =
[ 100.950272] number of loops: 10000
[ 100.960407] total time: 3181478
[ 100.969760] -> 318 cycles
[ 100.978652] 10000 times kmalloc(256)/kfree =
[ 100.991662] number of loops: 10000
[ 101.001796] total time: 3282810
[ 101.011149] -> 328 cycles
[ 101.020042] 10000 times kmalloc(512)/kfree =
[ 101.033025] number of loops: 10000
[ 101.043161] total time: 3286725
[ 101.052515] -> 328 cycles
[ 101.061409] 10000 times kmalloc(1024)/kfree =
[ 101.074652] number of loops: 10000
[ 101.084787] total time: 3281677
[ 101.094141] -> 328 cycles
[ 101.103033] 10000 times kmalloc(2048)/kfree =
[ 101.116277] number of loops: 10000
[ 101.126413] total time: 3281460
[ 101.135789] -> 328 cycles
[ 101.145850] 10000 times kmalloc(4096)/kfree =
[ 101.159120] number of loops: 10000
[ 101.169255] total time: 6786870
[ 101.178608] -> 678 cycles
[ 101.189783] 10000 times kmalloc(8192)/kfree =
[ 101.203030] number of loops: 10000
[ 101.213166] total time: 10135372
[ 101.222846] -> 1013 cycles
[ 101.234812] 10000 times kmalloc(16384)/kfree =
[ 101.248342] number of loops: 10000
[ 101.258476] total time: 11575222
[ 101.268090] -> 1157 cycles
* Slub HEAD, test 2
[ 225.212707] SLUB Performance testing
[ 225.223363] ========================
[ 225.234040] 1. Kmalloc: Repeatedly allocate then free test
[ 225.251038] 10000 times kmalloc(8) =
[ 225.261956] number of loops: 10000
[ 225.272089] total time: 1908952
[ 225.281444] -> 190 cycles
[ 225.290415] 10000 times kfree =
[ 225.300028] number of loops: 10000
[ 225.310164] total time: 3516172
[ 225.319527] -> 351 cycles
[ 225.327979] 10000 times kmalloc(16) =
[ 225.339174] number of loops: 10000
[ 225.349309] total time: 1955085
[ 225.358661] -> 195 cycles
[ 225.367662] 10000 times kfree =
[ 225.377275] number of loops: 10000
[ 225.387411] total time: 3602730
[ 225.396789] -> 360 cycles
[ 225.405258] 10000 times kmalloc(32) =
[ 225.416426] number of loops: 10000
[ 225.426561] total time: 2010450
[ 225.435914] -> 201 cycles
[ 225.444949] 10000 times kfree =
[ 225.454631] number of loops: 10000
[ 225.464829] total time: 3706695
[ 225.474239] -> 370 cycles
[ 225.482926] 10000 times kmalloc(64) =
[ 225.494100] number of loops: 10000
[ 225.504236] total time: 2450453
[ 225.513590] -> 245 cycles
[ 225.522689] 10000 times kfree =
[ 225.532303] number of loops: 10000
[ 225.542443] total time: 3897607
[ 225.551798] -> 389 cycles
[ 225.560546] 10000 times kmalloc(128) =
[ 225.571987] number of loops: 10000
[ 225.582122] total time: 2837782
[ 225.591475] -> 283 cycles
[ 225.600653] 10000 times kfree =
[ 225.610277] number of loops: 10000
[ 225.620412] total time: 4130122
[ 225.629789] -> 413 cycles
[ 225.638956] 10000 times kmalloc(256) =
[ 225.650398] number of loops: 10000
[ 225.660534] total time: 4093110
[ 225.669887] -> 409 cycles
[ 225.679515] 10000 times kfree =
[ 225.689135] number of loops: 10000
[ 225.699269] total time: 5478518
[ 225.708633] -> 547 cycles
[ 225.718031] 10000 times kmalloc(512) =
[ 225.729468] number of loops: 10000
[ 225.739602] total time: 4765365
[ 225.748955] -> 476 cycles
[ 225.758810] 10000 times kfree =
[ 225.768431] number of loops: 10000
[ 225.778565] total time: 6167265
[ 225.787918] -> 616 cycles
[ 225.797811] 10000 times kmalloc(1024) =
[ 225.809504] number of loops: 10000
[ 225.819639] total time: 6280335
[ 225.828991] -> 628 cycles
[ 225.839302] 10000 times kfree =
[ 225.848942] number of loops: 10000
[ 225.859078] total time: 7538393
[ 225.868456] -> 753 cycles
[ 225.878535] 10000 times kmalloc(2048) =
[ 225.890226] number of loops: 10000
[ 225.900362] total time: 6842648
[ 225.909716] -> 684 cycles
[ 225.920218] 10000 times kfree =
[ 225.929834] number of loops: 10000
[ 225.939977] total time: 8114550
[ 225.949331] -> 811 cycles
[ 225.958730] 10000 times kmalloc(4096) =
[ 225.970419] number of loops: 10000
[ 225.980554] total time: 4803345
[ 225.989933] -> 480 cycles
[ 225.999531] 10000 times kfree =
[ 226.009145] number of loops: 10000
[ 226.019278] total time: 5398282
[ 226.028656] -> 539 cycles
[ 226.038659] 10000 times kmalloc(8192) =
[ 226.050349] number of loops: 10000
[ 226.060484] total time: 6613185
[ 226.069837] -> 661 cycles
[ 226.080124] 10000 times kfree =
[ 226.089738] number of loops: 10000
[ 226.099874] total time: 7467765
[ 226.109251] -> 746 cycles
[ 226.119523] 10000 times kmalloc(16384) =
[ 226.131476] number of loops: 10000
[ 226.141611] total time: 7417830
[ 226.150963] -> 741 cycles
[ 226.161627] 10000 times kfree =
[ 226.171250] number of loops: 10000
[ 226.181386] total time: 8564873
[ 226.190765] -> 856 cycles
[ 226.198565] 2. Kmalloc: alloc/free test
[ 226.211071] 10000 times kmalloc(8)/kfree =
[ 226.223538] number of loops: 10000
[ 226.233674] total time: 3233355
[ 226.243028] -> 323 cycles
[ 226.251887] 10000 times kmalloc(16)/kfree =
[ 226.264612] number of loops: 10000
[ 226.274755] total time: 3181650
[ 226.284132] -> 318 cycles
[ 226.292991] 10000 times kmalloc(32)/kfree =
[ 226.305716] number of loops: 10000
[ 226.315851] total time: 3181140
[ 226.325228] -> 318 cycles
[ 226.334089] 10000 times kmalloc(64)/kfree =
[ 226.346839] number of loops: 10000
[ 226.356974] total time: 3183255
[ 226.366352] -> 318 cycles
[ 226.375216] 10000 times kmalloc(128)/kfree =
[ 226.388210] number of loops: 10000
[ 226.398345] total time: 3188498
[ 226.407698] -> 318 cycles
[ 226.416591] 10000 times kmalloc(256)/kfree =
[ 226.429602] number of loops: 10000
[ 226.439737] total time: 3281130
[ 226.449090] -> 328 cycles
[ 226.457983] 10000 times kmalloc(512)/kfree =
[ 226.470992] number of loops: 10000
[ 226.481127] total time: 3283387
[ 226.490480] -> 328 cycles
[ 226.499375] 10000 times kmalloc(1024)/kfree =
[ 226.512619] number of loops: 10000
[ 226.522754] total time: 3287888
[ 226.532106] -> 328 cycles
[ 226.540999] 10000 times kmalloc(2048)/kfree =
[ 226.554270] number of loops: 10000
[ 226.564405] total time: 3281467
[ 226.573757] -> 328 cycles
[ 226.583720] 10000 times kmalloc(4096)/kfree =
[ 226.596989] number of loops: 10000
[ 226.607124] total time: 6489922
[ 226.616476] -> 648 cycles
[ 226.627646] 10000 times kmalloc(8192)/kfree =
[ 226.640891] number of loops: 10000
[ 226.651027] total time: 10095772
[ 226.660639] -> 1009 cycles
[ 226.672381] 10000 times kmalloc(16384)/kfree =
[ 226.685910] number of loops: 10000
[ 226.696045] total time: 11056943
[ 226.705658] -> 1105 cycles
* cmpxchg_local Slub test
[ 119.518080] SLUB Performance testing
[ 119.528739] ========================
[ 119.539393] 1. Kmalloc: Repeatedly allocate then free test
[ 119.556032] 10000 times kmalloc(8) =
[ 119.566952] number of loops: 10000
[ 119.577087] total time: 831930
[ 119.586182] -> 83 cycles
[ 119.594933] 10000 times kfree =
[ 119.604570] number of loops: 10000
[ 119.614705] total time: 3636653
[ 119.624059] -> 363 cycles
[ 119.632142] 10000 times kmalloc(16) =
[ 119.643330] number of loops: 10000
[ 119.653464] total time: 851895
[ 119.662564] -> 85 cycles
[ 119.671341] 10000 times kfree =
[ 119.680954] number of loops: 10000
[ 119.691089] total time: 3722985
[ 119.700441] -> 372 cycles
[ 119.708551] 10000 times kmalloc(32) =
[ 119.719721] number of loops: 10000
[ 119.729855] total time: 928470
[ 119.738973] -> 92 cycles
[ 119.747770] 10000 times kfree =
[ 119.757382] number of loops: 10000
[ 119.767518] total time: 3772147
[ 119.776871] -> 377 cycles
[ 119.785065] 10000 times kmalloc(64) =
[ 119.796246] number of loops: 10000
[ 119.806380] total time: 1157535
[ 119.815734] -> 115 cycles
[ 119.824858] 10000 times kfree =
[ 119.834473] number of loops: 10000
[ 119.844609] total time: 3975780
[ 119.853962] -> 397 cycles
[ 119.862361] 10000 times kmalloc(128) =
[ 119.873801] number of loops: 10000
[ 119.883940] total time: 1792695
[ 119.893382] -> 179 cycles
[ 119.902658] 10000 times kfree =
[ 119.912282] number of loops: 10000
[ 119.922416] total time: 4385093
[ 119.931769] -> 438 cycles
[ 119.940617] 10000 times kmalloc(256) =
[ 119.952146] number of loops: 10000
[ 119.962345] total time: 3140227
[ 119.971753] -> 314 cycles
[ 119.981498] 10000 times kfree =
[ 119.991124] number of loops: 10000
[ 120.001258] total time: 5641035
[ 120.010613] -> 564 cycles
[ 120.019752] 10000 times kmalloc(512) =
[ 120.031186] number of loops: 10000
[ 120.041321] total time: 3989085
[ 120.050676] -> 398 cycles
[ 120.060528] 10000 times kfree =
[ 120.070146] number of loops: 10000
[ 120.080281] total time: 6159315
[ 120.089633] -> 615 cycles
[ 120.099344] 10000 times kmalloc(1024) =
[ 120.111033] number of loops: 10000
[ 120.121168] total time: 5733525
[ 120.130546] -> 573 cycles
[ 120.140827] 10000 times kfree =
[ 120.150444] number of loops: 10000
[ 120.160579] total time: 7450170
[ 120.169956] -> 745 cycles
[ 120.179854] 10000 times kmalloc(2048) =
[ 120.191544] number of loops: 10000
[ 120.201680] total time: 6298380
[ 120.211033] -> 629 cycles
[ 120.221555] 10000 times kfree =
[ 120.231170] number of loops: 10000
[ 120.241305] total time: 8169892
[ 120.250666] -> 816 cycles
[ 120.260044] 10000 times kmalloc(4096) =
[ 120.271733] number of loops: 10000
[ 120.281868] total time: 4739040
[ 120.291221] -> 473 cycles
[ 120.300847] 10000 times kfree =
[ 120.310483] number of loops: 10000
[ 120.320619] total time: 5484870
[ 120.329973] -> 548 cycles
[ 120.339970] 10000 times kmalloc(8192) =
[ 120.351659] number of loops: 10000
[ 120.361805] total time: 6594803
[ 120.371184] -> 659 cycles
[ 120.381465] 10000 times kfree =
[ 120.391104] number of loops: 10000
[ 120.401240] total time: 7454415
[ 120.410618] -> 745 cycles
[ 120.420834] 10000 times kmalloc(16384) =
[ 120.432797] number of loops: 10000
[ 120.442932] total time: 7245863
[ 120.452311] -> 724 cycles
[ 120.462923] 10000 times kfree =
[ 120.472545] number of loops: 10000
[ 120.482689] total time: 8431665
[ 120.492043] -> 843 cycles
[ 120.499843] 2. Kmalloc: alloc/free test
[ 120.511647] 10000 times kmalloc(8)/kfree =
[ 120.524116] number of loops: 10000
[ 120.534251] total time: 1129178
[ 120.543629] -> 112 cycles
[ 120.551773] 10000 times kmalloc(16)/kfree =
[ 120.564524] number of loops: 10000
[ 120.574658] total time: 1036778
[ 120.584036] -> 103 cycles
[ 120.592180] 10000 times kmalloc(32)/kfree =
[ 120.604905] number of loops: 10000
[ 120.615040] total time: 1031220
[ 120.624419] -> 103 cycles
[ 120.632561] 10000 times kmalloc(64)/kfree =
[ 120.645289] number of loops: 10000
[ 120.655425] total time: 1031025
[ 120.664777] -> 103 cycles
[ 120.672954] 10000 times kmalloc(128)/kfree =
[ 120.685941] number of loops: 10000
[ 120.696075] total time: 1127857
[ 120.705429] -> 112 cycles
[ 120.713599] 10000 times kmalloc(256)/kfree =
[ 120.726591] number of loops: 10000
[ 120.736724] total time: 1110885
[ 120.746101] -> 111 cycles
[ 120.754271] 10000 times kmalloc(512)/kfree =
[ 120.767256] number of loops: 10000
[ 120.777392] total time: 1110855
[ 120.786770] -> 111 cycles
[ 120.794940] 10000 times kmalloc(1024)/kfree =
[ 120.808239] number of loops: 10000
[ 120.818373] total time: 1111522
[ 120.827729] -> 111 cycles
[ 120.835932] 10000 times kmalloc(2048)/kfree =
[ 120.849175] number of loops: 10000
[ 120.859311] total time: 1217235
[ 120.868664] -> 121 cycles
[ 120.878627] 10000 times kmalloc(4096)/kfree =
[ 120.891872] number of loops: 10000
[ 120.902006] total time: 6501330
[ 120.911383] -> 650 cycles
[ 120.922653] 10000 times kmalloc(8192)/kfree =
[ 120.935922] number of loops: 10000
[ 120.946065] total time: 10424333
[ 120.955677] -> 1042 cycles
[ 120.967571] 10000 times kmalloc(16384)/kfree =
[ 120.981099] number of loops: 10000
[ 120.991233] total time: 11495947
[ 121.000871] -> 1149 cycles
* test module
Note that the kmalloc_caches is defined out because we are not a
boot-time, but at module load time and it does not work.
/* test-slub.c
*
* Compare local cmpxchg with irq disable / enable with cmpxchg_local for slub.
*/
#include <linux/jiffies.h>
#include <linux/compiler.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/calc64.h>
#include <asm/timex.h>
#include <asm/system.h>
#define TEST_COUNT 10000
static int slub_test_init(void)
{
void **v = kmalloc(TEST_COUNT * sizeof(void *), GFP_KERNEL);
unsigned int i;
cycles_t time1, time2, time;
long rem;
int size;
printk(KERN_ALERT "test init\n");
printk(KERN_ALERT "SLUB Performance testing\n");
printk(KERN_ALERT "========================\n");
printk(KERN_ALERT "1. Kmalloc: Repeatedly allocate then free test\n");
for (size = 8; size <= PAGE_SIZE << 2; size <<= 1) {
time1 = get_cycles();
for (i = 0; i < TEST_COUNT; i++) {
v[i] = kmalloc(size, GFP_KERNEL);
}
time2 = get_cycles();
time = time2 - time1;
printk(KERN_ALERT "%i times kmalloc(%d) = \n", i, size);
printk(KERN_ALERT "number of loops: %d\n", TEST_COUNT);
printk(KERN_ALERT "total time: %llu\n", time);
time = div_long_long_rem(time, TEST_COUNT, &rem);
printk(KERN_ALERT "-> %llu cycles\n", time);
time1 = get_cycles();
for (i = 0; i < TEST_COUNT; i++) {
kfree(v[i]);
}
time2 = get_cycles();
time = time2 - time1;
printk(KERN_ALERT "%i times kfree = \n", i);
printk(KERN_ALERT "number of loops: %d\n", TEST_COUNT);
printk(KERN_ALERT "total time: %llu\n", time);
time = div_long_long_rem(time, TEST_COUNT, &rem);
printk(KERN_ALERT "-> %llu cycles\n", time);
}
printk(KERN_ALERT "2. Kmalloc: alloc/free test\n");
for (size = 8; size <= PAGE_SIZE << 2; size <<= 1) {
time1 = get_cycles();
for (i = 0; i < TEST_COUNT; i++) {
kfree(kmalloc(size, GFP_KERNEL));
}
time2 = get_cycles();
time = time2 - time1;
printk(KERN_ALERT "%i times kmalloc(%d)/kfree = \n", i, size);
printk(KERN_ALERT "number of loops: %d\n", TEST_COUNT);
printk(KERN_ALERT "total time: %llu\n", time);
time = div_long_long_rem(time, TEST_COUNT, &rem);
printk(KERN_ALERT "-> %llu cycles\n", time);
}
#if 0
printk(KERN_ALERT "3. kmem_cache_alloc: Repeatedly allocate then free test\n");
for (size = 3; size <= PAGE_SHIFT; size ++) {
time1 = get_cycles();
for (i = 0; i < TEST_COUNT; i++) {
v[i] = kmem_cache_alloc(kmalloc_caches + size, GFP_KERNEL);
}
time2 = get_cycles();
time = time2 - time1;
printk(KERN_ALERT "%d times kmem_cache_alloc(%d) = \n", i, 1 << size);
printk(KERN_ALERT "number of loops: %d\n", TEST_COUNT);
printk(KERN_ALERT "total time: %llu\n", time);
time = div_long_long_rem(time, TEST_COUNT, &rem);
printk(KERN_ALERT "-> %llu cycles\n", time);
time1 = get_cycles();
for (i = 0; i < TEST_COUNT; i++) {
kmem_cache_free(kmalloc_caches + size, v[i]);
}
time2 = get_cycles();
time = time2 - time1;
printk(KERN_ALERT "%i times kmem_cache_free = \n", i);
printk(KERN_ALERT "number of loops: %d\n", TEST_COUNT);
printk(KERN_ALERT "total time: %llu\n", time);
time = div_long_long_rem(time, TEST_COUNT, &rem);
printk(KERN_ALERT "-> %llu cycles\n", time);
}
printk(KERN_ALERT "4. kmem_cache_alloc: alloc/free test\n");
for (size = 3; size <= PAGE_SHIFT; size++) {
time1 = get_cycles();
for (i = 0; i < TEST_COUNT; i++) {
kmem_cache_free(kmalloc_caches + size,
kmem_cache_alloc(kmalloc_caches + size,
GFP_KERNEL));
}
time2 = get_cycles();
time = time2 - time1;
printk(KERN_ALERT "%d times kmem_cache_alloc(%d)/kmem_cache_free = \n", i, 1 << size);
printk(KERN_ALERT "number of loops: %d\n", TEST_COUNT);
printk(KERN_ALERT "total time: %llu\n", time);
time = div_long_long_rem(time, TEST_COUNT, &rem);
printk(KERN_ALERT "-> %llu cycles\n", time);
}
printk(KERN_ALERT "5. kmem_cache_zalloc: Repeatedly allocate then free test\n");
for (size = 3; size <= PAGE_SHIFT; size ++) {
time1 = get_cycles();
for (i = 0; i < TEST_COUNT; i++) {
v[i] = kmem_cache_zalloc(kmalloc_caches + size, GFP_KERNEL);
}
time2 = get_cycles();
time = time2 - time1;
printk(KERN_ALERT "%d times kmem_cache_zalloc(%d) = \n", i, 1 << size);
printk(KERN_ALERT "number of loops: %d\n", TEST_COUNT);
printk(KERN_ALERT "total time: %llu\n", time);
time = div_long_long_rem(time, TEST_COUNT, &rem);
printk(KERN_ALERT "-> %llu cycles\n", time);
time1 = get_cycles();
for (i = 0; i < TEST_COUNT; i++) {
kmem_cache_free(kmalloc_caches + size, v[i]);
}
time2 = get_cycles();
time = time2 - time1;
printk(KERN_ALERT "%i times kmem_cache_free = \n", i);
printk(KERN_ALERT "number of loops: %d\n", TEST_COUNT);
printk(KERN_ALERT "total time: %llu\n", time);
time = div_long_long_rem(time, TEST_COUNT, &rem);
printk(KERN_ALERT "-> %llu cycles\n", time);
}
printk(KERN_ALERT "6. kmem_cache_zalloc: alloc/free test\n");
for (size = 3; size <= PAGE_SHIFT; size++) {
time1 = get_cycles();
for (i = 0; i < TEST_COUNT; i++) {
kmem_cache_free(kmalloc_caches + size,
kmem_cache_zalloc(kmalloc_caches + size,
GFP_KERNEL));
}
time2 = get_cycles();
time = time2 - time1;
printk(KERN_ALERT "%d times kmem_cache_zalloc(%d)/kmem_cache_free = \n", i, 1 << size);
printk(KERN_ALERT "number of loops: %d\n", TEST_COUNT);
printk(KERN_ALERT "total time: %llu\n", time);
time = div_long_long_rem(time, TEST_COUNT, &rem);
printk(KERN_ALERT "-> %llu cycles\n", time);
}
#endif //0
kfree(v);
return -EAGAIN; /* Fail will directly unload the module */
}
static void slub_test_exit(void)
{
printk(KERN_ALERT "test exit\n");
}
module_init(slub_test_init)
module_exit(slub_test_exit)
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Mathieu Desnoyers");
MODULE_DESCRIPTION("SLUB test");
--
Mathieu Desnoyers
Computer Engineering Ph.D. Student, Ecole Polytechnique de Montreal
OpenPGP key fingerprint: 8CD5 52C3 8E3C 4140 715F BA06 3F25 A8FE 3BAE 9A68
next prev parent reply other threads:[~2007-08-21 17:44 UTC|newest]
Thread overview: 135+ messages / expand[flat|nested] mbox.gz Atom feed top
2007-08-20 20:15 [patch 00/23] cmpxchg_local and cmpxchg64_local implementation Mathieu Desnoyers
2007-08-20 20:15 ` [patch 01/23] Fall back on interrupt disable in cmpxchg8b on 80386 and 80486 Mathieu Desnoyers
2007-08-20 20:32 ` Christoph Lameter
2007-08-20 20:41 ` Mathieu Desnoyers
2007-08-20 20:46 ` Christoph Lameter
2007-08-20 21:29 ` Mathieu Desnoyers
2007-08-20 21:49 ` Christoph Lameter
2007-08-20 21:54 ` Mathieu Desnoyers
2007-08-20 22:07 ` Christoph Lameter
2007-08-20 22:29 ` Mathieu Desnoyers
2007-08-21 17:38 ` [PATCH] SLUB Use cmpxchg() everywhere Mathieu Desnoyers
2007-08-21 17:38 ` [PATCH] SLUB use cmpxchg_local Mathieu Desnoyers
2007-08-21 17:44 ` Mathieu Desnoyers [this message]
2007-08-21 21:10 ` Christoph Lameter
2007-08-21 23:21 ` Mathieu Desnoyers
2007-08-21 23:35 ` Christoph Lameter
2007-08-21 23:38 ` Christoph Lameter
2007-08-21 20:41 ` Mathieu Desnoyers
2007-08-21 21:36 ` Christoph Lameter
2007-08-21 21:08 ` Christoph Lameter
2007-08-21 23:12 ` Mathieu Desnoyers
2007-08-21 23:17 ` Christoph Lameter
2007-08-21 23:39 ` Mathieu Desnoyers
2007-08-21 23:41 ` Christoph Lameter
2007-08-21 23:47 ` Mathieu Desnoyers
2007-08-21 23:51 ` Christoph Lameter
2007-08-22 0:03 ` Mathieu Desnoyers
2007-08-22 0:11 ` Christoph Lameter
2007-08-22 0:26 ` Mathieu Desnoyers
2007-08-22 0:34 ` Christoph Lameter
2007-08-22 1:18 ` Mathieu Desnoyers
2007-08-22 15:00 ` [PATCH] define have_arch_cmpxchg() Mathieu Desnoyers
2007-08-22 18:50 ` Christoph Lameter
2007-08-22 15:02 ` [PATCH] SLUB: use have_arch_cmpxchg() Mathieu Desnoyers
2007-08-22 16:24 ` Pekka Enberg
2007-08-27 14:56 ` Mathieu Desnoyers
2007-08-27 19:43 ` Christoph Lameter
2007-08-27 20:25 ` Mathieu Desnoyers
2007-08-22 1:28 ` [PATCH] SLUB use cmpxchg_local Andi Kleen
2007-08-22 0:38 ` Mathieu Desnoyers
2007-08-22 1:06 ` Christoph Lameter
2007-08-22 1:12 ` Mathieu Desnoyers
2007-08-22 9:39 ` Andi Kleen
2007-08-22 13:45 ` Mathieu Desnoyers
2007-08-22 13:46 ` Andi Kleen
2007-08-22 18:54 ` Christoph Lameter
2007-08-22 19:25 ` Christoph Lameter
2007-08-22 20:09 ` Mathieu Desnoyers
2007-08-22 20:19 ` Christoph Lameter
2007-08-22 20:29 ` Mathieu Desnoyers
2007-08-22 20:33 ` Christoph Lameter
2007-08-22 20:38 ` Christoph Lameter
2007-08-21 23:14 ` Christoph Lameter
2007-08-21 23:23 ` Mathieu Desnoyers
2007-08-21 23:50 ` Mathieu Desnoyers
2007-08-27 6:52 ` Peter Zijlstra
2007-08-27 19:39 ` Christoph Lameter
2007-08-27 20:22 ` Mathieu Desnoyers
2007-08-27 20:26 ` Christoph Lameter
2007-08-27 20:39 ` Mathieu Desnoyers
2007-08-27 21:04 ` Christoph Lameter
2007-08-27 21:10 ` Mathieu Desnoyers
2007-08-27 21:23 ` Christoph Lameter
2007-08-27 21:38 ` Mathieu Desnoyers
2007-08-27 22:12 ` Christoph Lameter
2007-08-27 22:27 ` Mathieu Desnoyers
2007-08-27 22:29 ` Christoph Lameter
2007-08-28 1:26 ` Christoph Lameter
2007-08-28 1:26 ` Christoph Lameter
2007-08-28 12:07 ` Mathieu Desnoyers
2007-08-28 12:07 ` Mathieu Desnoyers
2007-08-28 19:42 ` Christoph Lameter
2007-08-28 19:42 ` Christoph Lameter
2007-09-04 20:02 ` Mathieu Desnoyers
2007-09-04 20:02 ` Mathieu Desnoyers
2007-09-04 20:03 ` [PATCH] local_t protection (critical section) Mathieu Desnoyers
2007-09-04 20:03 ` Mathieu Desnoyers
2007-09-04 20:04 ` [PATCH] slub - Use local_t protection Mathieu Desnoyers
2007-09-04 20:04 ` Mathieu Desnoyers
2007-09-04 20:45 ` Christoph Lameter
2007-09-04 20:45 ` Christoph Lameter
2007-09-05 13:03 ` Mathieu Desnoyers
2007-09-05 13:03 ` Mathieu Desnoyers
2007-09-05 13:04 ` [PATCH] local_t protection (critical section) Mathieu Desnoyers
2007-09-05 13:04 ` Mathieu Desnoyers
2007-09-12 22:33 ` Christoph Lameter
2007-09-12 22:33 ` Christoph Lameter
2007-09-12 23:00 ` Mathieu Desnoyers
2007-09-12 23:00 ` Mathieu Desnoyers
2007-09-05 13:06 ` [PATCH] slub - Use local_t protection Mathieu Desnoyers
2007-09-05 13:06 ` Mathieu Desnoyers
2007-09-12 22:28 ` Christoph Lameter
2007-09-12 22:28 ` Christoph Lameter
2007-08-27 22:15 ` [PATCH] SLUB use cmpxchg_local Christoph Lameter
2007-08-28 7:12 ` Peter Zijlstra
2007-08-28 19:36 ` Christoph Lameter
2007-08-28 19:46 ` Peter Zijlstra
2007-08-20 20:15 ` [patch 02/23] Add cmpxchg_local to asm-generic for per cpu atomic operations Mathieu Desnoyers
2007-08-20 20:15 ` [patch 03/23] Add cmpxchg_local to arm Mathieu Desnoyers
2007-08-20 20:15 ` [patch 04/23] Add cmpxchg_local to avr32 Mathieu Desnoyers
2007-08-20 20:15 ` [patch 05/23] Add cmpxchg_local to blackfin, replace __cmpxchg by generic cmpxchg Mathieu Desnoyers
2007-08-20 20:15 ` [patch 06/23] Add cmpxchg_local to cris Mathieu Desnoyers
2007-08-20 20:15 ` [patch 07/23] Add cmpxchg_local to frv Mathieu Desnoyers
2007-08-20 20:15 ` [patch 08/23] Add cmpxchg_local to h8300 Mathieu Desnoyers
2007-08-20 20:15 ` [patch 09/23] Add cmpxchg_local, cmpxchg64 and cmpxchg64_local to ia64 Mathieu Desnoyers
2007-08-20 20:15 ` [patch 10/23] New cmpxchg_local (optimized for UP case) for m32r Mathieu Desnoyers
2007-08-21 9:36 ` Hirokazu Takata
2007-08-20 20:15 ` [patch 11/23] Fix m32r __xchg Mathieu Desnoyers
2007-08-21 9:39 ` Hirokazu Takata
2007-08-20 20:15 ` [patch 12/23] local_t m32r use architecture specific cmpxchg_local Mathieu Desnoyers
2007-08-21 9:34 ` Hirokazu Takata
2007-08-21 14:01 ` Mathieu Desnoyers
2007-08-20 20:15 ` [patch 13/23] Add cmpxchg_local to m86k Mathieu Desnoyers
2007-08-20 20:15 ` [patch 14/23] Add cmpxchg_local to m68knommu Mathieu Desnoyers
2007-08-20 20:15 ` [parisc-linux] [patch 15/23] Add cmpxchg_local to parisc Mathieu Desnoyers
2007-08-20 20:15 ` Mathieu Desnoyers
2007-08-20 20:15 ` [patch 16/23] Add cmpxchg_local to ppc Mathieu Desnoyers
2007-08-20 20:15 ` [patch 17/23] Add cmpxchg_local to s390 Mathieu Desnoyers
2007-08-20 20:15 ` [patch 18/23] Add cmpxchg_local to sh, use generic cmpxchg() instead of cmpxchg_u32 Mathieu Desnoyers
2007-08-20 20:15 ` [patch 19/23] Add cmpxchg_local to sh64 Mathieu Desnoyers
2007-08-20 20:15 ` [patch 20/23] Add cmpxchg_local to sparc, move __cmpxchg to system.h Mathieu Desnoyers
2007-08-20 20:15 ` Mathieu Desnoyers
2007-08-20 20:15 ` [patch 21/23] Add cmpxchg_local to sparc64 Mathieu Desnoyers
2007-08-20 20:15 ` Mathieu Desnoyers
2007-08-20 23:34 ` Julian Calaby
2007-08-20 23:34 ` Julian Calaby
2007-08-20 23:36 ` Christoph Lameter
2007-08-20 23:36 ` Christoph Lameter
2007-08-20 23:42 ` Julian Calaby
2007-08-20 23:42 ` Julian Calaby
2007-08-20 23:43 ` [patch 21/23] Add cmpxchg_local to sparc64 (update) Mathieu Desnoyers
2007-08-20 23:43 ` Mathieu Desnoyers
2007-08-20 20:15 ` [patch 22/23] Add cmpxchg_local to v850 Mathieu Desnoyers
2007-08-20 20:15 ` [patch 23/23] Add cmpxchg_local to xtensa Mathieu Desnoyers
2007-08-20 20:29 ` [patch 00/23] cmpxchg_local and cmpxchg64_local implementation Mathieu Desnoyers
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20070821174424.GB8360@Krystal \
--to=compudj@krystal.dyndns.org \
--cc=akpm@linux-foundation.org \
--cc=clameter@sgi.com \
--cc=linux-kernel@vger.kernel.org \
--cc=mingo@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.