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 22 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 <vecLib/vDSP_translate.h> which defines macros of the same name as
@@ skipping 122 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);

[Raymond Toy, 2016/10/03 16:47:06]

Are there alignment constraints for sourceP and destPCopy?  In general
AudioArrays are on 16-byte boundaries (I think), but I'm not sure this hold
everywhere for all callers.  Same issue applies to all of the routines below.

[Prashant.Patil, 2016/10/04 11:47:27]

There are no alignment constraints

+            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);
+        }
+
+        if (n > 0) {
+            if (n >= 28) {

[Raymond Toy, 2016/10/03 16:47:06]

Is there really much to be gained in having this complicated unrolling for all
of the possible remainders that aren't a multiple of 32 but are a multiple of 4?

The primary use case is for blocks of 128, so this code is never executed.  for
other uses, I think they're always a power of two (greater than 128), so this
code is never executed there either.

[Prashant.Patil, 2016/10/04 11:47:27]

OK. I shall remove all cases below 32.

+                LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);
+                vSrc6 = LD_SP(sourceP);
+                sourceP += 4;
+                LD_SP6(destPCopy, 4, vDst0, vDst1, vDst2, vDst3, vDst4, vDst5);
+                vDst6 = LD_SP(destPCopy);
+                destPCopy += 4;
+                VSMA4(vSrc0, vSrc1, vSrc2, vSrc3, vDst0, vDst1, vDst2, vDst3, vScale);
+                VSMA2(vSrc4, vSrc5, vDst4, vDst5, vScale);
+                vDst6 += vSrc6 * vScale;
+                ST_SP6(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, destP, 4);
+                ST_SP(vDst6, destP);
+                destP += 4;
+                n -= 28;
+            } else if (n >= 24) {
+                LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);
+                LD_SP6(destPCopy, 4, vDst0, vDst1, vDst2, vDst3, vDst4, vDst5);
+                VSMA4(vSrc0, vSrc1, vSrc2, vSrc3, vDst0, vDst1, vDst2, vDst3, vScale);
+                VSMA2(vSrc4, vSrc5, vDst4, vDst5, vScale);
+                ST_SP6(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, destP, 4);
+                n -= 24;
+            } else if (n >= 16) {
+                LD_SP4(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3);
+                LD_SP4(destPCopy, 4, vDst0, vDst1, vDst2, vDst3);
+                VSMA4(vSrc0, vSrc1, vSrc2, vSrc3, vDst0, vDst1, vDst2, vDst3, vScale);
+                ST_SP4(vDst0, vDst1, vDst2, vDst3, destP, 4);
+                n -= 16;
+            } else if (n >= 8) {
+                LD_SP2(sourceP, 4, vSrc0, vSrc1);
+                LD_SP2(destPCopy, 4, vDst0, vDst1);
+                VSMA2(vSrc0, vSrc1, vDst0, vDst1, vScale);
+                ST_SP2(vDst0, vDst1, destP, 4);
+                n -= 8;
+            }
+            if (n >= 4) {
+                vSrc0 = LD_SP(sourceP);
+                vDst0 = LD_SP(destPCopy);
+                vDst0 += vSrc0 * vScale;
+                ST_SP(vDst0, destP);
+                sourceP += 4;
+                destP += 4;
+                n -= 4;
+            }
+        }
+    }
 #endif
     while (n) {
         *destP += *sourceP * *scale;
         sourceP += sourceStride;
         destP += destStride;
         n--;
     }
 }
 
 void vsmul(const float* sourceP, int sourceStride, const float* scale, float* destP, int destStride, size_t framesToProcess)
