Currently I’m experimenting with jQuery (always being told prototype.js is evil). In my project I have to make quite some complex animations and I tried to detect if I can map them to the animate() syntax. Uh, and all hell broke loose. Here is my 24h experience:

1. You can’t animate regular DOM properties, like image width/height, which is much more smooth than styles.
2. It does not hold custom states, nor allows you to animate a virtual property ‘counter’ out of that you could folk all kinds of changes in the step-function. You HAVE TO animate a real css-style. Thus you fall back to your own timers and loose the easing-framework. Found it. But not optimal …
   
3. You can not hold any states, if you stop an animation you will loose the information about the position of the animation between [0.0,1.0], and any other. You have to track that via the step-function and calculation through the ‘now’ time-stamp, OR you calculate the position directly on the modified CSS-value.
4. Each modified style enters the effects-queue as a seperate function, or expressed differently: each property given to animate to change becomes an entire seperate animation!
5. animate’s step function is called per step per property! Simultanious animation of multiple values becomes together with 4) almost impossible! A simple zoom function (width+height on content, left+top on parent relative to childs size-change) requires you to write approx. 50 lines!
6. You can’t pause/resume animations (no states), you have to recalculate the position (see 3), recalculate how much time is missing and restart the animation.
7. width/height animations force overflow hidden and display block. In 2010 I’d like to animate overflow visible and display inline-block too! Maybe even tables-cols if you don’t mind …
8. You can’t define proxy-animations like “font-size = height / 10″, normally I’d say it should be possible to reference any animateable attribute/style.
9. You can’t because of that also forget about the “font-size += delta-height” type.
10. All calculations are done in floating point, as no browser supports sub-pixel accuracy you’l have horrible shift while zooming an image for example. The “zoom” effect anyway should be integral part of animate. Either way [left,left+width] are on a pixel-precision grid, if left becomes round down, left+width has to be round up (for zooming that is), of course trying to acount for this leads to headbanging on the keybord, because the animations are all seperate … and the step function is called per property …

Grr. Such a small function and so much issues.

Uh, sometimes you don’t know what’s in the mind of intel guys.

They state in their documentation that the movntq-op (taken over from MMXExt) has to take place on 16-byte aligned memory. What??? Either it’s a copy & paste error, it’s probably suppose to mean 8-byte aligned memory, or you got a command which can’t be executed.

Besides, no op on MMX / 3DNow need alignment, so I think it’s even entirely wong … either way. Nice work intel.

