add memory usage debugging

interface/src/Application.cpp

@@ -2822,28 +2822,36 @@ void Application::displayStats() {
     voxelStats << "Voxels Rendered: " << _voxels.getVoxelsRendered() / 1000.f << "K " <<
         "Updated: " << _voxels.getVoxelsUpdated()/1000.f << "K " <<
         "Max: " << _voxels.getMaxVoxels()/1000.f << "K ";
-        
     drawtext(10, statsVerticalOffset + 230, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
+
+    voxelStats.str("");
+    voxelStats << "Voxels Memory RAM: " << _voxels.getVoxelMemoryUsageRAM() / 1000000.f << "MB " <<
+        "VBO: " << _voxels.getVoxelMemoryUsageVBO() / 1000000.f << "MB ";
+    if (_voxels.hasVoxelMemoryUsageGPU()) {
+        voxelStats << "GPU: " << _voxels.getVoxelMemoryUsageGPU() / 1000000.f << "MB ";
+    }
+        
+    drawtext(10, statsVerticalOffset + 250, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
     
     voxelStats.str("");
     char* voxelDetails = _voxelSceneStats.getItemValue(VoxelSceneStats::ITEM_VOXELS);
     voxelStats << "Voxels Sent from Server: " << voxelDetails;
-    drawtext(10, statsVerticalOffset + 250, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
+    drawtext(10, statsVerticalOffset + 270, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
 
     voxelStats.str("");
     voxelDetails = _voxelSceneStats.getItemValue(VoxelSceneStats::ITEM_ELAPSED);
     voxelStats << "Scene Send Time from Server: " << voxelDetails;
-    drawtext(10, statsVerticalOffset + 270, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
+    drawtext(10, statsVerticalOffset + 290, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
 
     voxelStats.str("");
     voxelDetails = _voxelSceneStats.getItemValue(VoxelSceneStats::ITEM_ENCODE);
     voxelStats << "Encode Time on Server: " << voxelDetails;
-    drawtext(10, statsVerticalOffset + 290, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
+    drawtext(10, statsVerticalOffset + 310, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
 
     voxelStats.str("");
     voxelDetails = _voxelSceneStats.getItemValue(VoxelSceneStats::ITEM_MODE);
     voxelStats << "Sending Mode: " << voxelDetails;
-    drawtext(10, statsVerticalOffset + 310, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
+    drawtext(10, statsVerticalOffset + 330, 0.10f, 0, 1.0, 0, (char *)voxelStats.str().c_str());
     
     Node *avatarMixer = NodeList::getInstance()->soloNodeOfType(NODE_TYPE_AVATAR_MIXER);
     char avatarMixerStats[200];
@@ -2856,7 +2864,7 @@ void Application::displayStats() {
         sprintf(avatarMixerStats, "No Avatar Mixer");
     }
     
-    drawtext(10, statsVerticalOffset + 330, 0.10f, 0, 1.0, 0, avatarMixerStats);
+    drawtext(10, statsVerticalOffset + 350, 0.10f, 0, 1.0, 0, avatarMixerStats);
     drawtext(10, statsVerticalOffset + 450, 0.10f, 0, 1.0, 0, (char *)LeapManager::statusString().c_str());
     
     if (_perfStatsOn) {

interface/src/VoxelSystem.cpp

@@ -214,14 +214,17 @@ void VoxelSystem::cleanupVoxelMemory() {
             delete[] _writeVerticesArray;
             delete[] _readColorsArray;
             delete[] _writeColorsArray;
-            delete[] _writeVoxelDirtyArray;
-            delete[] _readVoxelDirtyArray;
         }
+        delete[] _writeVoxelDirtyArray;
+        delete[] _readVoxelDirtyArray;
     }
     _initialized = false; // no longer initialized
 }
 
 void VoxelSystem::initVoxelMemory() {
+    _initialMemoryUsageGPU = getFreeMemoryGPU();
+    _memoryUsageRAM = 0;
+    _memoryUsageVBO = 0; // our VBO allocations as we know them
     if (_useVoxelShader) {
         qDebug("Using Voxel Shader...\n");
         GLuint* indicesArray = new GLuint[_maxVoxels];
@@ -235,12 +238,13 @@ void VoxelSystem::initVoxelMemory() {
         // bind the indices VBO to the actual indices array
         glGenBuffers(1, &_vboVoxelsIndicesID);
         glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _vboVoxelsIndicesID);
-        glBufferData(GL_ELEMENT_ARRAY_BUFFER, _maxVoxels, indicesArray, GL_STATIC_DRAW);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * _maxVoxels, indicesArray, GL_STATIC_DRAW);
-    
+        _memoryUsageVBO += sizeof(GLuint) * _maxVoxels;
 
         glGenBuffers(1, &_vboVoxelsID);
         glBindBuffer(GL_ARRAY_BUFFER, _vboVoxelsID);
         glBufferData(GL_ARRAY_BUFFER, _maxVoxels * sizeof(VoxelShaderVBOData), NULL, GL_DYNAMIC_DRAW);
+        _memoryUsageVBO += _maxVoxels * sizeof(VoxelShaderVBOData);
     
         // delete the indices and normals arrays that are no longer needed
         delete[] indicesArray;
@@ -248,12 +252,18 @@ void VoxelSystem::initVoxelMemory() {
         // we will track individual dirty sections with these arrays of bools
         _writeVoxelDirtyArray = new bool[_maxVoxels];
         memset(_writeVoxelDirtyArray, false, _maxVoxels * sizeof(bool));
+        _memoryUsageRAM += (_maxVoxels * sizeof(bool));
+
         _readVoxelDirtyArray = new bool[_maxVoxels];
         memset(_readVoxelDirtyArray, false, _maxVoxels * sizeof(bool));
+        _memoryUsageRAM += (_maxVoxels * sizeof(bool));
 
         // prep the data structures for incoming voxel data
         _writeVoxelShaderData = new VoxelShaderVBOData[_maxVoxels];
+        _memoryUsageRAM += (sizeof(VoxelShaderVBOData) * _maxVoxels);
+
         _readVoxelShaderData = new VoxelShaderVBOData[_maxVoxels];
+        _memoryUsageRAM += (sizeof(VoxelShaderVBOData) * _maxVoxels);
     } else {
         GLuint* indicesArray = new GLuint[INDICES_PER_VOXEL * _maxVoxels];
 
@@ -289,6 +299,7 @@ void VoxelSystem::initVoxelMemory() {
             glBufferData(GL_ARRAY_BUFFER,
                          VERTEX_POINTS_PER_VOXEL * sizeof(GLbyte) * _maxVoxels,
                          normalsArray, GL_STATIC_DRAW);
+            _memoryUsageVBO += VERTEX_POINTS_PER_VOXEL * sizeof(GLbyte) * _maxVoxels;
 
             // delete the indices and normals arrays that are no longer needed
             delete[] normalsArray;
@@ -310,6 +321,7 @@ void VoxelSystem::initVoxelMemory() {
             glBufferData(GL_ARRAY_BUFFER,
                          VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat) * _maxVoxels,
                          normalsArray, GL_STATIC_DRAW);
+            _memoryUsageVBO += VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat) * _maxVoxels;
 
             // delete the indices and normals arrays that are no longer needed
             delete[] normalsArray;
@@ -319,11 +331,13 @@ void VoxelSystem::initVoxelMemory() {
         glGenBuffers(1, &_vboVerticesID);
         glBindBuffer(GL_ARRAY_BUFFER, _vboVerticesID);
         glBufferData(GL_ARRAY_BUFFER, VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat) * _maxVoxels, NULL, GL_DYNAMIC_DRAW);
+        _memoryUsageVBO += VERTEX_POINTS_PER_VOXEL * sizeof(GLfloat) * _maxVoxels;
 
         // VBO for colorsArray
         glGenBuffers(1, &_vboColorsID);
         glBindBuffer(GL_ARRAY_BUFFER, _vboColorsID);
         glBufferData(GL_ARRAY_BUFFER, VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte) * _maxVoxels, NULL, GL_DYNAMIC_DRAW);
+        _memoryUsageVBO += VERTEX_POINTS_PER_VOXEL * sizeof(GLubyte) * _maxVoxels;
 
         // VBO for the indicesArray
         glGenBuffers(1, &_vboIndicesID);
@@ -331,6 +345,7 @@ void VoxelSystem::initVoxelMemory() {
         glBufferData(GL_ELEMENT_ARRAY_BUFFER,
                      INDICES_PER_VOXEL * sizeof(GLuint) * _maxVoxels,
                      indicesArray, GL_STATIC_DRAW);
+        _memoryUsageVBO += INDICES_PER_VOXEL * sizeof(GLuint) * _maxVoxels;
 
         // delete the indices and normals arrays that are no longer needed
         delete[] indicesArray;
@@ -339,15 +354,22 @@ void VoxelSystem::initVoxelMemory() {
         // we will track individual dirty sections with these arrays of bools
         _writeVoxelDirtyArray = new bool[_maxVoxels];
         memset(_writeVoxelDirtyArray, false, _maxVoxels * sizeof(bool));
+        _memoryUsageRAM += (sizeof(bool) * _maxVoxels);
+
         _readVoxelDirtyArray = new bool[_maxVoxels];
         memset(_readVoxelDirtyArray, false, _maxVoxels * sizeof(bool));
+        _memoryUsageRAM += (sizeof(bool) * _maxVoxels);
 
         // prep the data structures for incoming voxel data
         _writeVerticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * _maxVoxels];
+        _memoryUsageRAM += (sizeof(GLfloat) * VERTEX_POINTS_PER_VOXEL * _maxVoxels);
         _readVerticesArray = new GLfloat[VERTEX_POINTS_PER_VOXEL * _maxVoxels];
+        _memoryUsageRAM += (sizeof(GLfloat) * VERTEX_POINTS_PER_VOXEL * _maxVoxels);
 
         _writeColorsArray = new GLubyte[VERTEX_POINTS_PER_VOXEL * _maxVoxels];
+        _memoryUsageRAM += (sizeof(GLubyte) * VERTEX_POINTS_PER_VOXEL * _maxVoxels);
         _readColorsArray = new GLubyte[VERTEX_POINTS_PER_VOXEL * _maxVoxels];
+        _memoryUsageRAM += (sizeof(GLubyte) * VERTEX_POINTS_PER_VOXEL * _maxVoxels);
 
 
         // create our simple fragment shader if we're the first system to init
@@ -1897,3 +1919,58 @@ void VoxelSystem::nodeKilled(Node* node) {
 }
 
 
+unsigned long VoxelSystem::getFreeMemoryGPU() {
+    // We can't ask all GPUs how much memory they have in use, but we can ask them about how much is free.
+    // So, we can record the free memory before we create our VBOs and the free memory after, and get a basic
+    // idea how how much we're using.
+
+    _hasMemoryUsageGPU = false; // assume the worst
+    unsigned long freeMemory = 0;
+    const int NUM_RESULTS = 4; // see notes, these APIs return up to 4 results
+    GLint results[NUM_RESULTS] = { 0, 0, 0, 0};
+
+    // ATI
+    // http://www.opengl.org/registry/specs/ATI/meminfo.txt
+    //
+    // TEXTURE_FREE_MEMORY_ATI                 0x87FC
+    // RENDERBUFFER_FREE_MEMORY_ATI            0x87FD
+    const GLenum VBO_FREE_MEMORY_ATI = 0x87FB;
+    glGetIntegerv(VBO_FREE_MEMORY_ATI, &results[0]);
+    GLenum errorATI = glGetError();
+    
+    if (errorATI == GL_NO_ERROR) {
+        _hasMemoryUsageGPU = true;
+        freeMemory = results[0];
+    } else {
+
+        // NVIDIA
+        // http://developer.download.nvidia.com/opengl/specs/GL_NVX_gpu_memory_info.txt
+        //
+        //const GLenum GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX = 0x9047;
+        //const GLenum GPU_MEMORY_INFO_EVICTION_COUNT_NVX = 0x904A;
+        //const GLenum GPU_MEMORY_INFO_EVICTED_MEMORY_NVX = 0x904B;
+        //const GLenum GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX = 0x9048;
+        
+        const GLenum GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX = 0x9049;
+        results[0] = 0;
+        glGetIntegerv(GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX, &results[0]);
+        freeMemory += results[0]; 
+        GLenum errorNVIDIA = glGetError();
+    
+        if (errorNVIDIA == GL_NO_ERROR) {
+            _hasMemoryUsageGPU = true;
+            freeMemory = results[0];
+        }
+    }
+    
+    const unsigned long BYTES_PER_KBYTE = 1024;
+    return freeMemory * BYTES_PER_KBYTE; // API results in KB, we want it in bytes
+}
+
+unsigned long VoxelSystem::getVoxelMemoryUsageGPU() {
+    unsigned long currentFreeMemory = getFreeMemoryGPU();
+    return (_initialMemoryUsageGPU - currentFreeMemory);
+}
+
+
+

interface/src/VoxelSystem.h

@@ -69,6 +69,10 @@ public:
 
     void setMaxVoxels(int maxVoxels);
     long int getMaxVoxels() const { return _maxVoxels; }
+    unsigned long getVoxelMemoryUsageRAM() const { return _memoryUsageRAM; }
+    unsigned long getVoxelMemoryUsageVBO() const { return _memoryUsageVBO; }
+    bool hasVoxelMemoryUsageGPU() const { return _hasMemoryUsageGPU; }
+    unsigned long getVoxelMemoryUsageGPU();
     long int getVoxelsCreated();
     long int getVoxelsColored();
     long int getVoxelsBytesRead();
@@ -185,6 +189,8 @@ private:
 
     void updateVBOs();
 
+    unsigned long getFreeMemoryGPU();
+
     // these are kinda hacks, used by getDistanceFromViewRangeOperation() probably shouldn't be here
     static float _maxDistance;
     static float _minDistance;
@@ -253,6 +259,10 @@ private:
     int  _dataSourceID;
     
     int _voxelServerCount;
+    unsigned long _memoryUsageRAM;
+    unsigned long _memoryUsageVBO;
+    unsigned long _initialMemoryUsageGPU;
+    bool _hasMemoryUsageGPU;
 };
 
 #endif