nel/src/3d/driver/direct3d/driver_direct3d_profile.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "stddirect3d.h"
  18
  19 #include "driver_direct3d.h"
  20 #include "nel/misc/hierarchical_timer.h"
  21
  22 #ifdef DEBUG_NEW
  23 #define new DEBUG_NEW
  24 #endif
  25
  26 using namespace std;
  27 using namespace NLMISC;
  28
  29 namespace NL3D
  30 {
  31
  32 // ***************************************************************************
  33
  34 void CDriverD3D::profileRenderedPrimitives(CPrimitiveProfile &pIn, CPrimitiveProfile &pOut)
  35 {
  36         pIn= _PrimitiveProfileIn;
  37         pOut= _PrimitiveProfileOut;
  38 }
  39
  40 // ***************************************************************************
  41
  42 uint32 CDriverD3D::profileAllocatedTextureMemory()
  43 {
  44         return _AllocatedTextureMemory;
  45 }
  46
  47 // ***************************************************************************
  48
  49 uint32 CDriverD3D::profileSetupedMaterials() const
  50 {
  51         return _NbSetupMaterialCall;
  52 }
  53
  54 // ***************************************************************************
  55
  56 uint32 CDriverD3D::profileSetupedModelMatrix() const
  57 {
  58         return _NbSetupModelMatrixCall;
  59 }
  60
  61 // ***************************************************************************
  62
  63 void CDriverD3D::enableUsedTextureMemorySum (bool enable)
  64 {
  65         if (enable)
  66                 nlinfo ("PERFORMANCE INFO: enableUsedTextureMemorySum has been set to true in CDriverD3D\n");
  67         _SumTextureMemoryUsed=enable;
  68 }
  69
  70 // ***************************************************************************
  71
  72 uint32 CDriverD3D::getUsedTextureMemory() const
  73 {
  74         // Sum memory used
  75         uint32 memory=0;
  76
  77         // For each texture used
  78         set<CTextureDrvInfosD3D*>::const_iterator ite=_TextureUsed.begin();
  79         while (ite!=_TextureUsed.end())
  80         {
  81                 // Get the d3d texture
  82                 CTextureDrvInfosD3D*    d3dtext;
  83                 d3dtext= (*ite);
  84
  85                 // Sum the memory used by this texture
  86                 memory+=d3dtext->TextureMemory;
  87
  88                 // Next texture
  89                 ite++;
  90         }
  91
  92         // Return the count
  93         return memory;
  94 }
  95
  96 // ***************************************************************************
  97 void CDriverD3D::startProfileVBHardLock()
  98 {
  99         if(_VBHardProfiling)
 100                 return;
 101
 102         // start
 103         _VBHardProfiles.clear();
 104         _VBHardProfiles.reserve(50);
 105         _VBHardProfiling= true;
 106         _CurVBHardLockCount= 0;
 107         _NumVBHardProfileFrame= 0;
 108         _VolatileVBLockTime = 0;
 109 }
 110
 111 // ***************************************************************************
 112
 113 void CDriverD3D::endProfileVBHardLock(std::vector<std::string> &result)
 114 {
 115         if(!_VBHardProfiling)
 116                 return;
 117
 118         // Fill infos.
 119         result.clear();
 120         result.resize(_VBHardProfiles.size() + 2);
 121         float   total= 0;
 122         for(uint i=0;i<_VBHardProfiles.size();i++)
 123         {
 124                 const   uint tmpSize= 256;
 125                 char    tmp[tmpSize];
 126                 CVBHardProfile  &vbProf= _VBHardProfiles[i];
 127                 const char      *vbName;
 128                 if(vbProf.VBHard && !vbProf.VBHard->getName().empty())
 129                 {
 130                         vbName= vbProf.VBHard->getName().c_str();
 131                 }
 132                 else
 133                 {
 134                         vbName= "????";
 135                 }
 136                 // Display in ms.
 137                 float   timeLock= (float)CTime::ticksToSecond(vbProf.AccumTime)*1000 / max(_NumVBHardProfileFrame,1U);
 138                 smprintf(tmp, tmpSize, "%16s%c: %2.3f ms", vbName, vbProf.Change?'*':' ', timeLock );
 139                 total+= timeLock;
 140
 141                 result[i]= tmp;
 142         }
 143         result[_VBHardProfiles.size()]= toString("Total: %2.3f", total);
 144 //      float   volatileVBTimeLock = (float)CTime::ticksToSecond(_VolatileVBLockTime)*1000 / max(_NumVBHardProfileFrame,1U);
 145         result[_VBHardProfiles.size() + 1]= toString("Volatile Vertex Buffer lock time = %2.3f", _VolatileVBLockTime);
 146
 147         // clear.
 148         _VBHardProfiling= false;
 149         contReset(_VBHardProfiles);
 150 }
 151
 152 // ***************************************************************************
 153
 154 void CDriverD3D::appendVBHardLockProfile(NLMISC::TTicks time, CVertexBuffer *vb)
 155 {
 156         // must allocate a new place?
 157         if(_CurVBHardLockCount>=_VBHardProfiles.size())
 158         {
 159                 _VBHardProfiles.resize(_VBHardProfiles.size()+1);
 160                 // set the original VBHard
 161                 _VBHardProfiles[_CurVBHardLockCount].VBHard= vb;
 162         }
 163
 164         // Accumulate.
 165         _VBHardProfiles[_CurVBHardLockCount].AccumTime+= time;
 166         // if change of VBHard for this chrono place
 167         if(_VBHardProfiles[_CurVBHardLockCount].VBHard != vb)
 168         {
 169                 // flag, and set new
 170                 _VBHardProfiles[_CurVBHardLockCount].VBHard= vb;
 171                 _VBHardProfiles[_CurVBHardLockCount].Change= true;
 172         }
 173
 174         // next!
 175         _CurVBHardLockCount++;
 176 }
 177
 178 // ***************************************************************************
 179 void CDriverD3D::startProfileIBLock()
 180 {
 181         if(_IBProfiling)
 182                 return;
 183
 184         // start
 185         _IBProfiles.clear();
 186         _IBProfiles.reserve(50);
 187         _IBProfiling= true;
 188         _CurIBLockCount= 0;
 189         _NumIBProfileFrame= 0;
 190         _VolatileIBLockTime = 0;
 191 }
 192
 193 // ***************************************************************************
 194
 195 void CDriverD3D::endProfileIBLock(std::vector<std::string> &result)
 196 {
 197         if(!_IBProfiling)
 198                 return;
 199
 200         // Fill infos.
 201         result.clear();
 202         result.resize(_IBProfiles.size() + 2);
 203         float   total= 0;
 204         for(uint i=0;i<_IBProfiles.size();i++)
 205         {
 206                 const   uint tmpSize= 256;
 207                 char    tmp[tmpSize];
 208                 CIBProfile      &ibProf= _IBProfiles[i];
 209                 const char      *ibName;
 210                 if(ibProf.IB && !ibProf.IB->getName().empty())
 211                 {
 212                         ibName= ibProf.IB->getName().c_str();
 213                 }
 214                 else
 215                 {
 216                         ibName= "????";
 217                 }
 218                 // Display in ms.
 219                 float   timeLock= (float)CTime::ticksToSecond(ibProf.AccumTime)*1000 / max(_NumIBProfileFrame,1U);
 220                 smprintf(tmp, tmpSize, "%16s%c: %2.3f ms", ibName, ibProf.Change?'*':' ', timeLock );
 221                 total+= timeLock;
 222
 223                 result[i]= tmp;
 224         }
 225         result[_IBProfiles.size()]= toString("Total: %2.3f", total);
 226         float   volatileIBTimeLock = (float)CTime::ticksToSecond(_VolatileIBLockTime)*1000 / max(_NumIBProfileFrame,1U);
 227         result[_IBProfiles.size() + 1]= toString("Volatile Index Buffer lock time = %2.3f", volatileIBTimeLock);
 228         nlwarning("IB lock time = %2.3f", total);
 229         nlwarning("Volatile IB lock time = %2.3f", volatileIBTimeLock);
 230
 231         // clear.
 232         _IBProfiling= false;
 233         contReset(_IBProfiles);
 234 }
 235
 236 // ***************************************************************************
 237
 238 void CDriverD3D::appendIBLockProfile(NLMISC::TTicks time, CIndexBuffer *ib)
 239 {
 240         // must allocate a new place?
 241         if(_CurIBLockCount>=_IBProfiles.size())
 242         {
 243                 _IBProfiles.resize(_IBProfiles.size()+1);
 244                 _IBProfiles[_CurIBLockCount].IB= ib;
 245         }
 246
 247         // Accumulate.
 248         _IBProfiles[_CurIBLockCount].AccumTime+= time;
 249         // if change of VBHard for this chrono place
 250         if(_IBProfiles[_CurIBLockCount].IB != ib)
 251         {
 252                 // flag, and set new
 253                 _IBProfiles[_CurIBLockCount].IB= ib;
 254                 _IBProfiles[_CurIBLockCount].Change= true;
 255         }
 256
 257         // next!
 258         _CurIBLockCount++;
 259 }
 260
 261 // ***************************************************************************
 262 void CDriverD3D::profileVBHardAllocation(std::vector<std::string> &result)
 263 {
 264         result.clear();
 265         result.reserve(1000);
 266         result.push_back(toString("Memory Allocated: %4d Ko in AGP / %4d Ko in VRAM",
 267                 getAvailableVertexAGPMemory()/1000, getAvailableVertexVRAMMemory()/1000 ));
 268         result.push_back(toString("Num VBHard: %d", _VertexBufferHardSet.size()));
 269
 270         uint    totalMemUsed= 0;
 271         set<CVBDrvInfosD3D*>::iterator  it;
 272         for(it= _VertexBufferHardSet.begin(); it!=_VertexBufferHardSet.end(); it++)
 273         {
 274                 CVBDrvInfosD3D  *vbHard= *it;
 275                 if(vbHard)
 276                 {
 277                         uint    vSize= vbHard->VertexBufferPtr->getVertexSize();
 278                         uint    numVerts= vbHard->VertexBufferPtr->getNumVertices();
 279                         totalMemUsed+= vSize*numVerts;
 280                 }
 281         }
 282         result.push_back(toString("Mem Used: %4d Ko", totalMemUsed/1000) );
 283
 284         for(it= _VertexBufferHardSet.begin(); it!=_VertexBufferHardSet.end(); it++)
 285         {
 286                 CVBDrvInfosD3D  *vbHard= *it;
 287                 if(vbHard)
 288                 {
 289                         uint    vSize= vbHard->VertexBufferPtr->getVertexSize();
 290                         uint    numVerts= vbHard->VertexBufferPtr->getNumVertices();
 291                         result.push_back(toString("  %16s: %4d ko (format: %d / numVerts: %d)",
 292                                 vbHard->VertexBufferPtr->getName().c_str(), vSize*numVerts/1000, vSize, numVerts ));
 293                 }
 294         }
 295 }
 296
 297 // ***************************************************************************
 298 void CDriverD3D::profileIBAllocation(std::vector<std::string> &result)
 299 {
 300         result.clear();
 301         result.reserve(1000);
 302         result.push_back(toString("Memory Allocated: %4d Ko in AGP / %4d Ko in VRAM",
 303                 getAvailableVertexAGPMemory()/1000, getAvailableVertexVRAMMemory()/1000 ));
 304         result.push_back(toString("Num Index buffers : %d", _IBDrvInfos.size()));
 305
 306         uint    totalMemUsed= 0;
 307         for(TIBDrvInfoPtrList::iterator it = _IBDrvInfos.begin(); it != _IBDrvInfos.end(); ++it)
 308         {
 309                 CIBDrvInfosD3D  *ib =  NLMISC::safe_cast<CIBDrvInfosD3D *>(*it);
 310                 if(ib)
 311                 {
 312                         uint    numIndex= ib->IndexBufferPtr->getNumIndexes();
 313                         totalMemUsed+= sizeof(uint32)*numIndex;
 314                 }
 315         }
 316         result.push_back(toString("Mem Used: %4d Ko", totalMemUsed/1000) );
 317
 318         for(TIBDrvInfoPtrList::iterator it = _IBDrvInfos.begin(); it != _IBDrvInfos.end(); ++it)
 319         {
 320                 CIBDrvInfosD3D  *ib =  NLMISC::safe_cast<CIBDrvInfosD3D *>(*it);
 321                 if(ib)
 322                 {
 323                         uint    numIndex= ib->IndexBufferPtr->getNumIndexes();
 324                         result.push_back(toString("  %16s: %4d ko ",
 325                                 ib->IndexBufferPtr->getName().c_str(), sizeof(uint32) * numIndex));
 326                 }
 327         }
 328 }
 329
 330 // ***************************************************************************
 331
 332 void CDriverD3D::startBench (bool wantStandardDeviation, bool quick, bool reset)
 333 {
 334         CHTimer::startBench (wantStandardDeviation, quick, reset);
 335 }
 336
 337 // ***************************************************************************
 338
 339 void CDriverD3D::endBench ()
 340 {
 341         CHTimer::endBench ();
 342 }
 343
 344 // ***************************************************************************
 345
 346 void CDriverD3D::displayBench (class NLMISC::CLog *log)
 347 {
 348         // diplay
 349         CHTimer::displayHierarchicalByExecutionPathSorted(log, CHTimer::TotalTime, true, 48, 2);
 350         CHTimer::displayHierarchical(log, true, 48, 2);
 351         CHTimer::displayByExecutionPath(log, CHTimer::TotalTime);
 352         CHTimer::display(log, CHTimer::TotalTime);
 353         CHTimer::display(log, CHTimer::TotalTimeWithoutSons);
 354 }
 355
 356 // ***************************************************************************
 357
 358 } // NL3D