MeVis/Foundation/Sources/ML/include/mlHost.h

Go to the documentation of this file.

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

//ML-includes
#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif
#ifndef __mlBasics_H
#include "mlBasics.h"
#endif
#ifndef __mlPagedImage_H
#include "mlPagedImage.h"
#endif
#ifndef __mlSubImage_H
#include "mlSubImage.h"
#endif
#ifndef __mlFields_H
#include "mlFields.h"
#endif
#ifndef __mlWaitCondition_H
#include "mlWaitCondition.h"
#endif
#ifndef __mlBarrier_H
#include "mlBarrier.h"
#endif
#ifndef __mlThread_H
#include "mlThread.h"
#endif

ML_START_NAMESPACE

class Module;
class ThreadDataClass;
class ProcessAllPagesHandler;

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
class MLEXPORT Host 
{

public:

  friend class PageRequestProcessor;

  //------------------------------------------------------

  //------------------------------------------------------
  static void registerWithMemoryManager();

  Host();

  virtual ~Host();

  //--- Progress Callback
  void                setProgressCB(void *userData, MLHostProgressCB *callback);

  MLHostProgressCB   *getProgressCB() const;

  void               *getProgressCBUserData() const;

  void                updateProgress(const char* info1, const char* info2);

  //--- Break check callback
  void                setBreakCheckCB(void *userData, MLHostBreakCheckCB *callback);

  MLHostBreakCheckCB *getBreakCheckCB() const;

  void               *getBreakCheckCBUserData() const;


  bool                shouldTerminate() const;

  Field               *getPressedNotifyField();

  static Host         &getDefaultHost();

  static void         destroyDefaultHost();

  static MLErrorCode  pushDefaultHost();

  static MLErrorCode  popDefaultHost();

  void                setMaxNumThreads(MLint32 numThreads);

  MLint32            getMaxNumThreads() const;

  MLuint32            isProcessingActive() const;


protected:
  void _setProcessingActive();

  void _unsetProcessingActive();

public:
  //------------------------------------------------------

  //------------------------------------------------------

  MLErrorCode getTile(PagedImage&             outputImage,
                      SubImageBox             location,
                      MLDataType            dataType,
                      void**                data,
                      const ScaleShiftData& scaleShiftData=ScaleShiftData()) ML_RETURN_VALUE_SHOULD_BE_USED;


  MLErrorCode getTile(PagedImage&             outputImage,
                      SubImage&               subImage,
                      const ScaleShiftData& scaleShiftData=ScaleShiftData()) ML_RETURN_VALUE_SHOULD_BE_USED;

  void freeTile(void* data);

  //---------------------------------------------------------------------------

  //---------------------------------------------------------------------------
  //---------------------------------------------------------------------------
  MLErrorCode processAllPages(Module& module,
                              MLint     outputIndex,
                              SubImageBox region=SubImageBox()) ML_RETURN_VALUE_SHOULD_BE_USED;
  
  //------------------------------------------------------------------------------
  //------------------------------------------------------------------------------
  MLErrorCode processAllPages(Module&               module,
                              ProcessAllPagesHandler& handler,
                              SubImageBox               region=SubImageBox()) ML_RETURN_VALUE_SHOULD_BE_USED;


  //------------------------------------------------------

  //------------------------------------------------------

  MLErrorCode updateImageProperties(Module &module, MLint outputIndex) ML_RETURN_VALUE_SHOULD_BE_USED;

  MLErrorCode updateImageProperties(PagedImage& outputImage) ML_RETURN_VALUE_SHOULD_BE_USED;

  static inline unsigned int getMemoryManagerId() { return _memoryManagerId; }

  static SubImageBox calculateInputSubImageBoxDebug(Module& module, int inIndex, const SubImageBox& outputSubImageBox, int outputIndex);

#ifdef ML_DEPRECATED


  
public:

  ML_DEPRECATED MLErrorCode getTile(Module                &op,
                                    MLint                  outIndex,
                                    SubImageBox              loc,
                                    MLDataType             dataType,
                                    void                 **data,
                                    const ScaleShiftData  &scaleShiftData=ScaleShiftData()) ML_RETURN_VALUE_SHOULD_BE_USED;
  ML_DEPRECATED MLErrorCode getTile(Module               &op,
                                    MLint                 outIndex,
                                    SubImage               &subImg,
                                    const ScaleShiftData &scaleShiftData=ScaleShiftData()) ML_RETURN_VALUE_SHOULD_BE_USED;
  inline ML_DEPRECATED MLErrorCode updateImageProps(Module &op, MLint outIndex) ML_RETURN_VALUE_SHOULD_BE_USED { return updateImageProperties(op, outIndex); }

  inline static ML_DEPRECATED SubImageBox calcInSubImageBoxDebug(Module& module, 
                                                               int inIndex, 
                                                               const SubImageBox& outSubImgBox, 
                                                               int outIndex)
  {
    return calculateInputSubImageBoxDebug(module, inIndex, outSubImgBox, outIndex);
  }
  
#endif // ML_DEPRECATED


private:

  // ------------------------------------------------------------------------------
  // ------------------------------------------------------------------------------
  MLErrorCode _processAllPages(Module&  module,
                               MLint      outputIndex,
                               SubImageBox  region,
                               ProcessAllPagesHandler* handler
                               ) ML_RETURN_VALUE_SHOULD_BE_USED;

  // ------------------------------------------------------------------------------
  // ------------------------------------------------------------------------------
  MLErrorCode _processPagesHelper(PagedImage             &outputImage,
                                  const SubImageBox      &location,
                                  MLDataType            dataType,
                                  void                 *data,
                                  const ScaleShiftData &scaleShiftData,
                                  bool                  calledByProcessAllPages) ML_RETURN_VALUE_SHOULD_BE_USED;

  Host(const Host &);

  Host& operator=(const Host &);

  MLErrorCode _requiredTypesRegisteredAndSupported(PagedImage* outputImage);

  MLErrorCode _getTileCore(PagedImage             &outputImage,
                           SubImageBox             location,
                           MLDataType            dataType,
                           void                 *data,
                           const ScaleShiftData &scaleShiftData) ML_RETURN_VALUE_SHOULD_BE_USED;

  MLErrorCode _updateImageProperties(PagedImage* outputImage) ML_RETURN_VALUE_SHOULD_BE_USED;


  //------------------------------------------------------

  //------------------------------------------------------


  void _calcPages(PagedImage                 &outputImage,
                  const std::vector <MLint> pageIDs,
                  MLMemoryBlockHandle*      memoryBlockHandles);

  //----------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------
  void _initializePageData(ThreadDataClass &tData, bool permitInCaching);

  //----------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------
  static void _calcPagesMT(ThreadDataClass** threadDataContainers);

  friend struct CalcPagesWorkerThreadFunction;

  //----------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------
  ThreadDataClass** _getWorkForWorkerThread(size_t workIndex);

  //----------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------
  void _shutdownWorkerThreads();

  //----------------------------------------------------------------------------------------
  //----------------------------------------------------------------------------------------
  void _increaseErrorCounter();

  //------------------------------------------------------

  //------------------------------------------------------
  void*              _userData;

  MLHostProgressCB*  _progressCB;

  void*              _breakCheckUserData;

  MLHostBreakCheckCB* _breakCheckCB;

  MLint32            _maxNumThreads;

  MLuint32           _isProcessingActive;

  WaitCondition      _workAvailable;

  WaitCondition      _workDone;

  Mutex              _workAvailableMutex;

  std::vector<Thread*> _workerThreads;

  std::vector<ThreadDataClass**> _workerThreadClassData;

  bool               _shutdownWorkerThreadsFlag;

  Mutex              _countSyncMutex;

  MLint32            _errorCounter;

  MLint32            _numFinishedThreads;

  MLint32            _numLaunchedThreads;

  size_t             _maxNumPagesToCalculateInSingleWorkerThread;

  static unsigned int         _memoryManagerId;

}; //End of class Host

ML_END_NAMESPACE

//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std {

  MLEXPORT ostream& operator<<(ostream& s, const ML_NAMESPACE::Host &host);

}

#endif //of __mlHost_H