X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Ftimer%2Ftimer.c;h=91f46393958acef5b6e9dc10968f14344b35ab5d;hp=4e0b7101cc0df6a8c4ce7a75bfbc4e5b71e86ba5;hb=ad2ce76c10f808283ea7cf25cd8e76a15710c4f3;hpb=08dac1288246b1fc9efe1695fe4c7575103e4a2b

diff --git a/ccan/timer/timer.c b/ccan/timer/timer.c
index 4e0b7101..91f46393 100644
--- a/ccan/timer/timer.c
+++ b/ccan/timer/timer.c
@@ -12,15 +12,15 @@ struct timer_level {
 	struct list_head list[PER_LEVEL];
 };
 
-static uint64_t time_to_grains(struct timeabs t)
+static uint64_t time_to_grains(struct timemono t)
 {
 	return t.ts.tv_sec * ((uint64_t)1000000000 / TIMER_GRANULARITY)
 		+ (t.ts.tv_nsec / TIMER_GRANULARITY);
 }
 
-static struct timeabs grains_to_time(uint64_t grains)
+static struct timemono grains_to_time(uint64_t grains)
 {
-	struct timeabs t;
+	struct timemono t;
 
 	t.ts.tv_sec = grains / (1000000000 / TIMER_GRANULARITY);
 	t.ts.tv_nsec = (grains % (1000000000 / TIMER_GRANULARITY))
@@ -28,13 +28,14 @@ static struct timeabs grains_to_time(uint64_t grains)
 	return t;
 }
 
-void timers_init(struct timers *timers, struct timeabs start)
+void timers_init(struct timers *timers, struct timemono start)
 {
 	unsigned int i;
 
 	list_head_init(&timers->far);
 	timers->base = time_to_grains(start);
 	timers->first = -1ULL;
+	memset(timers->firsts, 0xFF, sizeof(timers->firsts));
 	for (i = 0; i < ARRAY_SIZE(timers->level); i++)
 		timers->level[i] = NULL;
 }
@@ -52,15 +53,20 @@ static void timer_add_raw(struct timers *timers, struct timer *t)
 {
 	struct list_head *l;
 	unsigned int level = level_of(timers, t->time);
+	uint64_t *first;
 
-	if (!timers->level[level])
+	if (!timers->level[level]) {
 		l = &timers->far;
-	else {
+		first = &timers->firsts[ARRAY_SIZE(timers->level)];
+	} else {
 		int off = (t->time >> (level*TIMER_LEVEL_BITS)) & (PER_LEVEL-1);
 		l = &timers->level[level]->list[off];
+		first = &timers->firsts[level];
 	}
 
 	list_add_tail(l, &t->list);
+	if (t->time < *first)
+		*first = t->time;
 }
 
 void timer_init(struct timer *t)
@@ -73,7 +79,26 @@ static bool list_node_initted(const struct list_node *n)
 	return n->prev == n;
 }
 
-void timer_add(struct timers *timers, struct timer *t, struct timeabs when)
+void timer_addrel(struct timers *timers, struct timer *t, struct timerel rel)
+{
+	assert(list_node_initted(&t->list));
+
+	t->time = time_to_grains(timemono_add(time_mono(), rel));
+
+#if TIME_HAVE_MONOTONIC
+	assert(t->time >= timers->base);
+#else
+	/* Added in the past?  Treat it as imminent. */
+	if (t->time < timers->base)
+		t->time = timers->base;
+#endif
+	if (t->time < timers->first)
+		timers->first = t->time;
+
+	timer_add_raw(timers, t);
+}
+
+void timer_addmono(struct timers *timers, struct timer *t, struct timemono when)
 {
 	assert(list_node_initted(&t->list));
 
@@ -89,7 +114,7 @@ void timer_add(struct timers *timers, struct timer *t, struct timeabs when)
 }
 
 /* FIXME: inline */
-void timer_del(struct timers *timers, struct timer *t)
+void timer_del(struct timers *timers UNNEEDED, struct timer *t)
 {
 	list_del_init(&t->list);
 }
@@ -131,7 +156,10 @@ static void add_level(struct timers *timers, unsigned int level)
 		timer_add_raw(timers, t);
 }
 
