Персистентные структуры данных и архитектура

Функциональные (персистентные) структуры данных и
их влияние на архитектуру приложений
Vadim Shalts
Vadim Shalts Функциональные структуры данных и архитектура 1 / 86

Персистентные структуры данных и их анализ
Оговорки

Сase классы
Scala:
case class Foo(myval: String)
Java:
final class Foo {
private final String myval;
public Foo(String initialValue) {
this.myval = initialValue;
}
public String getValue() {
return this.myval;
}
@Override
public boolean equals(Object o) {
// ....
}
@Override
public int hashCode() {
// ...
}
}

Сase классы
Scala:
case class Foo(myval: String)
Java:
final class Foo {
private final String myval;
public Foo(String initialValue) {
this.myval = initialValue;
}
public String getValue() {
return this.myval;
}
@Override
public boolean equals(Object o) {
// ....
}
@Override
public int hashCode() {
// ...
}
}
Возможные решения для Java
projectlombok.org
immutables.org
github.com/google/auto
www.jannocessor.org
Scala, Groovy, Clojure :)

Project valhalla. JEP 169: Value Objects

Важные свойства неизменяемых (immutable) объектов
Легко создавать, тестировать и использовать
Являются потокобезопасными
Хорошие кандидаты для кэширования
Поддерживают инвариант состояния
Исключения не могут “разломать” состояние

Класс будет неизменяемым, если верно следующее:
Класс объявляется как final
Все его поля являются final
Ссылка this не должна пропасть во время конструирования
Не содержат методов, которые могли бы изменить наблюдаемое
состояние объекта
Любые поля, содержащие ссылки на изменяемые объекты,
например массивы, совокупности или изменяемые классы,
например Date:
Являются приватными
Никогда не возвращаются и никаким другим образом не
становятся доступными вызывающим операторам
Являются единственными ссылками на те объекты, на которые они
ссылаются
Не изменяют после конструирования состояние объектов, на
которые они ссылаются

JLS. Семантика final полей
«A thread-safe immutable object is seen as immutable by all threads,
even if a data race is used to pass references to the immutable object
between threads»
JLS 17.5

Персистентные структуры данных и их анализ Необходимость (или в чём проблемы)
Data Processing in Exascale-class Computing Systems | April 27, 2011 | CRM3
Transistors
(thousands)
Single-thread
Performance
(SpecINT)
Frequency
(MHz)
Typical Power
(Watts)
Number of
Cores
Original data collected and plotted by M. Horowitz, F. Labonte, O. Shacham, K. Olukotun, L. Hammond and C. Batten
Dotted line extrapolations by C. Moore
35 YEARS OF MICROPROCESSOR TREND DATA

Закон Амдала. Рост производительности
вычислительной системы

Функциональное программирование
«In computer science, functional programming is a
programming paradigm, a style of building the structure and
elements of computer programs, that treats computation as
the evaluation of mathematical functions and avoids state
and mutable data.»
wikipedia

Простая нотация
f (x)
Что скрывается за простой нотацией?

Сложность f(x)
int[] func(int[] param);
Какова сложность, если параметр:
простой тип
простой объект
коллекция простых типов
...

Традиционный подход
class Order {
private ArrayList<Item> items = EMPTY_LIST;
private double total = 0.0;
void addItem(Item item) {
items.add(item);
total = calcTotal();
}
String createCheck() {
// use items and total ...
// ....
}
// ....
}

Традиционный подход
class Order {
synchronized void addItem(Item item) {
items.add(item);
}
synchronized String createCheck() {
// use items and total ...
// ....
}
// ....
}

Java Language and Virtual Machine Specifications (14.19)
If execution of the Block completes normally, then the
monitor is unlocked and the synchronized statement
completes normally.
If execution of the Block completes abruptly for any
reason, then the monitor is unlocked and the
synchronized statement completes abruptly for the
same reason.

Потеряна предсказуемость
Потеряна предсказуемость.
Что можно сделать?

