• About
• Gallery
• Download
• Documentation
• Publications
• Community

include/voreen/core/io/cache.h

/**********************************************************************
 *                                                                    *
 * Voreen - The Volume Rendering Engine                               *
 *                                                                    *
 * Copyright (C) 2005-2010 The Voreen Team. <http://www.voreen.org>   *
 *                                                                    *
 * This file is part of the Voreen software package. Voreen is free   *
 * software: you can redistribute it and/or modify it under the terms *
 * of the GNU General Public License version 2 as published by the    *
 * Free Software Foundation.                                          *
 *                                                                    *
 * Voreen is distributed in the hope that it will be useful,          *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of     *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the       *
 * GNU General Public License for more details.                       *
 *                                                                    *
 * You should have received a copy of the GNU General Public License  *
 * in the file "LICENSE.txt" along with this program.                 *
 * If not, see <http://www.gnu.org/licenses/>.                        *
 *                                                                    *
 * The authors reserve all rights not expressly granted herein. For   *
 * non-commercial academic use see the license exception specified in *
 * the file "LICENSE-academic.txt". To get information about          *
 * commercial licensing please contact the authors.                   *
 *                                                                    *
 **********************************************************************/

#ifndef VRN_CACHE_H
#define VRN_CACHE_H

#include "voreen/core/io/cacheindex.h"
#include "voreen/core/ports/allports.h"
#include "voreen/core/datastructures/volume/volumehandle.h"
#include "voreen/core/voreenapplication.h"
#include "tgt/filesystem.h"
#include <typeinfo>

namespace voreen {

class Processor;

class CacheBase {
public:
    CacheBase(const std::string& cachedObjectsClassName, const std::type_info& assignedPortType);

    virtual ~CacheBase() { /* dtor has nothing to do */ }

    const std::type_info& getAssignedPortType() const;

    std::vector<Port*> getCacheConcernedOutports(Processor* const processor) const;

    const std::string& getCachedObjectsClassName() const;

    std::string getProcessorsInportConfig(const Processor* processor) const;

    bool isCompatible(Processor* const processor) const;

    bool isEnabled() const;

    void setEnabled(const bool enable);

    static bool isCachingEnabled() { return cachingEnabled_; }

    static void setCachingEnabled(const bool enable) { cachingEnabled_ = enable; }

protected:
    virtual std::string portContentToString(Port* const port) const = 0;

protected:
    const std::type_info& assignedPortType_;
    const std::string cachedObjectsClassName_;
    bool isEnabled_;

private:
    static bool cachingEnabled_;
};

// ============================================================================

template<typename S>
struct CacheObject {
    explicit CacheObject(S* object, const bool originsCache)
        : object_(object), originsCache_(originsCache)
    {
    }

    ~CacheObject() {
        if (originsCache_ == true)
            delete object_;
    }

    S* object_;
    bool originsCache_;
};

template<>
struct CacheObject<int> {
    explicit CacheObject(int object, const bool)
        : object_(object)
    {
    }

    ~CacheObject() {}

    int object_;
};

// ============================================================================

template<typename T>
class Cache : public CacheBase {
public:
    Cache(const std::string& cachedObjectsClassName, const std::type_info& assignedPortType);

    virtual ~Cache();

    T* find(Processor* const processor, Port* const port);

    bool update(Processor* const processor);

protected:
    virtual T* getPortData(Port* const port) const {
        GenericPort<T>* gp = dynamic_cast< GenericPort<T>* >(port);
        if(gp)
            return gp->getData();
        else
            return 0;
    }

    virtual T* loadObject(const std::string& filename) const = 0;

    virtual std::string saveObject(T* object, const std::string& directory,
        const std::string& filename) = 0;

protected:
    typedef std::map<std::string, CacheObject<T>* > ObjectMap;
    ObjectMap objectMap_;

