SSE2 Optimization for ParamEvent::SetTarget

Source/modules/webaudio/AudioParamTimeline.cpp

 /*
  * Copyright (C) 2011 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
@@ skipping 13 matching lines @@
  */
 
 #include "config.h"
 #if ENABLE(WEB_AUDIO)
 #include "modules/webaudio/AudioParamTimeline.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ExceptionCode.h"
 #include "platform/FloatConversion.h"
 #include "platform/audio/AudioUtilities.h"
+#include "wtf/CPU.h"
 #include "wtf/MathExtras.h"
 #include <algorithm>
 
+#if CPU(X86) || CPU(X86_64)
+#include <emmintrin.h>
+#endif
+
 namespace blink {
 
 static bool isPositiveAudioParamValue(float value, ExceptionState& exceptionState)
 {
     if (value > 0)
         return true;
 
     // Use denorm_min() in error message to make it clear what the mininum positive value is. The
     // Javascript API uses doubles, which gets converted to floats, sometimes causing an underflow.
     // This is confusing if the user specified a small non-zero (double) value that underflowed to
@@ skipping 295 matching lines @@
 
             case ParamEvent::SetTarget:
                 {
                     currentTime = fillToTime;
 
                     // Exponential approach to target value with given time constant.
                     float target = event.value();
                     float timeConstant = event.timeConstant();
                     float discreteTimeConstant = static_cast<float>(AudioUtilities::discreteTimeConstantForSampleRate(timeConstant, controlRate));
 
+#if CPU(X86) || CPU(X86_64)
+                    // Resolve recursion by expanding constants to achieve a 4-step loop unrolling.
+                    // v1 = v0 + (t - v0) * c
+                    // v2 = v1 + (t - v1) * c
+                    // v2 = v0 + (t - v0) * c + (t - (v0 + (t - v0) * c)) * c
+                    // v2 = v0 + (t - v0) * c + (t - v0) * c - (t - v0) * c * c
+                    // v2 = v0 + (t - v0) * c * (2 - c)
+                    // Thus c0 = c, c1 = c*(2-c). The same logic applies to c2 and c3.
+                    const float c0 = discreteTimeConstant;
+                    const float c1 = c0 * (2 - c0);
+                    const float c2 = c0 * ((c0 - 3) * c0 + 3);
+                    const float c3 = c0 * (c0 * ((4 - c0) * c0 - 6) + 4);
+
+                    float delta;
+                    __m128 vC = _mm_set_ps(c2, c1, c0, 0);
+                    __m128 vDelta, vValue, vResult;
+
+                    // Process 4 loop steps.
+                    unsigned fillToFrameTrunc = writeIndex + ((fillToFrame - writeIndex) / 4) * 4;
+                    for (; writeIndex < fillToFrameTrunc; writeIndex += 4) {
+                        delta = target - value;
+                        vDelta = _mm_set_ps1(delta);
+                        vValue = _mm_set_ps1(value);
+
+                        vResult = _mm_add_ps(vValue, _mm_mul_ps(vDelta, vC));
+                        _mm_storeu_ps(values + writeIndex, vResult);
+
+                        // Update value for next iteration.
+                        value += delta * c3;
+                    }
+#endif
+                    // Serially process remaining values
                     for (; writeIndex < fillToFrame; ++writeIndex) {
                         values[writeIndex] = value;
                         value += (target - value) * discreteTimeConstant;
                     }
 
                     break;
                 }
 
             case ParamEvent::SetValueCurve:
                 {
@@ skipping 96 matching lines @@
     // to the end of the values buffer.
     for (; writeIndex < numberOfValues; ++writeIndex)
         values[writeIndex] = value;
 
     return value;
 }
 
 } // namespace blink
 
 #endif // ENABLE(WEB_AUDIO)