mirror of
https://github.com/libretro/bsnes-libretro.git
synced 2024-11-23 08:59:40 +00:00
f5e5bf1772
byuu says: (Windows users may need to include <sys/time.h> at the top of nall/chrono.hpp, not sure.) Unchangelog: - forgot to add the Scheduler clock=0 fix because I have the memory of a goldfish Changelog: - new icarus database with nine additional games - hiro(GTK,Qt) won't constantly write its settings.bml file to disk anymore - added latency simulator for fun (settings.bml => Input/Latency in milliseconds) So the last one ... I wanted to test out nall::chrono, and I was also thinking that by polling every emulated frame, it's pretty wasteful when you are using Fast Forward and hitting 200+fps. As I've said before, calls to ruby::input::poll are not cheap. So to get around this, I added a limiter so that if you called the hardware poll function within N milliseconds, it'll return without doing any actual work. And indeed, that increases my framerate of Zelda 3 uncapped from 133fps to 142fps. Yay. But it's not a "real" speedup, as it only helps you when you exceed 100% speed (theoretically, you'd need to crack 300% speed since the game itself will poll at 16ms at 100% speed, but yet it sped up Zelda 3, so who am I to complain?) I threw the latency value into the settings file. It should be 16, but I set it to 5 since that was the lowest before it started negatively impacting uncapped speeds. You're wasting your time and CPU cycles setting it lower than 5, but if people like placebo effects it might work. Maybe I should let it be a signed integer so people can set it to -16 and think it's actually faster :P (I'm only joking. I took out the 96000hz audio placebo effect as well. Not really into psychological tricks anymore.) But yeah seriously, I didn't do this to start this discussion again for the billionth time. Please don't go there. And please don't tell me this WIP has higher/lower latency than before. I don't want to hear it. The only reason I bring it up is for the fun part that is worth discussing: put up or shut up time on how sensitive you are to latency! You can set the value above 5 to see how games feel. I personally can't really tell a difference until about 50. And I can't be 100% confident it's worse until about 75. But ... when I set it to 150, games become "extra difficult" ... the higher it goes, the worse it gets :D For this WIP, I've left no upper limit cap. I'll probably set a cap of something like 500ms or 1000ms for the official release. Need to balance user error/trolling with enjoyability. I'll think about it. [...] Now, what I worry about is stupid people seeing it and thinking it's an "added latency" setting, as if anyone would intentionally make things worse by default. This is a limiter. So if 5ms have passed since the game last polled, and that will be the case 99.9% of the time in games, the next poll will happen just in time, immediately when the game polls the inputs. Thus, a value below 1/<framerate>ms is not only pointless, if you go too low it will ruin your fast forward max speeds. I did say I didn't want to resort to placebo tricks, but I also don't want to spark up public discussion on this again either. So it might be best to default Input/Latency to 0ms, and internally have a max(5, latency) wrapper around the value.
135 lines
4.5 KiB
C++
135 lines
4.5 KiB
C++
#pragma once
|
|
|
|
#include <nall/function.hpp>
|
|
#include <nall/string.hpp>
|
|
|
|
namespace nall { namespace chrono { namespace {
|
|
|
|
//passage of time functions (from unknown epoch)
|
|
|
|
auto nanosecond() -> uint64_t {
|
|
timespec tv;
|
|
clock_gettime(CLOCK_MONOTONIC, &tv);
|
|
return tv.tv_sec * 1'000'000'000 + tv.tv_nsec;
|
|
}
|
|
|
|
auto microsecond() -> uint64_t { return nanosecond() / 1'000; }
|
|
auto millisecond() -> uint64_t { return nanosecond() / 1'000'000; }
|
|
auto second() -> uint64_t { return nanosecond() / 1'000'000'000; }
|
|
|
|
auto benchmark(const function<void ()>& f, uint64_t times = 1) -> void {
|
|
auto start = nanosecond();
|
|
while(times--) f();
|
|
auto end = nanosecond();
|
|
print("[chrono::benchmark] ", (double)(end - start) / 1'000'000'000.0, "s\n");
|
|
}
|
|
|
|
//exact date/time functions (from system epoch)
|
|
|
|
struct timeinfo {
|
|
timeinfo(
|
|
uint year = 0, uint month = 0, uint day = 0,
|
|
uint hour = 0, uint minute = 0, uint second = 0, uint weekday = 0
|
|
) : year(year), month(month), day(day),
|
|
hour(hour), minute(minute), second(second), weekday(weekday) {
|
|
}
|
|
|
|
explicit operator bool() const { return month; }
|
|
|
|
uint year; //...
|
|
uint month; //1 - 12
|
|
uint day; //1 - 31
|
|
uint hour; //0 - 23
|
|
uint minute; //0 - 59
|
|
uint second; //0 - 60
|
|
uint weekday; //0 - 6
|
|
};
|
|
|
|
auto timestamp() -> uint64_t {
|
|
return ::time(nullptr);
|
|
}
|
|
|
|
namespace utc {
|
|
auto timeinfo(uint64_t time = 0) -> chrono::timeinfo {
|
|
auto stamp = time ? (time_t)time : (time_t)timestamp();
|
|
auto info = gmtime(&stamp);
|
|
return {
|
|
(uint)info->tm_year + 1900,
|
|
(uint)info->tm_mon + 1,
|
|
(uint)info->tm_mday,
|
|
(uint)info->tm_hour,
|
|
(uint)info->tm_min,
|
|
(uint)info->tm_sec,
|
|
(uint)info->tm_wday
|
|
};
|
|
}
|
|
|
|
auto year(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).year, 4, '0'); }
|
|
auto month(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).month, 2, '0'); }
|
|
auto day(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).day, 2, '0'); }
|
|
auto hour(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).hour, 2, '0'); }
|
|
auto minute(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).minute, 2, '0'); }
|
|
auto second(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).second, 2, '0'); }
|
|
|
|
auto date(uint64_t timestamp = 0) -> string {
|
|
auto t = timeinfo(timestamp);
|
|
return {pad(t.year, 4, '0'), "-", pad(t.month, 2, '0'), "-", pad(t.day, 2, '0')};
|
|
}
|
|
|
|
auto time(uint64_t timestamp = 0) -> string {
|
|
auto t = timeinfo(timestamp);
|
|
return {pad(t.hour, 2, '0'), ":", pad(t.minute, 2, '0'), ":", pad(t.second, 2, '0')};
|
|
}
|
|
|
|
auto datetime(uint64_t timestamp = 0) -> string {
|
|
auto t = timeinfo(timestamp);
|
|
return {
|
|
pad(t.year, 4, '0'), "-", pad(t.month, 2, '0'), "-", pad(t.day, 2, '0'), " ",
|
|
pad(t.hour, 2, '0'), ":", pad(t.minute, 2, '0'), ":", pad(t.second, 2, '0')
|
|
};
|
|
}
|
|
}
|
|
|
|
namespace local {
|
|
auto timeinfo(uint64_t time = 0) -> chrono::timeinfo {
|
|
auto stamp = time ? (time_t)time : (time_t)timestamp();
|
|
auto info = localtime(&stamp);
|
|
return {
|
|
(uint)info->tm_year + 1900,
|
|
(uint)info->tm_mon + 1,
|
|
(uint)info->tm_mday,
|
|
(uint)info->tm_hour,
|
|
(uint)info->tm_min,
|
|
(uint)info->tm_sec,
|
|
(uint)info->tm_wday
|
|
};
|
|
}
|
|
|
|
auto year(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).year, 4, '0'); }
|
|
auto month(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).month, 2, '0'); }
|
|
auto day(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).day, 2, '0'); }
|
|
auto hour(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).hour, 2, '0'); }
|
|
auto minute(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).minute, 2, '0'); }
|
|
auto second(uint64_t timestamp = 0) -> string { return pad(timeinfo(timestamp).second, 2, '0'); }
|
|
|
|
auto date(uint64_t timestamp = 0) -> string {
|
|
auto t = timeinfo(timestamp);
|
|
return {pad(t.year, 4, '0'), "-", pad(t.month, 2, '0'), "-", pad(t.day, 2, '0')};
|
|
}
|
|
|
|
auto time(uint64_t timestamp = 0) -> string {
|
|
auto t = timeinfo(timestamp);
|
|
return {pad(t.hour, 2, '0'), ":", pad(t.minute, 2, '0'), ":", pad(t.second, 2, '0')};
|
|
}
|
|
|
|
auto datetime(uint64_t timestamp = 0) -> string {
|
|
auto t = timeinfo(timestamp);
|
|
return {
|
|
pad(t.year, 4, '0'), "-", pad(t.month, 2, '0'), "-", pad(t.day, 2, '0'), " ",
|
|
pad(t.hour, 2, '0'), ":", pad(t.minute, 2, '0'), ":", pad(t.second, 2, '0')
|
|
};
|
|
}
|
|
}
|
|
|
|
}}}
|