test compares normal vs canceled compaction times

Signed-off-by: Krasi Georgiev <kgeorgie@redhat.com>
This commit is contained in:
Krasi Georgiev 2019-01-24 12:48:56 +02:00
parent 9874377ead
commit 9638c13ec8

View file

@ -15,6 +15,7 @@ package tsdb
import ( import (
"context" "context"
"fmt"
"io/ioutil" "io/ioutil"
"math" "math"
"os" "os"
@ -747,17 +748,50 @@ func TestDisableAutoCompactions(t *testing.T) {
// TestCancelCompactions ensures that when the db is closed // TestCancelCompactions ensures that when the db is closed
// any running compaction is cancelled to unblock closing the db. // any running compaction is cancelled to unblock closing the db.
func TestCancelCompactions(t *testing.T) { func TestCancelCompactions(t *testing.T) {
tmpdir, err := ioutil.TempDir("", "test") createTestDb := func() (*DB, func()) {
tmpdir, err := ioutil.TempDir("", "testCancelCompaction")
testutil.Ok(t, err) testutil.Ok(t, err)
defer os.RemoveAll(tmpdir)
// Create some blocks to fall within the compaction range. // Create some blocks to fall within the compaction range.
createBlock(t, tmpdir, 3000, 0, 1000) createBlock(t, tmpdir, 4000, 0, 1000)
createBlock(t, tmpdir, 3000, 1000, 2000) createBlock(t, tmpdir, 4000, 1000, 2000)
createBlock(t, tmpdir, 1, 2000, 2001) // The most recent block is ignored so can be e small one. createBlock(t, tmpdir, 1, 2000, 2001) // The most recent block is ignored so can be e small one.
db, err := Open(tmpdir, log.NewNopLogger(), nil, &Options{BlockRanges: []int64{1, 2000}}) db, err := Open(tmpdir, log.NewNopLogger(), nil, &Options{BlockRanges: []int64{1, 2000}})
testutil.Ok(t, err) testutil.Ok(t, err)
testutil.Equals(t, 3, len(db.Blocks()), "initial block count mismatch")
testutil.Equals(t, 0.0, prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.ran), "initial compaction counter mismatch")
return db, func() {
os.RemoveAll(tmpdir)
}
}
// First lets mesure the compaction time without interupting it.
var timeCompactionUninterrupted time.Duration
{
db, delete := createTestDb()
defer delete()
db.compactc <- struct{}{} // Trigger a compaction.
var start time.Time
for {
if prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.populatingBlocks) > 0 {
start = time.Now()
break
}
time.Sleep(3 * time.Millisecond)
}
for {
if prom_testutil.ToFloat64(db.compactor.(*LeveledCompactor).metrics.ran) == 1 {
timeCompactionUninterrupted = time.Since(start)
break
}
time.Sleep(3 * time.Millisecond)
}
}
// Closing the db in the middle of compaction should take half the time.
{
db, delete := createTestDb()
defer delete()
db.compactc <- struct{}{} // Trigger a compaction. db.compactc <- struct{}{} // Trigger a compaction.
dbClosed := make(chan struct{}) dbClosed := make(chan struct{})
@ -775,6 +809,9 @@ func TestCancelCompactions(t *testing.T) {
start := time.Now() start := time.Now()
<-dbClosed <-dbClosed
actT := time.Since(start) actT := time.Since(start)
expT := time.Duration(100000000) fmt.Println(timeCompactionUninterrupted)
fmt.Println(actT)
expT := time.Duration(timeCompactionUninterrupted / 2)
testutil.Assert(t, actT < expT, "closing the db took more than expected. exp: <%v, act: %v", expT, actT) testutil.Assert(t, actT < expT, "closing the db took more than expected. exp: <%v, act: %v", expT, actT)
}
} }