Сравнение языков на массивах. Конец

[DeepFlake]

Кратко завершаю тему сравнения языков программирования на скорость работы с одномерными массивами.

Вот рейтинг языков (время работы программы в секундах):
1. Java (динамич. массив) - 9.6678
2. С++ (контейнер) - 10.44525
3. Rust (контейнер) - 13.42855
4. Ada (контейнер) - 13.6729
5. C++ (динамич. массив) - 14.96
6. Ada (динамич. массив) - 19.7034
7. Go (динамич. массив) - 37.7775
8. Java (контейнер) - 73..84
9. Free Pascal (динамич. массив) - 89.4925

[p51x]

И вас не смущает, что С++ контейнер в 1.5 раза быстрее массива, хотя на нем основан? Не приходит в голову, что вы что-то сделали не так?

[Алексей1153]

а не смущает, что Java оказалась быстрее C++ ?

[p51x]

Сообщение от Алексей1153

а не смущает, что Java оказалась быстрее C++ ?

Неа, прогретая вм, без сборки мусора, jit с simd и простой алгоритм вполне могут потягаться с неоптимизированным кое-как написанным С++.

[Vapaamies]

Сообщение от DeepFlake

Кратко завершаю тему сравнения языков программирования на скорость работы с одномерными массивами.

Я так и не понял, что мерилось. Эффективность реализации стандартных библиотек языков? Или возможность встроенных/библиотечных типов языка прямо отражать или не отражать машинное представление массива в памяти, избегая тем самым накладных расходов? По методике Борхеса?

Если берется «динамический массив» и учитывается время его инициализации — это разве не измерение эффективности менеджера памяти? Его надо учитывать отдельно. Непременно указать, какой менеджер памяти используется (для чего знать, как устроена работа с памятью в языке). И так далее.

Сообщение от DeepFlake

1. Java (динамич. массив) - 9.6678
2. С++ (контейнер) - 10.44525
3. Rust (контейнер) - 13.42855
4. Ada (контейнер) - 13.6729
5. C++ (динамич. массив) - 14.96
6. Ada (динамич. массив) - 19.7034
7. Go (динамич. массив) - 37.7775
8. Java (контейнер) - 73..84
9. Free Pascal (динамич. массив) - 89.4925

В свете заданных вопросов важны не цифры, а масштаб. Одна секунда разницы — это много или мало? Как меняется время при увеличении/уменьшении числа элементов массива, размера элементов, числа проходов? Короче, для каждого вида тестов — своя методика, чтобы не мерить воздух. Синоптики, вон, его каждый день мерят, а с выводами у них сами знаете как.

[p51x]

2 Vapaamies, еще скажите, что надо не один раз запускать, сбрасывать кэши и стартовать java на холодную, +разрешать один набор инструкций и т.д....

[DeepFlake]

to Алексей1153:
>а не смущает, что Java оказалась быстрее C++ ?

а вот над этим и надо всем подумать, почему это так получилось в данном случае. У меня есть объяснение этому

[DeepFlake]

to Vapaamies:
>Я так и не понял, что мерилось.

Это сообщение - окончание темы. Начало темы - в сообщениях "Сравнение языков на массивах, Часть 1 и часть 2, часть 3". Там в прикреплении полный исходный текст тестов.

[DeepFlake]

Ещё раз привожу полный исходный текст теста для C++. Память выделяется заранее, измеряется только время работы с циклами между вызовами chrono::system_clock::now() :
Начало не смотрите, там чтение из файла, смотрите в самом конце.

// License: Public domain.

#include <iostream>
#include <fstream>
#include <cstddef>
#include <chrono>
#include <string>
#include <cctype>

