Что делает __asm__ __volatile в C?

Я просмотрел код C из

http://www.mcs.anl.gov/~kazutomo/rdtsc.html

Они используют такие вещи, как " встроенный", " asm" и т.д., например:

code1:

static __inline__ tick gettick (void) {
    unsigned a, d;
    __asm__ __volatile__("rdtsc": "=a" (a), "=d" (d) );
    return (((tick)a) | (((tick)d) << 32));
}

code2:

volatile int  __attribute__((noinline)) foo2 (int a0, int a1) {
    __asm__ __volatile__ ("");
}

Мне было интересно, что делает код1 и code2?

Ответы

Ответ 1

Модификатор __volatile__ в блоке __asm__ заставляет оптимизатор компилятора выполнять код как есть. Без него оптимизатор может подумать, что он может быть удален или удален из цикла и кэширован.

Это полезно для команды rdtsc, например:

__asm__ __volatile__("rdtsc": "=a" (a), "=d" (d) )

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

При использовании в одиночку, например:

__asm__ __volatile__ ("")

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

__asm__ __volatile__ ("":::"memory")

Инструкция rdtsc является хорошим примером нестабильности. rdtsc обычно используется, когда вам нужно время, какое количество команд требуется выполнить. Представьте себе такой код, где вы хотите выполнить время r1 и r2:

__asm__ ("rdtsc": "=a" (a0), "=d" (d0) )
r1 = x1 + y1;
__asm__ ("rdtsc": "=a" (a1), "=d" (d1) )
r2 = x2 + y2;
__asm__ ("rdtsc": "=a" (a2), "=d" (d2) )

Здесь компилятору разрешено кэшировать временную метку, а допустимый вывод может показать, что каждая строка занимает ровно 0 тактов. Очевидно, это не то, что вы хотите, поэтому вы вводите __volatile__ для предотвращения кеширования:

__asm__ __volatile__("rdtsc": "=a" (a0), "=d" (d0))
r1 = x1 + y1;
__asm__ __volatile__("rdtsc": "=a" (a1), "=d" (d1))
r2 = x2 + y2;
__asm__ __volatile__("rdtsc": "=a" (a2), "=d" (d2))

Теперь вы будете получать новую временную метку каждый раз, но у нее все еще есть проблема, что и компилятор, и процессор могут изменить порядок всех этих операторов. Это может привести к выполнению блоков asm после того, как r1 и r2 уже были рассчитаны. Чтобы обойти это, вы должны добавить некоторые барьеры, которые вызывают сериализацию:

__asm__ __volatile__("mfence;rdtsc": "=a" (a0), "=d" (d0) :: "memory")
r1 = x1 + y1;
__asm__ __volatile__("mfence;rdtsc": "=a" (a1), "=d" (d1) :: "memory")
r2 = x2 + y2;
__asm__ __volatile__("mfence;rdtsc": "=a" (a2), "=d" (d2) :: "memory")

Обратите внимание на инструкцию mfence здесь, которая обеспечивает барьер на стороне процессора и спецификатор "памяти" в энергозависимом блоке, который обеспечивает защиту от компиляции. На современных процессорах вы можете заменить mfence:rdtsc на rdtscp для чего-то более эффективного.

Ответ 2

asm предназначен для включения собственного кода сборки в исходный код C. Например.

int a = 2;
asm("mov a, 3");
printf("%i", a); // will print 3

Составители имеют разные варианты. __asm__ должен быть синонимом, возможно, с некоторыми отличиями от компилятора.

volatile означает, что переменная может быть изменена извне (ака не программой C). Например, при программировании микроконтроллера, где адрес памяти 0x0000x1234 сопоставляется с определенным интерфейсом устройства (т.е. При кодировании GameBoy доступ к кнопкам/экрану/и т.д.)

volatile std::uint8_t* const button1 = 0x00001111;

Эта отключенная оптимизация компилятора, которая полагается на *button1, не изменяется, если не изменена кодом.

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

inline - это подсказка для компилятора для "встроенных" вызовов функции.

inline int f(int a) {
    return a + 1
}

int a;
int b = f(a);

Это не следует компилировать в вызов функции f, а в int b = a + 1. Как будто f где макрос. Компиляторы в основном делают эту оптимизацию автоматически в зависимости от использования/содержимого функции. __inline__ в этом примере может иметь более конкретное значение.

Сходство __attribute__((noinline)) (специфичный для GCC синтаксис) предотвращает встраивание функции.

Ответ 3

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

Квалификатор __volatile__, обычно используемый в системах реального времени для встроенных систем, решает проблему с тестами компилятора status register для бит ERROR или READY, вызывающим проблемы при оптимизации. __volatile__ был представлен как способ сообщить компилятору, что объект подвержен быстрым изменениям, и заставить каждую ссылку объекта быть подлинной ссылкой.