Ветка C по оптимизации статических переменных

Что ж, одним из способов исправить это было бы использование указателя функции для вызова метода. Инициализируйте функцию ptr вашей длинной функцией и в конце первого вызова установите для нее версию без дополнительной инициализации.

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

Короткий ответ - нет".

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

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

Здесь вы говорите буквально об одном или двух циклах, а возможно, даже и об этом, в зависимости от того, что еще процессор делает рядом с этим кодом.

[Обновить]

Если что-то подобное действительно вызывается миллионы или миллиарды раз в секунду, вы справитесь с этим, реструктурировав свой код так, чтобы инициализировать fd раньше, а затем использовать его повторно, не утруждая себя тестированием. Например, вы можете добавить вызов initGlobalState(); вверху функции main() и затем открыть файл. (Вы бы хотели, чтобы соответствующий destroyGlobalState(); закрыл его снова.)

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

В C++ конструкторы, деструкторы и идиома RAII делают такой подход очень естественным, способ.

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

static int fd;

unsigned long volatile *getReg(unsigned long addr) {
  /* do stuff with fd and addr */
  return 0;
}

int getRegSetup(void) {
  fd = open("file", O_RDWR | O_SYNC);
  if (fd < 0) return 1;                /* error */
  /* continue processing */
  return 0;                            /* ok */
}

Затем вызывающий абонент делает

  /* ... */
  if (getRegSetup()) {
    /* error */
  } else {
    do {
      ptr = getReg(42);
    } while (ptr);
  }
  /* ... */

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

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

static int g_fd = -1;

static unsigned long volatile *getReg(unsigned long addr)
{
    register int fd = g_fd;

    if (__builtin_expect ((fd > 0), 1))
    {
on_success:
        return NULL; // Do important stuff here.
    }

    fd = open("file", O_RDWR | O_SYNC);

    if (__builtin_expect ((fd > 0), 1))
    {
        g_fd = fd;
        goto on_success;
    }

    return NULL;
}

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

И если вы действительно хотите вызвать его один раз, то вам лучше перенести открытие файла в отдельную функцию, которая вызывается один раз и перед всем остальным. И да, взгляните на отзывы о профиле GCC и LTO. Это поможет вам достичь хороших результатов, не тратя слишком много времени на подобные вещи.

Кому интересно, вот что я придумал. Обратите внимание, что это модуль для более крупной, долго работающей программы. Кроме того, это не было рассмотрено, и в любом случае это плохой хак.

__attribute__((noinline)) static unsigned int volatile *get_mem(unsigned int addr) {
    static void *map = 0 ;
    static unsigned prevPage = -1U ;
    static int fd = -1;
    int poss_err = 0;
    register unsigned page = addr & ~MAP_MASK ;

    if ( unlikely(fd < 0) ) {
        if ((fd = open("/dev/mem", O_RDWR | O_SYNC)) < 0) {
            longjmp(mem_err, errno);
        }
    }
    if ( page != prevPage ) {
        if ( map ) {
            if (unlikely((munmap(map,MAP_SIZE) < 0))) poss_err = 1;
        }
        if (unlikely((map = mmap(0, MAP_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, page )) == MAP_FAILED)) longjmp(mem_err, errno);

        prevPage = page ;
    }
    return (unsigned int volatile *)((char *)map+(addr & MAP_MASK));
}

static void set_reg(const struct reg_info * const r, unsigned int val)
{
    unsigned int volatile * const mem = get_mem(r->addr);
    *mem = (*mem & (~(r->mask << r->shift))) | (val << r->shift);
}

// This isn't in the final piece. There are several entry points into this module. Just an example

static int entryPoint(unsigned int value){

    if (setjmp(mem_err)!=0) {
        // Serious error
        return -1;
    }

    for (i=0; i<n; i++) {
        if (strlen(regs[i].name) == strlen(name) &&
                strncmp(regs[i].name, name, strlen (name))==0) {

            set_reg(&regs[i], value);
            return value;
        }
    }
}

Очевидно, это не ответ на вопрос, поскольку он проверяет условие при каждом вызове.