github
/
aria2
mirror of https://github.com/aria2/aria2
1
0
Fork 0
Code Issues Releases Wiki Activity

MultiDiskAdaptor: Use std::unique_ptr for DiskWriterEntry and DiskWriter 

MultiFileAllocationIterator is also rewritten so that it does not
requre copying DiskWriterEntry objects.
pull/106/head
Tatsuhiro Tsujikawa 2013-07-05 21:08:24 +09:00
parent e823fe8bb5
commit f000fd0cab
12 changed files with 236 additions and 275 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
src/AnonDiskWriterFactory.h
View File

@ -36,6 +36,7 @@
#define D_ANON_DISK_WRITER_FACTORY_H #define D_ANON_DISK_WRITER_FACTORY_H
#include "DiskWriterFactory.h" #include "DiskWriterFactory.h"
#include "a2functional.h"
namespace aria2 { namespace aria2 {
@ -47,9 +48,9 @@ public:
AnonDiskWriterFactory() {} AnonDiskWriterFactory() {}
virtual ~AnonDiskWriterFactory() {} virtual ~AnonDiskWriterFactory() {}
virtual std::shared_ptr<DiskWriter> newDiskWriter(const std::string& filename) virtual std::unique_ptr<DiskWriter> newDiskWriter(const std::string& filename)
{ {
return std::shared_ptr<DiskWriter>(new DiskWriterType()); return make_unique<DiskWriterType>();
} }
}; };

5
src/DefaultDiskWriterFactory.cc
View File

@ -34,13 +34,14 @@
/* copyright --> */ /* copyright --> */
#include "DefaultDiskWriterFactory.h" #include "DefaultDiskWriterFactory.h"
#include "DefaultDiskWriter.h" #include "DefaultDiskWriter.h"
#include "a2functional.h"
namespace aria2 { namespace aria2 {
std::shared_ptr<DiskWriter> DefaultDiskWriterFactory::newDiskWriter std::unique_ptr<DiskWriter> DefaultDiskWriterFactory::newDiskWriter
(const std::string& filename) (const std::string& filename)
{ {
return std::shared_ptr<DiskWriter>(new DefaultDiskWriter(filename)); return make_unique<DefaultDiskWriter>(filename);
} }
} // namespace aria2 } // namespace aria2

3
src/DefaultDiskWriterFactory.h
View File

@ -44,7 +44,8 @@ class DiskWriter;
class DefaultDiskWriterFactory:public DiskWriterFactory class DefaultDiskWriterFactory:public DiskWriterFactory
{ {
public: public:
virtual std::shared_ptr<DiskWriter> newDiskWriter(const std::string& filename); virtual std::unique_ptr<DiskWriter> newDiskWriter
(const std::string& filename);
}; };
} // namespace aria2 } // namespace aria2

5
src/DefaultPieceStorage.cc
View File

@ -643,9 +643,8 @@ void DefaultPieceStorage::initStorage()
(downloadContext_->getFileEntries().begin(), (downloadContext_->getFileEntries().begin(),
downloadContext_->getFileEntries().end()); downloadContext_->getFileEntries().end());
std::shared_ptr<DiskWriter> writer = directDiskAdaptor->setDiskWriter
diskWriterFactory_->newDiskWriter(directDiskAdaptor->getFilePath()); (diskWriterFactory_->newDiskWriter(directDiskAdaptor->getFilePath()));
directDiskAdaptor->setDiskWriter(writer);
diskAdaptor_.reset(directDiskAdaptor); diskAdaptor_.reset(directDiskAdaptor);
} else { } else {
A2_LOG_DEBUG("Instantiating MultiDiskAdaptor"); A2_LOG_DEBUG("Instantiating MultiDiskAdaptor");

3
src/DiskWriterFactory.h
View File

@ -48,7 +48,8 @@ class DiskWriterFactory {
public: public:
virtual ~DiskWriterFactory() {} virtual ~DiskWriterFactory() {}
virtual std::shared_ptr<DiskWriter> newDiskWriter(const std::string& filename)=0; virtual std::unique_ptr<DiskWriter> newDiskWriter
(const std::string& filename)=0;
}; };
} // namespace aria2 } // namespace aria2

203
src/MultiDiskAdaptor.cc
View File

