source: Sophya/trunk/AddOn/TAcq/racqumem.cc@ 3623

#include "racqumem.h"

//----------------------------------------------------------------
// ---- classes de gestion memoire pour acquisition BAORadio -----
// LAL -      R. Ansari - Juin/Juillet 2008 
//----------------------------------------------------------------


RAcqMemZoneMgr::RAcqMemZoneMgr(uint_4 nz, uint_4 np, uint_4 psz)
  : mex(true), nzones(nz), npaq(np), paqsz(psz), stop_(false)
{
  St_MemZ st;

  st.act = (uint_4)MemZA_None;
  st.stat = (uint_8)MemZS_Free;
  for(int k=0; k<3; k++) st.nbact[k] = 0;
  uint_8 mzsz = npaq*paqsz;

   for(int k=0; k<NbZones(); k++) {
     memzones.push_back(new Byte[mzsz] );
     states.push_back(st);
   }
  
}

RAcqMemZoneMgr::~RAcqMemZoneMgr()
{
  for(uint_4 k=0; k<NbZones(); k++) delete[] memzones[k]; 
}

int RAcqMemZoneMgr::FindMemZoneId(MemZaction act)
{
  int rid = -1;
  if (stop_) return rid;
  if ((act != MemZA_Fill) && (act != MemZA_Save) && (act != MemZA_Proc)) return rid;
  mex.lock();
  while ((rid < 0)&&(!stop_)) {
    switch (act)
      {
      case MemZA_Fill:
        if (rid < 0) for(uint_4 k=0; k<NbZones(); k++) {
          if ((states[k].act == MemZA_None) && 
              ((states[k].stat == MemZS_Free)||(states[k].stat & MemZS_Saved)) ) 
            { rid = k; break; } 
        }
        if (rid >= 0) { states[rid].act = MemZA_Fill; states[rid].stat = MemZS_Free; }
        break;
      case MemZA_Save:
        for(uint_4 k=0; k<NbZones(); k++) {
          if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
              !(states[k].stat & MemZS_Saved) ) { rid = k; break; } 
        }
        if (rid >= 0) states[rid].act = MemZA_Save; 
        break;
      case MemZA_Proc:
        for(uint_4 k=0; k<NbZones(); k++) {
          if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) && 
              !(states[k].stat & MemZS_Proc) ) { rid = k; break; } 
        }
        if (rid >= 0) states[rid].act = MemZA_Proc;               
        break;
      case MemZA_None:   // MTQ pour supprimer un warning
        break;
      }
    if (rid < 0)  mex.wait();
  }
  mex.unlock();
  return rid;
}

int RAcqMemZoneMgr::FreeMemZone(int id, MemZStatus st)
{
  if ((id < 0) || (id >= (int)states.size()))  return 1;
  int rc = 0;
  mex.lock();
  switch (st) {
        case MemZS_Free :
          states[id].stat = MemZS_Free; 
          states[id].act = MemZA_None;
        break;
        case MemZS_Filled :
          if (states[id].act != MemZA_Fill)  rc = 2;
          else states[id].nbact[0]++;
          states[id].stat |= MemZS_Filled; 
          states[id].act = MemZA_None;
        break;
        case MemZS_Saved :
          if (states[id].act != MemZA_Save)  rc = 4;
          else states[id].nbact[1]++;     
          states[id].stat |= MemZS_Saved; 
          states[id].act = MemZA_None;
        break;
        case MemZS_Proc :
          if (states[id].act != MemZA_Proc)  rc = 8;
          else states[id].nbact[2]++;     
          states[id].stat |= MemZS_Proc; 
          states[id].act = MemZA_None;
        break;
        default :
          rc = 16;
          states[id].stat = MemZS_Free; 
          states[id].act = MemZA_None;
        break;
  }
  mex.unlock();
  mex.broadcast();
  return rc;
}

/*  MIS en inline 
Byte* RAcqMemZoneMgr::GetMemZone(int id)
{
  if ((id < 0) || (id >= memzones.size()))  return NULL;
  return memzones[id];
}
*/
ostream& RAcqMemZoneMgr::Print(ostream& os)
{
  os << "RAcqMemZoneMgr::Print() NbZones=" << NbZones() << " PaqSize()=" << PaqSize()
     << " NbPaquets()=" << NbPaquets() << " ZoneSize()=" << ZoneSize() << endl;
  for(uint_4 k=0; k<states.size(); k++) 
    os << " [" << k << "] Act=" << states[k].act << " Stat=" << states[k].stat 
       << " NbAct[0..2]=" << states[k].nbact[0] << "," << states[k].nbact[1]
       << "," << states[k].nbact[2] << endl;    
  return os;   
}

void RAcqMemZoneMgr::Stop()
{
  //  cout << "RAcqMemZoneMgr::Stop() ........ STOP                          BROADCAST" <<endl; 
  stop_ = true;
  mex.broadcast();
}