couchbase / moss / 165

pending completion

Build # 165

Build Type

push

travis-ci

Committed by

abhinavdangeti

Commit Message

mossScope: Unit tests for "mossScope stats"

+ TestLatestFooterStats
+ TestFragmentationStats

Change-Id: Iaf8c94968
Reviewed-on: http://review.couchbase.org/72823
Reviewed-by: Steve Yen <steve.yen@gmail.com>
Tested-by: abhinav dangeti <abhinav@couchbase.com>

Run Details

8 of 8 new or added lines in 2 files covered. (100.0%)

2640 of 3310 relevant lines covered (79.76%)

8788.6 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.82

/segment_stack_merge.go

//  Copyright (c) 2016 Couchbase, Inc.
//  Licensed under the Apache License, Version 2.0 (the "License");
//  you may not use this file except in compliance with the
//  License. You may obtain a copy of the License at
//    http://www.apache.org/licenses/LICENSE-2.0
//  Unless required by applicable law or agreed to in writing,
//  software distributed under the License is distributed on an "AS
//  IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
//  express or implied. See the License for the specific language
//  governing permissions and limitations under the License.

package moss

// calcTargetTopLevel() heuristically computes a new top level that
// the segmentStack should be merged to.
func (ss *segmentStack) calcTargetTopLevel() int {
        var minMergePercentage float64
        if ss.options != nil {
                minMergePercentage = ss.options.MinMergePercentage
        }
        if minMergePercentage <= 0 {
                minMergePercentage = DefaultCollectionOptions.MinMergePercentage
        }

        newTopLevel := 0
        maxTopLevel := len(ss.a) - 2

        for newTopLevel < maxTopLevel {
                numX0 := ss.a[newTopLevel].Len()
                numX1 := ss.a[newTopLevel+1].Len()
                if (float64(numX1) / float64(numX0)) > minMergePercentage {
                        break
                }

                newTopLevel++
        }

        return newTopLevel
}

// ------------------------------------------------------

// merge() returns a new segmentStack, merging all the segments that
// are at the given newTopLevel and higher.
func (ss *segmentStack) merge(newTopLevel int, base *segmentStack) (
        *segmentStack, error) {
        // ----------------------------------------------------
        // First, rough estimate the bytes neeeded.

        var totOps int
        var totKeyBytes, totValBytes uint64
        for i := newTopLevel; i < len(ss.a); i++ {
                totOps += ss.a[i].Len()
                nk, nv := ss.a[i].NumKeyValBytes()
                totKeyBytes += nk
                totValBytes += nv
        }

        // ----------------------------------------------------
        // Next, use an iterator for the actual merge.

        mergedSegment, err := newSegment(totOps, int(totKeyBytes+totValBytes))
        if err != nil {
                return nil, err
        }

        err = ss.mergeInto(newTopLevel, len(ss.a), mergedSegment, base, true, true, nil)
        if err != nil {
                return nil, err
        }

        a := make([]Segment, 0, newTopLevel+1)
        a = append(a, ss.a[0:newTopLevel]...)
        a = append(a, mergedSegment)

        return &segmentStack{
                options:            ss.options,
                a:                  a,
                refs:               1,
                lowerLevelSnapshot: ss.lowerLevelSnapshot.addRef(),
        }, nil
}

