func simulatedClient(rlReply *masterproto.GetReplicaListReply, leader int, readings chan float64, done chan bool) {
N := len(rlReply.ReplicaList)
servers := make([]net.Conn, N)
readers := make([]*bufio.Reader, N)
writers := make([]*bufio.Writer, N)
rarray := make([]int, *reqsNb)
karray := make([]int64, *reqsNb)
perReplicaCount := make([]int, N)
M := N
if *barOne {
M = N - 1
}
randObj := rand.New(rand.NewSource(42))
zipf := rand.NewZipf(randObj, *s, *v, uint64(*reqsNb))
for i := 0; i < len(rarray); i++ {
r := rand.Intn(M)
rarray[i] = r
perReplicaCount[r]++
if *conflicts >= 0 {
r = rand.Intn(100)
if r < *conflicts {
karray[i] = 42
} else {
karray[i] = int64(*startRange + 43 + i)
}
} else {
karray[i] = int64(zipf.Uint64())
}
}
repliesChan := make(chan int32, *reqsNb*N)
for i := 0; i < N; i++ {
var err error
servers[i], err = net.Dial("tcp", rlReply.ReplicaList[i])
if err != nil {
log.Printf("Error connecting to replica %d\n", i)
}
readers[i] = bufio.NewReader(servers[i])
if *fast {
//wait for replies from every replica
go waitForReplies(readers[i], repliesChan)
}
writers[i] = bufio.NewWriter(servers[i])
}
id := int32(*idStart)
args := genericsmrproto.Propose{id, state.Command{state.PUT, 0, 0}}
n := *reqsNb
for i := 0; i < n; i++ {
before := time.Now()
args.ClientId = id
args.Command.K = state.Key(karray[i])
if !*fast {
if *noLeader {
leader = rarray[i]
}
writers[leader].WriteByte(genericsmrproto.PROPOSE)
args.Marshal(writers[leader])
writers[leader].Flush()
} else {
//send to everyone
for rep := 0; rep < N; rep++ {
writers[rep].WriteByte(genericsmrproto.PROPOSE)
args.Marshal(writers[rep])
writers[rep].Flush()
}
}
for true {
rid := <-repliesChan
if rid == id {
break
}
}
after := time.Now()
id++
readings <- (after.Sub(before)).Seconds() * 1000
if *sleep > 0 {
time.Sleep(100 * 1000 * 1000)
}
}
for _, client := range servers {
if client != nil {
client.Close()
}
}
done <- true
}
func main() {
flag.Parse()
runtime.GOMAXPROCS(*procs)
randObj := rand.New(rand.NewSource(42 + int64(*forceLeader)))
//zipf := rand.NewZipf(randObj, *s, *v, uint64(*reqsNb / *rounds + *eps))
zipf := ycsbzipf.NewZipf(int(*reqsNb / *rounds + *eps), randObj)
if *conflicts > 100 {
log.Fatalf("Conflicts percentage must be between 0 and 100.\n")
}
if *writes > 100 {
log.Fatalf("Write percentage cannot be higher than 100.\n")
}
master, err := rpc.DialHTTP("tcp", fmt.Sprintf("%s:%d", *masterAddr, *masterPort))
if err != nil {
log.Fatalf("Error connecting to master\n")
}
rlReply := new(masterproto.GetReplicaListReply)
err = master.Call("Master.GetReplicaList", new(masterproto.GetReplicaListArgs), rlReply)
if err != nil {
log.Fatalf("Error making the GetReplicaList RPC")
}
N = len(rlReply.ReplicaList)
if *forcedN > N {
log.Fatalf("Cannot connect to more than the total number of replicas. -N parameter too high.\n")
}
if *forcedN > 0 {
N = *forcedN
}
servers := make([]net.Conn, N)
readers := make([]*bufio.Reader, N)
writers := make([]*bufio.Writer, N)
rarray = make([]int, *reqsNb / *rounds + *eps)
karrays := make([][]int64, N)
iarray := make([]int, *reqsNb / *rounds + *eps)
put := make([]bool, *reqsNb / *rounds + *eps)
perReplicaCount := make([]int, N)
test := make([]int, *reqsNb / *rounds + *eps)
for j := 0; j < N; j++ {
karrays[j] = make([]int64, *reqsNb / *rounds + *eps)
for i := 0; i < len(karrays[j]); i++ {
karrays[j][i] = int64(i)
}
robj := rand.New(rand.NewSource(442 + int64(j)))
randperm.Permute(karrays[j], robj)
}
for i := 0; i < len(rarray); i++ {
r := rand.Intn(N)
rarray[i] = r
if i < *reqsNb / *rounds {
perReplicaCount[r]++
}
if *conflicts >= 0 {
r = rand.Intn(100)
if r < *conflicts {
iarray[i] = 0
} else {
iarray[i] = i
}
} else {
iarray[i] = int(zipf.NextInt64())
test[karrays[rarray[i]][iarray[i]]]++
}
r = rand.Intn(100)
if r < *writes {
put[i] = true
} else {
put[i] = false
}
}
if *conflicts >= 0 {
fmt.Println("Uniform distribution")
} else {
fmt.Println("Zipfian distribution:")
//fmt.Println(test[0:100])
}
for i := 0; i < N; i++ {
var err error
servers[i], err = net.Dial("tcp", rlReply.ReplicaList[i])
if err != nil {
log.Printf("Error connecting to replica %d\n", i)
}
readers[i] = bufio.NewReader(servers[i])
writers[i] = bufio.NewWriter(servers[i])
}
successful = make([]int, N)
local = make([]int, N)
leader := 0
if *noLeader == false && *forceLeader < 0 {
reply := new(masterproto.GetLeaderReply)
if err = master.Call("Master.GetLeader", new(masterproto.GetLeaderArgs), reply); err != nil {
log.Fatalf("Error making the GetLeader RPC\n")
}
leader = reply.LeaderId
log.Printf("The leader is replica %d\n", leader)
} else if *forceLeader > 0 {
leader = *forceLeader
log.Printf("My leader is replica %d\n", leader)
}
var id int32 = 0
done := make(chan bool, N)
args := genericsmrproto.Propose{id, state.Command{state.PUT, 0, 0}, 0}
before_total := time.Now()
for j := 0; j < *rounds; j++ {
n := *reqsNb / *rounds
if *check {
rsp = make([]bool, n)
for j := 0; j < n; j++ {
rsp[j] = false
}
}
if *noLeader {
for i := 0; i < N; i++ {
go waitReplies(readers, i, perReplicaCount[i], done)
}
} else {
go waitReplies(readers, leader, n, done)
}
before := time.Now()
for i := 0; i < n+*eps; i++ {
dlog.Printf("Sending proposal %d\n", id)
args.CommandId = id
if put[i] {
args.Command.Op = state.PUT
} else {
args.Command.Op = state.GET
}
if !*fast && *noLeader {
leader = rarray[i]
}
args.Command.K = state.Key(karrays[leader][iarray[i]])
args.Command.V = state.Value(i) + 1
//args.Timestamp = time.Now().UnixNano()
if !*fast {
writers[leader].WriteByte(genericsmrproto.PROPOSE)
args.Marshal(writers[leader])
} else {
//send to everyone
for rep := 0; rep < N; rep++ {
writers[rep].WriteByte(genericsmrproto.PROPOSE)
args.Marshal(writers[rep])
writers[rep].Flush()
}
}
//fmt.Println("Sent", id)
id++
if i%100 == 0 {
for i := 0; i < N; i++ {
writers[i].Flush()
}
}
}
for i := 0; i < N; i++ {
writers[i].Flush()
}
err := false
if *noLeader {
for i := 0; i < N; i++ {
e := <-done
err = e || err
}
} else {
err = <-done
}
after := time.Now()
fmt.Printf("Round took %v\n", after.Sub(before))
if *check {
for j := 0; j < n; j++ {
if !rsp[j] {
fmt.Println("Didn't receive", j)
}
}
}
if err {
if *noLeader {
N = N - 1
} else {
reply := new(masterproto.GetLeaderReply)
master.Call("Master.GetLeader", new(masterproto.GetLeaderArgs), reply)
leader = reply.LeaderId
log.Printf("New leader is replica %d\n", leader)
}
}
}
after_total := time.Now()
fmt.Printf("Test took %v\n", after_total.Sub(before_total))
s := 0
ltot := 0
for _, succ := range successful {
s += succ
}
for _, loc := range local {
ltot += loc
}
fmt.Printf("Successful: %d\n", s)
fmt.Printf("Local Reads: %d\n", ltot)
for _, client := range servers {
if client != nil {
client.Close()
}
}
master.Close()
}
func simulatedClient(rlReply *masterproto.GetReplicaListReply, leader int, readings chan float64, done chan bool) {
N := len(rlReply.ReplicaList)
servers := make([]net.Conn, N)
readers := make([]*bufio.Reader, N)
writers := make([]*bufio.Writer, N)
rarray := make([]int, *reqsNb)
karray := make([]int64, *reqsNb)
perReplicaCount := make([]int, N)
M := N
if *barOne {
M = N - 1
}
randObj := rand.New(rand.NewSource(42))
zipf := rand.NewZipf(randObj, *s, *v, uint64(*reqsNb))
for i := 0; i < len(rarray); i++ {
r := rand.Intn(M)
rarray[i] = r
perReplicaCount[r]++
if *conflicts >= 0 {
r = rand.Intn(100)
if r < *conflicts {
karray[i] = 42
} else {
karray[i] = int64(*startRange + 43 + i)
}
} else {
karray[i] = int64(zipf.Uint64())
}
}
for i := 0; i < N; i++ {
var err error
servers[i], err = net.Dial("tcp", rlReply.ReplicaList[i])
if err != nil {
log.Printf("Error connecting to replica %d\n", i)
}
readers[i] = bufio.NewReader(servers[i])
writers[i] = bufio.NewWriter(servers[i])
}
var id int32 = 0
args := genericsmrproto.Propose{id, state.Command{state.PUT, 0, 0}}
var reply genericsmrproto.ProposeReply
n := *reqsNb
for i := 0; i < n; i++ {
if *noLeader {
leader = rarray[i]
}
args.ClientId = id
args.Command.K = state.Key(karray[i])
writers[leader].WriteByte(genericsmrproto.PROPOSE)
before := time.Now()
args.Marshal(writers[leader])
writers[leader].Flush()
if err := reply.Unmarshal(readers[leader]); err != nil || reply.OK == 0 {
fmt.Println("Error when reading:", err)
continue
}
after := time.Now()
id++
readings <- (after.Sub(before)).Seconds() * 1000
if *sleep > 0 {
time.Sleep(100 * 1000 * 1000)
}
}
for _, client := range servers {
if client != nil {
client.Close()
}
}
done <- true
}
func main() {
flag.Parse()
runtime.GOMAXPROCS(*procs)
randObj := rand.New(rand.NewSource(42))
zipf := rand.NewZipf(randObj, *s, *v, uint64(*reqsNb)) //uint64(*reqsNb / *rounds + *eps))
if *conflicts > 100 {
log.Fatalf("Conflicts percentage must be between 0 and 100.\n")
}
master, err := rpc.DialHTTP("tcp", fmt.Sprintf("%s:%d", *masterAddr, *masterPort))
if err != nil {
log.Fatalf("Error connecting to master\n")
}
rlReply := new(masterproto.GetReplicaListReply)
err = master.Call("Master.GetReplicaList", new(masterproto.GetReplicaListArgs), rlReply)
if err != nil {
log.Fatalf("Error making the GetReplicaList RPC")
}
N = len(rlReply.ReplicaList)
servers := make([]net.Conn, N)
readers := make([]*bufio.Reader, N)
writers := make([]*bufio.Writer, N)
rarray = make([]int, *reqsNb / *rounds + *eps)
karray := make([]int64, *reqsNb / *rounds + *eps)
perReplicaCount := make([]int, N)
//test := make([]int, *reqsNb / *rounds + *eps)
M := N
if *barOne {
M = N - 1
}
for i := 0; i < len(rarray); i++ {
r := rand.Intn(M)
rarray[i] = r
if i < *reqsNb / *rounds {
perReplicaCount[r]++
}
if *conflicts >= 0 {
r = rand.Intn(100)
if r < *conflicts {
karray[i] = 42
} else {
karray[i] = int64(43 + i)
}
} else {
karray[i] = int64(zipf.Uint64())
//test[karray[i]]++
}
}
if *conflicts >= 0 {
//fmt.Println("Uniform distribution")
} else {
/*fmt.Println("Zipfian distribution:")
sum := 0
for _, val := range test[0:2000] {
sum += val
}
fmt.Println(test[0:100])
fmt.Println(sum)*/
}
for i := 0; i < N; i++ {
var err error
servers[i], err = net.Dial("tcp", rlReply.ReplicaList[i])
if err != nil {
log.Printf("Error connecting to replica %d\n", i)
N = N - 1
}
readers[i] = bufio.NewReader(servers[i])
writers[i] = bufio.NewWriter(servers[i])
}
successful = make([]int, N)
leader := 0
if *noLeader == false {
reply := new(masterproto.GetLeaderReply)
if err = master.Call("Master.GetLeader", new(masterproto.GetLeaderArgs), reply); err != nil {
log.Fatalf("Error making the GetLeader RPC\n")
}
leader = reply.LeaderId
//log.Printf("The leader is replica %d\n", leader)
}
var id int32 = 0
done := make(chan bool, N)
args := genericsmrproto.Propose{id, state.Command{state.PUT, 0, 0}} //make([]int64, state.VALUE_SIZE)}}
pdone := make(chan bool)
go printer(pdone)
before_total := time.Now()
for j := 0; j < *rounds; j++ {
n := *reqsNb / *rounds
if *check {
rsp = make([]bool, n)
for j := 0; j < n; j++ {
rsp[j] = false
}
}
if *noLeader {
for i := 0; i < N; i++ {
go waitReplies(readers, i, perReplicaCount[i], done)
}
} else {
go waitReplies(readers, leader, n, done)
// go waitReplies(readers, 2, n, done)
}
// before := time.Now()
for i := 0; i < n+*eps; i++ {
//dlog.Printf("Sending proposal %d\n", id)
if *noLeader {
leader = rarray[i]
if leader >= N {
continue
}
}
args.ClientId = id
args.Command.K = state.Key(karray[i])
writers[leader].WriteByte(genericsmrproto.PROPOSE)
args.Marshal(writers[leader])
writers[leader].Flush()
//fmt.Println("Sent", id)
id++
if i%100 == 0 {
for i := 0; i < N; i++ {
writers[i].Flush()
}
}
}
for i := 0; i < N; i++ {
writers[i].Flush()
}
err := false
if *noLeader {
W := N
if *waitLess {
W = N - 1
}
for i := 0; i < W; i++ {
e := <-done
err = e || err
}
} else {
err = <-done
}
// after := time.Now()
// fmt.Printf("Round took %v\n", after.Sub(before))
if *check {
for j := 0; j < n; j++ {
if !rsp[j] {
fmt.Println("Didn't receive", j)
}
}
}
if err {
if *noLeader {
N = N - 1
} else {
reply := new(masterproto.GetLeaderReply)
master.Call("Master.GetLeader", new(masterproto.GetLeaderArgs), reply)
leader = reply.LeaderId
log.Printf("New leader is replica %d\n", leader)
}
}
}
after_total := time.Now()
//fmt.Printf("Test took %v\n", after_total.Sub(before_total))
//fmt.Printf("%v\n", (after_total.Sub(before_total)).Seconds())
s := 0
for _, succ := range successful {
s += succ
}
fmt.Printf("Successful: %d\n", s)
fmt.Printf("%v\n", float64(s)/(after_total.Sub(before_total)).Seconds())
for _, client := range servers {
if client != nil {
client.Close()
}
}
master.Close()
}
func main() {
flag.Parse()
runtime.GOMAXPROCS(*procs)
randObj := rand.New(rand.NewSource(42))
zipf := rand.NewZipf(randObj, *s, *v, uint64(*reqsNb / *rounds + *eps))
if *conflicts > 100 {
log.Fatalf("Conflicts percentage must be between 0 and 100.\n")
}
master, err := rpc.DialHTTP("tcp", fmt.Sprintf("%s:%d", *masterAddr, *masterPort))
if err != nil {
log.Fatalf("Error connecting to master\n")
}
rlReply := new(masterproto.GetReplicaListReply)
err = master.Call("Master.GetReplicaList", new(masterproto.GetReplicaListArgs), rlReply)
if err != nil {
log.Fatalf("Error making the GetReplicaList RPC")
}
N = len(rlReply.ReplicaList)
servers := make([]net.Conn, N)
readers := make([]*bufio.Reader, N)
writers := make([]*bufio.Writer, N)
rarray = make([]int, *reqsNb / *rounds + *eps)
karray := make([]int64, *reqsNb / *rounds + *eps)
perReplicaCount := make([]int, N)
test := make([]int, *reqsNb / *rounds + *eps)
for i := 0; i < len(rarray); i++ {
r := rand.Intn(N)
rarray[i] = r
if i < *reqsNb / *rounds {
perReplicaCount[r]++
}
if *conflicts >= 0 {
r = rand.Intn(100)
if r < *conflicts {
karray[i] = 42
} else {
karray[i] = int64(43 + i)
}
} else {
karray[i] = int64(zipf.Uint64())
test[karray[i]]++
}
}
if *conflicts >= 0 {
fmt.Println("Uniform distribution")
} else {
fmt.Println("Zipfian distribution:")
//fmt.Println(test[0:100])
}
for i := 0; i < N; i++ {
var err error
servers[i], err = net.Dial("tcp", rlReply.ReplicaList[i])
if err != nil {
log.Printf("Error connecting to replica %d\n", i)
}
readers[i] = bufio.NewReader(servers[i])
writers[i] = bufio.NewWriter(servers[i])
}
successful = make([]int, N)
leader := 0
if *noLeader == false {
reply := new(masterproto.GetLeaderReply)
if err = master.Call("Master.GetLeader", new(masterproto.GetLeaderArgs), reply); err != nil {
log.Fatalf("Error making the GetLeader RPC\n")
}
leader = reply.LeaderId
log.Printf("The leader is replica %d\n", leader)
}
var id int32 = 0
done := make(chan bool, N)
args := genericsmrproto.Propose{id, state.Command{state.PUT, 0, 0}}
before_total := time.Now()
for j := 0; j < *rounds; j++ {
n := *reqsNb / *rounds
if *check {
rsp = make([]bool, n)
for j := 0; j < n; j++ {
rsp[j] = false
}
}
donePrinting := make(chan bool)
readings := make(chan int64, n)
go printer(readings, donePrinting)
if *noLeader {
for i := 0; i < N; i++ {
go waitReplies(readers, i, perReplicaCount[i], done, readings)
}
} else {
go waitReplies(readers, leader, n, done, readings)
}
before := time.Now()
for i := 0; i < n+*eps; i++ {
dlog.Printf("Sending proposal %d\n", id)
args.ClientId = id
args.Command.K = state.Key(karray[i])
args.Command.V = state.Value(time.Now().UnixNano())
if !*fast {
if *noLeader {
leader = rarray[i]
}
writers[leader].WriteByte(genericsmrproto.PROPOSE)
args.Marshal(writers[leader])
} else {
//send to everyone
for rep := 0; rep < N; rep++ {
writers[rep].WriteByte(genericsmrproto.PROPOSE)
args.Marshal(writers[rep])
writers[rep].Flush()
}
}
//fmt.Println("Sent", id)
id++
if i%*batch == 0 {
for i := 0; i < N; i++ {
writers[i].Flush()
}
if *nanosleep > 0 {
time.Sleep(time.Duration(*nanosleep))
}
}
}
for i := 0; i < N; i++ {
writers[i].Flush()
}
err := false
if *noLeader {
for i := 0; i < N; i++ {
e := <-done
err = e || err
}
} else {
err = <-done
}
after := time.Now()
<-donePrinting
fmt.Printf("Round took %v\n", after.Sub(before))
if *check {
for j := 0; j < n; j++ {
if !rsp[j] {
fmt.Println("Didn't receive", j)
}
}
}
if err {
if *noLeader {
N = N - 1
} else {
reply := new(masterproto.GetLeaderReply)
master.Call("Master.GetLeader", new(masterproto.GetLeaderArgs), reply)
leader = reply.LeaderId
log.Printf("New leader is replica %d\n", leader)
}
}
}
after_total := time.Now()
fmt.Printf("Test took %v\n", after_total.Sub(before_total))
s := 0
for _, succ := range successful {
s += succ
}
fmt.Printf("Successful: %d\n", s)
for _, client := range servers {
if client != nil {
client.Close()
}
}
master.Close()
}
func simulatedClient(rlReply *masterproto.GetReplicaListReply, leaderId int, readsChan chan float64, writesChan chan float64, done chan bool, idx int) {
N := len(rlReply.ReplicaList)
servers := make([]net.Conn, N)
readers := make([]*bufio.Reader, N)
writers := make([]*bufio.Writer, N)
rarray := make([]int, *reqsNb)
iarray := make([]int, *reqsNb)
put := make([]bool, *reqsNb)
perReplicaCount := make([]int, N)
M := N
if *barOne {
M = N - 1
}
randObj := rand.New(rand.NewSource(int64(42 + idx)))
zipf := ycsbzipf.NewZipf(int(*D), randObj)
for i := 0; i < len(rarray); i++ {
r := rand.Intn(M)
rarray[i] = r
perReplicaCount[r]++
if *conflicts >= 0 {
r = rand.Intn(100)
if r < *conflicts {
iarray[i] = 0
} else {
iarray[i] = i
}
} else {
iarray[i] = int(zipf.NextInt64())
}
//r = rand.Intn(100)
r = randObj.Intn(100)
if r < *writes {
put[i] = true
} else {
put[i] = false
}
}
for i := 0; i < N; i++ {
var err error
servers[i], err = net.Dial("tcp", rlReply.ReplicaList[i])
if err != nil {
log.Printf("Error connecting to replica %d\n", i)
}
readers[i] = bufio.NewReader(servers[i])
writers[i] = bufio.NewWriter(servers[i])
}
var id int32 = 0
args := genericsmrproto.Propose{id, state.Command{state.PUT, 0, 0}, 0}
var reply genericsmrproto.ProposeReplyTS
n := *reqsNb
successful := 0
for i := 0; i < n; i++ {
leader := leaderId
if *noLeader {
leader = rarray[i]
}
args.CommandId = id
if put[i] {
args.Command.Op = state.PUT
} else {
args.Command.Op = state.GET
if *readFrom > 0 {
leader = *readFrom
}
}
args.Command.K = state.Key(karray[iarray[i]])
writers[leader].WriteByte(genericsmrproto.PROPOSE)
before := time.Now()
//log.Println(i, karray[i], iarray[i], karray[iarray[i]])
args.Marshal(writers[leader])
writers[leader].Flush()
if err := reply.Unmarshal(readers[leader]); err != nil {
fmt.Println("Error when reading:", err)
continue
}
if reply.OK != 0 {
successful++
}
after := time.Now()
id++
if put[i] {
writesChan <- (after.Sub(before)).Seconds() * 1000
} else {
readsChan <- (after.Sub(before)).Seconds() * 1000
}
if *sleep > 0 {
time.Sleep(100 * 1000 * 1000)
}
}
for _, client := range servers {
if client != nil {
client.Close()
}
}
log.Println("Successful:", successful)
done <- true
}