Справка с оптимизацией C# функционирует через C и/или блок

У меня есть этот метод C#, который я пытаюсь оптимизировать:

// assume arrays are same dimensions
private void DoSomething(int[] bigArray1, int[] bigArray2)
{
    int data1;
    byte A1, B1, C1, D1;
    int data2;
    byte A2, B2, C2, D2;
    for (int i = 0; i < bigArray1.Length; i++)
    {
        data1 = bigArray1[i];
        data2 = bigArray2[i];

        A1 = (byte)(data1 >> 0);
        B1 = (byte)(data1 >> 8);
        C1 = (byte)(data1 >> 16);
        D1 = (byte)(data1 >> 24);

        A2 = (byte)(data2 >> 0);
        B2 = (byte)(data2 >> 8);
        C2 = (byte)(data2 >> 16);
        D2 = (byte)(data2 >> 24);

        A1 = A1 > A2 ? A1 : A2;
        B1 = B1 > B2 ? B1 : B2;
        C1 = C1 > C2 ? C1 : C2;
        D1 = D1 > D2 ? D1 : D2;

        bigArray1[i] = (A1 << 0) | (B1 << 8) | (C1 << 16) | (D1 << 24); 
    }
}

Функция в основном выдерживает сравнение два int массивы. Для каждой пары соответствия элементам метод сравнивает каждое отдельное значение байта и берет большие из двух. Элементу в первом массиве затем присваивают новое int значение создается из 4 самых больших значений байта (независимо от источника).

Я думаю, что оптимизировал этот метод как можно больше в C# (вероятно, я не имею, конечно - предложения в этом отношении приветствуются также). Мой вопрос, действительно ли это стоит того для меня для перемещения этого метода в неуправляемый DLL C? Был бы получающийся метод выполняться быстрее (и сколько быстрее), принимая во внимание издержки маршалинга моего управляемого int массивы, таким образом, они могут быть переданы методу?

При выполнении это получило бы меня, скажем, 10%-е улучшение скорости, затем это не будет стоить моего времени наверняка. Если бы это было в 2 или 3 раза быстрее, то я должен был бы, вероятно, сделать это.

Примечание: никакая "преждевременная оптимизация" комментарии, заранее спасибо. Это - просто "оптимизация".

Обновление: Я понял, что мой пример кода не получал все, что я пытаюсь сделать в этой функции, таким образом, вот обновленная версия:

private void DoSomethingElse(int[] dest, int[] src, double pos, 
    double srcMultiplier)
{
    int rdr;
    byte destA, destB, destC, destD;
    double rem = pos - Math.Floor(pos);
    double recipRem = 1.0 - rem;
    byte srcA1, srcA2, srcB1, srcB2, srcC1, srcC2, srcD1, srcD2;
    for (int i = 0; i < src.Length; i++)
    {
        // get destination values
        rdr = dest[(int)pos + i];
        destA = (byte)(rdr >> 0);
        destB = (byte)(rdr >> 8);
        destC = (byte)(rdr >> 16);
        destD = (byte)(rdr >> 24);
        // get bracketing source values
        rdr = src[i];
        srcA1 = (byte)(rdr >> 0);
        srcB1 = (byte)(rdr >> 8);
        srcC1 = (byte)(rdr >> 16);
        srcD1 = (byte)(rdr >> 24);
        rdr = src[i + 1];
        srcA2 = (byte)(rdr >> 0);
        srcB2 = (byte)(rdr >> 8);
        srcC2 = (byte)(rdr >> 16);
        srcD2 = (byte)(rdr >> 24);
        // interpolate (simple linear) and multiply
        srcA1 = (byte)(((double)srcA1 * recipRem) + 
            ((double)srcA2 * rem) * srcMultiplier);
        srcB1 = (byte)(((double)srcB1 * recipRem) +
            ((double)srcB2 * rem) * srcMultiplier);
        srcC1 = (byte)(((double)srcC1 * recipRem) +
            ((double)srcC2 * rem) * srcMultiplier);
        srcD1 = (byte)(((double)srcD1 * recipRem) +
            ((double)srcD2 * rem) * srcMultiplier);
        // bytewise best-of
        destA = srcA1 > destA ? srcA1 : destA;
        destB = srcB1 > destB ? srcB1 : destB;
        destC = srcC1 > destC ? srcC1 : destC;
        destD = srcD1 > destD ? srcD1 : destD;
        // convert bytes back to int
        dest[i] = (destA << 0) | (destB << 8) |
            (destC << 16) | (destD << 24);
    }
}

По существу это делает то же самое как первый метод, кроме этого второй массив (src) всегда меньше, чем первое (dest), и второй массив расположен незначительно относительно первого (подразумевать, что вместо того, чтобы быть положением в, скажем, 10 относительно dest, он может быть расположен в 10,682791).

Для достижения этого я должен интерполировать между двумя значениями заключения в скобки в источнике (скажите, 10 и 11 в вышеупомянутом примере, для первого элемента), и затем сравните интерполированные байты с целевыми байтами.

Я подозреваю здесь, что умножение, вовлеченное в эту функцию, является существенно более дорогостоящим, чем сравнения байта, так, чтобы часть могла быть отвлекающим маневром (извините). Кроме того, даже если сравнения являются все еще несколько дорогими относительно умножения, у меня все еще есть проблема, что эта система может на самом деле быть многомерной, означая, что вместо того, чтобы сравнить 1-мерные массивы, массивы могли быть 2-, 5-или безотносительно - размерные, так, чтобы в конечном счете время, потраченное для вычисления интерполированных значений, затмило время, потраченное финалом bytewise сравнение 4 байтов (я предполагаю, что это имеет место).

Насколько дорогой умножение здесь относительно смещения бита, и действительно ли это - вид операции, которая могла быть ускорена, будучи разгруженным к DLL C (или даже блок DLL, хотя я должен буду нанять кого-то для создания этого для меня)?