radix tree test harness

main

radix-tree.c

CFLAGS += -I. -g -Wall -D_LGPL_SOURCE

LDFLAGS += -lpthread -lurcu

TARGETS = main

OFILES = main.o radix-tree.o linux.o test.o tag_check.o find_next_bit.o \

	 regression1.o regression2.o

targets: $(TARGETS)

main:	$(OFILES)

	$(CC) $(CFLAGS) $(LDFLAGS) $(OFILES) -o main

clean:

	$(RM) -f $(TARGETS) *.o radix-tree.c

$(OFILES): *.h */*.h

radix-tree.c: ../../../lib/radix-tree.c

	sed -e 's/^static //' -e 's/__always_inline //' -e 's/inline //' < $< > $@

/* find_next_bit.c: fallback find next bit implementation

 *

 * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.

 * Written by David Howells (dhowells@redhat.com)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version

 * 2 of the License, or (at your option) any later version.

 */

#include <linux/types.h>

#include <linux/bitops.h>

#define BITOP_WORD(nr)		((nr) / BITS_PER_LONG)

/*

 * Find the next set bit in a memory region.

 */

unsigned long find_next_bit(const unsigned long *addr, unsigned long size,

			    unsigned long offset)

{

	const unsigned long *p = addr + BITOP_WORD(offset);

	unsigned long result = offset & ~(BITS_PER_LONG-1);

	unsigned long tmp;

	if (offset >= size)

		return size;

	size -= result;

	offset %= BITS_PER_LONG;

	if (offset) {

		tmp = *(p++);

		tmp &= (~0UL << offset);

		if (size < BITS_PER_LONG)

			goto found_first;

		if (tmp)

			goto found_middle;

		size -= BITS_PER_LONG;

		result += BITS_PER_LONG;

	}

	while (size & ~(BITS_PER_LONG-1)) {

		if ((tmp = *(p++)))

			goto found_middle;

		result += BITS_PER_LONG;

		size -= BITS_PER_LONG;

	}

	if (!size)

		return result;

	tmp = *p;

found_first:

	tmp &= (~0UL >> (BITS_PER_LONG - size));

	if (tmp == 0UL)		/* Are any bits set? */

		return result + size;	/* Nope. */

found_middle:

	return result + __ffs(tmp);

}

#include <stdlib.h>

#include <string.h>

#include <malloc.h>

#include <unistd.h>

#include <assert.h>

#include <linux/mempool.h>

#include <linux/slab.h>

#include <urcu/uatomic.h>

int nr_allocated;

void *mempool_alloc(mempool_t *pool, int gfp_mask)

{

	return pool->alloc(gfp_mask, pool->data);

}

void mempool_free(void *element, mempool_t *pool)

{

	pool->free(element, pool->data);

}

mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn,

			mempool_free_t *free_fn, void *pool_data)

{

	mempool_t *ret = malloc(sizeof(*ret));

	ret->alloc = alloc_fn;

	ret->free = free_fn;

	ret->data = pool_data;

	return ret;

}

void *kmem_cache_alloc(struct kmem_cache *cachep, int flags)

{

	void *ret = malloc(cachep->size);

	if (cachep->ctor)

		cachep->ctor(ret);

	uatomic_inc(&nr_allocated);

	return ret;

}

void kmem_cache_free(struct kmem_cache *cachep, void *objp)

{

	assert(objp);

	uatomic_dec(&nr_allocated);

	memset(objp, 0, cachep->size);

	free(objp);

}

struct kmem_cache *

kmem_cache_create(const char *name, size_t size, size_t offset,

	unsigned long flags, void (*ctor)(void *))

{

	struct kmem_cache *ret = malloc(sizeof(*ret));

	ret->size = size;

	ret->ctor = ctor;

	return ret;

}

#ifndef _ASM_GENERIC_BITOPS_NON_ATOMIC_H_

#define _ASM_GENERIC_BITOPS_NON_ATOMIC_H_

#include <linux/types.h>

#define BITOP_MASK(nr)		(1UL << ((nr) % BITS_PER_LONG))

