Информация об изменениях

Сообщение Re[25]: C# - from indians by indians от 06.06.2015 20:08

Изменено 06.06.2015 21:53 Evgeny.Panasyuk

Старый текст
Новый текст
Разница

EP>C++ версия скомпилированная в JavaScript и запущенная в Firefox:
EP>

EP>Elapsed = 0.0960432s

EP>

EP>UPD: Иногда бывает даже вот так:
EP>

EP>Elapsed = 0.0744424s

Исходный main:

int main()
{
    constexpr auto N = 1u << 24;
    vector<Complex> v, u;
    v.reserve(N);
    generate_n(back_inserter(v), N, random_complex);
    u = v;
    random_shuffle(begin(v), end(v));
    random_shuffle(begin(u), end(u));

    benchmark([&]
    {
        transform(begin(v), end(v), begin(u), begin(v), [](auto x, auto y) { return x*y; });
    });

    volatile auto anti_opti = accumulate(begin(v), end(v), Complex{});
    (void)anti_opti;
}

А вот main из .js отформатированный сторонней утилитой. Имена идентификаторов это то что я разревёрсил, до этого были одно-двух буквенные:

function main() {
    var a = 0,
        b = 0,
        c = 0,
        d = 0,
        e = 0,
        f = 0,
        g = 0,
        h = 0,
        i = 0,
        j = 0,
        l = 0,
        m = 0,
        n = 0,
        o = 0,
        q = 0,
        s = 0,
        t = 0.0,
        u = 0.0,
        v = 0.0,
        w = 0.0;
    s = r;
    r = r + 80 | 0;
    j = s + 16 | 0;
    i = s;
    l = s + 8 | 0;
    o = s + 48 | 0;
    m = s + 60 | 0;
    c = s + 36 | 0;
    d = s + 40 | 0;
    f = s + 44 | 0;
    g = s + 32 | 0;
    mem_as_Int32[o >> 2] = 0;
    q = o + 4 | 0;
    mem_as_Int32[q >> 2] = 0;
    h = o + 8 | 0;
    mem_as_Int32[h >> 2] = 0;
    mem_as_Int32[m >> 2] = 0;
    n = m + 4 | 0;
    mem_as_Int32[n >> 2] = 0;
    mem_as_Int32[m + 8 >> 2] = 0;
    e = Pn(268435456) | 0;
    mem_as_Int32[o >> 2] = e;
    mem_as_Int32[q >> 2] = e;
    mem_as_Int32[h >> 2] = e + 268435456;
    e = j + 8 | 0;
    b = 16777216;
    do {
        t = +(rand() | 0) / 1.0e3 + -1.0e3;
        mem_as_Float64[j >> 3] = t;
        t = +(rand() | 0) / 1.0e3 + -1.0e3;
        mem_as_Float64[e >> 3] = t;
        a = mem_as_Int32[q >> 2] | 0;
        if (a >>> 0 < (mem_as_Int32[h >> 2] | 0) >>> 0) {
            if (!a) a = 0;
            else {
                mem_as_Int32[a + 0 >> 2] = mem_as_Int32[j + 0 >> 2];
                mem_as_Int32[a + 4 >> 2] = mem_as_Int32[j + 4 >> 2];
                mem_as_Int32[a + 8 >> 2] = mem_as_Int32[j + 8 >> 2];
                mem_as_Int32[a + 12 >> 2] = mem_as_Int32[j + 12 >> 2]
            }
            mem_as_Int32[q >> 2] = a + 16
        } else Dc(o, j);
        b = b + -1 | 0
    } while ((b | 0) != 0);
    Cc(m, mem_as_Int32[o >> 2] | 0, mem_as_Int32[q >> 2] | 0);
    mem_as_Int32[c >> 2] = mem_as_Int32[o >> 2];
    mem_as_Int32[d >> 2] = mem_as_Int32[q >> 2];
    mem_as_Int32[i + 0 >> 2] = mem_as_Int32[c + 0 >> 2];
    mem_as_Int32[j + 0 >> 2] = mem_as_Int32[d + 0 >> 2];
    random_shuffle(i, j);
    mem_as_Int32[f >> 2] = mem_as_Int32[m >> 2];
    mem_as_Int32[g >> 2] = mem_as_Int32[n >> 2];
    mem_as_Int32[i + 0 >> 2] = mem_as_Int32[f + 0 >> 2];
    mem_as_Int32[j + 0 >> 2] = mem_as_Int32[g + 0 >> 2];
    random_shuffle(i, j);
    high_resolution_clock::now(i);
    a = mem_as_Int32[o >> 2] | 0;
    c = mem_as_Int32[q >> 2] | 0;
    if ((a | 0) != (c | 0)) {
        b = mem_as_Int32[m >> 2] | 0;
        while (1) {
            u = +mem_as_Float64[a >> 3];
            g = a + 8 | 0;
            w = +mem_as_Float64[g >> 3];
            v = +mem_as_Float64[b >> 3];
            t = +mem_as_Float64[b + 8 >> 3];
            mem_as_Float64[a >> 3] = u * v - w * t;
            mem_as_Float64[g >> 3] = w * v + u * t;
            a = a + 16 | 0;
            if ((a | 0) == (c | 0)) break;
            else b = b + 16 | 0
        }
    }
    high_resolution_clock::now(l);
    e = l;
    f = mem_as_Int32[e >> 2] | 0;
    e = mem_as_Int32[e + 4 >> 2] | 0;
    a = i;
    g = mem_as_Int32[a >> 2] | 0;
    a = mem_as_Int32[a + 4 >> 2] | 0;
    l = zc(2664, 8, 10) | 0;
    a = xp(f | 0, e | 0, g | 0, a | 0) | 0;
    a = zc(Le(l, (+(a >>> 0) + 4294967296.0 * +(P | 0)) / 1.0e9) | 0, 24, 1) | 0;
    Ld(j, a + (mem_as_Int32[(mem_as_Int32[a >> 2] | 0) + -12 >> 2] | 0) | 0);
    l = kj(j, 7520) | 0;
    l = mc[mem_as_Int32[(mem_as_Int32[l >> 2] | 0) + 28 >> 2] & 15](l, 10) | 0;
    ij(j);
    Me(a, l) | 0;
    we(a) | 0;
    a = mem_as_Int32[m >> 2] | 0;
    if (!a) a = mem_as_Int32[o >> 2] | 0;
    else {
        b = mem_as_Int32[n >> 2] | 0;
        if ((b | 0) != (a | 0)) mem_as_Int32[n >> 2] = b + (~((b + -16 - a | 0) >>> 4) << 4);
        Qn(a);
        a = mem_as_Int32[o >> 2] | 0
    }
    if (!a) {
        r = s;
        return 0
    }
    b = mem_as_Int32[q >> 2] | 0;
    if ((b | 0) != (a | 0)) mem_as_Int32[q >> 2] = b + (~((b + -16 - a | 0) >>> 4) << 4);
    Qn(a);
    r = s;
    return 0
}

