// Calls rand 4 times
func (b *Big) MakeOne(w int, local_seed *uint32, txn *ddtxn.Query) {
rnd := uint64(ddtxn.RandN(local_seed, uint32(b.ni)))
txn.U1 = rnd
txn.U2 = (rnd * 2) % b.ni
txn.U3 = (rnd * 3) % b.ni
txn.U4 = (rnd * 4) % b.ni
txn.U5 = (rnd * 5) % b.ni
txn.U6 = (rnd * 6) % b.ni
txn.U7 = (rnd) % uint64(b.np)
if *incr {
txn.TXN = ddtxn.BIG_INCR
} else {
txn.TXN = ddtxn.BIG_RW
}
}
// Calls rand 4 times
func (b *Buy) MakeOne(w int, local_seed *uint32, sp uint32, txn *ddtxn.Query) {
var bidder int
var product int
if *partition {
rnd := ddtxn.RandN(local_seed, sp/8)
lb := int(rnd)
bidder = lb + w*int(sp)
} else {
bidder = int(ddtxn.RandN(local_seed, uint32(b.nbidders)))
}
x := int(ddtxn.RandN(local_seed, 100))
if b.zipfd > 0 {
product = int(b.z[w].Uint64())
} else {
product = int(ddtxn.RandN(local_seed, uint32(b.nproducts)))
}
if x < b.read_rate {
if x > b.ncontended_rate {
// Contended read; use Zipfian distribution or np
txn.K1 = ddtxn.UserKey(uint64(bidder))
txn.K2 = ddtxn.ProductKey(product)
} else {
// (Hopefully) uncontended read. Random product.
product = int(ddtxn.RandN(local_seed, uint32(b.nbidders)))
txn.K1 = ddtxn.UserKey(uint64(bidder))
txn.K2 = ddtxn.ProductKey(product)
}
txn.TXN = ddtxn.D_READ_TWO
} else {
amt := int32(ddtxn.RandN(local_seed, 10))
txn.K1 = ddtxn.UserKey(uint64(bidder))
txn.K2 = ddtxn.ProductKey(product)
txn.A = amt
txn.TXN = ddtxn.D_BUY
}
}
func (b *Rubis) MakeBid(w int, local_seed *uint32, txn *ddtxn.Query) {
txn.TXN = ddtxn.RUBIS_BID
bidder := b.users[0]
var x uint32
if b.zipfd > 0 {
x = uint32(b.zip[w].Uint64())
} else {
x = ddtxn.RandN(local_seed, uint32(b.nproducts))
}
if x >= uint32(len(b.products)) {
log.Fatalf("Huh %v %v %v\n", x, len(b.products), b.nproducts)
}
product := b.products[x]
txn.U1 = uint64(bidder)
if product == 0 {
log.Fatalf("store bid ID 0? %v %v", x, b.products[x])
}
txn.U2 = uint64(product)
txn.U3 = uint64(time.Now().UnixNano())
}
func (b *Rubis) MakeOne(w int, local_seed *uint32, txn *ddtxn.Query) {
x := float64(ddtxn.RandN(local_seed, 100))
if x < b.rates[0] {
txn.TXN = ddtxn.RUBIS_BID
//bidder := b.users[int(ddtxn.RandN(local_seed, b.sp))+w*int(b.sp)]
bidder := b.users[int(ddtxn.RandN(local_seed, uint32(b.nbidders)))]
//product := b.products[ddtxn.RandN(local_seed, uint32(b.nproducts))]
var x uint32
if b.zipfd > 0 {
x = uint32(b.zip[w].Uint64())
} else {
x = ddtxn.RandN(local_seed, uint32(b.nproducts))
}
product := b.products[x]
txn.U1 = uint64(bidder)
if product == 0 {
log.Fatalf("store bid ID 0? %v %v", x, b.products[x])
}
txn.U2 = uint64(product)
//txn.U3 = uint64(ddtxn.RandN(local_seed, 10))
txn.U3 = uint64(time.Now().UnixNano()) & 0x000efff
} else if x < b.rates[1] {
txn.TXN = ddtxn.RUBIS_VIEWBIDHIST
x := ddtxn.RandN(local_seed, uint32(b.nproducts))
product := b.products[x]
if product == 0 {
log.Fatalf("view bid hist ID 0? %v %v", x, b.products[x])
}
txn.U1 = uint64(product)
} else if x < b.rates[2] {
txn.TXN = ddtxn.RUBIS_BUYNOW
//bidder := b.users[int(ddtxn.RandN(local_seed, b.sp))+w*int(b.sp)]
bidder := b.users[int(ddtxn.RandN(local_seed, uint32(b.nbidders)))]
x := ddtxn.RandN(local_seed, uint32(b.nproducts))
product := b.products[x]
if product == 0 {
log.Fatalf("buy now ID 0? %v %v", x, b.products[x])
}
txn.U1 = uint64(bidder)
txn.U2 = uint64(product)
txn.A = int32(ddtxn.RandN(local_seed, 10))
} else if x < b.rates[3] {
txn.TXN = ddtxn.RUBIS_COMMENT
// u1 := b.users[int(ddtxn.RandN(local_seed, b.sp))+w*int(b.sp)]
u1 := b.users[int(ddtxn.RandN(local_seed, uint32(b.nbidders)))]
// u2 := b.users[int(ddtxn.RandN(local_seed, b.sp))+w*int(b.sp)]
u2 := b.users[int(ddtxn.RandN(local_seed, uint32(b.nbidders)))]
x := ddtxn.RandN(local_seed, uint32(b.nproducts))
product := b.products[x]
if product == 0 {
log.Fatalf("comment ID 0? %v %v", x, b.products[x])
}
txn.U1 = uint64(u1)
txn.U2 = uint64(u2)
txn.U3 = uint64(product)
txn.S1 = "xxxx"
txn.U4 = 1
} else if x < b.rates[4] {
txn.TXN = ddtxn.RUBIS_NEWITEM
// bidder := b.users[int(ddtxn.RandN(local_seed, b.sp))+w*int(b.sp)]
bidder := b.users[int(ddtxn.RandN(local_seed, uint32(b.nbidders)))]
amt := uint64(ddtxn.RandN(local_seed, 10))
txn.U1 = uint64(bidder)
txn.S1 = "yyyy"
txn.S2 = "zzzz"
txn.U2 = amt
txn.U3 = amt
txn.U4 = amt
txn.U5 = 1
txn.U6 = 1
txn.U7 = uint64(ddtxn.RandN(local_seed, uint32(ddtxn.NUM_CATEGORIES)))
} else if x < b.rates[5] {
txn.TXN = ddtxn.RUBIS_PUTBID
x := ddtxn.RandN(local_seed, uint32(b.nproducts))
product := b.products[x]
if product == 0 {
log.Fatalf("put bid ID 0? %v %v", x, b.products[x])
}
txn.U1 = uint64(product)
} else if x < b.rates[6] {
txn.TXN = ddtxn.RUBIS_PUTCOMMENT
x := ddtxn.RandN(local_seed, uint32(b.nproducts))
product := b.products[x]
if product == 0 {
log.Fatalf("put comment ID 0? %v %v", x, b.products[x])
}
// bidder := b.users[int(ddtxn.RandN(local_seed, b.sp))+w*int(b.sp)]
bidder := b.users[int(ddtxn.RandN(local_seed, uint32(b.nbidders)))]
txn.U1 = uint64(bidder)
txn.U2 = uint64(product)
} else if x < b.rates[7] {
txn.TXN = ddtxn.RUBIS_REGISTER
txn.U1 = uint64(ddtxn.RandN(local_seed, uint32(ddtxn.NUM_REGIONS)))
txn.U2 = uint64(ddtxn.RandN(local_seed, 1000000000))
} else if x < b.rates[8] {
txn.TXN = ddtxn.RUBIS_SEARCHCAT
txn.U1 = uint64(ddtxn.RandN(local_seed, uint32(ddtxn.NUM_CATEGORIES)))
txn.U2 = 5
} else if x < b.rates[9] {
txn.TXN = ddtxn.RUBIS_SEARCHREG
txn.U1 = uint64(ddtxn.RandN(local_seed, uint32(ddtxn.NUM_REGIONS)))
txn.U2 = uint64(ddtxn.RandN(local_seed, uint32(ddtxn.NUM_CATEGORIES)))
txn.U3 = 5
} else if x < b.rates[10] {
txn.TXN = ddtxn.RUBIS_VIEW
x := ddtxn.RandN(local_seed, uint32(b.nproducts))
product := b.products[x]
if product == 0 {
log.Fatalf("view ID 0? %v %v", x, b.products[x])
}
txn.U1 = uint64(product)
} else if x < b.rates[11] {
txn.TXN = ddtxn.RUBIS_VIEWUSER
// bidder := b.users[int(ddtxn.RandN(local_seed, b.sp))+w*int(b.sp)]
bidder := b.users[int(ddtxn.RandN(local_seed, uint32(b.nbidders)))]
txn.U1 = uint64(bidder)
} else {
log.Fatalf("No such transaction\n")
}
}
func main() {
flag.Parse()
runtime.GOMAXPROCS(*nprocs)
if *clientGoRoutines == 0 {
*clientGoRoutines = *nprocs
}
if *nworkers == 0 {
*nworkers = *nprocs
}
if *prob == -1 && *ZipfDist < 0 {
log.Fatalf("Zipf distribution must be positive")
}
if *ZipfDist >= 0 && *prob > -1 {
log.Fatalf("Set contention to -1 to use Zipf distribution of keys")
}
s := ddtxn.NewStore()
sp := uint32(*nbidders / *nworkers)
for i := 0; i < *nbidders; i++ {
k := ddtxn.ProductKey(i)
s.CreateKey(k, int32(0), ddtxn.SUM)
}
dlog.Printf("Done with Populate")
coord := ddtxn.NewCoordinator(*nworkers, s)
if *ddtxn.CountKeys {
for i := 0; i < *nworkers; i++ {
w := coord.Workers[i]
w.NKeyAccesses = make([]int64, *nbidders)
}
}
dlog.Printf("Done initializing single\n")
p := prof.StartProfile()
start := time.Now()
var wg sync.WaitGroup
pkey := int(sp - 1)
dlog.Printf("Partition size: %v; Contended key %v\n", sp/2, pkey)
gave_up := make([]int64, *clientGoRoutines)
goZipf := make([]*ddtxn.Zipf, *clientGoRoutines)
if *prob == -1 && *ZipfDist >= 0 {
for i := 0; i < *clientGoRoutines; i++ {
rnd := rand.New(rand.NewSource(int64(i * 12467)))
goZipf[i] = ddtxn.NewZipf(rnd, *ZipfDist, 1, uint64(*nbidders)-1)
if goZipf[i] == nil {
panic("nil zipf")
}
}
}
for i := 0; i < *clientGoRoutines; i++ {
wg.Add(1)
go func(n int) {
exp := ddtxn.MakeExp(50)
retries := make(ddtxn.RetryHeap, 0)
heap.Init(&retries)
var local_seed uint32 = uint32(rand.Intn(10000000))
wi := n % (*nworkers)
w := coord.Workers[wi]
top := (wi + 1) * int(sp)
bottom := wi * int(sp)
dlog.Printf("%v: Noncontended section: %v to %v\n", n, bottom, top)
end_time := time.Now().Add(time.Duration(*nsec) * time.Second)
for {
tm := time.Now()
if !end_time.After(tm) {
break
}
var t ddtxn.Query
if len(retries) > 0 && retries[0].TS.Before(tm) {
t = heap.Pop(&retries).(ddtxn.Query)
} else {
x := float64(ddtxn.RandN(&local_seed, 100))
if *prob == -1 {
x := goZipf[n].Uint64()
if x >= uint64(*nbidders) || x < 0 {
log.Fatalf("x not in bounds: %v\n", x)
}
t.K1 = ddtxn.ProductKey(int(x))
} else if x < *prob {
// contended txn
t.K1 = ddtxn.ProductKey(pkey)
} else {
// uncontended
k := pkey
for k == pkey {
if *partition {
rnd := ddtxn.RandN(&local_seed, sp-1)
lb := int(rnd)
k = lb + wi*int(sp) + 1
if k < bottom || k >= top+1 {
log.Fatalf("%v: outside my range %v [%v-%v]\n", n, k, bottom, top)
}
} else {
k = int(ddtxn.RandN(&local_seed, uint32(*nbidders)))
}
}
t.K1 = ddtxn.ProductKey(k)
}
t.TXN = ddtxn.D_INCR_ONE
if *atomicIncr {
t.TXN = ddtxn.D_ATOMIC_INCR_ONE
}
y := int(ddtxn.RandN(&local_seed, 100))
if y < *readrate {
t.TXN = ddtxn.D_READ_ONE
}
}
committed := false
_, err := w.One(t)
if err == ddtxn.EABORT {
committed = false
} else {
committed = true
}
t.I++
if !committed {
e := exp.Exp(t.I)
if e <= 0 {
e = 1
}
rnd := ddtxn.RandN(&local_seed, e)
if rnd <= 0 {
rnd = 1
}
t.TS = tm.Add(time.Duration(rnd) * time.Microsecond)
if t.TS.Before(end_time) {
heap.Push(&retries, t)
} else {
gave_up[n]++
}
}
}
w.Finished()
wg.Done()
if len(retries) > 0 {
dlog.Printf("[%v] Length of retry queue on exit: %v\n", n, len(retries))
}
gave_up[n] = gave_up[n] + int64(len(retries))
}(i)
}
wg.Wait()
coord.Finish()
end := time.Since(start)
p.Stop()
stats := make([]int64, ddtxn.LAST_STAT)
nitr, nwait, _, _, _, _, _ := ddtxn.CollectCounts(coord, stats)
for i := 1; i < *clientGoRoutines; i++ {
gave_up[0] = gave_up[0] + gave_up[i]
}
// nitr + NABORTS + ENOKEY is how many requests were issued. A
// stashed transaction eventually executes and contributes to
// nitr.
out := fmt.Sprintf(" nworkers: %v, nwmoved: %v, nrmoved: %v, sys: %v, total/sec: %v, abortrate: %.2f, stashrate: %.2f, rr: %v, nkeys: %v, contention: %v, zipf: %v, done: %v, actual time: %v, nreads: %v, nincrs: %v, epoch changes: %v, throughput ns/txn: %v, naborts: %v, coord time: %v, coord stats time: %v, total worker time transitioning: %v, nstashed: %v, rlock: %v, wrratio: %v, nsamples: %v, getkeys: %v, ddwrites: %v, nolock: %v, failv: %v, nlocked: %v, stashdone: %v, nfast: %v, gaveup: %v, potential: %v ", *nworkers, ddtxn.WMoved, ddtxn.RMoved, *ddtxn.SysType, float64(nitr)/end.Seconds(), 100*float64(stats[ddtxn.NABORTS])/float64(nitr+stats[ddtxn.NABORTS]), 100*float64(stats[ddtxn.NSTASHED])/float64(nitr+stats[ddtxn.NABORTS]), *readrate, *nbidders, *prob, *ZipfDist, nitr, end, stats[ddtxn.D_READ_ONE], stats[ddtxn.D_INCR_ONE], ddtxn.NextEpoch, end.Nanoseconds()/nitr, stats[ddtxn.NABORTS], ddtxn.Time_in_IE, ddtxn.Time_in_IE1, nwait, stats[ddtxn.NSTASHED], *ddtxn.UseRLocks, *ddtxn.WRRatio, stats[ddtxn.NSAMPLES], stats[ddtxn.NGETKEYCALLS], stats[ddtxn.NDDWRITES], stats[ddtxn.NO_LOCK], stats[ddtxn.NFAIL_VERIFY], stats[ddtxn.NLOCKED], stats[ddtxn.NDIDSTASHED], ddtxn.Nfast, gave_up[0], coord.PotentialPhaseChanges)
fmt.Printf(out)
fmt.Printf("\n")
f, err := os.OpenFile(*dataFile, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0600)
if err != nil {
panic(err)
}
defer f.Close()
ddtxn.PrintStats(out, stats, f, coord, s, *nbidders)
}
