mirror/OpenSpace
1
0
Fork 0
mirror of https://github.com/OpenSpace/OpenSpace.git synced 2026-04-23 20:50:59 -05:00
Code Issues Packages Projects Releases Wiki Activity

Update AsyncTileReader according to new features of ghoul::ThreadPool

Browse Source
This commit is contained in:
Erik Broberg
2016-08-11 22:04:15 -04:00
parent 1dd569a3e1
commit 6cb3dd1fea
4 changed files with 41 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/globebrowsing/tile/asynctilereader.cpp
+31 -39
View File
@@ -119,7 +119,7 @@ namespace openspace {
std::shared_ptr<TileDataset> tileDataset,
std::shared_ptr<ghoul::ThreadPool> pool)
: _tileDataset(tileDataset)
, _concurrentJobManager(pool)
, _threadPool(pool)
{
}
@@ -133,59 +133,51 @@ namespace openspace {
return _tileDataset;
}
bool AsyncTileDataProvider::enqueueTextureData(const ChunkIndex& chunkIndex) {
//auto tileDiskCache = std::make_shared<TileDiskCache>("test");
bool AsyncTileDataProvider::enqueueTileIO(const ChunkIndex& chunkIndex) {
if (satisfiesEnqueueCriteria(chunkIndex)) {
auto job = std::make_shared<TileLoadJob>(_tileDataset, chunkIndex);
//auto job = std::make_shared<DiskCachedTileLoadJob>(_tileDataset, chunkIndex, tileDiskCache, "ReadAndWrite");
_concurrentJobManager.enqueueJob(job);
_enqueuedTileRequests[chunkIndex.hashKey()] = chunkIndex;
const static auto job = [](const ChunkIndex& chunkIndex, std::shared_ptr<TileDataset> tileDataset) {
return tileDataset->readTileData(chunkIndex);
};
FutureResult futureResult = _threadPool->queue(job, chunkIndex, _tileDataset);
_futureTileIOResults[chunkIndex.hashKey()] = std::move(futureResult);
return true;
}
return false;
}
bool AsyncTileDataProvider::hasLoadedTextureData() const{
return _concurrentJobManager.numFinishedJobs() > 0;
}
std::shared_ptr<TileIOResult> AsyncTileDataProvider::nextTileIOResult() {
auto tileIOResult = _concurrentJobManager.popFinishedJob()->product();
ChunkHashKey key = tileIOResult->chunkIndex.hashKey();
if (_enqueuedTileRequests.find(key) != _enqueuedTileRequests.end()) {
_enqueuedTileRequests.erase(key);
}
return tileIOResult;
}
bool AsyncTileDataProvider::satisfiesEnqueueCriteria(const ChunkIndex& chunkIndex) const {
auto it = _enqueuedTileRequests.begin();
auto end = _enqueuedTileRequests.end();
for (; it != end; it++) {
const ChunkIndex& otherChunk = it->second;
if (chunkIndex.level == otherChunk.level &&
chunkIndex.manhattan(otherChunk) < 1) {
return false;
std::vector<std::shared_ptr<TileIOResult>> AsyncTileDataProvider::getTileIOResults() {
std::vector<std::shared_ptr<TileIOResult>> readyResults;
auto it = _futureTileIOResults.begin();
while(it != _futureTileIOResults.end()) {
std::future_status status = it->second.wait_for(std::chrono::seconds(0));
if (status == std::future_status::ready) {
readyResults.push_back(it->second.get());
it = _futureTileIOResults.erase(it);
}
else {
it++;
}
}
return true;
return readyResults;
}
bool AsyncTileDataProvider::satisfiesEnqueueCriteria(const ChunkIndex& chunkIndex) const {
// only allow tile to be enqueued if it's not already enqueued
return _futureTileIOResults.find(chunkIndex.hashKey()) == _futureTileIOResults.end();
}
void AsyncTileDataProvider::reset() {
_enqueuedTileRequests.clear();
_concurrentJobManager.reset();
// also clear tiles that has just been finished loading
while (hasLoadedTextureData()) {
nextTileIOResult(); // get it and throw it away
}
_futureTileIOResults.clear();
_threadPool->stop(ghoul::ThreadPool::RunRemainingTasks::No);
_threadPool->start();
getTextureDataProvider()->reset();
}
void AsyncTileDataProvider::clearRequestQueue() {
_concurrentJobManager.clearEnqueuedJobs();
_enqueuedTileRequests.clear();
_threadPool->clearRemainingTasks();
_futureTileIOResults.clear();
}
} // namespace openspace
modules/globebrowsing/tile/asynctilereader.h
+7 -6
View File
@@ -123,10 +123,9 @@ namespace openspace {
~AsyncTileDataProvider();
bool enqueueTextureData(const ChunkIndex& chunkIndex);
bool hasLoadedTextureData() const;
std::shared_ptr<TileIOResult> nextTileIOResult();
bool enqueueTileIO(const ChunkIndex& chunkIndex);
std::vector<std::shared_ptr<TileIOResult>> getTileIOResults();
void reset();
void clearRequestQueue();
@@ -138,10 +137,12 @@ namespace openspace {
virtual bool satisfiesEnqueueCriteria(const ChunkIndex&) const;
private:
using FutureResult = std::future<std::shared_ptr<TileIOResult>>;
std::shared_ptr<TileDataset> _tileDataset;
ConcurrentJobManager<TileIOResult> _concurrentJobManager;
std::unordered_map<ChunkHashKey, ChunkIndex> _enqueuedTileRequests;
std::shared_ptr<ghoul::ThreadPool> _threadPool;
std::unordered_map<ChunkHashKey, FutureResult> _futureTileIOResults;
};
modules/globebrowsing/tile/layeredtextureshaderprovider.cpp
+1 -2
View File
@@ -97,8 +97,7 @@ namespace openspace {
LayeredTexturePreprocessingData preprocessingData)
{
_updatedOnLastCall = false;
if (!(preprocessingData == _preprocessingData) || _programObject == nullptr)
{
if (!(preprocessingData == _preprocessingData) || _programObject == nullptr) {
recompileShaderProgram(preprocessingData);
_updatedOnLastCall = true;
}
modules/globebrowsing/tile/tileprovider.cpp
+2 -2
View File
@@ -320,8 +320,8 @@ namespace openspace {
void CachingTileProvider::initTexturesFromLoadedData() {
while (_asyncTextureDataProvider->hasLoadedTextureData()) {
std::shared_ptr<TileIOResult> tileIOResult = _asyncTextureDataProvider->nextTileIOResult();
auto readyTileIOResults = _asyncTextureDataProvider->getReadyTileIOResults();
for(auto tileIOResult : readyTileIOResults){
ChunkHashKey key = tileIOResult->chunkIndex.hashKey();
Tile tile = createTile(tileIOResult);
_tileCache->put(key, tile);