Конкурентные ассоциативные контейнеры

Concurrent mapS
C++ Russia 2015Maxim Khizhinsky

Concurrent mapsConcurrent maps
LIBCDS
Максим Хижинский, C++ Russia 2015
Операции:
● insert( key, value )
●
erase( key )
● find( key )
План:
● Concurrent maps изнутри
●
Управление памятью в lock-free структурах
●
Lock-free ordered list и concurrent maps на его основе
● Немного о деревьях

Hash tableHash table
LIBCDS
0 1 2 3 4 5 6
X X X
k1
k
k
k k
k
kk
k
k
2
3
4 5
6
7
8
9
T[7]
T[i] = std::hash( key ) % 7
Список
коллизий

Striped mapStriped map
LIBCDS
0 1 2 3 4 5 6
X X X
k1
k
k
k k
k
kk
k
k
2
3
4 5
6
7
8
9
T[7]

LIBCDS
0 1 2 3 4 5 6
X X X
k1
k
k
k k
k
kk
k
k
2
3
4 5
6
7
8
9
T[7]
Lock[7]

Striped map: rehashStriped map: rehash
LIBCDS
1. for ( i = 0; i < L; i++ )
Lock[i].lock();
2. N := 2 * N;
3. rehash T
4. for ( i := L - 1; i >=0; --i )
Lock[i].unlock();

L — const
Initial: L = N
Rehash: N := 2N
Striped map: rehashStriped map: rehash
LIBCDS
0 1 2 3 4 5 6
X X
k1
k
k
k k kkk
kk
2
3
4 5 67
89
T[8]
Lock[i] = std::hash( key ) % 4
Lock[4]
7
T[j] = std::hash( key ) % 8

LIBCDS
Lock[i] = std::hash( key ) % L
Lock[L]
α β γ δ
Tree search

Lock-free hash tableLock-free hash table
LIBCDS
0 1 2 3 4 5 6
X X X
k1
k
k
k k
k
kk
k
k
2
3
4 5
6
7
8
9
T[8]
Lock-free
список
коллизий
7
k
10

Lock-free ordered listLock-free ordered list
LIBCDS
Операции:
●
insert( node )
● erase( key )
●
find( key )
template <class T>
struct node {
std::atomic<node*> next_;
T data_;
};
H T52 8
Lock-free примитивы:
● atomic load/store
●
atomic compare-and-swap (CAS)

CAS — compare-and-swapCAS — compare-and-swap
LIBCDS
template <typename T>
bool CAS( T * pAtomic, T expected, T desired )
atomically {
if ( *pAtomic == expected ) {
*pAtomic = desired;
return true;
}
else
return false;
};

Lock-free list: insertLock-free list: insert
LIBCDS
H T52 8
3
H T52 8
3
3. prev->next_.CAS( next, new_node )
1. find insert position for key 3
2. new_node.next_.store( next )
H T52 8
prev next
new_node

Lock-free list: eraseLock-free list: erase
LIBCDS
1. find key 3
2. prev->next_.CAS( found, next )
H T52 8
prev
3
found
H T52 83
Проблема: параллельный insert
next

Lock-free list: insert/eraseLock-free list: insert/erase
LIBCDS
A: find key 3
H T52 8
prev
3
found
B: find insert pos for key 4
iprev inext
A: erase key 3
H T52 83
prev->next_.CAS( found, next )
next
B: insert key 4
H T52 83
4
iprev->next_.CAS( inext, new_item )
local vars

Marked pointerMarked pointer
LIBCDS
[ T.Harris, 2001 ]
Двухфазное удаление:
● Логическое удаление — помечаем элемент
●
Физическое удаление — исключаем элемент
В качестве метки используем младший бит указателя

Lock-free list: marked pointerLock-free list: marked pointer
LIBCDS
H T52 8
prev
3
found
iprev inext
nextA: erase
B: insert
A: Logical deletion - mark item found
H T52 83
found->next_.CAS( next, next | 1 )
B: iprev->next_.CAS( inext, new_item ) - failed!!!
A: Physical deletion - remove item found
H T52 83

Lock-free list: problemsLock-free list: problems
LIBCDS
H T52 8
prev
3
found
iprev inext
nextA: erase
B: insert
iprev->next_.CAS( inext, new_item )
local vars
Вдруг уже удалены?..

Lock-free list: problemsLock-free list: problems
LIBCDS
Проблемы:
●
Защита локальных данных — когда элемент можно
безопасно удалить?
●
ABA-проблема

