コード例 #1
0
func TestTupleSpaceProcessNewEntriesAlwaysRespondsToReaders(t *testing.T) {
	rts := tuplespace.NewRawTupleSpace(store.NewMemoryStore())
	take := rts.ReadOperation(tuplespace.MustMatch("cmd"), 0, tuplespace.ActionOne|tuplespace.ActionTake)
	read := rts.ReadOperation(tuplespace.MustMatch("cmd"), 0, tuplespace.ActionOne)
	go func() {
		time.Sleep(time.Second * 1)
		take.Cancel()
		read.Cancel()
	}()
	tuples := []tuplespace.Tuple{tuplespace.Tuple{"cmd": "uname -a"}}
	expected := []tuplespace.Tuple{tuplespace.Tuple{"cmd": "uname -a"}}
	assert.NoError(t, rts.ProcessNewEntries(tuples, time.Now()))
	assert.Equal(t, <-take.Get(), expected)
	assert.Equal(t, <-read.Get(), expected)
}
コード例 #2
0
func TestTupleSpaceTake(t *testing.T) {
	ts := tuplespace.NewTupleSpace(store.NewMemoryStore())
	defer ts.Shutdown()
	ts.Send(tuplespace.Tuple{"cmd": "uname -a"}, 0)
	ts.Send(tuplespace.Tuple{"cmd": "uptime"}, 0)
	_, err := ts.Take(tuplespace.MustMatch(`cmd != nil`), time.Second)
	assert.NoError(t, err)
	assert.Equal(t, ts.Stats().Tuples, 1)
}
コード例 #3
0
func benchmarkTupleSpaceReadAll1000(b *testing.B, builder TupleStoreBuilder) {
	ts := tuplespace.NewTupleSpace(NewTemporaryDiskStore(builder))
	defer ts.Shutdown()
	sendN(ts, 1000, 0)
	b.ResetTimer()
	match := tuplespace.MustMatch(`cmd != nil`)
	for i := 0; i < b.N; i++ {
		ts.ReadAll(match, 0)
	}
}
コード例 #4
0
func benchmarkTupleSpaceTake(b *testing.B, builder TupleStoreBuilder) {
	ts := tuplespace.NewTupleSpace(NewTemporaryDiskStore(builder))
	defer ts.Shutdown()
	sendN(ts, b.N, 0)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		match := tuplespace.MustMatch(`cmd == %d`, i)
		ts.Take(match, 0)
	}
}
コード例 #5
0
func TestTupleSpaceReadAll(t *testing.T) {
	ts := tuplespace.NewTupleSpace(store.NewMemoryStore())
	defer ts.Shutdown()
	ts.Send(tuplespace.Tuple{"cmd": "uname -a"}, 0)
	ts.Send(tuplespace.Tuple{"cmd": "uptime"}, 0)
	time.Sleep(time.Millisecond * 100)
	tuples, err := ts.ReadAll(tuplespace.MustMatch(`cmd != nil`), time.Second)
	assert.NoError(t, err)
	assert.Equal(t, tuples, []tuplespace.Tuple{tuplespace.Tuple{"cmd": "uname -a"}, tuplespace.Tuple{"cmd": "uptime"}})
	assert.Equal(t, ts.Stats().Tuples, 2)
}
コード例 #6
0
func benchmarkTupleSpaceRead(b *testing.B, builder TupleStoreBuilder) {
	ts := tuplespace.NewTupleSpace(NewTemporaryDiskStore(builder))
	defer ts.Shutdown()
	sendN(ts, b.N, 0)
	sendN(ts, b.N, 0)
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		match := tuplespace.MustMatch(`cmd == %d`, int64(i))
		_, err := ts.Read(match, 0)
		if err != nil {
			panic(err.Error())
		}
	}
}
コード例 #7
0
func benchmarkTupleSpaceStressTestConcurrency32(b *testing.B, builder TupleStoreBuilder) {
	ts := tuplespace.NewTupleSpace(NewTemporaryDiskStore(builder))
	defer ts.Shutdown()

	threads := 32
	messages := b.N

	var sent int32
	var read int32

	readWait := sync.WaitGroup{}
	for i := 0; i < threads; i++ {
		readWait.Add(1)
		go func(i int) {
			for n := 0; n < messages; n++ {
				match := tuplespace.MustMatch(`"a" == "reader" && "b" == %d && "c" == %d`, i, n)
				_, err := ts.Take(match, time.Minute)
				if err != nil {
					fmt.Errorf("failed to take: %s", err)
				} else {
					atomic.AddInt32(&read, 1)
				}
			}
			readWait.Done()
		}(i)
	}

	writeWait := sync.WaitGroup{}
	for i := 0; i < threads; i++ {
		writeWait.Add(1)
		go func(i int) {
			for n := 0; n < messages; n++ {
				tuple := tuplespace.Tuple{"a": "reader", "b": int64(i), "c": int64(n)}
				err := ts.Send(tuple, 0)
				if err != nil {
					fmt.Errorf("failed to take: %s", err)
				} else {
					atomic.AddInt32(&sent, 1)
				}
			}
			writeWait.Done()
		}(i)
	}

	writeWait.Wait()
	if int(sent) != threads*messages {
		panic("consistency check failed")
	}

	readWait.Wait()
	if sent != read {
		panic("consistency check failed")
	}

	// assert.Equal(t, ts.Stats(), tuplespace.TupleSpaceStats{
	// 	TuplesSeen:  int64(threads * messages),
	// 	WaitersSeen: int64(threads * messages),
	// 	TuplesTaken: int64(threads * messages),
	// 	TuplesRead:  0,
	// })
}