// SomeChunksP invokes callbacks on every unique chunk reachable from |r| in top-down order. Callbacks are invoked only once for each chunk regardless of how many times the chunk appears.
//
// |stopCb| is invoked for the types.Ref of every chunk. It can return true to stop SomeChunksP from descending any further.
// |chunkCb| is optional, invoked with the chunks.Chunk referenced by |stopCb| if it didn't return true.
func SomeChunksP(r types.Ref, bs types.BatchStore, stopCb SomeChunksStopCallback, chunkCb SomeChunksChunkCallback, concurrency int) {
rq := newRefQueue()
wg := sync.WaitGroup{}
mu := sync.Mutex{}
visitedRefs := map[hash.Hash]bool{}
walkChunk := func(r types.Ref) {
defer wg.Done()
tr := r.TargetHash()
mu.Lock()
visited := visitedRefs[tr]
visitedRefs[tr] = true
mu.Unlock()
if visited || stopCb(r) {
return
}
// Try to avoid the cost of reading |c|. It's only necessary if the caller wants to know about every chunk, or if we need to descend below |c| (ref height > 1).
var c chunks.Chunk
if chunkCb != nil || r.Height() > 1 {
c = bs.Get(tr)
d.Chk.False(c.IsEmpty())
if chunkCb != nil {
chunkCb(r, c)
}
}
if r.Height() == 1 {
return
}
v := types.DecodeValue(c, nil)
for _, r1 := range v.Chunks() {
wg.Add(1)
rq.tail() <- r1
}
}
iter := func() {
for r := range rq.head() {
walkChunk(r)
}
}
for i := 0; i < concurrency; i++ {
go iter()
}
wg.Add(1)
rq.tail() <- r
wg.Wait()
rq.close()
}
func traverseSource(srcRef types.Ref, srcDB, sinkDB Database) traverseResult {
h := srcRef.TargetHash()
if !sinkDB.has(h) {
srcBS := srcDB.validatingBatchStore()
c := srcBS.Get(h)
v := types.DecodeValue(c, srcDB)
d.Chk.True(v != nil, "Expected decoded chunk to be non-nil.")
sinkDB.validatingBatchStore().SchedulePut(c, srcRef.Height(), types.Hints{})
return traverseResult{h, v.Chunks(), len(c.Data())}
}
return traverseResult{}
}
func traverseCommon(comRef, sinkHead types.Ref, db Database) traverseResult {
if comRef.Height() > 1 && isRefOfCommitType(comRef.Type()) {
commit := comRef.TargetValue(db).(types.Struct)
// We don't want to traverse the parents of sinkHead, but we still want to traverse its Value on the sinkDB side. We also still want to traverse all children, in both the srcDB and sinkDB, of any common Commit that is not at the Head of sinkDB.
exclusionSet := types.NewSet()
if comRef.Equals(sinkHead) {
exclusionSet = commit.Get(ParentsField).(types.Set)
}
chunks := types.RefSlice(commit.Chunks())
for i := 0; i < len(chunks); {
if exclusionSet.Has(chunks[i]) {
end := len(chunks) - 1
chunks.Swap(i, end)
chunks = chunks[:end]
continue
}
i++
}
return traverseResult{comRef.TargetHash(), chunks, 0}
}
return traverseResult{}
}
func traverseSink(sinkRef types.Ref, db Database) traverseResult {
if sinkRef.Height() > 1 {
return traverseResult{sinkRef.TargetHash(), sinkRef.TargetValue(db).Chunks(), 0}
}
return traverseResult{}
}