Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

CacheManagerLRU.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       CacheManagerLRU.cpp                                           *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program 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    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

// Definition: LRU Cache Manager Implementation//

#include "CacheManagerLRU.hpp"
#include "ESInfo.hpp"
#include "VideoESInfo.hpp"
#include "ContainerInfo.hpp"    //includes metaitem+QualityInfo
#include "container/Video4LinuxContainerFile.hpp"
#include "global.hpp"
#include "../net/Url.hpp"
#include "ReferenceCounter.hpp"
#include "BitField.hpp"

CacheManagerLRU::CacheManagerLRU(u32 size, bool serverMod)
{
        serverMode=serverMod;
    cacheSize = size;
    actSize = 0;
    requests = 0;
    hits = 0;
    byteRequested = 0;
    byteHits = 0;
    qualityHits = 0.0;
    lock.initialize("CacheManagerLRU-lock");
};

CacheManagerLRU::~CacheManagerLRU()
{
        // we delete MetaObject, this deletes
        // all ContainerInfo objects too
        dprintf_full("~CacheManagerLRU() destructing\n");

        /*
        ** FIXME: the fopen already hangs the proxy on my system.. so turned off...
        FILE* fp=fopen("lru.stat","wb");
        dprintf_full("~CacheManagerLRU() destructing af\n");
        if(fp) {
                saveStatisticTo(fp);
                fclose(fp);
        }
        */


  list < MetaObject * >::iterator start;
  start = metaObjects.begin();

        while (!metaObjects.empty()) {
                start = metaObjects.begin();
                delete (*start);
                metaObjects.pop_front();
  }
        lock.destroy();
}

void CacheManagerLRU::putVideo(ContainerInfo * video,u32 dskSpaceAlreadyReserved)
{
        if(video==NULL) {
                actSize-= dskSpaceAlreadyReserved;
                return;
        }
        assert(video->getUsageCounter()->getUsage()==0);
        internalConsistencyCheck();
        u32 videoSize = video->getFileSize();
        byteRequested += videoSize;
        float percBits = 1;
        if (video->getFirstVisualES()) {
                percBits = video->getFirstVisualES()->getFrameStatistic()->getPercentageSetBits();
                dprintf_full("CacheManagerLRU::putVideo Inserting video %s, comp%f\r\n",video->getUrl()->toString(),percBits);
        
                if(percBits <=0.9) {
                        actSize-= dskSpaceAlreadyReserved;
                        prxStat.deletedDueToLowQuality++;
                        video->destroy();
                        dprintf_full("Deleted incomplete video %s\n",video->getUrl()->toString());
                        return;
                }
        }
        else if (video->getFirstAudioES())
                //FIXME: this stream only has audio, keep it in cache...
                dprintf_full("CacheManagerLRU::putVideo Inserting audio-only stream %s\r\n",video->getUrl()->toString());


        list<ESInfo*> *les=video->getESList();
        list<ESInfo*>::iterator lis;

        for(lis=les->begin();lis!=les->end();lis++) {
                u64 fs=(*lis)->getCurrentDemuxedMediaSize();
                fs*=8000;
                fs/=(*lis)->getDurationInMs();
                (*lis)->setAvgBandwidth((u32)fs);
                if( (*lis)->getMaxBandwidth()<(*lis)->getAvgBandwidth())
                        (*lis)->setMaxBandwidth((*lis)->getAvgBandwidth());
        }

        
        MetaObject* meta=findMetaObject(video->getUrl());
        if(!meta) {
                meta=new MetaObject(video);
                metaObjects.push_front(meta);
        }
        else {
                if(!meta->addMP4Stream(video)) {
                        video=NULL; // was deleted
                        actSize-= dskSpaceAlreadyReserved;
                }
        }

  if (video && videoSize <= cacheSize) {
                lrulist.push_front(video);
                actSize += video->getFileSize();
                actSize-= dskSpaceAlreadyReserved;
                if (actSize > cacheSize) {
                        dprintf_full("CacheManagerLRU::putVideo Cache Replacement needed\n");
                        replace(false);
                }
  } else if(video){
                dprintf_full("CacheManagerLRU::putVideo: video %s deleted because its size %i is larger than CacheSize %i\r\n",
             video->getUrl()->toString(), videoSize, cacheSize);
                meta->deleteMP4Stream(video);
                actSize-= dskSpaceAlreadyReserved;
                video->destroy();
                delete video;
  }
  internalConsistencyCheck();
 dprintf_full("CacheManagerLRU::putVideo END\r\n");
};

