VP1Prioritiser::Imp::SystemInfo Class Reference

Collaboration diagram for VP1Prioritiser::Imp::SystemInfo:

Public Types
enum	VisibilityState { NOTVISIBLE , VISIBLE , SOONVISIBLE }

Public Member Functions
	SystemInfo (IVP1System *, Imp *, IVP1ChannelWidget *, const VisibilityState &)
	~SystemInfo ()
void	setVisibilityState (const VisibilityState &)
void	addTimeMeasurement (const double &)
double	refreshtime () const

Public Attributes
IVP1System *	system {}

Private Member Functions
void	calcPriority ()
void	removeFromPriMap ()

Private Attributes
double	m_timing {}
double	m_priority {}
const bool	m_accumulator
VisibilityState	m_vs
Imp *	m_d {}
QQueue< double >	m_timemeasurements

Detailed Description

Definition at line 33 of file VP1Prioritiser.cxx.

Member Enumeration Documentation

VisibilityState

enum VP1Prioritiser::Imp::SystemInfo::VisibilityState

Enumerator
NOTVISIBLE
VISIBLE
SOONVISIBLE

Definition at line 35 of file VP1Prioritiser.cxx.

{ NOTVISIBLE, VISIBLE, SOONVISIBLE };

Constructor & Destructor Documentation

SystemInfo()

VP1Prioritiser::Imp::SystemInfo::SystemInfo ( IVP1System * s, Imp * d, IVP1ChannelWidget * cw, const VisibilityState & vs )

inline

Definition at line 81 of file VP1Prioritiser.cxx.

  :  system(s), m_priority(117117.117),
     m_accumulator(cw->isAccumulator()),m_vs(vs),m_d(d)
{
  //If another system with the same name exists already, we use that
  //timing as a reasonable guess. Otherwise we use the average of the
  //other channels. Failing that we use a default of 500ms.:
  double tmp(0);
  bool found(false);
  QHash<IVP1System*,Imp::SystemInfo*>::iterator itE = m_d->sys2info.end();
  for (QHash<IVP1System*,Imp::SystemInfo*>::iterator it=m_d->sys2info.begin();it!=itE;++it) {
    if ( it.key()->name() == s->name() ) {
      m_timing=it.value()->refreshtime();
      found=true;
      break;
    }
    tmp += m_timing=it.value()->refreshtime();
  }
  if (!found&&!m_d->sys2info.empty())
    m_timing = tmp/m_d->sys2info.count();
  else
    m_timing=500;
 
  calcPriority();
}

~SystemInfo()

VP1Prioritiser::Imp::SystemInfo::~SystemInfo ( )

inline

Definition at line 108 of file VP1Prioritiser.cxx.

{
  removeFromPriMap();
}

Member Function Documentation

addTimeMeasurement()

void VP1Prioritiser::Imp::SystemInfo::addTimeMeasurement ( const double & t )

inline

Definition at line 125 of file VP1Prioritiser.cxx.

{
  //Keep the seven latest measurements, and use a truncated mean as
  //final estimate.
 
  m_timemeasurements.enqueue(t);
  if (m_timemeasurements.count()==8)
    m_timemeasurements.dequeue();
 
  QList<double> tmplist = m_timemeasurements;
  std::sort(tmplist.begin(), tmplist.end());
 
  switch(tmplist.count()) {
  case 1: m_timing = tmplist.at(0); break;
  case 2: m_timing = 0.5*(tmplist.at(0)+tmplist.at(1)); break;
  case 3: m_timing = tmplist.at(1); break;
  case 4: m_timing = 0.5*(tmplist.at(1)+tmplist.at(2)); break;
  case 5: m_timing = (tmplist.at(1)+tmplist.at(2)+tmplist.at(3))/3.0; break;
  case 6: m_timing = 0.5*(tmplist.at(2)+tmplist.at(3)); break;
  case 7: m_timing = (tmplist.at(2)+tmplist.at(3)+tmplist.at(4))/3.0; break;
  default: assert(0&&"Should never happen"); break;
  }
 
  calcPriority();
}

calcPriority()

void VP1Prioritiser::Imp::SystemInfo::calcPriority ( )

inlineprivate

Definition at line 152 of file VP1Prioritiser.cxx.

{
  //1) Remove from m_d->priority2sys map
 
  if (m_priority!=117117.117)
    removeFromPriMap();
 
  //2) Calculate new priority
 
  //Priority is based on how long the systems take to refresh (the
  //fastest gets refreshed first).  In order to ensure that visible,
  //soonvisible, and accumulators gets priority they get a bonus of
  //30s, XXXms, and 100ms respectively (where XXX depends on the scenario):
 
  m_priority = m_timing + (m_vs==VISIBLE?-30000.0:(m_vs==SOONVISIBLE?-m_d->soonvisbonus:0.0)) + (m_accumulator?-100.0:0.0);
 
  //3) Add to m_d->priority2sys map
 
  std::pair<double,IVP1System*> a(m_priority,system);
  m_d->priority2sys.insert(a);
}

refreshtime()

double VP1Prioritiser::Imp::SystemInfo::refreshtime ( ) const

inline

Definition at line 41 of file VP1Prioritiser.cxx.

{ return m_timing; }

removeFromPriMap()

void VP1Prioritiser::Imp::SystemInfo::removeFromPriMap ( )

inlineprivate

Definition at line 175 of file VP1Prioritiser.cxx.

{
  //Fixme: Cache itp and it (in class Imp even?)!
  std::pair<Pri2SysMap::iterator, Pri2SysMap::iterator> itp(m_d->priority2sys.equal_range(m_priority));
  Pri2SysMap::iterator it = itp.first;
  for (;it!=itp.second;++it) {
    if (it->second==system) {
      m_d->priority2sys.erase(it);
      break;
    }
  }
  assert(it != itp.second);
}

setVisibilityState()

void VP1Prioritiser::Imp::SystemInfo::setVisibilityState ( const VisibilityState & vs )

inline

Definition at line 114 of file VP1Prioritiser.cxx.

{
  //Fixme: When do we get tabmanager setVisible signals? At startup? When channels are added?
  //Fixme: Do not emit these during file loading!!
  if (m_vs==vs)
    return;
  m_vs = vs;
  calcPriority();
}

Member Data Documentation

m_accumulator

const bool VP1Prioritiser::Imp::SystemInfo::m_accumulator

private

Definition at line 45 of file VP1Prioritiser.cxx.

m_d

Imp* VP1Prioritiser::Imp::SystemInfo::m_d {}

private

Definition at line 48 of file VP1Prioritiser.cxx.

{};

m_priority

double VP1Prioritiser::Imp::SystemInfo::m_priority {}

private

Definition at line 44 of file VP1Prioritiser.cxx.

{};

m_timemeasurements

QQueue<double> VP1Prioritiser::Imp::SystemInfo::m_timemeasurements

private

Definition at line 50 of file VP1Prioritiser.cxx.

m_timing

double VP1Prioritiser::Imp::SystemInfo::m_timing {}

private

Definition at line 43 of file VP1Prioritiser.cxx.

{};

m_vs

VisibilityState VP1Prioritiser::Imp::SystemInfo::m_vs

private

Definition at line 46 of file VP1Prioritiser.cxx.

system

IVP1System* VP1Prioritiser::Imp::SystemInfo::system {}

Definition at line 38 of file VP1Prioritiser.cxx.

{};

---

The documentation for this class was generated from the following file:

• VP1Prioritiser.cxx