Традиционный подход. Сохраняем состояние ошибки
class Order {
private boolean incorrectState = false;
if (incorrectState)
throw new IllegalStateException();
incorrectState = true;
items.add(item);
incorrectState = false;
}
// ....
}

Традиционный подход. Предотвращаем потерю
состояния
class Order {
private List<Item> items = EMPTY_LIST;
List<Item> newItems =
fastCopyAndAppend(items, item); // Как?
double newTotal = calcTotal(newItems);
items = newItems;
total = newTotal;
}
// ....
}

Еще лучше сделать класс Order неизменяемым
(immutable)!
«Classes should be immutable unless there’s a very good
reason to make them mutable.»
Joshua Bloch
«If an object cannot change state, then it can never
encounter conflicts or inconsistencies when multiple activities
attempt to change its state in incompatible ways. Programs
are much simpler to understand if existing objects are never
changed, but instead new ones are continually created during
the course of any computation.»
Doug Lea

Персистентные структуры данных и их анализ Определимся с терминологией
Термины
Неизменяемые (Immutable) структуры данных после
создания не могут быть изменены
Immutable структуры данных (обычно) могут быть скопированы с
изменениями для создания новой версии
Создание новой версии требует столько же памяти сколько
потребляет оригинал.
Персистентные (Persistent) структуры данных после
изменения содержат старую и новую версию данных
Persistent структуры данных являются Immutable в том смысле, что
создание новой версии не приводит к изменению старых версий
Создание новой версии может потребовать копирования данных из
оригинала. При этом старая и новые версии будут содержать
общие данные

Персистентные структуры данных и их анализ Примеры структур данных и их анализ
Обозначения
val x = X Y Z null
val x = X Y Z

Список. Начальный
val x1 = X Y Z

Список. Добавление
val x1 = X Y Z
val x2 = W

Список. Удаление
val x1 = X Y Z
val x2 = W
val x3 =

Как получить такие коллекции в Java?
<dependency>
<groupId>org.clojure</groupId>
<artifactId>clojure</artifactId>
<version>1.6.0</version>
</dependency>
Или
github.com/krukow/clj-ds
pcollections.org
www.functionaljava.org

Использование списка из Java
import com.github.krukow.clj_ds.*;
import java.util.LinkedList;
public class ClojureListTest {
public static void main(String[] args) {
PersistentList<String>
listCopy = Persistents.linkedList(new LinkedList());
PersistentList<String> list =
Persistents.linkedList("my", "list");
PersistentList<String> extended = list.plus("!!!");
PersistentList<String> cutted = extended.minus().minus();
System.out.println(list); // ("my" "list")
System.out.println(extended); // ("!!!" "my" "list")
System.out.println(cutted); // ("list")
}
}

FIFO очередь. Начальное состояние
val x1 =
Queue
enqueue list
dequeue list
5 4
1 2 3

FIFO очередь. Вставка
val x1 =
Queue
enqueue list
dequeue list
5 4
1 2 3
Queue
enqueue list
dequeue list
val x2 =
6

FIFO очередь. Удаление
val x1 =
Queue
enqueue list
dequeue list
5 4
1 2 3
Queue
enqueue list
dequeue list
val x2 =
6
Queue
enqueue list
dequeue list
val x3 =

FIFO очередь. Удаление
val x5 =
Queue
enqueue list
dequeue list
Queue
enqueue list
dequeue list
Queue
enqueue list
dequeue list
val x6 =
6 5 4
4 5 6

Использование очереди из Java
import com.github.krukow.clj_lang.PersistentQueue;
public class ClojureQueueTest {
PersistentQueue empty = PersistentQueue.EMPTY;
PersistentQueue queue = empty.cons("my").cons("queue");
PersistentQueue extended = queue.cons("!!!");
PersistentQueue cutted = extended.pop();
System.out.println(queue.seq()); // ("my" "queue")
System.out.println(extended.seq()); // ("my" "queue" "!!!")
System.out.println(cutted.seq()); // ("queue" "!!!")
}
}