//PROBLEM: we have no way of knowing if its a quality hit or not --> session knows
ContainerInfo *CacheManagerLRU::getVideo(const Url *name)
{
    list < ContainerInfo * >::iterator start, end;
        ContainerInfo* vid  = NULL;
    start = lrulist.begin();
    end = lrulist.end();
        internalConsistencyCheck();
    requests++;
        printf("*******CacheManagerLRU::getVideo use URL: #%s#\n", name->toString());
    if (strcmp(name->toString(), "v4l") != 0)
        {

                if(start==end) {
                        return NULL;
                }
                bool firstDel=false;
    
                while(start != end) {
                        
                        vid=(*start);
                        dprintf_full("CacheManagerLRU::getVideo found Cached URL: #%s#\n",vid->getUrl()->toString());
                        VideoESInfo* ves=vid->getFirstVisualES();
                        //                      AudioESInfo* aes=vid->getFirstAudioES();
                        float qual=0.0;
                        if(ves && ves->getFrameStatistic())
                                qual=ves->getFrameStatistic()->getPercentageSetBits();
                        dprintf_full("CacheManagerLRU::getVideo found %f complete (use %u)\n",qual,(*start)->getUsageCounter()->getUsage());
                        // quality too low and not used (aka quality will improve)
/*                      if(qual<0.9 && (*start)->getUsageCounter()->deactivateWhenUsage(0)) {
                                (*start)->destroy();
                                MetaObject* meta=(*start)->getMetaObject();
                                if(meta->getNumberOfVariations()==1) {
                                        deleteMetaObject(meta->getUrl());
                                }
                                else {
                                        meta->deleteMP4Stream(*start); // frees *start
                                }
                                
                                list < ContainerInfo * >::iterator tmp= start;
                                if(start!=lrulist.begin()) {
                                        start--; // point before the element which is deleted
                                        lrulist.erase(tmp);
                                }
                                else { // we delete the first element
                                        lrulist.erase(tmp);                             
                                        firstDel=true;
                                        start=lrulist.begin();
                                }
                        }
                        else*/ if ((*start)->getUrl()->isEqual(name,serverMode) )        {
                                lrulist.push_front(*start);
                                lrulist.erase(start);
                                start = lrulist.begin();
                                hits++;
                                byteRequested += (*start)->getFileSize();
                                byteHits += (*start)->getFileSize();
                                qualityHits += (*start)->getActQuality();
                                (*start)->setLastRequestTime(requests);
                                return (*start);
                        }
                        if(!firstDel)
                                ++start;
                }
        }
#ifndef WIN32
        else
        {
                dprintf_full("CacheManagerLRU::getVideo: Using v4lContailerfile");
                vid=Video4LinuxContainerFile::loadContainerInfo();
                return vid;
        }
#endif

        return NULL;


};

MetaObject* CacheManagerLRU::findMetaObject(const Url* url) {

        MetaObject* temp;
        ContainerInfo *tempInfo;
        list < MetaObject * >::iterator start, end;
        start = metaObjects.begin();
        end = metaObjects.end();

        dprintf_full("CacheManagerLRU::findMetaObject URL: %s \n",url->toString());
#ifndef WIN32
        if (strcmp(url->getFileName(), "v4l") == 0)
        {
                dprintf_full("CacheManagerLRU::findMetaObject using v4l:\n");
                tempInfo = Video4LinuxContainerFile::loadContainerInfo();
                dprintf_full("CacheManagerLRU::findMetaObject v4l: creating v4l containerinfo ok!!\n");
                temp = new MetaObject(tempInfo);
                if (temp == NULL) {
                        dprintf_full("CacheManagerLRU::findMetaObject v4l: NULL!!\n");
                } 
                else {
                        dprintf_full("CacheManagerLRU::findMetaObject v4l: OK, Number of variations : %d!!\n", temp->getNumberOfVariations());  
                }
                return temp;
        }
#endif

        for (; start != end; ++start) {
                const Url* tmp=(*start)->getUrl();
                dprintf_full("CacheManagerLRU::findMetaObject compares %s with %s\n",url->toString(), tmp->toString());
                if (url->isEqual(tmp,serverMode)) {
                        return (*start);
                }
        }
        
        return NULL;
};

void CacheManagerLRU::internalConsistencyCheck()
{
        u32 metaVariations=0;
        u32 sumVar=0;
        list < MetaObject * >::iterator start, end;
    start = metaObjects.begin();
    end = metaObjects.end();
        for (; start != end; ++start) {
                metaVariations+=(*start)->getNumberOfVariations();
        }
        list < ContainerInfo * >::iterator cstart, cend;
    cstart = lrulist.begin();
    cend = lrulist.end();
        sumVar=lrulist.size();
        assert(sumVar==metaVariations);
        for (; cstart != cend; ++cstart) {
                assert((*cstart)->getMetaObject());
        }
};

void CacheManagerLRU::deleteMetaObject(const Url* url) {

    list < MetaObject * >::iterator start, end;
    start = metaObjects.begin();
    end = metaObjects.end();
        for (; start != end; ++start) {
                if ((*start)->getUrl()->isEqual(url,serverMode)) {
                        delete (*start);
                        metaObjects.erase(start);
                        return;
                }
        }
        internalConsistencyCheck();
};
bool CacheManagerLRU::replace(bool testPriorDelete)
{
    list < ContainerInfo * >::iterator end;
        internalConsistencyCheck();
        if(testPriorDelete) {
                u32 maxMemFreeable=getSizeOfNotLockedObjects();
                // is it possible to get actSize < cacheSize?
                assert(actSize>=maxMemFreeable);
                if(actSize-maxMemFreeable>cacheSize)
                        return false;
        }

    while (!lrulist.empty() && actSize > cacheSize) {
                end = --lrulist.end();
                // find a video that is not in use
                while( end != lrulist.begin() && 
                          !(*end)->getUsageCounter()->deactivateWhenUsage(0))
                        --end;

                if ((*end)->getUsageCounter()->getUsage() == 0) {
                        actSize -= (*end)->getFileSize();
                        // LRU just deletes the file
                        (*end)->destroy();      // deletes the file
                        MetaObject* meta=(*end)->getMetaObject();
                        if(meta->getNumberOfVariations()==1) {
                                deleteMetaObject(meta->getUrl());
                        }
                        else {
                                bool ok=meta->deleteMP4Stream(*end); // frees *end
                                assert(ok);
                        }
                        lrulist.erase(end);
                }
    }
        internalConsistencyCheck();
        return (actSize<cacheSize);
}

u32 CacheManagerLRU::getSizeOfNotLockedObjects()
{
        list < ContainerInfo * >::iterator ci;
        u32 results=0;
        for(ci=lrulist.begin();ci!=lrulist.end();++ci) {
                if ((*ci)->getUsageCounter()->getUsage() == 0) {
                        results+=(*ci)->getFileSize();
                }
        }
        return results;
};

u32 CacheManagerLRU::getCacheSize() const
{
    return cacheSize;
}

u32 CacheManagerLRU::getActSize() const
{
    return actSize;
}

u32 CacheManagerLRU::getRequests() const
{
    return requests;
}

u32 CacheManagerLRU::getHits() const
{
    return hits;
}

u64 CacheManagerLRU::getByteRequested() const
{
    return byteRequested;
}

u64 CacheManagerLRU::getByteHits() const
{
    return byteHits;
}

double CacheManagerLRU::getQualityHits() const
{
    return qualityHits;
}


void CacheManagerLRU::getContent()
{
        list < ContainerInfo * >::iterator start, end;
        start = lrulist.begin();
        end = lrulist.end();


        for (; start != end; ++start) {
                printf("%s [%d] | %d - %d\n", (*start)->getUrl()->toString(), (*start)->getFileSize(), (*start)->getLastRequestTime(), requests);
        }
        printf("##### actual cache size ##### %d\n",actSize);
}

void CacheManagerLRU::saveCacheIndexToDir(const char* dir)
{
        assert(dir!=NULL);
        list < ContainerInfo * >::iterator start, end;
        start = lrulist.begin();
        end = lrulist.end();
        char *dummy = new char[4096];
        char* dummyP;
        char* tmp=NULL;
        strcpy(dummy,dir);
        dummyP=dummy+strlen(dummy);
        for (; start != end; ++start) {
                tmp=Url::transformUrlToLocalFile( (*start)->getUrl());
                strcpy(dummyP,tmp);
                strcat(dummyP,".conf");
                (*start)->saveToCfgFile(dummy);
                delete[] tmp;
        }
        delete [] dummy;

}

© ViTooKi 2003 :: [Lite version] Created with Doxygen