Может ли C# догнать C?

Современное сообщество программистов разбито на два лагеря - на тех, кто любит языки программирования с управляемой памятью, и тех кто их не любит. Два лагеря яро спорят друг с другом, ломая копья по поводу преимуществ в каком-то из аспектов программирования. Языки с неуправляемой памятью представляются как более быстрые, управляемые, контролируемые. А языки с управляемой памятью считаются более удобными в разроботке, в то время как их отставание по скорости выполнения и потребляемой памяти считается несущественным. В этой статье мы проверим, так ли это на самом деле. Со стороны олдскульных языков программирования выступит мастодонт мира разработки - С.
Сторону языков последних поколений будет представлять С#.

Статья носит ознакомительный характер и не претендует на комплексное сравнение. Полноценного тестирования проведено не будет, но будут приведены тесты, которые сможет повторить любой разработчик на своем компьютере.

Поскольку главным отличием одного языка от другого является управляемая память, на обращение с этой памятью мы и будем смотреть. А именно - будем смотреть на скорость записи в оперативную память.

Тестов на которых можно проверить разницу множество, но в рамках наших тестов мы будем заполнять последовательный блок памяти размером 1 GB.

В случае C это будет последовательный блок неуправляяемой помяти, полученный с помощью malloc, а в случае C# мы рассмотрим как блок памяти находящийся в управляемой куче, так и блок неуправляемой памяти в адресном пространстве процесса.

C# позволяет нам работать с неуправляемой памятью.

За счет чего может появиться разница во времени исполнения этой операции?

Код, который мы будем сравнивать, в конечном итоге превратится в инструкции для процессора, которые этот процессор будет выполнять. Однако, когда мы говорим о С, мы понимаем, что компилятор может оптимизировать написанный нами код. В случае же C# ситуация еще сложнее. В обычных условиях код будет скомпилирован в промежуточный язык CIL, который затем будет с помощью компиляции реального времени (JIT) скомпилирован в набор инструкций, которые будут исполняться. Код может быть оптимизирован на обоих этапах.
Именно сравнение этих оптимизаций двух языков программирования нам и интересно.

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

Тест №1
Для начала посмотрим на ситуацию без оптимизаций

Будем смотреть на итеративную запись блоками по 1 байту. Код чуть сложнее, чем требуется для теста. Это сделано для того, чтобы результаты времени его работы можно было сравнивать с другими результами, полученными в рамках этой статьи.

Первым выполним код на C

_{Просто скомпилируем его, не указывая компилятору, что нужно применить оптимизации}

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <stddef.h>

#define MEMSIZE (1l << 30)
#define CLOCK_IN_MS (CLOCKS_PER_SEC / 1000)
#define ITERATIONS 10



int main(int argc, char **argv)
{
    const size_t mem_size = MEMSIZE;
    const size_t cache_line_size = sysconf (_SC_LEVEL1_DCACHE_LINESIZE);
    clock_t start_clock;
    long diff_ms = 0;
    char *mem, *arr, *stop_addr, *ix_line;
    ptrdiff_t ix_char = 0;
    const char c = 1;
    int iter = 0;
    const int iter_count = ITERATIONS;
    
    printf("memsize=%zxh sizeof(size_t)=%zx cache_line=%lun", 
            mem_size, sizeof(mem_size), cache_line_size
    );

    if (!(mem = malloc(mem_size + cache_line_size))){
        fprintf(stderr, "unable to allocate memoryn");
        return -1;
    }

    arr = mem + cache_line_size - (long)mem % cache_line_size;

    stop_addr = arr + mem_size;

    for (iter = 0 ; iter < iter_count; ++iter) {
        start_clock = clock();
        for ( ix_line = arr; ix_line < stop_addr ; ix_line += cache_line_size) {
            for (ix_char = 0 ; ix_char < cache_line_size ; ++ix_char) {
                *(ix_line + ix_char) = c;
            }
        }
        diff_ms = (clock() - start_clock) / CLOCK_IN_MS;
        printf("iter=%d seq time=%lun", iter, diff_ms);
    }

    free(mem);

    return 0;
}

Результаты:

Теперь посмотрим на C# и массив в куче

using System.Diagnostics;

const int typicalItarationsCount = 10;
const int arraySize = 1073741824;
const int lineLength = 64;
const int linesCount = arraySize / lineLength;