@@ skipping 57 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, vSrc8, vSrc9;
+        v4f32 vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, vDst8, vDst9;
+
+        for (; n >= 40; n -= 40) {

[Raymond Toy, 2016/10/03 16:47:06]

Is it really worth doing blocks of 40 instead of 32?  Since the typical use case
is powers of two, this guarantees the messy code below is run.

Using blocks of 32 keeps a nice symmetry with the other code that uses 32.

[Prashant.Patil, 2016/10/04 11:47:27]

OK. This was done considering 10 cycle vector load latency in one of the mips
variants. However most of the variants have ~8 cycle latency now, hence will
change this to 32.

[Raymond Toy, 2016/10/04 15:37:44]

If there is significant gain in doing this, by all means let's do it. It just
makes thinking about the code much harder.

+            LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);
+            LD_SP4(sourceP, 4, vSrc6, vSrc7, vSrc8, vSrc9);
+            VSMUL4(vSrc0, vSrc1, vSrc2, vSrc3, vDst0, vDst1, vDst2, vDst3, vScale);
+            VSMUL4(vSrc4, vSrc5, vSrc6, vSrc7, vDst4, vDst5, vDst6, vDst7, vScale);
+            VSMUL2(vSrc8, vSrc9, vDst8, vDst9, vScale);
+            ST_SP6(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, destP, 4);
+            ST_SP4(vDst6, vDst7, vDst8, vDst9, destP, 4);
+        }
+
+        if (n > 0) {
+            if (n >= 24) {
+                if (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);
+                    n -= 32;
+                } else if (n >= 28) {
+                    LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);
+                    vSrc6 = LD_SP(sourceP);
+                    sourceP += 4;
+                    VSMUL4(vSrc0, vSrc1, vSrc2, vSrc3, vDst0, vDst1, vDst2, vDst3, vScale);
+                    VSMUL2(vSrc4, vSrc5, vDst4, vDst5, vScale);
+                    vDst6 = vSrc6 * vScale;
+                    ST_SP6(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, destP, 4);
+                    ST_SP(vDst6, destP);
+                    destP += 4;
+                    n -= 28;
+                } else {
+                    LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);
+                    VSMUL4(vSrc0, vSrc1, vSrc2, vSrc3, vDst0, vDst1, vDst2, vDst3, vScale);
+                    VSMUL2(vSrc4, vSrc5, vDst4, vDst5, vScale);
+                    ST_SP6(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, destP, 4);
+                    n -= 24;
+                }
+            } else {
+                if (n >= 16) {
+                    LD_SP4(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3);
+                    VSMUL4(vSrc0, vSrc1, vSrc2, vSrc3, vDst0, vDst1, vDst2, vDst3, vScale);
+                    ST_SP4(vDst0, vDst1, vDst2, vDst3, destP, 4);
+                    n -= 16;
+                } else if (n >= 8) {
+                    LD_SP2(sourceP, 4, vSrc0, vSrc1);
+                    VSMUL2(vSrc0, vSrc1, vDst0, vDst1, vScale);
+                    ST_SP2(vDst0, vDst1, destP, 4);
+                    n -= 8;
+                }
+            }
+            if (n >= 4) {
+                vSrc0 = LD_SP(sourceP);
+                vDst0 = vSrc0 * vScale;
+                ST_SP(vDst0, destP);
+                sourceP += 4;
+                destP += 4;
+                n -= 4;
+            }
+        }
+    }
 #endif
     float k = *scale;
     while (n--) {
         *destP = k * *sourceP;
         sourceP += sourceStride;
         destP += destStride;
     }
 #if CPU(X86) || CPU(X86_64)
     }
 #endif
