LDM/SoLDMResourceManager.h

Go to the documentation of this file.

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2021 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : J.HUMMEL (Dec 2002)
** Modified by : T.DUFOUR (MMM yyyy)
**=======================================================================*/
#ifndef  _SO_LDM_RESOURCE_MANAGER_
#define  _SO_LDM_RESOURCE_MANAGER_

#ifdef _MSC_VER
#pragma warning( push )
#pragma warning(disable:4251)
#endif

#include <LDM/SoLDMLargeDataManagement.h>
#include <LDM/nodes/SoLDMResourceParameters.h>
#include <Inventor/SbVec.h>
#include <Inventor/STL/vector>
#include <LDM/SoLDMTopoOctree.h>
#define MIN_RES_THRESHOLD 10000 //high number meaning not set

class SoDataSet;

// callback function prototypes
typedef void SoLDMTexFrontCB (void *userData);

SoEXTENDER_Documented class  SoLDMResourceManager : public SoLDMLargeDataManagement
{
public:
  SoLDMResourceManager(SoDataSet* ds);

  virtual ~SoLDMResourceManager();


private:

  enum LoadPolicy {
    NO_USER_INTERACTION,   // Only load when no user interaction
    ALWAYS,                // Always load
    NEVER                  // Never. No loading happens anymore. Allows suspending loading process.
  };

  void invalidateData();

  static void   setMultiIO(SbBool on);
  static SbBool getMultiIO();

  static void        setMonitoringAmount(int);
  static int         getMonitoringAmount();

  SbVec3i32  getTileSize() const;

  int  getDataSize();

  void setTexelSize( int texelSize );

  int  getTexelSize();

  SbVec3i32 getVolumeDim();

#if 1             SoDEPRECATED
    void setTex3LoadRate( int loadRate );
SoDEPRECATED
    int  getTex3LoadRate();
SoDEPRECATED
    void setTex2LoadRate( int loadRate );
SoDEPRECATED
    int  getTex2LoadRate();
SoDEPRECATED
    void setMinResolutionThreshold( int threshold = MIN_RES_THRESHOLD );   // don't unload above this threshold.
SoDEPRECATED
    int  getMinResolutionThreshold();
SoDEPRECATED
    void setMaxResolutionThreshold( int threshold );   // don't load below this threshold.
SoDEPRECATED
    int  getMaxResolutionThreshold();

#endif 
#if 1             SoDEPRECATED
    int getTileDimension();

#endif 
#if 1             SoDEPRECATED
  void setMaxMainMemory( int maxMainMemory );
SoDEPRECATED
  int  getMaxMainMemory();
SoDEPRECATED
  void setMaxTexMemory( int maxTexMemoryMB );
SoDEPRECATED
  int  getMaxTexMemory();
SoDEPRECATED
  int  getMaxTilesInMainMem();
SoDEPRECATED
  int  getMaxTilesInTexMem();
#endif 
#if 1             SoDEPRECATED
  void setTileHalfLife( float timeInSec );
SoDEPRECATED
  float getTileHalfLife();
SoDEPRECATED
  void setLoadPolicy( LoadPolicy loadPolicy );SoDEPRECATED
  LoadPolicy getLoadPolicy();

  /*
   * Sets the time (in seconds) for which VViz does not load once a user
   * stopped interaction
   * Consulted only in NO_USER_INTERACTION mode
   * Default is 0.3 seconds.
   */SoDEPRECATED
  void setMovingTimeOut( float );

  /*
   * gets the time for which VViz should not load once a user
   * stopped interaction
   */SoDEPRECATED
  float getMovingTimeOut();
SoDEPRECATED
  static void setTex2VVizLoadRate( int loadRate );
SoDEPRECATED
  static int  getTex2VVizLoadRate();
SoDEPRECATED
  static void setTex3VVizLoadRate( int loadRate );
SoDEPRECATED
  static int  getTex3VVizLoadRate();
SoDEPRECATED
  static void setMaxVVizMainMemory( int maxMainMemoryMB ); // set/get the allowed main memory in MB
SoDEPRECATED
  static void setMaxVVizTexMemory( int maxTexMemoryMB );
SoDEPRECATED
  static int getMaxVVizMainMemory(); // for all the LDM datasets.
SoDEPRECATED
  static int getMaxVVizTexMemory();
SoDEPRECATED
  static void setNumIO( unsigned int numIO );
SoDEPRECATED
  static unsigned int getNumIO();
SoDEPRECATED
  static void setLoadNotificationRate( int rate );
SoDEPRECATED
  static int getLoadNotificationRate();

#endif 
private:
  float m_decreaseWeightFactor;
  float getDecreaseWeightFactor() {return m_decreaseWeightFactor;};

  void setTileSize( SbVec3i32 tileDim );

  void setDataSize( int dataSize );

  void setVolumeDim( const SbVec3i32& dim );

  int         getNumTileToTime();

  /*
   * Enum used to store wich resources has changed. Can be cumulative to 
   * represent several resources modification
   * ie: GPU resources and CPU resource updated -> value =GPU_MEM_UPDATED | CPU_MEM_UPDATED
   */
  enum State
  {
    NO_UPDATE               = 0x00,
    CPU_MEM_UPDATED         = 0x01, // cpu memory has been changed
    GPU_MEM_UPDATED         = 0x02, // gpu memory has been changed
    GPU_2D_UPDATED          = 0x04, // gpu 2d memory has been changed
    LOADRATE_2D_UPDATED     = 0x08, // LoadRate 2D has been changed
    LOADRATE_3D_UPDATED     = 0x10, // LoadRate 3D has been changed
    LOAD_RATE_UPDATED       = 0x20, // Load notification rate has been updated
    UPDATE_ALL              = 0xFF  // Special value to include all previous state
  };

  // Update all is needed according to the given state
  virtual void updateResources(unsigned short resourceState);

  // Internal method
  int  getMaxMainMemoryInKB() const;       // return amount of main memory in KB
  int  getMaxTexMemoryInKB() const;        // return amount of tex memory in KB

  /*
  Those set of functions returns the sum of resources of all data sets registered
  */
  int  getSumOfMaxTilesInTexMem();
  int  getSumOfTex3LoadRate();
  int  getSumOfMax2DTextures();
  int  getSumOfTex2LoadRate();
  void getSumOfMemAndTileSize(uint64_t &memByte, int& tileSize);
  void getSumOfNumTileInMem( uint64_t &maxTileInMem );

  static void computeInternalCounters(const std::vector<SoLDMResourceManager*>& rsToUpdate);
  static void shareSpareResources(const std::vector<SoLDMResourceManager*>& rsToUpdate, 
    size_t spareAmount, SoLDMResourceManager::State resourceType);

  /* *
  * Set of method to compute and allocate internally amount of resources for each dataset
  * Each method works on a specific resources and determine how much of this resource can
  * be spared between all dataset. The computation is based on global value for each resources,
  * and the amount manually set by application 
  */
  void allocateGPUResources(const std::vector<SoLDMResourceManager*>& rsToUpdate);
  void allocateCPUResources(const std::vector<SoLDMResourceManager*>& rsToUpdate);
  void allocateGPU2DResources(const std::vector<SoLDMResourceManager*>& rsToUpdate);
  void allocateTex2LoadRate(const std::vector<SoLDMResourceManager*>& rsToUpdate);
  void allocateTex3LoadRate(const std::vector<SoLDMResourceManager*>& rsToUpdate);

  void setIdealTextFrontCb( SoLDMTexFrontCB *func, void* userData = NULL);
  void idealTexFrontReached();
  SoLDMTexFrontCB* m_callbackFunc;
  void* m_userData;
  SoDataSet* getDataSet() { return m_ds; };

  static uint64_t getMaxVViz2DTexMemory();

  static void setMaxVViz2DTexMemory(uint64_t maxMemory);

  void setMax2DTexMemory(int max2DTexMemory);

  int getMax2DTexMemory();

  void enableTileBorders( bool enableTileBorders );

  bool areTileBordersEnabled() const
  {
    return m_tileBordersEnabled;
  }

  void setMinTilesToLoad( int minTilesToLoad );

  int getMinTilesToLoad() const
  {
    return m_minTilesToLoad;
  }

  void setViewpointRefinement( SoLDMResourceParameters::ViewpointRefinementPolicy viewportRefinementPolicy );

  bool getViewpointRefinement() const;

  void setScreenResolutionCulling(SoLDMResourceParameters::ScreenResolutionCullingPolicy screenResolutionCullingPolicy);

  bool getScreenResolutionCulling() const;

private:

  int m_minResThreshold;       // minimum resolution required (0:1/1, 1:1/2, 2:1/4, ...), default is 100.
  int m_maxResThreshold;       // maximum resolution allowed (0:1/1, 1:1/2, 2:1/4, ...), default is 0.

  bool m_tileBordersEnabled;
  int m_minTilesToLoad;
  SoLDMResourceParameters::ViewpointRefinementPolicy m_viewpointRefinementPolicy;
  SoLDMResourceParameters::ScreenResolutionCullingPolicy m_screenResolutionCullingPolicy;

  // TODO: these 2 methods should be removed while the following friend dependencies will be managed
  friend class SoLDMMultiIOTileManager;
  friend class SoLDMMediator;

  //static void updateMainMemParams( int mem, SoLDMResourceManager* exclude );
  static void updateNumTilesInMainMem();

  static void updateMaxMainMem();

  static void updateSumMax2DTextures();

  static const std::vector<SoLDMResourceManager*>& getRSToUpdate();

  // texture memory controls (for SoVolumeRender, SoVolumeGeometry)
  static int s_maxVVizTexMemoryKB; // amount in KB of texture memory allowed for all the LDM datasets, default is 0 KB.

  int m_maxTexMemoryKB;            // amount in KB of texture memory allowed for the corresponding dataset.

  int m_numTilesInTexMem;        // num tiles allowed in texture memory = m_maxTexMemory / tileTexSize

  static void updateNumTilesInTexMem();

  static void updateMaxTexMem();

  // Check that all dataSets parameters are consistent with global ones.
  // If, for each dataSet, one parameter is not consistent with the global one, it
  // is reset to -1 in these dataSets.
  static void checkParametersConsistency(const std::vector<SoLDMResourceManager*>& rsToUpdate);

  // texture 3 memory load rate controls (for SoVolumeRender, SoVolumeGeometry)
  static int s_tex3VVizLoadRate;  // num tiles allowed to load in tex mem per frame for all the LDM datasets, default is 1.
  int m_tex3LoadRate;             // num tiles allowed to load in tex mem per frame for the corresponding dataset.


  // texture 2 memory controls (for SoOxxSlice, SoVolumeSkin)
  static uint64_t s_maxVViz2DTexMemory; // 2D tiles memory allowed in texture memory for all LDM datasets, default is 64M ( ~5% of 1G ).
  uint64_t m_num2DTextures;            // num 2D tiles allowed in texture memory for the corresponding primitives.

  // texture 2 memory load rate controls (for SoOxxSlice, SoVolumeSkin)
  static int s_tex2VVizLoadRate;  // num tiles allowed to load in tex mem per frame for all the LDM datasets, default is 64.
  int m_tex2LoadRate;             // num tiles allowed to load in tex mem per frame for the corresponding dataset.



  static int s_maxVVizMainMemoryKB; // amount in KB of main memory allowed for all the LDM datasets, default is 256 MB.
  int m_maxMainMemoryKB;            // amount in KB of main memory allowed for the corresponding dataset.

  int m_numTilesInMainMem;        // num tiles allowed in main memory = m_maxMainMemory / tileSize

  static int s_loadNotificationRate;
  static int s_memToLoad;

  //number of IO:
  static unsigned int s_numIO;
  static SbBool       s_isMultiIO;


  SbVec3i32 m_tileDimension;    // tile dimension, default is 64.
  int m_dataSize;         // data size in bytes (1,2 or 4), default is 1.
  int m_texelSize;        // texel size in bits, default is 8.
                          // =8  for 8 bits indexed 3D textures
                          // =32 for RGBA 3D textures
                          // =24 for 8 bits indexed 2D textures
                          // =96 for RGBA 2D textures
  SbVec3i32 m_volDim;     // dataset dimension



  static std::vector<SoLDMResourceManager*> s_resourceManagers; // list of all ResourceManager's

  
   // Internal octree needed to compute resources
  SoLDMTopoOctree m_topoOctree;

  float getDataTileSizeInKB();
  float getTexTileSizeInByte(bool is3DTile = false);

  // Adjust the CPU memory allocated per dataset by taking in account
  // dataset that needs less memory
  void adjustMemPerDataset(const std::vector<SoLDMResourceManager*>& rsToUpdate);

  SoDataSet* m_ds;

  // cache value before and after ajustMaxTilesInTexMem
  int m_getSumOfMaxTilesInTexMemAdjusted;
  int m_getSumOfMaxTilesInTexMem;

  size_t m_maxNeededMemKB;

  // List of resourceManager to take in account for 
  // resource sharing
  static std::vector<SoLDMResourceManager*> s_rsToUpdate;

  // Store the number of mask associated to each data set
  static  std::map<SoLDMMediator*, int> s_maskPerMediator;

  // Store the number of volume data that are not volumeMask, by cumulating their datasize.
  // For example dataset in float will count for 4, while a dataset in byte will count
  // for one. This allow to ponderate properly the amount of resources to 
  // dataset, taking in account their datasize.
  static size_t s_nbVolumeData;

  // store the amount of GPU memory available for dataset not manually configured
  // ie : ( s_MaxVVizTexMemory - ( Sum of memory of all datasets with #maxTexMem != -1 )) / ( number of datasets with #maxTexMem == -1 )
  static size_t s_gpuMemPerDataSetKB;

  // store the amount of CPU memory available for dataset not manually configured
  // ie : ( s_MaxVVizMainMemory - ( Sum of memory of all dataset with #maxMainMem != -1 )) / ( number of datasets with #maxMainMem  == -1 )
  static size_t s_cpuMemPerDataSetKB;

  // store the 2D tiles memory in texture (GPU) memory available for dataset not manually configured MB
  // ie : (s_maxVViz2DTexMemory - ( Sum of memory of all dataset with #max2DTextures != -1 )) / ( number of datasets with #max2DTextures  == -1 )
  static uint64_t s_2DGpuTexMemoryPerDataSetMB;

  // store the amount of 2D Load Rate available for dataset not manually configured
  // ie : (s_tex2VVizLoadRate - ( Sum of 2DLoadRate of all dataset with #tex2LoadRate != -1 )) / ( number of datasets with #tex2LoadRate  == -1 )
  static size_t s_tex2LoadRatePerDataSet;

  // store the amount of 3D Load Rate available for dataset not manually configured
  // ie : (s_tex3VVizLoadRate - ( Sum of 3DLoadRate of all dataset with #tex3LoadRate != -1 )) / ( number of datasets with #tex3LoadRate == -1 )
  static size_t s_tex3LoadRatePerDataSet;

  // store the remainder amount of GPU Memory
  static size_t s_spareGpuMemoryKB;

  // store the remainder amount of CPU Memory
  static size_t s_spareCpuMemoryKB;

  // store the remainder amount of tex2 LoadRate
  static size_t s_spareTex2LoadRate;

  // store the remainder amount of tex3 LoadRate
  static size_t s_spareTex3LoadRate;

  // if true, prints MaxMain(MiB), Max2DTex(MiB), Max3DTex(MiB), Tex2LoadRate, Tex3LoadRate.
  static bool s_debugResourceValues;

  static SbThreadMutex s_globalResourcesMutex;
};


#ifdef _MSC_VER
#pragma warning( pop )
#endif

#endif // _SO_LDM_RESOURCE_MANAGER_

---

Open Inventor Toolkit reference manual, generated on 15 Mar 2023
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/