Atomically { Delete Your Actors }

atomically {
delete your actors
}
John A. De Goes — @jdegoes
Wiem Zine Elabidine — @wiemzin

The Bank Heist The Hero Become a Hero!

12
def transfer(from: Account, to: Account,
amount: Amount): Unit = {
if (from.balance >= amount) {
from.balance -= amount
to.balance += amount
} else {
Thread.sleep(100)
transfer(from, to, amount)
}
}

13
} else {
Thread.sleep(100)
}
}

14
} else {
Thread.sleep(100)
}
}

15
} else {
Thread.sleep(100)
}
}

Double-Spend Exploits
$1 M
$1 M
$1 M $2 M

amount: Amount) = {
} else {
Thread.sleep(100)
}
}
amount: Amount) = {
} else {
Thread.sleep(100)
}
}
Thread 1 Thread 2
Race Condition Exploit

20
class Account {
var balance : Amount
var accountID : AccountID
var name : String
val opened : Instant
val status : AccountStatus
val tpe : AccountType
}

balance 200,000
accountID 2816157231
... ...
Main Memory
balance 200,000
... ...
Core 1 Cache
balance 200,000
... ...
Core 2 Cache

amount: Amount) = {
} else {
Thread.sleep(100)
}
}
amount: Amount) = {
} else {
Thread.sleep(100)
}
}
Thread 1 Thread 2
Stale Cache Exploit

4: getfield #2
7: invokevirtual #3
10: aload_2
11: invokevirtual #3
14: isub
15: invokestatic #4
18: dup_x1
19: putfield #2

amount: Amount) = {
} else {
Thread.sleep(100)
}
}
amount: Amount) = {
} else {
Thread.sleep(100)
}
}
Thread 1 Thread 2
Nonatomic Instruction Exploit

abstract class Account {
trait State {
@volatile var balance: BigDecimal = _
}
val state: State
def modify[A](f: State => A): A = this.synchronized {
val result = f(state)
this.notifyAll()
result
}
def await(): Unit = this.synchronized { this.wait() }
}

var loop = true
while (loop) {
from.modify { state =>
if (state.balance >= amount.value) {
state.balance -= amount.value
to.modify(state => state.balance += amount.value)
loop = false
}
else from.await()
}
}

transfer(from, to, amount) transfer(to, from, amount)
Thread 1 Thread 2
Deadlock Exploit

class Account extends Actor {
var balance = Amount.zero
var todos = List.empty[(ActorRef, Message)]
def receive = {
case Deposit(amount) =>
balance = balance + amount.value
sender ! Success(balance)
todos.foreach { case (s, m) => self ! m }
todos = Nil
case v @ Withdraw(amount) =>
if (balance >= amount.value) {
balance = balance - amount.value
sender ! Success(balance)
} else todos = (sender, v) :: todos
case Balance => sender ! Success(balance)
}
}

def transfer(from: ActorRef, to: ActorRef,
amount: Amount)(implicit garbage: Timeout): Unit =
(from ? Withdraw(amount)).flatMap { _ =>
to ? Deposit(amount)
}

for {
john <- johnAccount ? Balance
wiem <- wiemAccount ? Balance
} yield
if (wiem.value > john.value)
transfer(wiem, cafe, amount)
else transfer(john, cafe, amount)
$70
$99

for {
} yield
$70
$6,000,000 $99

$70
~$6m
for {
} yield
$10 $99

$70
-$60
for {
} yield
$99

46
def transfer(from : TRef[Account],
to : TRef[Account],
amount : Amount): UIO[Unit] =
atomically {
for {
balance <- from.get
_ <- check(balance >= amount)
_ <- from.update(_ - amount)
_ <- to.update(_ + amount)
} yield ()
}

47
to : TRef[Account],
atomically {
for {
balance <- from.get
} yield ()
}

48
to : TRef[Account],
atomically {
for {
balance <- from.get
} yield ()
}

49
to : TRef[Account],
atomically {
for {
balance <- from.get
} yield ()
}

50
to : TRef[Account],
atomically {
for {
balance <- from.get
} yield ()
}

51
to : TRef[Account],
atomically {
for {
balance <- from.get
} yield ()
}

STM: Software Transactional Memory
Provides the ability to atomically commit a series of
reads and writes to transactional memory when a set
of conditions is satisfied.
STM

STM
...Op 2Op 1 Op n
Final
State
Initial
State
commit
failure - rollback
retry - rollback
complete complete

STM
STM[E, A]
A transaction,
which models
reads & writes,
and can fail, retry,
or succeed.
TRef[A]
A transactional
reference, which
is read & written
inside STM
transactions.

STM[E, A]
Succeed with a
value of type A
Fail with an
error of type E
STM

TRef[A]
An immutable value
of type A
STM

trait TRef[A] {
val get: STM[Nothing, A]
def set(newValue: A): STM[Nothing, Unit]
def update(f: A => A): STM[Nothing, A]
def modify[B](f: A => (B, A)): STM[Nothing, B]
}
object TRef {
def make[A](a: A): STM[Nothing, TRef[A]]
}
TRef

trait STM[+E, +A] {
def commit: IO[E, A] = STM.atomically { this }
}
object STM {
def atomically[E, A](stm: STM[E, A]): IO[E, A]
}
STM - Commit

val hello: STM[Nothing, String] =
STM.succeed("Welcome to Scalar")
STM - Succeed

val sumBalances: STM[Nothing, Int] =
balance1.get.flatMap(a =>
balance2.get.map(b => a + b))
STM - map & flatMap

