Finishes add-path. (e7d2ac44) · Commits · 戴 / Bird

lib/bitops.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -6,6 +6,9 @@
		* Can be freely distributed and used under the terms of the GNU GPL.
		*/

		#ifndef _BIRD_BITOPTS_H_
		#define _BIRD_BITOPTS_H_

		/*
		* Bit mask operations:
		*
		@@ -19,3 +22,8 @@ u32 u32_mkmask(unsigned n);
		int u32_masklen(u32 x);

		u32 u32_log2(u32 v);

		static inline u32 u32_hash(u32 v) { return v * 2902958171u; }

		#endif

lib/hash.h

+86 −29

Original line number	Diff line number	Diff line
		@@ -3,7 +3,9 @@
		#define HASH(type) struct { type **data; uint count, order; }
		#define HASH_TYPE(v) typeof(** (v).data)
		#define HASH_SIZE(v) (1 << (v).order)
		#define HASH_MASK(v) ((1 << (v).order)-1)

		#define HASH_EQ(v,id,k1,k2...) (id##_EQ(k1, k2))
		#define HASH_FN(v,id,key...) ((u32) (id##_FN(key)) >> (32 - (v).order))


		#define HASH_INIT(v,pool,init_order) \
		@@ -15,16 +17,16 @@

		#define HASH_FIND(v,id,key...) \
		({ \
		uint _h = id##_FN((key)) & HASH_MASK(v); \
		u32 _h = HASH_FN(v, id, key); \
		HASH_TYPE(v) *_n = (v).data[_h]; \
		while (_n && !id##_EQ(id##_KEY(_n), (key))) \
		while (_n && !HASH_EQ(v, id, id##_KEY(_n), key)) \
		_n = id##_NEXT(_n); \
		_n; \
		})

		#define HASH_INSERT(v,id,node) \
		({ \
		uint _h = id##_FN(id##_KEY((node))) & HASH_MASK(v); \
		u32 _h = HASH_FN(v, id, id##_KEY((node))); \
		HASH_TYPE(v) **_nn = (v).data + _h; \
		id##_NEXT(node) = *_nn; \
		*_nn = node; \
		@@ -33,72 +35,117 @@

		#define HASH_DO_REMOVE(v,id,_nn) \
		({ \
		HASH_TYPE(v) _n = _nn; \
		if (_n) \
		{ \
		*_nn = id##_NEXT(_n); \
		_nn = id##_NEXT((_nn)); \
		(v).count--; \
		} \
		_n; \
		})

		#define HASH_DELETE(v,id,key...) \
		({ \
		uint _h = id##_FN((key)) & HASH_MASK(v); \
		HASH_TYPE(v) **_nn = (v).data + _h; \
		u32 _h = HASH_FN(v, id, key); \
		HASH_TYPE(v) _n, *_nn = (v).data + _h; \
		\
		while ((_nn) && !id##_EQ(id##_KEY((_nn)), (key))) \
		while ((_nn) && !HASH_EQ(v, id, id##_KEY((_nn)), key)) \
		_nn = &(id##_NEXT((*_nn))); \
		\
		if (_n = *_nn) \
		HASH_DO_REMOVE(v,id,_nn); \
		_n; \
		})

		#define HASH_REMOVE(v,id,node) \
		({ \
		uint _h = id##_FN(id##_KEY((node))) & HASH_MASK(v); \
		HASH_TYPE(v) **_nn = (v).data + _h; \
		u32 _h = HASH_FN(v, id, id##_KEY((node))); \
		HASH_TYPE(v) _n, *_nn = (v).data + _h; \
		\
		while ((_nn) && (_nn != (node))) \
		_nn = &(id##_NEXT((*_nn))); \
		\
		if (_n = *_nn) \
		HASH_DO_REMOVE(v,id,_nn); \
		_n; \
		})


		#define HASH_REHASH(v,id,pool,step) \
		({ \
		HASH_TYPE(v) _n, _n2, **_od; \
		uint _i, _s; \
		uint _i, _os; \
		\
		_s = HASH_SIZE(v); \
		_os = HASH_SIZE(v); \
		_od = (v).data; \
		(v).count = 0; \
		(v).order += (step); \
		(v).data = mb_allocz(pool, HASH_SIZE(v) * sizeof(* (v).data)); \
		\
		for (_i = 0; _i < _s; _i++) \
		for (_i = 0; _i < _os; _i++) \
		for (_n = _od[_i]; _n && (_n2 = id##_NEXT(_n), 1); _n = _n2) \
		HASH_INSERT(v, id, _n); \
		\
		mb_free(_od); \
		})

		#define REHASH_LO_MARK(a,b,c,d,e,f) a
		#define REHASH_HI_MARK(a,b,c,d,e,f) b
		#define REHASH_LO_STEP(a,b,c,d,e,f) c
		#define REHASH_HI_STEP(a,b,c,d,e,f) d
		#define REHASH_LO_BOUND(a,b,c,d,e,f) e
		#define REHASH_HI_BOUND(a,b,c,d,e,f) f

		#define HASH_DEFINE_REHASH_FN(id,type) \
		static void id##_REHASH_FN(void v, pool p, int step) \
		static void id##_REHASH(void v, pool p, int step) \
		{ HASH_REHASH(* (HASH(type) *) v, id, p, step); }

		#define HASH_TRY_REHASH_UP(v,id,pool) \

		#define HASH_MAY_STEP_UP(v,id,pool) HASH_MAY_STEP_UP_(v,pool, id##_REHASH, id##_PARAMS)
		#define HASH_MAY_STEP_DOWN(v,id,pool) HASH_MAY_STEP_DOWN_(v,pool, id##_REHASH, id##_PARAMS)
		#define HASH_MAY_RESIZE_DOWN(v,id,pool) HASH_MAY_RESIZE_DOWN_(v,pool, id##_REHASH, id##_PARAMS)

		#define HASH_MAY_STEP_UP_(v,pool,rehash_fn,args) \
		({ \
		if (((v).count > (HASH_SIZE(v) REHASH_HI_MARK(args))) && \
		((v).order < (REHASH_HI_BOUND(args)))) \
		rehash_fn(&(v), pool, REHASH_HI_STEP(args)); \
		})

		#define HASH_MAY_STEP_DOWN_(v,pool,rehash_fn,args) \
		({ \
		if (((v).count < (HASH_SIZE(v) REHASH_LO_MARK(args))) && \
		((v).order > (REHASH_LO_BOUND(args)))) \
		rehash_fn(&(v), pool, -(REHASH_LO_STEP(args))); \
		})

		#define HASH_MAY_RESIZE_DOWN_(v,pool,rehash_fn,args) \
		({ \
		if (((v).order < id##_REHASH_MAX) && ((v).count > HASH_SIZE(v))) \
		id##_REHASH_FN(&v, pool, 1); \
		int _o = (v).order; \
		while (((v).count < ((1 << _o) REHASH_LO_MARK(args))) && \
		(_o > (REHASH_LO_BOUND(args)))) \
		_o -= (REHASH_LO_STEP(args)); \
		if (_o < (v).order) \
		rehash_fn(&(v), pool, _o - (int) (v).order); \
		})

		#define HASH_TRY_REHASH_DOWN(v,id,pool) \

		#define HASH_INSERT2(v,id,pool,node) \
		({ \
		HASH_INSERT(v, id, node); \
		HASH_MAY_STEP_UP(v, id, pool); \
		})

		#define HASH_DELETE2(v,id,pool,key...) \
		({ \
		HASH_TYPE(v) *_n = HASH_DELETE(v, id, key); \
		if (_n) HASH_MAY_STEP_DOWN(v, id, pool); \
		_n; \
		})

		#define HASH_REMOVE2(v,id,pool,node) \
		({ \
		if (((v).order > id##_REHASH_MIN) && ((v).count < HASH_SIZE(v)/2)) \
		id##_REHASH_FN(&v, pool, -1); \
		HASH_TYPE(v) *_n = HASH_REMOVE(v, id, node); \
		if (_n) HASH_MAY_STEP_DOWN(v, id, pool); \
		_n; \
		})


		#define HASH_WALK(v,next,n) \
		do { \
		HASH_TYPE(v) *n; \
		@@ -121,3 +168,13 @@
		#define HASH_WALK_DELSAFE_END } while (0)


		#define HASH_WALK_FILTER(v,next,n,nn) \
		do { \
		HASH_TYPE(v) n, *nn; \
		uint _i; \
		uint _s = HASH_SIZE(v); \
		for (_i = 0; _i < _s; _i++) \
		for (nn = (v).data + _i; n = nn; (nn == n) ? (nn = &n->next) : NULL)

		#define HASH_WALK_FILTER_END } while (0)

lib/ipv4.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -52,6 +52,7 @@ typedef u32 ip_addr;
		#define ipa_mkmask(x) _MI(u32_mkmask(x))
		#define ipa_mklen(x) u32_masklen(_I(x))
		#define ipa_hash(x) ipv4_hash(_I(x))
		#define ipa_hash32(x) ipv4_hash32(_I(x))
		#define ipa_hton(x) x = _MI(htonl(_I(x)))
		#define ipa_ntoh(x) x = _MI(ntohl(_I(x)))
		#define ipa_classify(x) ipv4_classify(_I(x))
		@@ -86,6 +87,14 @@ static inline unsigned ipv4_hash(u32 a)
		return a & 0xffff;
		}

		static inline u32 ipv4_hash32(u32 a)
		{
		/* Returns a 32-bit value, although low-order bits are not mixed */
		a ^= a << 16;
		a ^= a << 12;
		return a;
		}

		static inline int ipv4_compare(u32 x, u32 y)
		{
		return (x > y) - (x < y);

lib/ipv6.h

+8 −0

Original line number	Diff line number	Diff line
		@@ -58,6 +58,7 @@ typedef struct ipv6_addr {
		#define ipa_mkmask(x) ipv6_mkmask(x)
		#define ipa_mklen(x) ipv6_mklen(&(x))
		#define ipa_hash(x) ipv6_hash(&(x))
		#define ipa_hash32(x) ipv6_hash32(&(x))
		#define ipa_hton(x) ipv6_hton(&(x))
		#define ipa_ntoh(x) ipv6_ntoh(&(x))
		#define ipa_classify(x) ipv6_classify(&(x))
		@@ -104,6 +105,13 @@ static inline unsigned ipv6_hash(ip_addr *a)
		return (x ^ (x >> 16) ^ (x >> 8)) & 0xffff;
		}

		static inline u32 ipv6_hash32(ip_addr *a)
		{
		/* Returns a 32-bit hash key, although low-order bits are not ixed */
		u32 x = _I0(a) ^ _I1(a) ^ _I2(a) ^ _I3(a);
		return x ^ (x << 16) ^ (x << 24);
		}

		static inline u32 ipv6_getbit(ip_addr a, u32 y)
		{
		return a.addr[y / 32] & (0x80000000 >> (y % 32));

nest/rt-attr.c

+31 −82

Original line number	Diff line number	Diff line
		@@ -51,6 +51,7 @@
		#include "nest/cli.h"
		#include "nest/attrs.h"
		#include "lib/alloca.h"
		#include "lib/hash.h"
		#include "lib/resource.h"
		#include "lib/string.h"

		@@ -63,14 +64,20 @@ static slab *rte_src_slab;
		/* rte source ID bitmap */
		static u32 *src_ids;
		static u32 src_id_size, src_id_used, src_id_pos;
		#define SRC_ID_SIZE_DEF 4
		#define SRC_ID_INIT_SIZE 4

		/* rte source hash */
		static struct rte_src **src_table;
		static u32 src_hash_order, src_hash_size, src_hash_count;
		#define SRC_HASH_ORDER_DEF 6
		#define SRC_HASH_ORDER_MAX 18
		#define SRC_HASH_ORDER_MIN 10

		#define RSH_KEY(n) n->proto, n->private_id
		#define RSH_NEXT(n) n->next
		#define RSH_EQ(p1,n1,p2,n2) p1 == p2 && n1 == n2
		#define RSH_FN(p,n) p->hash_key ^ u32_hash(n)

		#define RSH_REHASH rte_src_rehash
		#define RSH_PARAMS /2, *2, 1, 1, 8, 20
		#define RSH_INIT_ORDER 6

		static HASH(struct rte_src) src_hash;

		struct protocol *attr_class_to_protocol[EAP_MAX];

		@@ -81,17 +88,14 @@ rte_src_init(void)
		rte_src_slab = sl_new(rta_pool, sizeof(struct rte_src));

		src_id_pos = 0;
		src_id_size = SRC_ID_SIZE_DEF;
		src_id_size = SRC_ID_INIT_SIZE;
		src_ids = mb_allocz(rta_pool, src_id_size * sizeof(u32));

		/* ID 0 is reserved */
		src_ids[0] = 1;
		src_id_used = 1;

		src_hash_count = 0;
		src_hash_order = SRC_HASH_ORDER_DEF;
		src_hash_size = 1 << src_hash_order;
		src_table = mb_allocz(rta_pool, src_hash_size * sizeof(struct rte_src *));
		HASH_INIT(src_hash, rta_pool, RSH_INIT_ORDER);
		}

		static inline int u32_cto(unsigned int x) { return ffs(~x) - 1; }
		@@ -141,55 +145,21 @@ rte_src_free_id(u32 id)
		src_id_used--;
		}

		static inline u32 rte_src_hash(struct proto *p, u32 x, u32 order)
		{ return (x * 2902958171u) >> (32 - order); }

		static void
		rte_src_rehash(int step)
		{
		struct rte_src *old_tab, src, *src_next;
		u32 old_size, hash, i;

		old_tab = src_table;
		old_size = src_hash_size;

		src_hash_order += step;
		src_hash_size = 1 << src_hash_order;
		src_table = mb_allocz(rta_pool, src_hash_size * sizeof(struct rte_src *));

		for (i = 0; i < old_size; i++)
		for (src = old_tab[i]; src; src = src_next)
		{
		src_next = src->next;
		hash = rte_src_hash(src->proto, src->private_id, src_hash_order);
		src->next = src_table[hash];
		src_table[hash] = src;
		}

		mb_free(old_tab);
		}
		HASH_DEFINE_REHASH_FN(RSH, struct rte_src)

		struct rte_src *
		rt_find_source(struct proto *p, u32 id)
		{
		struct rte_src *src;
		u32 hash = rte_src_hash(p, id, src_hash_order);

		for (src = src_table[hash]; src; src = src->next)
		if ((src->proto == p) && (src->private_id == id))
		return src;

		return NULL;
		return HASH_FIND(src_hash, RSH, p, id);
		}

		struct rte_src *
		rt_get_source(struct proto *p, u32 id)
		{
		struct rte_src *src;
		u32 hash = rte_src_hash(p, id, src_hash_order);
		struct rte_src *src = rt_find_source(p, id);

		for (src = src_table[hash]; src; src = src->next)
		if ((src->proto == p) && (src->private_id == id))
		if (src)
		return src;

		src = sl_alloc(rte_src_slab);
		@@ -198,47 +168,26 @@ rt_get_source(struct proto *p, u32 id)
		src->global_id = rte_src_alloc_id();
		src->uc = 0;

		src->next = src_table[hash];
		src_table[hash] = src;

		src_hash_count++;
		if ((src_hash_count > src_hash_size) && (src_hash_order < SRC_HASH_ORDER_MAX))
		rte_src_rehash(1);
		HASH_INSERT2(src_hash, RSH, rta_pool, src);

		return src;
		}

		static inline void
		rt_remove_source(struct rte_src **sp)
		{
		struct rte_src src = sp;

		*sp = src->next;
		rte_src_free_id(src->global_id);
		sl_free(rte_src_slab, src);
		src_hash_count--;
		}

		void
		rt_prune_sources(void)
		{
		struct rte_src **sp;
		int i;

		for (i = 0; i < src_hash_size; i++)
		HASH_WALK_FILTER(src_hash, next, src, sp)
		{
		sp = &src_table[i];
		while (*sp)
		if (src->uc == 0)
		{
		if ((*sp)->uc == 0)
		rt_remove_source(sp);
		else
		sp = &(*sp)->next;
		HASH_DO_REMOVE(src_hash, RSH, sp);
		rte_src_free_id(src->global_id);
		sl_free(rte_src_slab, src);
		}
		}
		HASH_WALK_FILTER_END;

		while ((src_hash_count < (src_hash_size / 4)) && (src_hash_order > SRC_HASH_ORDER_MIN))
		rte_src_rehash(-1);
		HASH_MAY_RESIZE_DOWN(src_hash, RSH, rta_pool);
		}

Admin message