Don't need to store the end time of every small chunk

We can look at the start time of the next one since they don't
overlap.
This makes the data structure slightly smaller, and speeds up
unmarshalling since we don't need to seek through every value.

Signed-off-by: Bryan Boreham <[email protected]>

Author: bboreham

pkg/chunk/encoding/bigchunk.go

@@ -17,13 +17,13 @@ var errOutOfBounds = errors.New("out of bounds")
 type smallChunk struct {
 	chunkenc.XORChunk
 	start int64
-	end   int64
 }
 
 // bigchunk is a set of prometheus/tsdb chunks.  It grows over time and has no
 // upperbound on number of samples it can contain.
 type bigchunk struct {
 	chunks []smallChunk
+	end    int64
 
 	appender         chunkenc.Appender
 	remainingSamples int
@@ -45,7 +45,7 @@ func (b *bigchunk) Add(sample model.SamplePair) ([]Chunk, error) {
 
 	b.appender.Append(int64(sample.Timestamp), float64(sample.Value))
 	b.remainingSamples--
-	b.chunks[len(b.chunks)-1].end = int64(sample.Timestamp)
+	b.end = int64(sample.Timestamp)
 	return []Chunk{b}, nil
 }
 
@@ -70,7 +70,6 @@ func (b *bigchunk) addNextChunk(start model.Time) error {
 	b.chunks = append(b.chunks, smallChunk{
 		XORChunk: *chunkenc.NewXORChunk(),
 		start:    int64(start),
-		end:      int64(start),
 	})
 
 	appender, err := b.chunks[len(b.chunks)-1].Appender()
@@ -128,15 +127,14 @@ func (b *bigchunk) UnmarshalFromBuf(buf []byte) error {
 			return err
 		}
 
-		start, end, err := firstAndLastTimes(chunk)
+		start, err := firstTime(chunk)
 		if err != nil {
 			return err
 		}
 
 		b.chunks = append(b.chunks, smallChunk{
 			XORChunk: *chunk.(*chunkenc.XORChunk),
 			start:    int64(start),
-			end:      int64(end),
 		})
 	}
 	return nil
@@ -183,8 +181,8 @@ func (b *bigchunk) NewIterator() Iterator {
 func (b *bigchunk) Slice(start, end model.Time) Chunk {
 	i, j := 0, len(b.chunks)
 	for k := 0; k < len(b.chunks); k++ {
-		if b.chunks[k].end < int64(start) {
-			i = k + 1
+		if b.chunks[k].start <= int64(start) {
+			i = k
 		}
 		if b.chunks[k].start > int64(end) {
 			j = k
@@ -238,22 +236,19 @@ type bigchunkIterator struct {
 }
 
 func (it *bigchunkIterator) FindAtOrAfter(target model.Time) bool {
-	if it.i >= len(it.chunks) {
+	if it.i >= len(it.chunks) || int64(target) > it.end {
 		return false
 	}
 
 	// If the seek is outside the current chunk, use the index to find the right
 	// chunk.
-	if int64(target) < it.chunks[it.i].start || int64(target) > it.chunks[it.i].end {
+	if int64(target) < it.chunks[it.i].start ||
+		(it.i+1 < len(it.chunks) && int64(target) >= it.chunks[it.i+1].start) {
 		it.curr = nil
-		for it.i = 0; it.i < len(it.chunks) && int64(target) > it.chunks[it.i].end; it.i++ {
+		for it.i = 0; it.i+1 < len(it.chunks) && int64(target) >= it.chunks[it.i+1].start; it.i++ {
 		}
 	}
 
-	if it.i >= len(it.chunks) {
-		return false
-	}
-
 	if it.curr == nil {
 		it.curr = it.chunks[it.i].Iterator()
 	} else if t, _ := it.curr.At(); int64(target) <= t {
@@ -319,20 +314,13 @@ func (it *bigchunkIterator) Err() error {
 	return nil
 }
 
-func firstAndLastTimes(c chunkenc.Chunk) (int64, int64, error) {
+func firstTime(c chunkenc.Chunk) (int64, error) {
 	var (
-		first    int64
-		last     int64
-		firstSet bool
-		iter     = c.Iterator()
+		first int64
+		iter  = c.Iterator()
 	)
-	for iter.Next() {
-		t, _ := iter.At()
-		if !firstSet {
-			first = t
-			firstSet = true
-		}
-		last = t
+	if iter.Next() {
+		first, _ = iter.At()
 	}
-	return first, last, iter.Err()
+	return first, iter.Err()
 }