pavgd (32bit average [(a + b + 1) >> 1]:

/* add (a + b), and compare overflow */
movq	mm6, mmc
paddd	mmc, mmd
psubd	mm6, 0x80000000
psubd	mmc, 0x80000000
pcmpgtd	mm6, mmc
paddd	mmc, 0x80000000

/* add (ab + 1), and compare overflow */
pcmpeqd	mm5, mm5
pcmpeqd	mmd, mmd
pcmpeqd	mm5, mmc
psubd	mmc, mmd

/* shift carry in */
por	mm6, mm5
pslld	mm6, 31
psrld	mmc, 1
por	mmc, mm6

psubq (64bit - 64bit = 64bit):

movq	mm7, mmc
psubd	mmc, mms
movq	mm6, mmc
psubd	mm7, 0x80000000
psubd	mm6, 0x80000000
pcmpgtd	mm6, mm7
psllq	mm6, 32
psubd	mmc, mm6

paddq (64bit + 64bit = 64bit):

movq	mm7, mmc
paddd	mmc, mma
psubd	mm7, 0x80000000
psubd	mmc, 0x80000000
pcmpgtd	mm7, mmc
paddd	mmc, 0x80000000
psllq	mm7, 32
psubd	mmc, mm7

packusqd (saturated clamp from unsigned long long to unsigned long),
packssqud (saturated clamp from signed long long to unsigned long):

There is a condition for unsigned long long inputs, range is “only” [0x0000000000000000, 0x7FFFFFFFFFFF].
There is a no condition for signed long long inputs.

// from-scratch, no helper available

    /* -1 */
    pcmpeqd	mm6, mm6

    /* x >> 32 > -1 */
    movq	mm4, mmc0
    movq	mm5, mm2

    /* no psraq/pshufd/pshufw available,
     * duplicate ((x >> 32) | x) */
    punpckhdq	mm4, mmc0
    punpckhdq	mm5, mm2

    pcmpgtd	mm4, mm6
    pcmpgtd	mm5, mm6

    pand	mmc0, mm4
    pand	mm2, mm5

    /* 0 */
    pxor	mm7, mm7

    /* x >> 32 == 0 */
    movq	mm4, mmc0
    movq	mm5, mm2

    /* no psraq/pshufd/pshufw available,
     * duplicate ((x >> 32) | x) */
    punpckhdq	mm4, mmc0
    punpckhdq	mm5, mm2

    pcmpeqd	mm4, mm7
    pcmpeqd	mm5, mm7

    pand	mmc0, mm4
    pand	mm2, mm5

    /* 0xFFFFFFFF */
    pandn	mm4, mm6
    pandn	mm5, mm6

    por		mmc0, mm4
    por		mm2, mm5

    punpckldq	mmc0, mm2

packusdw (saturated clamp from unsigned long to unsigned short),
packssduw (saturated clamp from signed long to unsigned short):

There is a condition for unsigned long inputs, range is “only” [0x00000000, 0x7FFFFFFF].
There is a condition for signed long inputs, range is “only” [0x80008000, 0x7FFFFFFF]. You can go to full signed long if there would exist “psubsd”, which does not.

// via packssdw

psubd		xmmx, 0x00008000	// signed short in long
psubd		xmmy, 0x00008000
packssdw	xmmx, xmmy		// cast long to short
paddw		xmmy, 0x8000		// unsigned short

// with punpck and variable

movdqa		xmm?1, 0x00008000
movdqa		xmm?2, xmm?1
puncklwd	xmm?2, xmm?1		// 0v0000000080008000
punckldq	xmm?2, xmm?2		// 0v8000800080008000

psubd		xmmx, xmm?1
psubd		xmmy, xmm?1
packssdw	xmmx, xmmy
paddw		xmmy, xmm?2

// with pshufw and variable

movdqa		xmm?1, 0x00008000
pshuflw		xmm?2, xmm?1, 2|2|0|0	// 0v?????????80008000
pshufhw		xmm?2, xmm?1, 2|2|0|0	// 0v8000800080008000

psubd		xmmx, xmm?1
psubd		xmmy, xmm?1
packssdw	xmmx, xmmy
paddw		xmmy, xmm?2

// with pshufw and variable and no memory access

pcmpeqd		xmm?1, xmm?1		// 0xFFFFFFFF
pslld		xmm?1, 31		// 0x80000000
pslrd		xmm?1, 16		// 0x00008000
pshuflw		xmm?2, xmm?1, 2|2|0|0	// 0v?????????80008000
pshufhw		xmm?2, xmm?1, 2|2|0|0	// 0v8000800080008000

psubd		xmmx, xmm?1
psubd		xmmy, xmm?1
packssdw	xmmx, xmmy
paddw		xmmy, xmm?2

The SSE-ops lack a huge amount of very usefull functions. Basically every single mathematical relevant function is absent, worst, trying to re-create them and reach the same precision as the FPU-routines results in magnitude slower code. Sometimes one can find a usefull short-cut, but not very often.

Here I tried to make a cbrt(x), the cubic root. It’s basically a power-function, which is equivalent to the following euler-form:

double pow(double n, double r) {
    if (n > 0.0)
      return  exp(r / log ( n));
    else
      return -exp(r / log (-n));
}

The problem is, exp(x) and log(x) aren’t available either. Basically any function can be approximated either by Rational-Polynoms, Taylor-Series or some special Newtonian way. All of them are infinitely iterative, but mostly you won’t need infinite precision. So pow(x,y), exp(x) and log(x) can all be approximated by more or less equally complex polynoms - so it’s a bad deal to replace one approximation by two. We’ll stay with directly approximating cbrt(n).

Here two Rational-Polynom approximations:

// order 3/4
double cbrt(double x) {
return

      99.942970125 *x
 +  4591.64560671 * x*x
 + 14742.828103353 * x*x*x

/* ------------------------------ */ /

       1
 +   491.698363982 * x
 +  9105.81746731 * x*x*x
 + 11071.95822942296354 * x*x*x
 -  1236.0573805268561  * x*x*x*x

;
}

// order 4/4
double cbrt(double x) {
return

     173.791188868 * x
+  20254.442314157 * x*x
+ 212906.097079561 * x*x*x
+ 195085.639644873 * x*x*x*x

/* ------------------------------ */ /

       1
+   1147.163861142 * x
+  57143.213576431 * x*x
+ 278351.638227136 * x*x*x
+  91776.954562751 * x*x*x*x

;
}

Problem is, they are too inexact. As we do have sqrt(x) in SSE we can try the much faster (quadratically) converging Newtonian iterative approach (it’s Halley’s method):

       2x^3 + 4r
 x' = ----------- x
       4x^3 + 2r

       2(1x^3 + 2r)
 x' = -------------- x
       2(2x^3 + 1r)

        x^3 + 2r
 x' = ----------- x
       2x^3 +  r

Resulting in the following C-implementation:

double cbrt(double n) {
  const long int t = 2;	// two
  const long int f = 4;	// four

  const double s = fsign(n); n = fabs(n);
  const double X = sqrt(n);

  double
  c = (X * X * X),
  x = ((c * t) + (n * f)) * (X)
    / ((c * f) + (n * t));

  for (int i = 1; i < iterations; i++)
    c = (x * x * x),
    x = ((c * t) + (n * f)) * (x)
      / ((c * f) + (n * t));

  return x * s;
}

Unrolled this leads to the relative good and quick SSE-variant:

  movaps  xmm7, xmmX  /* store sign				 */
  andps	  xmmX, xmmword ptr [ absVPUf ]
  andps	  xmm7, xmmword ptr [ sgnVPUf ]

  movaps xmm5,	xmmX  /* xmm5 =	 r	  for Nth iteration only */
  movaps  xmm6,	xmmX  /*					 */
  addps	  xmm6,	xmm6  /* xmm6 =	2r	  for Nth iteration only */

/*sqrtps  xmmX,	xmmX   * sqrt(x)				 */
  rsqrtps xmm4,	xmmX  /* xmm4 = 1/sqrt(x),	first pass	 */
  mulps	  xmmX,	xmm4  /* sqrt(x)				 */

  movaps  xmm3,	xmmX  /* 1st iteration				 */
  mulps	  xmm3,	xmmX  /* xmmX =	x				 */
  mulps	  xmm3,	xmmX  /* xmm3 =	xmm4 = x * x * x		 */
  movaps  xmm4,	xmm3  /*  c					 */
  addps	  xmm4,	xmm4  /* 2c					 */
  addps	  xmm3,	xmm6  /*  c + 2r				 */
  addps	  xmm4,	xmm5  /* 2c +  r				 */
  mulps	  xmmX,	xmm3  /* ( c + 2r) / (2c +  r) * x’		 */
  divps	  xmmX,	xmm4  /* ( c + 2r) / (2c +  r)			 */
/*rcpps	  xmm4,	xmm4   *         1 / (2c +  r)			 */
/*mulps	  xmmX,	xmm4   * ( c + 2r) / (2c +  r)			 */

  movaps  xmm3,	xmmX  /* 2nd iteration				 */
  mulps	  xmm3,	xmmX  /* xmmX =	x				 */
  mulps	  xmm3,	xmmX  /* xmm3 =	xmm4 = x * x * x		 */
  movaps  xmm4,	xmm3  /*  c					 */
  addps	  xmm4,	xmm4  /* 2c					 */
  addps	  xmm3,	xmm6  /*  c + 2r				 */
  addps	  xmm4,	xmm5  /* 2c +  r				 */
  mulps	  xmmX,	xmm3  /* ( c + 2r) / (2c +  r) * x’		 */
  divps	  xmmX,	xmm4  /* ( c + 2r) / (2c +  r)			 */
/*rcpps	  xmm4,	xmm4   *         1 / (2c +  r)			 */
/*mulps	  xmmX,	xmm4   * ( c + 2r) / (2c +  r)			 */

  movaps  xmm3,	xmmX  /* 3rd iteration				 */
  mulps	  xmm3,	xmmX  /* xmmX =	x				 */
  mulps	  xmm3,	xmmX  /* xmm3 =	xmm4 = x * x * x		 */
  movaps  xmm4,	xmm3  /*  c					 */
  addps	  xmm4,	xmm4  /* 2c					 */
  addps	  xmm3,	xmm6  /*  c + 2r				 */
  addps	  xmm4,	xmm5  /* 2c +  r				 */
  mulps	  xmmX,	xmm3  /* ( c + 2r) / (2c +  r) * x’		 */
  divps	  xmmX,	xmm4  /* ( c + 2r) / (2c +  r)			 */
/*rcpps	  xmm4,	xmm4   *         1 / (2c +  r)			 */
/*mulps	  xmmX,	xmm4   * ( c + 2r) / (2c +  r)			 */

  orps	  xmmX,	xmm7  /* restore sign				 */

The iteration is unrolled can be repeated as much as you want to raise precision. The only issue is with the sign-masking as this requires memory access, otherwise the function is entirely variable free. The initial approximation via sqrt(x) is not required to be exact, picture it as a seed (you can even fill in a random variable, the function still will converge) so it can utilize the very fast reciprocal square-root. The divisions can be replaced by reciprocals too, but the precision suffers so much it isn’t worth the speedup (rcp is very very imprecise, much less than the 3DNow pfrcp, and there is no refinement-function in SSE like in 3DNow) as you’d have to add additional iterations to compensate for it and the repeated block is slower than a single division.

padddq (128bit + 64bit = 128bit):

// carry emulation via pcmpgtq equivalent

movdqa		xmmx, xmma
movdqa		xmmy, xmmb
movdqa		xmmz, xmma
paddq		xmma, xmmb
pcmpgtd		xmmx, xmmb
pcmpgtd		xmmy, xmma
pcmpeqd		xmmz, xmmb
pshufd		xmmx, xmmx, 1|1|1|1
pshufd		xmmz, xmmz, 1|1|1|1
pand		xmmz, xmmy
por		xmmz, xmmx
punpcklqdq	xmmz, xmmz
pslldq		xmmz, 8		or pshufd
psubq		xmma, xmmz

When you don’t have SSE4 available you have to compensate for the lack of ome essencial ops. In this series I’m going to write down equivalents of either missing or (currently) non-AMD ops.

pcmpeqq (64bit integer compare):

// equality == (hi == hi) && (lo == lo)

movdqa		xmm?3, xmma
pcmpeqd		xmm?3, xmmb
pshufd		xmm?1, xmm?3, 3|3|1|1	(b == a)
pshufd		xmm?2, xmm?3, 2|2|0|0	(B == A)
pand		xmm?1, xmm?2		(b == a) && (B == A)

pcmpgtq (64bit integer compare):

// greater == (hi > hi) || ((hi == hi) && (lo > lo))

movdqa		xmm?1, xmma
movdqa		xmm?2, xmma
pcmpgtd		xmm?1, xmmb
pcmpeqd		xmm?2, xmmb
pshufd		xmm?3, xmm?1, 3|3|1|1	(b > a)
pshufd		xmm?4, xmm?2, 3|3|1|1	(b == a)
por		xmm?2, xmm?1		(B > A) || (B == A)
pshufd		xmm?2, xmm?2, 2|2|0|0	(B >= A)
pand		xmm?2, xmm?4		(b == a) && (B >= A)
por		xmm?2, xmm?3		(b > a) || ((b == a) && (B >= A))