@@ skipping 92 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 vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6, vSrc7;
+        v4f32 vSrc8, vSrc9, vSrc10, vSrc11, vSrc12, vSrc13, vSrc14, vSrc15;
+        v4f32 vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7;
+
+        for (; n >= 32; n -= 32) {
+            LD_SP8(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc8, vSrc9, vSrc10, vSrc11);
+            LD_SP8(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7, vSrc12, vSrc13, vSrc14, vSrc15);

[Raymond Toy, 2016/10/03 16:47:06]

Can we pick better names for vSrc[n]?  It's really odd to see source1P loaded
into vSrc0-3 and vSrc8-11.

[Prashant.Patil, 2016/10/04 11:47:27]

Done.

+            ADD4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+            ADD4(vSrc8, vSrc12, vSrc9, vSrc13, vSrc10, vSrc14, vSrc11, vSrc15, vDst4, vDst5, vDst6, vDst7);
+            ST_SP8(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, destP, 4);
+        }
+
+        if (n > 0) {
+            if (n >= 20) {

[Raymond Toy, 2016/10/03 16:47:06]

Is this really worth doing?  In the typical use case n is always a multiple of
32.

[Prashant.Patil, 2016/10/04 11:47:27]

Done.

+                if (n >= 28) {
+                    LD_SP6(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc8, vSrc9);
+                    vSrc10 = LD_SP(source1P);
+                    source1P += 4;
+                    LD_SP6(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7, vSrc12, vSrc13);
+                    vSrc14 = LD_SP(source2P);
+                    source2P += 4;
+                    ADD4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+                    ADD2(vSrc8, vSrc12, vSrc9, vSrc13, vDst4, vDst5);
+                    vDst6 = vSrc10 + vSrc14;
+                    ST_SP6(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, destP, 4);
+                    ST_SP(vDst6, destP);
+                    destP += 4;
+                    n -= 28;
+                } else if (n >= 24) {
+                    LD_SP6(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc8, vSrc9);
+                    LD_SP6(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7, vSrc12, vSrc13);
+                    ADD4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+                    ADD2(vSrc8, vSrc12, vSrc9, vSrc13, vDst4, vDst5);
+                    ST_SP4(vDst0, vDst1, vDst2, vDst3, destP, 4);
+                    ST_SP2(vDst4, vDst5, destP, 4);
+                    n -= 24;
+                } else {
+                    LD_SP4(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3);
+                    vSrc8 = LD_SP(source1P);
+                    source1P += 4;
+                    LD_SP4(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7);
+                    vSrc12 = LD_SP(source2P);
+                    source2P += 4;
+                    ADD4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+                    vDst4 = vSrc8 + vSrc12;
+                    ST_SP4(vDst0, vDst1, vDst2, vDst3, destP, 4);
+                    ST_SP(vDst4, destP);
+                    destP += 4;
+                    n -= 20;
+                }
+            } else if (n >= 4) {
+                if (n >= 16) {
+                    LD_SP4(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3);
+                    LD_SP4(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7);
+                    ADD4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+                    ST_SP4(vDst0, vDst1, vDst2, vDst3, destP, 4);
+                    n -= 16;
+                } else if (n >= 12) {
+                    LD_SP2(source1P, 4, vSrc0, vSrc1);
+                    vSrc2 = LD_SP(source1P);
+                    source1P += 4;
+                    LD_SP2(source2P, 4, vSrc4, vSrc5);
+                    vSrc6 = LD_SP(source2P);
+                    source2P += 4;
+                    ADD2(vSrc0, vSrc4, vSrc1, vSrc5, vDst0, vDst1);
+                    vDst2 = vSrc2 + vSrc6;
+                    ST_SP2(vDst0, vDst1, destP, 4);
+                    ST_SP(vDst2, destP);
+                    destP += 4;
+                    n -= 12;
+                } else if (n >= 8) {
+                    LD_SP2(source1P, 4, vSrc0, vSrc1);
+                    LD_SP2(source2P, 4, vSrc4, vSrc5);
+                    ADD2(vSrc0, vSrc4, vSrc1, vSrc5, vDst0, vDst1);
+                    ST_SP2(vDst0, vDst1, destP, 4);
+                    n -= 8;
+                } else {
+                    vSrc0 = LD_SP(source1P);
+                    vSrc4 = LD_SP(source2P);
+                    vDst0 = vSrc0 + vSrc4;
+                    ST_SP(vDst0, destP);
+                    source1P += 4;
+                    source2P += 4;
+                    destP += 4;
+                    n -= 4;
+                }
+            }
+        }
+    }
 #endif
     while (n--) {
         *destP = *source1P + *source2P;
         source1P += sourceStride1;
         source2P += sourceStride2;
         destP += destStride;
     }
 #if CPU(X86) || CPU(X86_64)
     }
 #endif
