From cc82da3babdab3040d6e16624b5aefcd97138925 Mon Sep 17 00:00:00 2001 From: Tatsuhiro Tsujikawa Date: Sat, 11 Jun 2011 17:34:17 +0900 Subject: Added StreamPieceSelector class. This class abstracts the piece selection algorithm for HTTP/FTP download. --- src/DefaultPieceStorage.cc | 8 +++-- src/DefaultPieceStorage.h | 5 +-- src/DefaultStreamPieceSelector.cc | 57 +++++++++++++++++++++++++++++++++ src/DefaultStreamPieceSelector.h | 60 +++++++++++++++++++++++++++++++++++ src/Makefile.am | 4 ++- src/PieceStorage.h | 2 +- src/SegmentMan.cc | 4 +-- src/StreamPieceSelector.h | 67 +++++++++++++++++++++++++++++++++++++++ src/UnknownLengthPieceStorage.cc | 4 +-- src/UnknownLengthPieceStorage.h | 2 +- 10 files changed, 201 insertions(+), 12 deletions(-) create mode 100644 src/DefaultStreamPieceSelector.cc create mode 100644 src/DefaultStreamPieceSelector.h create mode 100644 src/StreamPieceSelector.h (limited to 'src') diff --git a/src/DefaultPieceStorage.cc b/src/DefaultPieceStorage.cc index 4472d99b..0696f30c 100644 --- a/src/DefaultPieceStorage.cc +++ b/src/DefaultPieceStorage.cc @@ -56,6 +56,7 @@ #include "Option.h" #include "fmt.h" #include "RarestPieceSelector.h" +#include "DefaultStreamPieceSelector.h" #include "array_fun.h" #include "PieceStatMan.h" #include "wallclock.h" @@ -76,7 +77,8 @@ DefaultPieceStorage::DefaultPieceStorage endGamePieceNum_(END_GAME_PIECE_NUM), option_(option), pieceStatMan_(new PieceStatMan(downloadContext->getNumPieces(), true)), - pieceSelector_(new RarestPieceSelector(pieceStatMan_)) + pieceSelector_(new RarestPieceSelector(pieceStatMan_)), + streamPieceSelector_(new DefaultStreamPieceSelector(bitfieldMan_)) {} DefaultPieceStorage::~DefaultPieceStorage() @@ -338,11 +340,11 @@ bool DefaultPieceStorage::hasMissingUnusedPiece() return bitfieldMan_->getFirstMissingUnusedIndex(index); } -SharedHandle DefaultPieceStorage::getSparseMissingUnusedPiece +SharedHandle DefaultPieceStorage::getMissingPiece (size_t minSplitSize, const unsigned char* ignoreBitfield, size_t length) { size_t index; - if(bitfieldMan_->getSparseMissingUnusedIndex + if(streamPieceSelector_->select (index, minSplitSize, ignoreBitfield, length)) { return checkOutPiece(index); } else { diff --git a/src/DefaultPieceStorage.h b/src/DefaultPieceStorage.h index 0fb22ff3..bb38dc43 100644 --- a/src/DefaultPieceStorage.h +++ b/src/DefaultPieceStorage.h @@ -48,6 +48,7 @@ class DiskWriterFactory; class FileEntry; class PieceStatMan; class PieceSelector; +class StreamPieceSelector; #define END_GAME_PIECE_NUM 20 @@ -85,7 +86,7 @@ private: SharedHandle pieceStatMan_; SharedHandle pieceSelector_; - + SharedHandle streamPieceSelector_; #ifdef ENABLE_BITTORRENT void getMissingPiece (std::vector >& pieces, @@ -156,7 +157,7 @@ public: virtual bool hasMissingUnusedPiece(); - virtual SharedHandle getSparseMissingUnusedPiece + virtual SharedHandle getMissingPiece (size_t minSplitSize, const unsigned char* ignoreBitfield, size_t length); virtual SharedHandle getMissingPiece(size_t index); diff --git a/src/DefaultStreamPieceSelector.cc b/src/DefaultStreamPieceSelector.cc new file mode 100644 index 00000000..2a899a89 --- /dev/null +++ b/src/DefaultStreamPieceSelector.cc @@ -0,0 +1,57 @@ +/* */ +#include "DefaultStreamPieceSelector.h" +#include "BitfieldMan.h" + +namespace aria2 { + +DefaultStreamPieceSelector::DefaultStreamPieceSelector +(BitfieldMan* bitfieldMan) + : bitfieldMan_(bitfieldMan) +{} + +DefaultStreamPieceSelector::~DefaultStreamPieceSelector() {} + +bool DefaultStreamPieceSelector::select +(size_t& index, + size_t minSplitSize, + const unsigned char* ignoreBitfield, + size_t length) +{ + return bitfieldMan_->getSparseMissingUnusedIndex + (index, minSplitSize, ignoreBitfield, length); +} + +} // namespace aria2 diff --git a/src/DefaultStreamPieceSelector.h b/src/DefaultStreamPieceSelector.h new file mode 100644 index 00000000..20f4f42c --- /dev/null +++ b/src/DefaultStreamPieceSelector.h @@ -0,0 +1,60 @@ +/* */ +#ifndef D_DEFAULT_STREAM_PIECE_SELECTOR_H +#define D_DEFAULT_STREAM_PIECE_SELECTOR_H + +#include "StreamPieceSelector.h" + +namespace aria2 { + +class BitfieldMan; + +class DefaultStreamPieceSelector:public StreamPieceSelector { +public: + DefaultStreamPieceSelector(BitfieldMan* bitfieldMan); + virtual ~DefaultStreamPieceSelector(); + + virtual bool select + (size_t& index, + size_t minSplitSize, + const unsigned char* ignoreBitfield, + size_t length); +private: + BitfieldMan* bitfieldMan_; +}; + +} // namespace aria2 + +#endif // D_DEFAULT_STREAM_PIECE_SELECTOR_H diff --git a/src/Makefile.am b/src/Makefile.am index 97e0ded3..a627c8f4 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -221,7 +221,9 @@ SRCS = Socket.h\ HttpListenCommand.cc HttpListenCommand.h\ HttpServerCommand.cc HttpServerCommand.h\ HttpServerResponseCommand.cc HttpServerResponseCommand.h\ - HttpServer.cc HttpServer.h + HttpServer.cc HttpServer.h\ + StreamPieceSelector.h\ + DefaultStreamPieceSelector.cc DefaultStreamPieceSelector.h if ENABLE_XML_RPC SRCS += XmlRpcRequestParserController.cc XmlRpcRequestParserController.h\ diff --git a/src/PieceStorage.h b/src/PieceStorage.h index 6f3c09bc..762201de 100644 --- a/src/PieceStorage.h +++ b/src/PieceStorage.h @@ -131,7 +131,7 @@ public: * Returns a missing piece if available. Otherwise returns 0; * If ignoreBitfield is set, indexes of true bit are excluded. */ - virtual SharedHandle getSparseMissingUnusedPiece + virtual SharedHandle getMissingPiece (size_t minSplitSize, const unsigned char* ignoreBitfield, size_t length) = 0; /** diff --git a/src/SegmentMan.cc b/src/SegmentMan.cc index dcc04334..d4aa3122 100644 --- a/src/SegmentMan.cc +++ b/src/SegmentMan.cc @@ -173,7 +173,7 @@ void SegmentMan::getInFlightSegment SharedHandle SegmentMan::getSegment(cuid_t cuid, size_t minSplitSize) { SharedHandle piece = - pieceStorage_->getSparseMissingUnusedPiece + pieceStorage_->getMissingPiece (minSplitSize, ignoreBitfield_.getFilterBitfield(), ignoreBitfield_.getBitfieldLength()); return checkoutSegment(cuid, piece); @@ -193,7 +193,7 @@ void SegmentMan::getSegment while(segments.size() < maxSegments) { SharedHandle segment = checkoutSegment(cuid, - pieceStorage_->getSparseMissingUnusedPiece + pieceStorage_->getMissingPiece (minSplitSize, filter.getFilterBitfield(), filter.getBitfieldLength())); if(!segment) { diff --git a/src/StreamPieceSelector.h b/src/StreamPieceSelector.h new file mode 100644 index 00000000..a8f95513 --- /dev/null +++ b/src/StreamPieceSelector.h @@ -0,0 +1,67 @@ +/* */ +#ifndef D_STREAM_PIECE_SELECTOR_H +#define D_STREAM_PIECE_SELECTOR_H + +#include "common.h" + +#include + +namespace aria2 { + +// Select piece for HTTP/FTP download. For BitTorrent downloads, use +// PieceSelector interface. +class StreamPieceSelector { +public: + virtual ~StreamPieceSelector() {} + // Selected piece index will be stored in index. To ignore some + // piece indexes from selection, use ignoreBitfield and set + // corresponding bit. length is the number of byte of + // ignoreBitfield. The number of bits in ignoreBitfield must be + // equal to the number of blocks in BitfieldMan. If piece index is + // selected, returns true. Otherwise, returns false. minSplitSize + // is a advice to derived class not to select piece such which the + // distance between it and already selected piece is less than + // minSplitSize. + virtual bool select + (size_t& index, + size_t minSplitSize, + const unsigned char* ignoreBitfield, + size_t length) = 0; +}; + +} // namespace aria2 + +#endif // D_STREAM_PIECE_SELECTOR_H diff --git a/src/UnknownLengthPieceStorage.cc b/src/UnknownLengthPieceStorage.cc index abb40354..706d5e4b 100644 --- a/src/UnknownLengthPieceStorage.cc +++ b/src/UnknownLengthPieceStorage.cc @@ -129,7 +129,7 @@ bool UnknownLengthPieceStorage::hasMissingUnusedPiece() abort(); } -SharedHandle UnknownLengthPieceStorage::getSparseMissingUnusedPiece +SharedHandle UnknownLengthPieceStorage::getMissingPiece (size_t minSplitSize, const unsigned char* ignoreBitfield, size_t length) { if(downloadFinished_) { @@ -146,7 +146,7 @@ SharedHandle UnknownLengthPieceStorage::getSparseMissingUnusedPiece SharedHandle UnknownLengthPieceStorage::getMissingPiece(size_t index) { if(index == 0) { - return getSparseMissingUnusedPiece(0, 0, 0); + return getMissingPiece(0, 0, 0); } else { return SharedHandle(); } diff --git a/src/UnknownLengthPieceStorage.h b/src/UnknownLengthPieceStorage.h index c1b7d4f2..e2531f14 100644 --- a/src/UnknownLengthPieceStorage.h +++ b/src/UnknownLengthPieceStorage.h @@ -106,7 +106,7 @@ public: /** * Returns a missing piece if available. Otherwise returns 0; */ - virtual SharedHandle getSparseMissingUnusedPiece + virtual SharedHandle getMissingPiece (size_t minSplitSize, const unsigned char* ignoreBitfield, size_t length); /** -- cgit