Firmware/FreeRTOS-RISCV
8
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Initial version

Browse Source
This commit is contained in:
Eyck Jentzsch
2019-06-28 23:08:36 +02:00
commit 4d8973e20b
2426 changed files with 948029 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2050
FreeRTOSv10.2.1/FreeRTOS-Plus/Source/Reliance-Edge/tests/posix/fsstress.c Normal file
View File

File diff suppressed because it is too large Load Diff

152
FreeRTOSv10.2.1/FreeRTOS-Plus/Source/Reliance-Edge/tests/posix/redposixcompat.h Normal file
View File

@ -0,0 +1,152 @@
/* ----> 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 Defines macros which make the Reliance Edge POSIX-like API look more
like the actual POSIX API.
This file is intended for porting POSIX file system tests; it is not
intended for application use.
*/
#ifndef REDPOSIXCOMPAT_H
#define REDPOSIXCOMPAT_H
#ifndef assert
#define assert(x) REDASSERT(x)
#endif
#undef O_RDONLY
#undef O_WRONLY
#undef O_RDWR
#undef O_APPEND
#undef O_CREAT
#undef O_EXCL
#undef O_TRUNC
#define O_RDONLY RED_O_RDONLY
#define O_WRONLY RED_O_WRONLY
#define O_RDWR RED_O_RDWR
#define O_APPEND RED_O_APPEND
#define O_CREAT RED_O_CREAT
#define O_EXCL RED_O_EXCL
#define O_TRUNC RED_O_TRUNC
#undef SEEK_SET
#undef SEEK_CUR
#undef SEEK_END
#define SEEK_SET RED_SEEK_SET
#define SEEK_CUR RED_SEEK_CUR
#define SEEK_END RED_SEEK_END
/* Old-fashioned Linux seek names.
*/
#undef L_SET
#undef L_INCR
#undef L_XTND
#define L_SET SEEK_SET
#define L_INCR SEEK_CUR
#define L_XTND SEEK_END
#undef S_IFDIR
#undef S_IFREG
#undef S_ISDIR
#undef S_ISREG
#define S_IFDIR RED_S_IFDIR
#define S_IFREG RED_S_IFREG
#define S_ISDIR(m) RED_S_ISDIR(m)
#define S_ISREG(m) RED_S_ISREG(m)
#undef ST_RDONLY
#undef ST_NOSUID
#define ST_RDONLY RED_ST_RDONLY
#define ST_NOSUID RED_ST_NOSUID
#undef open
#undef creat
#undef unlink
#undef mkdir
#undef rmdir
#undef rename
#undef link
#undef close
#undef read
#undef write
#undef fsync
#undef fdatasync
#undef lseek
#undef ftruncate
#undef fstat
#undef opendir
#undef readdir
#undef rewinddir
#undef closedir
#define open(path, oflag) red_open(path, oflag)
#define creat(path, mode) open(path, O_WRONLY|O_CREAT|O_TRUNC)
#define unlink(path) red_unlink(path)
#define mkdir(path) red_mkdir(path)
#define rmdir(path) red_rmdir(path)
#define rename(old, new) red_rename(old, new)
#define link(path, hardlink) red_link(path, hardlink)
#define close(fd) red_close(fd)
#define read(fd, buf, len) red_read(fd, buf, len)
#define write(fd, buf, len) red_write(fd, buf, len)
#define fsync(fd) red_fsync(fd)
#define fdatasync(fd) fsync(fd)
#define lseek(fd, offset, whence) red_lseek(fd, offset, whence)
#define lseek64(fd, offset, whence) lseek(fd, offset, whence)
#define ftruncate(fd, size) red_ftruncate(fd, size)
#define fstat(fd, stat) red_fstat(fd, stat)
#define fstat64(fd, stat) fstat(fd, stat)
#define opendir(path) red_opendir(path)
#define readdir(dirp) red_readdir(dirp)
#define readdir64(dirp) readdir(dirp)
#define rewinddir(dirp) red_rewinddir(dirp)
#define closedir(dirp) red_closedir(dirp)
#undef DIR
#define DIR REDDIR
#undef errno
#define errno (*(int *)red_errnoptr())
#undef memcpy
#undef memmove
#undef memset
#undef strlen
#undef strncmp
#undef strcmp
#undef strncpy
#define memcpy(d, s, l) RedMemCpy(d, s, (uint32_t)(l))
#define memmove(d, s, l) RedMemMove(d, s, (uint32_t)(l))
#define memset(d, c, l) RedMemSet(d, (uint8_t)(c), (uint32_t)(l))
#define strlen(s) RedStrLen(s)
#define strncmp(s1, s2, l) RedStrNCmp(s1, s2, (uint32_t)(l))
#define strcmp(s1, s2) RedStrCmp(s1, s2)
#define strncpy(d, s, l) RedStrNCpy(d, s, (uint32_t)(l))
#endif

