Add MSA (MIPS SIMD Arch) optimized VectorMath functions

third_party/WebKit/Source/platform/audio/VectorMath.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 23 matching lines @@
 #endif
 
 #if CPU(X86) || CPU(X86_64)
 #include <emmintrin.h>
 #endif
 
 #if HAVE(ARM_NEON_INTRINSICS)
 #include <arm_neon.h>
 #endif
 
+#if HAVE(MIPS_MSA_INTRINSICS)
+#include "platform/cpu/mips/CommonMacrosMSA.h"
+#endif
+
 #include <math.h>
 #include <algorithm>
 
 namespace blink {
 
 namespace VectorMath {
 
 #if OS(MACOSX)
 // On the Mac we use the highly optimized versions in Accelerate.framework
 // In 32-bit mode (__ppc__ or __i386__) <Accelerate/Accelerate.h> includes
@@ skipping 168 matching lines @@
       float32x4_t dest = vld1q_f32(destP);
 
       dest = vmlaq_f32(dest, source, k);
       vst1q_f32(destP, dest);
 
       sourceP += 4;
       destP += 4;
     }
     n = tailFrames;
   }
+#elif HAVE(MIPS_MSA_INTRINSICS)
+  if ((sourceStride == 1) && (destStride == 1)) {
+    float* destPCopy = destP;
+    const v4f32 vScale = (v4f32)__msa_fill_w(*((int32_t*)scale));
+    v4f32 vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6, vSrc7;
+    v4f32 vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7;
+
+    for (; n >= 32; n -= 32) {
+      LD_SP8(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6,
+             vSrc7);
+      LD_SP8(destPCopy, 4, vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6,
+             vDst7);
+      VSMA4(vSrc0, vSrc1, vSrc2, vSrc3, vDst0, vDst1, vDst2, vDst3, vScale);
+      VSMA4(vSrc4, vSrc5, vSrc6, vSrc7, vDst4, vDst5, vDst6, vDst7, vScale);
+      ST_SP8(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, destP, 4);
+    }
+  }
 #endif
   while (n) {
     *destP += *sourceP * *scale;
     sourceP += sourceStride;
     destP += destStride;
     n--;
   }
 }
 
 void vsmul(const float* sourceP,
@@ skipping 61 matching lines @@
 
     while (destP < endP) {
       float32x4_t source = vld1q_f32(sourceP);
       vst1q_f32(destP, vmulq_n_f32(source, k));
 
       sourceP += 4;
       destP += 4;
     }
     n = tailFrames;
   }
+#elif HAVE(MIPS_MSA_INTRINSICS)
+  if ((sourceStride == 1) && (destStride == 1)) {
+    const v4f32 vScale = (v4f32)__msa_fill_w(*((int32_t*)scale));
+    v4f32 vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6, vSrc7;
+    v4f32 vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7;
+
+    for (; n >= 32; n -= 32) {
+      LD_SP8(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6,
+             vSrc7);
+      VSMUL4(vSrc0, vSrc1, vSrc2, vSrc3, vDst0, vDst1, vDst2, vDst3, vScale);
+      VSMUL4(vSrc4, vSrc5, vSrc6, vSrc7, vDst4, vDst5, vDst6, vDst7, vScale);
+      ST_SP8(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, destP, 4);
+    }
+  }
 #endif
     float k = *scale;
     while (n--) {
       *destP = k * *sourceP;
       sourceP += sourceStride;
       destP += destStride;
     }
 #if CPU(X86) || CPU(X86_64)
   }
 #endif
@@ skipping 101 matching lines @@
       float32x4_t source1 = vld1q_f32(source1P);
       float32x4_t source2 = vld1q_f32(source2P);
       vst1q_f32(destP, vaddq_f32(source1, source2));
 
       source1P += 4;
       source2P += 4;
       destP += 4;
     }
     n = tailFrames;
   }
+#elif HAVE(MIPS_MSA_INTRINSICS)
+  if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
+    v4f32 vSrc1P0, vSrc1P1, vSrc1P2, vSrc1P3, vSrc1P4, vSrc1P5, vSrc1P6,
+          vSrc1P7;
+    v4f32 vSrc2P0, vSrc2P1, vSrc2P2, vSrc2P3, vSrc2P4, vSrc2P5, vSrc2P6,
+          vSrc2P7;
+    v4f32 vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7;
+
+    for (; n >= 32; n -= 32) {
+      LD_SP8(source1P, 4, vSrc1P0, vSrc1P1, vSrc1P2, vSrc1P3, vSrc1P4, vSrc1P5,
+             vSrc1P6, vSrc1P7);
+      LD_SP8(source2P, 4, vSrc2P0, vSrc2P1, vSrc2P2, vSrc2P3, vSrc2P4, vSrc2P5,
+             vSrc2P6, vSrc2P7);
+      ADD4(vSrc1P0, vSrc2P0, vSrc1P1, vSrc2P1, vSrc1P2, vSrc2P2, vSrc1P3,
+           vSrc2P3, vDst0, vDst1, vDst2, vDst3);
+      ADD4(vSrc1P4, vSrc2P4, vSrc1P5, vSrc2P5, vSrc1P6, vSrc2P6, vSrc1P7,
+           vSrc2P7, vDst4, vDst5, vDst6, vDst7);
+      ST_SP8(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, destP, 4);
+    }
+  }
 #endif
     while (n--) {
       *destP = *source1P + *source2P;
       source1P += sourceStride1;
       source2P += sourceStride2;
       destP += destStride;
     }
 #if CPU(X86) || CPU(X86_64)
   }
 #endif
