Атомный усилитель C++

Все атомарные операции добавления предназначены только для целочисленных типов. Вы можете делать все, что хотите, без блокировок, используя 128-битные операции CAS (сравнение и обмен) хотя и для float_4 (я предполагаю, что это 4 числа с плавающей запятой), но нет 256-битных операций CAS, которые вам понадобятся для double_4. Что вам нужно сделать, так это иметь цикл, который атомарно считывает float_4 из памяти, выполняет добавление с плавающей запятой обычным способом, а затем использует CAS для проверки и замены значения, если оно является исходным (и цикл, если нет, то есть какой-то другой поток изменил значение между чтением и записью). Обратите внимание, что 128-разрядный CAS доступен только в 64-разрядных архитектурах и что ваши данные должны быть правильно выровнены.

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

int lock = 1;

while(__sync_lock_test_and_set(&lock, 0) == 0) // trying to acquire lock
{
 //yield the thread or go to sleep
} 

//critical section, do the work

// release lock
lock = 1;

преимущество заключается в том, что вы экономите на блокировках ОС.

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

Я также хотел бы подробно рассказать о своем собственном редактировании на случай, если другие придут сюда с такой же неисправной блокировкой.

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

Я совершенно не знал, что &lock получит 1 при неудачном обмене!

parallel_for_each(attracting.extent, [=](index<1> idx) restrict(amp)
{
   .....
   for (int j = 0; j < attracted.extent.size(); j++)
   {
      ...
      int lock = 0; //the expected lock value

      **//note that, if locks[j]!=lock then lock=1
      //meaning that ACE will be true the next time if locks[j]==1
      //meaning the while will terminate even though someone else has the lock**
      while (!atomic_compare_exchange(&locks[j], &lock, 1));
      //when one warp thread gets the lock, ALL threads continue on
      ...
      acceleration[j] += ...; //locked write
      locks[j] = 0; //leaving the lock again
   }
});

Кажется, что исправить это сделать

parallel_for_each(attracting.extent, [=](index<1> idx) restrict(amp)
{
   .....
   for (int j = 0; j < attracted.extent.size(); j++)
   {
      ...
      int lock = 0; //the expected lock value

      while (!atomic_compare_exchange(&locks[j], &lock, 1))
      {
          lock=0; //reset the expected value
      };
      //when one warp thread gets the lock, ALL threads continue on
      ...
      acceleration[j] += ...; //locked write
      locks[j] = 0; //leaving the lock again
   }
});