Beispiel #1
0
func mergeDomains(engine storage.Engine, w origins.Writer, domains []string, since, asof time.Time) int {
	var (
		err   error
		count int
		log   *view.Log
	)

	iters := make([]origins.Iterator, len(domains))

	// Merge and output facts across domains.
	for i, d := range domains {
		log, err = view.OpenLog(engine, d, "commit")

		if err != nil {
			logrus.Fatal(err)
		}

		iters[i] = log.View(since, asof)
	}

	if count, err = origins.Copy(view.Merge(iters...), w); err != nil {
		logrus.Fatal(err)
	}

	return count
}
Beispiel #2
0
func TestMultiDomainLogIter(t *testing.T) {
	domains := []string{"test", "another_test"}

	// Number of transactions
	n := 100

	// Number of facts per transaction
	m := 100

	engine := randMultidomainStorage(domains, n, m)

	// Open and merge the commit logs.

	log0, err := view.OpenLog(engine, domains[0], "commit")
	if err != nil {
		t.Fatal(err)
	}

	log1, err := view.OpenLog(engine, domains[1], "commit")

	if err != nil {
		t.Fatal(err)
	}

	now := time.Now()
	mergedStreams := view.Merge(log0.Asof(now), log1.Asof(now))

	if err = mergedStreams.Err(); err != nil {
		t.Fatal(err)
	}

	i := 0
	var prevTrnId uint64 = 1<<64 - 1
	for {
		f := mergedStreams.Next()

		if err = mergedStreams.Err(); err != nil {
			t.Fatal(err)
		}

		if f == nil {
			break
		} else {
			if prevTrnId < f.Transaction {
				t.Errorf("Transactions are ordered incorrectly")
			}
			i++
		}
	}

	if i != n*m {
		t.Errorf("expected %d facts, got %d", n*m, i)
	}
}
Beispiel #3
0
func benchmarkDomainMerge(b *testing.B, numTrn, factsPerTrn, numDomains int) {
	var err error

	domains := make([]string, numDomains)
	iters := make([]origins.Iterator, len(domains))
	logs := make([]*view.Log, len(domains))

	for j := 0; j < numDomains; j++ {
		domains[j] = "domain_" + strconv.Itoa(j+1)
	}

	engine := randMultidomainStorage(domains, numTrn, factsPerTrn)

	for j := 0; j < len(domains); j++ {
		logs[j], err = view.OpenLog(engine, domains[j], "commit")

		if err != nil {
			b.Fatal(err)
		}
	}

	now := time.Now()

	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		for j := 0; j < len(domains); j++ {
			iters[j] = logs[j].Asof(now)
		}

		iter := view.Merge(iters...)

		if err := iter.Err(); err != nil {
			b.Fatal(err)
		}

		// The Merge() operation is lazy, and most of the actual work happens during Next(),
		// so to evaluate the true cost of merging we need to time how long it takes to step
		// through the resulting iterator.
		_, err = testNext(iter)
		if err != nil {
			b.Fatal(err)
		}
	}
}