+/* We don't need to search past the first at level 0, since the
+ * bucket range is 1; they're all the same. */
 static const struct timer *find_first(const struct list_head *list,
+				      unsigned int level,
 				      const struct timer *prev)
 {
 	struct timer *t;
@@ -139,80 +167,84 @@ static const struct timer *find_first(const struct list_head *list,
 	list_for_each(list, t, list) {
 		if (!prev || t->time < prev->time)
 			prev = t;
+		if (level == 0)
+			break;
 	}
 	return prev;
 }
 
-static const struct timer *get_first(const struct timers *timers)
+/* Update level's first watermark, and return overall first. */
+static const struct timer *first_for_level(struct timers *timers,
+					   size_t level,
+					   const struct timer *level_first,
+					   const struct timer *first)
 {
-	unsigned int level, i, off;
-	bool need_next;
-	uint64_t base;
-	const struct timer *found = NULL;
-	struct list_head *h;
-
-	if (timers->first < timers->base) {
-		base = timers->base;
-		level = 0;
+	if (level_first) {
+		timers->firsts[level] = level_first->time;
+		if (!first || level_first->time < first->time)
+			first = level_first;
 	} else {
-		/* May not be accurate, due to timer_del / expiry. */
-		level = level_of(timers, timers->first);
-		base = timers->first >> (TIMER_LEVEL_BITS * level);
+		timers->firsts[level] = -1ULL;
 	}
+	return first;
+}
 
-next:
-	if (!timers->level[level])
-		return find_first(&timers->far, NULL);
+static bool level_may_beat(const struct timers *timers, size_t level,
+			   const struct timer *first)
+{
+	return !first || timers->firsts[level] < first->time;
+}
 
-	need_next = false;
-	off = base % PER_LEVEL;
-	for (i = 0; i < PER_LEVEL; i++) {
-		h = &timers->level[level]->list[(i+off) % PER_LEVEL];
+/* FIXME: Suboptimal */
+static const struct timer *brute_force_first(struct timers *timers)
+{
+	unsigned int l, i;
+	const struct timer *found = NULL;
 
-		if (!list_empty(h))
-			break;
+	for (l = 0; l < ARRAY_SIZE(timers->level) && timers->level[l]; l++) {
+		const struct timer *t = NULL;
+
+		/* Do we know they don't have a better one? */
+		if (!level_may_beat(timers, l, found))
+			continue;
+
+		/* Find first timer on this level. */
+		for (i = 0; i < PER_LEVEL; i++)
+			t = find_first(&timers->level[l]->list[i], l, t);
 
-		/* We haven't cascaded yet, so if we wrap, we'll need to
-		 * check next level, too. */
-		if (i + off == PER_LEVEL)
-			need_next = true;
+		found = first_for_level(timers, l, t, found);
 	}
-	if (i == PER_LEVEL) {
-		level++;
-		base >>= TIMER_LEVEL_BITS;
-		if (off != 0)
-			/* We need *next* bucket: we've started reusing the
-			 * one above */
-			base++;
-		goto next;
+
+	/* Check (and update) far list if there's a chance. */
+	l = ARRAY_SIZE(timers->level);
+	if (level_may_beat(timers, l, found)) {
+		const struct timer *t = find_first(&timers->far, l, NULL);
+		found = first_for_level(timers, l, t, found);
 	}
 
-	/* Level 0 is exact, so they're all the same. */
-	if (level == 0)
-		found = list_top(h, struct timer, list);
-	else
-		found = find_first(h, NULL);
+	return found;
+}
 
-	while (need_next) {
-		need_next = false;
-		if (!timers->level[level+1]) {
-			found = find_first(&timers->far, found);
-		} else {
-			/* Current upper bucket has emptied into this
-			 * bucket; we want *next* one. */
-			base >>= TIMER_LEVEL_BITS;
-			base++;
-			off = base % PER_LEVEL;
-
-			if (off == 0) {
-				need_next = true;
-			} else {
-				h = &timers->level[level+1]->list[off];
-				found = find_first(h, found);
-			}
+static const struct timer *get_first(struct timers *timers)
+{
+	/* We can have just far timers, for example. */
+	if (timers->level[0]) {
+		/* First search rest of lower buckets; we've already spilled
+		 * so if we find one there we don't need to search further. */
+		unsigned int i, off = timers->base % PER_LEVEL;
+
+		for (i = off; i < PER_LEVEL; i++) {
+			struct list_head *h = &timers->level[0]->list[i];
+			if (!list_empty(h))
+				return find_first(h, 0, NULL);
 		}
 	}
-	return found;
+
+	/* From here on, we're searching non-normalized parts of the
+	 * data structure, which is much subtler.
+	 *
+	 * So we brute force. */
+	return brute_force_first(timers);
 }
 
 static bool update_first(struct timers *timers)
@@ -222,13 +254,13 @@ static bool update_first(struct timers *timers)
 	if (!found) {
 		timers->first = -1ULL;
 		return false;
-	}
+ 	}
 
 	timers->first = found->time;
 	return true;
 }
 
-bool timer_earliest(struct timers *timers, struct timeabs *first)
+bool timer_earliest(struct timers *timers, struct timemono *first)
 {
 	if (!update_first(timers))
 		return false;
@@ -285,7 +317,7 @@ static void timer_fast_forward(struct timers *timers, uint64_t time)
 }
 
 /* Returns an expired timer. */
-struct timer *timers_expire(struct timers *timers, struct timeabs expire)
+struct timer *timers_expire(struct timers *timers, struct timemono expire)
 {
 	uint64_t now = time_to_grains(expire);
 	unsigned int off;
@@ -367,7 +399,7 @@ struct timers *timers_check(const struct timers *timers, const char *abortstr)
 
 		h = &timers->level[l]->list[(i+off) % PER_LEVEL];
 		if (!timer_list_check(h, timers->base + i, timers->base + i,
-				      timers->first, abortstr))
+				      timers->firsts[l], abortstr))
 			return NULL;
 	}
 
@@ -385,7 +417,7 @@ struct timers *timers_check(const struct timers *timers, const char *abortstr)
 
 			h = &timers->level[l]->list[(i+off) % PER_LEVEL];
 			if (!timer_list_check(h, base, base + per_bucket - 1,
-					      timers->first, abortstr))
+					      timers->firsts[l], abortstr))
 				return NULL;
 			base += per_bucket;
 		}
@@ -394,7 +426,8 @@ struct timers *timers_check(const struct timers *timers, const char *abortstr)
 past_levels:
 	base = (timers->base & ~((1ULL << (TIMER_LEVEL_BITS * l)) - 1))
 		+ (1ULL << (TIMER_LEVEL_BITS * l)) - 1;
-	if (!timer_list_check(&timers->far, base, -1ULL, timers->first,
+	if (!timer_list_check(&timers->far, base, -1ULL,
+			      timers->firsts[ARRAY_SIZE(timers->level)],
 			      abortstr))
 		return NULL;