@ -55,9 +55,10 @@
namespace aria2 { namespace aria2 {
DiskWriterEntry::DiskWriterEntry(const std::shared_ptr<FileEntry>& fileEntry) DiskWriterEntry::DiskWriterEntry(const std::shared_ptr<FileEntry>& fileEntry)
: fileEntry_(fileEntry), : fileEntry_{fileEntry},
open_(false), open_{false},
needsFileAllocation_(false) needsFileAllocation_{false},
needsDiskWriter_{false}
{} {}
const std::string& DiskWriterEntry::getFilePath() const const std::string& DiskWriterEntry::getFilePath() const
@ -107,9 +108,9 @@ int64_t DiskWriterEntry::size() const
return File(getFilePath()).size(); return File(getFilePath()).size();
} }
void DiskWriterEntry::setDiskWriter(const std::shared_ptr<DiskWriter>& diskWriter) void DiskWriterEntry::setDiskWriter(std::unique_ptr<DiskWriter> diskWriter)
{ {
diskWriter_ = diskWriter; diskWriter_ = std::move(diskWriter);
} }
bool DiskWriterEntry::operator<(const DiskWriterEntry& entry) const bool DiskWriterEntry::operator<(const DiskWriterEntry& entry) const
@ -118,20 +119,19 @@ bool DiskWriterEntry::operator<(const DiskWriterEntry& entry) const
} }
MultiDiskAdaptor::MultiDiskAdaptor() MultiDiskAdaptor::MultiDiskAdaptor()
: pieceLength_(0), : pieceLength_{0},
maxOpenFiles_(DEFAULT_MAX_OPEN_FILES), maxOpenFiles_{DEFAULT_MAX_OPEN_FILES},
readOnly_(false) readOnly_{false}
{} {}
MultiDiskAdaptor::~MultiDiskAdaptor() {} MultiDiskAdaptor::~MultiDiskAdaptor() {}
namespace { namespace {
std::shared_ptr<DiskWriterEntry> createDiskWriterEntry std::unique_ptr<DiskWriterEntry> createDiskWriterEntry
(const std::shared_ptr<FileEntry>& fileEntry, (const std::shared_ptr<FileEntry>& fileEntry)
bool needsFileAllocation)
{ {
std::shared_ptr<DiskWriterEntry> entry(new DiskWriterEntry(fileEntry)); auto entry = make_unique<DiskWriterEntry>(fileEntry);
entry->needsFileAllocation(needsFileAllocation); entry->needsFileAllocation(fileEntry->isRequested());
return entry; return entry;
} }
} // namespace } // namespace
@ -144,33 +144,28 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
return; return;
} }
for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i = for(auto& fileEntry: getFileEntries()) {
getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) { diskWriterEntries_.push_back(createDiskWriterEntry(fileEntry));
diskWriterEntries_.push_back
(createDiskWriterEntry(*i, (*i)->isRequested()));
} }
std::map<std::string, bool> dwreq;
// TODO Currently, pieceLength_ == 0 is used for unit testing only. // TODO Currently, pieceLength_ == 0 is used for unit testing only.
if(pieceLength_ > 0) { if(pieceLength_ > 0) {
std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator done = auto done = std::begin(diskWriterEntries_);
diskWriterEntries_.begin(); for(auto itr = std::begin(diskWriterEntries_),
for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator itr = eoi = std::end(diskWriterEntries_); itr != eoi;) {
diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); auto& fileEntry = (*itr)->getFileEntry();
itr != eoi;) {
const std::shared_ptr<FileEntry>& fileEntry = (*itr)->getFileEntry();
if(!fileEntry->isRequested()) { if(!fileEntry->isRequested()) {
++itr; ++itr;
continue; continue;
} }
int64_t pieceStartOffset = int64_t pieceStartOffset =
(fileEntry->getOffset()/pieceLength_)*pieceLength_; (fileEntry->getOffset()/pieceLength_)*pieceLength_;
if(itr != diskWriterEntries_.begin()) { if(itr != std::begin(diskWriterEntries_)) {
for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator i = for(auto i = itr-1;; --i) {
itr-1; true; --i) { auto& fileEntry = (*i)->getFileEntry();
const std::shared_ptr<FileEntry>& fileEntry = (*i)->getFileEntry();
if(pieceStartOffset <= fileEntry->getOffset() || if(pieceStartOffset <= fileEntry->getOffset() ||
pieceStartOffset < fileEntry->getLastOffset()) { pieceStartOffset < fileEntry->getLastOffset()) {
A2_LOG_DEBUG(fmt("%s needs file allocation",
(*i)->getFileEntry()->getPath().c_str()));
(*i)->needsFileAllocation(true); (*i)->needsFileAllocation(true);
} else { } else {
break; break;
@ -205,7 +200,7 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
A2_LOG_DEBUG A2_LOG_DEBUG
(fmt("%s needs diskwriter", (fmt("%s needs diskwriter",
(*itr)->getFileEntry()->getPath().c_str())); (*itr)->getFileEntry()->getPath().c_str()));
dwreq[(*itr)->getFileEntry()->getPath()] = true; (*itr)->needsDiskWriter(true);
} else { } else {
break; break;
} }
@ -218,17 +213,15 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
} }
} }
DefaultDiskWriterFactory dwFactory; DefaultDiskWriterFactory dwFactory;
for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator i = for(auto& dwent : diskWriterEntries_) {
diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); if(dwent->needsFileAllocation() ||
i != eoi; ++i) { dwent->needsDiskWriter() ||
if((*i)->needsFileAllocation() || dwent->fileExists()) {
dwreq.find((*i)->getFileEntry()->getPath()) != dwreq.end() ||
(*i)->fileExists()) {
A2_LOG_DEBUG(fmt("Creating DiskWriter for filename=%s", A2_LOG_DEBUG(fmt("Creating DiskWriter for filename=%s",
(*i)->getFilePath().c_str())); dwent->getFilePath().c_str()));
(*i)->setDiskWriter(dwFactory.newDiskWriter((*i)->getFilePath())); dwent->setDiskWriter(dwFactory.newDiskWriter(dwent->getFilePath()));
if(readOnly_) { if(readOnly_) {
(*i)->getDiskWriter()->enableReadOnly(); dwent->getDiskWriter()->enableReadOnly();
} }
// TODO mmap is not enabled at this moment. Call enableMmap() // TODO mmap is not enabled at this moment. Call enableMmap()
// after this function call. // after this function call.
@ -237,24 +230,22 @@ void MultiDiskAdaptor::resetDiskWriterEntries()
} }
void MultiDiskAdaptor::openIfNot void MultiDiskAdaptor::openIfNot
(const std::shared_ptr<DiskWriterEntry>& entry, void (DiskWriterEntry::*open)()) (DiskWriterEntry* entry, void (DiskWriterEntry::*open)())
{ {
if(!entry->isOpen()) { if(!entry->isOpen()) {
// A2_LOG_DEBUG(fmt("DiskWriterEntry: Cache MISS. offset=%s", // A2_LOG_DEBUG(fmt("DiskWriterEntry: Cache MISS. offset=%s",
// util::itos(entry->getFileEntry()->getOffset()).c_str())); // util::itos(entry->getFileEntry()->getOffset()).c_str()));
int numOpened = openedDiskWriterEntries_.size(); int numOpened = openedDiskWriterEntries_.size();
(entry.get()->*open)(); (entry->*open)();
if(numOpened >= maxOpenFiles_) { if(numOpened >= maxOpenFiles_) {
// Cache is full. // Cache is full.
// Choose one DiskWriterEntry randomly and close it. // Choose one DiskWriterEntry randomly and close it.
size_t index = size_t index =
SimpleRandomizer::getInstance()->getRandomNumber(numOpened); SimpleRandomizer::getInstance()->getRandomNumber(numOpened);
std::vector<std::shared_ptr<DiskWriterEntry> >::iterator i = auto i = std::begin(openedDiskWriterEntries_);
openedDiskWriterEntries_.begin();
std::advance(i, index); std::advance(i, index);
(*i)->closeFile(); (*i)->closeFile();
(*i) = entry; *i = entry;
} else { } else {
openedDiskWriterEntries_.push_back(entry); openedDiskWriterEntries_.push_back(entry);
} }
@ -272,9 +263,8 @@ void MultiDiskAdaptor::openFile()
// Call DiskWriterEntry::openFile to make sure that zero-length files are // Call DiskWriterEntry::openFile to make sure that zero-length files are
// created. // created.
for(DiskWriterEntries::const_iterator itr = diskWriterEntries_.begin(), for(auto& dwent : diskWriterEntries_) {
eoi = diskWriterEntries_.end(); itr != eoi; ++itr) { openIfNot(dwent.get(), &DiskWriterEntry::openFile);
openIfNot(*itr, &DiskWriterEntry::openFile);
} }
} }
@ -285,9 +275,8 @@ void MultiDiskAdaptor::initAndOpenFile()
// we don't need to call it here. // we don't need to call it here.
// Call DiskWriterEntry::initAndOpenFile to make files truncated. // Call DiskWriterEntry::initAndOpenFile to make files truncated.
for(DiskWriterEntries::const_iterator itr = diskWriterEntries_.begin(), for(auto& dwent : diskWriterEntries_) {
eoi = diskWriterEntries_.end(); itr != eoi; ++itr) { openIfNot(dwent.get(), &DiskWriterEntry::initAndOpenFile);
openIfNot(*itr, &DiskWriterEntry::initAndOpenFile);
} }
} }
@ -299,12 +288,14 @@ void MultiDiskAdaptor::openExistingFile()
void MultiDiskAdaptor::closeFile() void MultiDiskAdaptor::closeFile()
{ {
std::for_each(diskWriterEntries_.begin(), diskWriterEntries_.end(), openedDiskWriterEntries_.clear();
std::mem_fn(&DiskWriterEntry::closeFile)); for(auto& dwent : diskWriterEntries_) {
dwent->closeFile();
}
} }
namespace { namespace {
bool isInRange(const std::shared_ptr<DiskWriterEntry> entry, int64_t offset) bool isInRange(DiskWriterEntry* entry, int64_t offset)
{ {
return entry->getFileEntry()->getOffset() <= offset && return entry->getFileEntry()->getOffset() <= offset &&
offset < entry->getFileEntry()->getLastOffset(); offset < entry->getFileEntry()->getLastOffset();
@ -312,7 +303,7 @@ bool isInRange(const std::shared_ptr<DiskWriterEntry> entry, int64_t offset)
} // namespace } // namespace
namespace { namespace {
ssize_t calculateLength(const std::shared_ptr<DiskWriterEntry> entry, ssize_t calculateLength(DiskWriterEntry* entry,
int64_t fileOffset, ssize_t rem) int64_t fileOffset, ssize_t rem)
{ {
if(entry->getFileEntry()->getLength() < fileOffset+rem) { if(entry->getFileEntry()->getLength() < fileOffset+rem) {
@ -326,7 +317,7 @@ ssize_t calculateLength(const std::shared_ptr<DiskWriterEntry> entry,
namespace { namespace {
class OffsetCompare { class OffsetCompare {
public: public:
bool operator()(int64_t offset, const std::shared_ptr<DiskWriterEntry>& dwe) bool operator()(int64_t offset, const std::unique_ptr<DiskWriterEntry>& dwe)
{ {
return offset < dwe->getFileEntry()->getOffset(); return offset < dwe->getFileEntry()->getOffset();
} }
@ -337,14 +328,12 @@ namespace {
DiskWriterEntries::const_iterator findFirstDiskWriterEntry DiskWriterEntries::const_iterator findFirstDiskWriterEntry
(const DiskWriterEntries& diskWriterEntries, int64_t offset) (const DiskWriterEntries& diskWriterEntries, int64_t offset)
{ {
DiskWriterEntries::const_iterator first = auto first = std::upper_bound(std::begin(diskWriterEntries),
std::upper_bound(diskWriterEntries.begin(), diskWriterEntries.end(), std::end(diskWriterEntries),
offset, OffsetCompare()); offset, OffsetCompare());
--first; --first;
// In case when offset is out-of-range // In case when offset is out-of-range
if(!isInRange(*first, offset)) { if(!isInRange((*first).get(), offset)) {
throw DL_ABORT_EX throw DL_ABORT_EX
(fmt(EX_FILE_OFFSET_OUT_OF_RANGE, static_cast<int64_t>(offset))); (fmt(EX_FILE_OFFSET_OUT_OF_RANGE, static_cast<int64_t>(offset)));
} }
@ -353,8 +342,7 @@ DiskWriterEntries::const_iterator findFirstDiskWriterEntry
} // namespace } // namespace
namespace { namespace {
void throwOnDiskWriterNotOpened(const std::shared_ptr<DiskWriterEntry>& e, void throwOnDiskWriterNotOpened(DiskWriterEntry* e, int64_t offset)
int64_t offset)
{ {
throw DL_ABORT_EX throw DL_ABORT_EX
(fmt("DiskWriter for offset=%" PRId64 ", filename=%s is not opened.", (fmt("DiskWriter for offset=%" PRId64 ", filename=%s is not opened.",
@ -366,19 +354,14 @@ void throwOnDiskWriterNotOpened(const std::shared_ptr<DiskWriterEntry>& e,
void MultiDiskAdaptor::writeData(const unsigned char* data, size_t len, void MultiDiskAdaptor::writeData(const unsigned char* data, size_t len,
int64_t offset) int64_t offset)
{ {
DiskWriterEntries::const_iterator first = auto first = findFirstDiskWriterEntry(diskWriterEntries_, offset);
findFirstDiskWriterEntry(diskWriterEntries_, offset);
ssize_t rem = len; ssize_t rem = len;
int64_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); int64_t fileOffset = offset-(*first)->getFileEntry()->getOffset();
for(DiskWriterEntries::const_iterator i = first, for(auto i = first, eoi = diskWriterEntries_.cend(); i != eoi; ++i) {
eoi = diskWriterEntries_.end(); i != eoi; ++i) { ssize_t writeLength = calculateLength((*i).get(), fileOffset, rem);
ssize_t writeLength = calculateLength(*i, fileOffset, rem); openIfNot((*i).get(), &DiskWriterEntry::openFile);
openIfNot(*i, &DiskWriterEntry::openFile);
if(!(*i)->isOpen()) { if(!(*i)->isOpen()) {
throwOnDiskWriterNotOpened(*i, offset+(len-rem)); throwOnDiskWriterNotOpened((*i).get(), offset+(len-rem));
} }
(*i)->getDiskWriter()->writeData(data+(len-rem), writeLength, fileOffset); (*i)->getDiskWriter()->writeData(data+(len-rem), writeLength, fileOffset);
@ -393,22 +376,16 @@ void MultiDiskAdaptor::writeData(const unsigned char* data, size_t len,
ssize_t MultiDiskAdaptor::readData ssize_t MultiDiskAdaptor::readData
(unsigned char* data, size_t len, int64_t offset) (unsigned char* data, size_t len, int64_t offset)
{ {
DiskWriterEntries::const_iterator first = auto first = findFirstDiskWriterEntry(diskWriterEntries_, offset);
findFirstDiskWriterEntry(diskWriterEntries_, offset);
ssize_t rem = len; ssize_t rem = len;
ssize_t totalReadLength = 0; ssize_t totalReadLength = 0;
int64_t fileOffset = offset-(*first)->getFileEntry()->getOffset(); int64_t fileOffset = offset-(*first)->getFileEntry()->getOffset();
for(DiskWriterEntries::const_iterator i = first, for(auto i = first, eoi = diskWriterEntries_.cend(); i != eoi; ++i) {
eoi = diskWriterEntries_.end(); i != eoi; ++i) { ssize_t readLength = calculateLength((*i).get(), fileOffset, rem);
ssize_t readLength = calculateLength(*i, fileOffset, rem); openIfNot((*i).get(), &DiskWriterEntry::openFile);
openIfNot(*i, &DiskWriterEntry::openFile);
if(!(*i)->isOpen()) { if(!(*i)->isOpen()) {
throwOnDiskWriterNotOpened(*i, offset+(len-rem)); throwOnDiskWriterNotOpened((*i).get(), offset+(len-rem));
} }
totalReadLength += totalReadLength +=
(*i)->getDiskWriter()->readData(data+(len-rem), readLength, fileOffset); (*i)->getDiskWriter()->readData(data+(len-rem), readLength, fileOffset);
rem -= readLength; rem -= readLength;
@ -427,27 +404,26 @@ void MultiDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
unsigned char buf[16*1024]; unsigned char buf[16*1024];
size_t buflen = 0; size_t buflen = 0;
size_t buffoffset = 0; size_t buffoffset = 0;
const WrDiskCacheEntry::DataCellSet& dataSet = entry->getDataSet(); auto& dataSet = entry->getDataSet();
if(dataSet.empty()) { if(dataSet.empty()) {
return; return;
} }
DiskWriterEntries::const_iterator dent = auto dent =
findFirstDiskWriterEntry(diskWriterEntries_, (*dataSet.begin())->goff), findFirstDiskWriterEntry(diskWriterEntries_, (*dataSet.begin())->goff),
eod = diskWriterEntries_.end(); eod = diskWriterEntries_.cend();
WrDiskCacheEntry::DataCellSet::const_iterator i = dataSet.begin(), auto i = std::begin(dataSet), eoi = std::end(dataSet);
eoi = dataSet.end();
size_t celloff = 0; size_t celloff = 0;
for(; dent != eod; ++dent) { for(; dent != eod; ++dent) {
int64_t lstart = 0, lp = 0; int64_t lstart = 0, lp = 0;
const std::shared_ptr<FileEntry>& fent = (*dent)->getFileEntry(); auto& fent = (*dent)->getFileEntry();
for(; i != eoi;) { for(; i != eoi;) {
if(std::max(fent->getOffset(), if(std::max(fent->getOffset(),
static_cast<int64_t>((*i)->goff + celloff)) < static_cast<int64_t>((*i)->goff + celloff)) <
std::min(fent->getLastOffset(), std::min(fent->getLastOffset(),
static_cast<int64_t>((*i)->goff + (*i)->len))) { static_cast<int64_t>((*i)->goff + (*i)->len))) {
openIfNot(*dent, &DiskWriterEntry::openFile); openIfNot((*dent).get(), &DiskWriterEntry::openFile);
if(!(*dent)->isOpen()) { if(!(*dent)->isOpen()) {
throwOnDiskWriterNotOpened(*dent, (*i)->goff + celloff); throwOnDiskWriterNotOpened((*dent).get(), (*i)->goff + celloff);
} }
} else { } else {
A2_LOG_DEBUG(fmt("%s Cache flush loff=%" PRId64 ", len=%lu", A2_LOG_DEBUG(fmt("%s Cache flush loff=%" PRId64 ", len=%lu",
@ -519,25 +495,25 @@ void MultiDiskAdaptor::writeCache(const WrDiskCacheEntry* entry)
bool MultiDiskAdaptor::fileExists() bool MultiDiskAdaptor::fileExists()
{ {
return std::find_if(getFileEntries().begin(), getFileEntries().end(), return std::find_if(std::begin(getFileEntries()),
std::end(getFileEntries()),
std::mem_fn(&FileEntry::exists)) != std::mem_fn(&FileEntry::exists)) !=
getFileEntries().end(); std::end(getFileEntries());
} }
int64_t MultiDiskAdaptor::size() int64_t MultiDiskAdaptor::size()
{ {
int64_t size = 0; int64_t size = 0;
for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i = for(auto& fe : getFileEntries()) {
getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) { size += File(fe->getPath()).size();
size += File((*i)->getPath()).size();
} }
return size; return size;
} }
std::shared_ptr<FileAllocationIterator> MultiDiskAdaptor::fileAllocationIterator() std::shared_ptr<FileAllocationIterator>
MultiDiskAdaptor::fileAllocationIterator()
{ {
return std::shared_ptr<FileAllocationIterator> return std::make_shared<MultiFileAllocationIterator>(this);
(new MultiFileAllocationIterator(this));
} }
void MultiDiskAdaptor::enableReadOnly() void MultiDiskAdaptor::enableReadOnly()
@ -552,10 +528,8 @@ void MultiDiskAdaptor::disableReadOnly()
void MultiDiskAdaptor::enableMmap() void MultiDiskAdaptor::enableMmap()
{ {
for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator i = for(auto& dwent : diskWriterEntries_) {
diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); auto& dw = dwent->getDiskWriter();
i != eoi; ++i) {
const std::shared_ptr<DiskWriter>& dw = (*i)->getDiskWriter();
if(dw) { if(dw) {
dw->enableMmap(); dw->enableMmap();
} }
@ -564,14 +538,12 @@ void MultiDiskAdaptor::enableMmap()
void MultiDiskAdaptor::cutTrailingGarbage() void MultiDiskAdaptor::cutTrailingGarbage()
{ {
for(std::vector<std::shared_ptr<DiskWriterEntry> >::const_iterator i = for(auto& dwent : diskWriterEntries_) {
diskWriterEntries_.begin(), eoi = diskWriterEntries_.end(); int64_t length = dwent->getFileEntry()->getLength();
i != eoi; ++i) { if(File(dwent->getFilePath()).size() > length) {
int64_t length = (*i)->getFileEntry()->getLength();
if(File((*i)->getFilePath()).size() > length) {
// We need open file before calling DiskWriter::truncate(int64_t) // We need open file before calling DiskWriter::truncate(int64_t)
openIfNot(*i, &DiskWriterEntry::openFile); openIfNot(dwent.get(), &DiskWriterEntry::openFile);
(*i)->getDiskWriter()->truncate(length); dwent->getDiskWriter()->truncate(length);
} }
} }
} }
@ -584,10 +556,9 @@ void MultiDiskAdaptor::setMaxOpenFiles(int maxOpenFiles)
size_t MultiDiskAdaptor::utime(const Time& actime, const Time& modtime) size_t MultiDiskAdaptor::utime(const Time& actime, const Time& modtime)
{ {
size_t numOK = 0; size_t numOK = 0;
for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i = for(auto& fe : getFileEntries()) {
getFileEntries().begin(), eoi = getFileEntries().end(); i != eoi; ++i) { if(fe->isRequested()) {
if((*i)->isRequested()) { File f{fe->getPath()};
File f((*i)->getPath());
if(f.isFile() && f.utime(actime, modtime)) { if(f.isFile() && f.utime(actime, modtime)) {
++numOK; ++numOK;
} }

26
src/MultiDiskAdaptor.h
View File

@ -46,9 +46,10 @@ class DiskWriter;
class DiskWriterEntry { class DiskWriterEntry {
private: private:
std::shared_ptr<FileEntry> fileEntry_; std::shared_ptr<FileEntry> fileEntry_;
std::shared_ptr<DiskWriter> diskWriter_; std::unique_ptr<DiskWriter> diskWriter_;
bool open_; bool open_;
bool needsFileAllocation_; bool needsFileAllocation_;
bool needsDiskWriter_;
public: public:
DiskWriterEntry(const std::shared_ptr<FileEntry>& fileEntry); DiskWriterEntry(const std::shared_ptr<FileEntry>& fileEntry);
@ -76,9 +77,9 @@ public:
return fileEntry_; return fileEntry_;
} }
void setDiskWriter(const std::shared_ptr<DiskWriter>& diskWriter); void setDiskWriter(std::unique_ptr<DiskWriter> diskWriter);
const std::shared_ptr<DiskWriter>& getDiskWriter() const const std::unique_ptr<DiskWriter>& getDiskWriter() const
{ {
return diskWriter_; return diskWriter_;
} }
@ -95,9 +96,18 @@ public:
needsFileAllocation_ = f; needsFileAllocation_ = f;
} }
bool needsDiskWriter() const
{
return needsDiskWriter_;
}
void needsDiskWriter(bool f)
{
needsDiskWriter_ = f;
}
}; };
typedef std::vector<std::shared_ptr<DiskWriterEntry> > DiskWriterEntries; typedef std::vector<std::unique_ptr<DiskWriterEntry>> DiskWriterEntries;
class MultiDiskAdaptor : public DiskAdaptor { class MultiDiskAdaptor : public DiskAdaptor {
friend class MultiFileAllocationIterator; friend class MultiFileAllocationIterator;
@ -105,7 +115,7 @@ private:
int32_t pieceLength_; int32_t pieceLength_;
DiskWriterEntries diskWriterEntries_; DiskWriterEntries diskWriterEntries_;
std::vector<std::shared_ptr<DiskWriterEntry> > openedDiskWriterEntries_; std::vector<DiskWriterEntry*> openedDiskWriterEntries_;
int maxOpenFiles_; int maxOpenFiles_;
@ -113,8 +123,7 @@ private:
void resetDiskWriterEntries(); void resetDiskWriterEntries();
void openIfNot(const std::shared_ptr<DiskWriterEntry>& entry, void openIfNot(DiskWriterEntry* entry, void (DiskWriterEntry::*f)());
void (DiskWriterEntry::*f)());
static const int DEFAULT_MAX_OPEN_FILES = 100; static const int DEFAULT_MAX_OPEN_FILES = 100;
@ -168,8 +177,7 @@ public:
virtual size_t utime(const Time& actime, const Time& modtime); virtual size_t utime(const Time& actime, const Time& modtime);
const std::vector<std::shared_ptr<DiskWriterEntry> >& const DiskWriterEntries& getDiskWriterEntries() const
getDiskWriterEntries() const
{ {
return diskWriterEntries_; return diskWriterEntries_;
} }

60
src/MultiFileAllocationIterator.cc
View File

@ -45,51 +45,49 @@
namespace aria2 { namespace aria2 {
MultiFileAllocationIterator::MultiFileAllocationIterator MultiFileAllocationIterator::MultiFileAllocationIterator
(MultiDiskAdaptor* diskAdaptor): (MultiDiskAdaptor* diskAdaptor)
diskAdaptor_(diskAdaptor), : diskAdaptor_{diskAdaptor},
entries_(diskAdaptor_->diskWriterEntries_.begin(), entryItr_{std::begin(diskAdaptor_->getDiskWriterEntries())}
diskAdaptor_->diskWriterEntries_.end())
{} {}
MultiFileAllocationIterator::~MultiFileAllocationIterator() {} MultiFileAllocationIterator::~MultiFileAllocationIterator() {}
void MultiFileAllocationIterator::allocateChunk() void MultiFileAllocationIterator::allocateChunk()
{ {
while(!fileAllocationIterator_ || while((!fileAllocationIterator_ ||
fileAllocationIterator_->finished()) { fileAllocationIterator_->finished()) &&
if(entries_.empty()) { entryItr_ != std::end(diskAdaptor_->getDiskWriterEntries())) {
break; auto& fileEntry = (*entryItr_)->getFileEntry();
} // Open file before calling DiskWriterEntry::size(). Calling
std::shared_ptr<DiskWriterEntry> entry = entries_.front(); // private function of MultiDiskAdaptor.
entries_.pop_front(); diskAdaptor_->openIfNot((*entryItr_).get(), &DiskWriterEntry::openFile);
std::shared_ptr<FileEntry> fileEntry = entry->getFileEntry(); if((*entryItr_)->needsFileAllocation() &&
// Open file before calling DiskWriterEntry::size() (*entryItr_)->size() < fileEntry->getLength()) {
diskAdaptor_->openIfNot(entry, &DiskWriterEntry::openFile);
if(entry->needsFileAllocation() && entry->size() < fileEntry->getLength()) {
// Calling private function of MultiDiskAdaptor.
switch(diskAdaptor_->getFileAllocationMethod()) { switch(diskAdaptor_->getFileAllocationMethod()) {
#ifdef HAVE_SOME_FALLOCATE #ifdef HAVE_SOME_FALLOCATE
case(DiskAdaptor::FILE_ALLOC_FALLOC): case(DiskAdaptor::FILE_ALLOC_FALLOC):
fileAllocationIterator_.reset fileAllocationIterator_ = make_unique<FallocFileAllocationIterator>
(new FallocFileAllocationIterator(entry->getDiskWriter().get(), ((*entryItr_)->getDiskWriter().get(),
entry->size(), (*entryItr_)->size(),
fileEntry->getLength())); fileEntry->getLength());
break; break;
#endif // HAVE_SOME_FALLOCATE #endif // HAVE_SOME_FALLOCATE
case(DiskAdaptor::FILE_ALLOC_TRUNC): case(DiskAdaptor::FILE_ALLOC_TRUNC):
fileAllocationIterator_.reset fileAllocationIterator_ = make_unique<TruncFileAllocationIterator>
(new TruncFileAllocationIterator(entry->getDiskWriter().get(), ((*entryItr_)->getDiskWriter().get(),
entry->size(), (*entryItr_)->size(),
fileEntry->getLength())); fileEntry->getLength());
break; break;
default: default:
fileAllocationIterator_.reset fileAllocationIterator_ = make_unique<AdaptiveFileAllocationIterator>
(new AdaptiveFileAllocationIterator(entry->getDiskWriter().get(), ((*entryItr_)->getDiskWriter().get(),
entry->size(), (*entryItr_)->size(),
fileEntry->getLength())); fileEntry->getLength());
break; break;
} }
break;
} }
++entryItr_;
} }
if(finished()) { if(finished()) {
return; return;
@ -99,7 +97,7 @@ void MultiFileAllocationIterator::allocateChunk()
bool MultiFileAllocationIterator::finished() bool MultiFileAllocationIterator::finished()
{ {
return entries_.empty() && return entryItr_ == std::end(diskAdaptor_->getDiskWriterEntries()) &&
(!fileAllocationIterator_ || fileAllocationIterator_->finished()); (!fileAllocationIterator_ || fileAllocationIterator_->finished());
} }
@ -121,10 +119,10 @@ int64_t MultiFileAllocationIterator::getTotalLength()
} }
} }
const std::deque<std::shared_ptr<DiskWriterEntry> >& const DiskWriterEntries&
MultiFileAllocationIterator::getDiskWriterEntries() const MultiFileAllocationIterator::getDiskWriterEntries() const
{ {
return entries_; return diskAdaptor_->getDiskWriterEntries();
} }
} // namespace aria2 } // namespace aria2

8
src/MultiFileAllocationIterator.h
View File

@ -40,16 +40,17 @@
#include <deque> #include <deque>
#include <memory> #include <memory>
#include "MultiDiskAdaptor.h"
namespace aria2 { namespace aria2 {
class MultiDiskAdaptor;
class DiskWriterEntry; class DiskWriterEntry;
class MultiFileAllocationIterator:public FileAllocationIterator class MultiFileAllocationIterator:public FileAllocationIterator
{ {
private: private:
MultiDiskAdaptor* diskAdaptor_; MultiDiskAdaptor* diskAdaptor_;
std::deque<std::shared_ptr<DiskWriterEntry> > entries_; DiskWriterEntries::const_iterator entryItr_;
std::unique_ptr<FileAllocationIterator> fileAllocationIterator_; std::unique_ptr<FileAllocationIterator> fileAllocationIterator_;
public: public:
MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor); MultiFileAllocationIterator(MultiDiskAdaptor* diskAdaptor);
@ -64,8 +65,7 @@ public:
virtual int64_t getTotalLength(); virtual int64_t getTotalLength();
const std::deque<std::shared_ptr<DiskWriterEntry> >& const DiskWriterEntries& getDiskWriterEntries() const;
getDiskWriterEntries() const;
}; };
} // namespace aria2 } // namespace aria2

5
src/UnknownLengthPieceStorage.cc
View File

@ -62,9 +62,8 @@ void UnknownLengthPieceStorage::initStorage()
directDiskAdaptor->setFileEntries(downloadContext_->getFileEntries().begin(), directDiskAdaptor->setFileEntries(downloadContext_->getFileEntries().begin(),
downloadContext_->getFileEntries().end()); downloadContext_->getFileEntries().end());
std::shared_ptr<DiskWriter> writer = directDiskAdaptor->setDiskWriter
diskWriterFactory_->newDiskWriter(directDiskAdaptor->getFilePath()); (diskWriterFactory_->newDiskWriter(directDiskAdaptor->getFilePath()));
directDiskAdaptor->setDiskWriter(writer);
diskAdaptor_.reset(directDiskAdaptor); diskAdaptor_.reset(directDiskAdaptor);
} }

80
test/MultiDiskAdaptorTest.cc
View File

@ -28,10 +28,10 @@ class MultiDiskAdaptorTest:public CppUnit::TestFixture {
CPPUNIT_TEST(testWriteCache); CPPUNIT_TEST(testWriteCache);
CPPUNIT_TEST_SUITE_END(); CPPUNIT_TEST_SUITE_END();
private: private:
std::shared_ptr<MultiDiskAdaptor> adaptor; std::unique_ptr<MultiDiskAdaptor> adaptor;
public: public:
void setUp() { void setUp() {
adaptor.reset(new MultiDiskAdaptor()); adaptor = make_unique<MultiDiskAdaptor>();
adaptor->setPieceLength(2); adaptor->setPieceLength(2);
} }
@ -81,13 +81,12 @@ std::vector<std::shared_ptr<FileEntry> > createEntries()
void MultiDiskAdaptorTest::testResetDiskWriterEntries() void MultiDiskAdaptorTest::testResetDiskWriterEntries()
{ {
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
// In openFile(), resetDiskWriterEntries() are called. // In openFile(), resetDiskWriterEntries() are called.
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
CPPUNIT_ASSERT(entries[0]->getDiskWriter()); CPPUNIT_ASSERT(entries[0]->getDiskWriter());
CPPUNIT_ASSERT(entries[1]->getDiskWriter()); CPPUNIT_ASSERT(entries[1]->getDiskWriter());
CPPUNIT_ASSERT(entries[2]->getDiskWriter()); CPPUNIT_ASSERT(entries[2]->getDiskWriter());
@ -98,14 +97,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
adaptor->closeFile(); adaptor->closeFile();
} }
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
fileEntries[0]->setRequested(false); fileEntries[0]->setRequested(false);
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
// In openFile(), resetDiskWriterEntries() are called. // In openFile(), resetDiskWriterEntries() are called.
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
// Because entries[1] spans entries[0] // Because entries[1] spans entries[0]
CPPUNIT_ASSERT(entries[0]->getDiskWriter()); CPPUNIT_ASSERT(entries[0]->getDiskWriter());
CPPUNIT_ASSERT(entries[1]->getDiskWriter()); CPPUNIT_ASSERT(entries[1]->getDiskWriter());
@ -117,15 +115,14 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
adaptor->closeFile(); adaptor->closeFile();
} }
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
fileEntries[0]->setRequested(false); fileEntries[0]->setRequested(false);
fileEntries[1]->setRequested(false); fileEntries[1]->setRequested(false);
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
// In openFile(), resetDiskWriterEntries() are called. // In openFile(), resetDiskWriterEntries() are called.
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
CPPUNIT_ASSERT(!entries[0]->getDiskWriter()); CPPUNIT_ASSERT(!entries[0]->getDiskWriter());
// Because entries[2] spans entries[1] // Because entries[2] spans entries[1]
CPPUNIT_ASSERT(entries[1]->getDiskWriter()); CPPUNIT_ASSERT(entries[1]->getDiskWriter());
@ -138,14 +135,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
adaptor->closeFile(); adaptor->closeFile();
} }
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
fileEntries[3]->setRequested(false); fileEntries[3]->setRequested(false);
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
// In openFile(), resetDiskWriterEntries() are called. // In openFile(), resetDiskWriterEntries() are called.
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
CPPUNIT_ASSERT(entries[0]->getDiskWriter()); CPPUNIT_ASSERT(entries[0]->getDiskWriter());
CPPUNIT_ASSERT(entries[1]->getDiskWriter()); CPPUNIT_ASSERT(entries[1]->getDiskWriter());
CPPUNIT_ASSERT(entries[2]->getDiskWriter()); CPPUNIT_ASSERT(entries[2]->getDiskWriter());
@ -158,14 +154,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
adaptor->closeFile(); adaptor->closeFile();
} }
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
fileEntries[4]->setRequested(false); fileEntries[4]->setRequested(false);
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
// In openFile(), resetDiskWriterEntries() are called. // In openFile(), resetDiskWriterEntries() are called.
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
CPPUNIT_ASSERT(entries[0]->getDiskWriter()); CPPUNIT_ASSERT(entries[0]->getDiskWriter());
CPPUNIT_ASSERT(entries[1]->getDiskWriter()); CPPUNIT_ASSERT(entries[1]->getDiskWriter());
CPPUNIT_ASSERT(entries[2]->getDiskWriter()); CPPUNIT_ASSERT(entries[2]->getDiskWriter());
@ -177,15 +172,14 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
adaptor->closeFile(); adaptor->closeFile();
} }
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
fileEntries[3]->setRequested(false); fileEntries[3]->setRequested(false);
fileEntries[4]->setRequested(false); fileEntries[4]->setRequested(false);
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
// In openFile(), resetDiskWriterEntries() are called. // In openFile(), resetDiskWriterEntries() are called.
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
CPPUNIT_ASSERT(entries[0]->getDiskWriter()); CPPUNIT_ASSERT(entries[0]->getDiskWriter());
CPPUNIT_ASSERT(entries[1]->getDiskWriter()); CPPUNIT_ASSERT(entries[1]->getDiskWriter());
CPPUNIT_ASSERT(entries[2]->getDiskWriter()); CPPUNIT_ASSERT(entries[2]->getDiskWriter());
@ -196,7 +190,7 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
adaptor->closeFile(); adaptor->closeFile();
} }
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
for(size_t i = 5; i < 9; ++i) { for(size_t i = 5; i < 9; ++i) {
fileEntries[i]->setRequested(false); fileEntries[i]->setRequested(false);
} }
@ -204,8 +198,7 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
// In openFile(), resetDiskWriterEntries() are called. // In openFile(), resetDiskWriterEntries() are called.
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
CPPUNIT_ASSERT(entries[0]->getDiskWriter()); CPPUNIT_ASSERT(entries[0]->getDiskWriter());
CPPUNIT_ASSERT(entries[1]->getDiskWriter()); CPPUNIT_ASSERT(entries[1]->getDiskWriter());
CPPUNIT_ASSERT(entries[2]->getDiskWriter()); CPPUNIT_ASSERT(entries[2]->getDiskWriter());
@ -216,14 +209,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
adaptor->closeFile(); adaptor->closeFile();
} }
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
for(size_t i = 1; i < 9; ++i) { for(size_t i = 1; i < 9; ++i) {
fileEntries[i]->setRequested(false); fileEntries[i]->setRequested(false);
} }
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
CPPUNIT_ASSERT(entries[0]->getDiskWriter()); CPPUNIT_ASSERT(entries[0]->getDiskWriter());
CPPUNIT_ASSERT(!entries[1]->getDiskWriter()); CPPUNIT_ASSERT(!entries[1]->getDiskWriter());
CPPUNIT_ASSERT(!entries[2]->getDiskWriter()); CPPUNIT_ASSERT(!entries[2]->getDiskWriter());
@ -234,14 +226,13 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
adaptor->closeFile(); adaptor->closeFile();
} }
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
for(size_t i = 2; i < 9; ++i) { for(size_t i = 2; i < 9; ++i) {
fileEntries[i]->setRequested(false); fileEntries[i]->setRequested(false);
} }
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
CPPUNIT_ASSERT(entries[0]->getDiskWriter()); CPPUNIT_ASSERT(entries[0]->getDiskWriter());
CPPUNIT_ASSERT(entries[1]->getDiskWriter()); CPPUNIT_ASSERT(entries[1]->getDiskWriter());
// entries[1] spans entries[2] // entries[1] spans entries[2]
@ -254,15 +245,14 @@ void MultiDiskAdaptorTest::testResetDiskWriterEntries()
adaptor->closeFile(); adaptor->closeFile();
} }
{ {
std::vector<std::shared_ptr<FileEntry> > fileEntries = createEntries(); auto fileEntries = createEntries();
for(size_t i = 0; i < 6; ++i) { for(size_t i = 0; i < 6; ++i) {
fileEntries[i]->setRequested(false); fileEntries[i]->setRequested(false);
} }
fileEntries[8]->setRequested(false); fileEntries[8]->setRequested(false);
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(fileEntries.begin(), fileEntries.end());
adaptor->openFile(); adaptor->openFile();
std::vector<std::shared_ptr<DiskWriterEntry> > entries = auto& entries = adaptor->getDiskWriterEntries();
adaptor->getDiskWriterEntries();
CPPUNIT_ASSERT(!entries[0]->getDiskWriter()); CPPUNIT_ASSERT(!entries[0]->getDiskWriter());
CPPUNIT_ASSERT(!entries[1]->getDiskWriter()); CPPUNIT_ASSERT(!entries[1]->getDiskWriter());
CPPUNIT_ASSERT(!entries[2]->getDiskWriter()); CPPUNIT_ASSERT(!entries[2]->getDiskWriter());
@ -291,8 +281,8 @@ void readFile(const std::string& filename, char* buf, int bufLength) {
} }
void MultiDiskAdaptorTest::testWriteData() { void MultiDiskAdaptorTest::testWriteData() {
std::vector<std::shared_ptr<FileEntry> > fileEntries(createEntries()); auto fileEntries = createEntries();
adaptor->setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor->setFileEntries(std::begin(fileEntries), std::end(fileEntries));
adaptor->openFile(); adaptor->openFile();
std::string msg = "12345"; std::string msg = "12345";
@ -340,13 +330,13 @@ void MultiDiskAdaptorTest::testWriteData() {
void MultiDiskAdaptorTest::testReadData() void MultiDiskAdaptorTest::testReadData()
{ {
std::vector<std::shared_ptr<FileEntry>> entries { auto entries = std::vector<std::shared_ptr<FileEntry>>{
std::make_shared<FileEntry>(A2_TEST_DIR "/file1r.txt", 15, 0), std::make_shared<FileEntry>(A2_TEST_DIR "/file1r.txt", 15, 0),
std::make_shared<FileEntry>(A2_TEST_DIR "/file2r.txt", 7, 15), std::make_shared<FileEntry>(A2_TEST_DIR "/file2r.txt", 7, 15),
std::make_shared<FileEntry>(A2_TEST_DIR "/file3r.txt", 3, 22) std::make_shared<FileEntry>(A2_TEST_DIR "/file3r.txt", 3, 22)
}; };
adaptor->setFileEntries(entries.begin(), entries.end()); adaptor->setFileEntries(std::begin(entries), std::end(entries));
adaptor->enableReadOnly(); adaptor->enableReadOnly();
adaptor->openFile(); adaptor->openFile();
unsigned char buf[128]; unsigned char buf[128];
@ -369,7 +359,7 @@ void MultiDiskAdaptorTest::testCutTrailingGarbage()
{ {
std::string dir = A2_TEST_OUT_DIR; std::string dir = A2_TEST_OUT_DIR;
std::string prefix = "aria2_MultiDiskAdaptorTest_testCutTrailingGarbage_"; std::string prefix = "aria2_MultiDiskAdaptorTest_testCutTrailingGarbage_";
std::vector<std::shared_ptr<FileEntry> > fileEntries { auto fileEntries = std::vector<std::shared_ptr<FileEntry>>{
std::make_shared<FileEntry>(dir+"/"+prefix+"1", 256, 0), std::make_shared<FileEntry>(dir+"/"+prefix+"1", 256, 0),
std::make_shared<FileEntry>(dir+"/"+prefix+"2", 512, 256) std::make_shared<FileEntry>(dir+"/"+prefix+"2", 512, 256)
}; };
@ -378,7 +368,7 @@ void MultiDiskAdaptorTest::testCutTrailingGarbage()
} }
MultiDiskAdaptor adaptor; MultiDiskAdaptor adaptor;
adaptor.setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor.setFileEntries(std::begin(fileEntries), std::end(fileEntries));
adaptor.setMaxOpenFiles(1); adaptor.setMaxOpenFiles(1);
adaptor.setPieceLength(1); adaptor.setPieceLength(1);
@ -396,7 +386,7 @@ void MultiDiskAdaptorTest::testSize()
{ {
std::string dir = A2_TEST_OUT_DIR; std::string dir = A2_TEST_OUT_DIR;
std::string prefix = "aria2_MultiDiskAdaptorTest_testSize_"; std::string prefix = "aria2_MultiDiskAdaptorTest_testSize_";
std::vector<std::shared_ptr<FileEntry>> fileEntries { auto fileEntries = std::vector<std::shared_ptr<FileEntry>>{
std::make_shared<FileEntry>(dir+"/"+prefix+"1", 1, 0), std::make_shared<FileEntry>(dir+"/"+prefix+"1", 1, 0),
std::make_shared<FileEntry>(dir+"/"+prefix+"2", 1, 1) std::make_shared<FileEntry>(dir+"/"+prefix+"2", 1, 1)
}; };
@ -405,7 +395,7 @@ void MultiDiskAdaptorTest::testSize()
} }
MultiDiskAdaptor adaptor; MultiDiskAdaptor adaptor;
adaptor.setFileEntries(fileEntries.begin(), fileEntries.end()); adaptor.setFileEntries(std::begin(fileEntries), std::end(fileEntries));
adaptor.setMaxOpenFiles(1); adaptor.setMaxOpenFiles(1);
adaptor.setPieceLength(1); adaptor.setPieceLength(1);
@ -417,7 +407,7 @@ void MultiDiskAdaptorTest::testSize()
void MultiDiskAdaptorTest::testUtime() void MultiDiskAdaptorTest::testUtime()
{ {
std::string storeDir = A2_TEST_OUT_DIR"/aria2_MultiDiskAdaptorTest_testUtime"; std::string storeDir = A2_TEST_OUT_DIR"/aria2_MultiDiskAdaptorTest_testUtime";
std::vector<std::shared_ptr<FileEntry> > entries { auto entries = std::vector<std::shared_ptr<FileEntry>>{
std::make_shared<FileEntry>(storeDir+"/requested", 0, 0), std::make_shared<FileEntry>(storeDir+"/requested", 0, 0),
std::make_shared<FileEntry>(storeDir+"/notFound", 0, 0), std::make_shared<FileEntry>(storeDir+"/notFound", 0, 0),
std::make_shared<FileEntry>(storeDir+"/notRequested", 0, 0), std::make_shared<FileEntry>(storeDir+"/notRequested", 0, 0),
@ -432,7 +422,7 @@ void MultiDiskAdaptorTest::testUtime()
entries[2]->setRequested(false); entries[2]->setRequested(false);
MultiDiskAdaptor adaptor; MultiDiskAdaptor adaptor;
adaptor.setFileEntries(entries.begin(), entries.end()); adaptor.setFileEntries(std::begin(entries), std::end(entries));
time_t atime = (time_t) 100000; time_t atime = (time_t) 100000;
time_t mtime = (time_t) 200000; time_t mtime = (time_t) 200000;
@ -453,16 +443,16 @@ void MultiDiskAdaptorTest::testWriteCache()
{ {
std::string storeDir = std::string storeDir =
A2_TEST_OUT_DIR"/aria2_MultiDiskAdaptorTest_testWriteCache"; A2_TEST_OUT_DIR"/aria2_MultiDiskAdaptorTest_testWriteCache";
std::vector<std::shared_ptr<FileEntry>> entries { auto entries = std::vector<std::shared_ptr<FileEntry>>{
std::make_shared<FileEntry>(storeDir+"/file1", 16385, 0), std::make_shared<FileEntry>(storeDir+"/file1", 16385, 0),
std::make_shared<FileEntry>(storeDir+"/file2", 4098, 16385) std::make_shared<FileEntry>(storeDir+"/file2", 4098, 16385)
}; };
for(const auto& i : entries) { for(const auto& i : entries) {
File(i->getPath()).remove(); File(i->getPath()).remove();
} }
std::shared_ptr<MultiDiskAdaptor> adaptor(new MultiDiskAdaptor()); auto adaptor = std::make_shared<MultiDiskAdaptor>();
adaptor->setFileEntries(std::begin(entries), std::end(entries)); adaptor->setFileEntries(std::begin(entries), std::end(entries));
WrDiskCacheEntry cache(adaptor); WrDiskCacheEntry cache{adaptor};
std::string data1(16383, '1'), data2(100, '2'), data3(4000, '3'); std::string data1(16383, '1'), data2(100, '2'), data3(4000, '3');
cache.cacheData(createDataCell(0, data1.c_str())); cache.cacheData(createDataCell(0, data1.c_str()));
cache.cacheData(createDataCell(data1.size(), data2.c_str())); cache.cacheData(createDataCell(data1.size(), data2.c_str()));

108
test/MultiFileAllocationIteratorTest.cc
View File

@ -38,18 +38,18 @@ void MultiFileAllocationIteratorTest::testMakeDiskWriterEntries()
std::string storeDir = A2_TEST_OUT_DIR"/aria2_MultiFileAllocationIteratorTest" std::string storeDir = A2_TEST_OUT_DIR"/aria2_MultiFileAllocationIteratorTest"
"_testMakeDiskWriterEntries"; "_testMakeDiskWriterEntries";
std::shared_ptr<FileEntry> fs[] = { auto fs = std::vector<std::shared_ptr<FileEntry>>{
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file1", 1536, 0)), std::make_shared<FileEntry>(storeDir+"/file1", 1536, 0),
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file2", 2048, 1536)),// req no std::make_shared<FileEntry>(storeDir+"/file2", 2048, 1536),// req no
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file3", 1024, 3584)), std::make_shared<FileEntry>(storeDir+"/file3", 1024, 3584),
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file4", 1024, 4608)),// req no std::make_shared<FileEntry>(storeDir+"/file4", 1024, 4608),// req no
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file5", 1024, 5632)),// req no std::make_shared<FileEntry>(storeDir+"/file5", 1024, 5632),// req no
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file6", 1024, 6656)),// req no std::make_shared<FileEntry>(storeDir+"/file6", 1024, 6656),// req no
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file7", 256, 7680)),// req no std::make_shared<FileEntry>(storeDir+"/file7", 256, 7680),// req no
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file8", 255, 7936)), std::make_shared<FileEntry>(storeDir+"/file8", 255, 7936),
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/file9", 1025, 8191)),// req no std::make_shared<FileEntry>(storeDir+"/file9", 1025, 8191),// req no
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/fileA", 1024, 9216)),// req no std::make_shared<FileEntry>(storeDir+"/fileA", 1024, 9216),// req no
std::shared_ptr<FileEntry>(new FileEntry(storeDir+"/fileB", 1024, 10240)), std::make_shared<FileEntry>(storeDir+"/fileB", 1024, 10240)
}; };
fs[1]->setRequested(false); // file2 fs[1]->setRequested(false); // file2
fs[3]->setRequested(false); // file4 fs[3]->setRequested(false); // file4
@ -59,21 +59,22 @@ void MultiFileAllocationIteratorTest::testMakeDiskWriterEntries()
fs[8]->setRequested(false); // file9 fs[8]->setRequested(false); // file9
fs[9]->setRequested(false); // fileA fs[9]->setRequested(false); // fileA
for(auto& fe : fs) {
File{fe->getPath()}.remove();
}
// create empty file4 // create empty file4
createFile(storeDir+std::string("/file4"), 0); createFile(storeDir+std::string("/file4"), 0);
std::shared_ptr<MultiDiskAdaptor> diskAdaptor(new MultiDiskAdaptor()); MultiDiskAdaptor diskAdaptor;
diskAdaptor->setFileEntries(std::begin(fs), std::end(fs)); diskAdaptor.setFileEntries(std::begin(fs), std::end(fs));
diskAdaptor->setPieceLength(1024); diskAdaptor.setPieceLength(1024);
diskAdaptor->openFile(); diskAdaptor.openFile();
auto itr = std::dynamic_pointer_cast<MultiFileAllocationIterator> auto allocitr = diskAdaptor.fileAllocationIterator();
(diskAdaptor->fileAllocationIterator()); auto itr = dynamic_cast<MultiFileAllocationIterator*>(allocitr.get());
const std::deque<std::shared_ptr<DiskWriterEntry> >& entries =
itr->getDiskWriterEntries();
auto& entries = itr->getDiskWriterEntries();
CPPUNIT_ASSERT_EQUAL((size_t)11, entries.size()); CPPUNIT_ASSERT_EQUAL((size_t)11, entries.size());
// file1 // file1
@ -152,58 +153,49 @@ void MultiFileAllocationIteratorTest::testAllocate()
int64_t length6 = 30; int64_t length6 = 30;
try { try {
std::shared_ptr<MultiDiskAdaptor> diskAdaptor(new MultiDiskAdaptor()); MultiDiskAdaptor diskAdaptor;
diskAdaptor->setPieceLength(1); diskAdaptor.setPieceLength(1);
int64_t offset = 0; int64_t offset = 0;
std::shared_ptr<FileEntry> fileEntry1(new FileEntry(storeDir+"/"+fname1, auto fileEntry1 = std::make_shared<FileEntry>(storeDir+"/"+fname1,
length1, length1, offset);
offset));
offset += length1; offset += length1;
std::shared_ptr<FileEntry> fileEntry2(new FileEntry(storeDir+"/"+fname2, auto fileEntry2 = std::make_shared<FileEntry>(storeDir+"/"+fname2,
length2, length2, offset);
offset));
offset += length2; offset += length2;
std::shared_ptr<FileEntry> fileEntry3(new FileEntry(storeDir+"/"+fname3, auto fileEntry3 = std::make_shared<FileEntry>(storeDir+"/"+fname3,
length3, length3, offset);
offset));
offset += length3; offset += length3;
std::shared_ptr<FileEntry> fileEntry4(new FileEntry(storeDir+"/"+fname4, auto fileEntry4 = std::make_shared<FileEntry>(storeDir+"/"+fname4,
length4, length4, offset);
offset));
fileEntry4->setRequested(false); fileEntry4->setRequested(false);
offset += length4; offset += length4;
std::shared_ptr<FileEntry> fileEntry5(new FileEntry(storeDir+"/"+fname5, auto fileEntry5 = std::make_shared<FileEntry>(storeDir+"/"+fname5,
length5, length5, offset);
offset));
offset += length5; offset += length5;
std::shared_ptr<FileEntry> fileEntry6(new FileEntry(storeDir+"/"+fname6, auto fileEntry6 = std::make_shared<FileEntry>(storeDir+"/"+fname6,
length6, length6, offset);
offset));
fileEntry6->setRequested(false); fileEntry6->setRequested(false);
std::vector<std::shared_ptr<FileEntry> > fs; auto fs = std::vector<std::shared_ptr<FileEntry>>{
fs.push_back(fileEntry1); fileEntry1,
fs.push_back(fileEntry2); fileEntry2,
fs.push_back(fileEntry3); fileEntry3,
fs.push_back(fileEntry4); fileEntry4,
fs.push_back(fileEntry5); fileEntry5,
fs.push_back(fileEntry6); fileEntry6
diskAdaptor->setFileEntries(fs.begin(), fs.end()); };
diskAdaptor.setFileEntries(std::begin(fs), std::end(fs));
for(std::vector<std::shared_ptr<FileEntry> >::const_iterator i = fs.begin(); for(auto& fe : fs) {
i != fs.end(); ++i) { File{fe->getPath()}.remove();
File((*i)->getPath()).remove();
} }
// we have to open file first. // we have to open file first.
diskAdaptor->initAndOpenFile(); diskAdaptor.initAndOpenFile();
auto itr = std::dynamic_pointer_cast<MultiFileAllocationIterator> auto allocitr = diskAdaptor.fileAllocationIterator();
(diskAdaptor->fileAllocationIterator()); auto itr = dynamic_cast<MultiFileAllocationIterator*>(allocitr.get());
while(!itr->finished()) { while(!itr->finished()) {
itr->allocateChunk(); itr->allocateChunk();
} }