Zkušenosti s jazykem D

[RAII]

Vyřešeno, celí obsah adresáře /usr/lib/gcc/x86_64-redhat-linux/4.8.2 sem zkopíroval do /usr/lib/gcc/x86_64-unknown-linux-gnu/4.8.2 a vše šlape jak má

[Reklama]

[Bla]

RAII: Existují i jazyky, ve kterých bys to Hello World napsal o poznání snáz

[RAII]

TO BLA: No, hello world se napíše opravdu snadno:

Kód: [Vybrat]

module core.main;
import std.stdio;

void main()
{
       writeln("Hello world");
}

Pokud sleduješ tu anabázi co sem tady řešil, tak to je proto že chci v D napsat bootloader, a bohužel, to není zas tak snadné ... Když máš k dispozici druntime a stdlib, není D problém, až teda na dokumentaci (ale to se zase týká low level)...

[RAII]

Přináším pěknej benchmark C++ vs D. Testování spočívá v rychlosti sečtení dvou matic. D je hotovo o !!!30% dřív než C++. Oboje sem kompiloval s -O3 (takže STL kontejnery by měli mít deaktivovaný debug zpomalovadla takže by měli bejt rychlí).
C++

Kód: [Vybrat]

#include <vector>
#include <random>

template <class T>
void addM(vector<vector<T>> & first, vector<vector<T>> & second)
{
    if (first.size() == second.size() && first[0].size() == second[0].size())
    {
        for (int i=0; i<first.size(); ++i)
        {
            for (int y=0; y<first[i].size(); ++y)
            {
                first[i][y] += second[i][y];
            }
        }
    }
}
template <class T>
void writeM(vector<vector<T>> & v)
{
    for (int i=0; i<v.size(); ++i)
    {
        for (int y=0; y<v[i].size(); ++y)
        {
            cout << v[i][y] << "  ";
        }
        cout << endl;
    }
}

int main()
{
    random_device ranDev;

    vector<vector<int>> v;
    for (int i=0; i<100; ++i)
        v.push_back(vector<int>(100));
    for (int i=0; i<v.size(); ++i)
        for (int y=0; y<v[i].size(); ++y)
            v[i][y] = 10+ranDev()%9;

    vector<vector<int>> v2;
    for (int i=0; i<100; ++i)
        v2.push_back(vector<int>(100));
    for (int i=0; i<v2.size(); ++i)
        for (int y=0; y<v2[i].size(); ++y)
            v2[i][y] = 10+ranDev()%9;

    for (int i=0; i<1000000; ++i)
        addM(v,v2);
    return 0;
}
a D

Kód: [Vybrat]

module zkouskarychlosti;

import std.stdio;
import std.random;
import std.datetime;

void matrixAdd(T)(T[][] firstM, T[][] secondM)
{
if ((firstM.length == secondM.length)&&(firstM[0].length == secondM[0].length))
{
for (int i=0; i<firstM.length; ++i)
{
firstM[i][] += secondM[i][];
}
}
}

void matrixSub(T)(T[][] firstM, T[][] secondM)
{
if ((firstM.length == secondM.length)&&(firstM[0].length == secondM[0].length))
{
for (int i=0; i<firstM.length; ++i)
{
firstM[i][] -= secondM[i][];
}
}
}

void writeM(T)(T[][] mat)
{
for (int i=0; i<mat.length; ++i)
{
for (int y=0; y<mat[i].length; ++y)
{
write(mat[i][y]);
write("  ");
}
writeln(" ");
}
}

void main()
{
StopWatch sw;
sw.start();
const int rowcols = 100; 
int[][] fm;
int[][] sm;
fm.length = 100;
sm.length = 100;
foreach (int i;0..rowcols)
{
fm[i].length = 100;
sm[i].length = 100;
foreach (int y;0..rowcols)
{
fm[i][y] = sm[i][y] = uniform(0,9);
}
}
foreach (int i;0..1000000)
{
matrixAdd(fm,sm);
}
writeln(sw.peek().msecs());
sw.stop();
}


[Sten]

Přináším pěknej benchmark C++ vs D. Testování spočívá v rychlosti sečtení dvou matic. D je hotovo o !!!30% dřív než C++. Oboje sem kompiloval s -O3 (takže STL kontejnery by měli mít deaktivovaný debug zpomalovadla takže by měli bejt rychlí).
C++

Kód: [Vybrat]

#include <vector>
#include <random>

template <class T>
void addM(vector<vector<T>> & first, vector<vector<T>> & second)
{
    if (first.size() == second.size() && first[0].size() == second[0].size())
    {
        for (int i=0; i<first.size(); ++i)
        {
            for (int y=0; y<first[i].size(); ++y)
            {
                first[i][y] += second[i][y];
            }
        }
    }
}
template <class T>
void writeM(vector<vector<T>> & v)
{
    for (int i=0; i<v.size(); ++i)
    {
        for (int y=0; y<v[i].size(); ++y)
        {
            cout << v[i][y] << "  ";
        }
        cout << endl;
    }
}