#define BITOP_WORD(nr)		((nr) / BITS_PER_LONG)

/**

 * __set_bit - Set a bit in memory

 * @nr: the bit to set

 * @addr: the address to start counting from

 *

 * Unlike set_bit(), this function is non-atomic and may be reordered.

 * If it's called on the same region of memory simultaneously, the effect

 * may be that only one operation succeeds.

 */

static inline void __set_bit(int nr, volatile unsigned long *addr)

{

	unsigned long mask = BITOP_MASK(nr);

	unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);

	*p  |= mask;

}

static inline void __clear_bit(int nr, volatile unsigned long *addr)

{

	unsigned long mask = BITOP_MASK(nr);

	unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);

	*p &= ~mask;

}

/**

 * __change_bit - Toggle a bit in memory

 * @nr: the bit to change

 * @addr: the address to start counting from

 *

 * Unlike change_bit(), this function is non-atomic and may be reordered.

 * If it's called on the same region of memory simultaneously, the effect

 * may be that only one operation succeeds.

 */

static inline void __change_bit(int nr, volatile unsigned long *addr)

{

	unsigned long mask = BITOP_MASK(nr);

	unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);

	*p ^= mask;

}

/**

 * __test_and_set_bit - Set a bit and return its old value

 * @nr: Bit to set

 * @addr: Address to count from

 *

 * This operation is non-atomic and can be reordered.

 * If two examples of this operation race, one can appear to succeed

 * but actually fail.  You must protect multiple accesses with a lock.

 */

static inline int __test_and_set_bit(int nr, volatile unsigned long *addr)

{

	unsigned long mask = BITOP_MASK(nr);

	unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);

	unsigned long old = *p;

	*p = old | mask;

	return (old & mask) != 0;

}

/**

 * __test_and_clear_bit - Clear a bit and return its old value

 * @nr: Bit to clear

 * @addr: Address to count from

 *

 * This operation is non-atomic and can be reordered.

 * If two examples of this operation race, one can appear to succeed

 * but actually fail.  You must protect multiple accesses with a lock.

 */

static inline int __test_and_clear_bit(int nr, volatile unsigned long *addr)

{

	unsigned long mask = BITOP_MASK(nr);

	unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);

	unsigned long old = *p;

	*p = old & ~mask;

	return (old & mask) != 0;

}

/* WARNING: non atomic and it can be reordered! */

static inline int __test_and_change_bit(int nr,

					    volatile unsigned long *addr)

{

	unsigned long mask = BITOP_MASK(nr);

	unsigned long *p = ((unsigned long *)addr) + BITOP_WORD(nr);

	unsigned long old = *p;

	*p = old ^ mask;

	return (old & mask) != 0;

}

/**

 * test_bit - Determine whether a bit is set

 * @nr: bit number to test

 * @addr: Address to start counting from

 */

static inline int test_bit(int nr, const volatile unsigned long *addr)

{

	return 1UL & (addr[BITOP_WORD(nr)] >> (nr & (BITS_PER_LONG-1)));

}

/**

 * __ffs - find first bit in word.

 * @word: The word to search

 *

 * Undefined if no bit exists, so code should check against 0 first.

 */

static inline unsigned long __ffs(unsigned long word)

{

	int num = 0;

	if ((word & 0xffffffff) == 0) {

		num += 32;

		word >>= 32;

	}

	if ((word & 0xffff) == 0) {

		num += 16;

		word >>= 16;

	}

	if ((word & 0xff) == 0) {

		num += 8;

		word >>= 8;

	}

	if ((word & 0xf) == 0) {

		num += 4;

		word >>= 4;

	}

	if ((word & 0x3) == 0) {

		num += 2;

		word >>= 2;

	}

	if ((word & 0x1) == 0)

		num += 1;

	return num;

}

unsigned long find_next_bit(const unsigned long *addr,

			    unsigned long size,

			    unsigned long offset);

#endif /* _ASM_GENERIC_BITOPS_NON_ATOMIC_H_ */