X-Git-Url: https://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftimer%2Ftimer.c;h=8d220a6a8c6f44893f12c76e95090c6f0998321d;hb=61c38f61b8a40dbd8fe48b7510e00cfcc5379378;hp=208d8e6988f1a2d8871ecf40aecb64b8f7f4e282;hpb=59846988226a93114dc3eef725c519f19fe445dc;p=ccan

diff --git a/ccan/timer/timer.c b/ccan/timer/timer.c
index 208d8e69..8d220a6a 100644
--- a/ccan/timer/timer.c
+++ b/ccan/timer/timer.c
@@ -35,6 +35,7 @@ void timers_init(struct timers *timers, struct timeabs start)
 	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)
@@ -148,73 +154,78 @@ static const struct timer *find_first(const struct list_head *list,
 	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, -1U, 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;
 
-		/* 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;
+		/* 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);
+
+		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. */
-	found = find_first(h, level, NULL);
+	return found;
+}
 
-	while (need_next) {
-		need_next = false;
-		if (!timers->level[level+1]) {
-			found = find_first(&timers->far, -1U, 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, level+1, 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)
@@ -224,7 +235,7 @@ static bool update_first(struct timers *timers)
 	if (!found) {
 		timers->first = -1ULL;
 		return false;
-	}
+ 	}
 
 	timers->first = found->time;
 	return true;
@@ -369,7 +380,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;
 	}
 
@@ -387,7 +398,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;
 		}
@@ -396,7 +407,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;