val sumBalances: STM[Nothing, Int] =
for {
a <- balance1.get
b <- balance2.get
} yield a + b
STM - map & flatMap

STM - Fail
def debit(sender: TRef[Amount], amount: Amount):
STM[String, Amount] =
for {
balance <- sender.update(_ - amount)
_ <- if (balance < 0) STM.fail("Insufficient funds")
else STM.succeed(())
} yield balance

def debitSuccess(sender: TRef[Amount],
amount: Amount): STM[Nothing, Boolean] =
debit(sender, amount).fold(_ => false, _ => true)
STM - Fold

def debitWithBalance(sender: TRef[Amount],
amount: Amount): STM[Nothing, Amount] =
debit(sender, amount)
.foldM(
_ => sender.get,
_ => sender.get)
STM - FoldM

def awaitTicket(tref: TRef[Option[Ticket]]): STM[Nothing, Ticket] =
for {
option <- tref.get
ticket <- option match {
case None => STM.retry
case Some(ticket) => STM.succeed(ticket)
}
} yield ticket
STM - Retry

def tripTickets: STM[Nothing, (Ticket, Ticket)] =
awaitTicket(toWarsaw) zip awaitTicket(toHome)
STM - Zip

def bid(price : Amount,
org : TRef[TravelCompany]): STM[Nothing, Ticket] =
for {
v <- org.get
_ <- STM.check(v.availTix.exists(_.price <= price))
ticket = findCheapest(v, price)
_ <- org.update(_.removeTix(ticket))
} yield ticket
STM - Check

STM - Filter
def bid(price : Amount,
org : TRef[TravelCompany]): STM[Nothing, Ticket] =
for {
v <- org.get.filter(_.availTix.exists(_.price <= price))
ticket = findCheapest(v, price)
_ <- org.update(_.removeTix(ticket))
} yield ticket

val trainOrAirplane: STM[Nothing, Ticket] =
bid(25.00, Railway) orElse bid(50.00, Airline)
STM - Choice

def checkIn(passengers: TRef[List[Person]]): STM[Nothing, Person] =
for {
head <- passengers.get.collect { case head :: tail => head }
_ <- passengers.update(_.drop(1))
} yield head
STM - Collect

STM
STM
STM
STM
Composable Easy to Reason About
to : TRef[Account],
atomically {
for {
balance <- from.get
} yield ()
}

Semaphore
Thread #2 holds
1 permit
Thread #1 holds
2 permits
Thread #3 waits
for 4 permits
Semaphore
6 permits

Semaphore
7 contributors
11 months+
301 lines of code

Semaphore
type Semaphore = TRef[Int]

Semaphore
def makeSemaphore(n: Int): UIO[Semaphore] =
TRef.make(n).commit

Semaphore
def acquire(semaphore: Semaphore, n: Int): UIO[Unit] =
(for {
value <- semaphore.get
_ <- STM.check(value >= n)
_ <- semaphore.set(value - n)
} yield ()).commit

Semaphore
def release(semaphore: Semaphore, n: Int): UIO[Unit] =
semaphore.update(_ + n).commit

Semaphore
1 author (you!)
10 minutes
8 lines of code
Your Semaphore using ZIO!

Promise
Unset Set
Wait Wait Continue Continue

Promise
7 contributors
11 months+
274 lines of code

Promise
type Promise[A] = TRef[Option[A]]

Promise
def makePromise[A]: UIO[Promise[A]] =
TRef.make(None).commit

Promise
def complete[A](promise: Promise[A], v: A): UIO[Boolean] =
(for {
value <- promise.get
change <- value match {
case Some(_) => STM.succeed(false)
case None => promise.set(Some(v)) *>
STM.succeed(true)
}
} yield change).commit

Promise
def await[A](promise: Promise[A]): UIO[A] =
promise.get.collect { case Some(a) => a }.commit

Promise
1 author (you!)
10 minutes
8 lines of code
Your Promise using ZIO!

Queue
Empty Queue
Capacity: 6
Full Queue
Capacity: 6
Offer
(Continue)
Take
(Wait)
Offer
(Wait)
Take
(Continue)

Queue
4 contributors
9 months+
487 lines of code

Queue
case class Queue[A](
capacity : Int,
tref : TRef[ScalaQueue[A]])

Queue
def makeQueue[A](capacity: Int): UIO[Queue[A]] =
TRef.make(ScalaQueue.empty[A]).commit
.map(Queue(capacity, _))

Queue
def offer[A](queue: Queue[A], a: A): UIO[Unit] =
(for {
q <- queue.tref.get
_ <- STM.check(q.length < queue.capacity)
_ <- queue.tref.update(_ enqueue a)
} yield ()).commit

Queue
def take[A](queue: Queue[A]): UIO[A] =
(for {
q <- queue.tref.get
a <- q.dequeueOption match {
case Some((a, as)) =>
queue.tref.set(as) *> STM.succeed(a)
case _ => STM.retry
}
} yield a).commit

Queue
1 author (you)
14 minutes
13 lines of code
Your Queue using ZIO!

THANK YOU!
LEARN MORE
github.com/scalaz/scalaz-zio
gitter.im/scalaz/scalaz-zio
FOLLOW US
@jdegoes @wiemzin

Atomically { Delete Your Actors }

More Related Content

What's hot (20)

Similar to Atomically { Delete Your Actors } (20)

More from John De Goes (20)

Recently uploaded (20)

Atomically { Delete Your Actors }