Qual é o custo de uma chamada de função?

Question

Em comparação com

• acesso à memória Simples
• Acesso ao disco
• Acesso à memória em outro computador (na mesma rede)
• Acesso ao disco em outro computador (na mesma rede)

em C ++ no Windows.

Answer 1

tempos relativos (não deve estar fora por mais de um fator de 100; -)

• memória de acesso em cache = 1
• chamada de função / retorno em cache = 2
• memória de acesso fora do cache = 10 .. 300
• acesso ao disco = 1000 .. 1E8 (amortizado depende do número de bytes transferido)
  • dependendo principalmente sobre os tempos de busca
  • a transferência em si pode ser muito rápido
  • envolve pelo menos alguns milhares de ops, uma vez que o limite de usuário / sistema deve ser cruzado pelo menos duas vezes; um I / O pedido deve ser agendada, o resultado deve ser escrito de volta; possivelmente buffers são alocados ...
• chamadas de rede = 1000 .. 1E9 (amortizado depende do número de bytes transferido)
  • mesmo argumento com o disco i / o
  • a velocidade de transferência crua pode ser bastante elevado, mas algum processo no outro computador deve fazer o trabalho real

Answer 2

Uma chamada de função é simplesmente uma mudança do ponteiro do quadro na memória na pilha e adição de um novo quadro em cima disso. Os parâmetros da função são deslocados em registradores locais para o uso e o ponteiro da pilha é avançado para o novo topo da pilha para a execução da função.

Em comparação com o tempo

Chamada de função ~ de memória simples acesso
chamada de função chamada de função chamada de função

Answer 3

Em comparação com um acesso à memória simples - um pouco mais, insignificante realmente

.

Em comparação com qualquer outra coisa listados -. Ordens de magnitude menos

Isso deve valer para praticamente qualquer idioma em qualquer sistema operacional.

Answer 4

Em geral, uma chamada de função vai ser um pouco mais lento do que o acesso à memória, uma vez que na verdade tem a ver vários acessos de memória para executar a chamada. Por exemplo, vários empurrões e pops da pilha são necessários para a maioria das chamadas de função usando __stdcall em x86. Mas se o seu acesso à memória é uma página que não é nem mesmo no cache L2, a chamada de função pode ser muito mais rápido se o destino ea pilha estão todos em caches de memória da CPU.

Para tudo o resto, uma chamada de função é muitos (muitos) magnitudes mais rápido.

Answer 5

Difícil de responder, porque há uma série de fatores envolvidos.

Em primeiro lugar, "Access Memory Simple" não é simples. Desde a velocidades de relógio modernos, uma CPU pode adicionar dois números mais rápido do que obter um número de um lado do chip para o outro (A velocidade da luz - Não é apenas uma boa ideia, é a lei)

Assim, é a função que está sendo chamado dentro do cache de memória CPU? É o acesso à memória que você está comparando-lo também?

Em seguida, temos a chamada de função irá limpar o gasoduto instruções da CPU, que vai afetar a velocidade de uma forma não-determinista.

Answer 6

Assumindo que você quer dizer a sobrecarga da própria chamada, em vez do que o receptor pode fazer, é definitivamente muito, muito mais rápido do que todos, mas o acesso à memória "simples".

É provavelmente mais lento do que o acesso à memória, mas nota que, desde que o compilador pode fazer inlining, chamada de função sobrecarga às vezes é zero. Mesmo se não, é pelo menos possível em algumas arquiteturas que algumas chamadas para código já no cache de instrução poderia ser mais rápido do que acessar a memória principal (sem cache). Depende quantos registros precisam ser derramado para a pilha antes de fazer a chamada, e esse tipo de coisa. Consulte o seu compilador e chamando documentação convenção, embora você provavelmente não ser capaz de descobrir isso mais rápido do que desmontar o código emitido.

Além disso, note que o acesso à memória "simples" às vezes não é - se o sistema operacional tem que trazer a página a partir do disco, em seguida, você tem uma longa espera em suas mãos. O mesmo seria verdadeiro se você saltar para código atualmente paginada no disco.

Se a questão subjacente é "quando devo otimizar meu código para minimizar o número total de chamadas de função feitas?", Então a resposta é "muito perto de nunca".

Answer 7

Este link aparece muito no Google. Para referência futura, eu corri um pequeno programa em C # sobre o custo de uma chamada de função, e a resposta é: "cerca de seis vezes o custo de inline". Abaixo estão os detalhes, consulte // Output na parte inferior. UPDATE: Para maçãs comparar melhor com maçãs, eu mudei Class1.Method para retornar 'vazio', como assim: void Method1 pública () {// return 0; }
Ainda assim, em linha é mais rápido por 2x: inline (avg): 610 ms; chamada de função (avg): 1380 ms. Portanto, a resposta, atualizado, é "cerca de duas vezes".