Вектор (Vector)Bit-partitioned hash tries
... 00000 00000 00000 = 0
... 00000 00000 11111 = 31
... 00000 00001 00000 = 32
... 00000 00001 11111 = 63
Values
bits 0-4
bits 5-9
Root
0 1 31 32 33 63
0 1 ... ... 31 0 1 ... ... 31
0 1
v1

Вектор (Vector). Замена элемента
Values
bits 0-4
bits 5-9
Root
0 1 31 32 33 63 Z
0 1 ... ... 31 0 1 ... ... 31 0 1 ... ... 31
0 1 0 1
v1 v2

Вектор (Vector). Полная структура
Values
bits 0-4
bits 5-9
Root
0 1 31 32 33 63 64 65
0 1 ... ... 31 0 1 ... ... 31
0 1
0 1
v1

Вектор (Vector). Добавление
Values
bits 0-4
bits 5-9
Root
0 1 31 32 33 63 64 65 66
0 1 ... ... 31 0 1 ... ... 31
0 1 0 1 2
0 1
v1 v2

Vector. Пример
public class PersistentVectorTest {
PersistentVector<Integer> p = Persistents.vector(1, 2, 3);
PersistentVector<Integer> extended = p.plus(4).plus(5);
PersistentVector<Integer> updated = p.plusN(1, 22);
PersistentVector<Integer> cutted = p.minus();
System.out.println(p); // [1 2 3]
System.out.println(extended); // [1 2 3 4 5]
System.out.println(updated); // [1 22 3]
System.out.println(cutted); // [1 2]
}
}

Улучшаем скорость. Переходные (Transient) структуры
данных
Инсоляция в рамках одного потока
O 1 создание из персистентных структур данных
Общие данных с персистентным источником
O 1 создание персистентных структур данных, когда
редактирование завершено
Нельзя использовать после создания конечной персистентной
версии
Быстрые

Transient структуры данных. Пример
public class TransienVectorTest {
PersistentVector p = Persistents.vector(1, 2, 3);
TransientVector t = p.asTransient();
TransientVector tf = t.plus(4).plus(5); // efficient bulk modification
PersistentVector p2 = tf.persist();
System.out.println(p); // [1 2 3]
System.out.println(p2); // [1 2 3 4 5]
}
}

До создания Transient
Values
bits 0-4
bits 5-9
Root
0 1 31 32 33 63 64 65
0 1 ... ... 31 0 1 ... ... 31
0 1
0 1
v1

Transient Vector
Values
bits 0-4
bits 5-9
Root
0 1 31 32 33 63 64 65
0 1 ... ... 31 0 1 ... ... 31
0 1
0 1
v1 Transient

Transient Vector. Дешёвое добавление
Values
bits 0-4
bits 5-9
Root
0 1 31 32 33 63 64 65 66
0 1 ... ... 31 0 1 ... ... 31
0 1 0 1 ... ... 31
0 1
v1 Transient

Transient Vector. Дешёвое добавление
Values
bits 0-4
bits 5-9
Root
0 1 31 32 33 63 64 65 66 67
0 1 ... ... 31 0 1 ... ... 31
0 1 0 1 ... ... 31
0 1
v1 Transient

Возврат к Persistent Vector
Values
bits 0-4
bits 5-9
Root
0 1 31 32 33 63 64 65 66 67
0 1 ... ... 31 0 1 ... ... 31
0 1 0 1 2 3
0 1
v1 v2

RRB trees - Relaxed Radix Balanced Trees
“RRB-Trees: Efficient Immutable Vectors”,
EPFL-REPORT-169879, September, 2011:
http://infoscience.epfl.ch/record/169879/files/RMTrees.pdf
Дополнительные операции c O log N :
объединение коллекций (concatenation)
вставка в позицию (insert-at)
разделение на части (splits-at)
Реализации:
github.com/clojure/core.rrb-vector
github.com/TiarkRompf/rrbtrees

