Привет.

x64, какая из реализаций более эффективна на ваш взгляд? более предпочтительна? Ваше мнение.

Спасибо.

void f() {
    // 1 вариант
    int64_t some_position = 0;
    calculate_new_position(&some_position);
}

void calculate_new_position(int64_t* position) {
    *position += some_offset;
}



void h() {
    // 2 вариант
    int64_t some_position = 0;
    int64_t new_position = get_new_position_after(some_position);

    // 2.1 вариант
    int64_t new_position = get_new_position_after_with_ref(some_position);
}

int64t_ get_new_position_after(const int64_t aposition) {
    int64_t position = aposition;
    for(int i = 0; i < 1000; ++i)
        position += some_offset;
    return position;
}

int64t_ get_new_position_after_with_ref(const int64_t& aposition) {
    int64_t position = aposition;
    for(int i = 0; i < 1000; ++i)
        position += some_offset;
    return position;
}

Здравствуйте, kvasya, Вы писали:


K>x64, какая из реализаций более эффективна на ваш взгляд? более предпочтительна? Ваше мнение.

Насчёт эффективности. Я бы задавал подобный вопрос профайлеру, а не участникам форума )

Здравствуйте, kvasya, Вы писали:

K>какая из реализаций более эффективна на ваш взгляд?

Если функция компилируется в несколько элементарных команд, и объявлена инлайновой — второй вариант предпочтительнее, поскольку компилятор легко может встроить ее в любую формулу.

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

Здравствуйте, ArtDenis, Вы писали:

AD>Насчёт эффективности. Я бы задавал подобный вопрос профайлеру, а не участникам форума )

Это дискуссия с коллегой, о сферическом коде в вакууме.

Здравствуйте, kvasya, Вы писали:
K>

K>position_t get_new_position(const position_t position) 
K>{
K>    for(int i = 0; i < 1000; i++)
K>        position += some_offset; // хотя тут, конечно в случае константного оффсета цикл не нужен :)
K>    return position;
K>}
K>

Здравствуйте, kvasya, Вы писали:

K>Привет.
K>x64, какая из реализаций более эффективна на ваш взгляд? более предпочтительна? Ваше мнение.
K>Спасибо.


За эффективность не скажу, к тому же, она наверняка будет определяться
нюансами компилятора и контекстом (наличием свободных регистров и т.п.).

А по критерию "минимального удивления" я бы выбрал вариант 2.

Здравствуйте, kvasya, Вы писали:

K>x64, какая из реализаций более эффективна на ваш взгляд? более предпочтительна? Ваше мнение.

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

Но, поскольку семантика использования функции — это автоинкремент, получается выбор между записями
x += n
x = x+n

Второе более многословно и грозит ошибками

pos1 = get_new_position_after(pos1);
pos1 = get_new_position_after(pos2); // вместо автоинкремента прибавили не к тому...
pos1 = get_new_position_after(pos2); // вместо автоинкремента прибавили опять к старому...

Так что, на вкус и цвет тамбовский волк.

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

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

position_t get_new_position(position_t old); // здесь избавились от ссылки
// возможно, это облегчит жизнь компилятору, позволит ему оптимизировать реализацию

inline void update_position(position_t& pos) // не даёт ошибиться, и легко инлайнится
{
  pos = get_new_position(pos);
}