Add clouds API

[minetest.git] / src / profiler.h

diff --git a/src/profiler.h b/src/profiler.h
index b9fa2248558ed599dbc1dba6d1843ff366fb9689..6da11597262b384d54483a31918e744db7264117 100644 (file)
--- a/src/profiler.h
+++ b/src/profiler.h
@@ -20,13 +20,21 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #ifndef PROFILER_HEADER
 #define PROFILER_HEADER
 
-#include "irrlichttypes_bloated.h"
+#include "irrlichttypes.h"
 #include <string>
-#include <jmutex.h>
-#include <jmutexautolock.h>
 #include <map>
+
+#include "threading/mutex.h"
+#include "threading/mutex_auto_lock.h"
 #include "util/timetaker.h"
-#include "util/numeric.h" // paging()
+#include "util/numeric.h"      // paging()
+#include "debug.h"             // assert()
+
+#define MAX_PROFILER_TEXT_ROWS 20
+
+// Global profiler
+class Profiler;
+extern Profiler *g_profiler;
 
 /*
        Time profiler
@@ -37,65 +45,49 @@ class Profiler
 public:
        Profiler()
        {
-               m_mutex.Init();
        }
 
        void add(const std::string &name, float value)
        {
-               JMutexAutoLock lock(m_mutex);
+               MutexAutoLock lock(m_mutex);
                {
                        /* No average shall have been used; mark add used as -2 */
-                       core::map<std::string, int>::Node *n = m_avgcounts.find(name);
-                       if(n == NULL)
+                       std::map<std::string, int>::iterator n = m_avgcounts.find(name);
+                       if(n == m_avgcounts.end())
                                m_avgcounts[name] = -2;
                        else{
-                               if(n->getValue() == -1)
-                                       n->setValue(-2);
-                               assert(n->getValue() == -2);
+                               if(n->second == -1)
+                                       n->second = -2;
+                               assert(n->second == -2);
                        }
                }
                {
-                       core::map<std::string, float>::Node *n = m_data.find(name);
-                       if(n == NULL)
+                       std::map<std::string, float>::iterator n = m_data.find(name);
+                       if(n == m_data.end())
                                m_data[name] = value;
                        else
-                               n->setValue(n->getValue() + value);
+                               n->second += value;
                }
        }
 
        void avg(const std::string &name, float value)
        {
-               JMutexAutoLock lock(m_mutex);
-               {
-                       core::map<std::string, int>::Node *n = m_avgcounts.find(name);
-                       if(n == NULL)
-                               m_avgcounts[name] = 1;
-                       else{
-                               /* No add shall have been used */
-                               assert(n->getValue() != -2);
-                               if(n->getValue() <= 0)
-                                       n->setValue(1);
-                               else
-                                       n->setValue(n->getValue() + 1);
-                       }
-               }
-               {
-                       core::map<std::string, float>::Node *n = m_data.find(name);
-                       if(n == NULL)
-                               m_data[name] = value;
-                       else
-                               n->setValue(n->getValue() + value);
-               }
+               MutexAutoLock lock(m_mutex);
+               int &count = m_avgcounts[name];
+
+               assert(count != -2);
+               count = MYMAX(count, 0) + 1;
+               m_data[name] += value;
        }
 
        void clear()
        {
-               JMutexAutoLock lock(m_mutex);
-               for(core::map<std::string, float>::Iterator
-                               i = m_data.getIterator();
-                               i.atEnd() == false; i++)
+               MutexAutoLock lock(m_mutex);
+               for(std::map<std::string, float>::iterator
+                               i = m_data.begin();
+                               i != m_data.end(); ++i)
                {
-                       i.getNode()->setValue(0);
+                       i->second = 0;
                }
                m_avgcounts.clear();
        }
@@ -105,46 +97,56 @@ class Profiler
                printPage(o, 1, 1);
        }
 
+       float getValue(const std::string &name) const
+       {
+               std::map<std::string, float>::const_iterator numerator = m_data.find(name);
+               if (numerator == m_data.end())
+                       return 0.f;
+
+               std::map<std::string, int>::const_iterator denominator = m_avgcounts.find(name);
+               if (denominator != m_avgcounts.end()){
+                       if (denominator->second >= 1)
+                               return numerator->second / denominator->second;
+               }
+
+               return numerator->second;
+       }
+
        void printPage(std::ostream &o, u32 page, u32 pagecount)
        {
-               JMutexAutoLock lock(m_mutex);
+               MutexAutoLock lock(m_mutex);
 
                u32 minindex, maxindex;
                paging(m_data.size(), page, pagecount, minindex, maxindex);
 
-               for(core::map<std::string, float>::Iterator
-                               i = m_data.getIterator();
-                               i.atEnd() == false; i++)
-               {
-                       if(maxindex == 0)
+               for (std::map<std::string, float>::const_iterator i = m_data.begin();
+                               i != m_data.end(); ++i) {
+                       if (maxindex == 0)
                                break;
                        maxindex--;
 
-                       if(minindex != 0)
-                       {
+                       if (minindex != 0) {
                                minindex--;
                                continue;
                        }
 
-                       std::string name = i.getNode()->getKey();
                        int avgcount = 1;
-                       core::map<std::string, int>::Node *n = m_avgcounts.find(name);
-                       if(n){
-                               if(n->getValue() >= 1)
-                                       avgcount = n->getValue();
+                       std::map<std::string, int>::const_iterator n = m_avgcounts.find(i->first);
+                       if (n != m_avgcounts.end()) {
+                               if(n->second >= 1)
+                                       avgcount = n->second;
                        }
-                       o<<"  "<<name<<": ";
+                       o << "  " << i->first << ": ";
                        s32 clampsize = 40;
-                       s32 space = clampsize - name.size();
-                       for(s32 j=0; j<space; j++)
-                       {
-                               if(j%2 == 0 && j < space - 1)
-                                       o<<"-";
+                       s32 space = clampsize - i->first.size();
+                       for(s32 j = 0; j < space; j++) {
+                               if (j % 2 == 0 && j < space - 1)
+                                       o << "-";
                                else
-                                       o<<" ";
+                                       o << " ";
                        }
-                       o<<(i.getNode()->getValue() / avgcount);
-                       o<<std::endl;
+                       o << (i->second / avgcount);
+                       o << std::endl;
                }
        }
 
@@ -152,7 +154,7 @@ class Profiler
 
        void graphAdd(const std::string &id, float value)
        {
-               JMutexAutoLock lock(m_mutex);
+               MutexAutoLock lock(m_mutex);
                std::map<std::string, float>::iterator i =
                                m_graphvalues.find(id);
                if(i == m_graphvalues.end())
@@ -162,15 +164,22 @@ class Profiler
        }
        void graphGet(GraphValues &result)
        {
-               JMutexAutoLock lock(m_mutex);
+               MutexAutoLock lock(m_mutex);
                result = m_graphvalues;
                m_graphvalues.clear();
        }
 
+       void remove(const std::string& name)
+       {
+               MutexAutoLock lock(m_mutex);
+               m_avgcounts.erase(name);
+               m_data.erase(name);
+       }
+
 private:
-       JMutex m_mutex;
-       core::map<std::string, float> m_data;
-       core::map<std::string, int> m_avgcounts;
+       Mutex m_mutex;
+       std::map<std::string, float> m_data;
+       std::map<std::string, int> m_avgcounts;
        std::map<std::string, float> m_graphvalues;
 };