ABA-проблемаABA-проблема
LIBCDS
52
prev
3
found next
Thread A: erase(3) Thread B
52 3
erase(3); erase(5)
2 3
insert(4)
Heap
new node(4) alloc
delete
42
preempted...
42
prev found next
5
addr(3) == addr(4)
prev->next_.CAS( found, next ) - success!!!
2 мусор

SMRSMR
LIBCDS
Проблемы:
● Защита локальных данных — когда элемент можно
безопасно удалить?
●
ABA-проблема
Решение:
Safe memory reclamation (SMR)
● Tagged pointers
●
Hazard Pointers
●
User-space RCU

Tagged pointersTagged pointers
LIBCDS
pointer tag
prev->next_.dwCAS( found, <next.ptr, prev->next_.tag + 1> )
template <class T>
struct tagged_ptr {
T * ptr;
uintptr_t tag;
};
Требует dwCAS — не везде есть
Решает только ABA-проблему
Освободить память нельзя,
нужен free-list
[ boost.lock-free ]
H T52 8
prev
3
found next

Tagged pointers: historyTagged pointers: history
LIBCDS
ABA-проблема характерна только для CAS
Архитектуры процессоров
LL/SC:
●
IBM PowerPC
● MIPS
●
ARM
➢ LL — load linked
➢ SC — store conditional
bool weak_CAS( T * ptr,
T expected, T desired )
{ T cur = LL( ptr );
return cur == expected
&& SC( ptr, desired );
}
Эмуляция LL/SC на CAS
— намного труднее
CAS:
●
x86, amd64
● Sparc
●
Itanium
С++11 — только CAS

Hazard pointersHazard pointers
LIBCDS
✔ Использует только атомарные чтение/запись
 Защищает только локальные ссылки
✔ Размер массива отложенных (готовых к
удалению) элементов ограничен сверху
 Перед работой с указателем его следует
объявить как hazard
решает ABA-проблему
Физическое удаление элементов

LIBCDS
H T52 8
prev
3
found next
erase( Key k ) {
hp_guard h1 = get_guard();
hp_guard h2 = get_guard();
retry:
node * prev = Head;
do {
node * found = h2.protect( prev->next_);
if ( found->key == k )
if (prev->next_.CAS( found, found->next_)) {
hp_retire( found );
return true;
}
else
goto retry;
h1 = h2;
prev = found;
} while ( found->key < k );
return false;
}
Распределяем HP (TLS)
Защищаем элемент
Удаляем элемент

LIBCDS
P – thread count
Thread 0
Thread HP Manager
0
1
…
K - 1
HP[K]
0
1
2
…
R - 1
Retired[R]
Hazard Pointer Singleton
Thread
1
Thread
P - 1
K = 4 R = 2 KP
<K,P, R> : R > K * P

Hazard PointersHazard Pointers
LIBCDS
Объявление Hazard Pointer'а – защита локальной ссылки
class hp_guard {
void * hp;
// ...
};
T * hp_guard::protect(
std::atomic<T*>& what) {
T * t;
do {
hp = t = what.load(std::memory_order_relaxed);
} while (t != what.load(std::memory_order_acquire));
return t;
}
0
1
…
K - 1
HP[K]

Hazard PointersHazard Pointers
LIBCDS
Удаление элемента
void hp_retire( T * what ) {
push what to current_thread.Retired array
if ( current_thread.Retired is full )
hp.Scan( current_thread );
}
void hp::Scan() {
void * guarded[K*P] = union HP[K] for all P thread;
foreach ( p in current_thread.Retired[R] )
if ( p not in guarded[] )
delete p;
}
<K,P, R> : R > K * P
0
1
2
…
R - 1
Retired[R]
0
1
…
K - 1
HP[K]

User-space Read-Copy UpdateUser-space Read-Copy Update
LIBCDS
✔ RCU — метод синхронизации:
RCU.lock() / RCU.unlock()
✔ Разработан для почти-read-only данных (map, set)
✔ Очень легкие read-side lock
✔ Удаление элемента — ожидание окончания эпохи
решает ABA-проблему
Физическое удаление элементов
RCU.lock(): ничего не блокирует
Объявляет, что поток входит в
текущую RCU-эпоху

User-space RCUUser-space RCU
LIBCDS
Map.find( ... );
Set.insert( ... );
Map.find( ... );
Map.erase( ... )...
Thread 1
Set.find( ... );
Map.insert( ... );
Set.find( ... );
Set.insert( ... );
Thread N
Эпоха 1
RCU.sync() - ждем, пока все потоки покинут эпоху 1
Set.find( ... );
Map.insert( ... );
Set.find( ... );
Set.insert( ... );
... Map.erase;
Map.find( ... );
Set.insert( ... );
Map.find( ... );
++Эпоха
Эпоха 2