    CacheIndex& cacheIndex_;

private:
    void cleanup();

private:
    static const std::string loggerCat_;
    const std::string cacheFolder_;
};

template<typename T>
Cache<T>::Cache(const std::string& cachedObjectsClassName, const std::type_info& assignedPortType)
    : CacheBase(cachedObjectsClassName, assignedPortType),
    objectMap_(),
    cacheIndex_(CacheIndex::getInstance()),
    cacheFolder_(VoreenApplication::app()->getCachePath())
{
}

template<typename T>
Cache<T>::~Cache() {
    typename Cache<T>::ObjectMap::iterator it = objectMap_.begin();
    for ( ; it != objectMap_.end(); ++it) {
        delete it->second;
        it->second = 0;
    }
    objectMap_.clear();
}

template<typename T>
T* Cache<T>::find(Processor* const processor, Port* const port)
{
    // Do nothing if this cache is disabled in general or in particular,
    // or the parameters are bad.
    //
    if ((isEnabled() == false) || (processor == 0) || (port == 0))
        return 0;

    // 1. Check whether the cached data already exist in the local object map and
    // return them if so.
    //
    std::string inportConfig = getProcessorsInportConfig(processor);
        CacheIndex::IndexKey key = CacheIndex::generateCacheIndexKey(processor, port, inportConfig);
    std::string keyStr = key.first + "." + key.second;
    typename Cache<T>::ObjectMap::const_iterator it = objectMap_.find(keyStr);
    if (it != objectMap_.end()) {
        //std::cout << "find(): found object in local map!";
        cacheIndex_.incrementRefCounter(key);
        return (it->second)->object_;
    }

    // 2. If the data were not in the local object map, look up the cache index entry.
    // If the there is not even a cache index entry, the data are not cached at all
    // and 0 is returned.
    //
    const std::string filename = cacheIndex_.findFilename(processor, port, inportConfig);
    if (filename.empty() == true)
        return 0;

    // 3. Otherwise, if there is a cache index entry, load the concerned object and
    // store it in the local object map for future lookups.
    //
    T* object = loadObject(filename);
    if (object != 0) {
        //std::cout << "find(): found cache index entry for object!";
        std::pair<typename Cache<T>::ObjectMap::iterator, bool> res =
            objectMap_.insert(std::make_pair(keyStr, new CacheObject<T>(object, true)));
    }
    return object;
}

template<typename T>
bool Cache<T>::update(Processor* const processor) {
    // Do nothing if caching is disabled in general or in particular, or if one of the
    // parameters is bad.
    //
    if ((isEnabled() == false) || (processor == 0))
        return false;

    std::string inportConfig = getProcessorsInportConfig(processor);
    if (inportConfig.empty() == true)
        return false;

    std::vector<Port*> concernedPorts = getCacheConcernedOutports(processor);
    bool result = (! concernedPorts.empty());
    for (size_t i = 0; i < concernedPorts.size(); ++i) {
        T* object = getPortData(concernedPorts[i]);
        if (object == 0)
            continue;

        // try to find an entry for that processor and port with the current
        // configuration on the inports in the index of the cache
        //
        std::string filename = cacheIndex_.findFilename(processor, concernedPorts[i], inportConfig);
        bool requiresNewEntry = filename.empty();

        // save the object itself and add entry to the cache's index. if filename is not empty,
        // the file will be replaced. otherwise a new file will be created and the filename
        // which will be generated is retruned.
        //
        filename = saveObject(object, cacheFolder_, filename);
        result = (result && (! filename.empty()));
        std::string key;
        if ((result == true) && (requiresNewEntry == true)) {
            key = cacheIndex_.insert(processor, concernedPorts[i], cachedObjectsClassName_,
                inportConfig, filename);
            // cleanup cache
            cleanup();
        }

        if ((key.empty() == true) && (requiresNewEntry == true)) {
            LFATAL("update(): Insertion of cache index failed!");
            return false;
        }

        // add or replace the internal 'copy' of the object
        //
        std::pair<typename Cache<T>::ObjectMap::iterator, bool> res =
            objectMap_.insert(std::make_pair(key, new CacheObject<T>(object, false)));

        if (res.second == false) {
            //std::cout << "update(): replacing existing data...";
            delete (res.first)->second;
            (res.first)->second = new CacheObject<T>(object, false);
        }
    }
    return result;
}

// private methods
//

template<typename T>
void Cache<T>::cleanup() {
    std::vector<std::pair<std::string, std::string> > dumps = cacheIndex_.cleanup();
    for (size_t i = 0; i < dumps.size(); ++i) {

        // 1. Erase the object from the local object map
        //
        objectMap_.erase(dumps[i].first);

        // 2. Delete the file from the cache's directory
        //
        std::string& file = dumps[i].second;
        //std::cout << "cleanup(): deleting file '" << file << "'...";
        tgt::FileSystem::deleteFile(file);

        // If file is a .dat file, also try to delete related .raw file
        //
        if (tgt::FileSystem::fileExtension(file) == "dat") {
            file.replace(file.size() - 3, 3, "raw");
            tgt::FileSystem::deleteFile(file);
        }
    }
}

template<typename T> const std::string Cache<T>::loggerCat_("Cache<T>");

}   // namespace

#endif

• Getting Started
• Video Tutorials
• Build Instructions
• Adding a Module
• Programming Tutorials
• API Documentation
• FAQ

edit