@@ skipping 63 matching lines @@
       float32x4_t source1 = vld1q_f32(source1P);
       float32x4_t source2 = vld1q_f32(source2P);
       vst1q_f32(destP, vmulq_f32(source1, source2));
 
       source1P += 4;
       source2P += 4;
       destP += 4;
     }
     n = tailFrames;
   }
+#elif HAVE(MIPS_MSA_INTRINSICS)
+  if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
+    v4f32 vSrc1P0, vSrc1P1, vSrc1P2, vSrc1P3, vSrc1P4, vSrc1P5, vSrc1P6,
+          vSrc1P7;
+    v4f32 vSrc2P0, vSrc2P1, vSrc2P2, vSrc2P3, vSrc2P4, vSrc2P5, vSrc2P6,
+          vSrc2P7;
+    v4f32 vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7;
+
+    for (; n >= 32; n -= 32) {
+      LD_SP8(source1P, 4, vSrc1P0, vSrc1P1, vSrc1P2, vSrc1P3, vSrc1P4, vSrc1P5,
+             vSrc1P6, vSrc1P7);
+      LD_SP8(source2P, 4, vSrc2P0, vSrc2P1, vSrc2P2, vSrc2P3, vSrc2P4, vSrc2P5,
+             vSrc2P6, vSrc2P7);
+      MUL4(vSrc1P0, vSrc2P0, vSrc1P1, vSrc2P1, vSrc1P2, vSrc2P2, vSrc1P3,
+           vSrc2P3, vDst0, vDst1, vDst2, vDst3);
+      MUL4(vSrc1P4, vSrc2P4, vSrc1P5, vSrc2P5, vSrc1P6, vSrc2P6, vSrc1P7,
+           vSrc2P7, vDst4, vDst5, vDst6, vDst7);
+      ST_SP8(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, destP, 4);
+    }
+  }
 #endif
   while (n) {
     *destP = *source1P * *source2P;
     source1P += sourceStride1;
     source2P += sourceStride2;
     destP += destStride;
     n--;
   }
 }
 
@@ skipping 182 matching lines @@
     }
     float32x2_t twoMax =
         vmax_f32(vget_low_f32(fourMax), vget_high_f32(fourMax));
 
     float groupMax[2];
     vst1_f32(groupMax, twoMax);
     max = std::max(groupMax[0], groupMax[1]);
 
     n = tailFrames;
   }
+#elif HAVE(MIPS_MSA_INTRINSICS)
+  if (sourceStride == 1) {
+    v4f32 vMax = {
+        0,
+    };
+    v4f32 vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6, vSrc7;
+    const v16i8 vSignBitMask = (v16i8)__msa_fill_w(0x7FFFFFFF);
+
+    for (; n >= 32; n -= 32) {
+      LD_SP8(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6,
+             vSrc7);
+      AND_W4_SP(vSrc0, vSrc1, vSrc2, vSrc3, vSignBitMask);
+      VMAX_W4_SP(vSrc0, vSrc1, vSrc2, vSrc3, vMax);
+      AND_W4_SP(vSrc4, vSrc5, vSrc6, vSrc7, vSignBitMask);
+      VMAX_W4_SP(vSrc4, vSrc5, vSrc6, vSrc7, vMax);
+    }
+
+    max = std::max(max, vMax[0]);
+    max = std::max(max, vMax[1]);
+    max = std::max(max, vMax[2]);
+    max = std::max(max, vMax[3]);
+  }
 #endif
 
   while (n--) {
     max = std::max(max, fabsf(*sourceP));
     sourceP += sourceStride;
   }
 
   ASSERT(maxP);
   *maxP = max;
 }
@@ skipping 18 matching lines @@
     float32x4_t low = vdupq_n_f32(lowThreshold);
     float32x4_t high = vdupq_n_f32(highThreshold);
     while (destP < endP) {
       float32x4_t source = vld1q_f32(sourceP);
       vst1q_f32(destP, vmaxq_f32(vminq_f32(source, high), low));
       sourceP += 4;
       destP += 4;
     }
     n = tailFrames;
   }
+#elif HAVE(MIPS_MSA_INTRINSICS)
+  if ((sourceStride == 1) && (destStride == 1)) {
+    v4f32 vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6, vSrc7;
+    v4f32 vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7;
+    const v4f32 vLowThr = (v4f32)__msa_fill_w(*((int32_t*)lowThresholdP));
+    const v4f32 vHighThr = (v4f32)__msa_fill_w(*((int32_t*)highThresholdP));

[Raymond Toy, 2016/10/04 15:48:07]

Use C++ casting here instead of C.

However, is this guaranteed to do the right thing with this kind of type
punning? I always forget the complicated rules. I always use a union of int and
float for this kind of punning.

+
+    for (; n >= 32; n -= 32) {
+      LD_SP8(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6,
+             vSrc7);
+      VCLIP4(vSrc0, vSrc1, vSrc2, vSrc3, vLowThr, vHighThr, vDst0, vDst1, vDst2,
+             vDst3);
+      VCLIP4(vSrc4, vSrc5, vSrc6, vSrc7, vLowThr, vHighThr, vDst4, vDst5, vDst6,
+             vDst7);
+      ST_SP8(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, destP, 4);
+    }
+  }
 #endif
   while (n--) {
     *destP = clampTo(*sourceP, lowThreshold, highThreshold);
     sourceP += sourceStride;
     destP += destStride;
   }
 }
 
 #endif  // OS(MACOSX)
 
 }  // namespace VectorMath
 
 }  // namespace blink