Performance Multithreading vs Single-Threading C#

Pessoal,
Boa tarde!

Estou fazendo alguns testes para tentar dar um improve na performance de um processo no projeto que estou trabalhando, o cenário é o seguinte;

Realizei alguns testes fazendo a mesma ação sendo na primeira com duas threads e a segunda somente com uma. Os resultados obtidos mostra que mesmo aumentando a quantidade de dados a “processar” o single foi mais rápido (coisa de 150ms em média por teste).

O Teste era criar um array de inteiros com 30000 números quaisquer, iterar sobre os mesmos e retornar o valor final. Utilizando duas threads eu quebrei o 30000 em dois, processando de 0 a 15000 em uma e de 15001 a 3000 em outra. No single processava do 0 ao 30000 diretamente.

Resultados Obtidos

Single-Thread:

TESTE | RESULTADO
1 º - 2.130 MS
2 º - 2.074 MS

Multithreading:
TESTE | RESULTADO
1 º - 2.314 MS
2 º - 2.218 MS

Algumas dúvidas:
1º - O que eu estou fazendo de errado?.
2º - Quais considerações tenho que ter nestes testes?
3º - Comentários! =)

Maquina utilizada no teste [EDIT]
Processador: Intel Core i7-4600u VPro CPU 2.70 ghz
Memória RAM: 8GB
SO: Windows 8

Obrigado pela colaboração de todos! =)

Segue abaixo o código utilizado:

MAIN Single -Thread

 static void Main(string[] args)
        {
            //CRIANDO ARRAY
            int[] numbers = new int[30000];

            for (int i = 0; i < 30000; i++)
            {
                numbers[i] = i + i + 1;
            }

            //RESULT TEST
            int uniqueresult = 0;

            uniqueresult = Program(0, 30000, numbers,1);
  
            Console.WriteLine("Resultado1: " + uniqueresult);
        }

MAIN Multithreading

static void Main(string[] args)
        {
            //ARRAY
            int[] numbers = new int[30000];

            for (int i = 0; i < 30000; i++)
            {
                numbers[i] = i + i + 1;
            }

            //RESULT TEST
            int result1 = 0;
            int result2 = 0;
        
            //FIRST PROGRAM
            Thread thread1 = new Thread(() => result1 = Program(0, 15000, numbers, 1));
            thread1.Start();

            //SECOND PROGRAM
            Thread thread2 = new Thread(() => result2 = Program(15001, 30000, numbers, 2));
            thread2.Start();
            
            thread1.Join();
            thread2.Join();

            Console.WriteLine("Resultado1: " + (result1+result2));
        }

MÉTODO Program

public static int Program(int initial,int end,int[] values,int programaNumero)
        {
            //RETURN VALUE
            int value = 0;

            //SUM
            for (int i = initial; i < end; i++)
            {
                Console.WriteLine($"[PROGRAMA{programaNumero}] - Posicao: {i},  Valor: {values[i]} ");
                value += values[i];
            }

            return value;
        }

eu ACHO que 30000 elementos em um array talvez seja pouco para vc ser beneficiado pelo uso de thread sendo que vc tem um overhead pelo uso de threads.

o q eu faria:

  1. copie o seu programa “single-thread” para “no-thread”.
  2. altere o single-thread para iniciar uma thread que vai executar o programa e fazer um join no final.

motivação: vc pode ver a diferença entre no-thread ( original ) para single-thread.

  1. tenha 2 versões multi-thread: 2 e 4 threads.

motivação: ver como o problema muda com a adição de threads.

  1. retire esses console.writeline. no inicio de cada Main() vc pegue o tempo corrente ( DateTime.Now ) e antes de acabar pegue o tempo corrente de novo e então faça uma subtração.

motivação: isso vai te dar o tempo que vc gastou dentro do Main e não vai levar em conta o overhead do seu programa ( inicia, carrega coisas, etc ).

  1. faça 3 tipos de benchmark: 1000, 30000 e 3000000 elementos no array

dessa forma, vc pode ter uma ideia dos beneficios ou não de usar threads.

  1. para um teste de X threads ( 0, 1, 2, … ) e um dado tamanho, rode algumas vezes e calcule a media. varias coisas podem acontecer durante o benchmark então uma boa estatistica vai ajudar.

provavelmente com mais threads, com muitos elementos vc deve ver alguma vantagem. se vc for pra 8 threads talvez seja melhor ainda ( porem isso não escala “para sempre” e uma hora vc chega num limite, que tem haver com a arquitetura do seu processador etc)

  1. leia sobre benchmark tests. provavelmente vc tera outros insights.
1 curtida

Obrigado pelo seu comentário, excelente!

veja se ajuda:

http://jonskeet.uk/csharp/benchmark.html