MeVis/Foundation/Sources/ML/include/host/mlPageRequestProcessorBase.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
#ifndef __mlPageRequestProcessorBase_H
#define __mlPageRequestProcessorBase_H

#include "mlInitSystemML.h"

#include "mlPageRequestProcessor.h"
#include "mlProcessingTimeLine.h"

ML_START_NAMESPACE

class Host;
class PagedImage;
class UserThreadData;

//-------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------------
class MLEXPORT PageRequestProcessorBase : public PageRequestProcessor
{
public:
  PageRequestProcessorBase(Host* host);
  ~PageRequestProcessorBase();

  virtual bool supportsMultiThreading() = 0;

  virtual void removeCancelledRequests();

  ProcessingTimeLine& getProcessingTimeLine() { return _profile; }

  ProcessingTimeLine::TimeLine* getOverviewTimeLine() { return _useTimeLineProfiling?_overviewTimeLine:NULL; }

  void enableTimeLineProfiling(bool flag);

  bool isTimeLineProfilingEnabled() const { return _useTimeLineProfiling; }

  int getProcessingScope() const { return _processingScope; }

  virtual void enterProcessingScope();

  virtual void leaveProcessingScope();

protected:
  bool createMoreWork(bool sleepWhenBlocked);
  
  void setupCurrentProcessingScope();
 
  virtual void handleErrorsInGUIThread();

  void terminateAllRequestsInGUIThread();

  void addNewCursor(PageRequestCursor* cursor);
 
  virtual void getAllPageRequestQueues(std::vector< std::deque<PageRequest*>* >& queues);

  Host* _host;

  bool _terminated;

  bool _workProduced;

  int _rootTileRequests;

  std::vector< std::vector<PageRequestCursor*> > _cursors;


  bool _useTimeLineProfiling;
  ProcessingTimeLine _profile;
  ProcessingTimeLine::TimeLine* _guiThreadTimeLine;
  ProcessingTimeLine::TimeLine* _overviewTimeLine;

  int _processingScope;
  int _producerProcessingScope;
  int _producerCursorCounter;
  int _guiThreadRecursionCounter;

  struct ScopeStackEntry
  {
    ScopeStackEntry() {
      rootTilesToWaitFor = 0;
      errorOccurred = false;
    }

    std::deque<PageRequest*> guiQueue;
    int rootTilesToWaitFor;

    bool errorOccurred;

    std::vector<PageRequest*> pageRequestsWithErrors;
  };

  ScopeStackEntry* _currentScope;

  std::vector<ScopeStackEntry> _scopeStack;

  TimeCounter _progressUpdateTimer;

  struct PerThreadStorage {
    ~PerThreadStorage() { clear(); }

    void clear();

    std::map<PagedImage*, UserThreadData*> userThreadDataMap;
  };

  PerThreadStorage _guiPerThreadStorage;

  UserThreadData* getUserThreadData(PageRequest* request, PerThreadStorage& perThreadStorage);

};

ML_END_NAMESPACE

#endif