HashMap. Hash Array Mapped Trie (HAMT)
Bit-partitioned hash tries

HashMap. ДобавлениеPath Copying
int count 15
INode root
HashMap
int count 16
INode root
HashMap

Общие свойства
Версионность
Потоковая безопасность
Безопасность для итерирования
Уменьшение потребление памяти (для нескольких
копий)
Возможно увеличение потребления памяти (для
одной копии)
Простота использования
Производительность?

Теория за бортом
Детальный анализ производительности
Линзы (Functional lenses) - упрощают работу с
вложенными неизменяемыми структурами данных
Zipper - техника представления объединённых
структур данных. Ускоряет обработку персистентных
коллекций.
Ctrie - concurrent hash-trie

Влияние на архитектуру приложений Применение и примеры архитектуры
Архитектура

Undo/Redo. Команды
trait UndoableCommand {
def redo()
def undo()
}
var currentState = new StringBuilder()
class InsertCommand(pos: Int, value: String)
extends UndoableCommand {
def redo() = currentState.insert(pos, value)
def undo() = currentState.delete(pos, value.length)
}

Undo/Redo + шаблон Хранитель (Memento)
case class Memento(storedState: String)
var currentState = new StringBuilder()
val stateHistory = collection.mutable.Stack[Memento]()
class InsertCommand(pos: Int, value: String)
extends UndoableCommand {
def redo() = {
stateHistory.push( new Memento(currentState.mkString) )
currentState.insert(pos, value)
}
def undo() = {
currentState.clear()
currentState.append( stateHistory.pop.storedState )
}
}

Undo/Redo + Персистентные структуры данных
case class Article(name: String, price: Double)
case class Order(goods: Vector[Article], total: Double)
type State = Order
type UndoableCommand = State => State
var currentState = new State(Vector.empty, 0)
val stateHistory = collection.mutable.Stack[State]()
def executeCommand(command: UndoableCommand) = {
stateHistory.push( currentState )
currentState = command(currentState)
}
def undoCommand() =
currentState = stateHistory.pop()

Undo/Redo + Персистентные структуры данных
def buyArticle(article: Article): UndoableCommand =
(state: State) =>
new State(state.goods :+ article,
state.total + article.price)
// someCommand is function: State => State
val someCommand = buyArticle(new Article("iPad", 499))
executeCommand(someCommand)
println(state.total) // 499.0
undoCommand()
println(state.total) // 0.0

Блокировки. synchronized и ReentrantLock
Now t
Thread 1
Thread 2
Thread 3
Thread 4

Блокировки. ReentrantReadWriteLock
Now t
Thread 1
Thread 2
Thread 3
Thread 4

Блокировки. ReentrantReadWriteLock другой пример
Now t
Thread 1
Thread 2
Thread 3
Thread 4

Блокировки. StampedLock
Now t
Thread 1
Thread 2
Thread 3Thread 3
Thread 4

StampedLock. Лучше масштабируется
class Point {
private double x, y;
private final StampedLock sl = new StampedLock();
void move(double deltaX, double deltaY) { // an exclusively locked method
long stamp = sl.writeLock();
try {
x += deltaX;
y += deltaY;
} finally {
sl.unlockWrite(stamp);
}
}
// ...
}

StampedLock. Оптимистичные блокировки
class Point {
private double x, y;
private final StampedLock sl = new StampedLock();
double distanceFromOrigin() { // A read-only method
long stamp = sl.tryOptimisticRead();
double currentX = x, currentY = y;
if (!sl.validate(stamp)) {
stamp = sl.readLock();
try {
currentX = x;
currentY = y;
} finally {
sl.unlockRead(stamp);
}
}
return Math.sqrt(currentX * currentX + currentY * currentY);
}
// ...
}

