percpu_counter: tie error bounds more obviously to count values
Subsystems (2)
PATCH 4/5 percpu_counter: tie error bounds more obviously to count values
This change simply moves around the computed error bound used in a few spots so it is more closely associated with the count value. This is based on this interpretation of the correct value of of a percpu_counter:
percpu_counter->count +/- error
So when thinking about the code, it is useful to think of (count + error) or (count - error) to represent an upper or lower bound of the percpu_counter's value. And this change simply moves things around to match that way of thinking.
Doing this made me realize there's another optimization to be made--namely skipping the per-cpu sum if after taking the lock we know the result will be below the threshold.
--- lib/percpu_counter.c | 32 +++++++++++++++++++++++--------- 1 file changed, 23 insertions(+), 9 deletions(-)
lib/percpu_counter.c +23 -9
@@ -234,16 +234,21 @@ int __percpu_counter_add_unless_lt(strucpreempt_disable (); -/* Check to see if rough count will be sufficient for comparison */ +/* +* Check to see if rough count will be sufficient for +* comparison. First, if the upper bound is too low, +* we're done. +*/ count =percpu_counter_read (fbc); -if (count + amount < threshold - error) +if (count + error + amount < threshold) goto out;/* -* If the updated counter will be over the threshold we know -* we can safely add, and might be able to avoid locking. +* Next, if the lower bound is above the threshold, we can +* safely add the amount. See if we can do so without +* locking. */ -if (count + amount > threshold + error) { +if (count - error + amount > threshold) {s32 *pcount =this_cpu_ptr (fbc->counters); count = *pcount + amount;
@@ -255,12 +260,21 @@ int __percpu_counter_add_unless_lt(struc }/* -* If the result is over the error threshold, we can just add it -* into the global counter ignoring what is in the per-cpu counters -* as they will not change the result of the calculation. +* We're within the error margin, so we need to be more +* precise. Take the lock, get the current count value, and +* check once more whether the result will be outside the +* error threshold. +* +* If we find we can safely add, just add the amount into +* the global counter ignoring what is in the per-cpu +* counters as they will not change the result of the +* calculation. */ spin_lock (&fbc->lock); -if (fbc->count + amount > threshold + error) { +if (fbc->count + error + amount < threshold) + goto out_unlock; + +if (fbc->count - error + amount > threshold) { fbc->count += amount; ret =1 ; goto out_unlock;
_______________________________________________
xfs mailing list
[email protected]
http://oss.sgi.com/mailman/listinfo/xfs