2011-05-30 23:15:43 +02:00
|
|
|
/*
|
2013-02-24 18:40:43 +01:00
|
|
|
Minetest
|
2013-02-24 19:38:45 +01:00
|
|
|
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2011-05-30 23:15:43 +02:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 16:56:56 +02:00
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
2011-05-30 23:15:43 +02:00
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
2012-06-05 16:56:56 +02:00
|
|
|
GNU Lesser General Public License for more details.
|
2011-05-30 23:15:43 +02:00
|
|
|
|
2012-06-05 16:56:56 +02:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2011-05-30 23:15:43 +02:00
|
|
|
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
|
|
|
|
|
2013-08-11 04:09:45 +02:00
|
|
|
#include "irrlichttypes.h"
|
2011-05-30 23:15:43 +02:00
|
|
|
#include <string>
|
2013-09-16 05:00:01 +02:00
|
|
|
#include "jthread/jmutex.h"
|
|
|
|
#include "jthread/jmutexautolock.h"
|
2012-03-21 02:33:02 +01:00
|
|
|
#include <map>
|
2012-06-17 01:40:36 +02:00
|
|
|
#include "util/timetaker.h"
|
|
|
|
#include "util/numeric.h" // paging()
|
2013-08-11 04:09:45 +02:00
|
|
|
#include "debug.h" // assert()
|
2011-05-30 23:15:43 +02:00
|
|
|
|
|
|
|
/*
|
|
|
|
Time profiler
|
|
|
|
*/
|
|
|
|
|
|
|
|
class Profiler
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
Profiler()
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2011-10-16 20:16:44 +02:00
|
|
|
void add(const std::string &name, float value)
|
2011-05-30 23:15:43 +02:00
|
|
|
{
|
|
|
|
JMutexAutoLock lock(m_mutex);
|
|
|
|
{
|
2011-10-16 21:39:35 +02:00
|
|
|
/* No average shall have been used; mark add used as -2 */
|
2012-12-20 18:19:49 +01:00
|
|
|
std::map<std::string, int>::iterator n = m_avgcounts.find(name);
|
|
|
|
if(n == m_avgcounts.end())
|
2011-10-16 21:39:35 +02:00
|
|
|
m_avgcounts[name] = -2;
|
|
|
|
else{
|
2012-12-20 18:19:49 +01:00
|
|
|
if(n->second == -1)
|
|
|
|
n->second = -2;
|
|
|
|
assert(n->second == -2);
|
2011-10-16 21:39:35 +02:00
|
|
|
}
|
2011-05-30 23:15:43 +02:00
|
|
|
}
|
|
|
|
{
|
2012-12-20 18:19:49 +01:00
|
|
|
std::map<std::string, float>::iterator n = m_data.find(name);
|
|
|
|
if(n == m_data.end())
|
2011-10-16 21:39:35 +02:00
|
|
|
m_data[name] = value;
|
|
|
|
else
|
2012-12-20 18:19:49 +01:00
|
|
|
n->second += value;
|
2011-10-16 20:16:44 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-16 21:39:35 +02:00
|
|
|
void avg(const std::string &name, float value)
|
2011-10-16 20:16:44 +02:00
|
|
|
{
|
|
|
|
JMutexAutoLock lock(m_mutex);
|
|
|
|
{
|
2012-12-20 18:19:49 +01:00
|
|
|
std::map<std::string, int>::iterator n = m_avgcounts.find(name);
|
|
|
|
if(n == m_avgcounts.end())
|
2011-10-16 21:39:35 +02:00
|
|
|
m_avgcounts[name] = 1;
|
|
|
|
else{
|
|
|
|
/* No add shall have been used */
|
2012-12-20 18:19:49 +01:00
|
|
|
assert(n->second != -2);
|
2013-03-23 07:24:31 +01:00
|
|
|
n->second = (std::max)(n->second, 0) + 1;
|
2011-10-16 21:39:35 +02:00
|
|
|
}
|
2011-10-16 20:16:44 +02:00
|
|
|
}
|
|
|
|
{
|
2012-12-20 18:19:49 +01:00
|
|
|
std::map<std::string, float>::iterator n = m_data.find(name);
|
|
|
|
if(n == m_data.end())
|
2011-10-16 21:39:35 +02:00
|
|
|
m_data[name] = value;
|
|
|
|
else
|
2012-12-20 18:19:49 +01:00
|
|
|
n->second += value;
|
2011-05-30 23:15:43 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void clear()
|
|
|
|
{
|
|
|
|
JMutexAutoLock lock(m_mutex);
|
2012-12-20 18:19:49 +01:00
|
|
|
for(std::map<std::string, float>::iterator
|
|
|
|
i = m_data.begin();
|
|
|
|
i != m_data.end(); ++i)
|
2011-05-30 23:15:43 +02:00
|
|
|
{
|
2012-12-20 18:19:49 +01:00
|
|
|
i->second = 0;
|
2011-05-30 23:15:43 +02:00
|
|
|
}
|
2011-10-16 21:39:35 +02:00
|
|
|
m_avgcounts.clear();
|
2011-05-30 23:15:43 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void print(std::ostream &o)
|
2012-02-01 00:56:30 +01:00
|
|
|
{
|
|
|
|
printPage(o, 1, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void printPage(std::ostream &o, u32 page, u32 pagecount)
|
2011-05-30 23:15:43 +02:00
|
|
|
{
|
|
|
|
JMutexAutoLock lock(m_mutex);
|
2012-02-01 00:56:30 +01:00
|
|
|
|
|
|
|
u32 minindex, maxindex;
|
|
|
|
paging(m_data.size(), page, pagecount, minindex, maxindex);
|
|
|
|
|
2012-12-20 18:19:49 +01:00
|
|
|
for(std::map<std::string, float>::iterator
|
|
|
|
i = m_data.begin();
|
|
|
|
i != m_data.end(); ++i)
|
2011-05-30 23:15:43 +02:00
|
|
|
{
|
2012-02-01 00:56:30 +01:00
|
|
|
if(maxindex == 0)
|
|
|
|
break;
|
|
|
|
maxindex--;
|
|
|
|
|
|
|
|
if(minindex != 0)
|
|
|
|
{
|
|
|
|
minindex--;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2012-12-20 18:19:49 +01:00
|
|
|
std::string name = i->first;
|
2011-10-16 21:39:35 +02:00
|
|
|
int avgcount = 1;
|
2012-12-20 18:19:49 +01:00
|
|
|
std::map<std::string, int>::iterator n = m_avgcounts.find(name);
|
|
|
|
if(n != m_avgcounts.end()){
|
|
|
|
if(n->second >= 1)
|
|
|
|
avgcount = n->second;
|
2011-10-16 21:39:35 +02:00
|
|
|
}
|
2011-10-16 20:16:44 +02:00
|
|
|
o<<" "<<name<<": ";
|
2011-05-30 23:15:43 +02:00
|
|
|
s32 clampsize = 40;
|
2011-10-16 20:16:44 +02:00
|
|
|
s32 space = clampsize - name.size();
|
2011-05-30 23:15:43 +02:00
|
|
|
for(s32 j=0; j<space; j++)
|
|
|
|
{
|
|
|
|
if(j%2 == 0 && j < space - 1)
|
|
|
|
o<<"-";
|
|
|
|
else
|
|
|
|
o<<" ";
|
|
|
|
}
|
2012-12-20 18:19:49 +01:00
|
|
|
o<<(i->second / avgcount);
|
2011-05-30 23:15:43 +02:00
|
|
|
o<<std::endl;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-21 02:33:02 +01:00
|
|
|
typedef std::map<std::string, float> GraphValues;
|
|
|
|
|
|
|
|
void graphAdd(const std::string &id, float value)
|
|
|
|
{
|
|
|
|
JMutexAutoLock lock(m_mutex);
|
|
|
|
std::map<std::string, float>::iterator i =
|
|
|
|
m_graphvalues.find(id);
|
|
|
|
if(i == m_graphvalues.end())
|
|
|
|
m_graphvalues[id] = value;
|
|
|
|
else
|
|
|
|
i->second += value;
|
|
|
|
}
|
|
|
|
void graphGet(GraphValues &result)
|
|
|
|
{
|
|
|
|
JMutexAutoLock lock(m_mutex);
|
|
|
|
result = m_graphvalues;
|
|
|
|
m_graphvalues.clear();
|
|
|
|
}
|
|
|
|
|
2014-01-06 15:21:22 +01:00
|
|
|
void remove(const std::string& name)
|
|
|
|
{
|
|
|
|
JMutexAutoLock lock(m_mutex);
|
|
|
|
m_avgcounts.erase(name);
|
|
|
|
m_data.erase(name);
|
|
|
|
}
|
|
|
|
|
2011-05-30 23:15:43 +02:00
|
|
|
private:
|
|
|
|
JMutex m_mutex;
|
2012-12-20 18:19:49 +01:00
|
|
|
std::map<std::string, float> m_data;
|
|
|
|
std::map<std::string, int> m_avgcounts;
|
2012-03-21 02:33:02 +01:00
|
|
|
std::map<std::string, float> m_graphvalues;
|
2011-10-16 20:16:44 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
enum ScopeProfilerType{
|
|
|
|
SPT_ADD,
|
2012-03-21 14:38:24 +01:00
|
|
|
SPT_AVG,
|
|
|
|
SPT_GRAPH_ADD
|
2011-05-30 23:15:43 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
class ScopeProfiler
|
|
|
|
{
|
|
|
|
public:
|
2011-10-16 20:16:44 +02:00
|
|
|
ScopeProfiler(Profiler *profiler, const std::string &name,
|
|
|
|
enum ScopeProfilerType type = SPT_ADD):
|
2011-05-30 23:15:43 +02:00
|
|
|
m_profiler(profiler),
|
|
|
|
m_name(name),
|
2011-10-16 20:16:44 +02:00
|
|
|
m_timer(NULL),
|
|
|
|
m_type(type)
|
2011-05-30 23:15:43 +02:00
|
|
|
{
|
|
|
|
if(m_profiler)
|
|
|
|
m_timer = new TimeTaker(m_name.c_str());
|
|
|
|
}
|
|
|
|
// name is copied
|
2011-10-16 20:16:44 +02:00
|
|
|
ScopeProfiler(Profiler *profiler, const char *name,
|
|
|
|
enum ScopeProfilerType type = SPT_ADD):
|
2011-05-30 23:15:43 +02:00
|
|
|
m_profiler(profiler),
|
|
|
|
m_name(name),
|
2011-10-16 20:16:44 +02:00
|
|
|
m_timer(NULL),
|
|
|
|
m_type(type)
|
2011-05-30 23:15:43 +02:00
|
|
|
{
|
|
|
|
if(m_profiler)
|
|
|
|
m_timer = new TimeTaker(m_name.c_str());
|
|
|
|
}
|
|
|
|
~ScopeProfiler()
|
|
|
|
{
|
|
|
|
if(m_timer)
|
|
|
|
{
|
2011-10-16 21:39:35 +02:00
|
|
|
float duration_ms = m_timer->stop(true);
|
|
|
|
float duration = duration_ms / 1000.0;
|
2011-10-16 20:16:44 +02:00
|
|
|
if(m_profiler){
|
|
|
|
switch(m_type){
|
|
|
|
case SPT_ADD:
|
|
|
|
m_profiler->add(m_name, duration);
|
|
|
|
break;
|
2011-10-16 21:39:35 +02:00
|
|
|
case SPT_AVG:
|
|
|
|
m_profiler->avg(m_name, duration);
|
2011-10-16 20:16:44 +02:00
|
|
|
break;
|
2012-03-21 14:38:24 +01:00
|
|
|
case SPT_GRAPH_ADD:
|
|
|
|
m_profiler->graphAdd(m_name, duration);
|
|
|
|
break;
|
2011-10-16 20:16:44 +02:00
|
|
|
}
|
|
|
|
}
|
2011-05-30 23:15:43 +02:00
|
|
|
delete m_timer;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
Profiler *m_profiler;
|
|
|
|
std::string m_name;
|
|
|
|
TimeTaker *m_timer;
|
2011-10-16 20:16:44 +02:00
|
|
|
enum ScopeProfilerType m_type;
|
2011-05-30 23:15:43 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|