Use SSE intrinsics instead of asm() for vertical SSE, finally offloading the register...

diff --git a/README b/README
index 98b88c3f406aba47113484f73520ebdf7cd11d41..be6feb972d34f9ede69615b1eb5059712ebeb6b0 100644 (file)
--- a/README
+++ b/README
@@ -75,9 +75,6 @@ The following optimizations are possible but not done (yet?):
    filter kernel is large (ie. large amounts of scaling).
  - qscale does not use multiple processors or cores (although different cores 
    can of course work on different images at the same time).
- - qscale does not make very good use of the extra eight SSE registers found
-   on 64-bit x86-compatible (usually called amd64 or x86-64) machines. In
-   fact, out of the box it might not even compile on such machines.
 
 Finally, a word of advice: Even the fastest scaler can never be as fast as not
 scaling. If you can do less work, or move it to a time where it is less user

diff --git a/libqscale.c b/libqscale.c
index 47b6fe8959c8d0db09545c0f3448a012658d6dde..9a37853f0d15e8f5ecde44a45d3088dd904be0f7 100644 (file)
--- a/libqscale.c
+++ b/libqscale.c
@@ -42,6 +42,13 @@
 #define M_PI 3.14159265358979323846264
 #endif
 
+#if USE_VERTICAL_SSE || USE_HORIZONTAL_SSE
+typedef float v4sf __attribute__((vector_size(16)));
+typedef int v4si __attribute__((vector_size(16)));
+typedef short v8hi __attribute__((vector_size(16)));
+typedef char v16qi __attribute__((vector_size(16)));
+#endif
+
 qscale_img *qscale_load_jpeg(const char *filename)
 {
        FILE *file = fopen(filename, "rb");
@@ -411,93 +418,51 @@ static void vscale(unsigned char *pix, float *npix, unsigned w, unsigned h, unsi
                float *dptr = npix + x;
                for (y = 0; y < nh; ++y) {
 #if USE_VERTICAL_SSE
-                       /*
-                        * xmm0 - xmm3: acc[0..15]
-                        * xmm4: current filter coefficient
-                        * xmm5, xmm6, xmm7: scratchpad
-                        */
-                       __asm__ (
-                               /* clear */
-                               "pxor %%xmm0, %%xmm0          \n"
-                               "pxor %%xmm1, %%xmm1          \n"
-                               "pxor %%xmm2, %%xmm2          \n"
-                               "pxor %%xmm3, %%xmm3          \n"
-
-                               /* main loop */
-                               "0:                           \n"
-                               
-                               /* a zero is useful during unpacking */
-                               "pxor %%xmm4, %%xmm4          \n"
-                               
-                               /* fetch all 16 source bytes */
-                               "movups (%0), %%xmm5          \n"
-                               "prefetcht0 (%0,%3,4)         \n"
-
-                               /* unpack into words (xmm5, xmm7) */
-                               "movaps %%xmm5, %%xmm7        \n"
-                               "punpcklbw %%xmm4, %%xmm5     \n"
-                               "punpckhbw %%xmm4, %%xmm7     \n"
-
-                               /* unpack xmm5 into dwords (xmm5, xmm6) */
-                               "movaps %%xmm5, %%xmm6        \n"
-                               "punpcklwd %%xmm4, %%xmm5     \n"
-                               "punpckhwd %%xmm4, %%xmm6     \n"
-
-                               /* convert xmm5, xmm6 to floats */
-                               "cvtdq2ps %%xmm5, %%xmm5      \n"
-                               "cvtdq2ps %%xmm6, %%xmm6      \n"
-
-                               /* fetch the coefficient */
-                               "movss (%2), %%xmm4           \n"
-                               "shufps $0x0, %%xmm4, %%xmm4  \n"
-
-                               /* do the muls for xmm5 and xmm6 */
-                               "mulps %%xmm4, %%xmm5         \n"
-                               "mulps %%xmm4, %%xmm6         \n"
-                               "addps %%xmm5, %%xmm0         \n"
-                               "addps %%xmm6, %%xmm1         \n"
-
-                               /* get the zero back again */
-                               "pxor %%xmm4, %%xmm4          \n"
-
-                               /* unpack xmm7 into dwords (xmm7, xmm6) */
-                               "movaps %%xmm7, %%xmm6        \n"
-                               "punpcklwd %%xmm4, %%xmm7     \n"
-                               "punpckhwd %%xmm4, %%xmm6     \n"
-
-                               /* convert xmm7, xmm6 to floats */
-                               "cvtdq2ps %%xmm7, %%xmm7      \n"
-                               "cvtdq2ps %%xmm6, %%xmm6      \n"
-
-                               /* fetch the coefficient */
-                               "movss (%2), %%xmm4           \n"
-                               "shufps $0x0, %%xmm4, %%xmm4  \n"
-
-                               /* do the second set of muls */
-                               "mulps %%xmm4, %%xmm7         \n"
-                               "mulps %%xmm4, %%xmm6         \n"
-                               "addps %%xmm7, %%xmm2         \n"
-                               "addps %%xmm6, %%xmm3         \n"
-
-                               /* move along, and loop */
-                               "add $4, %2                   \n"
-                               "add %3, %0                   \n"
-                               "dec %1                       \n"
-                               "jnz 0b                       \n"
-
-                               /* store the values */
-                               "movaps %%xmm0, (%4)          \n"
-                               "movaps %%xmm1, 16(%4)        \n"
-                               "movaps %%xmm2, 32(%4)        \n"
-                               "movaps %%xmm3, 48(%4)        \n"
-                               : :
-                               "r" (&sptr[pd[y].start * w]),        /* 0: srcptr base */
-                               "r" (pd[y].end - pd[y].start + 1),   /* 1: filter len */
-                               "r" (&coeffs[pd[y].startcoeff]),     /* 2: coeffs base */
-                               "r" ((long)w),                       /* 3: stride */
-                               "r" (dptr)                           /* 4: dstptr base */
-                               : "memory", "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7"
-                       );
+                       /* A zero is useful during unpacking. */
+                       static const v4sf zero = { 0.0f, 0.0f, 0.0f, 0.0f };
+                       const unsigned char *sptr_xmm = &sptr[pd[y].start * w];
+                       const float *coeffptr = &coeffs[pd[y].startcoeff];
+                       const int filter_len = pd[y].end - pd[y].start + 1;
+                       int i;
+
+                       v4sf acc0 = { 0.0f, 0.0f, 0.0f, 0.0f };
+                       v4sf acc1 = { 0.0f, 0.0f, 0.0f, 0.0f };
+                       v4sf acc2 = { 0.0f, 0.0f, 0.0f, 0.0f };
+                       v4sf acc3 = { 0.0f, 0.0f, 0.0f, 0.0f };
+                       
+                       for (i = 0; i < filter_len; ++i, ++coeffptr, sptr_xmm += w) {
+                               __builtin_prefetch(sptr_xmm + w, 0);
+                               v16qi src = (v16qi)__builtin_ia32_loadups((float*)sptr_xmm);
+
+                               // unpack into words
+                               v8hi src_lo = (v8hi)__builtin_ia32_punpcklbw128(src, (v16qi)zero);
+                               v8hi src_hi = (v8hi)__builtin_ia32_punpckhbw128(src, (v16qi)zero);
+
+                               // unpack into dwords, convert to floats
+                               v4si src0_i = (v4si)__builtin_ia32_punpcklwd128(src_lo, (v8hi)zero);
+                               v4si src1_i = (v4si)__builtin_ia32_punpckhwd128(src_lo, (v8hi)zero);
+                               v4si src2_i = (v4si)__builtin_ia32_punpcklwd128(src_hi, (v8hi)zero);
+                               v4si src3_i = (v4si)__builtin_ia32_punpckhwd128(src_hi, (v8hi)zero);
+
+                               v4sf src0 = __builtin_ia32_cvtdq2ps(src0_i);
+                               v4sf src1 = __builtin_ia32_cvtdq2ps(src1_i);
+                               v4sf src2 = __builtin_ia32_cvtdq2ps(src2_i);
+                               v4sf src3 = __builtin_ia32_cvtdq2ps(src3_i);
+                       
+                               // fetch the coefficient, and replicate it
+                               v4sf coeff = { *coeffptr, *coeffptr, *coeffptr, *coeffptr };
+
+                               // do the actual muladds
+                               acc0 = __builtin_ia32_addps(acc0, __builtin_ia32_mulps(src0, coeff));
+                               acc1 = __builtin_ia32_addps(acc1, __builtin_ia32_mulps(src1, coeff));
+                               acc2 = __builtin_ia32_addps(acc2, __builtin_ia32_mulps(src2, coeff));
+                               acc3 = __builtin_ia32_addps(acc3, __builtin_ia32_mulps(src3, coeff));
+                       }
+
+                       *(v4sf *)(&dptr[0]) = acc0;
+                       *(v4sf *)(&dptr[4]) = acc1;
+                       *(v4sf *)(&dptr[8]) = acc2;
+                       *(v4sf *)(&dptr[12]) = acc3;
 #else
                        int i;
                        float acc[CACHE_LINE_FACTOR];