DtGlTextureResidencyManager.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 2023 MAK Technologies, Inc.
** All rights reserved.
******************************************************************************/


#pragma once
#include <vrvGraphicsUtils/vrvGraphicsUtils.h>

#include <map>
#include <unordered_map>

namespace makVrv
{
   class DtGlTextureResidentMemoryTracker;

   class DT_DLL_VRVGRAPHICSUTILS DtGlTextureResidencyManager
   {
   public:
      typedef std::map<unsigned int, int> TexIDToCount;
      typedef std::map<void*, TexIDToCount> ContextToTexID;

   public:
      DtGlTextureResidencyManager();

      virtual ~DtGlTextureResidencyManager();

      DtGlTextureResidencyManager(const DtGlTextureResidencyManager&) = delete;

      DtGlTextureResidencyManager& operator=(const DtGlTextureResidencyManager&) = delete;

   public:
      virtual void makeResidentIfNecessary(void* gContext, GLuint textureID);

      virtual bool makeNonResidentIfNecessary(void* gContext, GLuint textureID, bool canDelete);

      virtual void deletingTexture(GLuint textureID);

      virtual bool ensureTextureIsResident(GLuint textureID, GLuint64 textureAddress);

      virtual GLuint64 gpuTextureAddress(GLuint textureID) const;

      virtual bool isTexture(GLuint textureID) const;

      virtual DtGlTextureResidentMemoryTracker* tracker() const;

      virtual void setAllowNvidiaBindlessFix(bool enable);

   protected:
      virtual DtGlTextureResidentMemoryTracker* getOrCreateTracker(void* graphicsContext);
   protected:
      // Count of textures we've made resident *across all contexts*
      // So 1 texture in 3 contexts will have a count of 3
      // When this array goes to 0 then we call glDeleteTextures if the
      // texture is also marked 
      ContextToTexID myTextureCountByContext;

      // So for pageable terrains, the textures can be shared between tiles
      // However, when you releaseGLObjects and say glMakeTextureHandleNonResidentARB, 
      // other tiles which share the texture will not draw or have other problems
      // since we removed the data from underneath them
      // This is a basic (non-thread safe!) reference counting of textures by
      // context ID
      TexIDToCount myTextureIdToRefCountAcrossContexts;

      std::unordered_map<void*, DtGlTextureResidentMemoryTracker*> myContextsToTrackers;

      // This is a work-around (HACK) for NVIDIA driver bug:
      // https://jira.mak.com/browse/VRV-4620
      // The work-around is to only ever make bindless textures resident and non-resident, once.
      // In other words, don't try to make them resident and non-resident for each context.

      // I'm guessing because the texture is made resident in 1 context, then any other context
      // can use that memory by getting the texture address. The work-around will fail if
      // the driver starts doing proper ref-counting or something per context.

      // Note that NVIDIA does not seem to be following the bindless spec:
      // This is from the spec (see issues section)
      // "However, texture and image handle residency is managed per-context.  If
      // a texture or image handle is used in multiple contexts in a share group,
      // the handle must be made resident in all such contexts."
      std::unordered_map<GLuint, bool> myTextureIsResidentMap;

      // Also adding a way to disable the above work-around (HACK) for NVIDIA driver bug.
      // The reason is that if NVIDIA fixes the driver, then vrv will most likely
      // crash with the work-around. This will give a customer a way to disable it
      // without us needed to provide a patch or update.
      bool myAllowNvidiaBindlessFix;
   };
}