// GetGCMetadata reads the latest GC metadata for this range.
func (r *Range) GetGCMetadata() (*proto.GCMetadata, error) {
key := keys.RangeGCMetadataKey(r.Desc().RaftID)
gcMeta := &proto.GCMetadata{}
_, err := engine.MVCCGetProto(r.rm.Engine(), key, proto.ZeroTimestamp, true, nil, gcMeta)
if err != nil {
return nil, err
}
return gcMeta, nil
}
// InternalGC iterates through the list of keys to garbage collect
// specified in the arguments. MVCCGarbageCollect is invoked on each
// listed key along with the expiration timestamp. The GC metadata
// specified in the args is persisted after GC.
func (r *Range) InternalGC(batch engine.Engine, ms *engine.MVCCStats, args *proto.InternalGCRequest, reply *proto.InternalGCResponse) {
// Garbage collect the specified keys by expiration timestamps.
if err := engine.MVCCGarbageCollect(batch, ms, args.Keys, args.Timestamp); err != nil {
reply.SetGoError(err)
return
}
// Store the GC metadata for this range.
key := keys.RangeGCMetadataKey(r.Desc().RaftID)
err := engine.MVCCPutProto(batch, ms, key, proto.ZeroTimestamp, nil, &args.GCMeta)
reply.SetGoError(err)
}
// InternalGC iterates through the list of keys to garbage collect
// specified in the arguments. MVCCGarbageCollect is invoked on each
// listed key along with the expiration timestamp. The GC metadata
// specified in the args is persisted after GC.
func (r *Range) InternalGC(batch engine.Engine, ms *engine.MVCCStats, args proto.InternalGCRequest) (proto.InternalGCResponse, error) {
var reply proto.InternalGCResponse
// Garbage collect the specified keys by expiration timestamps.
if err := engine.MVCCGarbageCollect(batch, ms, args.Keys, args.Timestamp); err != nil {
return reply, err
}
// Store the GC metadata for this range.
key := keys.RangeGCMetadataKey(r.Desc().RaftID)
if err := engine.MVCCPutProto(batch, ms, key, proto.ZeroTimestamp, nil, &args.GCMeta); err != nil {
return reply, err
}
return reply, nil
}
// createRangeData creates sample range data in all possible areas of
// the key space. Returns a slice of the encoded keys of all created
// data.
func createRangeData(r *Replica, t *testing.T) []roachpb.EncodedKey {
ts0 := roachpb.ZeroTimestamp
ts := roachpb.Timestamp{WallTime: 1}
keyTSs := []struct {
key roachpb.Key
ts roachpb.Timestamp
}{
{keys.ResponseCacheKey(r.Desc().RangeID, &roachpb.ClientCmdID{WallTime: 1, Random: 1}), ts0},
{keys.ResponseCacheKey(r.Desc().RangeID, &roachpb.ClientCmdID{WallTime: 2, Random: 2}), ts0},
{keys.RaftHardStateKey(r.Desc().RangeID), ts0},
{keys.RaftLogKey(r.Desc().RangeID, 1), ts0},
{keys.RaftLogKey(r.Desc().RangeID, 2), ts0},
{keys.RangeGCMetadataKey(r.Desc().RangeID), ts0},
{keys.RangeLastVerificationTimestampKey(r.Desc().RangeID), ts0},
{keys.RangeStatsKey(r.Desc().RangeID), ts0},
{keys.RangeDescriptorKey(r.Desc().StartKey), ts},
{keys.TransactionKey(roachpb.Key(r.Desc().StartKey), []byte("1234")), ts0},
{keys.TransactionKey(roachpb.Key(r.Desc().StartKey.Next()), []byte("5678")), ts0},
{keys.TransactionKey(fakePrevKey(r.Desc().EndKey), []byte("2468")), ts0},
// TODO(bdarnell): KeyMin.Next() results in a key in the reserved system-local space.
// Once we have resolved https://github.com/cockroachdb/cockroach/issues/437,
// replace this with something that reliably generates the first valid key in the range.
//{r.Desc().StartKey.Next(), ts},
// The following line is similar to StartKey.Next() but adds more to the key to
// avoid falling into the system-local space.
{append(append([]byte{}, r.Desc().StartKey...), '\x01'), ts},
{fakePrevKey(r.Desc().EndKey), ts},
}
keys := []roachpb.EncodedKey{}
for _, keyTS := range keyTSs {
if err := engine.MVCCPut(r.store.Engine(), nil, keyTS.key, keyTS.ts, roachpb.MakeValueFromString("value"), nil); err != nil {
t.Fatal(err)
}
keys = append(keys, engine.MVCCEncodeKey(keyTS.key))
if !keyTS.ts.Equal(ts0) {
keys = append(keys, engine.MVCCEncodeVersionKey(keyTS.key, keyTS.ts))
}
}
return keys
}
// TestGCQueueShouldQueue verifies conditions which inform priority
// and whether or not the range should be queued into the GC queue.
// Ranges are queued for GC based on two conditions. The age of bytes
// available to be GC'd, and the age of unresolved intents.
func TestGCQueueShouldQueue(t *testing.T) {
defer leaktest.AfterTest(t)
tc := testContext{}
tc.Start(t)
defer tc.Stop()
// Put an empty GC metadata; all that's read from it is last scan nanos.
key := keys.RangeGCMetadataKey(tc.rng.Desc().RaftID)
if err := engine.MVCCPutProto(tc.rng.rm.Engine(), nil, key, proto.ZeroTimestamp, nil, &proto.GCMetadata{}); err != nil {
t.Fatal(err)
}
iaN := intentAgeNormalization.Nanoseconds()
ia := iaN / 1E9
bc := int64(gcByteCountNormalization)
ttl := int64(24 * 60 * 60)
testCases := []struct {
gcBytes int64
gcBytesAge int64
intentCount int64
intentAge int64
now proto.Timestamp
shouldQ bool
priority float64
}{
// No GC'able bytes, no time elapsed.
{0, 0, 0, 0, makeTS(0, 0), false, 0},
// No GC'able bytes, with intent age, 1/2 intent normalization period elapsed.
{0, 0, 1, ia / 2, makeTS(0, 0), false, 0},
// No GC'able bytes, with intent age=1/2 period, and other 1/2 period elapsed.
{0, 0, 1, ia / 2, makeTS(iaN/2, 0), false, 0},
// No GC'able bytes, with intent age=2*intent normalization.
{0, 0, 1, 3 * ia / 2, makeTS(iaN/2, 0), true, 2},
// No GC'able bytes, 2 intents, with avg intent age=4x intent normalization.
{0, 0, 2, 7 * ia, makeTS(iaN, 0), true, 4.5},
// GC'able bytes, no time elapsed.
{bc, 0, 0, 0, makeTS(0, 0), false, 0},
// GC'able bytes, avg age = TTLSeconds.
{bc, bc * ttl, 0, 0, makeTS(0, 0), false, 0},
// GC'able bytes, avg age = 2*TTLSeconds.
{bc, 2 * bc * ttl, 0, 0, makeTS(0, 0), true, 2},
// x2 GC'able bytes, avg age = TTLSeconds.
{2 * bc, 2 * bc * ttl, 0, 0, makeTS(0, 0), true, 2},
// GC'able bytes, intent bytes, and intent normalization * 2 elapsed.
{bc, bc * ttl, 1, 0, makeTS(iaN*2, 0), true, 5},
}
gcQ := newGCQueue()
for i, test := range testCases {
// Write gc'able bytes as key bytes; since "live" bytes will be
// zero, this will translate into non live bytes. Also write
// intent count. Note: the actual accounting on bytes is fictional
// in this test.
stats := engine.MVCCStats{
KeyBytes: test.gcBytes,
IntentCount: test.intentCount,
IntentAge: test.intentAge,
GCBytesAge: test.gcBytesAge,
}
if err := tc.rng.stats.SetMVCCStats(tc.rng.rm.Engine(), stats); err != nil {
t.Fatal(err)
}
shouldQ, priority := gcQ.shouldQueue(test.now, tc.rng)
if shouldQ != test.shouldQ {
t.Errorf("%d: should queue expected %t; got %t", i, test.shouldQ, shouldQ)
}
if math.Abs(priority-test.priority) > 0.00001 {
t.Errorf("%d: priority expected %f; got %f", i, test.priority, priority)
}
}
}
// splitTrigger is called on a successful commit of an AdminSplit
// transaction. It copies the response cache for the new range and
// recomputes stats for both the existing, updated range and the new
// range.
func (r *Range) splitTrigger(batch engine.Engine, split *proto.SplitTrigger) error {
if !bytes.Equal(r.Desc().StartKey, split.UpdatedDesc.StartKey) ||
!bytes.Equal(r.Desc().EndKey, split.NewDesc.EndKey) {
return util.Errorf("range does not match splits: (%s-%s) + (%s-%s) != %s",
split.UpdatedDesc.StartKey, split.UpdatedDesc.EndKey,
split.NewDesc.StartKey, split.NewDesc.EndKey, r)
}
// Copy the GC metadata.
gcMeta, err := r.GetGCMetadata()
if err != nil {
return util.Errorf("unable to fetch GC metadata: %s", err)
}
if err := engine.MVCCPutProto(batch, nil, keys.RangeGCMetadataKey(split.NewDesc.RaftID), proto.ZeroTimestamp, nil, gcMeta); err != nil {
return util.Errorf("unable to copy GC metadata: %s", err)
}
// Copy the last verification timestamp.
verifyTS, err := r.GetLastVerificationTimestamp()
if err != nil {
return util.Errorf("unable to fetch last verification timestamp: %s", err)
}
if err := engine.MVCCPutProto(batch, nil, keys.RangeLastVerificationTimestampKey(split.NewDesc.RaftID), proto.ZeroTimestamp, nil, &verifyTS); err != nil {
return util.Errorf("unable to copy last verification timestamp: %s", err)
}
// Compute stats for updated range.
now := r.rm.Clock().Timestamp()
iter := newRangeDataIterator(&split.UpdatedDesc, batch)
ms, err := engine.MVCCComputeStats(iter, now.WallTime)
iter.Close()
if err != nil {
return util.Errorf("unable to compute stats for updated range after split: %s", err)
}
if err := r.stats.SetMVCCStats(batch, ms); err != nil {
return util.Errorf("unable to write MVCC stats: %s", err)
}
// Initialize the new range's response cache by copying the original's.
if err = r.respCache.CopyInto(batch, split.NewDesc.RaftID); err != nil {
return util.Errorf("unable to copy response cache to new split range: %s", err)
}
// Add the new split range to the store. This step atomically
// updates the EndKey of the updated range and also adds the
// new range to the store's range map.
newRng, err := NewRange(&split.NewDesc, r.rm)
if err != nil {
return err
}
// Compute stats for new range.
iter = newRangeDataIterator(&split.NewDesc, batch)
ms, err = engine.MVCCComputeStats(iter, now.WallTime)
iter.Close()
if err != nil {
return util.Errorf("unable to compute stats for new range after split: %s", err)
}
if err = newRng.stats.SetMVCCStats(batch, ms); err != nil {
return util.Errorf("unable to write MVCC stats: %s", err)
}
// Copy the timestamp cache into the new range.
r.Lock()
r.tsCache.MergeInto(newRng.tsCache, true /* clear */)
r.Unlock()
batch.Defer(func() {
if err := r.rm.SplitRange(r, newRng); err != nil {
// Our in-memory state has diverged from the on-disk state.
log.Fatalf("failed to update Store after split: %s", err)
}
})
return nil
}