|| || || || || || || ||

---

ImageCache.h

Go to the documentation of this file.

// ImageCache should no longer be used
//#ifndef MediaTable_ImageCache_h
#ifdef I_REALLY_WANT_TO_USE_IMAGECACHE
#define MediaTable_ImageCache_h

#include "OglGui/OglImageCache.h"

#include "TableDataSource.h"
#include "Visualization/RgbOglImage.h"

#ifdef USE_BOOST_THREADPOOL

// use this version for boost v. 34 (as on UvA FC8)
//#include "threadpool23/threadpool.hpp"
// use this version for boost >= 37 (as on other machines)
#include "threadpool25/threadpool.hpp"

#endif


namespace Impala {
namespace Application {
namespace MediaTable {


// RvB: BRAINSTORM!!
//      Als we een interface meegeven met een member functie:
//      OGLIMAGE* GetImageByID( String, id)
//      en niet meer een source meegeven. Dan zou dit een meer algemene
//      OGLIMAGE cache kunnen zijn. Preload moet er dan ook uit, maar
//      kan makkelijk aan de app kant worden geimplementeerd


/* A short note on how ImageCache and TableViewCache objects relate:

 Specifications:
  - there shall be only one application wide instance of an OGLIMAGE
    for a specified image
  - there may be more than one view associated with that OGLIMAGE
  - those views may also be cached

 Implementation:

 There is only one ImageCache instance, which handles a cached set of OGLIMAGEs

 For each Window where Views are needed there is one TableViewCache.

 TableViewCache: a cache of views with associated (refcounted) OGLIMAGE objects
 TableViewCache retrieves new OGLIMAGEs by asking ImageCache, which will get
 the image from cache if possible, or load and cache it if it's not there.

 ImageCache therefore keeps it's own (refcounted) set of OGLIMAGEs, which it
 will deref only when the cache is full.

 ImageCache::mCacheSize MUST BE larger than those of the largest TableViewCache.

 The idea is that, if a window wants to draw a specific view for an OGLIMAGE
 already displayed in another window, the OGLIMAGE does not get loaded twice.

 If a specific window scrolls trough it's own views, then those will be cached
 locally before it needs to revert to the global ImageCache cache.

 Eventually we might want to remove TableViewCache, or at least the
 caching bit in there

 Ork
*/

class ImageCache
{
public:
    typedef Impala::Core::Array::Array2dVec3UInt8   Array2dVec3UInt8;
    typedef std::pair<int, OGLIMAGE*>               ImageWithID;

    static void InitializeCache(TableDataSource *source, int size)
    {
        if (sInstance)
        {
            ILOG_WARN("ImageCache already initialized. Skipping.");
            return;
        }
        sInstance = new ImageCache(source, size);
    }

    static ImageCache* GetInstance()
    {
        if (!sInstance)
        {
            ILOG_ERROR("You forgot to initialize ImageCache with a source.");
            return 0;
        }
        return sInstance;
    }

    // RvB: Not being used
    OGLIMAGE* GetImage(int id, String column)
    {
        OGLIMAGE *i = GetImageFromCache(id, column);
        if (!i)
            i = LoadImage(id, column);
        return i;
    }

    OGLIMAGE* GetImageFromCache(int id, String column)
    {
        /* todo:
        currently images are cached by row, assumption is only one image
        per row, we should also cache-verify the column.
        */
        for (int i=0; i<mImages.size(); i++)
        {
            if (id == mImages[i]->first) {
                //ILOG_DEBUG("cache hit: " << id);
                UpdateLRU(i);
                return mImages[i]->second;
            }
        }
        return 0;
    }

#ifndef USE_BOOST_THREADPOOL
    OGLIMAGE* LoadImage(int id, String column)
    {
        // image not in cache, load and place in cache:
        // ILOG_DEBUG("cache miss: retrieving " << id << "...");
        Array2dVec3UInt8* ar = mSource->GetImageDataByID(column, id);
        if (ar == 0)
            return 0;

        ImageWithID *p = GetLeastUsedImageFromCache();
        if (p->second)
        {
            ReleaseOglImage(p->second);
            ILOG_DEBUG("Refcount for least used image now " <<
                       p->second->refCount);
        }
        else
            ILOG_DEBUG("Cache not yet grown to max size, growing...");

        p->second = Visualization::RgbOglImage::OglImage(ar);
        p->first = id;
        return p->second;
    }
#else
    OGLIMAGE* LoadImage(int id, String column)
    {
        // image not in cache, create a new dummy OGLIMAGE and place
        // this in the cache, and start a worker thread to load the
        // actual image, which will flip the changed bit on the OGLIMAGE
        // so OGL redraws it.

        // ILOG_DEBUG("cache miss: retrieving " << id << "...");

        ImageWithID *p = GetLeastUsedImageFromCache();
        if (p->second)
        {
            ReleaseOglImage(p->second);
            ILOG_DEBUG("Refcount for least used image now " <<
                       p->second->refCount);
        }
        else
            ILOG_DEBUG("Cache not yet grown to max size, growing...");

        p->second = Visualization::RgbOglImage::OglImage(mEmptyArray);
        p->first = id;

        // initialize and launch thread:
        // note: todo - upgrade this to use a threadpool instead of firing
        //       a new thread for every image.
        OglImageLoader loader(mSource, column, id, p->second);
        //boost::thread work(loader);
        mThreadPool->schedule(loader);

        mActiveTasks = true;

        return p->second;
    }
#endif

#ifndef USE_BOOST_THREADPOOL
    bool
    IsLoadingImages()
    {
        return false;
    }
#else
    bool
    IsLoadingImages()
    {
        if (!mActiveTasks)
            return false;

        ILOG_DEBUG("TP check: Size " << mThreadPool->size() << " Active tasks " << mThreadPool->active() << " Pending tasks " << mThreadPool->pending());

        if (mThreadPool->active() == 0)
            mActiveTasks = false;

        return true;
    }
#endif


