pcsx2/plugins/GSdx/GSFunctionMap.h

221 lines
4.4 KiB
C
Raw Normal View History

/*
* Copyright (C) 2007-2009 Gabest
* http://www.gabest.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (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
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Make; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
#pragma once
#include "GS.h"
#include "GSCodeBuffer.h"
struct GSRasterizerStats
{
int64 ticks;
int prims, pixels;
GSRasterizerStats()
{
Reset();
}
void Reset()
{
ticks = 0;
pixels = prims = 0;
}
};
template<class KEY, class VALUE> class GSFunctionMap
{
protected:
struct ActivePtr
{
uint64 frame, frames;
int64 ticks, pixels;
VALUE f;
};
hash_map<KEY, VALUE> m_map;
hash_map<KEY, ActivePtr*> m_map_active;
ActivePtr* m_active;
virtual VALUE GetDefaultFunction(KEY key) = 0;
public:
GSFunctionMap()
: m_active(NULL)
{
}
virtual ~GSFunctionMap()
{
for_each(m_map_active.begin(), m_map_active.end(), delete_second());
}
VALUE operator [] (KEY key)
{
m_active = NULL;
hash_map<KEY, ActivePtr*>::iterator i = m_map_active.find(key);
if(i != m_map_active.end())
{
m_active = i->second;
}
else
{
hash_map<KEY, VALUE>::iterator i = m_map.find(key);
ActivePtr* p = new ActivePtr();
memset(p, 0, sizeof(*p));
p->frame = (uint64)-1;
p->f = i != m_map.end() ? i->second : GetDefaultFunction(key);
m_map_active[key] = p;
m_active = p;
}
return m_active->f;
}
void UpdateStats(const GSRasterizerStats& stats, uint64 frame)
{
if(m_active)
{
if(m_active->frame != frame)
{
m_active->frame = frame;
m_active->frames++;
}
m_active->pixels += stats.pixels;
m_active->ticks += stats.ticks;
}
}
virtual void PrintStats()
{
int64 ttpf = 0;
for(hash_map<KEY, ActivePtr*>::iterator i = m_map_active.begin(); i != m_map_active.end(); i++)
{
ActivePtr* p = i->second;
if(p->frames)
{
ttpf += p->ticks / p->frames;
}
}
for(hash_map<KEY, ActivePtr*>::iterator i = m_map_active.begin(); i != m_map_active.end(); i++)
{
KEY key = i->first;
ActivePtr* p = i->second;
if(p->frames > 0)
{
int64 tpp = p->pixels > 0 ? p->ticks / p->pixels : 0;
int64 tpf = p->frames > 0 ? p->ticks / p->frames : 0;
int64 ppf = p->frames > 0 ? p->pixels / p->frames : 0;
printf("[%012I64x]%c %6.2f%% | %5.2f%% | f %4I64d | p %10I64d | tpp %4I64d | tpf %9I64d | ppf %7I64d\n",
(uint64)key, m_map.find(key) == m_map.end() ? '*' : ' ',
(float)(tpf * 10000 / 50000000) / 100,
(float)(tpf * 10000 / ttpf) / 100,
p->frames, p->pixels,
tpp, tpf, ppf);
}
}
}
};
#include "vtune/JITProfiling.h"
template<class CG, class KEY, class VALUE>
class GSCodeGeneratorFunctionMap : public GSFunctionMap<KEY, VALUE>
{
uint32 m_id;
string m_name;
hash_map<uint64, CG*> m_cgmap;
GSCodeBuffer m_cb;
enum {MAX_SIZE = 4096};
protected:
virtual CG* Create(KEY key, void* ptr, size_t maxsize = MAX_SIZE) = 0;
public:
GSCodeGeneratorFunctionMap(const char* name)
: m_id(0x100000)
, m_name(name)
{
}
virtual ~GSCodeGeneratorFunctionMap()
{
for_each(m_cgmap.begin(), m_cgmap.end(), delete_second());
}
VALUE GetDefaultFunction(KEY key)
{
CG* cg = NULL;
hash_map<uint64, CG*>::iterator i = m_cgmap.find(key);
if(i != m_cgmap.end())
{
cg = i->second;
}
else
{
void* ptr = m_cb.GetBuffer(MAX_SIZE);
cg = Create(key, ptr, MAX_SIZE);
ASSERT(cg);
m_cb.ReleaseBuffer(cg->getSize());
m_cgmap[key] = cg;
// vtune method registration
string name = format("%s<%016I64x>()", m_name.c_str(), (uint64)key);
iJIT_Method_Load ml;
memset(&ml, 0, sizeof(ml));
ml.method_id = m_id++;
ml.method_name = (char*)name.c_str();
ml.method_load_address = (void*)cg->getCode();
ml.method_size = cg->getSize();
iJIT_NotifyEvent(iJVM_EVENT_TYPE_METHOD_LOAD_FINISHED, &ml);
}
return (VALUE)cg->getCode();
}
};