int main()
{
    std::size_t     set1_len, set2_len;
    bool            isSubSet;
    bool            found;
    long int*       set1;
    long int*       set2;
    std::string     buf_s;
    std::size_t     processed_count;
    bool            rest_space;
    long int        buf_val;
    std::size_t     read_cnt;

    std::setlocale( LC_ALL, "C.UTF-8" );
    std::locale::global( std::locale( "C.UTF-8" ) );

    std::cout << "Проверка двух множеств на вхождение" 
        " друг в друга." << std::endl ;
    std::cout << "NO INDEX CHECK" << std::endl ;

    std::ifstream    set1_f;
    set1_f.open( "set1.txt" );
    if ( set1_f.is_open() )
    {
        if ( set1_f.bad() )
        {
            std::cerr << "Файл set1.txt: ошибка чтения файла." << std::endl ;
            set1_f.close();
            return 1;
        }
        if ( set1_f.eof() )
        {
            std::cerr << "Файл set1.txt: файл не должен быть пустым." << std::endl ;
            set1_f.close();
            return 1;
        }
        std::getline( set1_f, buf_s );
        try
        {
            buf_val = std::stol( buf_s, &processed_count );
            if ( buf_val < 1 )
            {
                std::cerr << "Файл set1.txt: длина массива должна быть положительным числом."
                    << std::endl ;
                set1_f.close();
                return 1;
            }
            set1_len = buf_val ; 
            if ( processed_count != buf_s.length() )
            {
                rest_space = true;
                for ( std::string::size_type buf_ind = processed_count; 
                        buf_ind < buf_s.length() ; ++buf_ind )
                {
                    if ( not std::isspace( buf_s.at( buf_ind ) ) )
                    {
                        rest_space = false;
                        break;
                    }
                }
                
                if ( not rest_space )
                {
                    std::cerr << "Файл set1.txt: в первой строке должно быть целое число - длина массива."
                        << std::endl ;
                    set1_f.close();
                    return 1;
                }
            }

        }
        catch ( const std::invalid_argument& ex )
        {
            std::cerr << "Файл set1.txt: в первой строке должна быть длина массива."
                << std::endl ;
            set1_f.close();
            return 1;
        }
        catch ( const std::out_of_range& ex )
        {
            std::cerr << "Файл set1.txt: в первой строке недействительная длина массива."
                << std::endl ;
            set1_f.close();
            return 1;
        }
        std::cout << "set1 len = " << set1_len << std::endl ;
        
        set1 = new long int [ set1_len ] ;
        read_cnt = 0;
        while ( read_cnt < set1_len )
        {
            if ( set1_f.bad() )
            {
                std::cerr << "Файл set1.txt: ошибка чтения файла." << std::endl ;
                set1_f.close();
                delete [] set1;
                return 1;
            }
            if ( set1_f.eof() )
            {
                std::cerr << "Файл set1.txt: в файле должны быть ещё данные." << std::endl ;
                set1_f.close();
                delete [] set1;
                return 1;
            }

            std::getline( set1_f, buf_s );
            try
            {
                set1[ read_cnt ] = std::stol( buf_s, &processed_count );
                if ( processed_count != buf_s.length() )
                {
                    rest_space = true;
                    for ( std::string::size_type buf_ind = processed_count; 
                            buf_ind < buf_s.length() ; ++buf_ind )
                    {
                        if ( not std::isspace( buf_s.at( buf_ind ) ) )
                        {
                            rest_space = false;
                            break;
                        }
                    }
                    
                    if ( not rest_space )
                    {
                        std::cerr << "Файл set1.txt: в строке " << read_cnt+2 << 
                            " должно быть целое число." << std::endl ;
                        set1_f.close();
                        delete [] set1;
                        return 1;
                    }
                }

            }
            catch ( const std::invalid_argument& ex )
            {
                std::cerr << "Файл set1.txt: в строке " << read_cnt+2 << " должно быть целое число."
                    << std::endl ;
                set1_f.close();
                delete [] set1;
                return 1;
            }
            catch ( const std::out_of_range& ex )
            {
                std::cerr << "Файл set1.txt: в строке " << read_cnt+2 << " недействительная целое число."
                    << std::endl ;
                set1_f.close();
                delete [] set1;
                return 1;
            }

            ++read_cnt;
        }
        
    }
    else
    {
        std::cerr << "Ошибка открытия файла set1.txt" << std::endl ;
        return 1;
    }
    set1_f.close();

[DeepFlake]

    std::ifstream    set2_f;
    set2_f.open( "set2.txt" );
    if ( set2_f.is_open() )
    {
        if ( set2_f.bad() )
        {
            std::cerr << "Файл set2.txt: ошибка чтения файла." << std::endl ;
            set1_f.close();
            set2_f.close();
            delete [] set1;
            return 1;
        }
        if ( set2_f.eof() )
        {
            std::cerr << "Файл set2.txt: файл не должен быть пустым." << std::endl ;
            set1_f.close();
            set2_f.close();
            delete [] set1;
            return 1;
        }
        std::getline( set2_f, buf_s );
        try
        {
            buf_val = std::stol( buf_s, &processed_count );
            if ( buf_val < 1 )
            {
                std::cerr << "Файл set2.txt: длина массива должна быть положительным числом."
                    << std::endl ;
                set1_f.close();
                set2_f.close();
                delete [] set1;
                return 1;
            }
            set2_len = buf_val ; 
            if ( processed_count != buf_s.length() )
            {
                rest_space = true;
                for ( std::string::size_type buf_ind = processed_count; 
                        buf_ind < buf_s.length() ; ++buf_ind )
                {
                    if ( not std::isspace( buf_s.at( buf_ind ) ) )
                    {
                        rest_space = false;
                        break;
                    }
                }
                
                if ( not rest_space )
                {
                    std::cerr << "Файл set2.txt: в первой строке должно быть целое число - длина массива."
                        << std::endl ;
                    set1_f.close();
                    set2_f.close();
                    delete [] set1;
                    return 1;
                }
            }

        }
        catch ( const std::invalid_argument& ex )
        {
            std::cerr << "Файл set2.txt: в первой строке должна быть длина массива."
                << std::endl ;
            set1_f.close();
            set2_f.close();
            delete [] set1;
            return 1;
        }
        catch ( const std::out_of_range& ex )
        {
            std::cerr << "Файл set2.txt: в первой строке недействительная длина массива."
                << std::endl ;
            set1_f.close();
            set2_f.close();
            delete [] set1;
            return 1;
        }
        std::cout << "set2 len = " << set2_len << std::endl ;
        
        set2 = new long int [ set2_len ] ;
        read_cnt = 0;
        while ( read_cnt < set2_len )
        {
            if ( set2_f.bad() )
            {
                std::cerr << "Файл set2.txt: ошибка чтения файла." << std::endl ;
                set1_f.close();
                set2_f.close();
                delete [] set1;
                delete [] set2;
                return 1;
            }
            if ( set2_f.eof() )
            {
                std::cerr << "Файл set2.txt: в файле должны быть ещё данные." << std::endl ;
                set1_f.close();
                set2_f.close();
                delete [] set1;
                delete [] set2;
                return 1;
            }

            std::getline( set2_f, buf_s );
            try
            {
                set2[ read_cnt ] = std::stol( buf_s, &processed_count );
                if ( processed_count != buf_s.length() )
                {
                    rest_space = true;
                    for ( std::string::size_type buf_ind = processed_count; 
                            buf_ind < buf_s.length() ; ++buf_ind )
                    {
                        if ( not std::isspace( buf_s.at( buf_ind ) ) )
                        {
                            rest_space = false;
                            break;
                        }
                    }
                    
                    if ( not rest_space )
                    {
                        std::cerr << "Файл set2.txt: в строке " << read_cnt+2 << 
                            " должно быть целое число." << std::endl ;
                        set1_f.close();
                        set2_f.close();
                        delete [] set1;
                        delete [] set2;
                        return 1;
                    }
                }

            }
            catch ( const std::invalid_argument& ex )
            {
                std::cerr << "Файл set2.txt: в строке " << read_cnt+2 << " должно быть целое число."
                    << std::endl ;
                set1_f.close();
                set2_f.close();
                delete [] set1;
                delete [] set2;
                return 1;
            }
            catch ( const std::out_of_range& ex )
            {
                std::cerr << "Файл set2.txt: в строке " << read_cnt+2 << " недействительная целое число."
                    << std::endl ;
                set1_f.close();
                set2_f.close();
                delete [] set1;
                delete [] set2;
                return 1;
            }

            ++read_cnt;
        }
        
    }
    else
    {
        std::cerr << "Ошибка открытия файла set2.txt" << std::endl ;
        set1_f.close();
        delete [] set1;
        return 1;
    }
    set2_f.close();

    std::cout << "1st arr, len=" << set1_len << ":" << std::endl;
    std::cout << "2nd arr, len=" << set2_len << ":" << std::endl;

    auto start_time = std::chrono::system_clock::now();

    isSubSet = true;
    if ( set1_len >= set2_len )
    { // первый массив больше
        for ( std::size_t ind1=0; ind1 < set2_len; ++ind1 )
        {
            found = false;
            for ( std::size_t ind2=0; ind2 < set1_len; ++ind2 )
            {
                if ( set1[ ind2 ] == set2[ ind1 ] )
                {
                    // нашли совпадение элементов
                    found = true;
                    break;
                }
            }
            if ( not found )
            {  // не все элементы set2 принадлежат set1
                isSubSet = false;
                break;
            }
        }
    }
    else 
    {  // второй массив больше
        for ( std::size_t ind1=0; ind1 < set1_len; ++ind1 )
        {  // проход по первому массиву
            found = false;
            for ( std::size_t ind2=0; ind2 < set2_len; ++ind2 )
            {  // проход по второму массиву
                if ( set1[ ind1 ] == set2[ ind2 ] )
                {  // нашли совпадение элементов
                    found = true;
                    break;
                }
            }
            if ( not found )
            {   // не все элементы set1 принадлежат set2
                isSubSet = false;
                    //  не является подмножеством
                break;
            }
        }
    }

    std::chrono::duration<double> dur =
        std::chrono::system_clock::now() - start_time;

    std::cout << "is subset = " << isSubSet << std::endl ;
    if ( set1_len >= set2_len )
    {
        if ( isSubSet )
        {
            std::cout << "Второе множество является подмножеством первого." << std::endl ;
        }
        else
        {
            std::cout << "Ни одно из данных множеств не является подмножеством другого." 
                << std::endl ;
        }
    }
    else
    {
        if ( isSubSet )
        {
            std::cout << "Первое множество является подмножеством второго." << std::endl ;
        }
        else
        {
            std::cout << "Ни одно из данных множеств не является подмножеством другого." 
                << std::endl ;
        }
    }
    
    std::cout << "Продолжительность расчёта: " << dur.count()
        << " секунд." << std::endl;

    delete [] set1;
    delete [] set2;

    return 0;
}