-/// Multiply FREQ by N and store result in W array.
-static void mult96bit(uint64_t freq, uint32_t N, uint64_t W[2]) {
- uint64_t u0 = freq & UINT32_MAX;
- uint64_t u1 = freq >> 32;
-
- // Represent 96-bit value as w[2]:w[1]:w[0];
- uint32_t w[3] = { 0, 0, 0 };
-
- uint64_t t = u0 * N;
- uint64_t k = t >> 32;
- w[0] = t;
- t = u1 * N + k;
- w[1] = t;
- w[2] = t >> 32;
-
- // W[1] - higher bits.
- // W[0] - lower bits.
- W[0] = w[0] + ((uint64_t) w[1] << 32);
- W[1] = w[2];
-}
-
-
-/// Divide 96-bit value stored in W array by D.
-/// Return 64-bit quotient, saturated to UINT64_MAX on overflow.
-static uint64_t div96bit(uint64_t W[2], uint32_t D) {
- uint64_t y = W[0];
- uint64_t x = W[1];
- unsigned i;
-
- // This is really a 64-bit division.
- if (!x)
- return y / D;
-
- // This long division algorithm automatically saturates on overflow.
- for (i = 0; i < 64 && x; ++i) {
- uint32_t t = -((x >> 31) & 1); // Splat bit 31 to bits 0-31.
- x = (x << 1) | (y >> 63);
- y = y << 1;
- if ((x | t) >= D) {
- x -= D;
- ++y;
- }
- }
-
- return y << (64 - i);
-}
-
-
-void BlockFrequency::scale(uint32_t N, uint32_t D) {
- assert(D != 0 && "Division by zero");
-
- // Calculate Frequency * N.
- uint64_t MulLo = (Frequency & UINT32_MAX) * N;
- uint64_t MulHi = (Frequency >> 32) * N;
- uint64_t MulRes = (MulHi << 32) + MulLo;
-
- // If the product fits in 64 bits, just use built-in division.
- if (MulHi <= UINT32_MAX && MulRes <= MulLo) {
- Frequency = MulRes / D;
- return;
- }
-
- // Product overflowed, use 96-bit operations.
- // 96-bit value represented as W[1]:W[0].
- uint64_t W[2];
- mult96bit(Frequency, N, W);
- Frequency = div96bit(W, D);
- return;
-}
-