From: Eric Dumazet new_inode() dirties a contended cache line to get increasing inode numbers. Solve this problem by providing to each cpu a per_cpu variable, feeded by the shared last_ino, but once every 1024 allocations. This reduces contention on the shared last_ino, and give same spreading ino numbers than before (i.e. same wraparound after 2^32 allocations). Signed-off-by: Eric Dumazet Signed-off-by: Nick Piggin --- fs/inode.c | 47 ++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 40 insertions(+), 7 deletions(-) Index: linux-2.6/fs/inode.c =================================================================== --- linux-2.6.orig/fs/inode.c 2010-10-19 14:18:59.000000000 +1100 +++ linux-2.6/fs/inode.c 2010-10-19 14:19:24.000000000 +1100 @@ -754,6 +754,45 @@ } EXPORT_SYMBOL_GPL(inode_add_to_lists); +#define LAST_INO_BATCH 1024 + +/* + * Each cpu owns a range of LAST_INO_BATCH numbers. + * 'shared_last_ino' is dirtied only once out of LAST_INO_BATCH allocations, + * to renew the exhausted range. + * + * This does not significantly increase overflow rate because every CPU can + * consume at most LAST_INO_BATCH-1 unused inode numbers. So there is + * NR_CPUS*(LAST_INO_BATCH-1) wastage. At 4096 and 1024, this is ~0.1% of the + * 2^32 range, and is a worst-case. Even a 50% wastage would only increase + * overflow rate by 2x, which does not seem too significant. + * + * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW + * error if st_ino won't fit in target struct field. Use 32bit counter + * here to attempt to avoid that. + */ +static DEFINE_PER_CPU(unsigned int, last_ino); + +static unsigned int get_next_ino(void) +{ + unsigned int res; + + get_cpu(); + res = __this_cpu_read(last_ino); +#ifdef CONFIG_SMP + if (unlikely((res & (LAST_INO_BATCH - 1)) == 0)) { + static atomic_t shared_last_ino; + int next = atomic_add_return(LAST_INO_BATCH, &shared_last_ino); + + res = next - LAST_INO_BATCH; + } +#endif + res++; + __this_cpu_write(last_ino, res); + put_cpu(); + return res; +} + /** * new_inode - obtain an inode * @sb: superblock @@ -768,18 +807,12 @@ */ struct inode *new_inode(struct super_block *sb) { - /* - * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW - * error if st_ino won't fit in target struct field. Use 32bit counter - * here to attempt to avoid that. - */ - static atomic_t last_ino = ATOMIC_INIT(0); struct inode *inode; inode = alloc_inode(sb); if (inode) { spin_lock(&inode->i_lock); - inode->i_ino = (unsigned int)atomic_inc_return(&last_ino); + inode->i_ino = get_next_ino(); inode->i_state = 0; __inode_add_to_lists(sb, NULL, inode); spin_unlock(&inode->i_lock); -- To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html Please read the FAQ at http://www.tux.org/lkml/