SlideShare a Scribd company logo

ПВТ - весна 2015 - Лекция 8. Многопоточное программирование без использования блокировок

•
Alexey Paznikov, profile picture
Alexey Paznikov

Документ посвящен многопоточному программированию без блокировок, описывающему модель потребитель-производитель и различные виды алгоритмов, свободных от блокировок. Основное внимание уделяется целям, связанным с повышением масштабируемости и устранением проблем, таких как гонки и дедлоки. Приводится реализация потокобезопасного стека и обсуждаются аспекты его работы в многопоточной среде.

Education
1 of 195
Downloaded 35 times
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
Лекция 8. Многопоточное программирование без блокировок. Модель потребитель-производитель. Потокобезопасный стек Пазников Алексей Александрович Кафедра вычислительных систем СибГУТИ Сайт курса: http://cpct.sibsutis.ru/~apaznikov/teaching/ Вопросы: https://piazza.com/sibsutis.ru/spring2015/pct2015spring Параллельные вычислительные технологии Осень 2014 (Parallel Computing Technologies, PCT 14)
Многопоточное программирование без использования блокировок 2 Если вы думаете, что программирование без блокировок это просто, значит или вы - один из тех 50 человек, которые умеют это делать, или же используете атомарные инструкции недостаточно аккуратно. Герб Саттер
Цели многопоточного программирования без блокировок 3 Однопоточная программа Многопоточная программа с блокировками Многопоточная программа без блокировок
Цели многопоточного программирования без блокировок ▪ Повышение масштабируемости путём сокращения блокировок и ожиданий в алгоритмах и структурах данных. ▪ Решение проблем, связанных с блокировками: ▫ Гонки: нужно не забыть заблокировать, причём именно нужный участок кода ▫ Дедлоки: необходимо запирать в нужном порядке различные потоки ▫ Сложность выбора критической секции (простота или масштабируемость) ▫ Голоданеие, инверсия приоритетов и др. 4
Виды алгоритмов, свободных от блокировок ▪ Свободные от ожиданий (wait-free). “Никто никогда не ждёт”. Каждая операция завершается за N шагов без каких-либо условий. Гарантии: ▫ максимум пропускной способности системы ▫ отсутствие голодания ▪ Свободные от блокировок (lock-free). “Всегда какой-то из потоков работает”. Каждый шаг приближает итоговое решение. Гарантии: ▫ максимум пропускной способности системы ▫ отсутствие голодания (один поток может постоянно ожидать) ▪ Свободные от препятствий (obstruction-free). “Поток работает, если нет конфликтов”. За ограниченное число шагов поток, при условии, что другие “мешающие” ему потоки остановлены, достигает результата. ▫ Все потоки не блокируются из-за проблем (задержек, ошибок) с другими потоками. ▫ Не гарантируется прогресс, если одновременно работают два или больше потоков. 5
Цели многопоточного программирования без блокировок 6 ?
Цели многопоточного программирования без блокировок 7
Цели многопоточного программирования без блокировок 8 t ≥ 30 мин. ■ 40 мин. ■ 1 час ■ 2 часа ■ ...
Цели многопоточного программирования без блокировок 9 t ≥ 30 мин. ■ 40 мин. ■ 1 час ■ 2 часа ■ ...
Цели многопоточного программирования без блокировок 10 t ≥ 30 мин. ■ 40 мин. ■ 1 час ■ 2 часа ■ ... t = 1 час ± 10 мин.
Цели многопоточного программирования без блокировок 11 locks (с блокировками) lock-free (без блокировок) t ≥ 30 мин. ■ 40 мин. ■ 1 час ■ 2 часа ■ ... t = 1 час ± 10 мин.
Реализация модели потребитель-производитель без блокировок 12
Производитель-потребитель на основе блокировок 13 Производитель Потребитель Потребитель Потребитель Производитель Производитель
Производитель-потребитель на основе блокировок void producer() { while (ThereAreTasks()) { task = BuildNewTask(); std::unique_lock<std::mutex> lock{mut}; queue.push(task); lock.unlock(); cv.notify(); } std::unique_lock<std::mutex> lock{mut}; queue.push(done); // добавить признак окончания lock.unlock(); cv.notify(); } 14
Производитель-потребитель на основе блокировок void consumer() { task = nullptr; while (task != done) { std::unique_lock<std::mutex> lock{mut}; cv.wait(mut, []{ return queue.empty(); }); task = queue.first(); if (task != done) queue.pop(); } if (task != done) DoWork(task); } 15
1 производитель, K потребителей 16 emptyempty empty empty 1 2 3 K
Производитель-потребитель без блокировок 17 is empty? empty is empty? is empty? empty is empty? is empty? empty is empty? is empty? empty is empty?
Производитель-потребитель без блокировок 18 put out is empty? is empty? empty put out full is empty? empty full is empty? is empty? is empty?
Производитель-потребитель без блокировок 19 is empty? is empty? empty put in full is empty? empty full is empty? process process is empty?
Производитель-потребитель без блокировок 20 is empty? is empty? put in full is empty? empty full is empty? process process full is empty?
Производитель-потребитель без блокировок 21 is empty? is empty? full is empty? full is empty? is empty? empty full done done put in done flag put output out
Производитель-потребитель без блокировок 22 is empty? full is empty? full is empty? done done full done put out empty is empty? put in done flag
Производитель-потребитель без блокировок 23 full is empty? full is empty? done done full done is empty? is empty? done full put out
Производитель-потребитель без блокировок 24 full is empty? full is empty? done done full done is empty? is empty? done full
Производитель-потребитель без блокировок 25 Empty Task Done Start End Производитель Потребитель
Производитель 26 curr = 0; // указатель на текущий слот while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // если null, то проверить curr = (curr + 1) % numOfConsumers; // следующий слот slot[curr] = task; sem[curr].signal(); }
Производитель 27 curr = 0; // указатель на текущий слот while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // если null, то проверить curr = (curr + 1) % numOfConsumers; // следующий слот slot[curr] = task; sem[curr].signal(); } // Фаза 2: выставить флаги “done” во всех слотах numNotified = 0; while (numNotified < numOfConsumers) { while (slot[curr] != null) // если null, то проверить curr = (curr + 1) % numOfConsumers; // следующий slot[curr] = done; // освободить слот sem[curr].signal(); ++numNotified; }
Потребитель 28 task = null; while (task != done) // Дождаться, когда слот будет полным while ((task = slot[mySlot]) == null) sem[mySlot].wait(); if (task != done) { slot[mySlot] = null; // помечаем слот пустым DoWork(task); // выполняем задачу } // вне критической секции }
Потребитель 29 task = null; while (task != done) // Дождаться, когда слот будет полным while ((task = slot[mySlot]) == null) sem[mySlot].wait(); if (task != done) { slot[mySlot] = null; // помечаем слот пустым DoWork(task); // выполняем задачу } // вне критической секции } Как применить модель памяти С++?
Производитель, модель памяти С++ 30 curr = 0; while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = task; // release non-null sem[curr].signal(); } // Фаза 2: выставить флаги “done” во всех слотах numNotified = 0; while (numNotified < numOfConsumers) { while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = done; // release done sem[curr].signal(); ++numNotified; }
Потребитель, модель памяти С++ 31 task = null; while (task != done) // Дождаться, когда слот будет полным while ((task = slot[mySlot]) // acquire non-null == null) sem[mySlot].wait(); if (task != done) { slot[mySlot] = null; // release null DoWork(task); } }
Производитель-потребитель, класс алгоритма 32 curr = 0; while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = task; // release non-null sem[curr].signal(); } // Фаза 2: выставить флаги “done” во всех слотах numNotified = 0; while (numNotified < numOfConsumers) { while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = done; // release done sem[curr].signal(); ++numNotified; } Алгоритм - свободный от ожиданий, свободный от блокировок или свободный от остановок?
Производитель-потребитель, класс алгоритма 33 curr = 0; while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = task; // release non-null sem[curr].signal(); } // Фаза 2: выставить флаги “done” во всех слотах numNotified = 0; while (numNotified < numOfConsumers) { while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = done; // release done sem[curr].signal(); ++numNotified; } Алгоритм - свободный от ожиданий, свободный от блокировок или свободный от остановок? Этап 2: Свободная от остановок Этап 1: Свободный от ожиданий
Производитель-потребитель без блокировок 34 task = null; while (task != done) // Дождаться, когда слот будет полным while ((task = slot[mySlot]) == null) sem[mySlot].wait(); if (task != done) { slot[mySlot] = null; DoWork(task); } } можно ли поменять две строки? нужно ли это сделать?
N производителей, K потребителей 35 1 2 3 K ? ? ? ? ? ? ? ?
N производителей, K потребителей 36 1 2 3 K ? ? ? ? ? ? ? ? гонка!
N производителей, K потребителей 37 is empty? is empty? is empty? is empty? 1 2 3 K CAS(empty, full) CAS(empty, full) CAS(empty, full) CAS(empty, full)
N производителей, K потребителей 38 is empty? is empty? is empty? is empty? CAS(empty, full) CAS(empty, full) CAS(empty, full) CAS(empty, full) 1 2 3 K CAS – compare and swap (compare exchange) CAS – атомарное сравнение с обменом
N производителей, K потребителей 39 producer (вариант): curr = 0; while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (!slot[curr].CAS(null, task)) curr = (curr + 1) % numOfConsumers; sem[curr].signal(); } Не получилось – идём дальше Пытаемся атомарно сделать из пустого слота полный
N производителей, M потребителей 40 1 2 K3 ? ? ? ? ? ? ? ?
N производителей, M потребителей 41 1 2 K3 ? ? ? ? ? ? ? ? гонка! гонка!
N производителей, M потребителей 42 CAS(empty, full) CAS(empty, full) CAS(empty, full) CAS(empty, full) CAS(full, empty) CAS(empty, full) CAS(empty, full) CAS(empty, full) 1 2 K3 CAS – атомарное сравнение с обменом CAS – compare and swap (compare exchange)
N производителей, M потребителей 43 consumer (вариант): task = null; curr = 0; while (true) { task = slot[curr]; if (slot[curr] != null) if (!slot[curr].CAS(task, null)) curr = (curr + 1) % numOfSlots; if (task != done) DoWork(task); else break; } Пытаемся атомарно сделать из полного слота пустой Не получилось – идём дальше Запоминаем состояние слота и проверяем, не пустой ли он
Реализация стека, свободного от блокировок, на основе сборщика мусора 44
Стек, свободный от блокировок 45 T T T T head 1. Конструктор 2. Деструктор 3. Поиск узла (find) 4. Добавление узла (push) 5. Удаление узла (pop)
Стек, свободный от блокировок 46 template <typename T> class lfstack { public: lfstack(); ~lfstack(); T* find(T data) const; // найти элемент, равный data void push(T data); // добавить элемент в голову private: struct node { // атомарные операции T data; // не требуются node* next; }; std::atomic<node*> head{nullptr}; // атомарный указатель }; // на голову списка
Конструктор и деструктор 47 template <typename T> lfstack<T>::lfstack() {} Объект создаётся в одном потоке, поэтому не нужно обеспечивать параллельный доступ. Нельзя использовать стек до тех пор, пока он не будет создан, т.е. до выполнения конструктора, и после того, как он будет уничтожен, т.е. после выполнения деструктора. template <typename T> lfstack<T>::~lfstack() { auto first = head.load(); while (first) { auto unlinked = first; first = first->next; delete unlinked; } }
Функция push 48 1. Создать новый узел. 2. Записать в его указатель next текущее значение head. 3. Записать в head указатель на новый узел. void push(T const& data) { auto new_node = new node{data}; // (1) node_node->next = head.load(); // (2) head = new_node; // (3) } struct node { T data; node* next; node(T const& _data): data{_data} {} };
Функция push 49 T head TTT Начальная стадия
Функция push 50 T head TTT Начальная стадия Промежуточная стадия T head TTT T
Функция push 51 T head TTT Начальная стадия Промежуточная стадия T head TTT T Конечная стадия T head TTT T
Функция push – гонка 52 T head TTT Начальная стадия Промежуточная стадия выполняется двумя потоками T head TTT T T
Функция push 53 T head TTT Начальная стадия Промежуточная стадия выполняется двумя потоками T head TTT T Первый добавляемый элемент пропал, остался только второй T head TTT T T T
Функция push 54 void push(T const& data) { auto new_node = new node{data}; // (1) node_node->next = head.load(); // (2) head = new_node; // (3) while (!head.compare_exchange_weak(new_node->next, new_node)); // (3) } 1. Создать новый узел. 2. Записать в его указатель next текущее значение head. 3. Записать в head указатель на новый узел, при этом с помощью операции сравнить-и-обменять гарантировать то, что head не был модифицирован с момента чтения на шаге 2.
Функция pop (ошибочная) 55 void pop(T& result) { node* old_head = head.load(); head = head->next; result = old_head->data; }
Функция pop 56 T head TTT Начальная стадия Промежуточная стадия T head TTT Конечная стадия T head TT
Функция pop 57 T head TTT Начальная стадия Промежуточная стадия T head TTT Конечная стадия T head TT B A A B head
Функция pop (ошибочная) 58 void pop(T& result) { node* old_head = head.load(); while (!head.compare_exchange_weak(old_head, old_head->next); result = old_head->data; }
Функция pop (ошибочная) 59 void pop(T& result) { node* old_head = head.load(); while (!head.compare_exchange_weak(old_head, old_head->next); result = old_head->data; }
Функция pop (ошибочная) 60 void pop(T& result) { node* old_head = head.load(); while (!head.compare_exchange_weak(old_head, old_head->next); result = old_head->data; } std::shared_ptr<T> pop(T& result) { node* old_head = head.load(); while (old_head && !head.compare_exchange_weak(old_head, old_head->next)); return old_head ? old_head->data : std::shared_ptr<T>(); }
Функция pop (ошибочная) 61 class lfstack { private: struct node { std::shared_ptr<T> data; node* next; node(T const& _data): data(std::make_shared<T>(_data)) { } }; ... std::shared_ptr<T> pop(T& result) { node* old_head = head.load(); while (old_head && !head.compare_exchange_weak(old_head, old_head->next)); return old_head ? old_head->data : std::shared_ptr<T>(); }
Проблема АВА 62 4 old_head 321 head->next Поток А выполняет удаление узла из вершины стека
Проблема АВА 63 4 old_head 321 head->next 43 Поток А выполняет удаление узла из вершины стека old_head old_head->next Поток А был вытеснен и другие потоки удалили два узла из стека
Проблема АВА 64 4 old_head 321 head->next 43 Поток А был вытеснен и другие потоки удалили два узла из стека Поток А выполняет удаление узла из вершины стека 435 old_head old_head->next old_head old_head->next Некий поток добавил новый узел и аллокатор выделил под него ту же память
Проблема АВА 65 4 old_head 321 head->next 43 Поток А выполняет удаление узла из вершины стека 43 Некий поток добавил новый узел и аллокатор выделил под него ту же память 5 43 Поток А: head.compare_exchange( old_head, old_head->next)) 5 old_head old_head->next old_head old_head->next old_head old_head->next Поток А был вытеснен и другие потоки удалили два узла из стека
Проблема АВА 66 4 old_head 321 head->next 43 Поток А выполняет удаление узла из вершины стека 435 43 Некий поток добавил новый узел и аллокатор выделил под него ту же память Поток А: head.compare_exchange( old_head, old_head->next)) 5 old_head old_head->next old_head old_head->next old_head old_head->next Поток А был вытеснен и другие потоки удалили два узла из стека
Решения проблемы АВА 67 1. “Ленивый” сборщик мусора 2. Указатели опасности 3. Счётчик ссылок на элемент 4. Сделать узлы уникальными 5. Вообще не удалять узлы 6. Добавление дополнительных узлов 7. и т.д.
Функция pop (наивная) 68 // количество потоков, выполняющих pop std::atomic<unsigned> threads_in_pop; std::shared_ptr<T> pop() { threads_in_pop++; node* old_head = head_load(); while (old_head && !head.compare_exchange_weak(old_head, old_head->next)); std::shared_ptr<T> res; if (old_head) res.swap(old_head->data); // не копировать, // а обменять данные try_reclaim(old_head); // попробовать освободить // удалённые узлы return res; }
Функция pop (наивная) 69 template<typename T> class lfstack { private: std::atomic<node*> delete_list; static void delete_nodes(node* nodes); while (nodes) { node* next = nodes->next; delete nodes; nodes = next; } }
Функция try_reclaim освобождения удалённых узлов 70 void try_reclaim(node* old_head) { if (threads_in_pop == 1) { // я единственный в pop? node* nodes_to_delete = // захватить список delete_list.exchange{nullptr}; // на удаление if (!--thread_in_pop) // точно единственный? delete_nodes(nodes_to_delete)); // удалить всё! else if (nodes_to_delete) // если в захваченном списке // что-то было // вернуть это в общий список узлов на удаление chain_pending_nodes(nodes_to_delete); delete old_head; // удаляем хотя бы только что // исключённый узел } else { // удалим узел как-нибудь потом chain_pending_node(old_head); --threads_in_pop; } }
Функция try_reclaim освобождения удалённых узлов 71 // добавляем захваченный список в общий список узлов, // подлежащих удалению void chain_pending_nodes(node* nodes) { node* last = nodes; while (node* const next = last->next) last = next; chain_pending_nodes(nodes, last); } // добавить список узлов в список узлов на удаление void chain_pending_nodes(node* first, node* last) { last->next = delete_list; while (!delete_list.compare_exchange_weak(last->next, first)); } // добавить узел в список узлов на удаление void chain_pending_node(node* n) { chain_pending_nodes(n, n); }
Функция try_reclaim освобождения удалённых узлов 72 4 head 321 delete_list 0threads_in_pop 4 head 321 delete_list threads_in_pop 1 5 5 A A удаляет узел 1 и вытесняется в pop() после 1-го чтения threads_in_pop
Функция try_reclaim освобождения удалённых узлов 73 4 head 32 delete_list 2threads_in_pop 43 delete_list threads_in_pop 2 5 2 С удаляет узел и продолжает работать до момента выхода из pop() old_head B B вызывает pop() и вытесняется после 1-го чтения head A head old_head B 4 C 5 A
Функция try_reclaim освобождения удалённых узлов 74threads_in_pop 2 43 delete_list threads_in_pop 2 2 A возобновляет выполнение и захватывает список на удаление. После этого он должен 2-й раз проверить, один ли он в pop() head old_head B 2 5 A 43 head old_head B 2 delete_list A 2 5 delete_list B возобновляет выполнение, выполняет CAS и переходит к 3 узлу
Реализация стека, свободного от блокировок, на основе указателей опасности 75
Указатели опасности (hazard pointers) 76 4 old_head 321 head->next 43 Поток А выполняет удаление узла из вершины стека и помечает узел 1 как узел, который он использует. old_head old_head->next Поток А был вытеснен и другие потоки удалили два узла из стека, но не освобождают память из-под первого узла. 2 head head 1 A “понимает”, что головной узел head изменился и нужно выполнить compare_exchange 43 old_head old_head->next 21
Функция pop на основе указателей опасности 77 std::shared_ptr<T> pop() { std::atomic<void*>& hp = get_hazard_pointer_for_current_thread(); // установить указатель опасности перед чтением указателя, // который мы собираемся разыменовывать node* old_head = head.load(); node* temp; do { temp = old_head; hp.store(old_head); old_head = head.load(); } while (old_head != temp); // ... }
Функция pop на основе указателей опасности 78 std::shared_ptr<T> pop() { std::atomic<void*>& hp = get_hazard_pointer_for_current_thread(); node* old_head = head.load(); do { node* temp; do { temp = old_head; hp.store(old_head); // устанавливаем УО old_head = head.load(); } while (old_head != temp); } while (old_head && // получаем узел !head.compare_exchange_strong(old_head, old_head->next)); hp.store(nullptr);
Указатели опасности (hazard pointers) 79 4 old_head 321 head hp
Указатели опасности (hazard pointers) 80 4 old_head 321 head temp = old_head temp hp
Указатели опасности (hazard pointers) 81 4 old_head 321 head hp temp = old_head temp hp.store(old_head)
Указатели опасности (hazard pointers) 82 4 old_head 321 temp = old_head head temp hp.store(old_head) old_head = head.load() “old old_head” “new old_head” hp
Указатели опасности (hazard pointers) 83 4 old_head 321 temp = old_head head temp hp.store(old_head) old_head = head.load() “old old_head” “new old_head” hp == ? Таким образом, внутренний цикл гарарантирует то, что указатель опасности будет указывать на тот головной элемент head, с котором мы будем работать (сдвигать указатель на следующий элемент) Проверка позволяет определить, не изменился ли головной элемент с тех пор, когда мы запомнили его в указателе опасности.
Указатели опасности (hazard pointers) 84 4 old_head 321 temp = old_head head temp hp.store(old_head) old_head = head.load() “old old_head” “new old_head” hp == ? Во внешнем цикле сдвигаем указатель с head на следующий элемент с уверенностью, что никто не подменит элемент head.
Указатели опасности (hazard pointers) 85 После того, как поток А успешно выполнил compare_exchange, указатель опасности можно обнулять hp.store(nullptr), т.к. никто пока не сможет удалить old_head, кроме А, поскольку head изменён потоком А 43 old_head old_head->next 21 Вариант 1 43 old_head->next 1 Вариант 2 old_head 2
Функция pop на основе указателей опасности 86 std::shared_ptr<T> res; if (old_head) { res.swap(old_head->data); // извлекаем данные if (outstanding_hazard_pointers_for(old_head)) // если опасно, удаляем потом reclaim_later(old_head); else // если не опасно, удаляем сейчас delete old_head; // пробуем удалить узлы, какие можно удалить delete_nodes_with_no_hazards(); } return res; }
Реализация указателей опасности 87 4321 head 1 5 6 7 m432 max_hazard_pointers
Реализация указателей опасности 88 4321 head 1 5 6 7 m432 Указатели опасности, m = max_hazard_pointers пустой? нет if (hazard_pointers[i].id. compare_exchange_strong( old_id, std::this_thread::get_id())) thread_local hp
Реализация указателей опасности 89 4321 head 1 5 6 7 m432 Указатели опасности, m = max_hazard_pointers пустой? да if (hazard_pointers[i].id. compare_exchange_strong( old_id, std::this_thread::get_id())) thread_local hp
Реализация указателей опасности 90 4321 head 1 5 6 7 m432 Указатели опасности, m = max_hazard_pointers пустой? да if (hazard_pointers[i].id. compare_exchange_strong( old_id, std::this_thread::get_id())) thread_local hp
Реализация указателей опасности 91 const auto max_hazard_pointers = 100; struct hazard_pointer { std::atomic<std::thread::id> id; std::atomic<void*> pointer; }; hazard_pointer hazard_pointers[max_hazard_pointers]; class hp_owner { hazard_pointer* hp; public: hp_owner(hp_owner const&) = delete; hp_owner operator=(hp_owner const&) = delete;
Реализация указателей опасности 92 hp_owner(): hp{nullptr} { for (auto i = 0; i < max_hazard_pointers; i++) { std::thread::id old_id; // пустой незанятый УО // если i-й УО не занят, завладеть им, записав в него // свой идентификатор потока if (hazard_pointers[i].id.compare_exchange_strong( old_id, std::this_thread::get_id())) { hp = &hazard_pointers[i]; // я владею i-м УО break; } } // таблица УО закончилась, указателей нам не досталось if (!hp) throw std::runtime_error("No hazard ptrs available"); }
Реализация указателей опасности 93 hp_owner(): hp{nullptr} { for (auto i = 0; i < max_hazard_pointers; i++) { std::thread::id old_id; if (hazard_pointers[i].id.compare_exchange_strong( old_id, std::this_thread::get_id())) { hp = &hazard_pointers[i]; break; } } if (!hp) throw std::runtime_error("No hazard ptrs available"); } std::atomic<void*>& get_pointer() { return hp->pointer; } ~hp_owner() { hp->pointer.store(nullptr); hp->id.store(std::thread::id()); }
Реализация указателей опасности 94 // вернуть указатель опасности для текущего потока std::atomic<void*>& get_hazard_pointer_for_current_thread() { thread_local static hp_owner hazard; return hazard.get_pointer(); }
Реализация указателей опасности 95 // вернуть указатель опасности для текущего потока std::atomic<void*>& get_hazard_pointer_for_current_thread() { thread_local static hp_owner hazard; return hazard.get_pointer(); } // проверить, не ссылается ли на указатель какой-то из УО bool outstanding_hazard_pointers_for(void* p) { for (auto i = 0; i < max_hazard_pointers; i++) { if (hazard_pointers[i].pointer.load() == p) { return true; } } return false; }
Реализация функции освобождения памяти 96 template <typename T> void do_delete(void* p) { delete static_cast<T*>(p); } struct data_to_reclaim { // обёртка над данными для void* data; // помещения в список удаления std::function<void(void*)> deleter; data_to_reclaim* next; template<typename T> data_to_reclaim(T* p): data{p}, deleter{&do_delete<T>}, next{0} { } ~data_to_reclaim() { deleter(data); } }; std::atomic<data_to_reclaim*> nodes_to_reclaim;
Реализация функции освобождения памяти 97 // добавить элемент в список на удаление void add_to_reclaim_list(data_to_reclaim* node) { node->next = nodes_to_reclaim.load(); while (!nodes_to_reclaim.compare_exchange_weak( node->next, node)); } // удалить элемент позже template<typename T> void reclaim_later(T* data) { add_to_recalim_list(new data_to_reclaim(data)); }
Реализация функции освобождения памяти 98 void delete_nodes_with_no_hazards() { // захватить текущий список data_to_reclaim* current = nodes_to_reclaim.exchange(nullptr); while (current) { data_to_reclaim* const next = current->next; if (!outstanding_hazard_pointers_for(current->data)) // если не опасно, удалить сейчас delete current; else // если опасно удалить потом add_to_reclaim_list(current); current = next; } }
Реализация функции освобождения памяти 99 4321 nodes_to_reclaim
Реализация функции освобождения памяти 100 nodes_to_reclaim 4321 current current = nodes_to_reclaim. exchange(nullptr);
Реализация функции освобождения памяти 101 nodes_to_reclaim 432 current 1 1 add_to_reclaim_list(current);
Реализация функции освобождения памяти 102 nodes_to_reclaim 432 current 1 delete current;
Реализация функции освобождения памяти 103 nodes_to_reclaim 43 current 1 5 add_to_reclaim_list() при выполнении pop()
Реализация функции освобождения памяти 104 nodes_to_reclaim 4 current 1 5 3 add_to_reclaim_list(current); 1
Реализация функции освобождения памяти 105 nodes_to_reclaim 4 current 1 5 3
Реализация функции освобождения памяти 106 nodes_to_reclaim current 1 5 3
Недостатки указетелей опасности 107 1. Просмотр массива указателей опаности требует в худшем случае max_hazard_pointers атомарных переменных. 2. Атомарные операции могут работать медленнее эквивалентных обычных операций 3. При освобождении узла также требуется просмотреть список указателей опаности, т.е. max_hazard_pointers в худшем случае. Функция pop дорогостоящая. Решения?
Недостатки указетелей опасности 108 1. Просмотр массива указателей опаности требует в худшем случае max_hazard_pointers атомарных переменных. 2. Атомарные операции могут работать медленнее эквивалентных обычных операций 3. При освобождении узла также требуется просмотреть список указателей опаности, т.е. max_hazard_pointers в худшем случае. Функция pop дорогостоящая. Решения? 1. Вместо просмотра max_hazard_pointers в каждом pop(), проверяем 2 * max_hazard_pointers через каждые max_hazard_pointers вызовов pop() и освобождаем не менее max_hazard_pointers. В среднем проверяем два узла при каждом вызове pop() и один освобождаем. 2. Каждый поток хранит собственный список освобождения в локальных данных потока. Это потребует выделения памяти под max_hazard_pointers2 узлов.
Реализация стека, свободного от блокировок, с помощью умного указателя 109
Реализация на основе атомарного умного указателя 110 ▪ Удалять узлы можно только при отсутствии обращения к ним из других потоков ▪ Если на узел нет ссылки, то его можно удаляь
Реализация на основе атомарного умного указателя 111 ▪ Удалять узлы можно только при отсутствии обращения к ним из других потоков ▪ Если на узел нет ссылки, то его можно удаляь ▪ Умный указатель shared_ptr как раз решает эту задачу!
Реализация на основе атомарного умного указателя 112 ▪ Удалять узлы можно только при отсутствии обращения к ним из других потоков ▪ Если на узел нет ссылки, то его можно удаляь ▪ Умный указатель shared_ptr как раз решает эту задачу! ... ▪ Но, к сожалению, атомарные операции c shared_ptr в большинстве реализаций не свободны от блокировок.
Реализация на основе атомарного умного указателя 113 template <typename T> class lfstack { private: struct node { std::shared_ptr<T> data; std::shared_ptr<node> next; node(T const& _data): data(std::make_shared<T>(_data)) { } }; std::shared_ptr<node> head;
Реализация на основе атомарного умного указателя 114 ... void push(T const& data) { std::shared_ptr<node> const new_node = std::make_shared<node>(data); new_node->next = head.load(); while (!std::atomic_compare_exchange_weak(&head, &nead_node->next, new_node)); } std::shared_ptr<T> pop() { std::shared_ptr<node> old_head = std::atomic_load(&head); while (old_head && !std::atomic_compare_exchange_weak(&head, &old_head, old_head->next)); return old_head ? old_head->data : std::shared_ptr<T>(); }
Реализация стека, свободного от блокировок, с помощью подсчёта ссылок 115
Двойной счётчик ссылок 116 counted_node_ptr node internal_count data next external_count ▪ При начале каждого чтения внешний счётчик увеличивается. ▪ При завершении чтения внутренний счётчик уменьшается. ▪ При удалении узла внутренний счетчик увеличивается на величину внешнего минус 1, а внешний отбрасывается. ▪ Если внутренний счётчик равен 0, узел можно удалять.
Двойной счётчик ссылок 117 head 1 2 3
Двойной счётчик ссылок 118 template<typename T> class lfstack { private: struct counted_node_ptr { int external_count; node* ptr; }; struct node { std::shared_ptr<T> data; std::atomic<int> internal_count; counted_node_ptr next; node(T const& _data): data(std::make_shared<T>(_data)), internal_count(0) {} }; std::atomic<counted_node_ptr> head;
Двойной счётчик ссылок 119 ~lfstack() { while (pop()); } void push(T const& data) { counted_node_ptr new_node; new_node.ptr = new node(data); new_node.external_count = 1; new_node.ptr->next = head.load(); while (!head.compare_exchange_weak(new_node.ptr->next, new_node)); } };
Двойной счётчик ссылок 120 template <typename T> class lfstack { private: // Увеличение внешнего счётчика void increase_head_count(counted_node_ptr& old_counter) { counted_node_ptr new_counter; do { new_counter = old_counter; ++new_counter.external_count; } while (!head.compare_exchange_strong(old_counter, new_counter)); old_counter.external_count = new_counter.external_count; }
public: std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Двойной счётчик ссылок 121
public: std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Двойной счётчик ссылок 122 1. Увеличить внешний счётчик 2. Разыменовать указатель 3. Проверить указатель на пустоту
public: std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Двойной счётчик ссылок 123 Попытаться выполнить удаление узла 1. Если получилось, забрать данные 2. Прибавить внутренний счётчик к внешнему 3. Если счётчик стал равным 0, удалить узел 4. Вернуть результат (даже если счётчик не стал равным 0)
public: std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Двойной счётчик ссылок 124 Если не получилось выполнить удаление узла (какой-то поток удалил узел раньше нас) 1. Уменьшить счётчик ссылок на 1. 2. Если другие потоки на узел не ссылаются, освободить память (убрать за тем потоком, который выполнил удаление)
0 0 Двойной счётчик ссылок 125 1 0 1 1 head 1 2 3 Сценарий 1: Поток А эксклюзивно удаляет узел. Другие потоки ему не мешают.
0 0 Двойной счётчик ссылок 126 2 1 1 head 1 2 3 Поток A: increase_head_count(old_head) node* const = old_head.ptr 0
0 0 0 Двойной счётчик ссылок 127 2 1 1 head 1 2 3 Поток A: head.compare_exchange(old_head, ptr->next)
0 0 0 Двойной счётчик ссылок 128 2 1 1 head 1 2 3 Поток A: count_increase = 2 - 2 = 0 internal_count = 0 + 0 = 0
0 0 0 Двойной счётчик ссылок 129 2 1 1 head 1 2 3 Поток A: delete ptr
0 0 0 Двойной счётчик ссылок 130 1 1 1 head 1 2 3 Сценарий 2: Потоки А и В одновременно удаляют узел. Потоку А удаётся выполнить удаление узла вперёд B. Поток В успевает выйти из pop до того, как А попробует освободить узел.
0 0 0 Двойной счётчик ссылок 131 2 1 1 head 1 2 3 Поток B: increase_head_count(old_head)
0 0 0 Двойной счётчик ссылок 132 3 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток A: increase_head_count(old_head) head.compare_exchange(...)
-1 0 0 Двойной счётчик ссылок 133 3 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток B: internal_count.fetch_sub(1) Поток A: increase_head_count(old_head) head.compare_exchange(...)
0 0 0 Двойной счётчик ссылок 134 x 1 1 head 1 2 3 Поток A: count_increase = 3 - 2 = 1 internal_count = -1 + 1 = 0 Поток B: increase_head_count(old_head) Поток B: internal_count = 0 - 1 = -1 Поток A: increase_head_count(old_head) head.compare_exchange(...)
0 0 0 Двойной счётчик ссылок 135 x 1 1 head 1 2 3 Поток A: count_increase = 3 - 2 = 1 internal_count = -1 + 1 = 0 Поток B: increase_head_count(old_head) Поток B: internal_count = 0 - 1 = -1 Поток A: increase_head_count(old_head) head.compare_exchange(...) Поток A: delete ptr
0 0 0 Двойной счётчик ссылок 136 1 1 1 head 1 2 3 Сценарий 3: Потоки А и В одновременно удаляют узел. Потоку А удаётся выполнить удаление узла вперёд B. Поток В не успевает выйти из pop, когда А пытается освободить узел, и поэтому А узел не освобождает. Зато поток В, последним покидая узел, освобождает память из-под узла, удалённого А.
0 0 0 Двойной счётчик ссылок 137 3 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток A: increase_head_count(old_head) head.compare_exchange(...)
1 0 0 Двойной счётчик ссылок 138 x 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток A: increase_head_count(old_head) head.compare_exchange(...) Поток A: count_increase = 3 - 2 = 1 internal_count = 0 + 1 = 1 Поток A узел не освобождает
0 0 0 Двойной счётчик ссылок 139 x 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток A: increase_head_count(old_head) head.compare_exchange(...) Поток A: count_increase = 3 - 2 = 1 internal_count = 0 + 1 = 1 Поток A узел не освобождает Поток B: internal_count = 1 - 1 = 0 delete ptr Узел освобождает поток B
Двойной счётчик ссылок - проблема 140 template<typename T> class lfstack { private: struct counted_node_ptr { int external_count; node* ptr; }; struct node { std::shared_ptr<T> data; std::atomic<int> internal_count; counted_node_ptr next; node(T const& _data): data(std::make_shared<T>(_data)), internal_count(0) {} }; std::atomic<counted_node_ptr> head; Структура может не поддерживать выполнение атомарных операций без блокировок!
Применение модели памяти С++ для стека, свободного от блокировок 141
Применение модели памяти С++ 142 void push(T const& data) { counted_node_ptr new_node; new_node.ptr = new node(data); new_node.external_count = 1; new_node.ptr->next = head.load(std::memory_order_relaxed); while (!head.compare_exchange_weak(new_node.ptr->next, new_node)); void increase_head_count(counted_node_ptr& old_counter) { counted_node_ptr new_counter; do { new_counter = old_counter; ++new_counter.external_count; } while (!head.compare_exchange_strong(old_counter, new_counter)); old_counter.external_count = new_counter.external_count; }
Применение модели памяти С++ 143 void push(T const& data) { counted_node_ptr new_node; new_node.ptr = new node(data); new_node.external_count = 1; new_node.ptr->next = head.load(std::memory_order_relaxed); while (!head.compare_exchange_weak(new_node.ptr->next, new_node)); void increase_head_count(counted_node_ptr& old_counter) { counted_node_ptr new_counter; do { new_counter = old_counter; ++new_counter.external_count; } while (!head.compare_exchange_strong(old_counter, new_counter)); old_counter.external_count = new_counter.external_count; } Подготовка данных Установка head (“флага”) Проверка head (“флага”) Работа с добавленным элементом
Применение модели памяти С++ 144 void push(T const& data) { counted_node_ptr new_node; new_node.ptr = new node(data); new_node.external_count = 1; new_node.ptr->next = head.load(std::memory_order_relaxed); while (!head.compare_exchange_weak(new_node.ptr->next, new_node, std::memory_order_release, std::memory_order_relaxed)); void increase_head_count(counted_node_ptr& old_counter) { counted_node_ptr new_counter; do { new_counter = old_counter; ++new_counter.external_count; } while (!head.compare_exchange_strong(old_counter, std::memory_order_acquire, std::memory_order_relaxed, new_counter)); old_counter.external_count = new_counter.external_count; } Подготовка данных Установка head (“флага”) Работа с добавленным элементом Проверка head (“флага”)
Применение модели памяти С++ 145 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Чтение указателя
Применение модели памяти С++ 146 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Чтение указателя acquire не нужен, т.к. захват выполнен в increase_head_count
Применение модели памяти С++ 147 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Извлечение данных Удаление должно выполняться после извлечения данных
Применение модели памяти С++ 148 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase, std::memory_order_release) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Удаление должно выполняться после извлечения данных Извлечение данных
Применение модели памяти С++ 149 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase, std::memory_order_release) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1, std::memory_order_acquire) == 1) delete ptr; } Удаление должно выполняться после извлечения данных Извлечение данных
Применение модели памяти С++ 150 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase, std::memory_order_release) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1, std::memory_order_relaxed) == 1) ptr->internal_count.load(std::memory_order_acquire); delete ptr; } Достаточно вставить операцию захвата- загрузки, чтобы удалить ptr после извлечения данных Извлечение данных fetch_sub входит в последовательность освобождений, поэтому “не мешает” acquire
Разработка эффективного потокобезопасного неблокируемого стека 151
Схема устранения парных операций 152 Стек a b c head T3: pop() T1: pop() T2: push(d) Узкое место! ■ Загрузка кэш- памяти ■ Загрузка шины
Схема с задержкой 153 Стек a b c head T1: push(x) trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node));
Схема с задержкой 154 Стек a b c head T1: push(x) x trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node));
Схема с задержкой 155 Стек a b c T1: trypush(x) trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node)); CAS failed
Схема с задержкой 156 Стек a b c T1: trypush(x) trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node)); T1: backoff e.g. exponential backoff CAS failed
Схема с задержкой 157 Стек a b c T1: trypush(x) trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node)); T1: backoff T1: trypush(x) e.g. exponential backoff
Схема устранения парных операций 158 Речной вокзал – Цветной проезд 1235 ■ Пассажиры “состязаются” за водителя маршрутки (contention), который обслуживает их последовательно ■ Водитель маршрутки – “узкое место” (bottleneck)
Стек Схема устранения парных операций 159 a b c head Вспомогательный массив (elimination array) T3: pop() T1: pop() T2: push(d) T1: return(d) T2: ok
Стек Схема устранения парных операций 160 a b c head Вспомогательный массив (elimination array) T3: pop() T1: pop() T2: push(d) T1: return(d) T2: ok exchanger
Схема устранения парных операций 161 class exchanger { atomic<T*> slot{nullptr}; atomic<int> state{EMPTY}; public: auto exchanger(T* myitem, int waittime, T* result) { for (;;) { if (timeout(waittime)) return TIME_ELAPSED_CODE; auto curritem = slot.load(); auto currstate = state.load(); switch (currstate) {
Схема устранения парных операций 162 case EMPTY: if (slot.CAS(curritem, myitem) && state.CAS(EMPTY, WAITING)) { while (time < waittime) { curritem = slot.load(); if (state == BUSY) { slot.store(nullptr); state.store(EMPTY); return curritem; } } if (slot.CAS(myitem, nullptr) && state.CAS(WAITING, EMPTY)) { return TIME_ELAPSED_CODE; } else { curritem = slot.load(); slot.store(nullptr); state.store(EMPTY); return curritem; } }
Схема устранения парных операций 163 case WAITING: if slot.CAS(curritem, item) && state.CAS(WAITING, BUSY) return curritem; case BUSY: break; default: ... } } } }
Схема устранения парных операций 164 case EMPTY: if (slot.CAS(curritem, myitem) && state.CAS(EMPTY, WAITING)) { while (time < waittime) { old_item = slot.load(); if (state == BUSY) { slot.store(nullptr); state.store(EMPTY); return old_item; } } if (slot.CAS(myitem, nullptr) && state.CAS(WAITING, EMPTY)) { return TIME_ELAPSED_CODE; } else { item = slot.load(); slot.store(nullptr); state.store(EMPTY); return item; } } Оба CAS должны выполниться атомарно – как транзакция, т.е. либо выполниться оба, либо не выполниться вообще! Оба CAS должны выполниться атомарно – как транзакция, т.е. либо выполниться оба, либо не выполниться вообще!
class exchanger { struct content_t { T* slot{nullptr}; int state{EMPTY}; }; atomic<content_t> content; public: auto exchanger(T* myitem, int waittime, T* result) { for (;;) { if (timeout(waittime)) return TIME_ELAPSED_CODE; auto curritem = slot; auto currstate = state; switch (currstate) { Схема устранения парных операций 165 4 байта 8 байт 12 байт > машинного слова (8 байт) CAS выполнится не атомарно
class exchanger { struct content_t { T* slot{nullptr}; int state{EMPTY}; }; atomic<content_t*> content; public: auto exchanger(T* myitem, int waittime, T* result) { for (;;) { if (timeout(waittime)) return TIME_ELAPSED_CODE; auto curritem = slot.load(); auto currstate = state.load(); switch (currstate) { Схема устранения парных операций 166 CAS атомарный!
Схема устранения парных операций 167 case EMPTY: auto old_content = content; if (old_content->state == EMPTY) { auto new_content = new content{myitem, WAITING}; if (content.CAS(old_content, new_content) { while (time < waittime) { old_item = content->slot.load(); if (state == BUSY) { content->slot.store(nullptr); content->state.store(EMPTY); return old_item; } } delete old_content; } } // ... // Остальные пары CAS модифицируем аналогичным образом.
Схема устранения парных операций 168 T1: item1 state EMPTY slot null curritem currstate slot.load(); state.load();
slot null Схема устранения парных операций 169 T1: item1 state EMPTY CAS(old_content, new_content) curritem currstate null EMPTY old_content content item1 WAITING new_content
Схема устранения парных операций 170 state WAITING T1: item1 slot item1 curritem currstate null EMPTY old_content
Схема устранения парных операций 171 state WAITING T1: item1 slot item1 curritem currstate null EMPTY state.load() == BUSY?
Схема устранения парных операций 172 state WAITING T1: item1 slot item1 curritem currstate slot.load(); state.load(); T2: item2 old_content
Схема устранения парных операций 173 state WAITING T1: item1 slot item1 curritem currstate T2: item2 old_contentnew_content item1 WAITING item2 BUSY CAS(old_content, new_content)
slot item2 Схема устранения парных операций 174 state BUSY T1: item1 T2: item2 curritem currstate old_content item1 WAITING return curritem
Схема устранения парных операций 175 slot item2 T1: item1 T2: item2 curritem currstate null BUSY state.load() == BUSY? state BUSY YES!
Схема устранения парных операций 176 state item2 T1: item1 T2: item2 curritem currstate item2 BUSY slot BUSY state.load() return curritem
Стек Схема устранения парных операций 177 a b c head Вспомогательный массив (elimination array) T3: pop() T1: pop() T2: push(d) В худшем случае (если встречаются следуют не парно), вершина становится узким местом!
Elimination Tree (дерево устранения) 178 2 5 3 4 0 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 Линеаризация linearization Согласованность относительно “состояния покоя” quiescent consistency Линеаризация – такое выполнение параллельных операций, при котором они соответствуют какому-то последовательному выполнению операций со стеком. Т.е. потокобезопасный стек (или другая структура) “ведёт себя” как обычный последовательный стек.
Elimination Tree (дерево устранения) 179 2 5 3 4 0 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 Линеаризация linearization Согласованность относительно “состояния покоя” quiescent consistency Согласованность относительно “состояния покоя” – такое выполнение параллельных операций, при котором операции могут выполняться со стеком одновременно до момента, когда наступает “тишина”, т.е. нет текущих операций со структурой.
Elimination Tree (дерево устранения) 180 2 5 3 4 0 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 Добавление 5 элементов 5 разными потоками T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5)
Elimination Tree (дерево устранения) 181 2 5 3 4 0 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
Elimination Tree (дерево устранения) 182 2 5 3 4 1 0 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
Elimination Tree (дерево устранения) 183 5 3 4 0 0 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
Elimination Tree (дерево устранения) 184 5 3 4 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
Elimination Tree (дерево устранения) 185 5 1 4 1 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 2 3 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
Elimination Tree (дерево устранения) 186 5 4 0 1 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 3 2 1 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
Elimination Tree (дерево устранения) 187 5 1 0 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 3 2 1 4 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
Elimination Tree (дерево устранения) 188 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Есть состояние покоя!
Elimination Tree (дерево устранения) 189 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: pop() T2: pop() 1 2 Нет состояния покоя!
Elimination Tree (дерево устранения) 190 5 0 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: pop() T2: pop() 1 2 Нет состояния покоя!
Elimination Tree (дерево устранения) 191 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: pop() T2: pop() 2 T1:return(5) Нет состояния покоя!
Elimination Tree (дерево устранения) 192 5 1 1 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: pop() T2: pop() T2:return(5)Есть состояние покоя!
Elimination Tree (дерево устранения) 193 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 Корень дерева становится узким местом!
Elimination Tree (дерево устранения) 194 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 Корень дерева становится узким местом! И узлы тоже!
Elimination Tree с Elimination Arrays 195 5 1 1 1 2 3 4 Elimination array длины L T1:push(6) T2:pop() T5:push(7) 1 Elimination array длины L / 2 T3:pop() T4:pop() T5:ok T4: return(7) T3:return(5) T2:return(6) A:ok

More Related Content

PDF
ПВТ - весна 2015 - Лекция 5. Многопоточное программирование в С++. Синхрониза...
Alexey Paznikov
 
PDF
ПВТ - осень 2014 - Лекция 7. Многопоточное программирование без блокировок. М...
Alexey Paznikov
 
PDF
ПВТ - весна 2015 - Лекция 3. Реентерабельность. Сигналы. Локальные данные пот...
Alexey Paznikov
 
PDF
ПВТ - весна 2015 - Лекция 4. Шаблоны многопоточного программирования
Alexey Paznikov
 
PDF
Кулагин И.И., Пазников А.А., Курносов М.Г. Оптимизация информационных обменов...
Alexey Paznikov
 
PDF
ПВТ - весна 2015 - Лекция 6. Разработка параллельных структур данных на основ...
Alexey Paznikov
 
PDF
ПВТ - осень 2014 - Лекция 6 - Атомарные операции. Внеочередное выполнение инс...
Alexey Paznikov
 
PDF
ПВТ - осень 2014 - Лекция 5 - Многопоточное программирование в языке С++. Р...
Alexey Paznikov
 
ПВТ - весна 2015 - Лекция 5. Многопоточное программирование в С++. Синхрониза...
Alexey Paznikov
 
ПВТ - осень 2014 - Лекция 7. Многопоточное программирование без блокировок. М...
Alexey Paznikov
 
ПВТ - весна 2015 - Лекция 3. Реентерабельность. Сигналы. Локальные данные пот...
Alexey Paznikov
 
ПВТ - весна 2015 - Лекция 4. Шаблоны многопоточного программирования
Alexey Paznikov
 
Кулагин И.И., Пазников А.А., Курносов М.Г. Оптимизация информационных обменов...
Alexey Paznikov
 
ПВТ - весна 2015 - Лекция 6. Разработка параллельных структур данных на основ...
Alexey Paznikov
 
ПВТ - осень 2014 - Лекция 6 - Атомарные операции. Внеочередное выполнение инс...
Alexey Paznikov
 
ПВТ - осень 2014 - Лекция 5 - Многопоточное программирование в языке С++. Р...
Alexey Paznikov
 

What's hot (20)

PDF
ПВТ - весна 2015 - Лекция 2. POSIX Threads. Основные понятия многопоточного п...
Alexey Paznikov
 
PDF
ПВТ - осень 2014 - Лекция 4 - Стандарт POSIX Threads. Реентерабельность. Сигн...
Alexey Paznikov
 
PDF
ПВТ - весна 2015 - Лекция 7. Модель памяти С++. Внеочередное выполнение инстр...
Alexey Paznikov
 
PDF
ПВТ - весна 2015 - Лекция 1. Актуальность параллельных вычислений. Анализ пар...
Alexey Paznikov
 
PDF
Дмитрий Кашицын, Троллейбус из буханки: алиасинг и векторизация в LLVM
Sergey Platonov
 
PDF
Юрий Ефимочев, Компилируемые в реальном времени DSL для С++
Sergey Platonov
 
PDF
Лекция 8. Intel Threading Building Blocks
Mikhail Kurnosov
 
PDF
ПВТ - весна 2015 - Лекция 0. Описание курса
Alexey Paznikov
 
PDF
Полухин Антон, Как делать не надо: C++ велосипедостроение для профессионалов
Sergey Platonov
 
PDF
Лекция 8: Многопоточное программирование: Intel Threading Building Blocks
Mikhail Kurnosov
 
PDF
Parallel STL
Evgeny Krutko
 
PDF
Лекция 6. Стандарт OpenMP
Mikhail Kurnosov
 
PDF
Модель памяти C++ - Андрей Янковский, Яндекс
Yandex
 
PDF
Лекция 2. Коллективные операции в MPI. Параллельные алгоритмы случайного блуж...
Alexey Paznikov
 
PDF
Догнать и перегнать boost::lexical_cast
Roman Orlov
 
PDF
Для чего мы делали свой акторный фреймворк и что из этого вышло?
Yauheni Akhotnikau
 
PDF
Дракон в мешке: от LLVM к C++ и проблемам неопределенного поведения
Platonov Sergey
 
PPTX
Григорий Демченко, Асинхронность и неблокирующая синхронизация
Sergey Platonov
 
PDF
Лекция 7: Многопоточное программирование: часть 3 (OpenMP)
Mikhail Kurnosov
 
PDF
Алексей Куканов — Параллелизм в C++: управляйте приложением, а не потоками!
Yandex
 
ПВТ - весна 2015 - Лекция 2. POSIX Threads. Основные понятия многопоточного п...
Alexey Paznikov
 
ПВТ - осень 2014 - Лекция 4 - Стандарт POSIX Threads. Реентерабельность. Сигн...
Alexey Paznikov
 
ПВТ - весна 2015 - Лекция 7. Модель памяти С++. Внеочередное выполнение инстр...
Alexey Paznikov
 
ПВТ - весна 2015 - Лекция 1. Актуальность параллельных вычислений. Анализ пар...
Alexey Paznikov
 
Дмитрий Кашицын, Троллейбус из буханки: алиасинг и векторизация в LLVM
Sergey Platonov
 
Юрий Ефимочев, Компилируемые в реальном времени DSL для С++
Sergey Platonov
 
Лекция 8. Intel Threading Building Blocks
Mikhail Kurnosov
 
ПВТ - весна 2015 - Лекция 0. Описание курса
Alexey Paznikov
 
Полухин Антон, Как делать не надо: C++ велосипедостроение для профессионалов
Sergey Platonov
 
Лекция 8: Многопоточное программирование: Intel Threading Building Blocks
Mikhail Kurnosov
 
Parallel STL
Evgeny Krutko
 
Лекция 6. Стандарт OpenMP
Mikhail Kurnosov
 
Модель памяти C++ - Андрей Янковский, Яндекс
Yandex
 
Лекция 2. Коллективные операции в MPI. Параллельные алгоритмы случайного блуж...
Alexey Paznikov
 
Догнать и перегнать boost::lexical_cast
Roman Orlov
 
Для чего мы делали свой акторный фреймворк и что из этого вышло?
Yauheni Akhotnikau
 
Дракон в мешке: от LLVM к C++ и проблемам неопределенного поведения
Platonov Sergey
 
Григорий Демченко, Асинхронность и неблокирующая синхронизация
Sergey Platonov
 
Лекция 7: Многопоточное программирование: часть 3 (OpenMP)
Mikhail Kurnosov
 
Алексей Куканов — Параллелизм в C++: управляйте приложением, а не потоками!
Yandex
 
Ad

Similar to ПВТ - весна 2015 - Лекция 8. Многопоточное программирование без использования блокировок (20)

PDF
Введение в разработку многопоточных приложений
CUSTIS
 
PPT
Как построить высокопроизводительный Front-end сервер (Александр Крижановский)
Ontico
 
PDF
C++ STL & Qt. Занятие 08.
Igor Shkulipa
 
PDF
Этюды о буферизации: асинхронные оповещения, репликация обновлений, объединен...
corehard_by
 
PPT
04 ос взаимодействие_процессов_1
921519
 
PDF
1 встреча — Параллельное программирование (А. Свириденков)
Smolensk Computer Science Club
 
PPTX
Операционные системы 2015, лекция № 5
Aleksey Bragin
 
PDF
Помоги ближнему, или Как потоки помогают друг другу
Alexey Fyodorov
 
PDF
Помоги ближнему, или Как потоки помогают друг другу
CEE-SEC(R)
 
PDF
2012 03 14_parallel_programming_lecture05
Computer Science Club
 
PDF
Что особенного в СУБД для данных в оперативной памяти / Константин Осипов (Ta...
Ontico
 
PPTX
javaaaaddawdawdawdasdsadsaddadadm11n.pptx
ssuserb46e0b
 
PDF
Distributed Systems Presentation for Business informatics students (Staroletov)
Sergey Staroletov
 
PDF
Nonblocking algorithms/CAS/Atomics by Alexey Fyodorov
JavaDayUA
 
PDF
Atomics, CAS and Nonblocking algorithms
Alexey Fyodorov
 
PPTX
Expert Java Day: Java concurrency
Pavel Titkov
 
PPTX
PostSharp - Threading Model Library
Andrey Gordienkov
 
PDF
PostSharp - Threading Model
Andrey Gordienkov
 
PDF
Общество Мертвых Потоков
Alexey Fyodorov
 
PDF
Практика Lock-free. RealTime-сервер
Platonov Sergey
 
Введение в разработку многопоточных приложений
CUSTIS
 
Как построить высокопроизводительный Front-end сервер (Александр Крижановский)
Ontico
 
C++ STL & Qt. Занятие 08.
Igor Shkulipa
 
Этюды о буферизации: асинхронные оповещения, репликация обновлений, объединен...
corehard_by
 
04 ос взаимодействие_процессов_1
921519
 
1 встреча — Параллельное программирование (А. Свириденков)
Smolensk Computer Science Club
 
Операционные системы 2015, лекция № 5
Aleksey Bragin
 
Помоги ближнему, или Как потоки помогают друг другу
Alexey Fyodorov
 
Помоги ближнему, или Как потоки помогают друг другу
CEE-SEC(R)
 
2012 03 14_parallel_programming_lecture05
Computer Science Club
 
Что особенного в СУБД для данных в оперативной памяти / Константин Осипов (Ta...
Ontico
 
javaaaaddawdawdawdasdsadsaddadadm11n.pptx
ssuserb46e0b
 
Distributed Systems Presentation for Business informatics students (Staroletov)
Sergey Staroletov
 
Nonblocking algorithms/CAS/Atomics by Alexey Fyodorov
JavaDayUA
 
Atomics, CAS and Nonblocking algorithms
Alexey Fyodorov
 
Expert Java Day: Java concurrency
Pavel Titkov
 
PostSharp - Threading Model Library
Andrey Gordienkov
 
PostSharp - Threading Model
Andrey Gordienkov
 
Общество Мертвых Потоков
Alexey Fyodorov
 
Практика Lock-free. RealTime-сервер
Platonov Sergey
 
Ad

More from Alexey Paznikov (16)

PDF
Лекция 6. Параллельная сортировка. Алгоритмы комбинаторного поиска. Параллель...
Alexey Paznikov
 
PDF
Лекция 5. Метод конечных разностей (параллельные алгоритмы в стандарте MPI)
Alexey Paznikov
 
PDF
Лекция 4. Производные типы данных в стандарте MPI
Alexey Paznikov
 
PDF
Лекция 3. Виртуальные топологии в MPI. Параллельные алгоритмы в стандарте MPI...
Alexey Paznikov
 
PDF
Лекция 1. Основные понятия стандарта MPI. Дифференцированные обмены
Alexey Paznikov
 
PDF
ПВТ - осень 2014 - Лекция 3 - Стандарт POSIX Threads
Alexey Paznikov
 
PDF
ПВТ - осень 2014 - Лекция 2 - Архитектура вычислительных систем с общей памятью
Alexey Paznikov
 
PDF
ПВТ - осень 2014 - лекция 1 - Введение в параллельные вычисления
Alexey Paznikov
 
PDF
ПВТ - осень 2014 - лекция 1а - Описание курса
Alexey Paznikov
 
PDF
Анализ эффективности выполнения алгоритма параллельной редукции в языке Cray ...
Alexey Paznikov
 
PPTX
ТФРВС - весна 2014 - лекция 11
Alexey Paznikov
 
PPTX
ТФРВС - весна 2014 - лекция 10
Alexey Paznikov
 
PPTX
ТФРВС - весна 2014 - лекция 9
Alexey Paznikov
 
PPTX
ТФРВС - весна 2014 - лекция 8
Alexey Paznikov
 
PPTX
ТФРВС - весна 2014 - лекция 7
Alexey Paznikov
 
PPTX
ТФРВС - весна 2014 - лекция 6
Alexey Paznikov
 
Лекция 6. Параллельная сортировка. Алгоритмы комбинаторного поиска. Параллель...
Alexey Paznikov
 
Лекция 5. Метод конечных разностей (параллельные алгоритмы в стандарте MPI)
Alexey Paznikov
 
Лекция 4. Производные типы данных в стандарте MPI
Alexey Paznikov
 
Лекция 3. Виртуальные топологии в MPI. Параллельные алгоритмы в стандарте MPI...
Alexey Paznikov
 
Лекция 1. Основные понятия стандарта MPI. Дифференцированные обмены
Alexey Paznikov
 
ПВТ - осень 2014 - Лекция 3 - Стандарт POSIX Threads
Alexey Paznikov
 
ПВТ - осень 2014 - Лекция 2 - Архитектура вычислительных систем с общей памятью
Alexey Paznikov
 
ПВТ - осень 2014 - лекция 1 - Введение в параллельные вычисления
Alexey Paznikov
 
ПВТ - осень 2014 - лекция 1а - Описание курса
Alexey Paznikov
 
Анализ эффективности выполнения алгоритма параллельной редукции в языке Cray ...
Alexey Paznikov
 
ТФРВС - весна 2014 - лекция 11
Alexey Paznikov
 
ТФРВС - весна 2014 - лекция 10
Alexey Paznikov
 
ТФРВС - весна 2014 - лекция 9
Alexey Paznikov
 
ТФРВС - весна 2014 - лекция 8
Alexey Paznikov
 
ТФРВС - весна 2014 - лекция 7
Alexey Paznikov
 
ТФРВС - весна 2014 - лекция 6
Alexey Paznikov
 

ПВТ - весна 2015 - Лекция 8. Многопоточное программирование без использования блокировок

  • 1. Лекция 8. Многопоточное программирование без блокировок. Модель потребитель-производитель. Потокобезопасный стек Пазников Алексей Александрович Кафедра вычислительных систем СибГУТИ Сайт курса: http://cpct.sibsutis.ru/~apaznikov/teaching/ Вопросы: https://piazza.com/sibsutis.ru/spring2015/pct2015spring Параллельные вычислительные технологии Осень 2014 (Parallel Computing Technologies, PCT 14)
  • 2. Многопоточное программирование без использования блокировок 2 Если вы думаете, что программирование без блокировок это просто, значит или вы - один из тех 50 человек, которые умеют это делать, или же используете атомарные инструкции недостаточно аккуратно. Герб Саттер
  • 3. Цели многопоточного программирования без блокировок 3 Однопоточная программа Многопоточная программа с блокировками Многопоточная программа без блокировок
  • 4. Цели многопоточного программирования без блокировок ▪ Повышение масштабируемости путём сокращения блокировок и ожиданий в алгоритмах и структурах данных. ▪ Решение проблем, связанных с блокировками: ▫ Гонки: нужно не забыть заблокировать, причём именно нужный участок кода ▫ Дедлоки: необходимо запирать в нужном порядке различные потоки ▫ Сложность выбора критической секции (простота или масштабируемость) ▫ Голоданеие, инверсия приоритетов и др. 4
  • 5. Виды алгоритмов, свободных от блокировок ▪ Свободные от ожиданий (wait-free). “Никто никогда не ждёт”. Каждая операция завершается за N шагов без каких-либо условий. Гарантии: ▫ максимум пропускной способности системы ▫ отсутствие голодания ▪ Свободные от блокировок (lock-free). “Всегда какой-то из потоков работает”. Каждый шаг приближает итоговое решение. Гарантии: ▫ максимум пропускной способности системы ▫ отсутствие голодания (один поток может постоянно ожидать) ▪ Свободные от препятствий (obstruction-free). “Поток работает, если нет конфликтов”. За ограниченное число шагов поток, при условии, что другие “мешающие” ему потоки остановлены, достигает результата. ▫ Все потоки не блокируются из-за проблем (задержек, ошибок) с другими потоками. ▫ Не гарантируется прогресс, если одновременно работают два или больше потоков. 5
  • 8. Цели многопоточного программирования без блокировок 8 t ≥ 30 мин. ■ 40 мин. ■ 1 час ■ 2 часа ■ ...
  • 9. Цели многопоточного программирования без блокировок 9 t ≥ 30 мин. ■ 40 мин. ■ 1 час ■ 2 часа ■ ...
  • 10. Цели многопоточного программирования без блокировок 10 t ≥ 30 мин. ■ 40 мин. ■ 1 час ■ 2 часа ■ ... t = 1 час ± 10 мин.
  • 11. Цели многопоточного программирования без блокировок 11 locks (с блокировками) lock-free (без блокировок) t ≥ 30 мин. ■ 40 мин. ■ 1 час ■ 2 часа ■ ... t = 1 час ± 10 мин.
  • 13. Производитель-потребитель на основе блокировок 13 Производитель Потребитель Потребитель Потребитель Производитель Производитель
  • 14. Производитель-потребитель на основе блокировок void producer() { while (ThereAreTasks()) { task = BuildNewTask(); std::unique_lock<std::mutex> lock{mut}; queue.push(task); lock.unlock(); cv.notify(); } std::unique_lock<std::mutex> lock{mut}; queue.push(done); // добавить признак окончания lock.unlock(); cv.notify(); } 14
  • 15. Производитель-потребитель на основе блокировок void consumer() { task = nullptr; while (task != done) { std::unique_lock<std::mutex> lock{mut}; cv.wait(mut, []{ return queue.empty(); }); task = queue.first(); if (task != done) queue.pop(); } if (task != done) DoWork(task); } 15
  • 16. 1 производитель, K потребителей 16 emptyempty empty empty 1 2 3 K
  • 18. Производитель-потребитель без блокировок 18 put out is empty? is empty? empty put out full is empty? empty full is empty? is empty? is empty?
  • 20. Производитель-потребитель без блокировок 20 is empty? is empty? put in full is empty? empty full is empty? process process full is empty?
  • 25. Производитель-потребитель без блокировок 25 Empty Task Done Start End Производитель Потребитель
  • 26. Производитель 26 curr = 0; // указатель на текущий слот while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // если null, то проверить curr = (curr + 1) % numOfConsumers; // следующий слот slot[curr] = task; sem[curr].signal(); }
  • 27. Производитель 27 curr = 0; // указатель на текущий слот while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // если null, то проверить curr = (curr + 1) % numOfConsumers; // следующий слот slot[curr] = task; sem[curr].signal(); } // Фаза 2: выставить флаги “done” во всех слотах numNotified = 0; while (numNotified < numOfConsumers) { while (slot[curr] != null) // если null, то проверить curr = (curr + 1) % numOfConsumers; // следующий slot[curr] = done; // освободить слот sem[curr].signal(); ++numNotified; }
  • 28. Потребитель 28 task = null; while (task != done) // Дождаться, когда слот будет полным while ((task = slot[mySlot]) == null) sem[mySlot].wait(); if (task != done) { slot[mySlot] = null; // помечаем слот пустым DoWork(task); // выполняем задачу } // вне критической секции }
  • 29. Потребитель 29 task = null; while (task != done) // Дождаться, когда слот будет полным while ((task = slot[mySlot]) == null) sem[mySlot].wait(); if (task != done) { slot[mySlot] = null; // помечаем слот пустым DoWork(task); // выполняем задачу } // вне критической секции } Как применить модель памяти С++?
  • 30. Производитель, модель памяти С++ 30 curr = 0; while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = task; // release non-null sem[curr].signal(); } // Фаза 2: выставить флаги “done” во всех слотах numNotified = 0; while (numNotified < numOfConsumers) { while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = done; // release done sem[curr].signal(); ++numNotified; }
  • 31. Потребитель, модель памяти С++ 31 task = null; while (task != done) // Дождаться, когда слот будет полным while ((task = slot[mySlot]) // acquire non-null == null) sem[mySlot].wait(); if (task != done) { slot[mySlot] = null; // release null DoWork(task); } }
  • 32. Производитель-потребитель, класс алгоритма 32 curr = 0; while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = task; // release non-null sem[curr].signal(); } // Фаза 2: выставить флаги “done” во всех слотах numNotified = 0; while (numNotified < numOfConsumers) { while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = done; // release done sem[curr].signal(); ++numNotified; } Алгоритм - свободный от ожиданий, свободный от блокировок или свободный от остановок?
  • 33. Производитель-потребитель, класс алгоритма 33 curr = 0; while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = task; // release non-null sem[curr].signal(); } // Фаза 2: выставить флаги “done” во всех слотах numNotified = 0; while (numNotified < numOfConsumers) { while (slot[curr] != null) // acquire null curr = (curr + 1) % numOfConsumers; slot[curr] = done; // release done sem[curr].signal(); ++numNotified; } Алгоритм - свободный от ожиданий, свободный от блокировок или свободный от остановок? Этап 2: Свободная от остановок Этап 1: Свободный от ожиданий
  • 34. Производитель-потребитель без блокировок 34 task = null; while (task != done) // Дождаться, когда слот будет полным while ((task = slot[mySlot]) == null) sem[mySlot].wait(); if (task != done) { slot[mySlot] = null; DoWork(task); } } можно ли поменять две строки? нужно ли это сделать?
  • 35. N производителей, K потребителей 35 1 2 3 K ? ? ? ? ? ? ? ?
  • 36. N производителей, K потребителей 36 1 2 3 K ? ? ? ? ? ? ? ? гонка!
  • 37. N производителей, K потребителей 37 is empty? is empty? is empty? is empty? 1 2 3 K CAS(empty, full) CAS(empty, full) CAS(empty, full) CAS(empty, full)
  • 38. N производителей, K потребителей 38 is empty? is empty? is empty? is empty? CAS(empty, full) CAS(empty, full) CAS(empty, full) CAS(empty, full) 1 2 3 K CAS – compare and swap (compare exchange) CAS – атомарное сравнение с обменом
  • 39. N производителей, K потребителей 39 producer (вариант): curr = 0; while (ThereAreMoreTasks()) { task = AllocateAndBuildNewTask(); while (!slot[curr].CAS(null, task)) curr = (curr + 1) % numOfConsumers; sem[curr].signal(); } Не получилось – идём дальше Пытаемся атомарно сделать из пустого слота полный
  • 40. N производителей, M потребителей 40 1 2 K3 ? ? ? ? ? ? ? ?
  • 41. N производителей, M потребителей 41 1 2 K3 ? ? ? ? ? ? ? ? гонка! гонка!
  • 42. N производителей, M потребителей 42 CAS(empty, full) CAS(empty, full) CAS(empty, full) CAS(empty, full) CAS(full, empty) CAS(empty, full) CAS(empty, full) CAS(empty, full) 1 2 K3 CAS – атомарное сравнение с обменом CAS – compare and swap (compare exchange)
  • 43. N производителей, M потребителей 43 consumer (вариант): task = null; curr = 0; while (true) { task = slot[curr]; if (slot[curr] != null) if (!slot[curr].CAS(task, null)) curr = (curr + 1) % numOfSlots; if (task != done) DoWork(task); else break; } Пытаемся атомарно сделать из полного слота пустой Не получилось – идём дальше Запоминаем состояние слота и проверяем, не пустой ли он
  • 44. Реализация стека, свободного от блокировок, на основе сборщика мусора 44
  • 45. Стек, свободный от блокировок 45 T T T T head 1. Конструктор 2. Деструктор 3. Поиск узла (find) 4. Добавление узла (push) 5. Удаление узла (pop)
  • 46. Стек, свободный от блокировок 46 template <typename T> class lfstack { public: lfstack(); ~lfstack(); T* find(T data) const; // найти элемент, равный data void push(T data); // добавить элемент в голову private: struct node { // атомарные операции T data; // не требуются node* next; }; std::atomic<node*> head{nullptr}; // атомарный указатель }; // на голову списка
  • 47. Конструктор и деструктор 47 template <typename T> lfstack<T>::lfstack() {} Объект создаётся в одном потоке, поэтому не нужно обеспечивать параллельный доступ. Нельзя использовать стек до тех пор, пока он не будет создан, т.е. до выполнения конструктора, и после того, как он будет уничтожен, т.е. после выполнения деструктора. template <typename T> lfstack<T>::~lfstack() { auto first = head.load(); while (first) { auto unlinked = first; first = first->next; delete unlinked; } }
  • 48. Функция push 48 1. Создать новый узел. 2. Записать в его указатель next текущее значение head. 3. Записать в head указатель на новый узел. void push(T const& data) { auto new_node = new node{data}; // (1) node_node->next = head.load(); // (2) head = new_node; // (3) } struct node { T data; node* next; node(T const& _data): data{_data} {} };
  • 51. Функция push 51 T head TTT Начальная стадия Промежуточная стадия T head TTT T Конечная стадия T head TTT T
  • 52. Функция push – гонка 52 T head TTT Начальная стадия Промежуточная стадия выполняется двумя потоками T head TTT T T
  • 53. Функция push 53 T head TTT Начальная стадия Промежуточная стадия выполняется двумя потоками T head TTT T Первый добавляемый элемент пропал, остался только второй T head TTT T T T
  • 54. Функция push 54 void push(T const& data) { auto new_node = new node{data}; // (1) node_node->next = head.load(); // (2) head = new_node; // (3) while (!head.compare_exchange_weak(new_node->next, new_node)); // (3) } 1. Создать новый узел. 2. Записать в его указатель next текущее значение head. 3. Записать в head указатель на новый узел, при этом с помощью операции сравнить-и-обменять гарантировать то, что head не был модифицирован с момента чтения на шаге 2.
  • 55. Функция pop (ошибочная) 55 void pop(T& result) { node* old_head = head.load(); head = head->next; result = old_head->data; }
  • 56. Функция pop 56 T head TTT Начальная стадия Промежуточная стадия T head TTT Конечная стадия T head TT
  • 57. Функция pop 57 T head TTT Начальная стадия Промежуточная стадия T head TTT Конечная стадия T head TT B A A B head
  • 58. Функция pop (ошибочная) 58 void pop(T& result) { node* old_head = head.load(); while (!head.compare_exchange_weak(old_head, old_head->next); result = old_head->data; }
  • 59. Функция pop (ошибочная) 59 void pop(T& result) { node* old_head = head.load(); while (!head.compare_exchange_weak(old_head, old_head->next); result = old_head->data; }
  • 60. Функция pop (ошибочная) 60 void pop(T& result) { node* old_head = head.load(); while (!head.compare_exchange_weak(old_head, old_head->next); result = old_head->data; } std::shared_ptr<T> pop(T& result) { node* old_head = head.load(); while (old_head && !head.compare_exchange_weak(old_head, old_head->next)); return old_head ? old_head->data : std::shared_ptr<T>(); }
  • 61. Функция pop (ошибочная) 61 class lfstack { private: struct node { std::shared_ptr<T> data; node* next; node(T const& _data): data(std::make_shared<T>(_data)) { } }; ... std::shared_ptr<T> pop(T& result) { node* old_head = head.load(); while (old_head && !head.compare_exchange_weak(old_head, old_head->next)); return old_head ? old_head->data : std::shared_ptr<T>(); }
  • 62. Проблема АВА 62 4 old_head 321 head->next Поток А выполняет удаление узла из вершины стека
  • 63. Проблема АВА 63 4 old_head 321 head->next 43 Поток А выполняет удаление узла из вершины стека old_head old_head->next Поток А был вытеснен и другие потоки удалили два узла из стека
  • 64. Проблема АВА 64 4 old_head 321 head->next 43 Поток А был вытеснен и другие потоки удалили два узла из стека Поток А выполняет удаление узла из вершины стека 435 old_head old_head->next old_head old_head->next Некий поток добавил новый узел и аллокатор выделил под него ту же память
  • 65. Проблема АВА 65 4 old_head 321 head->next 43 Поток А выполняет удаление узла из вершины стека 43 Некий поток добавил новый узел и аллокатор выделил под него ту же память 5 43 Поток А: head.compare_exchange( old_head, old_head->next)) 5 old_head old_head->next old_head old_head->next old_head old_head->next Поток А был вытеснен и другие потоки удалили два узла из стека
  • 66. Проблема АВА 66 4 old_head 321 head->next 43 Поток А выполняет удаление узла из вершины стека 435 43 Некий поток добавил новый узел и аллокатор выделил под него ту же память Поток А: head.compare_exchange( old_head, old_head->next)) 5 old_head old_head->next old_head old_head->next old_head old_head->next Поток А был вытеснен и другие потоки удалили два узла из стека
  • 67. Решения проблемы АВА 67 1. “Ленивый” сборщик мусора 2. Указатели опасности 3. Счётчик ссылок на элемент 4. Сделать узлы уникальными 5. Вообще не удалять узлы 6. Добавление дополнительных узлов 7. и т.д.
  • 68. Функция pop (наивная) 68 // количество потоков, выполняющих pop std::atomic<unsigned> threads_in_pop; std::shared_ptr<T> pop() { threads_in_pop++; node* old_head = head_load(); while (old_head && !head.compare_exchange_weak(old_head, old_head->next)); std::shared_ptr<T> res; if (old_head) res.swap(old_head->data); // не копировать, // а обменять данные try_reclaim(old_head); // попробовать освободить // удалённые узлы return res; }
  • 69. Функция pop (наивная) 69 template<typename T> class lfstack { private: std::atomic<node*> delete_list; static void delete_nodes(node* nodes); while (nodes) { node* next = nodes->next; delete nodes; nodes = next; } }
  • 70. Функция try_reclaim освобождения удалённых узлов 70 void try_reclaim(node* old_head) { if (threads_in_pop == 1) { // я единственный в pop? node* nodes_to_delete = // захватить список delete_list.exchange{nullptr}; // на удаление if (!--thread_in_pop) // точно единственный? delete_nodes(nodes_to_delete)); // удалить всё! else if (nodes_to_delete) // если в захваченном списке // что-то было // вернуть это в общий список узлов на удаление chain_pending_nodes(nodes_to_delete); delete old_head; // удаляем хотя бы только что // исключённый узел } else { // удалим узел как-нибудь потом chain_pending_node(old_head); --threads_in_pop; } }
  • 71. Функция try_reclaim освобождения удалённых узлов 71 // добавляем захваченный список в общий список узлов, // подлежащих удалению void chain_pending_nodes(node* nodes) { node* last = nodes; while (node* const next = last->next) last = next; chain_pending_nodes(nodes, last); } // добавить список узлов в список узлов на удаление void chain_pending_nodes(node* first, node* last) { last->next = delete_list; while (!delete_list.compare_exchange_weak(last->next, first)); } // добавить узел в список узлов на удаление void chain_pending_node(node* n) { chain_pending_nodes(n, n); }
  • 72. Функция try_reclaim освобождения удалённых узлов 72 4 head 321 delete_list 0threads_in_pop 4 head 321 delete_list threads_in_pop 1 5 5 A A удаляет узел 1 и вытесняется в pop() после 1-го чтения threads_in_pop
  • 73. Функция try_reclaim освобождения удалённых узлов 73 4 head 32 delete_list 2threads_in_pop 43 delete_list threads_in_pop 2 5 2 С удаляет узел и продолжает работать до момента выхода из pop() old_head B B вызывает pop() и вытесняется после 1-го чтения head A head old_head B 4 C 5 A
  • 74. Функция try_reclaim освобождения удалённых узлов 74threads_in_pop 2 43 delete_list threads_in_pop 2 2 A возобновляет выполнение и захватывает список на удаление. После этого он должен 2-й раз проверить, один ли он в pop() head old_head B 2 5 A 43 head old_head B 2 delete_list A 2 5 delete_list B возобновляет выполнение, выполняет CAS и переходит к 3 узлу
  • 75. Реализация стека, свободного от блокировок, на основе указателей опасности 75
  • 76. Указатели опасности (hazard pointers) 76 4 old_head 321 head->next 43 Поток А выполняет удаление узла из вершины стека и помечает узел 1 как узел, который он использует. old_head old_head->next Поток А был вытеснен и другие потоки удалили два узла из стека, но не освобождают память из-под первого узла. 2 head head 1 A “понимает”, что головной узел head изменился и нужно выполнить compare_exchange 43 old_head old_head->next 21
  • 77. Функция pop на основе указателей опасности 77 std::shared_ptr<T> pop() { std::atomic<void*>& hp = get_hazard_pointer_for_current_thread(); // установить указатель опасности перед чтением указателя, // который мы собираемся разыменовывать node* old_head = head.load(); node* temp; do { temp = old_head; hp.store(old_head); old_head = head.load(); } while (old_head != temp); // ... }
  • 78. Функция pop на основе указателей опасности 78 std::shared_ptr<T> pop() { std::atomic<void*>& hp = get_hazard_pointer_for_current_thread(); node* old_head = head.load(); do { node* temp; do { temp = old_head; hp.store(old_head); // устанавливаем УО old_head = head.load(); } while (old_head != temp); } while (old_head && // получаем узел !head.compare_exchange_strong(old_head, old_head->next)); hp.store(nullptr);
  • 79. Указатели опасности (hazard pointers) 79 4 old_head 321 head hp
  • 80. Указатели опасности (hazard pointers) 80 4 old_head 321 head temp = old_head temp hp
  • 81. Указатели опасности (hazard pointers) 81 4 old_head 321 head hp temp = old_head temp hp.store(old_head)
  • 82. Указатели опасности (hazard pointers) 82 4 old_head 321 temp = old_head head temp hp.store(old_head) old_head = head.load() “old old_head” “new old_head” hp
  • 83. Указатели опасности (hazard pointers) 83 4 old_head 321 temp = old_head head temp hp.store(old_head) old_head = head.load() “old old_head” “new old_head” hp == ? Таким образом, внутренний цикл гарарантирует то, что указатель опасности будет указывать на тот головной элемент head, с котором мы будем работать (сдвигать указатель на следующий элемент) Проверка позволяет определить, не изменился ли головной элемент с тех пор, когда мы запомнили его в указателе опасности.
  • 84. Указатели опасности (hazard pointers) 84 4 old_head 321 temp = old_head head temp hp.store(old_head) old_head = head.load() “old old_head” “new old_head” hp == ? Во внешнем цикле сдвигаем указатель с head на следующий элемент с уверенностью, что никто не подменит элемент head.
  • 85. Указатели опасности (hazard pointers) 85 После того, как поток А успешно выполнил compare_exchange, указатель опасности можно обнулять hp.store(nullptr), т.к. никто пока не сможет удалить old_head, кроме А, поскольку head изменён потоком А 43 old_head old_head->next 21 Вариант 1 43 old_head->next 1 Вариант 2 old_head 2
  • 86. Функция pop на основе указателей опасности 86 std::shared_ptr<T> res; if (old_head) { res.swap(old_head->data); // извлекаем данные if (outstanding_hazard_pointers_for(old_head)) // если опасно, удаляем потом reclaim_later(old_head); else // если не опасно, удаляем сейчас delete old_head; // пробуем удалить узлы, какие можно удалить delete_nodes_with_no_hazards(); } return res; }
  • 88. Реализация указателей опасности 88 4321 head 1 5 6 7 m432 Указатели опасности, m = max_hazard_pointers пустой? нет if (hazard_pointers[i].id. compare_exchange_strong( old_id, std::this_thread::get_id())) thread_local hp
  • 89. Реализация указателей опасности 89 4321 head 1 5 6 7 m432 Указатели опасности, m = max_hazard_pointers пустой? да if (hazard_pointers[i].id. compare_exchange_strong( old_id, std::this_thread::get_id())) thread_local hp
  • 90. Реализация указателей опасности 90 4321 head 1 5 6 7 m432 Указатели опасности, m = max_hazard_pointers пустой? да if (hazard_pointers[i].id. compare_exchange_strong( old_id, std::this_thread::get_id())) thread_local hp
  • 91. Реализация указателей опасности 91 const auto max_hazard_pointers = 100; struct hazard_pointer { std::atomic<std::thread::id> id; std::atomic<void*> pointer; }; hazard_pointer hazard_pointers[max_hazard_pointers]; class hp_owner { hazard_pointer* hp; public: hp_owner(hp_owner const&) = delete; hp_owner operator=(hp_owner const&) = delete;
  • 92. Реализация указателей опасности 92 hp_owner(): hp{nullptr} { for (auto i = 0; i < max_hazard_pointers; i++) { std::thread::id old_id; // пустой незанятый УО // если i-й УО не занят, завладеть им, записав в него // свой идентификатор потока if (hazard_pointers[i].id.compare_exchange_strong( old_id, std::this_thread::get_id())) { hp = &hazard_pointers[i]; // я владею i-м УО break; } } // таблица УО закончилась, указателей нам не досталось if (!hp) throw std::runtime_error("No hazard ptrs available"); }
  • 93. Реализация указателей опасности 93 hp_owner(): hp{nullptr} { for (auto i = 0; i < max_hazard_pointers; i++) { std::thread::id old_id; if (hazard_pointers[i].id.compare_exchange_strong( old_id, std::this_thread::get_id())) { hp = &hazard_pointers[i]; break; } } if (!hp) throw std::runtime_error("No hazard ptrs available"); } std::atomic<void*>& get_pointer() { return hp->pointer; } ~hp_owner() { hp->pointer.store(nullptr); hp->id.store(std::thread::id()); }
  • 94. Реализация указателей опасности 94 // вернуть указатель опасности для текущего потока std::atomic<void*>& get_hazard_pointer_for_current_thread() { thread_local static hp_owner hazard; return hazard.get_pointer(); }
  • 95. Реализация указателей опасности 95 // вернуть указатель опасности для текущего потока std::atomic<void*>& get_hazard_pointer_for_current_thread() { thread_local static hp_owner hazard; return hazard.get_pointer(); } // проверить, не ссылается ли на указатель какой-то из УО bool outstanding_hazard_pointers_for(void* p) { for (auto i = 0; i < max_hazard_pointers; i++) { if (hazard_pointers[i].pointer.load() == p) { return true; } } return false; }
  • 96. Реализация функции освобождения памяти 96 template <typename T> void do_delete(void* p) { delete static_cast<T*>(p); } struct data_to_reclaim { // обёртка над данными для void* data; // помещения в список удаления std::function<void(void*)> deleter; data_to_reclaim* next; template<typename T> data_to_reclaim(T* p): data{p}, deleter{&do_delete<T>}, next{0} { } ~data_to_reclaim() { deleter(data); } }; std::atomic<data_to_reclaim*> nodes_to_reclaim;
  • 97. Реализация функции освобождения памяти 97 // добавить элемент в список на удаление void add_to_reclaim_list(data_to_reclaim* node) { node->next = nodes_to_reclaim.load(); while (!nodes_to_reclaim.compare_exchange_weak( node->next, node)); } // удалить элемент позже template<typename T> void reclaim_later(T* data) { add_to_recalim_list(new data_to_reclaim(data)); }
  • 98. Реализация функции освобождения памяти 98 void delete_nodes_with_no_hazards() { // захватить текущий список data_to_reclaim* current = nodes_to_reclaim.exchange(nullptr); while (current) { data_to_reclaim* const next = current->next; if (!outstanding_hazard_pointers_for(current->data)) // если не опасно, удалить сейчас delete current; else // если опасно удалить потом add_to_reclaim_list(current); current = next; } }
  • 99. Реализация функции освобождения памяти 99 4321 nodes_to_reclaim
  • 100. Реализация функции освобождения памяти 100 nodes_to_reclaim 4321 current current = nodes_to_reclaim. exchange(nullptr);
  • 101. Реализация функции освобождения памяти 101 nodes_to_reclaim 432 current 1 1 add_to_reclaim_list(current);
  • 102. Реализация функции освобождения памяти 102 nodes_to_reclaim 432 current 1 delete current;
  • 103. Реализация функции освобождения памяти 103 nodes_to_reclaim 43 current 1 5 add_to_reclaim_list() при выполнении pop()
  • 104. Реализация функции освобождения памяти 104 nodes_to_reclaim 4 current 1 5 3 add_to_reclaim_list(current); 1
  • 105. Реализация функции освобождения памяти 105 nodes_to_reclaim 4 current 1 5 3
  • 106. Реализация функции освобождения памяти 106 nodes_to_reclaim current 1 5 3
  • 107. Недостатки указетелей опасности 107 1. Просмотр массива указателей опаности требует в худшем случае max_hazard_pointers атомарных переменных. 2. Атомарные операции могут работать медленнее эквивалентных обычных операций 3. При освобождении узла также требуется просмотреть список указателей опаности, т.е. max_hazard_pointers в худшем случае. Функция pop дорогостоящая. Решения?
  • 108. Недостатки указетелей опасности 108 1. Просмотр массива указателей опаности требует в худшем случае max_hazard_pointers атомарных переменных. 2. Атомарные операции могут работать медленнее эквивалентных обычных операций 3. При освобождении узла также требуется просмотреть список указателей опаности, т.е. max_hazard_pointers в худшем случае. Функция pop дорогостоящая. Решения? 1. Вместо просмотра max_hazard_pointers в каждом pop(), проверяем 2 * max_hazard_pointers через каждые max_hazard_pointers вызовов pop() и освобождаем не менее max_hazard_pointers. В среднем проверяем два узла при каждом вызове pop() и один освобождаем. 2. Каждый поток хранит собственный список освобождения в локальных данных потока. Это потребует выделения памяти под max_hazard_pointers2 узлов.
  • 109. Реализация стека, свободного от блокировок, с помощью умного указателя 109
  • 110. Реализация на основе атомарного умного указателя 110 ▪ Удалять узлы можно только при отсутствии обращения к ним из других потоков ▪ Если на узел нет ссылки, то его можно удаляь
  • 111. Реализация на основе атомарного умного указателя 111 ▪ Удалять узлы можно только при отсутствии обращения к ним из других потоков ▪ Если на узел нет ссылки, то его можно удаляь ▪ Умный указатель shared_ptr как раз решает эту задачу!
  • 112. Реализация на основе атомарного умного указателя 112 ▪ Удалять узлы можно только при отсутствии обращения к ним из других потоков ▪ Если на узел нет ссылки, то его можно удаляь ▪ Умный указатель shared_ptr как раз решает эту задачу! ... ▪ Но, к сожалению, атомарные операции c shared_ptr в большинстве реализаций не свободны от блокировок.
  • 113. Реализация на основе атомарного умного указателя 113 template <typename T> class lfstack { private: struct node { std::shared_ptr<T> data; std::shared_ptr<node> next; node(T const& _data): data(std::make_shared<T>(_data)) { } }; std::shared_ptr<node> head;
  • 114. Реализация на основе атомарного умного указателя 114 ... void push(T const& data) { std::shared_ptr<node> const new_node = std::make_shared<node>(data); new_node->next = head.load(); while (!std::atomic_compare_exchange_weak(&head, &nead_node->next, new_node)); } std::shared_ptr<T> pop() { std::shared_ptr<node> old_head = std::atomic_load(&head); while (old_head && !std::atomic_compare_exchange_weak(&head, &old_head, old_head->next)); return old_head ? old_head->data : std::shared_ptr<T>(); }
  • 115. Реализация стека, свободного от блокировок, с помощью подсчёта ссылок 115
  • 116. Двойной счётчик ссылок 116 counted_node_ptr node internal_count data next external_count ▪ При начале каждого чтения внешний счётчик увеличивается. ▪ При завершении чтения внутренний счётчик уменьшается. ▪ При удалении узла внутренний счетчик увеличивается на величину внешнего минус 1, а внешний отбрасывается. ▪ Если внутренний счётчик равен 0, узел можно удалять.
  • 118. Двойной счётчик ссылок 118 template<typename T> class lfstack { private: struct counted_node_ptr { int external_count; node* ptr; }; struct node { std::shared_ptr<T> data; std::atomic<int> internal_count; counted_node_ptr next; node(T const& _data): data(std::make_shared<T>(_data)), internal_count(0) {} }; std::atomic<counted_node_ptr> head;
  • 119. Двойной счётчик ссылок 119 ~lfstack() { while (pop()); } void push(T const& data) { counted_node_ptr new_node; new_node.ptr = new node(data); new_node.external_count = 1; new_node.ptr->next = head.load(); while (!head.compare_exchange_weak(new_node.ptr->next, new_node)); } };
  • 120. Двойной счётчик ссылок 120 template <typename T> class lfstack { private: // Увеличение внешнего счётчика void increase_head_count(counted_node_ptr& old_counter) { counted_node_ptr new_counter; do { new_counter = old_counter; ++new_counter.external_count; } while (!head.compare_exchange_strong(old_counter, new_counter)); old_counter.external_count = new_counter.external_count; }
  • 121. public: std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Двойной счётчик ссылок 121
  • 122. public: std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Двойной счётчик ссылок 122 1. Увеличить внешний счётчик 2. Разыменовать указатель 3. Проверить указатель на пустоту
  • 123. public: std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Двойной счётчик ссылок 123 Попытаться выполнить удаление узла 1. Если получилось, забрать данные 2. Прибавить внутренний счётчик к внешнему 3. Если счётчик стал равным 0, удалить узел 4. Вернуть результат (даже если счётчик не стал равным 0)
  • 124. public: std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Двойной счётчик ссылок 124 Если не получилось выполнить удаление узла (какой-то поток удалил узел раньше нас) 1. Уменьшить счётчик ссылок на 1. 2. Если другие потоки на узел не ссылаются, освободить память (убрать за тем потоком, который выполнил удаление)
  • 125. 0 0 Двойной счётчик ссылок 125 1 0 1 1 head 1 2 3 Сценарий 1: Поток А эксклюзивно удаляет узел. Другие потоки ему не мешают.
  • 126. 0 0 Двойной счётчик ссылок 126 2 1 1 head 1 2 3 Поток A: increase_head_count(old_head) node* const = old_head.ptr 0
  • 127. 0 0 0 Двойной счётчик ссылок 127 2 1 1 head 1 2 3 Поток A: head.compare_exchange(old_head, ptr->next)
  • 128. 0 0 0 Двойной счётчик ссылок 128 2 1 1 head 1 2 3 Поток A: count_increase = 2 - 2 = 0 internal_count = 0 + 0 = 0
  • 129. 0 0 0 Двойной счётчик ссылок 129 2 1 1 head 1 2 3 Поток A: delete ptr
  • 130. 0 0 0 Двойной счётчик ссылок 130 1 1 1 head 1 2 3 Сценарий 2: Потоки А и В одновременно удаляют узел. Потоку А удаётся выполнить удаление узла вперёд B. Поток В успевает выйти из pop до того, как А попробует освободить узел.
  • 131. 0 0 0 Двойной счётчик ссылок 131 2 1 1 head 1 2 3 Поток B: increase_head_count(old_head)
  • 132. 0 0 0 Двойной счётчик ссылок 132 3 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток A: increase_head_count(old_head) head.compare_exchange(...)
  • 133. -1 0 0 Двойной счётчик ссылок 133 3 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток B: internal_count.fetch_sub(1) Поток A: increase_head_count(old_head) head.compare_exchange(...)
  • 134. 0 0 0 Двойной счётчик ссылок 134 x 1 1 head 1 2 3 Поток A: count_increase = 3 - 2 = 1 internal_count = -1 + 1 = 0 Поток B: increase_head_count(old_head) Поток B: internal_count = 0 - 1 = -1 Поток A: increase_head_count(old_head) head.compare_exchange(...)
  • 135. 0 0 0 Двойной счётчик ссылок 135 x 1 1 head 1 2 3 Поток A: count_increase = 3 - 2 = 1 internal_count = -1 + 1 = 0 Поток B: increase_head_count(old_head) Поток B: internal_count = 0 - 1 = -1 Поток A: increase_head_count(old_head) head.compare_exchange(...) Поток A: delete ptr
  • 136. 0 0 0 Двойной счётчик ссылок 136 1 1 1 head 1 2 3 Сценарий 3: Потоки А и В одновременно удаляют узел. Потоку А удаётся выполнить удаление узла вперёд B. Поток В не успевает выйти из pop, когда А пытается освободить узел, и поэтому А узел не освобождает. Зато поток В, последним покидая узел, освобождает память из-под узла, удалённого А.
  • 137. 0 0 0 Двойной счётчик ссылок 137 3 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток A: increase_head_count(old_head) head.compare_exchange(...)
  • 138. 1 0 0 Двойной счётчик ссылок 138 x 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток A: increase_head_count(old_head) head.compare_exchange(...) Поток A: count_increase = 3 - 2 = 1 internal_count = 0 + 1 = 1 Поток A узел не освобождает
  • 139. 0 0 0 Двойной счётчик ссылок 139 x 1 1 head 1 2 3 Поток B: increase_head_count(old_head) Поток A: increase_head_count(old_head) head.compare_exchange(...) Поток A: count_increase = 3 - 2 = 1 internal_count = 0 + 1 = 1 Поток A узел не освобождает Поток B: internal_count = 1 - 1 = 0 delete ptr Узел освобождает поток B
  • 140. Двойной счётчик ссылок - проблема 140 template<typename T> class lfstack { private: struct counted_node_ptr { int external_count; node* ptr; }; struct node { std::shared_ptr<T> data; std::atomic<int> internal_count; counted_node_ptr next; node(T const& _data): data(std::make_shared<T>(_data)), internal_count(0) {} }; std::atomic<counted_node_ptr> head; Структура может не поддерживать выполнение атомарных операций без блокировок!
  • 141. Применение модели памяти С++ для стека, свободного от блокировок 141
  • 142. Применение модели памяти С++ 142 void push(T const& data) { counted_node_ptr new_node; new_node.ptr = new node(data); new_node.external_count = 1; new_node.ptr->next = head.load(std::memory_order_relaxed); while (!head.compare_exchange_weak(new_node.ptr->next, new_node)); void increase_head_count(counted_node_ptr& old_counter) { counted_node_ptr new_counter; do { new_counter = old_counter; ++new_counter.external_count; } while (!head.compare_exchange_strong(old_counter, new_counter)); old_counter.external_count = new_counter.external_count; }
  • 143. Применение модели памяти С++ 143 void push(T const& data) { counted_node_ptr new_node; new_node.ptr = new node(data); new_node.external_count = 1; new_node.ptr->next = head.load(std::memory_order_relaxed); while (!head.compare_exchange_weak(new_node.ptr->next, new_node)); void increase_head_count(counted_node_ptr& old_counter) { counted_node_ptr new_counter; do { new_counter = old_counter; ++new_counter.external_count; } while (!head.compare_exchange_strong(old_counter, new_counter)); old_counter.external_count = new_counter.external_count; } Подготовка данных Установка head (“флага”) Проверка head (“флага”) Работа с добавленным элементом
  • 144. Применение модели памяти С++ 144 void push(T const& data) { counted_node_ptr new_node; new_node.ptr = new node(data); new_node.external_count = 1; new_node.ptr->next = head.load(std::memory_order_relaxed); while (!head.compare_exchange_weak(new_node.ptr->next, new_node, std::memory_order_release, std::memory_order_relaxed)); void increase_head_count(counted_node_ptr& old_counter) { counted_node_ptr new_counter; do { new_counter = old_counter; ++new_counter.external_count; } while (!head.compare_exchange_strong(old_counter, std::memory_order_acquire, std::memory_order_relaxed, new_counter)); old_counter.external_count = new_counter.external_count; } Подготовка данных Установка head (“флага”) Работа с добавленным элементом Проверка head (“флага”)
  • 145. Применение модели памяти С++ 145 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Чтение указателя
  • 146. Применение модели памяти С++ 146 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Чтение указателя acquire не нужен, т.к. захват выполнен в increase_head_count
  • 147. Применение модели памяти С++ 147 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Извлечение данных Удаление должно выполняться после извлечения данных
  • 148. Применение модели памяти С++ 148 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase, std::memory_order_release) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1) == 1) delete ptr; } } Удаление должно выполняться после извлечения данных Извлечение данных
  • 149. Применение модели памяти С++ 149 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase, std::memory_order_release) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1, std::memory_order_acquire) == 1) delete ptr; } Удаление должно выполняться после извлечения данных Извлечение данных
  • 150. Применение модели памяти С++ 150 std::shared_ptr<T> pop() { counted_node_ptr old_head = head.load(); for (;;) { increase_head_count(old_head); node* const ptr = old_head.ptr; if (!ptr) return std::shared_ptr<T>(); if (head.compare_exchange_strong(old_head, ptr->next, std::memory_order_relaxed)) { std::shared_ptr<T> res; res.swap(ptr->data); int const count_increase = old_head.external_count - 2; if (ptr->internal_count.fetch_add(count_increase, std::memory_order_release) == -count_increase) delete ptr; return res; } else if (ptr->internal_count.fetch_sub(1, std::memory_order_relaxed) == 1) ptr->internal_count.load(std::memory_order_acquire); delete ptr; } Достаточно вставить операцию захвата- загрузки, чтобы удалить ptr после извлечения данных Извлечение данных fetch_sub входит в последовательность освобождений, поэтому “не мешает” acquire
  • 152. Схема устранения парных операций 152 Стек a b c head T3: pop() T1: pop() T2: push(d) Узкое место! ■ Загрузка кэш- памяти ■ Загрузка шины
  • 153. Схема с задержкой 153 Стек a b c head T1: push(x) trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node));
  • 154. Схема с задержкой 154 Стек a b c head T1: push(x) x trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node));
  • 155. Схема с задержкой 155 Стек a b c T1: trypush(x) trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node)); CAS failed
  • 156. Схема с задержкой 156 Стек a b c T1: trypush(x) trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node)); T1: backoff e.g. exponential backoff CAS failed
  • 157. Схема с задержкой 157 Стек a b c T1: trypush(x) trypush(x) { auto new_node = new node{x}; node_node->next = head.load(); return head.CAS(new_node->next, new_node)); T1: backoff T1: trypush(x) e.g. exponential backoff
  • 158. Схема устранения парных операций 158 Речной вокзал – Цветной проезд 1235 ■ Пассажиры “состязаются” за водителя маршрутки (contention), который обслуживает их последовательно ■ Водитель маршрутки – “узкое место” (bottleneck)
  • 159. Стек Схема устранения парных операций 159 a b c head Вспомогательный массив (elimination array) T3: pop() T1: pop() T2: push(d) T1: return(d) T2: ok
  • 160. Стек Схема устранения парных операций 160 a b c head Вспомогательный массив (elimination array) T3: pop() T1: pop() T2: push(d) T1: return(d) T2: ok exchanger
  • 161. Схема устранения парных операций 161 class exchanger { atomic<T*> slot{nullptr}; atomic<int> state{EMPTY}; public: auto exchanger(T* myitem, int waittime, T* result) { for (;;) { if (timeout(waittime)) return TIME_ELAPSED_CODE; auto curritem = slot.load(); auto currstate = state.load(); switch (currstate) {
  • 162. Схема устранения парных операций 162 case EMPTY: if (slot.CAS(curritem, myitem) && state.CAS(EMPTY, WAITING)) { while (time < waittime) { curritem = slot.load(); if (state == BUSY) { slot.store(nullptr); state.store(EMPTY); return curritem; } } if (slot.CAS(myitem, nullptr) && state.CAS(WAITING, EMPTY)) { return TIME_ELAPSED_CODE; } else { curritem = slot.load(); slot.store(nullptr); state.store(EMPTY); return curritem; } }
  • 163. Схема устранения парных операций 163 case WAITING: if slot.CAS(curritem, item) && state.CAS(WAITING, BUSY) return curritem; case BUSY: break; default: ... } } } }
  • 164. Схема устранения парных операций 164 case EMPTY: if (slot.CAS(curritem, myitem) && state.CAS(EMPTY, WAITING)) { while (time < waittime) { old_item = slot.load(); if (state == BUSY) { slot.store(nullptr); state.store(EMPTY); return old_item; } } if (slot.CAS(myitem, nullptr) && state.CAS(WAITING, EMPTY)) { return TIME_ELAPSED_CODE; } else { item = slot.load(); slot.store(nullptr); state.store(EMPTY); return item; } } Оба CAS должны выполниться атомарно – как транзакция, т.е. либо выполниться оба, либо не выполниться вообще! Оба CAS должны выполниться атомарно – как транзакция, т.е. либо выполниться оба, либо не выполниться вообще!
  • 165. class exchanger { struct content_t { T* slot{nullptr}; int state{EMPTY}; }; atomic<content_t> content; public: auto exchanger(T* myitem, int waittime, T* result) { for (;;) { if (timeout(waittime)) return TIME_ELAPSED_CODE; auto curritem = slot; auto currstate = state; switch (currstate) { Схема устранения парных операций 165 4 байта 8 байт 12 байт > машинного слова (8 байт) CAS выполнится не атомарно
  • 166. class exchanger { struct content_t { T* slot{nullptr}; int state{EMPTY}; }; atomic<content_t*> content; public: auto exchanger(T* myitem, int waittime, T* result) { for (;;) { if (timeout(waittime)) return TIME_ELAPSED_CODE; auto curritem = slot.load(); auto currstate = state.load(); switch (currstate) { Схема устранения парных операций 166 CAS атомарный!
  • 167. Схема устранения парных операций 167 case EMPTY: auto old_content = content; if (old_content->state == EMPTY) { auto new_content = new content{myitem, WAITING}; if (content.CAS(old_content, new_content) { while (time < waittime) { old_item = content->slot.load(); if (state == BUSY) { content->slot.store(nullptr); content->state.store(EMPTY); return old_item; } } delete old_content; } } // ... // Остальные пары CAS модифицируем аналогичным образом.
  • 168. Схема устранения парных операций 168 T1: item1 state EMPTY slot null curritem currstate slot.load(); state.load();
  • 169. slot null Схема устранения парных операций 169 T1: item1 state EMPTY CAS(old_content, new_content) curritem currstate null EMPTY old_content content item1 WAITING new_content
  • 170. Схема устранения парных операций 170 state WAITING T1: item1 slot item1 curritem currstate null EMPTY old_content
  • 171. Схема устранения парных операций 171 state WAITING T1: item1 slot item1 curritem currstate null EMPTY state.load() == BUSY?
  • 172. Схема устранения парных операций 172 state WAITING T1: item1 slot item1 curritem currstate slot.load(); state.load(); T2: item2 old_content
  • 173. Схема устранения парных операций 173 state WAITING T1: item1 slot item1 curritem currstate T2: item2 old_contentnew_content item1 WAITING item2 BUSY CAS(old_content, new_content)
  • 174. slot item2 Схема устранения парных операций 174 state BUSY T1: item1 T2: item2 curritem currstate old_content item1 WAITING return curritem
  • 175. Схема устранения парных операций 175 slot item2 T1: item1 T2: item2 curritem currstate null BUSY state.load() == BUSY? state BUSY YES!
  • 176. Схема устранения парных операций 176 state item2 T1: item1 T2: item2 curritem currstate item2 BUSY slot BUSY state.load() return curritem
  • 177. Стек Схема устранения парных операций 177 a b c head Вспомогательный массив (elimination array) T3: pop() T1: pop() T2: push(d) В худшем случае (если встречаются следуют не парно), вершина становится узким местом!
  • 178. Elimination Tree (дерево устранения) 178 2 5 3 4 0 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 Линеаризация linearization Согласованность относительно “состояния покоя” quiescent consistency Линеаризация – такое выполнение параллельных операций, при котором они соответствуют какому-то последовательному выполнению операций со стеком. Т.е. потокобезопасный стек (или другая структура) “ведёт себя” как обычный последовательный стек.
  • 179. Elimination Tree (дерево устранения) 179 2 5 3 4 0 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 Линеаризация linearization Согласованность относительно “состояния покоя” quiescent consistency Согласованность относительно “состояния покоя” – такое выполнение параллельных операций, при котором операции могут выполняться со стеком одновременно до момента, когда наступает “тишина”, т.е. нет текущих операций со структурой.
  • 180. Elimination Tree (дерево устранения) 180 2 5 3 4 0 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 Добавление 5 элементов 5 разными потоками T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5)
  • 181. Elimination Tree (дерево устранения) 181 2 5 3 4 0 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
  • 182. Elimination Tree (дерево устранения) 182 2 5 3 4 1 0 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
  • 183. Elimination Tree (дерево устранения) 183 5 3 4 0 0 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
  • 184. Elimination Tree (дерево устранения) 184 5 3 4 0 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
  • 185. Elimination Tree (дерево устранения) 185 5 1 4 1 0 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 2 3 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
  • 186. Elimination Tree (дерево устранения) 186 5 4 0 1 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 3 2 1 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
  • 187. Elimination Tree (дерево устранения) 187 5 1 0 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 3 2 1 4 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Нет состояния покоя!
  • 188. Elimination Tree (дерево устранения) 188 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: push(1) T2: push(2) T3: push(3) T4: push(4) T5: push(5) Есть состояние покоя!
  • 189. Elimination Tree (дерево устранения) 189 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: pop() T2: pop() 1 2 Нет состояния покоя!
  • 190. Elimination Tree (дерево устранения) 190 5 0 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: pop() T2: pop() 1 2 Нет состояния покоя!
  • 191. Elimination Tree (дерево устранения) 191 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: pop() T2: pop() 2 T1:return(5) Нет состояния покоя!
  • 192. Elimination Tree (дерево устранения) 192 5 1 1 1 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 T1: pop() T2: pop() T2:return(5)Есть состояние покоя!
  • 193. Elimination Tree (дерево устранения) 193 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 Корень дерева становится узким местом!
  • 194. Elimination Tree (дерево устранения) 194 5 1 1 0 lock-free stack lock-free stack lock-free stack lock-free stack путь 0 путь 1 1 2 3 4 Корень дерева становится узким местом! И узлы тоже!
  • 195. Elimination Tree с Elimination Arrays 195 5 1 1 1 2 3 4 Elimination array длины L T1:push(6) T2:pop() T5:push(7) 1 Elimination array длины L / 2 T3:pop() T4:pop() T5:ok T4: return(7) T3:return(5) T2:return(6) A:ok