← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/libktorrent/oneiric

« back to all changes in this revision

Viewing changes to src/diskio/cache.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Modestas Vainius
  • Date: 2011-05-26 00:33:38 UTC
  • mfrom: (5.1.7 experimental)
  • Revision ID: james.westby@ubuntu.com-20110526003338-2r4zwyzn8bovsxay
Tags: 1.1.1-2
Release to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/diskio/cache.cpp
46
46
 
47
47
        Cache::~Cache()
48
48
        {
49
 
                clearPieceCache();
 
49
                cleanupPieceCache();
 
50
        }
 
51
 
 
52
        void Cache::cleanupPieceCache()
 
53
        {
 
54
                PieceCache::iterator i = piece_cache.begin();
 
55
                while (i != piece_cache.end())
 
56
                {
 
57
                        i.value()->unload();
 
58
                        i++;
 
59
                }
 
60
                piece_cache.clear();
50
61
        }
51
62
 
52
63
 
76
87
                Q_UNUSED(job);
77
88
        }
78
89
        
79
 
        PieceDataPtr Cache::findPiece(Chunk* c,Uint32 off,Uint32 len)
 
90
        PieceData::Ptr Cache::findPiece(Chunk* c,Uint32 off,Uint32 len,bool read_only)
80
91
        {
81
 
                QMultiMap<Chunk*,PieceData*>::iterator i = piece_cache.find(c);
 
92
                PieceCache::iterator i = piece_cache.find(c);
82
93
                while (i != piece_cache.end() && i.key() == c)
83
94
                {
84
 
                        PieceData* cp = i.value();
85
 
                        if (cp->offset() == off && cp->length() == len)
86
 
                                return PieceDataPtr(cp);
 
95
                        PieceData::Ptr cp = i.value();
 
96
                        if (cp->offset() == off && cp->length() == len && !(!cp->writeable() && !read_only))
 
97
                                return PieceData::Ptr(cp);
87
98
                        i++;
88
99
                }
89
100
                
90
 
                return 0;
 
101
                return PieceData::Ptr();
91
102
        }
92
103
        
93
 
        void Cache::insertPiece(Chunk* c,PieceData* p)
 
104
        void Cache::insertPiece(Chunk* c,PieceData::Ptr p)
94
105
        {
95
106
                piece_cache.insert(c,p);
96
107
        }
97
108
        
98
109
        void Cache::clearPieces(Chunk* c)
99
110
        {
100
 
                QMultiMap<Chunk*,PieceData*>::iterator i = piece_cache.find(c);
 
111
                PieceCache::iterator i = piece_cache.find(c);
101
112
                while (i != piece_cache.end() && i.key() == c)
102
113
                {
103
 
                        PieceData* cp = i.value();
104
 
                        delete cp;
105
114
                        i = piece_cache.erase(i);
106
115
                }
107
116
        }
108
117
        
109
118
        void Cache::clearPieceCache()
110
119
        {
111
 
                QMultiMap<Chunk*,PieceData*>::iterator i = piece_cache.begin();
 
120
                PieceCache::iterator i = piece_cache.begin();
112
121
                while (i != piece_cache.end())
113
122
                {
114
 
                        PieceData* cp = i.value();
115
 
                        delete cp;
116
 
                        i++;
117
 
                }
118
 
                piece_cache.clear();
119
 
        }
120
 
 
121
 
        void Cache::clearPiece(PieceData* p)
122
 
        {
123
 
                Chunk* c = p->parentChunk();
124
 
                QMultiMap<Chunk*,PieceData*>::iterator i = piece_cache.find(p->parentChunk());
125
 
                while (i != piece_cache.end() && i.key() == c)
126
 
                {
127
 
                        if (i.value() == p)
128
 
                        {
129
 
                                PieceData* cp = i.value();
130
 
                                delete cp;
131
 
                                piece_cache.erase(i);
132
 
                                break;
133
 
                        }
134
 
                        i++;
 
123
                        if (!i.value()->inUse())
 
124
                                i = piece_cache.erase(i);
 
125
                        else
 
126
                                i++;
135
127
                }
136
128
        }
137
129
        
139
131
        {
140
132
                Uint64 mem = 0;
141
133
                Uint64 freed = 0;
142
 
                QMultiMap<Chunk*,PieceData*>::iterator i = piece_cache.begin();
 
134
                PieceCache::iterator i = piece_cache.begin();
143
135
                while (i != piece_cache.end())
144
136
                {
145
 
                        PieceData* cp = i.value();
146
 
                        if (!cp->inUse())
 
137
                        if (!i.value()->inUse())
147
138
                        {
148
 
                                freed += cp->length();
149
 
                                delete cp;
 
139
                                freed += i.value()->length();
150
140
                                i = piece_cache.erase(i);
151
141
                        }
152
142
                        else
153
143
                        {
154
 
                        //      Out(SYS_GEN|LOG_DEBUG) << "PieceCache: " << i.key()->getIndex() << " " << cp->offset() << " " << cp->length() << " " << cp->ref_count <<  endl;
155
 
                                mem += cp->length();
 
144
                                mem += i.value()->length();
156
145
                                i++;
157
146
                        }
158
147
                }