478
FreeRTOSv10.2.1/FreeRTOS-Plus/Source/Reliance-Edge/tests/util/atoi.c Normal file
View File

@ -0,0 +1,478 @@
/* ----> 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 utilities that convert strings to numbers.
*/
#include <redfs.h>
#include <redtestutils.h>
#define ISHEXDIGITU(c) (((c) >= 'A') && ((c) <= 'F'))
#define ISHEXDIGITL(c) (((c) >= 'a') && ((c) <= 'f'))
#define ISHEXDIGIT(c) (ISHEXDIGITL(c) || ISHEXDIGITU(c))
/** @brief Converts an ASCII number into an int32_t.
Converts all decimal digit numbers up to the end of the string or to the
first non-numerical character.
@note This function does *not* ignore leading white space.
@param pszNum Pointer to a constant array of characters.
@return The integer represented in the string.
*/
int32_t RedAtoI(
const char *pszNum)
{
int32_t lValue = 0;
int32_t lNegative = 1;
uint32_t ulIdx = 0U;
if(pszNum[ulIdx] == '+')
{
ulIdx++;
}
else if(pszNum[ulIdx] == '-')
{
ulIdx++;
lNegative = -1;
}
else
{
/* No sign, implicitly positive.
*/
}
while(ISDIGIT(pszNum[ulIdx]))
{
lValue *= 10;
lValue += pszNum[ulIdx] - '0';
ulIdx++;
}
lValue *= lNegative;
return lValue;
}
/** @brief Convert a hexadecimal ASCII number into a uint32_t value.
The function processes all hex digits up to a NUL-terminator, or to the
first non-hex character. Only hexadecimal digits are processed, so leading
white space, or a leading "0x" prefix are not allowed.
If pachNum points to an empty string (points to a NUL), this function will
return NULL, and the value at *pulNum will not be modified.
@note This function does not check for overflow. If there are more
significant digits than can be represented in a uint32_t variable, the
output is unspecified.
@param pszNum A pointer to a constant array of hex characters.
@param pulNum A pointer to the location in which to store the uint32_t
result. Upon return, this value will be modified ONLY if
the function succeeds and the returned pointer is valid (not
NULL).
@return A pointer to the byte following the converted number or NULL to
indicate failure.
*/
const char *RedHtoUL(
const char *pszNum,
uint32_t *pulNum)
{
uint64_t ullValue;
const char *pszReturn;
pszReturn = RedHtoULL(pszNum, &ullValue);
if(pszReturn != NULL)
{
if(ullValue < UINT32_MAX)
{
*pulNum = (uint32_t)ullValue;
}
else
{
pszReturn = NULL;
}
}
return pszReturn;
}
/** @brief Convert a hexadecimal ASCII number into a D_UINT64 value.
The function processes all hex digits up to a NUL-terminator, or to the
first non-hex character. Only hexadecimal digits are processed, so leading
white space, or a leading "0x" prefix are not allowed.
If pachNum points to an empty string (points to a NUL), this function will
return NULL, and the value at *pulNum will not be modified.
@note This function does not check for overflow. If there are more
significant digits than can be represented in a uint64_t variable, the
output is unspecified.
@param pszNum A pointer to a constant array of hex characters.
@param pullNum A pointer to the location in which to store the uint64_t
result. Upon return, this value will be modified ONLY if
the function succeeds and the returned pointer is valid (not
NULL).
@return A pointer to the byte following the converted number, or NULL to
indicate failure.
*/
const char *RedHtoULL(
const char *pszNum,
uint64_t *pullNum)
{
uint64_t ullValue = 0U;
const char *pszReturn = NULL;
uint32_t ulIdx = 0U;
REDASSERT(pszNum != NULL);
REDASSERT(pullNum != NULL);
while(pszNum[ulIdx] != '\0')
{
char cDigit = pszNum[ulIdx];
if(ISDIGIT(cDigit))
{
cDigit -= '0';
}
else if(ISHEXDIGITU(cDigit))
{
cDigit -= ('A' - 10);
}
else if(ISHEXDIGITL(cDigit))
{
cDigit -= ('a' - 10);
}
else
{
break;
}
REDASSERT((ullValue & UINT64_SUFFIX(0xF000000000000000)) == 0U);
ullValue <<= 4U;
ullValue += cDigit;
ulIdx++;
pszReturn = &pszNum[ulIdx];
}
/* Modify the number returned only if we found one or more valid hex
digits.
*/
if(pszReturn != NULL)
{
*pullNum = ullValue;
}
return pszReturn;
}
/** @brief Convert the ASCII number to a uint32_t value.
The number may be hex or decimal. Hex numbers must be prefixed by '0x', and
they may be upper or lower case. The conversion process will stop with the
first non hex or decimal digit.
If the number is negative (the first character is a '-' sign), the value
will be range checked and returned as the equivalent unsigned value.
@note This function will NOT fail for numbers which exceed the size of a
uint32_t value.
@param pszNum A pointer to the ASCII number to convert
@param pulNum A pointer to the uint32_t location to store the result.
This value will be modified on return only if the function
succeeds and the returned pointer is valid (not NULL).
@return A pointer to the byte following the converted number, or NULL to
indicate failure.
*/
const char *RedNtoUL(
const char *pszNum,
uint32_t *pulNum)
{
bool fNegative = false;
uint32_t ulIdx = 0U;
const char *pszReturn;
REDASSERT(pszNum != NULL);
REDASSERT(pulNum != NULL);
if(pszNum[ulIdx] == '-')
{
fNegative = true;
ulIdx++;
}
/* Hex numbers must be prefixed with '0x'.
*/
if((pszNum[ulIdx] == '0') && ((pszNum[ulIdx + 1U] == 'x') || (pszNum[ulIdx + 1U] == 'X')))
{
ulIdx += 2U;
if(ISDIGIT(pszNum[ulIdx]) || ISHEXDIGIT(pszNum[ulIdx]))
{
pszReturn = RedHtoUL(&pszNum[ulIdx], pulNum);
}
else
{
pszReturn = NULL;
}
}
else if(ISDIGIT(pszNum[ulIdx]))
{
uint32_t ulTemp;
ulTemp = RedAtoI(&pszNum[ulIdx]);
while(ISDIGIT(pszNum[ulIdx]))
{
ulIdx++;
}
if(fNegative)
{
/* Fail if the number is out of range.
*/
if(ulTemp > INT32_MAX)
{
pszReturn = NULL;
}
else
{
*pulNum = -((int32_t)ulTemp);
pszReturn = &pszNum[ulIdx];
}
}
else
{
*pulNum = ulTemp;
pszReturn = &pszNum[ulIdx];
}
}
else
{
/* Return an error if there is not at least one hex or decimal digit.
*/
pszReturn = NULL;
}
return pszReturn;
}
/** @brief Convert the ASCII number pointed to by pachNum to a uint64_t value.
The number may be hex or decimal. Hex numbers must be prefixed by '0x', and
they may be upper or lower case. The conversion process will stop with the
first non hex or decimal digit.
If the number is negative (the first character is a '-' sign), the value
will be range checked and returned as the equivalent unsigned value.
@param pszNum A pointer to the ASCII number to convert.
@param pullNum A pointer to the uint64_t location to store the result.
This value will be modified on return only if the function
succeeds and the returned pointer is valid (not NULL).
@return A pointer to the byte following the converted number, or NULL to
indicate failure.
*/
const char *RedNtoULL(
const char *pszNum,
uint64_t *pullNum)
{
bool fNegative = false;
uint32_t ulIdx = 0U;
const char *pszReturn;
REDASSERT(pszNum != NULL);
REDASSERT(pullNum != NULL);
if(pszNum[ulIdx] == '-')
{
fNegative = true;
ulIdx++;
}
/* Hex numbers must be prefixed with '0x'.
*/
if((pszNum[ulIdx] == '0') && ((pszNum[ulIdx + 1U] == 'x') || (pszNum[ulIdx + 1U] == 'X')))
{
ulIdx += 2U;
if(ISDIGIT(pszNum[ulIdx]) || ISHEXDIGIT(pszNum[ulIdx]))
{
pszReturn = RedHtoULL(&pszNum[ulIdx], pullNum);
}
else
{
pszReturn = NULL;
}
}
else if(ISDIGIT(pszNum[ulIdx]))
{
uint64_t ullTemp = 0U;
while(ISDIGIT(pszNum[ulIdx]))
{
ullTemp *= 10U;
ullTemp += pszNum[ulIdx] - '0';
ulIdx++;
}
if(fNegative)
{
/* Fail if the number is out of range.
*/
if(ullTemp > INT64_MAX)
{
pszReturn = NULL;
}
else
{
*pullNum = (uint64_t)(-((int64_t)ullTemp));
pszReturn = &pszNum[ulIdx];
}
}
else
{
*pullNum = ullTemp;
pszReturn = &pszNum[ulIdx];
}
}
else
{
/* Return an error if there is not at least one hex or decimal digit.
*/
pszReturn = NULL;
}
return pszReturn;
}
/** @brief Convert an ASCII hex or decimal number, which may may have a "B",
"KB", or "MB" suffix (case insensitive), to a binary value.
Hex numbers must be prefixed with "0x".
@note If there is no postfix, KB is assumed!
May fail due to bad formatting or overflow.
@param pszNum A pointer to the ASCII number to convert.
@param pulResult A pointer to a uint32_t in which to place the result.
@return A pointer to the byte following the string, or NULL to indicate an
error. In the event of an error, *pulResult will not be modified.
*/
const char *RedSizeToUL(
const char *pszNum,
uint32_t *pulResult)
{
uint32_t ulResult;
const char *pszSuffix;
const char *pszReturn;
uint32_t ulIdx = 0U;
REDASSERT(pszNum != NULL);
REDASSERT(pulResult != NULL);
/* Do the basic hex/decimal conversion
*/
pszSuffix = RedNtoUL(pszNum, &ulResult);
if(pszSuffix != NULL)
{
if((pszSuffix[ulIdx] == 'B') || (pszSuffix[ulIdx] == 'b'))
{
ulIdx++;
pszReturn = &pszSuffix[ulIdx];
}
else if( ((pszSuffix[ulIdx] == 'M') || (pszSuffix[ulIdx] == 'm'))
&& ((pszSuffix[ulIdx + 1U] == 'B') || (pszSuffix[ulIdx + 1U] == 'b')))
{
ulIdx += 2U;
if(ulResult > (UINT32_MAX / (1024U * 1024U)))
{
pszReturn = NULL;
}
else
{
ulResult *= 1024U * 1024U;
pszReturn = &pszSuffix[ulIdx];
}
}
else
{
/* The number is either postfixed with "KB" or something
else (we don't care), but we must increment the pointer
if it is something recognize.
*/
if( ((pszSuffix[ulIdx] == 'K') || (pszSuffix[ulIdx] == 'k'))
&& ((pszSuffix[ulIdx + 1U] == 'B') || (pszSuffix[ulIdx + 1U] == 'b')))
{
ulIdx += 2U;
}
/* "B" or "MB" were not specified, so it must be "KB"
*/
if(ulResult > (UINT32_MAX / 1024U))
{
pszReturn = NULL;
}
else
{
ulResult *= 1024UL;
pszReturn = &pszSuffix[ulIdx];
}
}
if(pszReturn != NULL)
{
*pulResult = ulResult;
}
}
else
{
pszReturn = NULL;
}
return pszReturn;
}

