642 lines
19 KiB
C
642 lines
19 KiB
C
/* ----> DO NOT REMOVE THE FOLLOWING NOTICE <----
|
|
|
|
Copyright (c) 2014-2015 Datalight, Inc.
|
|
All Rights Reserved Worldwide.
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; use version 2 of the License.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but "AS-IS," WITHOUT ANY WARRANTY; without even the implied warranty
|
|
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License along
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
/* Businesses and individuals that for commercial or other reasons cannot
|
|
comply with the terms of the GPLv2 license may obtain a commercial license
|
|
before incorporating Reliance Edge into proprietary software for
|
|
distribution in any form. Visit http://www.datalight.com/reliance-edge for
|
|
more information.
|
|
*/
|
|
/** @file
|
|
@brief Implements routines for certain 64-bit math operations and simulated
|
|
floating point.
|
|
|
|
RedUint64DivMod32() and RedUint64DivMod64() are derived from code at
|
|
http://www.hackersdelight.org. This web site states explicitly that "You
|
|
are free to use, copy, and distribute any of the code on this web site,
|
|
whether modified by you or not. You need not give attribution."
|
|
*/
|
|
#include <redfs.h>
|
|
#include <redtestutils.h>
|
|
|
|
|
|
static uint32_t nlz64(uint64_t ullValue);
|
|
|
|
|
|
/** @brief Return a ratio value formatted as a floating point string accurate to
|
|
the specified number of decimal places.
|
|
|
|
The function exists to provide floating point style output without using
|
|
any actual floating point types.
|
|
|
|
This function may scale the numbers down to avoid overflow at the high end.
|
|
Likewise, potential divide-by-zero errors are internally avoided. Here are
|
|
some examples:
|
|
|
|
Dividend | Divisor | DecPlaces | Result
|
|
-------- | ------- | --------- | ------
|
|
12133 | 28545 | 2 | "0.42"
|
|
1539 | 506 | 2 | "3.04"
|
|
|
|
To get a number formatted as a percentage, take the take the portion of the
|
|
total (normally the smaller part), multiply it by 100, and pass it to this
|
|
function as the Dividend, pass the "total" value to this function as the
|
|
Divisor, and specify the desired number of decimal places.
|
|
|
|
For example, if you have a disk format overhead value of N blocks out of a
|
|
total of Y blocks on the disk, and you want to display the format overhead
|
|
as a percentage, you would use a function call
|
|
similar to:
|
|
|
|
~~~{.c}
|
|
RedRatio(szBuffer, sizeof(szBuffer), N*100U, Y, 2U);
|
|
~~~
|
|
|
|
If N=145, Y=4096, and decimal places is 2, the resulting output would be
|
|
"3.54".
|
|
|
|
The string returned will always be null-terminated, even if it means
|
|
stomping on the least significant decimal digit.
|
|
|
|
If either the dividend or divisor values are zero, the string "0.0" will be
|
|
returned, with the prescribed number of decimal places.
|
|
|
|
@note This function has "reasonable" limits which meet the needs of the
|
|
various supplemental utilities which use this function. Extremely
|
|
large ratios, or using many decimal places may not function as
|
|
desired.
|
|
|
|
Parameters:
|
|
@param pBuffer A pointer to the buffer in which to store the null
|
|
terminated results.
|
|
@param ulBufferLen The length of the output buffer.
|
|
@param ullDividend The "total" value to divide.
|
|
@param ullDivisor The portion of ullDividend for which to calculate the
|
|
ratio (may be greater than ulDividend).
|
|
@param ulDecPlaces The number of decimal places to use, from 0 to 9.
|
|
|
|
@return @p pBuffer.
|
|
*/
|
|
char *RedRatio(
|
|
char *pBuffer,
|
|
uint32_t ulBufferLen,
|
|
uint64_t ullDividend,
|
|
uint64_t ullDivisor,
|
|
uint32_t ulDecPlaces)
|
|
{
|
|
REDASSERT(pBuffer != NULL);
|
|
REDASSERT(ulBufferLen > 0U);
|
|
REDASSERT(ulDecPlaces <= 9U); /* arbitrary */
|
|
|
|
if((ullDivisor > 0U) && (ullDividend > 0U))
|
|
{
|
|
uint32_t ii;
|
|
uint32_t ulFactor = 1U;
|
|
uint64_t ullDecimal;
|
|
uint64_t ullTemp;
|
|
|
|
for(ii = 1U; ii <= ulDecPlaces; ii++)
|
|
{
|
|
ulFactor *= 10U;
|
|
}
|
|
|
|
ullDecimal = RedMulDiv64(ullDividend, ulFactor, ullDivisor);
|
|
|
|
/* Shouldn't really be calling this function in a situation where we
|
|
can overflow at this point...
|
|
*/
|
|
REDASSERT(ullDecimal != UINT64_MAX);
|
|
|
|
if(ullDivisor <= ullDividend)
|
|
{
|
|
uint32_t ulDecimal;
|
|
|
|
(void)RedUint64DivMod32(ullDecimal, ulFactor, &ulDecimal);
|
|
ullDecimal = ulDecimal;
|
|
}
|
|
|
|
ullTemp = RedUint64DivMod64(ullDividend, ullDivisor, NULL);
|
|
|
|
if(ulDecPlaces > 0U)
|
|
{
|
|
RedSNPrintf(pBuffer, ulBufferLen, "%llu.%0*llu", (unsigned long long)ullTemp,
|
|
(unsigned)ulDecPlaces, (unsigned long long)ullDecimal);
|
|
}
|
|
else
|
|
{
|
|
RedSNPrintf(pBuffer, ulBufferLen, "%llu", (unsigned long long)ullTemp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* If either the dividend or divisor is zero, then just output a "0.0"
|
|
string with the prescribed number of decimal places.
|
|
*/
|
|
if(ulDecPlaces > 0U)
|
|
{
|
|
RedSNPrintf(pBuffer, ulBufferLen, "0.%0*u", (unsigned)ulDecPlaces, 0U);
|
|
}
|
|
else
|
|
{
|
|
RedStrNCpy(pBuffer, "0", ulBufferLen);
|
|
}
|
|
}
|
|
|
|
/* Ensure the returned buffer is always null-terminated
|
|
*/
|
|
pBuffer[ulBufferLen - 1U] = '\0';
|
|
|
|
return pBuffer;
|
|
}
|
|
|
|
|
|
/** @brief Multiply 64-bit and 32-bit numbers, and divide by a 64-bit number,
|
|
returning a 64-bit result.
|
|
|
|
@note This function may return an approximate value if multiplying
|
|
@p ullBase and @p ulMultplier results in a number larger than 64-bits
|
|
_and_ this cannot be avoided by scaling.
|
|
|
|
@param ullBase The base 64-bit number number.
|
|
@param ulMultiplier The 32-bit number by which to multiply.
|
|
@param ullDivisor The 64-bit number by which to divide.
|
|
|
|
@return The 64-bit unsigned integer result. Always returns zero if either
|
|
@p ullBase or @p ulMultiplier are zero (regardless what
|
|
@p ullDivisor is). Returns UINT64_MAX if an overflow condition
|
|
occurred, or if @p ullDivisor is zero.
|
|
*/
|
|
uint64_t RedMulDiv64(
|
|
uint64_t ullBase,
|
|
uint32_t ulMultiplier,
|
|
uint64_t ullDivisor)
|
|
{
|
|
uint64_t ullTemp;
|
|
|
|
/* Result would always be zero if either of these are zero. Specifically
|
|
test this case before looking for a zero divisor.
|
|
*/
|
|
if((ullBase == 0U) || (ulMultiplier == 0U))
|
|
{
|
|
return 0U;
|
|
}
|
|
|
|
if(ullDivisor == 0U)
|
|
{
|
|
return UINT64_MAX;
|
|
}
|
|
|
|
/* Since we don't have the ability (yet) to use 128-bit numbers, we jump
|
|
through the following hoops (in order) to try to determine the proper
|
|
results without losing precision:
|
|
|
|
1) Shift the divisor and one of the multiplicands as many times as is
|
|
necessary to reduce the scale -- only if it can be done without
|
|
losing precision.
|
|
2) Divide one of the multiplicands by the divisor first, but only if it
|
|
divides evenly, preserving precision.
|
|
3) Same as #2, but try it for the other multiplicand.
|
|
4) Last ditch, divide the larger multiplicand by the divisor first, then
|
|
do the multiply. This <WILL> lose precision.
|
|
|
|
These solutions are identified as CODE-PATHs #1-4 which are used to
|
|
identify the matching tests in dltmain.c.
|
|
|
|
Note that execution might partially include CODE-PATH #1 up until
|
|
shifting can no longer be done without losing precision. In that case,
|
|
one of the three remaining options will be used.
|
|
*/
|
|
|
|
ullTemp = RedUint64DivMod32(UINT64_MAX, ulMultiplier, NULL);
|
|
while(ullBase > ullTemp)
|
|
{
|
|
uint64_t ullMod;
|
|
uint64_t ullBaseTemp;
|
|
uint64_t ullWideMultiplier;
|
|
|
|
/* CODE-PATH #1
|
|
*/
|
|
/* So long as ulDivisor, and at least one of the other numbers, are
|
|
evenly divisible by 2, we can scale the numbers so the result does
|
|
not overflow the intermediate 64-bit value.
|
|
*/
|
|
if((ullDivisor & 1U) == 0U)
|
|
{
|
|
if((ullBase & 1U) == 0U)
|
|
{
|
|
/* CODE-PATH #1a
|
|
*/
|
|
ullDivisor >>= 1U;
|
|
ullBase >>= 1U;
|
|
continue;
|
|
}
|
|
|
|
if(((ulMultiplier & 1U) == 0U) && ((ullTemp & UINT64_SUFFIX(0x8000000000000000)) == 0U))
|
|
{
|
|
/* CODE-PATH #1b
|
|
*/
|
|
ullDivisor >>= 1U;
|
|
ulMultiplier >>= 1U;
|
|
ullTemp <<= 1U;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* If we get to this point, the above method (#1) cannot be used
|
|
because not enough of the numbers are even long enough to scale the
|
|
operands down. We'll see if either multiplicand is evenly divisble
|
|
by ulDivisor, and if so, do the divide first, then the multiply.
|
|
(Note that once we get to this point, we will never exercise the
|
|
while{} loop anymore.)
|
|
*/
|
|
|
|
/* CODE-PATH #2
|
|
*/
|
|
ullBaseTemp = RedUint64DivMod64(ullBase, ullDivisor, &ullMod);
|
|
if(ullMod == 0U)
|
|
{
|
|
/* Evenly divides, so check that we won't overflow, and finish up.
|
|
*/
|
|
ullBase = ullBaseTemp;
|
|
if(ullBase > ullTemp)
|
|
{
|
|
return UINT64_MAX;
|
|
}
|
|
else
|
|
{
|
|
/* We've validated that this will not overflow.
|
|
*/
|
|
ullBase *= ulMultiplier;
|
|
return ullBase;
|
|
}
|
|
}
|
|
|
|
/* CODE-PATH #3
|
|
*/
|
|
ullWideMultiplier = RedUint64DivMod64(ulMultiplier, ullDivisor, &ullMod);
|
|
if(ullMod == 0U)
|
|
{
|
|
/* Evenly divides, so check that we won't overflow, and finish up.
|
|
*/
|
|
|
|
/* Must recalculate ullTemp relative to ullBase
|
|
*/
|
|
ullTemp = RedUint64DivMod64(UINT64_MAX, ullBase, NULL);
|
|
if(ullWideMultiplier > ullTemp)
|
|
{
|
|
return UINT64_MAX;
|
|
}
|
|
else
|
|
{
|
|
uint32_t ulNarrowMultiplier = (uint32_t)ullWideMultiplier;
|
|
|
|
/* We've validated that this will not overflow.
|
|
*/
|
|
ullBase *= ulNarrowMultiplier;
|
|
return ullBase;
|
|
}
|
|
}
|
|
|
|
/* CODE-PATH #4
|
|
|
|
Neither of the multipliers is evenly divisible by the divisor, so
|
|
just punt and divide the larger number first, then do the final
|
|
multiply.
|
|
|
|
All the other attempts above would preserve precision -- this is the
|
|
only case where precision may be lost.
|
|
*/
|
|
|
|
/* If necessary reverse the ullBase and ulMultiplier operands so that
|
|
ullBase contains the larger of the two values.
|
|
*/
|
|
if(ullBase < ulMultiplier)
|
|
{
|
|
uint32_t ulTemp = ulMultiplier;
|
|
|
|
ulMultiplier = (uint32_t)ullBase;
|
|
ullBase = ulTemp;
|
|
}
|
|
|
|
ullBase = RedUint64DivMod64(ullBase, ullDivisor, NULL);
|
|
ullTemp = RedUint64DivMod32(UINT64_MAX, ulMultiplier, NULL);
|
|
if(ullBase > ullTemp)
|
|
{
|
|
return UINT64_MAX;
|
|
}
|
|
else
|
|
{
|
|
ullBase *= ulMultiplier;
|
|
return ullBase;
|
|
}
|
|
}
|
|
|
|
/* We only get to this point if either there was never any chance of
|
|
overflow, or if the pure shifting mechanism succeeded in reducing
|
|
the scale so overflow is not a problem.
|
|
*/
|
|
|
|
ullBase *= ulMultiplier;
|
|
ullBase = RedUint64DivMod64(ullBase, ullDivisor, NULL);
|
|
|
|
return ullBase;
|
|
}
|
|
|
|
|
|
/** @brief Divide a 64-bit value by a 32-bit value, returning the quotient and
|
|
the remainder.
|
|
|
|
Essentially this function does the following:
|
|
|
|
~~~{.c}
|
|
if(pulRemainder != NULL)
|
|
{
|
|
*pulRemainder = (uint32_t)(ullDividend % ulDivisor);
|
|
}
|
|
return ullDividend / ulDivisor;
|
|
~~~
|
|
|
|
However, it does so without ever actually dividing/modulating a 64-bit
|
|
value, since such operations are not allowed in all environments.
|
|
|
|
@param ullDividend The value to divide.
|
|
@param ulDivisor The value to divide by.
|
|
@param pulRemainder Populated with the remainder; may be NULL.
|
|
|
|
@return The quotient (result of the division).
|
|
*/
|
|
uint64_t RedUint64DivMod32(
|
|
uint64_t ullDividend,
|
|
uint32_t ulDivisor,
|
|
uint32_t *pulRemainder)
|
|
{
|
|
uint64_t ullQuotient;
|
|
uint32_t ulResultRemainder;
|
|
|
|
/* Check for divide by zero.
|
|
*/
|
|
if(ulDivisor == 0U)
|
|
{
|
|
REDERROR();
|
|
|
|
/* Nonsense value if no asserts.
|
|
*/
|
|
ullQuotient = UINT64_SUFFIX(0xFFFFFFFFFFFFFBAD);
|
|
ulResultRemainder = 0xFFFFFBADU;
|
|
}
|
|
else if(ullDividend <= UINT32_MAX)
|
|
{
|
|
uint32_t ulDividend = (uint32_t)ullDividend;
|
|
|
|
ullQuotient = ulDividend / ulDivisor;
|
|
ulResultRemainder = ulDividend % ulDivisor;
|
|
}
|
|
else
|
|
{
|
|
uint32_t ulResultHi;
|
|
uint32_t ulResultLo;
|
|
uint32_t ulRemainder;
|
|
uint8_t bIndex;
|
|
uint32_t ulThisDivision;
|
|
uint32_t ulMask;
|
|
uint8_t ucNextValue;
|
|
uint32_t ulInterimHi, ulInterimLo;
|
|
uint32_t ulLowDword = (uint32_t)ullDividend;
|
|
uint32_t ulHighDword = (uint32_t)(ullDividend >> 32U);
|
|
|
|
/* Compute the high part and get the remainder
|
|
*/
|
|
ulResultHi = ulHighDword / ulDivisor;
|
|
ulResultLo = 0U;
|
|
ulRemainder = ulHighDword % ulDivisor;
|
|
|
|
/* Compute the low part
|
|
*/
|
|
ulMask = 0xFF000000U;
|
|
for(bIndex = 0U; bIndex < sizeof(uint32_t); bIndex++)
|
|
{
|
|
ucNextValue = (uint8_t)((ulLowDword & ulMask) >> ((sizeof(uint32_t) - 1U - bIndex) * 8U));
|
|
ulInterimHi = ulRemainder >> 24U;
|
|
ulInterimLo = (ulRemainder << 8U) | ucNextValue;
|
|
ulThisDivision = 0U;
|
|
while(ulInterimHi != 0U)
|
|
{
|
|
uint64_t ullInterim = ((uint64_t)ulInterimHi << 32U) + ulInterimLo;
|
|
|
|
ullInterim -= ulDivisor;
|
|
ulThisDivision++;
|
|
|
|
ulInterimHi = (uint32_t)(ullInterim >> 32U);
|
|
ulInterimLo = (uint32_t)ullInterim;
|
|
}
|
|
ulThisDivision += ulInterimLo / ulDivisor;
|
|
ulRemainder = ulInterimLo % ulDivisor;
|
|
ulResultLo <<= 8U;
|
|
ulResultLo += ulThisDivision;
|
|
ulMask >>= 8U;
|
|
}
|
|
|
|
ullQuotient = ((uint64_t)ulResultHi << 32U) + ulResultLo;
|
|
ulResultRemainder = (uint32_t)(ullDividend - (ullQuotient * ulDivisor));
|
|
}
|
|
|
|
if(pulRemainder != NULL)
|
|
{
|
|
*pulRemainder = ulResultRemainder;
|
|
}
|
|
|
|
return ullQuotient;
|
|
}
|
|
|
|
|
|
/** @brief Divide a 64-bit value by a 64-bit value, returning the quotient and
|
|
the remainder.
|
|
|
|
Essentially this function does the following:
|
|
|
|
~~~{.c}
|
|
if(pullRemainder != NULL)
|
|
{
|
|
*pullRemainder = ullDividend % ullDivisor;
|
|
}
|
|
return ullDividend / ullDivisor;
|
|
~~~
|
|
|
|
However, it does so without ever actually dividing/modulating a 64-bit
|
|
value, since such operations are not allowed in all environments.
|
|
|
|
@param ullDividend The value to divide.
|
|
@param ullDivisor The value to divide by.
|
|
@param pullRemainder Populated with the remainder; may be NULL.
|
|
|
|
@return The quotient (result of the division).
|
|
*/
|
|
uint64_t RedUint64DivMod64(
|
|
uint64_t ullDividend,
|
|
uint64_t ullDivisor,
|
|
uint64_t *pullRemainder)
|
|
{
|
|
/* The variables u0, u1, etc. take on only 32-bit values, but they are
|
|
declared uint64_t to avoid some compiler warning messages and to avoid
|
|
some unnecessary EXTRs that the compiler would put in, to convert
|
|
uint64_ts to ints.
|
|
*/
|
|
uint64_t u0;
|
|
uint64_t u1;
|
|
uint64_t q0;
|
|
uint64_t q1;
|
|
uint64_t ullQuotient;
|
|
|
|
/* First the procedure takes care of the case in which the divisor is a
|
|
32-bit quantity. There are two subcases: (1) If the left half of the
|
|
dividend is less than the divisor, one execution of RedUint64DivMod32()
|
|
is all that is required (overflow is not possible). (2) Otherwise it
|
|
does two divisions, using the grade school method.
|
|
*/
|
|
|
|
if((ullDivisor >> 32U) == 0U)
|
|
{
|
|
if((ullDividend >> 32U) < ullDivisor)
|
|
{
|
|
/* If ullDividend/ullDivisor cannot overflow, just do one division.
|
|
*/
|
|
ullQuotient = RedUint64DivMod32(ullDividend, (uint32_t)ullDivisor, NULL);
|
|
}
|
|
else
|
|
{
|
|
uint32_t k;
|
|
|
|
/* If ullDividend/ullDivisor would overflow:
|
|
*/
|
|
|
|
/* Break ullDividend up into two halves.
|
|
*/
|
|
u1 = ullDividend >> 32U;
|
|
u0 = ullDividend & 0xFFFFFFFFU;
|
|
|
|
/* First quotient digit and first remainder.
|
|
*/
|
|
q1 = RedUint64DivMod32(u1, (uint32_t)ullDivisor, &k);
|
|
|
|
/* 2nd quot. digit.
|
|
*/
|
|
q0 = RedUint64DivMod32(((uint64_t)k << 32U) + u0, (uint32_t)ullDivisor, NULL);
|
|
|
|
ullQuotient = (q1 << 32U) + q0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
uint64_t n;
|
|
uint64_t v1;
|
|
|
|
n = nlz64(ullDivisor); /* 0 <= n <= 31. */
|
|
v1 = (ullDivisor << n) >> 32U; /* Normalize the divisor so its MSB is 1. */
|
|
u1 = ullDividend >> 1U; /* To ensure no overflow. */
|
|
|
|
/* Get quotient from divide unsigned insn.
|
|
*/
|
|
q1 = RedUint64DivMod32(u1, (uint32_t)v1, NULL);
|
|
|
|
q0 = (q1 << n) >> 31U; /* Undo normalization and division of ullDividend by 2. */
|
|
|
|
/* Make q0 correct or too small by 1.
|
|
*/
|
|
if(q0 != 0U)
|
|
{
|
|
q0--;
|
|
}
|
|
|
|
if((ullDividend - (q0 * ullDivisor)) >= ullDivisor)
|
|
{
|
|
q0++; /* Now q0 is correct. */
|
|
}
|
|
|
|
ullQuotient = q0;
|
|
}
|
|
|
|
if(pullRemainder != NULL)
|
|
{
|
|
*pullRemainder = ullDividend - (ullQuotient * ullDivisor);
|
|
}
|
|
|
|
return ullQuotient;
|
|
}
|
|
|
|
|
|
/** @brief Compute the number of leading zeroes in a 64-bit value.
|
|
|
|
@param ullValue The value for which to compute the NLZ.
|
|
|
|
@return The number of leading zeroes in @p ullValue.
|
|
*/
|
|
static uint32_t nlz64(
|
|
uint64_t ullValue)
|
|
{
|
|
uint32_t n;
|
|
|
|
if(ullValue == 0U)
|
|
{
|
|
n = 64U;
|
|
}
|
|
else
|
|
{
|
|
uint64_t x = ullValue;
|
|
|
|
n = 0U;
|
|
|
|
if(x <= UINT64_SUFFIX(0x00000000FFFFFFFF))
|
|
{
|
|
n += 32U;
|
|
x <<= 32U;
|
|
}
|
|
|
|
if(x <= UINT64_SUFFIX(0x0000FFFFFFFFFFFF))
|
|
{
|
|
n += 16U;
|
|
x <<= 16U;
|
|
}
|
|
|
|
if(x <= UINT64_SUFFIX(0x00FFFFFFFFFFFFFF))
|
|
{
|
|
n += 8U;
|
|
x <<= 8U;
|
|
}
|
|
|
|
if(x <= UINT64_SUFFIX(0x0FFFFFFFFFFFFFFF))
|
|
{
|
|
n += 4U;
|
|
x <<= 4U;
|
|
}
|
|
|
|
if(x <= UINT64_SUFFIX(0x3FFFFFFFFFFFFFFF))
|
|
{
|
|
n += 2U;
|
|
x <<= 2U;
|
|
}
|
|
|
|
if(x <= UINT64_SUFFIX(0x7FFFFFFFFFFFFFFF))
|
|
{
|
|
n += 1;
|
|
}
|
|
}
|
|
|
|
return n;
|
|
}
|
|
|