int main()
{
    random_device ranDev;

    vector<vector<int>> v;
    for (int i=0; i<100; ++i)
        v.push_back(vector<int>(100));
    for (int i=0; i<v.size(); ++i)
        for (int y=0; y<v[i].size(); ++y)
            v[i][y] = 10+ranDev()%9;

    vector<vector<int>> v2;
    for (int i=0; i<100; ++i)
        v2.push_back(vector<int>(100));
    for (int i=0; i<v2.size(); ++i)
        for (int y=0; y<v2[i].size(); ++y)
            v2[i][y] = 10+ranDev()%9;

    for (int i=0; i<1000000; ++i)
        addM(v,v2);
    return 0;
}
a D

Kód: [Vybrat]

module zkouskarychlosti;

import std.stdio;
import std.random;
import std.datetime;

void matrixAdd(T)(T[][] firstM, T[][] secondM)
{
if ((firstM.length == secondM.length)&&(firstM[0].length == secondM[0].length))
{
for (int i=0; i<firstM.length; ++i)
{
firstM[i][] += secondM[i][];
}
}
}

void matrixSub(T)(T[][] firstM, T[][] secondM)
{
if ((firstM.length == secondM.length)&&(firstM[0].length == secondM[0].length))
{
for (int i=0; i<firstM.length; ++i)
{
firstM[i][] -= secondM[i][];
}
}
}

void writeM(T)(T[][] mat)
{
for (int i=0; i<mat.length; ++i)
{
for (int y=0; y<mat[i].length; ++y)
{
write(mat[i][y]);
write("  ");
}
writeln(" ");
}
}

void main()
{
StopWatch sw;
sw.start();
const int rowcols = 100; 
int[][] fm;
int[][] sm;
fm.length = 100;
sm.length = 100;
foreach (int i;0..rowcols)
{
fm[i].length = 100;
sm[i].length = 100;
foreach (int y;0..rowcols)
{
fm[i][y] = sm[i][y] = uniform(0,9);
}
}
foreach (int i;0..1000000)
{
matrixAdd(fm,sm);
}
writeln(sw.peek().msecs());
sw.stop();
}


To je tím, že ten program v C++ je špatně napsaný. Pokud nahradím všechny for (int i=0; i<v.size(); ++i) za for (int i=0, count = v.size(); i < count; ++i), zrychlí to ten program o 80 %!

[Reklama]

[RAII]

TO STEN: A zkoušel si to upravit a pustit? Já sem to upravil a hádej co. Úplně stejně rychlé...Možná o pár desítek milisekund rychlejší, D je ale rychlejší o stovky milisekund. Žádných 80% zrychlení se neděje. Ono, schválně se koukni co dělá funkce .size(). Takřka nic, jedná se jen o funkci s jedním řádkem a to returnem hodnoty. Funkce se volaj hodně rychle víme?

[JSH]

To je tím, že ten program v C++ je špatně napsaný. Pokud nahradím všechny for (int i=0; i<v.size(); ++i) za for (int i=0, count = v.size(); i < count; ++i), zrychlí to ten program o 80 %!

80% je trochu moc, ale 15 sekund to srazilo na 12. Daleko víc by se IMO dalo získat použitím 1D pole a vlastním indexováním. Takhle se taky matice píšou. Vektor vektorů se sem moc nehodí. Když už nic jiného, tak na rozdíl od matice může být každý z těch vektorů jinak dlouhý a kód by to měl správně kontrolovat.

[RAII]

D to dalo za 7,5 s ... C++ za 12 po optimalizaci za 11 ... ano ano, dalo se to vyřešit všemi možnými způsoby, jež by to zrychlily, ale to prosím by šlo udělat i u D ... a opět by bylo rychlejší

[JSH]

Tak je to přesně, jak jsem si myslel. Použití 1D pole srazí ten čas na 6 sekund.

Kód: [Vybrat]

template <class T>
void addM(vector<T> & first, vector<T> & second, int r, int c)
{
    T * row_first = &first[0];
    T * row_second = &second[0];
    for(int i = 0; i < r; ++i)
    {
        for(int j = 0; j < c; ++j)
        {
            row_first[j] += row_second[j];
        }
        row_first += c;
        row_second += c;
    }
}

Nevím jak D implementuje dvorozměrná pole. Ale určitě nepoužívá něco tak neefektivního jako vektor vektorů, ale alokuje to v jednom bloku. Až budeš mít zase chuť porovnávat jazyky, tak se prosím ujisti že neporovnáváš bubble-sort s quick-sortem. Díky.