var tmpArray = new bool[arraySize];
for(var iteration = 0; iteration < typicalItarationsCount; ++iteration)
{
    var watch = new Stopwatch();
    watch.Start();
    for(long i = 0; i < linesCount; ++i)
    {
        for(long j = 0; j < lineLength; ++j)
        {
            tmpArray[i * lineLength + j] = true;
        }
    }
    watch.Stop();
    tmpArray = new bool[arraySize];
    Console.WriteLine($"iter={iteration} seq time={watch.ElapsedMilliseconds}");
}

Результаты:

А теперь посмотрим на неуправляемую память в C#

_{Для работы с указателями в C# необходимо пометить блок кода ключевым словом "unsafe", а так же добавить в файл .csproj блок указывающий, что сборка будет работать с таким кодом.}

<Project Sdk="Microsoft.NET.Sdk">

  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <PropertyGroup>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  </PropertyGroup>
</Project>

using System.Diagnostics;
using System.Runtime.InteropServices;

unsafe 
{
    const int typicalItarationsCount = 10;
    const int arraySize = 1073741824;
    const int lineLength = 64;
    const int linesCount = arraySize / lineLength;

    for(var iteration = 0; iteration < typicalItarationsCount; ++iteration)
    {
        bool* buffer = (bool*)NativeMemory.Alloc((nuint) arraySize, sizeof(bool));
        var readPtr = buffer;
        var endPtr = buffer + arraySize;
        var watch = new Stopwatch();
        watch.Start();
        for(long i = 0; i < linesCount; ++i)
        {
            for(long j = 0; j < lineLength; ++j)
            {
                *readPtr = true;
                ++readPtr;
            }
        }
        watch.Stop();
        NativeMemory.Free(buffer);
        Console.WriteLine($"iter={iteration} seq time={watch.ElapsedMilliseconds}");
    }
}

Результаты:

Без применения специальных оптимизаций, C проиграл соревнование по скорости в 7 раз по сравнению с массивами в куче C#, и в 4 раза по сравнению с использованием неуправляемой помяти в C#. Результаты уже интересны.

Тест №2
Теперь скомпилируем C код с максимальными возможными оптимизациями
_{- используем аргумент командной строки для gcc "-Wall -O4"}

Результаты:

Как и предполагалось, оптимизированный код на C показывает впечатляющие результаты
Но эти результаты впечатляют по сравнению с результатами неоптимизированного специально кода на C#.

Попробуем использовать оптимизации в C# при работе с массивом в куче

_{Для этого необходимо добавить в .csproj файл секцию, включающую оптимизации выполняемые компилятором}

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <PropertyGroup>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  </PropertyGroup>
  <PropertyGroup>
    <Optimize>true</Optimize>
  </PropertyGroup>
</Project>

Результаты:

Попробуем использовать оптимизации в C# при работе с неуправляемой помятью

Результаты:

Видно, что попытка указать компилятору C#, что код нужно оптимизировать, к улучшению результатов не приводит.

Может быть дело в JIT-компиляции? Последяя версия C# позволяет использовать AOT-компиляцию.

Тест №3
Попробуем скомпилировать C# код нативно для нашего компьютера.

Для исполнения такого файла нам не нужен будет dotnet

_{Для этого .csproj должен содержать секцию добавляющую нативную публикацию}

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net8.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
  </PropertyGroup>
  <PropertyGroup>
    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
  </PropertyGroup>
  <PropertyGroup>
    <Optimize>true</Optimize>
  </PropertyGroup>
  <PropertyGroup>
    <PublishAot>true</PublishAot>
    <OptimizationPreference>Speed</OptimizationPreference>
  </PropertyGroup>
</Project>

Результаты для массивов в куче:

Результаты для неуправляемой памяти:

Прироста производительности тоже не наблюдается

Вывод

C# проигрывает C при последовательной записи в оперативную память примерно в 8 раз. Это происходит из-за того, что оптимизации компилятора C превосходят оптимизации которые претерпевает C# код, превращаясь в машинные коды. Однако, эти оптимизации бесполезны при непоследовательной записи в память, что будет видно в следующем тесте. Сторонние факторы, такие как физическая реализация процессора, влияют на многие операции сильнее, чем разница в программах, написанных на этих языках

Немного теории

Центральным элементом современного компьютера является процессор. У процессора есть кеш-линии - последовательные кусочки памяти, в которые загружаются данные, с которыми процессор будет работать. Загрузка кеш-линии довольно дорогая операция, поэтому, если возможно, такие операции нужно минимизировать. Предполагаем, что для заполнения блока оперативной памяти, с последовательной записью данных, число загрузок данных в кеш-линии процессора и последующих копирований этих данных в оперативную память будет минимально. А при непоследовательной записи в память, когда для каждой следующей итерации кеш-линию необходимо перезагружать, - максимально.

Поэтому проведем следующий тест.

Тест №4
Посмотрим на C код не последовательно пишущий в память

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include <stddef.h>

#define MEMSIZE (1l << 30)
#define CLOCK_IN_MS (CLOCKS_PER_SEC / 1000)
#define ITERATIONS 10



int main(int argc, char **argv)
{
    const size_t mem_size = MEMSIZE;
    const size_t cache_line_size = sysconf (_SC_LEVEL1_DCACHE_LINESIZE);
    clock_t start_clock;
    long diff_ms = 0;
    char *mem, *arr, *stop_addr, *ix_line;
    ptrdiff_t ix_char = 0;
    const char c = 1;
    int iter = 0;
    const int iter_count = ITERATIONS;
    
    printf("memsize=%zxh sizeof(size_t)=%zx cache_line=%lun", 
            mem_size, sizeof(mem_size), cache_line_size
    );

    if (!(mem = malloc(mem_size + cache_line_size))){
        fprintf(stderr, "unable to allocate memoryn");
        return -1;
    }

    arr = mem + cache_line_size - (long)mem % cache_line_size;

    stop_addr = arr + mem_size;

    for (iter = 0 ; iter < iter_count; ++iter) {
        start_clock = clock();
        for (ix_char = 0 ; ix_char < cache_line_size ; ++ix_char) {
            for ( ix_line = arr; ix_line < stop_addr ; ix_line += cache_line_size) {
                *(ix_line + ix_char) = c;
            }
        }
        diff_ms = (clock() - start_clock) / CLOCK_IN_MS;
        printf("iter=%d unseq time=%lun", iter, diff_ms);
    }

    free(mem);

    return 0;
}

Непоследовательный доступ в C#. Массив в куче

using System.Diagnostics;

const int typicalItarationsCount = 10;
const int arraySize = 1073741824;
const int lineLength = 64;
const int linesCount = arraySize / lineLength;

var tmpArray = new bool[arraySize];
for(var iteration = 0; iteration < typicalItarationsCount; ++iteration)
{
    var watch = new Stopwatch();
    watch.Start();
    for(long i = 0; i < lineLength; ++i)
    {
        var currentLineStart = 0;
        for(long j = 0; j < linesCount; ++j)
        {
            tmpArray[currentLineStart + i] = true;
            currentLineStart += lineLength;
        }
    }
    watch.Stop();
    Console.WriteLine($"iter={iteration} seq time={watch.ElapsedMilliseconds}");
}

Результаты:

Непоследовательный доступ в C#. Неуправляемая память

using System.Diagnostics;
using System.Runtime.InteropServices;

unsafe 
{
    const int typicalItarationsCount = 10;
    const int arraySize = 1073741824;
    const int lineLength = 64;
    const int linesCount = arraySize / lineLength;

    for(var iteration = 0; iteration < typicalItarationsCount; ++iteration)
    {
        bool* buffer = (bool*)NativeMemory.Alloc((nuint) arraySize, sizeof(bool));
        var readPtr = buffer;
        var endPtr = buffer + arraySize;
        var watch = new Stopwatch();
        watch.Start();
        for(long i = 0; i < lineLength; ++i)
        {
            readPtr = buffer + i;
            for(long j = 0; j < linesCount; ++j)
            {
                *readPtr = true;
                readPtr += lineLength;
            }
        }
        watch.Stop();
        NativeMemory.Free(buffer);
        Console.WriteLine($"iter={iteration} seq time={watch.ElapsedMilliseconds}");
    }
}

Результаты:

Для тестов специально были выбраны такие реализации программ, чтобы разница арифметических операциях не влияла на время исполнения.

P.S.: Это мой первый опыт написания подобных статей, не судите строго за шероховатости.