mem_as_Int32 и mem_as_Float64 это views одного и того же буфера (есть views и других типов). Heap и stack находятся в этом буфере.

Первый цикл это generate_n:

e = j + 8 | 0;
b = 16777216;
do {
    t = +(rand() | 0) / 1.0e3 + -1.0e3;
    mem_as_Float64[j >> 3] = t;
    t = +(rand() | 0) / 1.0e3 + -1.0e3;
    mem_as_Float64[e >> 3] = t;
    a = mem_as_Int32[q >> 2] | 0;
    if (a >>> 0 < (mem_as_Int32[h >> 2] | 0) >>> 0) {
        if (!a) a = 0;
        else {
            mem_as_Int32[a + 0 >> 2] = mem_as_Int32[j + 0 >> 2];
            mem_as_Int32[a + 4 >> 2] = mem_as_Int32[j + 4 >> 2];
            mem_as_Int32[a + 8 >> 2] = mem_as_Int32[j + 8 >> 2];
            mem_as_Int32[a + 12 >> 2] = mem_as_Int32[j + 12 >> 2]
        }
        mem_as_Int32[q >> 2] = a + 16
    } else Dc(o, j);
    b = b + -1 | 0
} while ((b | 0) != 0);

Тут видно что компилятор в этот же цикл сразу поместил копирование во второй вектор, то есть:

generate_n(back_inserter(v), N, random_complex);
u = v;

избежав двух проходов по памяти первого вектора.

Следующий цикл это transform с легко узнаваемой формулой умножения комплексных чисел:

high_resolution_clock::now(i);
a = mem_as_Int32[o >> 2] | 0;
c = mem_as_Int32[q >> 2] | 0;
if ((a | 0) != (c | 0)) {
    b = mem_as_Int32[m >> 2] | 0;
    while (1) {
        u = +mem_as_Float64[a >> 3];
        g = a + 8 | 0;
        w = +mem_as_Float64[g >> 3];
        v = +mem_as_Float64[b >> 3];
        t = +mem_as_Float64[b + 8 >> 3];
        mem_as_Float64[a >> 3] = u * v - w * t;
        mem_as_Float64[g >> 3] = w * v + u * t;
        a = a + 16 | 0;
        if ((a | 0) == (c | 0)) break;
        else b = b + 16 | 0
    }
}
high_resolution_clock::now(l);

То есть это результат компиляции:

transform(begin(v), end(v), begin(u), begin(v), [](auto x, auto y) { return x*y; });

Несмотря на volatile, компилятор выкинул accumulate. Его можно принудительно добавить (через вывод в результата в cout), но на замер времени это не повлияло.

P.S. Думаю на базе Emscripten можно сделать компилятор из C++ в Java — тогда там наконец "появятся" автоматические структуры