func (ss *segmentStack) mergeInto(minSegmentLevel, maxSegmentHeight int,
        dest SegmentMutator, base *segmentStack, includeDeletions, optimizeTail bool,
        cancelCh chan error) error {
        cancelCheckEvery := ss.options.MergerCancelCheckEvery
        if cancelCheckEvery <= 0 {
                cancelCheckEvery = DefaultCollectionOptions.MergerCancelCheckEvery
        }

        iter, err := ss.startIterator(nil, nil, IteratorOptions{
                IncludeDeletions: includeDeletions,
                SkipLowerLevel:   true,
                MinSegmentLevel:  minSegmentLevel,
                MaxSegmentHeight: maxSegmentHeight,
                base:             base,
        })
        if err != nil {
                return err
        }

        defer iter.Close()

        readOptions := ReadOptions{NoCopyValue: true}

OUTER:
        for i := 0; true; i++ {
                if cancelCh != nil && i%cancelCheckEvery == 0 {
                        select {
                        case cancelErr := <-cancelCh:
                                return cancelErr
                        default:
                                // NO-OP.
                        }
                }

                entryEx, key, val, err := iter.CurrentEx()
                if err == ErrIteratorDone {
                        break
                }
                if err != nil {
                        return err
                }

                if optimizeTail && len(iter.cursors) == 1 {
                        // When only 1 cursor remains, copy the remains of the
                        // last segment more directly instead of Next()'ing
                        // through the iterator.
                        cursor := iter.cursors[0]

                        segment := iter.ss.a[cursor.ssIndex]
                        segmentOps := segment.Len()

                        for pos := cursor.pos; pos < segmentOps; pos++ {
                                op, k, v := segment.GetOperationKeyVal(pos)

                                err = dest.Mutate(op, k, v)
                                if err != nil {
                                        return err
                                }
                        }

                        break OUTER
                }

                op := entryEx.Operation
                if op == OperationMerge {
                        // TODO: the merge operator implementation is currently
                        // inefficient and not lazy enough right now.
                        val, err = ss.get(key, len(ss.a)-1, base, readOptions)
                        if err != nil {
                                return err
                        }

                        if val == nil {
                                op = OperationDel
                        } else {
                                op = OperationSet
                        }
                }

                err = dest.Mutate(op, key, val)
                if err != nil {
                        return err
                }

                err = iter.Next()
                if err == ErrIteratorDone {
                        break
                }
                if err != nil {
                        return err
                }
        }

        return nil
}