    int GetImageCacheMaxSize()
    {
        return mCacheSize;
    }

    // speedup function which might be nice for demos:
    void PreloadCache()
    {
        // only works if there is one image column in the DataSource
        int preload = mCacheSize;
        if (mSource->GetTotalRows() < mCacheSize)
            preload = mSource->GetTotalRows();
        ILOG_INFO("Preloading " << preload << " images...");
        for (int i=0; i<preload; i++)
        {
            if (i%100==0)
                ILOG_DEBUG("Preloading image " << i << " of " << preload);
            LoadImage(i, "");
        }
    }

private:
    ImageCache(TableDataSource* source, int size) // constructor: private
    {
        Init(source, size);
    }

    ImageCache(ImageCache const&){};             // copy constructor: private
    ImageCache& operator=(ImageCache const&){};  // assignment operator: private

    ImageWithID* GetLeastUsedImageFromCache()
    {
        int item = mLRU.front();
        UpdateLRU(item);
        return mImages[item];
    }

    void UpdateLRU(int index)
    {
        mLRU.remove(index);
        mLRU.push_back(index);
    }

    void Init(TableDataSource* source, int size)
    {
        mCacheSize = size;
        ILOG_DEBUG("Initializing image cache for "<< mCacheSize <<" OGLIMAGEs");

#ifdef USE_BOOST_THREADPOOL
        mEmptyArray = Core::Array::ArrayCreate<Core::Array::Array2dVec3UInt8>(0, 0, 0, 0);
        // Initialize threadpool with single thread
        mThreadPool = new boost::threadpool::pool(1);
        if(source->MultiThreadImageCacheSupported)
                mThreadPool->size_controller().resize(8);
        mActiveTasks = false;
#endif

        mSource = source;

        for (int i=0; i<mCacheSize; i++)
        {
            mImages.push_back(new ImageWithID(-1, 0));
            mLRU.push_back(i);
        }
    }

#ifdef USE_BOOST_THREADPOOL
    class OglImageLoader {
        public:
            OglImageLoader(TableDataSource *s, std::string column, int row, OGLIMAGE *result)
            {
                mSource = s;
                mColumn = column;
                mRow = row;
                mImage = result;
            }

        void operator()() {
            ILOG_DEBUG("Worker thread retrieving " << mColumn << "x" << mRow);
            LoadImage();
        }

        int LoadImage()
        {
            Array2dVec3UInt8* ar = mSource->GetImageDataByID(mColumn, mRow);
            if (ar == 0)
                return 0;

            // delay loop for testing:
/*            boost::xtime xt;
            boost::xtime_get(&xt, boost::TIME_UTC);
            xt.nsec += 250 * 100000 * 4;
            boost::thread::sleep(xt);
*/

            mImage->imageHandle = ar;
            mImage->h = ar->CH();
            mImage->w = ar->CW();
            mImage->changed = 1;
            ILOG_DEBUG("Loaded image " << mColumn << "x" << mRow << " as " << mImage->w << "x" << mImage->h <<" pixels in " << mImage);

            return 1;
        }

        private:
        TableDataSource *mSource;
        std::string      mColumn;
        int              mRow;
        OGLIMAGE*        mImage;
    };
#endif


    int                         mCacheSize;

    std::list<int>              mLRU;
    std::vector<ImageWithID*>   mImages;
    TableDataSource*            mSource;

    static ImageCache*          sInstance;

#ifdef USE_BOOST_THREADPOOL
    Core::Array::Array2dVec3UInt8* mEmptyArray;
    boost::threadpool::pool     *mThreadPool;
    bool                         mActiveTasks;
#endif

    ILOG_VAR_DEC;
};

ImageCache* ImageCache::sInstance = 0;

ILOG_VAR_INIT(ImageCache, Application.MediaTable);

} // namespace MediaTable
} // namespace Application
} // namespace Impala
#endif // ImageCache_h

---