Вызов функции указателем, находящимся в массиве при изменении содержимого массива

Question

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

Что произойдет, если содержимое массива указателей функций будет изменено во время этого процесса? Можно ли считать вызовы функций достаточно атомными, чтобы быть уверенными в том, что ничего неожиданного не происходит или нужно не менять указатели на функции, например, когда происходит нажатие на стек?

Следующий пример (псевдошум). init() запускается один раз при запуске, а функция callFunctions() запускается периодически, скажем, раз в секунду. Затем изменяется changeFunctions() и изменяет содержимое функцииPtrArray []. Это может произойти в любой момент времени, поскольку код запускается в разных процессах как ОС, подобный среде.

void (*functionPtrArray[3]) (void); 

void init(void) 
{ 
    functionPtrArray[0] = function1; 
    functionPtrArray[1] = function2; 
    functionPtrArray[2] = function3; 
} 

void callFunctions(void) 
{ 
    for (i = 0; i < 3; i++) 
    { 
     *functionPtrArray[i](); 
    } 
} 

void changeFunctions(void) 
{ 
    functionPtrArray[0] = newFunction1; 
    functionPtrArray[1] = newFunction2; 
    functionPtrArray[2] = newFunction3; 
} 

Answer 1

редактировать: Я был слишком длинным и упреждающий Лундин: https://stackoverflow.com/a/42201493/5592711

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

Например, в этом фрагменте some_function() будет выполняться штраф и не зависит от модификации ptr.

void(*ptr)(void) = &some_function; 
(*ptr)(); 
// ... in another thread, while 'some_function()' is executing 
ptr = &other_function; 

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

Чтобы обеспечить синхронизацию между потоками, вы можете использовать mutexes, например, используя библиотеку pthread (вы можете сами Google, вы найдете много информации).

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

// You can use static mutex initialization 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 

void callFunctions(void) 
{ 
    pthread_mutex_lock(&mutex); 
    for (i = 0; i < 3; i++) 
    { 
     *functionPtrArray[i](); 
    } 
    pthread_mutex_unlock(&mutex); 
} 

void changeFunctions(void) 
{ 
    pthread_mutex_lock(&mutex); 
    functionPtrArray[0] = newFunction1; 
    functionPtrArray[1] = newFunction2; 
    functionPtrArray[2] = newFunction3; 
    pthread_mutex_unlock(&mutex); 
} 

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

1. Мьютексы блокируется в течение всего выполнения функций (что не требуется, вы можете просто заблокировать его читать указатели на функции, разблокировать, а затем выполнить их)
2. Функции должны быть не самим вызовом changeFunctions, иначе вы окажетесь в тупике.

Answer 2

callFunctions() выполняется периодически, скажем, один раз в секунду. Затем изменяется changeFunctions() и изменяет содержимое функцииPtrArray []. Это может произойти в любой момент времени, поскольку код запускается в разных процессах как ОС, подобный среде.

Из вашего описания, это очевидно, что functionPtrArray массив изменяется, и доступ к 4by более чем один нити/процесса (ов) в unsychronized способом, который является data race. Итак, вам нужно будет обеспечить синхронизацию так или иначе.

Answer 3

Это тот же случай, что и для любой переменной в многопоточном сценарии. Нет, они не могут считаться атомными, если вы не используете квалификатор _Atomic от C11.

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

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

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

void callFunctions(void) 
{ 
    for (i = 0; i < 3; i++) 
    { 
    void(*local)(void); 

    grab_mutex(); 
     local = functionPtrArray[i]; 
    release_mutex(); 

    local(); // call is completely thread-safe 
    } 
}