using System; utilizando System.Collections.Generic; usando System.Linq; usando System.Text; using System.Diagnostics;

namespace FunctionCallCost { Programa classe { static void Main (string [] args) { Debug.WriteLine ( "stop1"); int Imáx = 100000000; // 100M Datetime funcCall1 = DateTime.Now; Cronómetro sw = Stopwatch.StartNew ();

        for (int i = 0; i < iMax; i++)
        {
            //gives about 5.94 seconds to do a billion loops, 
          // or 0.594 for 100M, about 6 times faster than
            //the method call.
        }

        sw.Stop(); 

        long iE = sw.ElapsedMilliseconds;

        Debug.WriteLine("elapsed time of main function (ms) is: " + iE.ToString());

        Debug.WriteLine("stop2");

        Class1 myClass1 = new Class1();
        Stopwatch sw2 = Stopwatch.StartNew();
        int dummyI;
        for (int ie = 0; ie < iMax; ie++)
        {
          dummyI =  myClass1.Method1();
        }
        sw2.Stop(); 

        long iE2 = sw2.ElapsedMilliseconds;

        Debug.WriteLine("elapsed time of helper class function (ms) is: " + iE2.ToString());

        Debug.WriteLine("Hi3");


    }
}

// Classe 1 aqui using System; utilizando System.Collections.Generic; usando System.Linq; using System.Text;

namespace FunctionCallCost { classe Class1 {

    public Class1()
    {
    }

    public int Method1 ()
    {
        return 0;
    }
}

}

// Output: stop1 tempo decorrido de função principal (ms) é: 595 stop2 tempo decorrido da função classe auxiliar (ms) é: 3780

stop1 tempo decorrido de função principal (ms) é: 592 stop2 tempo decorrido da função classe auxiliar (ms) é: 4042

stop1 tempo decorrido de função principal (ms) é: 626 stop2 tempo decorrido da função classe auxiliar (ms) é: 3755

Answer 8

O custo de realmente chamar a função, mas não executá-lo na íntegra? ou o custo de realmente executar a função? simplesmente a criação de uma chamada de função não é uma operação custosa (atualizar o PC?). mas, obviamente, o custo de uma função de executar na íntegra depende do que a função está fazendo.

Answer 9

Vamos não se esqueça de que C ++ tem chamadas virtuais (significativamente mais caros, cerca de x10) e no Windows, você pode esperar VS às chamadas inline (0 custo por definição, já que não há esquerda no binário chamada)

Answer 10

depende do que essa função faz, ele cairia 2 em sua lista se estivesse fazendo lógica com objetos na memória. Mais abaixo na lista, se incluísse disco de acesso / rede.

Answer 11

Uma chamada de função geralmente envolve apenas um par de cópias de memória (muitas vezes em registradores, de modo que não deve ocupar muito tempo) e, em seguida, uma operação de salto. Este será mais lento do que um acesso à memória, mas mais rápido do que qualquer uma das outras operações mencionadas acima, porque eles exigem a comunicação com outro hardware. O mesmo deve geralmente são verdadeiras em qualquer combinação OS / idioma.

Answer 12

Se a função é embutido em tempo de compilação, o custo da função torna-se equivelant a 0.

0, claro, sendo, o que você teria chegado por não ter uma chamada de função, ou seja:. Inlined it yourself

Isto, obviamente, soa excessivamente óbvia quando eu escrevê-lo assim.

Answer 13

O custo de uma chamada de função depende da arquitetura. x86 é consideravelmente mais lento (alguns relógios, além de um relógio ou mais por argumento de função), enquanto 64-bit é muito menos porque a maioria dos argumentos de função são passados ??nos registos em vez de na pilha.

Answer 14

Chamada de função é na verdade uma cópia de parâmetros para a pilha (acesso à memória múltipla), cadastre-se salvar, a execução de código real, e, finalmente, resultar cópia e e registros restaurar (os registros salvar / restaurar dependem do sistema).

Então .. falando relativamente:

• Chamada de função> Acesso simples memória.
• Chamada de função << Acesso ao disco -. Em comparação com a memória pode ser centenas de vezes mais caro
• Chamada de função << acesso à memória em outro computador - a largura de banda de rede e protocolo são os assassinos de tempo grande aqui
.
• Chamada de função <<< Acesso ao disco em outro computador - todos os itens acima e mais:)

Answer 15

acesso à memória Só é mais rápido do que uma chamada de função.

Mas a chamada pode ser evitado se compilador com a otimização inline (para compilador GCC (s) e não só é activado quando utilizar o nível 3 de otimização (O3)).