示例#1
0
func Test_UndoRedo(t *testing.T) {
	u, _, f := initial()
	tr1 := u.AddTransition("transition1",
		state.FactorEquals{f, "a"},
		state.Spontaneous{0},
		"AB happened.",
		map[*state.Factor]state.Value{f: "b"})
	tr2 := u.AddTransition("transition2",
		state.FactorEquals{f, "b"},
		state.Spontaneous{0},
		"BC happened.",
		map[*state.Factor]state.Value{f: "c"})
	s := u.Instantiate()

	assert(t, "No undo before do", false, nil != s.Now().Past())
	assert(t, "No redo before do", false, nil != s.Now().Future())
	tr1.Apply(s)
	tr2.Apply(s)
	assert(t, "Can undo after do", true, nil != s.Now().Past())
	assert(t, "Pre-undo", state.Value("c"), s.Get(f))
	assert(t, "Redo before mid", false, nil != s.Now().Future())
	s.Goto(s.Now().Past())
	assert(t, "Undo 1", state.Value("b"), s.Get(f))
	assert(t, "Redo after mid", true, nil != s.Now().Future())
	s.Goto(s.Now().Past())
	assert(t, "Undo 2", state.Value("a"), s.Get(f))
	s.Goto(s.Now().Future())
	assert(t, "Redo", state.Value("b"), s.Get(f))
}
示例#2
0
func Test_SpontaneousNot(t *testing.T) {
	u, r, f := initial()
	u.AddTransition("a-transition",
		state.FactorEquals{f, "a"},
		state.Spontaneous{0},
		"",
		map[*state.Factor]state.Value{f: "b"})
	s := u.Instantiate()

	assert(t, "Initial state", state.Value("a"), s.Get(f))

	s.RunSpontaneous(r)

	assert(t, "Spontaneous didn't happen", state.Value("a"), s.Get(f))
}
示例#3
0
func Bool() state.BoolExpr {
	if current_token == '(' {
		Match('(')
		exp := Conjunction()
		Match(')')
		return exp
	} else {
		fac := u.FindFactor(FactorName())
		switch current_token {
		//		case '<':
		//			Match('<')
		//			if current_token == '=' {
		//				Match('=')
		//			}

		//			if current_token == INT {
		//				Match(INT)
		//			} else {
		//				FactorName()
		//			}
		//		case '>':
		//			Match('>')
		//			if current_token == '=' {
		//				Match('=')
		//			}

		//			if current_token == INT {
		//				Match(INT)
		//			} else {
		//				FactorName()
		//			}
		case '=':
			Match('=')
			if current_token == INT {
				exp := state.FactorEquals{fac, state.Value(strconv.Itoa(current_int))}
				Match(INT)
				return exp
			} else {
				exp := state.FactorEquals{fac, state.Value(current_string)}
				Match(STRING)
				return exp
			}
		}
	}
	return nil
}
示例#4
0
func FactorTransition() (*state.Factor, state.Value) {
	fac := u.FindFactor(FactorName())
	var val state.Value
	if current_token == '-' {
		Match('-')
		if current_token == '>' {
			Match('>')
			val = state.Value(FactorValue())
		} // else {
		//			Match(INT)
		//		}
		//	} else {
		//		Match('+')
		//		if current_token == INT {
		//			Match(INT)
		//		}
	}
	return fac, val
}
示例#5
0
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()
}
示例#6
0
func (r *Replica) MakeInstance(q, i int, seq int32, deps [3]int32) {
	command := &state.Command{state.PUT, state.Key(q), state.Value(i)}
	r.InstanceSpace[q][i] = &Instance{command, 0, epaxosproto.COMMITTED, seq, deps, nil, 0, 0}
}
示例#7
0
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()
}