and why on earth did I name it qdiv, why!
a = 3.141592
b = 6.666
c = a * bc = 20.941852272float floatmult(float a,float b){return (a*b);}FP32 mul(FP32 a, FP32 b)
{
return ((long long)a * (long long)b) >> 16;
}Ok. I see two reasons to have floating point faster than fixed point :
1) Your test function is optimised very cleverly by the compiler. If you test is something like :
The compiler is able to precompute 3.141592 * 6.666 for the floating point version of this code, so the compiled code will beCode:a = 3.141592 b = 6.666 c = a * b
It's the fastest code in the west of everywhere you want :lol:Code:c = 20.941852272
In contrast, with a fixed point version of this code, the compiler is no longer able to precompute the result,and then the compiled code will effectivly do the computation, that is slower than copying a constant.
Conclusion for case 1) --> You MUST check the generated assembler code.
2) Your algorithm is badly designed. A naive use of fixed point leads to slowniness and non controled numerical precision. Show it to us, don't be that shy
. Well now that I think about it I may have a few values that are constant.. heh I'll have to change that and test again. OK let's test again.. as low as 13.12 seconds for fixed, 12.54 for floats, no, there's no mistake, and all my values are modified as often as they should be so that there's none of the kind of optimization you mentionned.void distance(coord p1, coord p2, coord p3, coord *p0) //fixed
{
int32_t u; //u is in 8.24
u = qdiv(qmul((p3.x - p1.x), (p2.x - p1.x)) + qmul((p3.y - p1.y), (p2.y - p1.y)), qmul((p2.x - p1.x), (p2.x - p1.x)) + qmul((p2.y - p1.y), (p2.y - p1.y)));
if (u<0)
{
p0->x = p3.x - p1.x;
p0->y = p3.y - p1.y;
}
else
if (u>(1<<24))
{
p0->x = p3.x - p2.x;
p0->y = p3.y - p2.y;
}
else
{
p0->x = p1.x + qmul2(u, (p2.x - p1.x));
p0->x -= p3.x;
p0->y = p1.y + qmul2(u, (p2.y - p1.y));
p0->y -= p3.y;
}
if (p0->x<0) //negativity check
p0->x = -p0->x;
if (p0->y<0) //negativity check
p0->y = -p0->y;
}void distance(coord p1, coord p2, coord p3, coord *p0) //float
{
float u;
u = ((p3.x - p1.x) * (p2.x - p1.x) + (p3.y - p1.y) * (p2.y - p1.y)) / ((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
if (u<0.0)
{
p0->x = p3.x - p1.x;
p0->y = p3.y - p1.y;
}
else
if (u>1.0)
{
p0->x = p3.x - p2.x;
p0->y = p3.y - p2.y;
}
else
{
p0->x = p1.x + u * (p2.x - p1.x);
p0->x -= p3.x;
p0->y = p1.y + u * (p2.y - p1.y);
p0->y -= p3.y;
}
if (p0->x<0) //negativity check
p0->x = -p0->x;
if (p0->y<0) //negativity check
p0->y = -p0->y;
} p2.y = (120 + (i<<4))%240 << 8;
p2.x = (160 + (i<<4))%320 << 8;
p1.y = (0 + (i<<3))%240 << 8;
p1.x = (0 + (i<<2))%320 << 8;
for (iy=0; iy<240; iy++)
for (ix=0; ix<320; ix++)
{
p3.x = ix<<8;
p3.y = iy<<8;
distance(p1, p2, p3, &p0);
if (p0.x<GAUSS_SIZE && p0.y<GAUSS_SIZE)
{
#ifdef fixed
g_val = g_lut[p0.y*GAUSS_SIZE + p0.x];
#else
g_val = g_lut[((int32_t) p0.y)*GAUSS_SIZE + ((int32_t) p0.x)];
#endif
screen16[iy*320 + ix] = ((g_val&248)<<8) | ((g_val&252)<<3) | ((g_val&248)>>3);
}
else
screen16[iy*320 + ix] = 0xffff;
}Heh, my guess is for the optimization. gcc seems to do some very small 'safe' optimizations even when you don't ask for them, as I've found out by going through generated assembler. To make it a valid comparison, you'll have to run the float operations in a separate function I think, so make a
to do it and I think that will keep the compiler from optimizing itCode:float floatmult(float a,float b){return (a*b);}
A_SN said:Code:int32_t u; //u is in 8.24 u = qdiv(qmul((p3.x - p1.x), (p2.x - p1.x)) + qmul((p3.y - p1.y), (p2.y - p1.y)), qmul((p2.x - p1.x), (p2.x - p1.x)) + qmul((p2.y - p1.y), (p2.y - p1.y)));
Code:float u; u = ((p3.x - p1.x) * (p2.x - p1.x) + (p3.y - p1.y) * (p2.y - p1.y)) / ((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
One thing that may matter is that probably gcc did not recognize the squaring in your fixed-point computation.
Try to write a specific square fixed-point routine and let us know how it goes
) approximatively 10% faster with libfloat than with fixed point.Code:int32_t u; //u is in 8.24 u = qdiv(qmul((p3.x - p1.x), (p2.x - p1.x)) + qmul((p3.y - p1.y), (p2.y - p1.y)), qmul((p2.x - p1.x), (p2.x - p1.x)) + qmul((p2.y - p1.y), (p2.y - p1.y)));
Code:float u; u = ((p3.x - p1.x) * (p2.x - p1.x) + (p3.y - p1.y) * (p2.y - p1.y)) / ((p2.x - p1.x) * (p2.x - p1.x) + (p2.y - p1.y) * (p2.y - p1.y));
One thing that may matter is that probably gcc did not recognize the squaring in your fixed-point computation.
Try to write a specific square fixed-point routine and let us know how it goes
rixed posted on Feb 1 2007 at 12:22 AM said:OK, understood !
The softfloat library have a _big_ advantage here : nowhere it has to multiplies nor divides 64 bit numbers.
Take qmul for example (return (int32_t) (((int64_t) a*B) >> 8)) : although a single smull should be enough, because both a and b are 32 bits, we cannot in C have operands with different size than result, so we cast a into 64 bits, which, as consequence, imply that b also will be casted to 64 bits and the mul will in fact multiplies two 64 bits integers, giving a 64 bit result. This version of qmul leads to 2 MULs instead of one.
Take now qdiv ( return (int32_t) (( (int64_t) a << 32 )/B)>> 8) ) : here again we are asking GCC to divide two 64 bits integers, althoug we only have 32 significants bits per value.
By not using 64 bit cast anymore in qdiv yields an improvement of about 40% in speed, while removing 64 bits cast from qmul add another aprox 10% (very rought numbers). The result is then twice faster, that is much faster than the float version. But, of course, the results are false
What you should need : code an inlined qmul function in asm that use smull (very easy).
Then, code your own divide that do not use int64_t integers (should be easy in C, more tricky in asm).
And I will do exactly the same in gpu940 : I just checked that my Fix_mul function suffer the same problem
Thank you for raising some attention on this !
A_SN posted on Feb 1 2007 at 07:24 AM said:
static inline int32_t Fix_mul(int32_t a, int32_t b) {
int32_t ret;
__asm__(
"smull %[lo], r1, %[a], %[b]\n"
"mov %[lo], %[lo], lsr #16\n"
"orr %[lo], %[lo], r1, lsl #16\n"
: [lo] "=&r" (ret) // rhi, rlo and rm must be distinct registers
: [a] "r" (a), [b] "r" (b)
: "r1"
);
return ret;
}#include <stdio.h>
#include <stdint.h>
static inline uint32_t qdiv(uint32_t R, uint32_t D)
{
if (R < D) return 0;
uint32_t normD;
uint64_t next_normD = D;
uint32_t Q = 0;
uint32_t e = 0, next_e = 1;
do {
normD = next_normD;
e = next_e;
next_normD <<= 1U;
next_e <<= 1U;
} while (next_normD <= R);
do {
// can not be done more than 32 times
if (normD <= R) {
Q += e;
R -= normD;
}
if (R < D) return Q;
normD >>= 1U;
e >>= 1U;
} while (1);
}
int main(void)
{
unsigned i;
# define RUN 9999999
for (i=1; i<RUN; i++) {
uint32_t volatile ax, bx, q;
ax = 1<<27;
bx = i;
q = ax/bx;
}
printf("GCC done\n\n\n\n");
for (i=1; i<RUN; i++) {
uint32_t volatile ax, bx, q;
ax = 1<<27;
bx = i;
q = qdiv(ax, bx);
}
printf("QDIV done\n\n\n\n");
for (i=1; i<RUN; i++) {
float volatile af, bf, q;
af = 1<<27;
bf = i;
q = af/bf;
}
printf("SOFTFLOAT done\n\n\n\n");
return 0;
}Gary Miller posted on Feb 1 2007 at 02:21 PM said:
