From 581fb2dc04e9f55cb3f21539eeaa31109ce1190e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Xavier=20Llor=C3=A0?= Date: Tue, 29 Mar 2016 09:58:46 -0700 Subject: [PATCH] Add and remove existing triple benchmarks. --- tools/benchmark/batteries/add.go | 116 +++++++++++++++++++++++++- tools/benchmark/batteries/remove.go | 120 ++++++++++++++++++++++++++- tools/vcli/bw/benchmark/benchmark.go | 22 +++-- 3 files changed, 246 insertions(+), 12 deletions(-) diff --git a/tools/benchmark/batteries/add.go b/tools/benchmark/batteries/add.go index 555a01ac..4369c866 100644 --- a/tools/benchmark/batteries/add.go +++ b/tools/benchmark/batteries/add.go @@ -56,7 +56,7 @@ func AddTreeTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime. gID := fmt.Sprintf("add_tree_%s_r%d_i%d", gids[i], i, idxReps) data := trplSets[i] bes = append(bes, &runtime.BenchEntry{ - BatteryID: "Add non-existent triples", + BatteryID: "Add non-existing triples", ID: fmt.Sprintf("%s, reps=%02d", ids[i], r), Triples: gSizes[i], Reps: r, @@ -77,6 +77,62 @@ func AddTreeTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime. return bes, nil } +// AddExistingTreeTriplesBenchmark creates the benchmark +func AddExistingTreeTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime.BenchEntry, error) { + bFactors := []int{2, 200} + sizes := []int{10, 1000, 100000} + var trplSets [][]*triple.Triple + var ids []string + var gids []string + var gSizes []int + gs, err := getTreeGenerators(bFactors) + if err != nil { + return nil, err + } + for idx, g := range gs { + for _, s := range sizes { + ts, err := g.Generate(s) + if err != nil { + return nil, err + } + trplSets = append(trplSets, ts) + ids = append(ids, fmt.Sprintf("tg branch_factor=%04d, size=%07d", bFactors[idx], s)) + gids = append(gids, fmt.Sprintf("b%d_s%d", bFactors[idx], s)) + gSizes = append(gSizes, s) + } + } + var bes []*runtime.BenchEntry + reps := []int{10} + for i, max := 0, len(ids); i < max; i++ { + for idxReps, r := range reps { + var g storage.Graph + gID := fmt.Sprintf("add_existing_tree_%s_r%d_i%d", gids[i], i, idxReps) + data := trplSets[i] + bes = append(bes, &runtime.BenchEntry{ + BatteryID: "Add existing triples", + ID: fmt.Sprintf("%s, reps=%02d", ids[i], r), + Triples: gSizes[i], + Reps: r, + Setup: func() error { + var err error + g, err = st.NewGraph(ctx, gID) + if err != nil { + return err + } + return g.AddTriples(ctx, data) + }, + F: func() error { + return g.AddTriples(ctx, data) + }, + TearDown: func() error { + return st.DeleteGraph(ctx, gID) + }, + }) + } + } + return bes, nil +} + // AddGraphTriplesBenchmark creates the benchmark func AddGraphTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime.BenchEntry, error) { nodes := []int{317, 1000} @@ -109,7 +165,7 @@ func AddGraphTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime gID := fmt.Sprintf("add_graph_%s_r%d_i%d", gids[i], i, idxReps) data := trplSets[i] bes = append(bes, &runtime.BenchEntry{ - BatteryID: "Add triples", + BatteryID: "Add non-existing triples", ID: fmt.Sprintf("%s, reps=%02d", ids[i], r), Triples: gSizes[i], Reps: r, @@ -129,3 +185,59 @@ func AddGraphTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime } return bes, nil } + +// AddExistingGraphTriplesBenchmark creates the benchmark +func AddExistingGraphTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime.BenchEntry, error) { + nodes := []int{317, 1000} + sizes := []int{10, 1000, 100000} + var trplSets [][]*triple.Triple + var ids []string + var gids []string + var gSizes []int + gs, err := getGraphGenerators(nodes) + if err != nil { + return nil, err + } + for idx, g := range gs { + for _, s := range sizes { + ts, err := g.Generate(s) + if err != nil { + return nil, err + } + trplSets = append(trplSets, ts) + ids = append(ids, fmt.Sprintf("erg nodes=%04d, size=%07d", nodes[idx], s)) + gids = append(gids, fmt.Sprintf("n%d_s%d", nodes[idx], s)) + gSizes = append(gSizes, s) + } + } + var bes []*runtime.BenchEntry + reps := []int{10} + for i, max := 0, len(ids); i < max; i++ { + for idxReps, r := range reps { + var g storage.Graph + gID := fmt.Sprintf("add_existing_graph_%s_r%d_i%d", gids[i], i, idxReps) + data := trplSets[i] + bes = append(bes, &runtime.BenchEntry{ + BatteryID: "Add existing triples", + ID: fmt.Sprintf("%s, reps=%02d", ids[i], r), + Triples: gSizes[i], + Reps: r, + Setup: func() error { + var err error + g, err = st.NewGraph(ctx, gID) + if err != nil { + return err + } + return g.AddTriples(ctx, data) + }, + F: func() error { + return g.AddTriples(ctx, data) + }, + TearDown: func() error { + return st.DeleteGraph(ctx, gID) + }, + }) + } + } + return bes, nil +} diff --git a/tools/benchmark/batteries/remove.go b/tools/benchmark/batteries/remove.go index 7cedf64d..1d9182d8 100644 --- a/tools/benchmark/batteries/remove.go +++ b/tools/benchmark/batteries/remove.go @@ -53,10 +53,10 @@ func RemoveTreeTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runti for i, max := 0, len(ids); i < max; i++ { for idxReps, r := range reps { var g storage.Graph - gID := fmt.Sprintf("add_tree_%s_r%d_i%d", gids[i], i, idxReps) + gID := fmt.Sprintf("remove_tree_%s_r%d_i%d", gids[i], i, idxReps) data := trplSets[i] bes = append(bes, &runtime.BenchEntry{ - BatteryID: "Remove triples", + BatteryID: "Remove non-existing triples", ID: fmt.Sprintf("%s, reps=%02d", ids[i], r), Triples: gSizes[i], Reps: r, @@ -77,6 +77,62 @@ func RemoveTreeTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runti return bes, nil } +// RemoveExistingTreeTriplesBenchmark creates the benchmark +func RemoveExistingTreeTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime.BenchEntry, error) { + bFactors := []int{2, 200} + sizes := []int{10, 1000, 100000} + var trplSets [][]*triple.Triple + var ids []string + var gids []string + var gSizes []int + gs, err := getTreeGenerators(bFactors) + if err != nil { + return nil, err + } + for idx, g := range gs { + for _, s := range sizes { + ts, err := g.Generate(s) + if err != nil { + return nil, err + } + trplSets = append(trplSets, ts) + ids = append(ids, fmt.Sprintf("etg branch_factor=%04d, size=%07d", bFactors[idx], s)) + gids = append(gids, fmt.Sprintf("b%d_s%d", bFactors[idx], s)) + gSizes = append(gSizes, s) + } + } + var bes []*runtime.BenchEntry + reps := []int{10} + for i, max := 0, len(ids); i < max; i++ { + for idxReps, r := range reps { + var g storage.Graph + gID := fmt.Sprintf("remove_existing_tree_%s_r%d_i%d", gids[i], i, idxReps) + data := trplSets[i] + bes = append(bes, &runtime.BenchEntry{ + BatteryID: "Remove existing triples", + ID: fmt.Sprintf("%s, reps=%02d", ids[i], r), + Triples: gSizes[i], + Reps: r, + Setup: func() error { + var err error + g, err = st.NewGraph(ctx, gID) + if err != nil { + return err + } + return g.AddTriples(ctx, data) + }, + F: func() error { + return g.RemoveTriples(ctx, data) + }, + TearDown: func() error { + return st.DeleteGraph(ctx, gID) + }, + }) + } + } + return bes, nil +} + // RemoveGraphTriplesBenchmark creates the benchmark func RemoveGraphTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime.BenchEntry, error) { nodes := []int{317, 1000} @@ -106,10 +162,10 @@ func RemoveGraphTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runt for i, max := 0, len(ids); i < max; i++ { for idxReps, r := range reps { var g storage.Graph - gID := fmt.Sprintf("add_graph_%s_r%d_i%d", gids[i], i, idxReps) + gID := fmt.Sprintf("remove_graph_%s_r%d_i%d", gids[i], i, idxReps) data := trplSets[i] bes = append(bes, &runtime.BenchEntry{ - BatteryID: "Remove triples", + BatteryID: "Remove non-existent triples", ID: fmt.Sprintf("%s, reps=%02d", ids[i], r), Triples: gSizes[i], Reps: r, @@ -129,3 +185,59 @@ func RemoveGraphTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runt } return bes, nil } + +// RemoveExistingGraphTriplesBenchmark creates the benchmark +func RemoveExistingGraphTriplesBenchmark(ctx context.Context, st storage.Store) ([]*runtime.BenchEntry, error) { + nodes := []int{317, 1000} + sizes := []int{10, 1000, 100000} + var trplSets [][]*triple.Triple + var ids []string + var gids []string + var gSizes []int + gs, err := getGraphGenerators(nodes) + if err != nil { + return nil, err + } + for idx, g := range gs { + for _, s := range sizes { + ts, err := g.Generate(s) + if err != nil { + return nil, err + } + trplSets = append(trplSets, ts) + ids = append(ids, fmt.Sprintf("rg nodes=%04d, size=%07d", nodes[idx], s)) + gids = append(gids, fmt.Sprintf("n%d_s%d", nodes[idx], s)) + gSizes = append(gSizes, s) + } + } + var bes []*runtime.BenchEntry + reps := []int{10} + for i, max := 0, len(ids); i < max; i++ { + for idxReps, r := range reps { + var g storage.Graph + gID := fmt.Sprintf("remove_existing_graph_%s_r%d_i%d", gids[i], i, idxReps) + data := trplSets[i] + bes = append(bes, &runtime.BenchEntry{ + BatteryID: "Remove existent triples", + ID: fmt.Sprintf("%s, reps=%02d", ids[i], r), + Triples: gSizes[i], + Reps: r, + Setup: func() error { + var err error + g, err = st.NewGraph(ctx, gID) + if err != nil { + return err + } + return g.AddTriples(ctx, data) + }, + F: func() error { + return g.RemoveTriples(ctx, data) + }, + TearDown: func() error { + return st.DeleteGraph(ctx, gID) + }, + }) + } + } + return bes, nil +} diff --git a/tools/vcli/bw/benchmark/benchmark.go b/tools/vcli/bw/benchmark/benchmark.go index 9196c4f9..9da7da89 100644 --- a/tools/vcli/bw/benchmark/benchmark.go +++ b/tools/vcli/bw/benchmark/benchmark.go @@ -48,9 +48,9 @@ a tree or a random graph generator.`, // runAll executes all the canned benchmarks and prints out the stats. func runAll(ctx context.Context, st storage.Store) int { // - Add non existing triples. (done) - // - Add triples that already exist. (todo) + // - Add triples that already exist. (done) // - Remove non existing triples. (done) - // - Remove existing triples. (todo) + // - Remove existing triples. (done) // - BQL tree walking from root. (todo) // - BQL random graph hopping. (todo) // - BQL sorting. (todo) @@ -61,11 +61,21 @@ func runAll(ctx context.Context, st storage.Store) int { var out int - out += runBattery(ctx, st, "adding unexistent tree triples", batteries.AddTreeTriplesBenchmark) - out += runBattery(ctx, st, "adding unexistent graph triples", batteries.AddGraphTriplesBenchmark) + // Add non existing triples. + out += runBattery(ctx, st, "adding unexisting tree triples", batteries.AddTreeTriplesBenchmark) + out += runBattery(ctx, st, "adding unexisting graph triples", batteries.AddGraphTriplesBenchmark) - out += runBattery(ctx, st, "removing unexistent tree triples", batteries.RemoveTreeTriplesBenchmark) - out += runBattery(ctx, st, "removing unexistent graph triples", batteries.RemoveGraphTriplesBenchmark) + // Add existing triples. + out += runBattery(ctx, st, "adding existing tree triples", batteries.AddExistingTreeTriplesBenchmark) + out += runBattery(ctx, st, "adding existing graph triples", batteries.AddExistingGraphTriplesBenchmark) + + // Remove non existing triples. + out += runBattery(ctx, st, "removing unexisting tree triples", batteries.RemoveTreeTriplesBenchmark) + out += runBattery(ctx, st, "removing unexisting graph triples", batteries.RemoveGraphTriplesBenchmark) + + // Remove existing triples. + out += runBattery(ctx, st, "removing existing tree triples", batteries.RemoveExistingTreeTriplesBenchmark) + out += runBattery(ctx, st, "removing existing graph triples", batteries.RemoveExistingGraphTriplesBenchmark) return out }