// 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 }