@@ skipping 57 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 vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6, vSrc7;
+        v4f32 vSrc8, vSrc9, vSrc10, vSrc11, vSrc12, vSrc13, vSrc14, vSrc15;
+        v4f32 vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7;
+
+        for (; n >= 32; n -= 32) {
+            LD_SP8(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc8, vSrc9, vSrc10, vSrc11);

[Raymond Toy, 2016/10/03 16:47:06]

Same comment as in line 512.

[Prashant.Patil, 2016/10/04 11:47:27]

Done.

+            LD_SP8(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7, vSrc12, vSrc13, vSrc14, vSrc15);
+            MUL4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+            MUL4(vSrc8, vSrc12, vSrc9, vSrc13, vSrc10, vSrc14, vSrc11, vSrc15, vDst4, vDst5, vDst6, vDst7);
+            ST_SP8(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, destP, 4);
+        }
+
+        if (n > 0) {
+            if (n >= 20) {
+                if (n >= 28) {
+                    LD_SP6(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc8, vSrc9);
+                    vSrc10 = LD_SP(source1P);
+                    source1P += 4;
+                    LD_SP6(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7, vSrc12, vSrc13);
+                    vSrc14 = LD_SP(source2P);
+                    source2P += 4;
+                    MUL4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+                    MUL2(vSrc8, vSrc12, vSrc9, vSrc13, vDst4, vDst5);
+                    vDst6 = vSrc10 * vSrc14;
+                    ST_SP6(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, destP, 4);
+                    ST_SP(vDst6, destP);
+                    destP += 4;
+                    n -= 28;
+                } else if (n >= 24) {
+                    LD_SP6(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc8, vSrc9);
+                    LD_SP6(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7, vSrc12, vSrc13);
+                    MUL4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+                    MUL2(vSrc8, vSrc12, vSrc9, vSrc13, vDst4, vDst5);
+                    ST_SP4(vDst0, vDst1, vDst2, vDst3, destP, 4);
+                    ST_SP2(vDst4, vDst5, destP, 4);
+                    n -= 24;
+                } else { /* n >= 20 */
+                    LD_SP4(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3);
+                    vSrc8 = LD_SP(source1P);
+                    source1P += 4;
+                    LD_SP4(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7);
+                    vSrc12 = LD_SP(source2P);
+                    source2P += 4;
+                    MUL4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+                    vDst4 = vSrc8 * vSrc12;
+                    ST_SP4(vDst0, vDst1, vDst2, vDst3, destP, 4);
+                    ST_SP(vDst4, destP);
+                    destP += 4;
+                    n -= 20;
+                }
+            } else if (n >= 4) {
+                if (n >= 16) {
+                    LD_SP4(source1P, 4, vSrc0, vSrc1, vSrc2, vSrc3);
+                    LD_SP4(source2P, 4, vSrc4, vSrc5, vSrc6, vSrc7);
+                    MUL4(vSrc0, vSrc4, vSrc1, vSrc5, vSrc2, vSrc6, vSrc3, vSrc7, vDst0, vDst1, vDst2, vDst3);
+                    ST_SP4(vDst0, vDst1, vDst2, vDst3, destP, 4);
+                    n -= 16;
+                } else if (n >= 12) {
+                    LD_SP2(source1P, 4, vSrc0, vSrc1);
+                    vSrc2 = LD_SP(source1P);
+                    source1P += 4;
+                    LD_SP2(source2P, 4, vSrc4, vSrc5);
+                    vSrc6 = LD_SP(source2P);
+                    source2P += 4;
+                    MUL2(vSrc0, vSrc4, vSrc1, vSrc5, vDst0, vDst1);
+                    vDst2 = vSrc2 * vSrc6;
+                    ST_SP2(vDst0, vDst1, destP, 4);
+                    ST_SP(vDst2, destP);
+                    destP += 4;
+                    n -= 12;
+                } else if (n >= 8) {
+                    LD_SP2(source1P, 4, vSrc0, vSrc1);
+                    LD_SP2(source2P, 4, vSrc4, vSrc5);
+                    MUL2(vSrc0, vSrc4, vSrc1, vSrc5, vDst0, vDst1);
+                    ST_SP2(vDst0, vDst1, destP, 4);
+                    n -= 8;
+                } else { // n >= 4
+                    vSrc0 = LD_SP(source1P);
+                    vSrc4 = LD_SP(source2P);
+                    vDst0 = vSrc0 * vSrc4;
+                    ST_SP(vDst0, destP);
+                    source1P += 4;
+                    source2P += 4;
+                    destP += 4;
+                    n -= 4;
+                }
+            }
+        }
+    }
 #endif
     while (n) {
         *destP = *source1P * *source2P;
         source1P += sourceStride1;
         source2P += sourceStride2;
         destP += destStride;
         n--;
     }
 }
 