641
FreeRTOSv10.2.1/FreeRTOS-Plus/Source/Reliance-Edge/tests/util/math.c Normal file
View File

@ -0,0 +1,641 @@
/* ----> 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;
}

1265
FreeRTOSv10.2.1/FreeRTOS-Plus/Source/Reliance-Edge/tests/util/printf.c Normal file
View File

File diff suppressed because it is too large Load Diff

159
FreeRTOSv10.2.1/FreeRTOS-Plus/Source/Reliance-Edge/tests/util/rand.c Normal file
View File

@ -0,0 +1,159 @@
/* ----> 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 a random number generator.
*/
#include <redfs.h>
#include <redtestutils.h>
/* This is the global seed used by the random number generator when the caller
has not provided a seed to either the RedRand32() or RedRand64() functions.
*/
static uint64_t ullGlobalRandomNumberSeed;
/* Whether the above seed has been initialized.
*/
static bool fGlobalSeedInited;
/** @brief Set the global seed used by the random number generator.
The global seed gets used when RedRand64() or RedRand32() are called with
a NULL seed argument.
@param ullSeed The value to use as the global RNG seed.
*/
void RedRandSeed(
uint64_t ullSeed)
{
ullGlobalRandomNumberSeed = ullSeed;
fGlobalSeedInited = true;
}
/** @brief Generate a 64-bit pseudo-random number.
The period of this random number generator is 2^64 (1.8 x 1019). These
parameters are the same as the default one-stream SPRNG lcg64 generator and
it satisfies the requirements for a maximal period.
The tempering value is used and an AND mask and is specifically selected to
favor the distribution of lower bits.
@param pullSeed A pointer to the seed to use. Set this value to NULL to
use the internal global seed value.
@return A pseudo-random number in the range [0, UINT64_MAX].
*/
uint64_t RedRand64(
uint64_t *pullSeed)
{
const uint64_t ullA = UINT64_SUFFIX(2862933555777941757);
const uint64_t ullC = UINT64_SUFFIX(3037000493);
const uint64_t ullT = UINT64_SUFFIX(4921441182957829599);
uint64_t ullN;
uint64_t *pullSeedPtr;
uint64_t ullLocalSeed;
if(pullSeed != NULL)
{
ullLocalSeed = *pullSeed;
pullSeedPtr = pullSeed;
}
else
{
if(!fGlobalSeedInited)
{
/* Unfortunately, the Reliance Edge OS services don't give us much
to work with to initialize the global seed. There is no entropy
abstraction, no tick count abstraction, and the timestamp
abstraction uses an opaque type which is not guaranteed to be an
integer. The best we can do is use the RTC.
Tests using the RNG should be supplying a seed anyway, for
reproducibility.
*/
RedRandSeed((uint64_t)RedOsClockGetTime());
}
ullLocalSeed = ullGlobalRandomNumberSeed;
pullSeedPtr = &ullGlobalRandomNumberSeed;
}
ullN = (ullLocalSeed * ullA) + ullC;
*pullSeedPtr = ullN;
/* The linear congruential generator used above produces good psuedo-random
64-bit number sequences, however, as with any LCG, the period of the
lower order bits is much shorter resulting in alternately odd/even pairs
in bit zero.
The result of the LGC above is tempered below with a series of XOR and
shift operations to produce a more acceptable equidistribution of bits
throughout the 64-bit range.
*/
ullN ^= (ullN >> 21U) & ullT;
ullN ^= (ullN >> 43U) & ullT;
ullN ^= (ullN << 23U) & ~ullT;
ullN ^= (ullN << 31U) & ~ullT;
return ullN;
}
/** @brief Generate a 32-bit pseudo-random number.
@note The 32-bit random number generator internally uses the 64-bit random
number generator, returning the low 32-bits of the pseudo-random
64-bit value.
@param pulSeed A pointer to the seed to use. Set this value to NULL to use
the internal global seed value.
@return A pseudo-random number in the range [0, UINT32_MAX].
*/
uint32_t RedRand32(
uint32_t *pulSeed)
{
uint64_t ullN;
if(pulSeed != NULL)
{
uint64_t ullLocalSeed;
ullLocalSeed = *pulSeed;
ullN = RedRand64(&ullLocalSeed);
*pulSeed = (uint32_t)ullLocalSeed;
}
else
{
ullN = RedRand64(NULL);
}
return (uint32_t)ullN;
}