Fix unnecessary exception use in Map::isNodeUnderground

[dragonfireclient.git] / src / profiler.h

diff --git a/src/profiler.h b/src/profiler.h
index e5bb760c6dcbecc349dc605241f1a2a59766e0cc..6704afd514f96908920b4ea7f47b5e563efa00c0 100644 (file)
--- a/src/profiler.h
+++ b/src/profiler.h
@@ -17,21 +17,24 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-#ifndef PROFILER_HEADER
-#define PROFILER_HEADER
+#pragma once
 
 #include "irrlichttypes.h"
+#include <cassert>
 #include <string>
 #include <map>
+#include <ostream>
 
-#include "jthread/jmutex.h"
-#include "jthread/jmutexautolock.h"
+#include "threading/mutex_auto_lock.h"
 #include "util/timetaker.h"
-#include "util/numeric.h" // paging()
-#include "debug.h" // assert()
+#include "util/numeric.h"      // paging()
 
 #define MAX_PROFILER_TEXT_ROWS 20
 
+// Global profiler
+class Profiler;
+extern Profiler *g_profiler;
+
 /*
        Time profiler
 */
@@ -39,13 +42,11 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 class Profiler
 {
 public:
-       Profiler()
-       {
-       }
+       Profiler() = default;
 
        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 */
                        std::map<std::string, int>::iterator n = m_avgcounts.find(name);
@@ -68,7 +69,7 @@ class Profiler
 
        void avg(const std::string &name, float value)
        {
-               JMutexAutoLock lock(m_mutex);
+               MutexAutoLock lock(m_mutex);
                int &count = m_avgcounts[name];
 
                assert(count != -2);
@@ -78,12 +79,9 @@ class Profiler
 
        void clear()
        {
-               JMutexAutoLock lock(m_mutex);
-               for(std::map<std::string, float>::iterator
-                               i = m_data.begin();
-                               i != m_data.end(); ++i)
-               {
-                       i->second = 0;
+               MutexAutoLock lock(m_mutex);
+               for (auto &it : m_data) {
+                       it.second = 0;
                }
                m_avgcounts.clear();
        }
@@ -110,44 +108,39 @@ class Profiler
 
        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(std::map<std::string, float>::iterator
-                               i = m_data.begin();
-                               i != m_data.end(); ++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->first;
                        int avgcount = 1;
-                       std::map<std::string, int>::iterator n = m_avgcounts.find(name);
-                       if(n != m_avgcounts.end()){
+                       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->second / avgcount);
-                       o<<std::endl;
+                       o << (i->second / avgcount);
+                       o << std::endl;
                }
        }
 
@@ -155,7 +148,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())
@@ -165,20 +158,20 @@ 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)
        {
-               JMutexAutoLock lock(m_mutex);
+               MutexAutoLock lock(m_mutex);
                m_avgcounts.erase(name);
                m_data.erase(name);
        }
 
 private:
-       JMutex m_mutex;
+       std::mutex m_mutex;
        std::map<std::string, float> m_data;
        std::map<std::string, int> m_avgcounts;
        std::map<std::string, float> m_graphvalues;
@@ -194,54 +187,11 @@ class ScopeProfiler
 {
 public:
        ScopeProfiler(Profiler *profiler, const std::string &name,
-                       enum ScopeProfilerType type = SPT_ADD):
-               m_profiler(profiler),
-               m_name(name),
-               m_timer(NULL),
-               m_type(type)
-       {
-               if(m_profiler)
-                       m_timer = new TimeTaker(m_name.c_str());
-       }
-       // name is copied
-       ScopeProfiler(Profiler *profiler, const char *name,
-                       enum ScopeProfilerType type = SPT_ADD):
-               m_profiler(profiler),
-               m_name(name),
-               m_timer(NULL),
-               m_type(type)
-       {
-               if(m_profiler)
-                       m_timer = new TimeTaker(m_name.c_str());
-       }
-       ~ScopeProfiler()
-       {
-               if(m_timer)
-               {
-                       float duration_ms = m_timer->stop(true);
-                       float duration = duration_ms / 1000.0;
-                       if(m_profiler){
-                               switch(m_type){
-                               case SPT_ADD:
-                                       m_profiler->add(m_name, duration);
-                                       break;
-                               case SPT_AVG:
-                                       m_profiler->avg(m_name, duration);
-                                       break;
-                               case SPT_GRAPH_ADD:
-                                       m_profiler->graphAdd(m_name, duration);
-                                       break;
-                               }
-                       }
-                       delete m_timer;
-               }
-       }
+                       ScopeProfilerType type = SPT_ADD);
+       ~ScopeProfiler();
 private:
-       Profiler *m_profiler;
+       Profiler *m_profiler = nullptr;
        std::string m_name;
-       TimeTaker *m_timer;
+       TimeTaker *m_timer = nullptr;
        enum ScopeProfilerType m_type;
 };
-
-#endif
-