@@ skipping 169 matching lines @@
             sourceP += 4;
         }
         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, vSrc8, vSrc9;
+        const v16i8 vMask = (v16i8) __msa_fill_w(0x7FFFFFFF);
+
+        for (; n >= 40; n -= 40) {
+            LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);

[Raymond Toy, 2016/10/03 16:47:06]

Same comment as in line 333.

[Prashant.Patil, 2016/10/04 11:47:27]

Done.

+            LD_SP4(sourceP, 4, vSrc6, vSrc7, vSrc8, vSrc9);
+            VMAXMGV4(vSrc0, vSrc1, vSrc2, vSrc3, vMask, vMax);
+            VMAXMGV4(vSrc4, vSrc5, vSrc6, vSrc7, vMask, vMax);
+            VMAXMGV2(vSrc8, vSrc9, vMask, vMax);
+        }
+
+        if (n > 0) {
+            if (n >= 32) {
+                LD_SP8(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6, vSrc7);
+                VMAXMGV4(vSrc0, vSrc1, vSrc2, vSrc3, vMask, vMax);
+                VMAXMGV4(vSrc4, vSrc5, vSrc6, vSrc7, vMask, vMax);
+                n -= 32;
+            } else if (n >= 28) {
+                LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);
+                vSrc6 = LD_SP(sourceP);
+                sourceP += 4;
+                VMAXMGV4(vSrc0, vSrc1, vSrc2, vSrc3, vMask, vMax);
+                VMAXMGV2(vSrc4, vSrc5, vMask, vMax);
+                vMax = __msa_fmax_w(vMax, (v4f32) ((v16i8) vSrc6 & vMask));
+                n -= 28;
+            } else if (n >= 24) {
+                LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);
+                VMAXMGV4(vSrc0, vSrc1, vSrc2, vSrc3, vMask, vMax);
+                VMAXMGV2(vSrc4, vSrc5, vMask, vMax);
+                n -= 24;
+            } else if (n >= 16) {
+                LD_SP4(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3);
+                VMAXMGV4(vSrc0, vSrc1, vSrc2, vSrc3, vMask, vMax);
+                n -= 16;
+            } else if (n >= 8) {
+                LD_SP2(sourceP, 4, vSrc0, vSrc1);
+                VMAXMGV2(vSrc0, vSrc1, vMask, vMax);
+                n -= 8;
+            }
+
+            if (n >= 4) {
+                vSrc0 = LD_SP(sourceP);
+                sourceP += 4;
+                vMax = __msa_fmax_w(vMax, (v4f32) ((v16i8) vSrc0 & vMask));
+                n -= 4;
+            }
+        }
+
+        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 13 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, vSrc8, vSrc9;
+        v4f32 vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, vDst8, vDst9;
+        const v4f32 vLowThr = (v4f32) __msa_fill_w(*((int32_t *) lowThresholdP));
+        const v4f32 vHighThr = (v4f32) __msa_fill_w(*((int32_t *) highThresholdP));
+
+        for (; n >= 40; n -= 40) {
+            LD_SP8(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5, vSrc6, vSrc7);
+            LD_SP2(sourceP, 4, vSrc8, vSrc9);
+            VCLIP4(vSrc0, vSrc1, vSrc2, vSrc3, vLowThr, vHighThr, vDst0, vDst1, vDst2, vDst3);
+            VCLIP4(vSrc4, vSrc5, vSrc6, vSrc7, vLowThr, vHighThr, vDst4, vDst5, vDst6, vDst7);
+            VCLIP2(vSrc8, vSrc9, vLowThr, vHighThr, vDst8, vDst9);
+            ST_SP8(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, vDst6, vDst7, destP, 4);
+            ST_SP2(vDst8, vDst9, destP, 4);
+        }
+
+        if (n > 0) {
+            if (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);
+                n -= 32;
+            } else if (n >= 28) {
+                LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);
+                vSrc6 = LD_SP(sourceP);
+                sourceP += 4;
+                VCLIP4(vSrc0, vSrc1, vSrc2, vSrc3, vLowThr, vHighThr, vDst0, vDst1, vDst2, vDst3);
+                VCLIP2(vSrc4, vSrc5, vLowThr, vHighThr, vDst4, vDst5);
+                vDst6 = __msa_fmax_w(__msa_fmin_w(vSrc6, vHighThr), vLowThr);
+                ST_SP6(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, destP, 4);
+                ST_SP(vDst6, destP);
+                destP += 4;
+                n -= 28;
+            } else if (n >= 24) {
+                LD_SP6(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3, vSrc4, vSrc5);
+                VCLIP4(vSrc0, vSrc1, vSrc2, vSrc3, vLowThr, vHighThr, vDst0, vDst1, vDst2, vDst3);
+                VCLIP2(vSrc4, vSrc5, vLowThr, vHighThr, vDst4, vDst5);
+                ST_SP6(vDst0, vDst1, vDst2, vDst3, vDst4, vDst5, destP, 4);
+                n -= 24;
+            } else if (n >= 16) {
+                LD_SP4(sourceP, 4, vSrc0, vSrc1, vSrc2, vSrc3);
+                VCLIP4(vSrc0, vSrc1, vSrc2, vSrc3, vLowThr, vHighThr, vDst0, vDst1, vDst2, vDst3);
+                ST_SP4(vDst0, vDst1, vDst2, vDst3, destP, 4);
+                n -= 16;
+            } else if (n >= 8) {
+                LD_SP2(sourceP, 4, vSrc0, vSrc1);
+                VCLIP2(vSrc0, vSrc1, vLowThr, vHighThr, vDst0, vDst1);
+                ST_SP2(vDst0, vDst1, destP, 4);
+                n -= 8;
+            }
+            if (n >= 4) {
+                vSrc0 = LD_SP(sourceP);
+                sourceP += 4;
+                vDst0 = __msa_fmax_w(__msa_fmin_w(vSrc0, vHighThr), vLowThr);
+                ST_SP(vDst0, destP);
+                destP += 4;
+                n -= 4;
+            }
+        }
+    }
 #endif
     while (n--) {
         *destP = clampTo(*sourceP, lowThreshold, highThreshold);
         sourceP += sourceStride;
         destP += destStride;
     }
 }
 
 #endif // OS(MACOSX)
 
 } // namespace VectorMath
 
 } // namespace blink