[RAII]

No, je to implementováno jako pole pointerů na pole a navíc je to dynamicky alokováno. S GC. Ještě jednou s GC. Pokud bych to předělal plně na pointery a řešil to jak ty + obešel GC vlastním alokátorem, byl bych zase v úplně jiné dimenzi než C++. Zejtra se na to podívám. Jo a neporovnávám buble sort s quick sortem ale bubble sort s bubble sortem kterej má zasranej pomalej neoptimalizovanej GC xD

[JSH]

D to dalo za 7,5 s ... C++ za 12 po optimalizaci za 11 ... ano ano, dalo se to vyřešit všemi možnými způsoby, jež by to zrychlily, ale to prosím by šlo udělat i u D ... a opět by bylo rychlejší

Tohle sis vycucal z levého nebo pravého palce? Až porovnáš dva kódy, kde C++ nebude používat brutálně neefektivní konstrukce, tak to můžeš tvrdit. Hoď sem to nejlepší, co z D dostaneš. Já si schválně pohraju s C++ kódem a uvidíme.

[RAII]

D má totiž díky slice a range operátorům možnost dělat SIMD optimalizace což v C++ nejde (ručně ano xD) ... nejsem si ale jistej detailama. Asi se podívám do vnitřností binárky abych zjistil co je na tom pravdy. Jinak objevil sem svojí potencionální chybu ... v C++ používám random_device který je na linuxu pomalí protože čerpá z /dev/random (nebo /dev/urandom ?? nejsem si jist jedno je pomalejší a random_device používá to rychlejší). V D používám implicitní pseudo generátor náhodných čísel. Ale stejně má chyba nemá měřitelný vliv...náhodná čísla sou generována jen 2000krát. Dobře přijímám výzvu, du to začít tunit.

[Sten]

To je tím, že ten program v C++ je špatně napsaný. Pokud nahradím všechny for (int i=0; i<v.size(); ++i) za for (int i=0, count = v.size(); i < count; ++i), zrychlí to ten program o 80 %!

80% je trochu moc, ale 15 sekund to srazilo na 12. Daleko víc by se IMO dalo získat použitím 1D pole a vlastním indexováním. Takhle se taky matice píšou. Vektor vektorů se sem moc nehodí. Když už nic jiného, tak na rozdíl od matice může být každý z těch vektorů jinak dlouhý a kód by to měl správně kontrolovat.

Nahradil jsem všechny fory, ne jen jeden. Na mém počítači se tím srazil čas ze 12 sekund na 2,5.

D to dalo za 7,5 s ... C++ za 12 po optimalizaci za 11 ... ano ano, dalo se to vyřešit všemi možnými způsoby, jež by to zrychlily, ale to prosím by šlo udělat i u D ... a opět by bylo rychlejší

To není pravda. Moje zrychlení jen řekne C++, že to pole nemění velikost během výpočtů. Což je přesně to, co dělá i D.

[JSH]

Nahradil jsem všechny fory, ne jen jeden. Na mém počítači se tím srazil čas ze 12 sekund na 2,5.

Nepoužil jsi náhodou icc? Ten mi jednou podobný kód zoptimalizoval tak, až mi ho vyoptimalizoval úplně pryč.

[RAII]

No, tak sem to pěkně zoptimalizoval no ... na 700 ms takže 0,7s xDDD BTW mám 2 core pentium 3 GHZ (jo jasně někdo to bude mít i v C++ za pár milisekund když použije ňáký monstrum).  BTW, ten source code tady nedávám jen tak pro srandu, zkuste si zkompilovat i ten kód Dčka. Jasně máš to za 2,5 sekundy, ale jakej máš stroj? Skus tam zkompilovat i D a uvidíš že bude zase rychlejší!

Kód: [Vybrat]

module zkouskarychlosti;

import std.stdio;
import std.random;
import std.datetime;
import std.c.stdlib;

pure void mAdd(T)(T * matA, const T * matB, in long sm)
{
matA[0..sm] += matB[0..sm];
}

void mWrite(T)(const T * mat,in long width, in long heigth)
{
long totalS = width * heigth;
foreach (long i;0..totalS)
{
if (i == width)
writeln(" ");
write(mat[i]);
write("  ");
}
writeln(" ");
}

void main()
{
StopWatch sw;
sw.start();
int * v0 = cast(int*)malloc(1000*int.sizeof);
int * v1 = cast(int*)malloc(1000*int.sizeof);
foreach (int i;0..1000)
{
v0[i] = v1[i] = uniform(0,9);
}
foreach (int i;0..1000000)
{
mAdd(v0,v1,1000);
}
writeln(sw.peek().msecs());
sw.stop();
free(v0);
free(v1);
}