Lock-free hash tableLock-free hash table
LIBCDS
0 1 2 3 4 5 6
X X X
k1
k
k
k k
k
kk
k
k
2
3
4 5
6
7
8
9
T[8]
Lock-free
cписок:
HP/RCU
+ marked
pointers
7
k
10
Hash table + Lock-free ordered list
No rehashing

Split-ordered listSplit-ordered list
LIBCDS
Rehashing приводит к перераспределению
элементов между buckets
0 1
2
4
6
3
5
0 1 2 3
2 354
6
Key % 2 Key % 4
Вместо того, чтобы перемещать
элементы между buckets, будем
перемещать buckets между
элементами
[ Nir Shavit, 2003 ]

LIBCDS
0 8 2 1 9 13
T[0]
T[1]
k iSentinel node Regular node
N = 2 size() = 4
Load factor L: size() / N ≤ L
Если L = 2, то вставка нового элемента приводит к увеличению
hash table
Hash table
Lock-free ordered list

LIBCDS
0 8 2 1 9 13
T[0]
T[1]
N = 4
Hash table
Insert
T[2] = null
T[3] = null
10
T[i]: i = hash % N
10 % 4 = 2 — T[2] не инициализирован
Нужно вставить новый sentinel node
Куда вставлять?..
2
10

LIBCDS
0 8 2 1 9 13
T[0]
T[1]
N = 4
Hash table
Insert
T[2] = null
T[3] = null
10
2
Split bucket
Bucket = hash % 2
m + 1
Parent_bucket Parent_bucket + 2
m
= 10 % 4
10 % 4, m = 12
Parent_bucket = 0

LIBCDS
0 8 2 1 9 13
T[0]
T[1]
N = 4
Hash table
Insert
T[2] = null
T[3] = null
10
2
Split bucket
Bucket = hash % 2
m + 1
m
= 10 % 4
10 % 4, m = 12
Parent_bucket = 0
0000 1000 0010 0001 1001 1101
0010
Арифметика
по модулю
2
p

LIBCDS
0 8 2 1 9 13
T[0]
T[1]
N = 4
Hash table
Insert
T[2] = null
T[3] = null
10
2
Split bucket
Bucket = hash % 2
m + 1
m
= 10 % 4
10 % 4, m = 12
Parent_bucket = 0
0000 0001 0100 1000 1001 1011
0100
Инвертируем
порядок бит!
Отсортирован!

LIBCDS
template <class Key, class T>
struct split_list_node
{
Key key;
uint key_hash; // = std::hash(key)
uint shah; // = invert( key_hash ) - для сортировки
T data;
};

Уже есть!!!
parent_bucket
LIBCDS
0 8 2 1 9 13
T[0]
T[1]
Hash table
Insert
T[2] = null
T[3] = null
2
0000 0 0001 1 0100 1 1000 0 1001 1 1011 1
Надо различать sentinel и
regular node.
msb(key_hash) = 1 — regular → lsb( shah ) = 1
msb(key_hash) = 0 — sentinel →lsb( shah ) = 0
0100 0

parent_bucket
LIBCDS
0 8 2 1 9 13
T[0]
T[1]
Hash table
Insert
T[2]
T[3] = null
2
0000 0 0001 1 0100 1 1000 0 1001 1 1011 1
0100 0
2

LIBCDS
0 8 2 1 9 13
T[0]
T[1]
Hash table
Insert
T[2]
T[3] = null
0000 0 0001 1 0100 1 1000 0 1001 1 1011 10100 0
2
10
0101 1
0101 1
10
Bucket = 10 % 4 = 2

LIBCDS
Удаление — как из обычного lock-free списка
Sentinel node никогда не удаляются
1: Logical deletion - mark item
52 83
found->next_.CAS( next, next | 1 )
2: Physical deletion - unlink item
52 83

LIBCDS
T[0]
T[1]
. . . .
T[N-1]
T[N]
seg0
seg1
. . . .
null
Segment[M]
T[0]
T[1]
. . . .
T[N-1]
T[N]
T[0]
T[1]
. . . .
T[N-1]
T[N]
Статический
массив
сегментов
Сегментная организация hash table
Сегмент – старшие биты хеша
T[i] – младшие N бит хеша
Динамическое расширение

LIBCDS
X10 15 23 34 5542
Complexity O(N)
Что ещё можно сделать из lock-free ordered list?
✔ Простой hash map — без расширения
✔ Split-ordered list
find(34)

LIBCDS
X10 15 23 34 5542
Complexity O(N/2)
X