1	// Copyright (c) 2016 Couchbase, Inc.
2	// Licensed under the Apache License, Version 2.0 (the "License");
3	// you may not use this file except in compliance with the
4	// License. You may obtain a copy of the License at
5	// http://www.apache.org/licenses/LICENSE-2.0
6	// Unless required by applicable law or agreed to in writing,
7	// software distributed under the License is distributed on an "AS
8	// IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
9	// express or implied. See the License for the specific language
10	// governing permissions and limitations under the License.
11
12	package moss
13
14	// calcTargetTopLevel() heuristically computes a new top level that
15	// the segmentStack should be merged to.
16	func (ss *segmentStack) calcTargetTopLevel() int {	38✔
17	var minMergePercentage float64	38✔
18	if ss.options != nil {	76✔
19	minMergePercentage = ss.options.MinMergePercentage	38✔
20	}	38✔
21	if minMergePercentage <= 0 {	76✔
22	minMergePercentage = DefaultCollectionOptions.MinMergePercentage	38✔
23	}	38✔
24
25	newTopLevel := 0	38✔
26	maxTopLevel := len(ss.a) - 2	38✔
27		38✔
28	for newTopLevel < maxTopLevel {	48✔
29	numX0 := ss.a[newTopLevel].Len()	10✔
30	numX1 := ss.a[newTopLevel+1].Len()	10✔
31	if (float64(numX1) / float64(numX0)) > minMergePercentage {	20✔
32	break	10✔
33	}
34
35	newTopLevel++	×
36	}
37
38	return newTopLevel	38✔
39	}
40
41	// ------------------------------------------------------
42
43	// merge() returns a new segmentStack, merging all the segments that
44	// are at the given newTopLevel and higher.
45	func (ss segmentStack) merge(newTopLevel int, base segmentStack) (
46	*segmentStack, error) {	43✔
47	// ----------------------------------------------------	43✔
48	// First, rough estimate the bytes neeeded.	43✔
49		43✔
50	var totOps int	43✔
51	var totKeyBytes, totValBytes uint64	43✔
52	for i := newTopLevel; i < len(ss.a); i++ {	156✔
53	totOps += ss.a[i].Len()	113✔
54	nk, nv := ss.a[i].NumKeyValBytes()	113✔
55	totKeyBytes += nk	113✔
56	totValBytes += nv	113✔
57	}	113✔
58
59	// ----------------------------------------------------
60	// Next, use an iterator for the actual merge.
61
62	mergedSegment, err := newSegment(totOps, int(totKeyBytes+totValBytes))	43✔
63	if err != nil {	43✔
64	return nil, err	×
65	}	×
66
67	err = ss.mergeInto(newTopLevel, len(ss.a), mergedSegment, base, true, true, nil)	43✔
68	if err != nil {	43✔
69	return nil, err	×
70	}	×
71
72	a := make([]Segment, 0, newTopLevel+1)	43✔
73	a = append(a, ss.a[0:newTopLevel]...)	43✔
74	a = append(a, mergedSegment)	43✔
75		43✔
76	return &segmentStack{	43✔
77	options: ss.options,	43✔
78	a: a,	43✔
79	refs: 1,	43✔
80	lowerLevelSnapshot: ss.lowerLevelSnapshot.addRef(),	43✔
81	}, nil	43✔
82	}
83
84	func (ss *segmentStack) mergeInto(minSegmentLevel, maxSegmentHeight int,
85	dest SegmentMutator, base *segmentStack, includeDeletions, optimizeTail bool,
86	cancelCh chan error) error {	117✔
87	cancelCheckEvery := ss.options.MergerCancelCheckEvery	117✔
88	if cancelCheckEvery <= 0 {	234✔
89	cancelCheckEvery = DefaultCollectionOptions.MergerCancelCheckEvery	117✔
90	}	117✔
91
92	iter, err := ss.startIterator(nil, nil, IteratorOptions{	117✔
93	IncludeDeletions: includeDeletions,	117✔
94	SkipLowerLevel: true,	117✔
95	MinSegmentLevel: minSegmentLevel,	117✔
96	MaxSegmentHeight: maxSegmentHeight,	117✔
97	base: base,	117✔
98	})	117✔
99	if err != nil {	117✔
100	return err	×
101	}	×
102
103	defer iter.Close()	117✔
104		117✔
105	readOptions := ReadOptions{NoCopyValue: true}	117✔
106		117✔
107	OUTER:	117✔
108	for i := 0; true; i++ {	75,823✔
109	if cancelCh != nil && i%cancelCheckEvery == 0 {	75,706✔
110	select {	×
111	case cancelErr := <-cancelCh:	×
112	return cancelErr	×
113	default:	×
114	// NO-OP.
115	}
116	}
117
118	entryEx, key, val, err := iter.CurrentEx()	75,706✔
119	if err == ErrIteratorDone {	75,711✔
120	break	5✔
121	}
122	if err != nil {	75,701✔
123	return err	×
124	}	×
125
126	if optimizeTail && len(iter.cursors) == 1 {	75,724✔
127	// When only 1 cursor remains, copy the remains of the	23✔
128	// last segment more directly instead of Next()'ing	23✔
129	// through the iterator.	23✔
130	cursor := iter.cursors[0]	23✔
131		23✔
132	segment := iter.ss.a[cursor.ssIndex]	23✔
133	segmentOps := segment.Len()	23✔
134		23✔
135	for pos := cursor.pos; pos < segmentOps; pos++ {	100✔
136	op, k, v := segment.GetOperationKeyVal(pos)	77✔
137		77✔
138	err = dest.Mutate(op, k, v)	77✔
139	if err != nil {	77✔
140	return err	×
141	}	×
142	}
143
144	break OUTER	23✔
145	}
146
147	op := entryEx.Operation	75,678✔
148	if op == OperationMerge {	75,685✔
149	// TODO: the merge operator implementation is currently	7✔
150	// inefficient and not lazy enough right now.	7✔
151	val, err = ss.get(key, len(ss.a)-1, base, readOptions)	7✔
152	if err != nil {	7✔
153	return err	×
154	}	×
155
156	if val == nil {	7✔
157	op = OperationDel	×
158	} else {	7✔
159	op = OperationSet	7✔
160	}	7✔
161	}
162
163	err = dest.Mutate(op, key, val)	75,678✔
164	if err != nil {	75,678✔
165	return err	×
166	}	×
167
168	err = iter.Next()	75,678✔
169	if err == ErrIteratorDone {	75,767✔
170	break	89✔
171	}
172	if err != nil {	75,589✔
173	return err	×
174	}	×
175	}
176
177	return nil	117✔
178	}

couchbase / moss / 165

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous