---

PsnMomeFifo.h

Go to the documentation of this file.

/*
 * This file is part of openMask © INRIA, CNRS, Universite de Rennes 1 1993-2002, thereinafter the Software
 * 
 * The Software has been developped within the Siames Project. 
 * INRIA, the University of Rennes 1 and CNRS jointly hold intellectual property rights
 * 
 * The Software has been registered with the Agence pour la Protection des
 * Programmes (APP) under registration number IDDN.FR.001.510008.00.S.P.2001.000.41200
 *
 * This file may be distributed under the terms of the Q Public License
 * version 1.0 as defined by Trolltech AS of Norway and appearing in the file
 * LICENSE.QPL included in the packaging of this file.
 *
 * Licensees holding valid specific licenses issued by INRIA, CNRS or Université de Rennes 1 
 * for the software may use this file in accordance with that specific license 
 *
 */
#ifndef PsnMomeFifoHEADER
#define PsnMomeFifoHEADER


class PsnSharedMemoryManager;

#include <PsnAbstractFifo.h>
#include <typeinfo>
#include <PsnArray.h>
#include <PsnNew.h>
#include "PsnMutexLock.h"


#ifdef _SGI
#include <new.h>
#include <malloc.h>
#else
#include <new>
#endif

template <typename Type>
class PsnMomeFifo : public PsnAbstractFifo<Type>
{
public:
   PsnMomeFifo(const unsigned int, PsnRelaxedMemoryManager * myMemory);
   PsnMomeFifo(void * fifoAddress,  const unsigned int);
   virtual ~PsnMomeFifo() ;
   virtual void set (const Type & val, const PsDate & date) = 0 ;
   virtual unsigned int getNumberOfPresentValues( int maxCherche = -1 ) const = 0;
   virtual const Type & getPreceedingValue (const unsigned int indice) const ;
   virtual const PsDate & getPreceedingDate(const unsigned int indice) const ;

   virtual void setInPlace ( const Type & val, const PsDate & date) = 0 ;

   virtual Type & getNextPlaceHolder() = 0 ;

   virtual void clear() = 0 ;
   virtual void printDebuggingInformation() const = 0;
   void * fifo() ;
   virtual void resyncFifo ( PsnRelaxedMemoryManager * myMemory ) const ;
//     virtual void initialiseContext() const ; 
//     virtual unsigned int getNumberOfPresentValuesUsingContext( int maxCherche = -1 ) const ;
//     virtual const Type & getPreceedingValueUsingContext (const int indice) const ;
//     virtual const PsDate & getPreceedingDateUsingContext (const int indice) const ;

protected:
   virtual unsigned int findFirstValid() const = 0 ;

   class valeurDate {
   public:
      void * operator new(size_t size, void * place) {
         return place ;
      }
      PsDate dateValeur;
      Type   valeur ;    
      PsDate datePlusVieilleValeurValide ; 
   };
   
   PsnAbstractArray <valeurDate> * _tab ;

   mutable PsDate _dateOfOldestValidValue ; 
   mutable unsigned int _lastValidIndex ;

   mutable unsigned int _offsetToMostRecentOfLastExamined ;
   mutable unsigned int _indexOfLastValueExamined ;
   mutable PsnMutexLock _accessToContext ;

};

#include <PsnMomeReaderFifo.h>
#include <PsnMomeWriterFifo.h>


template <typename Type> 
void PsnMomeFifo<Type>::printDebuggingInformation() const {
   PsnAbstractFifo<Type>::printDebuggingInformation() ;
   cerr<<"Valeur du tableau : "<<endl;
   _tab->printDebuggingInformation (_fifoSize) ;
   cerr<<"_dateOfOldestValidValue : "<<_dateOfOldestValidValue<<endl;
   cerr<<"_lastValidIndex : "<<_lastValidIndex<<endl;
}


template <typename Type> 
void * PsnMomeFifo<Type>::fifo() {
   return (void *)_tab ;
}

template <typename Type> 
const Type & PsnMomeFifo<Type>::getPreceedingValue (const unsigned int offsetToMostRecent) const {
#ifdef _DEBUGATTRIBUTSMOME
   cerr<<"PsnMomeFifo<"<<typeid(Type).name()<<">::"<<this<<"::getPreceedingValue ("<<offsetToMostRecent<<") const"<<endl;
#endif

   assert (offsetToMostRecent >= 0) ;
   assert (offsetToMostRecent < _fifoSize - 2 ) ;

   int lookAt = findFirstValid () ;
#ifdef _DEBUGATTRIBUTSMOME
   cerr<<"First valid is : "<<lookAt<<endl;
   printDebuggingInformation() ;
#endif

   unsigned int offsetToMostRecentOfLastFound = -1 ;

   if ( (*_tab)[lookAt].dateValeur >= _dateOfOldestValidValue ) offsetToMostRecentOfLastFound++ ;

   while ( offsetToMostRecentOfLastFound != offsetToMostRecent ) {
      if ( lookAt != 0 ) {
         lookAt--;
      }
      else {
         lookAt = _fifoSize - 1 ;
      }
      
      if ( (*_tab)[lookAt].dateValeur >= _dateOfOldestValidValue ) offsetToMostRecentOfLastFound++ ;
   }

   return (*_tab)[lookAt].valeur ;
}


template <typename Type> 
void PsnMomeFifo<Type>::resyncFifo( PsnRelaxedMemoryManager * myMemory ) const {
   ((PsnMomeArray<valeurDate> *) _tab )->resync( myMemory ) ;
}




template <typename Type> 
const PsDate & PsnMomeFifo<Type>::getPreceedingDate (const unsigned int offsetToMostRecent) const {
#ifdef _DEBUGATTRIBUTSMOME
   cerr<<"PsnMomeFifo<"<<typeid(Type).name()<<">::"<<this<<"::getPreceedingDate ("<<offsetToMostRecent<<") const"<<endl;
   printDebuggingInformation();
#endif

   assert (offsetToMostRecent >= 0) ;

   if (offsetToMostRecent > 4) cerr<<"C'est anormal de demander à "<<offsetToMostRecent<<endl;
   assert (offsetToMostRecent < _fifoSize - 2) ;

   int lookAt = findFirstValid () ;
   unsigned int offsetToMostRecentOfLastExamined = -1 ;

   if ( (*_tab)[lookAt].dateValeur >= _dateOfOldestValidValue ) offsetToMostRecentOfLastExamined++ ;

   
   while ( offsetToMostRecentOfLastExamined != offsetToMostRecent ) {
      if ( lookAt != 0 ) {
         lookAt--;
      }
      else {
         lookAt = _fifoSize - 1 ;
      }
      
      if ( (*_tab)[lookAt].dateValeur >= _dateOfOldestValidValue ) offsetToMostRecentOfLastExamined++ ;
   }

   return (*_tab)[lookAt].dateValeur ;
}

template <typename Type> 
PsnMomeFifo<Type>::~PsnMomeFifo () {
#ifdef _DEBUGEXEC
   cerr<<"PsnMomeFifo<Type>::~PsnMomeFifo ()"<<endl;
#endif
}

template <typename Type> 
PsnMomeFifo<Type>::PsnMomeFifo (const unsigned int taille, PsnRelaxedMemoryManager * myMemory) : PsnAbstractFifo<Type>(taille), _offsetToMostRecentOfLastExamined(taille) {
   
   myMemory->lockIfNeeded ( ) ;
   
   _tab = new(myMemory) PsnMomeArray< valeurDate > ( taille, *myMemory) ;
   
   myMemory->unlockIfNeeded ( ) ;

   _dateOfOldestValidValue = PsDate ( -1 ); 
   _lastValidIndex = ( PsnRelaxedMemoryManager::getReadableQueueIndex() - 1 + _fifoSize ) % _fifoSize ;
}



template <typename Type> 
PsnMomeFifo<Type>::PsnMomeFifo (void * fifoAddress, const unsigned int taille)
   : PsnAbstractFifo<Type>(taille), 
   _offsetToMostRecentOfLastExamined(taille) {
   
   _tab =  (PsnMomeArray< valeurDate > * ) fifoAddress ;
   
   _dateOfOldestValidValue = PsDate ( -1 ); 

   _lastValidIndex = ( PsnRelaxedMemoryManager::getReadableQueueIndex() - 1 + _fifoSize ) % _fifoSize ;
}


#endif

---