Comparando o desempenho de C # e C ++ para tarefas de processamento de imagem

Há uma opinião de que C # não tem lugar em tarefas computacionais, e essa opinião é bastante justificada: o compilador JIT é forçado a compilar e otimizar o código durante a execução do programa com atrasos mínimos, ele simplesmente não tem a oportunidade de gastar mais recursos computacionais para gerar um código mais eficiente , em contraste com o compilador C ++, que pode levar minutos e até horas neste assunto.

No entanto, nos últimos anos, a eficiência do compilador JIT aumentou visivelmente e vários chips úteis foram introduzidos na própria estrutura, por exemplo, intrínsecos .

E então me perguntei: é possível em 2020, usando .NET 5.0, escrever código que não seria muito inferior em desempenho ao C ++? Descobriu-se que você pode.

Motivação

Estou engajado no desenvolvimento de algoritmos de processamento de imagem e em um nível bastante baixo. Ou seja, não se trata de malabarismo com tijolos em Python, mas sim do desenvolvimento de algo novo e, de preferência, produtivo. O código Python leva um tempo inaceitavelmente longo, enquanto o uso de C ++ leva a uma diminuição na velocidade de desenvolvimento. O equilíbrio ideal entre produtividade e desempenho para tais tarefas é alcançado usando C # e Java. Confirmando minhas palavras - o projeto Fiji .

Anteriormente, usei C # para prototipagem e reescrevi algoritmos prontos que são essenciais para o desempenho em C ++, coloquei-os na biblioteca e retirei a biblioteca de C #. Mas, neste caso, a portabilidade era prejudicada e não era muito conveniente depurar o código.

Mas isso foi há muito tempo, desde então o .NET deu um passo à frente, e eu me pergunto se eu poderia abandonar a biblioteca nativa C ++ e mudar totalmente para C #?

Cenário

Vou comparar linguagens usando o exemplo de métodos básicos de processamento de imagens: soma de imagens, rotação, convolução, filtragem de mediana. São esses métodos que mais frequentemente precisam ser escritos em C ++. O tempo de execução da convolução é especialmente crítico.

Para cada um dos métodos, exceto para a filtragem de mediana, três implementações foram feitas em C # e C ++:

• Implementação ingênua usando métodos como GetPixel (x, y) e SetPixel (x, y, value);

  
  
  
  
  

• Implementação otimizada usando ponteiros e trabalhando com eles em um nível baixo;

  
  
  
  
  

• Implementação Intrinsky (AVX).

  
  
  
  
  

(Array.Sort, std::sort), , , , . .

, , C# unmanaged - . - , C++ UB , C# - .

Github, , C#:

[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public static void Sum_ThisProperty(NativeImage<float> img1, NativeImage<float> img2, NativeImage<float> res)
{
    for (var j = 0; j < res.Height; j++)
    for (var i = 0; i < res.Width; i++)
        res[i, j] = img1[i, j] + img2[i, j];
}

[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public static void Sum_Optimized(NativeImage<float> img1, NativeImage<float> img2, NativeImage<float> res)
{
    var w = res.Width;

    for (var j = 0; j < res.Height; j++)
    {
        var p1 = img1.PixelAddr(0, j);
        var p2 = img2.PixelAddr(0, j);
        var r = res.PixelAddr(0, j);

        for (var i = 0; i < w; i++)
            r[i] = p1[i] + p2[i];
    }
}

[MethodImpl(MethodImplOptions.AggressiveOptimization)]
public static void Sum_Avx(NativeImage<float> img1, NativeImage<float> img2, NativeImage<float> res)
{
    var w8 = res.Width / 8 * 8;

    for (var j = 0; j < res.Height; j++)
    {
        var p1 = img1.PixelAddr(0, j);
        var p2 = img2.PixelAddr(0, j);
        var r = res.PixelAddr(0, j);

        for (var i = 0; i < w8; i += 8)
        {
            Avx.StoreAligned(r, Avx.Add(Avx.LoadAlignedVector256(p1), Avx.LoadAlignedVector256(p2)));

            p1 += 8;
            p2 += 8;
            r += 8;
        }
        
        for (var i = w8; i < res.Width; i++)
            *r++ = *p1++ + *p2++;
    }
}

      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

. (1/10 ) 256x256 float 32 bit.

: Convolve 7x7 (avx*) - , , .

Core i7-2600K @ 4.0 GHz.

:

• (avx), C#, , C++. , C# !

  
  
  
  
  

• C# , C# , C++ .

  
  
  
  
  

• C# C++ 2 6 . .

  
  
  
  
  

, C# , C++. : , C++ , C# . C#, C++.

P.S. .NET - - . (, ), C++ , , , C# , .