forked from anacrolix/torrent
/
piece.go
158 lines (129 loc) · 3.53 KB
/
piece.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package torrent
import (
"sync"
"github.com/anacrolix/missinggo/bitmap"
"github.com/anacrolix/torrent/metainfo"
pp "github.com/anacrolix/torrent/peer_protocol"
"github.com/anacrolix/torrent/storage"
)
// Piece priority describes the importance of obtaining a particular piece.
type piecePriority byte
func (pp *piecePriority) Raise(maybe piecePriority) {
if maybe > *pp {
*pp = maybe
}
}
const (
PiecePriorityNone piecePriority = iota // Not wanted.
PiecePriorityNormal // Wanted.
PiecePriorityReadahead // May be required soon.
PiecePriorityNext // Succeeds a piece where a read occurred.
PiecePriorityNow // A read occurred in this piece.
)
type piece struct {
// The completed piece SHA1 hash, from the metainfo "pieces" field.
Hash metainfo.Hash
t *Torrent
index int
// Chunks we've written to since the last check. The chunk offset and
// length can be determined by the request chunkSize in use.
DirtyChunks bitmap.Bitmap
Hashing bool
QueuedForHash bool
EverHashed bool
PublicPieceState PieceState
priority piecePriority
pendingWritesMutex sync.Mutex
pendingWrites int
noPendingWrites sync.Cond
}
func (p *piece) Info() metainfo.Piece {
return p.t.info.Piece(p.index)
}
func (p *piece) Storage() storage.Piece {
return p.t.storage.Piece(p.Info())
}
func (p *piece) pendingChunkIndex(chunkIndex int) bool {
return !p.DirtyChunks.Contains(chunkIndex)
}
func (p *piece) pendingChunk(cs chunkSpec, chunkSize pp.Integer) bool {
return p.pendingChunkIndex(chunkIndex(cs, chunkSize))
}
func (p *piece) hasDirtyChunks() bool {
return p.DirtyChunks.Len() != 0
}
func (p *piece) numDirtyChunks() (ret int) {
return p.DirtyChunks.Len()
}
func (p *piece) unpendChunkIndex(i int) {
p.DirtyChunks.Add(i)
}
func (p *piece) pendChunkIndex(i int) {
p.DirtyChunks.Remove(i)
}
func (p *piece) numChunks() int {
return p.t.pieceNumChunks(p.index)
}
func (p *piece) undirtiedChunkIndices() (ret bitmap.Bitmap) {
ret = p.DirtyChunks.Copy()
ret.FlipRange(0, p.numChunks())
return
}
func (p *piece) incrementPendingWrites() {
p.pendingWritesMutex.Lock()
p.pendingWrites++
p.pendingWritesMutex.Unlock()
}
func (p *piece) decrementPendingWrites() {
p.pendingWritesMutex.Lock()
if p.pendingWrites == 0 {
panic("assertion")
}
p.pendingWrites--
if p.pendingWrites == 0 {
p.noPendingWrites.Broadcast()
}
p.pendingWritesMutex.Unlock()
}
func (p *piece) waitNoPendingWrites() {
p.pendingWritesMutex.Lock()
for p.pendingWrites != 0 {
p.noPendingWrites.Wait()
}
p.pendingWritesMutex.Unlock()
}
func (p *piece) chunkIndexDirty(chunk int) bool {
return p.DirtyChunks.Contains(chunk)
}
func (p *piece) chunkIndexSpec(chunk int) chunkSpec {
return chunkIndexSpec(chunk, p.length(), p.chunkSize())
}
func (p *piece) numDirtyBytes() (ret pp.Integer) {
defer func() {
if ret > p.length() {
panic("too many dirty bytes")
}
}()
numRegularDirtyChunks := p.numDirtyChunks()
if p.chunkIndexDirty(p.numChunks() - 1) {
numRegularDirtyChunks--
ret += p.chunkIndexSpec(p.lastChunkIndex()).Length
}
ret += pp.Integer(numRegularDirtyChunks) * p.chunkSize()
return
}
func (p *piece) length() pp.Integer {
return p.t.pieceLength(p.index)
}
func (p *piece) chunkSize() pp.Integer {
return p.t.chunkSize
}
func (p *piece) lastChunkIndex() int {
return p.numChunks() - 1
}
func (p *piece) bytesLeft() (ret pp.Integer) {
if p.t.pieceComplete(p.index) {
return 0
}
return p.length() - p.numDirtyBytes()
}