Оптимистичные блокировки через StampedLock.
Проблемы и ограничения
«The use of optimistic mode for short read-only code
segments often reduces contention and improves throughput.
However, its use is inherently fragile. Optimistic read sections
should only read fields and hold them in local variables for
later use after validation. Fields read while in optimistic
mode may be wildly inconsistent, so usage applies only when
you are familiar enough with data representations to check
consistency and/or repeatedly invoke method validate()»
StampedLock. Java Documentation

Блокировки. StampedLock
Now t
Thread 1
Thread 2
Thread 3
Thread 4

Блокировки. Неизменяемые данные
t
Thread 1Thread 1
Thread 2Thread 2Thread 2
Thread 3Thread 3
Thread 4Thread 4

Блокировки. Много писателей
@volatile var currentState: State = initialState
val writersLock = new StampedLock
def readState() = {
val latestState = currentState
// ...
}
def updateState(command: Command) = {
val stamp = writersLock.writeLockInterruptibly()
try {
currentState = command(currentState)
} catch {
case AbortException => // ...
case ex: Throwable => // ...
} finally {
writersLock.unlockWrite(stamp)
}
}

Реализация с неизменяемым Point классом.
Общий код
trait ReferenceManager[T] {
def setState(state: T) = updateState(_ => state)
def getState(): T
def updateState(stateReplacer: T => T)
}

Общий код
class LockBasedReferenceManager[T] extends ReferenceManager[T] {
@volatile private var currentState: T = _
private val writersLock = new StampedLock
def getState() = currentState
def updateState(stateReplacer: T => T) = {
val stamp = writersLock.writeLockInterruptibly()
try {
currentState = stateReplacer(latestState)
} catch {
case ex: Throwable => // ...
} finally {
writersLock.unlockWrite(stamp)
}
}
}

Основная логика
case class Point(x: Double, y: Double) {
def distanceFromOrigin() = Math.sqrt(x * x + y * y)
def move(deltaX: Double, deltaY: Double) =
new Point(x + deltaX, y + deltaY)
}
class PointHolder(reference: ReferenceManager[Point]) {
reference.setState(Point(0, 0)) // Initial state
def distanceFromOrigin() =
reference.getState().distanceFromOrigin()
def move(deltaX: Double, deltaY: Double) =
reference.updateState { s => s.move(deltaX, deltaY) }
}

Блокировки. Оптимистичное обновление состояния
t
Thread 1Thread 1Thread 1Thread 1
Thread 2
Thread 3Thread 3
Thread 4Thread 4

Реализация через CAS. Сходство с MVCC
class OptimisticReferenceManager[T] extends ReferenceManager[T] {
val ref = new AtomicReference[T]
override def setState(state: T) = ref.set(state)
def getState() = ref.get
def updateState(stateReplacer: T => T) = {
var continue = true
while(continue) {
val latestState = getState()
val newState = stateReplacer(latestState)
if (ref.compareAndSet(latestState, newState))
continue = false
}
}
}

STM - Software transactional memory
Механизм управления параллелизмом аналогичный
механизму транзакций баз данных.
Используется для управления доступом к совместно
используемой памяти в параллельных вычислениях.
Альтернатива для синхронизации на основе
блокировок.

Clojure STM
Реализация основана на MVCC
Транзакции обеспечиваются изоляцией снимков
(Snapshot isolation)
Оптимистичный подход, рассчитываем на малую
вероятность коллизий на запись
Невозможны deadlocks, livelocks или гонки
Компонуемые операции

STM - полезен
Если паттерны доступа укладываются в:
частые чтения
достаточно редкие конфликты на запись
Почему?
Если транзакция не удалась, то нужно выполнить
откат
Нужно минимизировать пенальти за откат и
максимизировать параллелизм.

STM - Механика
Значения вычитанные внутри транзакции:
гарантированно целостные и отражают все
изменения
относятся к транзакциям, которые были завершены
до начала этой транзакции.
Изменения внутри транзакция:
локальны и видимы только внутри транзакции
становятся целиком видимыми после коммита