LIBCDS
X10 15 23 34 5542
Complexity O(N/4)
X
X

Skip listSkip list
LIBCDS
X
X
X
X
X
X
X
X10 15 23 34 5542
Head Tail
[ W.Pugh, 1990 ]

Skip listSkip list
LIBCDS
X
X
X
X
X
X
X
X10 15 23 34 5542
23
Tower
h = 3
Вероятностная структура данных:
P[ h == 1 ] = 1/2
P[ h == k ] = 1/2
k
, 0 < k < 32
h = lsb( rand() )
O(log(N))

Skip list: insertSkip list: insert
LIBCDS
X
X
X
X
X
X
X
X10 15 23 34 5542
Head Tail
Поиск позиции: формируем массив prev[]

LIBCDS
X
X
X
X
X
X
X
X10 15 23 34 5542
Head Tail
Связываем в список на уровне 0

LIBCDS
X
X
X
X
X
X
X
X10 15 23 34 5542
Head Tail
Связываем в список на уровне 1, 2, …
снизу вверх

Skip list: eraseSkip list: erase
LIBCDS
X
X
X
X
X
X
X
X10 15 23 34 5542
Head Tail
Двухфазное: 1. Logical deletion — mark
сверху вниз

Skip list: eraseSkip list: erase
LIBCDS
X
X
X
X
X
X
X
X10 15 23 34 5542
Head Tail
Фаза 2. Physical deletion — unlink
сверху вниз

Skip listSkip list
LIBCDS
Особенности:
Отсортированный контейнер
get_max(), get_min()
Можно использовать как priority queue
Сложность поиска: O(log N)
Hazard Pointer: для max height = 32 требует
min 64 hazard pointer'ов
Требует эффективной реализации tower

Binary search treeBinary search tree
LIBCDS
«Прямой» lock-free подход приводит к очень сложным
алгоритмам.
Non-blocking подход дает менее сложные алгоритмы
Routing nodes - только ключи
Leaf nodes - данные
Leaf-oriented tree
Основная цель: lock-free / wait-free find()

LIBCDS
10
5 20
3015
27 45
Thread A: erase(15)
Thread B: erase(27)
10
5 20
3015
27 45
Error!!!
Достижимый
узел
Конкурентное CAS-based удаление
CAS
CAS
Должно быть

LIBCDS
10
5 20
3015
27 45
Thread A: erase(27)
Thread B: insert(29)
10
5 20
3015
27
45
Error!!!
Недостижимые
узлы
Конкурентное CAS-based удаление + вставка
CAS
29
29

LIBCDS
Routing node
Left child Right child
State
Key
IFlag DFlag
MarkClean (default)

LIBCDS
10
5 20
3015
27 45
Insert 29
1 30.State.CAS( Clean, IFlag)
10
5 20
3015
27
4527
29
2 Insert
30.left.CAS( )27 27
10
5 20
3015
27
4527
29
3 30.State.CAS( IFlag, Clean )

LIBCDS
10
5 20
3015
27 45
Erase 27
1 20.State.CAS( Clean, DFlag)
10
5 20
3015
27 45
2 Mark 30
30.State.CAS(
Clean, Mark)
10
5 20
3015
27 45
3 Delete
20.right.CAS( )30 45
10
5 20
3015
27 45
4 20.State.CAS(
Dflag, Clean)

Конкуренция
LIBCDS
10
5 20
3015
27 45
Thread A: erase(15)
Thread B: erase(27)
Конкурентное CAS-based удаление
A
BA
10
5 20
3015
27 45
A
A
Выиграл A
10
5 20
3015
27 45
A
Выиграл B
B
B
B: повтор
поиска 27
A: unflag +
повтор
поиска 15

LIBCDS
find() - lock-free
insert(), erase() - non-blocked
Характеристики:
Сложность:
O(log(N)) — для случайных ключей
O(N) — в худшем случае

libcdslibcds
LIBCDS
https://github.com/khizmax/libcds
Все это, а также многое другое, можно найти здесь:

PerformancePerformance
LIBCDS
Intel Dual Xeon X5670 2.93 GHz 12 cores 24 threads / 24 GB RAM

Questions?..Questions?..

Concurrent mapsConcurrent maps
Спасибо за внимание!
libcds.dev@gmail.com
https://github.com/khizmax/libcds

Конкурентные ассоциативные контейнеры

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (20)

Similar to Конкурентные ассоциативные контейнеры

Similar to Конкурентные ассоциативные контейнеры (20)

More from Platonov Sergey

More from Platonov Sergey (20)

Конкурентные ассоциативные контейнеры