Christophe Riccio
ago%!(EXTRA string=11 years)
parent
20bdab33dd
commit
0bffce4f4b
6 changed files with 1105 additions and 472 deletions
@ -0,0 +1,447 @@ |
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// OpenGL Mathematics Copyright (c) 2005 - 2014 G-Truc Creation (www.g-truc.net)
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// Created : 2014-10-27
|
||||
// Updated : 2014-10-27
|
||||
// Licence : This source is under MIT licence
|
||||
// File : test/core/func_integer_find_lsb.cpp
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// This has the programs for computing the number of leading zeros
|
||||
// in a word.
|
||||
// Max line length is 57, to fit in hacker.book.
|
||||
// Compile with g++, not gcc.
|
||||
#include <cstdio> |
||||
#include <cstdlib> // To define "exit", req'd by XLC. |
||||
#include <ctime> |
||||
|
||||
#define LE 1 // 1 for little-endian, 0 for big-endian.
|
||||
|
||||
int pop(unsigned x) { |
||||
x = x - ((x >> 1) & 0x55555555); |
||||
x = (x & 0x33333333) + ((x >> 2) & 0x33333333); |
||||
x = (x + (x >> 4)) & 0x0F0F0F0F; |
||||
x = x + (x << 8); |
||||
x = x + (x << 16); |
||||
return x >> 24; |
||||
} |
||||
|
||||
int nlz1(unsigned x) { |
||||
int n; |
||||
|
||||
if (x == 0) return(32); |
||||
n = 0; |
||||
if (x <= 0x0000FFFF) {n = n +16; x = x <<16;} |
||||
if (x <= 0x00FFFFFF) {n = n + 8; x = x << 8;} |
||||
if (x <= 0x0FFFFFFF) {n = n + 4; x = x << 4;} |
||||
if (x <= 0x3FFFFFFF) {n = n + 2; x = x << 2;} |
||||
if (x <= 0x7FFFFFFF) {n = n + 1;} |
||||
return n; |
||||
} |
||||
|
||||
int nlz1a(unsigned x) { |
||||
int n; |
||||
|
||||
/* if (x == 0) return(32); */ |
||||
if ((int)x <= 0) return (~x >> 26) & 32; |
||||
n = 1; |
||||
if ((x >> 16) == 0) {n = n +16; x = x <<16;} |
||||
if ((x >> 24) == 0) {n = n + 8; x = x << 8;} |
||||
if ((x >> 28) == 0) {n = n + 4; x = x << 4;} |
||||
if ((x >> 30) == 0) {n = n + 2; x = x << 2;} |
||||
n = n - (x >> 31); |
||||
return n; |
||||
} |
||||
// On basic Risc, 12 to 20 instructions.
|
||||
|
||||
int nlz2(unsigned x) { |
||||
unsigned y; |
||||
int n; |
||||
|
||||
n = 32; |
||||
y = x >>16; if (y != 0) {n = n -16; x = y;} |
||||
y = x >> 8; if (y != 0) {n = n - 8; x = y;} |
||||
y = x >> 4; if (y != 0) {n = n - 4; x = y;} |
||||
y = x >> 2; if (y != 0) {n = n - 2; x = y;} |
||||
y = x >> 1; if (y != 0) return n - 2; |
||||
return n - x; |
||||
} |
||||
|
||||
// As above but coded as a loop for compactness:
|
||||
// 23 to 33 basic Risc instructions.
|
||||
int nlz2a(unsigned x) { |
||||
unsigned y; |
||||
int n, c; |
||||
|
||||
n = 32; |
||||
c = 16; |
||||
do { |
||||
y = x >> c; if (y != 0) {n = n - c; x = y;} |
||||
c = c >> 1; |
||||
} while (c != 0); |
||||
return n - x; |
||||
} |
||||
|
||||
int nlz3(int x) { |
||||
int y, n; |
||||
|
||||
n = 0; |
||||
y = x; |
||||
L: if (x < 0) return n; |
||||
if (y == 0) return 32 - n; |
||||
n = n + 1; |
||||
x = x << 1; |
||||
y = y >> 1; |
||||
goto L; |
||||
} |
||||
|
||||
int nlz4(unsigned x) { |
||||
int y, m, n; |
||||
|
||||
y = -(x >> 16); // If left half of x is 0,
|
||||
m = (y >> 16) & 16; // set n = 16. If left half
|
||||
n = 16 - m; // is nonzero, set n = 0 and
|
||||
x = x >> m; // shift x right 16.
|
||||
// Now x is of the form 0000xxxx.
|
||||
y = x - 0x100; // If positions 8-15 are 0,
|
||||
m = (y >> 16) & 8; // add 8 to n and shift x left 8.
|
||||
n = n + m; |
||||
x = x << m; |
||||
|
||||
y = x - 0x1000; // If positions 12-15 are 0,
|
||||
m = (y >> 16) & 4; // add 4 to n and shift x left 4.
|
||||
n = n + m; |
||||
x = x << m; |
||||
|
||||
y = x - 0x4000; // If positions 14-15 are 0,
|
||||
m = (y >> 16) & 2; // add 2 to n and shift x left 2.
|
||||
n = n + m; |
||||
x = x << m; |
||||
|
||||
y = x >> 14; // Set y = 0, 1, 2, or 3.
|
||||
m = y & ~(y >> 1); // Set m = 0, 1, 2, or 2 resp.
|
||||
return n + 2 - m; |
||||
} |
||||
|
||||
int nlz5(unsigned x) { |
||||
int pop(unsigned x); |
||||
|
||||
x = x | (x >> 1); |
||||
x = x | (x >> 2); |
||||
x = x | (x >> 4); |
||||
x = x | (x >> 8); |
||||
x = x | (x >>16); |
||||
return pop(~x); |
||||
} |
||||
|
||||
/* The four programs below are not valid ANSI C programs. This is
|
||||
because they refer to the same storage locations as two different types. |
||||
However, they work with xlc/AIX, gcc/AIX, and gcc/NT. If you try to |
||||
code them more compactly by declaring a variable xx to be "double," and |
||||
then using |
||||
|
||||
n = 1054 - (*((unsigned *)&xx + LE) >> 20); |
||||
|
||||
then you are violating not only the rule above, but also the ANSI C |
||||
rule that pointer arithmetic can be performed only on pointers to |
||||
array elements. |
||||
When coded with the above statement, the program fails with xlc, |
||||
gcc/AIX, and gcc/NT, at some optimization levels. |
||||
BTW, these programs use the "anonymous union" feature of C++, not |
||||
available in C. */ |
||||
|
||||
int nlz6(unsigned k) { |
||||
union { |
||||
unsigned asInt[2]; |
||||
double asDouble; |
||||
}; |
||||
int n; |
||||
|
||||
asDouble = (double)k + 0.5; |
||||
n = 1054 - (asInt[LE] >> 20); |
||||
return n; |
||||
} |
||||
|
||||
int nlz7(unsigned k) { |
||||
union { |
||||
unsigned asInt[2]; |
||||
double asDouble; |
||||
}; |
||||
int n; |
||||
|
||||
asDouble = (double)k; |
||||
n = 1054 - (asInt[LE] >> 20); |
||||
n = (n & 31) + (n >> 9); |
||||
return n; |
||||
} |
||||
|
||||
/* In single precision, round-to-nearest mode, the basic method fails for:
|
||||
k = 0, k = 01FFFFFF, 03FFFFFE <= k <= 03FFFFFF, |
||||
07FFFFFC <= k <= 07FFFFFF, |
||||
0FFFFFF8 <= k <= 0FFFFFFF, |
||||
... |
||||
7FFFFFC0 <= k <= 7FFFFFFF. |
||||
FFFFFF80 <= k <= FFFFFFFF. |
||||
For k = 0 it gives 158, and for the other values it is too low by 1. */ |
||||
|
||||
int nlz8(unsigned k) { |
||||
union { |
||||
unsigned asInt; |
||||
float asFloat; |
||||
}; |
||||
int n; |
||||
|
||||
k = k & ~(k >> 1); /* Fix problem with rounding. */ |
||||
asFloat = (float)k + 0.5f; |
||||
n = 158 - (asInt >> 23); |
||||
return n; |
||||
} |
||||
|
||||
/* The example below shows how to make a macro for nlz. It uses an
|
||||
extension to the C and C++ languages that is provided by the GNU C/C++ |
||||
compiler, namely, that of allowing statements and declarations in |
||||
expressions (see "Using and Porting GNU CC", by Richard M. Stallman |
||||
(1998). The underscores are necessary to protect against the |
||||
possibility that the macro argument will conflict with one of its local |
||||
variables, e.g., NLZ(k). */ |
||||
|
||||
int nlz9(unsigned k) { |
||||
union { |
||||
unsigned asInt; |
||||
float asFloat; |
||||
}; |
||||
int n; |
||||
|
||||
k = k & ~(k >> 1); /* Fix problem with rounding. */ |
||||
asFloat = (float)k; |
||||
n = 158 - (asInt >> 23); |
||||
n = (n & 31) + (n >> 6); /* Fix problem with k = 0. */ |
||||
return n; |
||||
} |
||||
|
||||
/* Below are three nearly equivalent programs for computing the number
|
||||
of leading zeros in a word. This material is not in HD, but may be in a |
||||
future edition. |
||||
Immediately below is Robert Harley's algorithm, found at the |
||||
comp.arch newsgroup entry dated 7/12/96, pointed out to me by Norbert |
||||
Juffa. |
||||
Table entries marked "u" are unused. 14 ops including a multiply, |
||||
plus an indexed load. |
||||
The smallest multiplier that works is 0x045BCED1 = 17*65*129*513 (all |
||||
of form 2**k + 1). There are no multipliers of three terms of the form |
||||
2**k +- 1 that work, with a table size of 64 or 128. There are some, |
||||
with a table size of 64, if you precede the multiplication with x = x - |
||||
(x >> 1), but that seems less elegant. There are also some if you use a |
||||
table size of 256, the smallest is 0x01033CBF = 65*255*1025 (this would |
||||
save two instructions in the form of this algorithm with the |
||||
multiplication expanded into shifts and adds, but the table size is |
||||
getting a bit large). */ |
||||
|
||||
#define u 99 |
||||
int nlz10(unsigned x) { |
||||
|
||||
static char table[64] = |
||||
{32,31, u,16, u,30, 3, u, 15, u, u, u,29,10, 2, u, |
||||
u, u,12,14,21, u,19, u, u,28, u,25, u, 9, 1, u, |
||||
17, u, 4, u, u, u,11, u, 13,22,20, u,26, u, u,18, |
||||
5, u, u,23, u,27, u, 6, u,24, 7, u, 8, u, 0, u}; |
||||
|
||||
x = x | (x >> 1); // Propagate leftmost
|
||||
x = x | (x >> 2); // 1-bit to the right.
|
||||
x = x | (x >> 4); |
||||
x = x | (x >> 8); |
||||
x = x | (x >>16); |
||||
x = x*0x06EB14F9; // Multiplier is 7*255**3.
|
||||
return table[x >> 26]; |
||||
} |
||||
|
||||
/* Harley's algorithm with multiply expanded.
|
||||
19 elementary ops plus an indexed load. */ |
||||
|
||||
int nlz10a(unsigned x) { |
||||
|
||||
static char table[64] = |
||||
{32,31, u,16, u,30, 3, u, 15, u, u, u,29,10, 2, u, |
||||
u, u,12,14,21, u,19, u, u,28, u,25, u, 9, 1, u, |
||||
17, u, 4, u, u, u,11, u, 13,22,20, u,26, u, u,18, |
||||
5, u, u,23, u,27, u, 6, u,24, 7, u, 8, u, 0, u}; |
||||
|
||||
x = x | (x >> 1); // Propagate leftmost
|
||||
x = x | (x >> 2); // 1-bit to the right.
|
||||
x = x | (x >> 4); |
||||
x = x | (x >> 8); |
||||
x = x | (x >> 16); |
||||
x = (x << 3) - x; // Multiply by 7.
|
||||
x = (x << 8) - x; // Multiply by 255.
|
||||
x = (x << 8) - x; // Again.
|
||||
x = (x << 8) - x; // Again.
|
||||
return table[x >> 26]; |
||||
} |
||||
|
||||
/* Julius Goryavsky's version of Harley's algorithm.
|
||||
17 elementary ops plus an indexed load, if the machine |
||||
has "and not." */ |
||||
|
||||
int nlz10b(unsigned x) { |
||||
|
||||
static char table[64] = |
||||
{32,20,19, u, u,18, u, 7, 10,17, u, u,14, u, 6, u, |
||||
u, 9, u,16, u, u, 1,26, u,13, u, u,24, 5, u, u, |
||||
u,21, u, 8,11, u,15, u, u, u, u, 2,27, 0,25, u, |
||||
22, u,12, u, u, 3,28, u, 23, u, 4,29, u, u,30,31}; |
||||
|
||||
x = x | (x >> 1); // Propagate leftmost
|
||||
x = x | (x >> 2); // 1-bit to the right.
|
||||
x = x | (x >> 4); |
||||
x = x | (x >> 8); |
||||
x = x & ~(x >> 16); |
||||
x = x*0xFD7049FF; // Activate this line or the following 3.
|
||||
// x = (x << 9) - x; // Multiply by 511.
|
||||
// x = (x << 11) - x; // Multiply by 2047.
|
||||
// x = (x << 14) - x; // Multiply by 16383.
|
||||
return table[x >> 26]; |
||||
} |
||||
|
||||
int errors; |
||||
void error(int x, int y) { |
||||
errors = errors + 1; |
||||
printf("Error for x = %08x, got %d\n", x, y); |
||||
} |
||||
|
||||
int main() |
||||
{ |
||||
# ifdef GLM_TEST_ENABLE_PERF |
||||
|
||||
int i, n; |
||||
static unsigned test[] = {0,32, 1,31, 2,30, 3,30, 4,29, 5,29, 6,29, |
||||
7,29, 8,28, 9,28, 16,27, 32,26, 64,25, 128,24, 255,24, 256,23, |
||||
512,22, 1024,21, 2048,20, 4096,19, 8192,18, 16384,17, 32768,16, |
||||
65536,15, 0x20000,14, 0x40000,13, 0x80000,12, 0x100000,11, |
||||
0x200000,10, 0x400000,9, 0x800000,8, 0x1000000,7, 0x2000000,6, |
||||
0x4000000,5, 0x8000000,4, 0x0FFFFFFF,4, 0x10000000,3, |
||||
0x3000FFFF,2, 0x50003333,1, 0x7FFFFFFF,1, 0x80000000,0, |
||||
0xFFFFFFFF,0}; |
||||
std::size_t const Count = 10000000; |
||||
|
||||
n = sizeof(test)/4; |
||||
|
||||
std::clock_t TimestampBeg = 0; |
||||
std::clock_t TimestampEnd = 0; |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz1(test[i]) != test[i+1]) error(test[i], nlz1(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz1: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz1a(test[i]) != test[i+1]) error(test[i], nlz1a(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz1a: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz2(test[i]) != test[i+1]) error(test[i], nlz2(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz2: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz2a(test[i]) != test[i+1]) error(test[i], nlz2a(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz2a: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz3(test[i]) != test[i+1]) error(test[i], nlz3(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz3: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz4(test[i]) != test[i+1]) error(test[i], nlz4(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz4: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz5(test[i]) != test[i+1]) error(test[i], nlz5(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz5: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz6(test[i]) != test[i+1]) error(test[i], nlz6(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz6: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz7(test[i]) != test[i+1]) error(test[i], nlz7(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz7: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz8(test[i]) != test[i+1]) error(test[i], nlz8(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz8: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz9(test[i]) != test[i+1]) error(test[i], nlz9(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz9: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz10(test[i]) != test[i+1]) error(test[i], nlz10(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz10: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz10a(test[i]) != test[i+1]) error(test[i], nlz10a(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz10a: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
TimestampBeg = std::clock(); |
||||
for (std::size_t k = 0; k < Count; ++k) |
||||
for (i = 0; i < n; i += 2) { |
||||
if (nlz10b(test[i]) != test[i+1]) error(test[i], nlz10b(test[i]));} |
||||
TimestampEnd = std::clock(); |
||||
|
||||
printf("nlz10b: %d clocks\n", TimestampEnd - TimestampBeg); |
||||
|
||||
if (errors == 0) |
||||
printf("Passed all %d cases.\n", sizeof(test)/8); |
||||
|
||||
# endif//GLM_TEST_ENABLE_PERF
|
||||
} |
||||
Loading…
Reference in New Issue