mirror of
https://github.com/yse/easy_profiler.git
synced 2024-12-26 16:11:02 +08:00
306 lines
7.8 KiB
C++
306 lines
7.8 KiB
C++
//#define FULL_DISABLE_PROFILER
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include <vector>
|
|
#include <iostream>
|
|
#include <condition_variable>
|
|
#include <cstdlib>
|
|
#include <math.h>
|
|
|
|
#include <easy/profiler.h>
|
|
#include <easy/arbitrary_value.h>
|
|
#include <easy/reader.h>
|
|
|
|
std::condition_variable cv;
|
|
std::mutex cv_m;
|
|
int g_i = 0;
|
|
|
|
int OBJECTS = 500;
|
|
int MODELLING_STEPS = 1500;
|
|
int RENDER_STEPS = 1500;
|
|
int RESOURCE_LOADING_COUNT = 50;
|
|
|
|
//#define SAMPLE_NETWORK_TEST
|
|
|
|
void localSleep(uint64_t magic=200000)
|
|
{
|
|
//PROFILER_BEGIN_FUNCTION_BLOCK_GROUPED(profiler::colors::Blue);
|
|
volatile int i = 0;
|
|
for (; i < magic; ++i);
|
|
}
|
|
|
|
void loadingResources(){
|
|
EASY_FUNCTION(profiler::colors::DarkCyan);
|
|
localSleep();
|
|
// std::this_thread::sleep_for(std::chrono::milliseconds(50));
|
|
}
|
|
|
|
void prepareMath(){
|
|
EASY_FUNCTION(profiler::colors::Green);
|
|
uint64_t sum = 0;
|
|
int* intarray = new int[OBJECTS];
|
|
for (int i = 0; i < OBJECTS; ++i)
|
|
{
|
|
intarray[i] = i * i;
|
|
sum += i * i;
|
|
}
|
|
delete[] intarray;
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(3));
|
|
|
|
EASY_VALUE("sum", sum, profiler::colors::Blue);
|
|
}
|
|
|
|
void calcIntersect(){
|
|
EASY_FUNCTION(profiler::colors::Gold);
|
|
//int* intarray = new int[OBJECTS * OBJECTS];
|
|
int* intarray = new int[OBJECTS];
|
|
for (int i = 0; i < OBJECTS; ++i)
|
|
{
|
|
for (int j = i; j < OBJECTS; ++j)
|
|
//intarray[i * OBJECTS + j] = i * j - i / 2 + (OBJECTS - j) * 5;
|
|
intarray[j] = i * j - i / 2 + (OBJECTS - j) * 5;
|
|
}
|
|
delete[] intarray;
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(4));
|
|
}
|
|
|
|
double multModel(double i)
|
|
{
|
|
EASY_FUNCTION(profiler::colors::PaleGold);
|
|
return i * sin(i) * cos(i);
|
|
}
|
|
|
|
void calcPhys(){
|
|
EASY_FUNCTION(profiler::colors::Amber);
|
|
double* intarray = new double[OBJECTS];
|
|
for (int i = 0; i < OBJECTS; ++i)
|
|
intarray[i] = multModel(double(i)) + double(i / 3) - double((OBJECTS - i) / 2);
|
|
calcIntersect();
|
|
delete[] intarray;
|
|
}
|
|
|
|
double calcSubbrain(int i)
|
|
{
|
|
EASY_FUNCTION(profiler::colors::Navy);
|
|
auto val = i * i * i - i / 10 + (OBJECTS - i) * 7 ;
|
|
EASY_VALUE("subbrainResult", val, profiler::colors::DarkRed);
|
|
return val;
|
|
}
|
|
|
|
void calcBrain(){
|
|
EASY_FUNCTION(profiler::colors::LightBlue);
|
|
double* intarray = new double[OBJECTS];
|
|
for (int i = 0; i < OBJECTS; ++i)
|
|
intarray[i] = calcSubbrain(i) + double(i * 180 / 3);
|
|
delete[] intarray;
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(3));
|
|
}
|
|
|
|
void calculateBehavior(){
|
|
EASY_FUNCTION(profiler::colors::Blue);
|
|
calcPhys();
|
|
calcBrain();
|
|
}
|
|
|
|
void modellingStep(){
|
|
EASY_FUNCTION();
|
|
prepareMath();
|
|
calculateBehavior();
|
|
}
|
|
|
|
void prepareRender(){
|
|
EASY_FUNCTION(profiler::colors::Brick);
|
|
localSleep();
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(8));
|
|
|
|
}
|
|
|
|
int multPhys(int i)
|
|
{
|
|
EASY_FUNCTION(profiler::colors::Red700, profiler::ON);
|
|
return i * i * i * i / 100;
|
|
}
|
|
|
|
int calcPhysicForObject(int i)
|
|
{
|
|
EASY_FUNCTION(profiler::colors::Red);
|
|
return multPhys(i) + i / 3 - (OBJECTS - i) * 15;
|
|
}
|
|
|
|
void calculatePhysics(){
|
|
EASY_FUNCTION(profiler::colors::Red);
|
|
unsigned int* intarray = new unsigned int[OBJECTS];
|
|
for (int i = 0; i < OBJECTS; ++i)
|
|
intarray[i] = calcPhysicForObject(i);
|
|
delete[] intarray;
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(8));
|
|
}
|
|
|
|
void quadratic_loop(uint64_t n)
|
|
{
|
|
EASY_FUNCTION(profiler::colors::Blue);
|
|
EASY_VALUE("N", n);
|
|
volatile int i = 0;
|
|
for (; i < n; ++i)
|
|
localSleep(n);
|
|
}
|
|
|
|
void frame(uint64_t n){
|
|
EASY_FUNCTION(profiler::colors::Magenta);
|
|
prepareRender();
|
|
calculatePhysics();
|
|
quadratic_loop(n);
|
|
}
|
|
|
|
void loadingResourcesThread(){
|
|
//std::unique_lock<std::mutex> lk(cv_m);
|
|
//cv.wait(lk, []{return g_i == 1; });
|
|
EASY_THREAD("Resource loading");
|
|
#ifdef SAMPLE_NETWORK_TEST
|
|
while (true) {
|
|
#else
|
|
for(int i = 0; i < RESOURCE_LOADING_COUNT; i++){
|
|
#endif
|
|
loadingResources();
|
|
EASY_EVENT("Resources Loading!", profiler::colors::Cyan);
|
|
localSleep(1200000);
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
}
|
|
}
|
|
|
|
void modellingThread(){
|
|
//std::unique_lock<std::mutex> lk(cv_m);
|
|
//cv.wait(lk, []{return g_i == 1; });
|
|
EASY_THREAD("Modelling");
|
|
uint64_t step = 0;
|
|
#ifdef SAMPLE_NETWORK_TEST
|
|
while (true) {
|
|
#else
|
|
for (int i = 0; i < MODELLING_STEPS; i++){
|
|
#endif
|
|
EASY_END_BLOCK;
|
|
EASY_NONSCOPED_BLOCK("Frame", true, 15., profiler::ON, -5.f, profiler::colors::Red);
|
|
modellingStep();
|
|
|
|
localSleep(1200000);
|
|
|
|
++step;
|
|
double vals[] = {(double)step, sin((double)step), cos((double)step)};
|
|
EASY_VALUE("step", vals, profiler::colors::Gold, EASY_VIN(step));
|
|
if (step > 10000000)
|
|
step = 0;
|
|
|
|
EASY_TEXT("Test String", "Some short text. Hey!", profiler::colors::Red);
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
}
|
|
EASY_END_BLOCK;
|
|
}
|
|
|
|
void renderThread(){
|
|
//std::unique_lock<std::mutex> lk(cv_m);
|
|
//cv.wait(lk, []{return g_i == 1; });
|
|
EASY_THREAD("Render");
|
|
uint64_t n = 20;
|
|
#ifdef SAMPLE_NETWORK_TEST
|
|
while (true) {
|
|
#else
|
|
for (int i = 0; i < RENDER_STEPS; i++){
|
|
#endif
|
|
frame(n);
|
|
localSleep(1200000);
|
|
n += 20;
|
|
if (n >= 700)
|
|
n = 20;
|
|
//std::this_thread::sleep_for(std::chrono::milliseconds(20));
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
if (argc > 1 && argv[1]){
|
|
OBJECTS = std::atoi(argv[1]);
|
|
}
|
|
if (argc > 2 && argv[2]){
|
|
MODELLING_STEPS = std::atoi(argv[2]);
|
|
}
|
|
if (argc > 3 && argv[3]){
|
|
RENDER_STEPS = std::atoi(argv[3]);
|
|
}
|
|
if (argc > 4 && argv[4]){
|
|
RESOURCE_LOADING_COUNT = std::atoi(argv[4]);
|
|
}
|
|
|
|
std::cout << "Objects count: " << OBJECTS << std::endl;
|
|
std::cout << "Render steps: " << RENDER_STEPS << std::endl;
|
|
std::cout << "Modelling steps: " << MODELLING_STEPS << std::endl;
|
|
std::cout << "Resource loading count: " << RESOURCE_LOADING_COUNT << std::endl;
|
|
|
|
auto start = std::chrono::system_clock::now();
|
|
|
|
#ifndef SAMPLE_NETWORK_TEST
|
|
EASY_PROFILER_ENABLE;
|
|
#endif
|
|
|
|
EASY_MAIN_THREAD;
|
|
profiler::startListen();
|
|
|
|
#ifdef EASY_CONSTEXPR_AVAILABLE
|
|
constexpr int grrr[] {2, -3, 4};
|
|
auto pppp = &grrr;
|
|
EASY_ARRAY("threads count", grrr, 3, false, true, "blabla", profiler::colors::Blue/*, EASY_VIN("threads count")*/, profiler::OFF);
|
|
#endif
|
|
|
|
int* intPtr = new int(2);
|
|
EASY_VALUE("count", *intPtr);
|
|
|
|
std::vector<std::thread> threads;
|
|
//for (int i=0; i < 3; i++)
|
|
{
|
|
threads.emplace_back(loadingResourcesThread);
|
|
threads.emplace_back(renderThread);
|
|
threads.emplace_back(modellingThread);
|
|
}
|
|
|
|
cv_m.lock();
|
|
g_i = 1;
|
|
cv_m.unlock();
|
|
cv.notify_all();
|
|
|
|
#ifndef SAMPLE_NETWORK_TEST
|
|
std::atomic_bool stop;
|
|
stop = false;
|
|
auto frame_time_printer_thread = std::thread([&stop]()
|
|
{
|
|
while (!stop.load(std::memory_order_acquire))
|
|
{
|
|
std::cout << "Frame time: max " << profiler::main_thread::frameTimeLocalMax() << " us // avg " << profiler::main_thread::frameTimeLocalAvg() << " us\n";
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(500));
|
|
}
|
|
});
|
|
#endif
|
|
|
|
modellingThread();
|
|
|
|
#ifndef SAMPLE_NETWORK_TEST
|
|
stop.store(true, std::memory_order_release);
|
|
frame_time_printer_thread.join();
|
|
#endif
|
|
|
|
for(auto& t : threads)
|
|
t.join();
|
|
|
|
auto end = std::chrono::system_clock::now();
|
|
auto elapsed =
|
|
std::chrono::duration_cast<std::chrono::microseconds>(end - start);
|
|
|
|
std::cout << "Elapsed time: " << elapsed.count() << " usec" << std::endl;
|
|
|
|
auto blocks_count = profiler::dumpBlocksToFile("test.prof");
|
|
|
|
std::cout << "Blocks count: " << blocks_count << std::endl;
|
|
|
|
return 0;
|
|
}
|