tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

lib: mul_u64_u64_div_u64(): rename parameter 'c' to 'd'

Patch series "Implement mul_u64_u64_div_u64_roundup()", v5.

The pwm-stm32.c code wants a 'rounding up' version of
mul_u64_u64_div_u64(). This can be done simply by adding 'divisor - 1' to
the 128bit product. Implement mul_u64_add_u64_div_u64(a, b, c, d) = (a *
b + c)/d based on the existing code. Define mul_u64_u64_div_u64(a, b, d)
as mul_u64_add_u64_div_u64(a, b, 0, d) and mul_u64_u64_div_u64_roundup(a,
b, d) as mul_u64_add_u64_div_u64(a, b, d-1, d).

Only x86-64 has an optimsed (asm) version of the function. That is
optimised to avoid the 'add c' when c is known to be zero. In all other
cases the extra code will be noise compared to the software divide code.

The test module has been updated to test mul_u64_u64_div_u64_roundup() and
also enhanced it to verify the C division code on x86-64 and the 32bit
division code on 64bit.


This patch (of 9):

Change to prototype from mul_u64_u64_div_u64(u64 a, u64 b, u64 c) to
mul_u64_u64_div_u64(u64 a, u64 b, u64 d). Using 'd' for 'divisor' makes
more sense.

An upcoming change adds a 'c' parameter to calculate (a * b + c)/d.

Link: https://lkml.kernel.org/r/20251105201035.64043-1-david.laight.linux@gmail.com
Link: https://lkml.kernel.org/r/20251105201035.64043-2-david.laight.linux@gmail.com
Signed-off-by: David Laight <david.laight.linux@gmail.com>
Reviewed-by: Nicolas Pitre <npitre@baylibre.com>
Cc: Biju Das <biju.das.jz@bp.renesas.com>
Cc: Borislav Betkov <bp@alien8.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Jens Axboe <axboe@kernel.dk>
Cc: Li RongQing <lirongqing@baidu.com>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleinxer <tglx@linutronix.de>
Cc: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

authored by

David Laight and committed by
Andrew Morton 5944f875 af9b65d6

+12 -12
+12 -12
lib/math/div64.c
··· 184 184 EXPORT_SYMBOL(iter_div_u64_rem); 185 185 186 186 #ifndef mul_u64_u64_div_u64 187 - u64 mul_u64_u64_div_u64(u64 a, u64 b, u64 c) 187 + u64 mul_u64_u64_div_u64(u64 a, u64 b, u64 d) 188 188 { 189 189 if (ilog2(a) + ilog2(b) <= 62) 190 - return div64_u64(a * b, c); 190 + return div64_u64(a * b, d); 191 191 192 192 #if defined(__SIZEOF_INT128__) 193 193 ··· 212 212 213 213 #endif 214 214 215 - /* make sure c is not zero, trigger runtime exception otherwise */ 216 - if (unlikely(c == 0)) { 215 + /* make sure d is not zero, trigger runtime exception otherwise */ 216 + if (unlikely(d == 0)) { 217 217 unsigned long zero = 0; 218 218 219 219 OPTIMIZER_HIDE_VAR(zero); 220 220 return ~0UL/zero; 221 221 } 222 222 223 - int shift = __builtin_ctzll(c); 223 + int shift = __builtin_ctzll(d); 224 224 225 225 /* try reducing the fraction in case the dividend becomes <= 64 bits */ 226 226 if ((n_hi >> shift) == 0) { 227 227 u64 n = shift ? (n_lo >> shift) | (n_hi << (64 - shift)) : n_lo; 228 228 229 - return div64_u64(n, c >> shift); 229 + return div64_u64(n, d >> shift); 230 230 /* 231 231 * The remainder value if needed would be: 232 - * res = div64_u64_rem(n, c >> shift, &rem); 232 + * res = div64_u64_rem(n, d >> shift, &rem); 233 233 * rem = (rem << shift) + (n_lo - (n << shift)); 234 234 */ 235 235 } 236 236 237 - if (n_hi >= c) { 237 + if (n_hi >= d) { 238 238 /* overflow: result is unrepresentable in a u64 */ 239 239 return -1; 240 240 } 241 241 242 242 /* Do the full 128 by 64 bits division */ 243 243 244 - shift = __builtin_clzll(c); 245 - c <<= shift; 244 + shift = __builtin_clzll(d); 245 + d <<= shift; 246 246 247 247 int p = 64 + shift; 248 248 u64 res = 0; ··· 257 257 n_hi <<= shift; 258 258 n_hi |= n_lo >> (64 - shift); 259 259 n_lo <<= shift; 260 - if (carry || (n_hi >= c)) { 261 - n_hi -= c; 260 + if (carry || (n_hi >= d)) { 261 + n_hi -= d; 262 262 res |= 1ULL << p; 263 263 } 264 264 } while (n_hi);