blob: f63de76c4a8277241a816860197fc5e7107f5c2c (
plain) (
blame)
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
|
package stm
// A Tx represents an atomic transaction.
type Tx struct {
reads map[*Var]uint64
writes map[*Var]interface{}
}
// verify checks that none of the logged values have changed since the
// transaction began.
// TODO: is pointer equality good enough? probably not, without immutable data
func (tx *Tx) verify() bool {
for v, version := range tx.reads {
v.mu.Lock()
changed := v.version != version
v.mu.Unlock()
if changed {
return false
}
}
return true
}
// commit writes the values in the transaction log to their respective Vars.
func (tx *Tx) commit() {
for v, val := range tx.writes {
v.mu.Lock()
v.val = val
v.version++
v.mu.Unlock()
}
}
// wait blocks until another transaction modifies any of the Vars read by tx.
func (tx *Tx) wait() {
globalCond.L.Lock()
for tx.verify() {
globalCond.Wait()
}
globalCond.L.Unlock()
}
// Get returns the value of v as of the start of the transaction.
func (tx *Tx) Get(v *Var) interface{} {
// If we previously wrote to v, it will be in the write log.
if val, ok := tx.writes[v]; ok {
return val
}
v.mu.Lock()
defer v.mu.Unlock()
// If we haven't previously read v, record its version
if _, ok := tx.reads[v]; !ok {
tx.reads[v] = v.version
}
return v.val
}
// Set sets the value of a Var for the lifetime of the transaction.
func (tx *Tx) Set(v *Var, val interface{}) {
tx.writes[v] = val
}
// Retry aborts the transaction and retries it when a Var changes.
func (tx *Tx) Retry() {
panic(Retry)
}
// Assert is a helper function that retries a transaction if the condition is
// not satisfied.
func (tx *Tx) Assert(p bool) {
if !p {
tx.Retry()
}
}
|
