Я досить багато гуглив за чергою без блокування в C ++. Я знайшов трохи коду та кілька випробувань - але нічого, що я не зміг скомпілювати. Також буде вітатися хеш без замків.
РЕЗЮМЕ: Поки що у мене немає позитивної відповіді. Не існує бібліотеки "готової до виробництва", і напрочуд жодна з існуючих бібліотек не відповідає API контейнерів STL.
Відповіді:
Починаючи з 1.53, Boost забезпечує набір структур даних без блокування , включаючи черги, стеки та черги одного виробника / одного споживача (тобто кільцеві буфери).
Відправною точкою буде будь-яка стаття DDJ Herb Sutter для одного виробника та споживача, або для кількох . Код, який він надає (у рядку, починаючи з другої сторінки кожної статті), використовує атомарний тип шаблону C ++ 0x <T>; яку можна імітувати, використовуючи міжпроцесорну бібліотеку Boost.
Код підсилення закопаний в глибині межпроцессной бібліотеки, але прочитавши відповідний заголовочний файл (atomic.hpp) реалізації для необхідних операцій порівняння та обміну в системах, які я знайомий із виглядом звуку.
Я написав чергу без замків . Він має Особливості ™:
Він доступний на GitHub за спрощеною ліцензією BSD (сміливо розмовляйте!).
Застереження:
Здається, у Facebook Folly є безкоштовні структури даних на основі C ++ 11 <atomic>:
ProducerConsumerQueue з документами та прикладом коду тут .
AtomicHashMap з документами та прикладом коду тут
Я б наважився сказати, що вони зараз використовуються у виробництві, тож я думаю, їх можна сміливо використовувати в інших проектах.
Ура!
Перевіривши більшість поданих відповідей, я можу лише стверджувати:
Відповідь - НІ .
Немає такої речі, яка могла б бути використана прямо з коробки.
boost.lockfree - це спроба створити реалізації c ++ класів стеку і fifo lockfree.
Найближче, що мені відомо, - це взаємозв’язані списки з єдиним зв’язком Windows . Звичайно, це лише Windows.
Якщо у вас є черга декількох виробників / одного споживача / FIFO, ви можете легко створити один LockFree, використовуючи SLIST або тривіальний Lock Free LIFO стек. Те, що ви робите, - це створити другий «приватний» стек для споживача (який також можна зробити як СПИСОК для простоти або будь-яку іншу вибрану вами модель стека). Споживач викидає речі з приватного стеку. Кожного разу, коли приватний LIFO вичерпується, ви робите флеш, а не вискакуєте спільний паралельний SLIST (захоплюючи весь ланцюжок SLIST), а потім проходите список Flushed у порядку, висуваючи елементи на приватний стек.
Це працює для одного виробника / одного споживача та для декількох виробників / одного споживача.
Однак це не працює для випадків із кількома споживачами (як з одним виробником, так і з декількома виробниками).
Окрім того, що стосується хеш-таблиць, вони є ідеальним кандидатом для «розмежування», яке просто поділяє хеш на сегменти, що мають блокування на сегменти кешу. Ось як це робить паралельна бібліотека Java (використовуючи 32 смуги). Якщо у вас є легкий замок зчитувача-записувача, до хеш-таблиці можна отримати одночасний доступ для одночасного читання, і ви зупинитесь лише тоді, коли запис відбувається на спірних смугах (і, можливо, якщо ви дозволяєте нарощувати хеш-таблицю).
Якщо ви прокручуєте свої власні, переконайтеся, що ви переплетете свої замки за допомогою хеш-записів, а не покладете всі свої замки в масив поруч один з одним, щоб ви мали менше шансів на обмін помилками.
Я можу затриматись із цим.
Відсутність рішень (на запитання) було головним чином пов'язано з важливою проблемою в C ++ (до C ++ 0x / 11): C ++ не має (не має) одночасної моделі пам'яті.
Тепер, використовуючи std :: atomic, ви можете контролювати проблеми впорядкування пам'яті та мати належні операції порівняння та обміну. Я написав собі реалізацію безблокової черги Micheal & Scott (PODC96) з використанням C ++ 11 та покажчиків небезпеки Micheal (IEEE TPDS 2004), щоб уникнути проблем із безкоштовним звільненням та ABA. Це працює нормально, але це швидке та брудне впровадження, і я не задоволений фактичними показниками. Код доступний на bitbucket: LockFreeExperiment
Також можна запровадити чергу без замків без вказівників на небезпеку, використовуючи подвійні слова CAS (але 64-бітні версії будуть можливі лише на x86-64 за допомогою cmpxchg16b), я маю допис у блозі про це (з неперевіреним кодом черги) тут : Впровадження загального порівняння та заміни двох слів для x86 / x86-64 (блог LSE.)
Мій власний орієнтир показує мені, що черга з подвійним блокуванням (також у статті Micheal & Scott 1996) працює так само, як і без блокування (я не досяг достатньої кількості суперечок, щоб заблоковані структури даних мали проблеми з продуктивністю, але мій стенд занадто легкий для зараз), і паралельна черга від TBB від Intel здається ще кращою (вдвічі швидшою) для відносно невеликої кількості (залежно від операційної системи, у FreeBSD 9, найнижча межа, яку я знайшов на даний момент, ця кількість становить 8 потоків на i7 з 4 ядрами, а отже 8 логічними процесорами) потоків і мають дуже дивну поведінку (час виконання мого простого тесту переміщується з секунд на години!)
Інші обмеження щодо безблокувальних черг, що відповідають стилю STL: наявність ітераторів у безблокованій черзі не має сенсу.
А потім з’явилися будівельні блоки Intel Threading . І деякий час це було добре.
PS: ви шукаєте concurrent_queue і concurrent_hash_map
Наскільки мені відомо, такого ще немає у відкритому доступі. Одне питання, яке повинен вирішити реалізатор, полягає в тому, що вам потрібен розподільник пам’яті без блокування, який існує, хоча я не можу зараз знайти посилання.
Далі йдеться зі статті Herb Sutter про Одночасну чергову безпеку без блокування http://www.drdobbs.com/parallel/writing-a-generalized-concurrent-queue/211601363?pgno=1 . Я вніс деякі зміни, такі як компілятор, що впорядковує речі. Для компіляції цього коду потрібен GCC v4.4 +.
#include <atomic>
#include <iostream>
using namespace std;
//compile with g++ setting -std=c++0x
#define CACHE_LINE_SIZE 64
template <typename T>
struct LowLockQueue {
private:
struct Node {
Node( T* val ) : value(val), next(nullptr) { }
T* value;
atomic<Node*> next;
char pad[CACHE_LINE_SIZE - sizeof(T*)- sizeof(atomic<Node*>)];
};
char pad0[CACHE_LINE_SIZE];
// for one consumer at a time
Node* first;
char pad1[CACHE_LINE_SIZE
- sizeof(Node*)];
// shared among consumers
atomic<bool> consumerLock;
char pad2[CACHE_LINE_SIZE
- sizeof(atomic<bool>)];
// for one producer at a time
Node* last;
char pad3[CACHE_LINE_SIZE
- sizeof(Node*)];
// shared among producers
atomic<bool> producerLock;
char pad4[CACHE_LINE_SIZE
- sizeof(atomic<bool>)];
public:
LowLockQueue() {
first = last = new Node( nullptr );
producerLock = consumerLock = false;
}
~LowLockQueue() {
while( first != nullptr ) { // release the list
Node* tmp = first;
first = tmp->next;
delete tmp->value; // no-op if null
delete tmp;
}
}
void Produce( const T& t ) {
Node* tmp = new Node( new T(t) );
asm volatile("" ::: "memory"); // prevent compiler reordering
while( producerLock.exchange(true) )
{ } // acquire exclusivity
last->next = tmp; // publish to consumers
last = tmp; // swing last forward
producerLock = false; // release exclusivity
}
bool Consume( T& result ) {
while( consumerLock.exchange(true) )
{ } // acquire exclusivity
Node* theFirst = first;
Node* theNext = first-> next;
if( theNext != nullptr ) { // if queue is nonempty
T* val = theNext->value; // take it out
asm volatile("" ::: "memory"); // prevent compiler reordering
theNext->value = nullptr; // of the Node
first = theNext; // swing first forward
consumerLock = false; // release exclusivity
result = *val; // now copy it back
delete val; // clean up the value
delete theFirst; // and the old dummy
return true; // and report success
}
consumerLock = false; // release exclusivity
return false; // report queue was empty
}
};
int main(int argc, char* argv[])
{
//Instead of this Mambo Jambo one can use pthreads in Linux to test comprehensively
LowLockQueue<int> Q;
Q.Produce(2);
Q.Produce(6);
int a;
Q.Consume(a);
cout<< a << endl;
Q.Consume(a);
cout<< a << endl;
return 0;
}
Я знайшов інше рішення, написане на c:
Я писав це колись, мабуть, ще в 2010 році, я впевнений, за допомогою різних посилань. Це багатовиробничий єдиний споживач.
template <typename T>
class MPSCLockFreeQueue
{
private:
struct Node
{
Node( T val ) : value(val), next(NULL) { }
T value;
Node* next;
};
Node * Head;
__declspec(align(4)) Node * InsertionPoint; //__declspec(align(4)) forces 32bit alignment this must be changed for 64bit when appropriate.
public:
MPSCLockFreeQueue()
{
InsertionPoint = new Node( T() );
Head = InsertionPoint;
}
~MPSCLockFreeQueue()
{
// release the list
T result;
while( Consume(result) )
{
//The list should be cleaned up before the destructor is called as there is no way to know whether or not to delete the value.
//So we just do our best.
}
}
void Produce( const T& t )
{
Node * node = new Node(t);
Node * oldInsertionPoint = (Node *) InterLockedxChange((volatile void **)&InsertionPoint,node);
oldInsertionPoint->next = node;
}
bool Consume( T& result )
{
if (Head->next)
{
Node * oldHead = Head;
Head = Head->next;
delete oldHead;
result = Head->value;
return true;
}
return false; // else report empty
}
};