Commit 529a3404 authored by Eric Dumazet's avatar Eric Dumazet Committed by Linus Torvalds

[PATCH] x86_64: Optimize NUMA node hash function

Compute the highest possible value for memnode_shift, in order to reduce
footprint of memnodemap[] to the minimum, thus making all users
(phys_to_nid(), kfree()), more cache friendly.

Before the patch :

 Node 0 MemBase 0000000000000000 Limit 00000001ffffffff
 Node 1 MemBase 0000000200000000 Limit 00000003ffffffff
 Using 23 for the hash shift. Max adder is 3ffffffff

After the patch :

 Node 0 MemBase 0000000000000000 Limit 00000001ffffffff
 Node 1 MemBase 0000000200000000 Limit 00000003ffffffff
 Using 33 for the hash shift.

In this case, only 2 bytes of memnodemap[] are used, instead of 2048
Signed-off-by: default avatarEric Dumazet <dada1@cosmosbay.com>
Signed-off-by: default avatarAndi Kleen <ak@suse.de>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent e4e5d324
...@@ -38,38 +38,57 @@ cpumask_t node_to_cpumask[MAX_NUMNODES] __read_mostly; ...@@ -38,38 +38,57 @@ cpumask_t node_to_cpumask[MAX_NUMNODES] __read_mostly;
int numa_off __initdata; int numa_off __initdata;
int __init compute_hash_shift(struct node *nodes, int numnodes)
/*
* Given a shift value, try to populate memnodemap[]
* Returns :
* 1 if OK
* 0 if memnodmap[] too small (of shift too small)
* -1 if node overlap or lost ram (shift too big)
*/
static int __init populate_memnodemap(
const struct node *nodes, int numnodes, int shift)
{ {
int i; int i;
int shift = 20; int res = -1;
unsigned long addr,maxend=0; unsigned long addr, end;
for (i = 0; i < numnodes; i++)
if ((nodes[i].start != nodes[i].end) && (nodes[i].end > maxend))
maxend = nodes[i].end;
while ((1UL << shift) < (maxend / NODEMAPSIZE)) memset(memnodemap, 0xff, sizeof(memnodemap));
shift++;
printk (KERN_DEBUG"Using %d for the hash shift. Max adder is %lx \n",
shift,maxend);
memset(memnodemap,0xff,sizeof(*memnodemap) * NODEMAPSIZE);
for (i = 0; i < numnodes; i++) { for (i = 0; i < numnodes; i++) {
if (nodes[i].start == nodes[i].end) addr = nodes[i].start;
end = nodes[i].end;
if (addr >= end)
continue; continue;
for (addr = nodes[i].start; if ((end >> shift) >= NODEMAPSIZE)
addr < nodes[i].end; return 0;
addr += (1UL << shift)) { do {
if (memnodemap[addr >> shift] != 0xff) { if (memnodemap[addr >> shift] != 0xff)
printk(KERN_INFO
"Your memory is not aligned you need to rebuild your kernel "
"with a bigger NODEMAPSIZE shift=%d adder=%lu\n",
shift,addr);
return -1; return -1;
}
memnodemap[addr >> shift] = i; memnodemap[addr >> shift] = i;
} addr += (1 << shift);
} while (addr < end);
res = 1;
} }
return res;
}
int __init compute_hash_shift(struct node *nodes, int numnodes)
{
int shift = 20;
while (populate_memnodemap(nodes, numnodes, shift + 1) >= 0)
shift++;
printk(KERN_DEBUG "Using %d for the hash shift.\n",
shift);
if (populate_memnodemap(nodes, numnodes, shift) != 1) {
printk(KERN_INFO
"Your memory is not aligned you need to rebuild your kernel "
"with a bigger NODEMAPSIZE shift=%d\n",
shift);
return -1;
}
return shift; return shift;
} }
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment