Какова стоимость вызова функции?

Только доступ к памяти быстрее, чем вызов функции.

, Но вызов может избежаться, если компилятор со встроенной оптимизацией (для компилятора (компиляторов) GCC и не только это активируется при использовании уровня 3 оптимизации (-O3)).

Вызов функции является на самом деле копией параметров на стек (несколько доступ к памяти), регистр сохраняют, фактическое выполнение кода, и наконец заканчиваются копия и и восстановление регистров (регистры сохраняют/восстанавливают, зависят от системы).

Так.. разговор относительно:

• Вызов функции> Простой доступ к памяти.
• Вызов функции < < Доступ к диску - по сравнению с памятью это могут быть сотни более дорогих времен.
• Вызов функции < < Доступ к памяти на другом компьютере - сетевая пропускная способность и протокол является главными уничтожителями времени здесь.
• Вызов функции < < < Доступ к диску на другом компьютере - все вышеупомянутое и больше:)

Стоимость вызова функции зависит от архитектуры. x86 значительно медленнее (несколько часов плюс приблизительно одни часы на аргумент функции), в то время как 64-разрядный намного меньше, потому что большинство аргументов функции передается в регистрах вместо на стеке.

Если функция встраивается во время компиляции, стоимость функции становится equivelant к 0.

0, конечно, быть, что Вы продвинулись бы, не имея вызова функции, т.е.: встроенный это самостоятельно.

Это, конечно, звучит чрезмерно очевидным, когда я пишу его как этот.

Вызов функции обычно включает просто несколько копий памяти (часто в регистры, таким образом, они не должны занимать много времени), и затем операция перехода. Это будет медленнее, чем доступ к памяти, но быстрее, чем любая из других упомянутых выше операций, потому что они требуют связи с другими аппаратными средствами. То же должно обычно сохраняться на любой комбинации ОС/языка.

Давайте не забывать, что C++ имеет виртуальные вызовы (значительно более дорогой, о x10), и в Windows можно ожидать, что VS встроит вызовы (0 стоимости по определению, поскольку нет никакого вызова, оставленного в двоичном файле)

Зависит от того, что делает та функция, она упала бы 2-я на Ваш список, если бы она делала логику с объектами в памяти. Далее вниз список, если это включало диск/доступ к сети.

Принятие Вас означает издержки самого вызова, а не что мог бы сделать вызываемый, это определенно далеко, намного более быстро, чем все кроме "простого" доступа к памяти.

Это, вероятно, медленнее, чем доступ к памяти, но обратите внимание, что, так как компилятор может сделать встраивание, вызов функции наверху иногда является нулем. Даже если не, по крайней мере, возможно на некоторой архитектуре, что некоторые вызовы уже для кодирования в кэше инструкции могли быть более быстрыми, чем доступ к основной (некэшируемой) памяти. Это зависит, сколько регистры должны быть пролиты для укладки прежде, чем выполнить вызов и такую вещь. Консультируйтесь со своей документацией компилятора и соглашения о вызовах, хотя Вы вряд ли будете в состоянии понять его быстрее, чем разборка испускаемого кода.

Также примечание, что "простой" доступ к памяти иногда не - если ОС должна ввести страницу от диска тогда, у Вас есть долгое ожидание на Ваших руках. То же было бы верно, если Вы вскакиваете в код, в настоящее время разбиваемый на страницы на диске.

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

Трудно для ответа, потому что существует много включенных факторов.

, В первую очередь, "Простой Доступ к памяти" не прост. С тех пор в современных тактовых частотах, ЦП может добавить два числа быстрее, чем это получает число от одной стороны микросхемы к другому (Скорость света - Это не просто хорошая идея, это - ЗАКОН)

Так, функция называет в кэше памяти ЦП? Доступ к памяти, Вы сравниваете его также?

Тогда у нас есть вызов функции, очистит конвейер инструкции по ЦП, который будет влиять на скорость недетерминированным способом.

В целом вызов функции будет немного медленнее, чем доступ к памяти, так как это на самом деле должно сделать несколько доступов памяти для выполнения вызова. Например, несколько нажатий и появляются стека, требуются для большей части использования вызовов функции __ stdcall на x86. Но если Ваш доступ к памяти к странице, которая не находится даже в кэше L2, вызов функции может быть намного быстрее, если место назначения и стек - все в кэшах памяти ЦП.

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

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

По сравнению с перечисленным всем остальным - порядки величины меньше.

Это должно сохраняться для примерно любого языка на любой ОС.

Вызов функции является просто сдвигом указателя кадра в памяти на стек и добавление нового кадра вдобавок ко всему Параметры функции смещаются в локальные регистры для использования, и указатель вершины стека совершенствуется к новой вершине стека для выполнения функции.

По сравнению со временем

Вызов функции ~ простой доступ к памяти
Вызов функции < Доступ к диску
Вызов функции < доступ к памяти на другом компьютере
Вызов функции < доступ к диску на другом компьютере

Стоимость фактического вызывания функции, но не выполнения его полностью? или стоимость фактического выполнения функции? просто установка вызова функции не является дорогостоящей операцией (обновите ПК?). но очевидно стоимость функционального выполнения полностью зависит от того, что делает функция.

Эта ссылка часто встречается в Google. Для справки в будущем я запустил небольшую программу на C # о стоимости вызова функции и получил ответ: «примерно в шесть раз дороже встроенного». Подробности ниже, см. // Вывод внизу. ОБНОВЛЕНИЕ. Чтобы лучше сравнивать яблоки с яблоками, я изменил Class1.Method, чтобы он возвращал void, а именно: public void Method1 () {// return 0; }
Тем не менее, inline быстрее в 2 раза: inline (avg): 610 мс; вызов функции (средн.): 1380 мс. Итак, обновленный ответ - «примерно два раза».

с использованием System; с использованием System.Collections.Generic; с использованием System.Linq; с использованием System.Text; с использованием System.Diagnostics;

namespace FunctionCallCost { class Program { static void Main (string [] args) { Debug.WriteLine ("стоп1"); int iMax = 100000000; // 100M DateTime funcCall1 = DateTime.Now; Секундомер 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");


    }
}

// Класс 1 здесь using System; using System.Collections.Generic; using System.Linq; using System.Text;

пространство имен FunctionCallCost { class Class1 {

    public Class1()
    {
    }

    public int Method1 ()
    {
        return 0;
    }
}

}

// Вывод: stop1 истекшее время основной функции (мс): 595 stop2 прошедшее время вспомогательного класса функция (мс): 3780

stop1 Истекшее время основной функции (мс): 592 stop2 Истекшее время функции вспомогательного класса (мс): 4042

stop1 Истекшее время основной функции (мс): 626 stop2 Истекшее время функции вспомогательного класса (мс): 3755