STM. Работа с ссылками
Слайд Neale Swinnerton (Clojure STM - What? Why? How?)

И снова менеджер
def as[T](value: AnyRef) = value.asInstanceOf[T]
class StmReferenceManager[T <: AnyRef]
extends ReferenceManager[T] {
private val ref = new Ref(null)
override def setState(state: T) = as[T]( ref.set(state) )
def getState() = as[T]( ref.deref() )
def updateState(stateReplacer: T => T) = ref.alter(new AFn() {
override def invoke(state: AnyRef): AnyRef = as[T]{
as[AnyRef]( stateReplacer( as[T](state) ) )
}
}, null)
}

Скрываем работу с транзакциями
def atomic[T](func: => T) = as[T] {
LockingTransaction.runInTransaction(new Callable[T] {
def call = func
})
}

Надёжный, дерзкий, губернский банк
case class History(change: Double, balanceBeforeChange: Double)
case class Account(balance: Double, history: Vector[History]) {
if (balance < 0 || history.length > 100)
throw new IllegalArgumentException("Not today")
if (history.length > 0 && history.last.change < 0.10)
throw new IllegalArgumentException("Suspicious behavior")
def changeBalanceBy(amount: Double) =
new Account(balance + amount, history :+ History(amount, balance))
}
class AccountHolder(reference: ReferenceManager[Account]) {
reference.setState(Account(0, Vector())) // Initial state
def balance = reference.getState().balance
def changeBalanceBy(amount: Double) =
reference.updateState ( s => s.changeBalanceBy(amount) )
}

Соединяем всё вместе
val (source, target) = atomic {
(new AccountHolder(new StmReferenceManager()),
new AccountHolder(new StmReferenceManager()))
}
try {
atomic {
target.changeBalanceBy(200)
println(target.balance) // 200.0
source.changeBalanceBy(-200) // IllegalStateException: Balance negative
}
} catch {
case ex: Throwable => ex.printStackTrace();
}
println(source.balance) // 0.0
println(target.balance) // 0.0
source.changeBalanceBy(200) // IllegalStateException: No transaction running

Транзакции. ACI(D) для персистентных структур
✓ Atomicity (Атомарность)
✓ Consistency (Согласованность)
✓ Isolation (Изолированность)
✗ Durability (Долговечность)

Влияние на архитектуру приложений Персистентные базы данных (Datomic)
Базы данных. Классика

Datomic. Общая идея

Datomic
Иммутабильная база данных с поддержкой ACID
Явным образом оперирует временем - время всегда частью
модели данных
Основная единица хранения данных - факт привязанный ко
времени (datom)
Datom - запись со списком атрибутов.
Атрибуты могут ссылаться на другие факты - отношения
Изменения модели происходит путём добавления новых
фактов

Datomic 2
Полагается на внешнюю реализацию хранилища данных
(RAM, DynamoDB, RDBMS, ...)
Изменения/транзакции отделены от чтения и проходят через
специальный компонент (transactor).
Возможно симулирование состояния базы без коммитов
Практически безграничное масштабирование запросов на
чтение и встроенная поддержка кеширования
Запросы могут использовать функции на Java/Clojure.

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

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

Персистентные структуры данных - итоги 2
Стратегия работы с блокировками стала гибкой и не связана
жестко с реализацией логики
Упрощается тестирование и разработка бизнес логики
(наиболее часто меняющийся код)
Повышается надёжность - случайные ошибки (исключения)
имеют меньше шансов навредить
Доступность старых фактов/данных упрощает разработку и
открывает новые возможности (datomic + blueprints)

Вопросы
Вопросы?

Персистентные структуры данных и архитектура

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (9)

En vedette

En vedette (20)

Similaire à Персистентные структуры данных и архитектура

Similaire à Персистентные структуры данных и архитектура (20)

Персистентные структуры данных и архитектура