18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-20 12:44:59 +01:00

Merge pull request #385 from MaSzyna-EU07/feat/blackbox-standalone

feat(blackbox): the black box on its own, lighter physics logs, physicslog.trains
This commit is contained in:
2026-11-16 16:01:52 +00:00
committed by GitHub
18 changed files with 860 additions and 93 deletions

View File

@@ -540,9 +540,18 @@ bool global_settings::ConfigParseSimulation(cParser& Parser, const std::string&
return true;
}
// the physics logs of the trains only, of the drivers of rail vehicles; "physicslog yes" writes them all anyway
if (token == "physicslog.trains")
{
ParseOne(Parser, WriteTrainLogFlag);
return true;
}
if (token == "blackbox")
{
ParseOne(Parser, BlackBox);
bool blackbox{false};
ParseOne(Parser, blackbox);
BlackBox = blackbox;
return true;
}
@@ -1737,7 +1746,10 @@ global_settings::export_as_text( std::ostream &Output ) const {
export_as_text( Output, "sound.volume.ambient", EnvironmentAmbientVolume );
export_as_text( Output, "sound.asyncload", AudioAsyncLoad );
export_as_text( Output, "physicslog", WriteLogFlag );
export_as_text( Output, "blackbox", BlackBox );
export_as_text( Output, "physicslog.trains", WriteTrainLogFlag );
if( BlackBox ) {
export_as_text( Output, "blackbox", *BlackBox );
}
export_as_text( Output, "fullphysics", FullPhysics );
export_as_text( Output, "debuglog", iWriteLogEnabled );
export_as_text( Output, "multiplelogs", MultipleLogs );

View File

@@ -113,7 +113,9 @@ struct global_settings {
bool priorityLoadText3D{false}; // ladowanie T3D priorytetowo
int iWriteLogEnabled{ 3 }; // maska bitowa: 1-zapis do pliku, 2-okienko, 4-nazwy torów
bool MultipleLogs{ false };
bool BlackBox{ true }; // with the physics logs on, the black box of the session is written as well (blackbox_doc.md)
// the black box of the session (blackbox_doc.md): "blackbox yes" writes it whatever the physics logs, "blackbox no"
// never, and with no entry it is written along with the physics logs
std::optional<bool> BlackBox;
bool ShowSystemConsole{ false }; // toggle visibility of the OS console window with log output
unsigned int DisabledLogTypes{ 0 };
bool ParserLogIncludes{ true };

263
utilities/physicslog.cpp Normal file
View File

@@ -0,0 +1,263 @@
/*
This Source Code Form is subject to the
terms of the Mozilla Public License, v.
2.0. If a copy of the MPL was not
distributed with this file, You can
obtain one at
http://mozilla.org/MPL/2.0/.
*/
#include "stdafx.h"
#include "utilities/physicslog.h"
#include "utilities/Logs.h"
#include <algorithm>
#include <cctype>
#include <exception>
#include <fstream>
#include <future>
#include <memory>
#include <string_view>
#include <system_error>
#include <utility>
physicslog_writer PhysicsLogs;
namespace {
// the most of all the logs kept while their files can't be written, shared by those, a log never less than the
// least: the oldest lines go beyond it
constexpr std::size_t keptwhilefailing{64 * 1024 * 1024};
constexpr std::size_t keptwhilefailingleast{64 * 1024};
// the text cut to its last lines within Most
void keep_last(std::string &Text, std::size_t const Most) {
if (Text.size() <= Most)
return;
auto const cut{Text.find('\n', Text.size() - Most)};
Text.erase(0, cut == std::string::npos ? Text.size() : cut + 1);
}
// the name of the file of the log Name, its extension too. what no file name may have on Windows is replaced, on every
// system, so the logs are named alike everywhere: a spawned vehicle is named <spawn>:<number>, and on NTFS "a:1.dat"
// isn't even an error but the stream 1.dat of the file a, which nothing lists
std::string file_name(std::string const &Name) {
std::string name{Name};
for (auto &character : name) {
if (static_cast<unsigned char>(character) < 0x20 || std::string_view{R"(<>:"/\|?*)"}.find(character) != std::string_view::npos)
character = '_';
}
// a device rather than a file, with any extension: con.dat is the console. told by the name before its first dot
auto stem{name.substr(0, name.find('.'))};
while (false == stem.empty() && stem.back() == ' ')
stem.pop_back();
std::ranges::transform(stem, stem.begin(), [](unsigned char const Character) { return static_cast<char>(std::toupper(Character)); });
auto const numbered{stem.size() == 4 && (stem.starts_with("COM") || stem.starts_with("LPT")) && stem[3] >= '1' && stem[3] <= '9'};
if (numbered || stem == "CON" || stem == "PRN" || stem == "AUX" || stem == "NUL")
name.insert(0, 1, '_');
return name + ".dat";
}
// told in the log of the simulator, if there's the memory for it
void tell(std::string const &Text) noexcept {
try {
ErrorLog(Text);
} catch (...) {
// out of memory for a line of the log too: nothing more to be done about it
}
}
} // namespace
physicslog_writer::physicslog_writer(std::filesystem::path Folder, std::chrono::milliseconds const Interval) :
m_folder{std::move(Folder)}, m_shownfolder{m_folder.generic_string()}, m_interval{Interval} {}
physicslog_writer::~physicslog_writer() {
try {
stop();
} catch (...) {
// at the end of the process: what the logs couldn't keep, memory or a file, isn't to end it worse
}
}
void physicslog_writer::begin(std::string const &Name, std::string_view const Header) {
std::scoped_lock lock{m_mutex};
auto &lines{m_pending[Name]};
lines.fresh = true;
lines.header.assign(Header);
lines.text.clear();
start();
}
void physicslog_writer::append(std::string const &Name, std::string_view const Line) {
std::scoped_lock lock{m_mutex};
m_pending[Name].text.append(Line);
start();
}
void physicslog_writer::flush() {
std::scoped_lock files{m_filemutex};
write();
}
bool physicslog_writer::flush_for(std::chrono::milliseconds const Timeout) {
// on a thread of its own, left behind if it doesn't end in time: a disk which doesn't answer holds it up in the
// writing, not only the lock. for the end of the process, which doesn't wait for it
auto done{std::make_shared<std::promise<void>>()};
auto ended{done->get_future()};
std::thread([this, done] {
flush_safely();
done->set_value();
}).detach();
return ended.wait_for(Timeout) == std::future_status::ready;
}
void physicslog_writer::stop() {
std::jthread thread;
bool itself;
{
std::scoped_lock lock{m_mutex};
m_stopped = true;
// taken by the first to stop, so it's joined once
thread = std::move(m_thread);
itself = m_writer == std::this_thread::get_id();
}
// the stop asked outside the lock, which waking the writer takes
if (thread.joinable())
thread.request_stop();
// stopped from the writer itself, by the end of a run which failed in it: the files may be held by it
if (itself) {
if (thread.joinable())
thread.detach();
return;
}
if (thread.joinable())
thread.join();
flush_safely();
}
std::filesystem::path physicslog_writer::file(std::string const &Name) const {
auto const name{file_name(Name)};
#ifdef _WIN32
// in the code page of the system, as the standard library would convert it, but with the bytes not of it replaced
// instead of an exception thrown: a vehicle of a scenery written in 1250 on a Windows set to UTF-8, say
auto const size{static_cast<int>(name.size())};
std::wstring wide(static_cast<std::size_t>(::MultiByteToWideChar(CP_ACP, 0, name.data(), size, nullptr, 0)), L'\0');
::MultiByteToWideChar(CP_ACP, 0, name.data(), size, wide.data(), static_cast<int>(wide.size()));
return m_folder / wide;
#else
// the bytes are the name of the file as they are
return m_folder / name;
#endif
}
std::string physicslog_writer::shown(std::string const &Name) const {
return m_shownfolder + '/' + file_name(Name);
}
void physicslog_writer::start() {
if (m_stopped || m_thread.joinable())
return;
m_thread = std::jthread([this](std::stop_token const &Stop) { run(Stop); });
m_writer = m_thread.get_id();
}
void physicslog_writer::run(std::stop_token const &Stop) {
// woken by every stop asked, by stop() or by the end of the thread itself. the lock taken once first: the writer is
// either about to wait, and sees the stop, or waiting already
std::stop_callback const wake{Stop, [this] {
{ std::scoped_lock lock{m_mutex}; }
m_wake.notify_all();
}};
while (false == Stop.stop_requested()) {
{
std::unique_lock lock{m_mutex};
// woken early only to stop, which writes the rest itself
if (m_wake.wait_for(lock, m_interval, [&Stop] { return Stop.stop_requested(); }))
return;
}
flush_safely();
}
}
void physicslog_writer::flush_safely() noexcept {
try {
flush();
} catch (std::exception const &Error) {
tell(std::string{"Bad physics log: the writing failed ("} + Error.what() + "), the lines taken for it are lost");
} catch (...) {
tell("Bad physics log: the writing failed, the lines taken for it are lost");
}
}
void physicslog_writer::write() {
std::map<std::string, pending> taken;
{
std::scoped_lock lock{m_mutex};
taken.swap(m_pending);
}
if (taken.empty())
return;
std::error_code error;
std::filesystem::create_directories(m_folder, error);
std::map<std::string, pending> failed;
for (auto &[name, lines] : taken) {
if (lines.text.empty() && false == lines.fresh)
continue;
// a log going wrong otherwise, out of memory say, is kept for the next try as one whose file can't be written:
// the others are written still, and the writer goes on
auto written{false};
std::string problem{"can't write"};
try {
written = write_log(name, lines);
} catch (std::exception const &Error) {
problem = std::string{"failed ("} + Error.what() + ") to write";
}
if (written) {
if (m_failed.erase(name) > 0)
WriteLog("Physics log: " + shown(name) + " written again");
continue;
}
if (m_failed.insert(name).second)
ErrorLog("Bad physics log: " + problem + " " + shown(name) + ", its last lines are kept for the next try");
failed.emplace(name, std::move(lines));
}
if (failed.empty())
return;
// cut before the lock, which the simulation waits on to give its lines: only what came since is added under it
auto const most{std::max(keptwhilefailingleast, keptwhilefailing / failed.size())};
for (auto &[name, lines] : failed)
keep_last(lines.text, most);
// tried again the next time, before what came since; a file held by another program for a while doesn't lose
// them, nor its header. a log begun anew since drops them
std::scoped_lock lock{m_mutex};
for (auto &[name, lines] : failed) {
auto &now{m_pending[name]};
if (now.fresh)
continue;
lines.text.append(now.text);
now = std::move(lines);
}
}
bool physicslog_writer::write_log(std::string const &Name, pending const &Lines) const {
auto const path{file(Name)};
std::error_code error;
// how long it was, to be cut back to if the lines are written in part only, a disk filling up say: else they'd be
// written twice, the next time
auto const before{Lines.fresh ? 0 : std::filesystem::file_size(path, error)};
auto const existed{false == Lines.fresh && false == static_cast<bool>(error)};
// in text mode, as the logs were always written: on Windows their lines, which end with "\r\n", end with "\r\r\n"
std::ofstream stream{path, Lines.fresh ? std::ios::out | std::ios::trunc : std::ios::out | std::ios::app};
if (stream.is_open()) {
if (Lines.fresh)
stream << Lines.header;
stream << Lines.text;
}
stream.close();
if (false == stream.fail())
return true;
if (existed)
std::filesystem::resize_file(path, before, error);
return false;
}

88
utilities/physicslog.h Normal file
View File

@@ -0,0 +1,88 @@
/*
This Source Code Form is subject to the
terms of the Mozilla Public License, v.
2.0. If a copy of the MPL was not
distributed with this file, You can
obtain one at
http://mozilla.org/MPL/2.0/.
*/
#pragma once
#include <chrono>
#include <condition_variable>
#include <filesystem>
#include <map>
#include <mutex>
#include <set>
#include <stop_token>
#include <string>
#include <string_view>
#include <thread>
// the physics logs, <folder>/<name>.dat, what no file name may have on Windows replaced in the name (a spawned vehicle's
// has a ':'), the same on every system. the lines given are kept, and written every two seconds by a thread of its own,
// each file opened only for the moment it is written to: the logs of hundreds of vehicles hold no files open, and the
// simulation doesn't wait for the disk. a crash loses the last two seconds of real time of them. lines whose file can't
// be written, held by another program say, are kept for the next try: the last 64 MB of them all at most
class physicslog_writer {
public:
explicit physicslog_writer(std::filesystem::path Folder = "physicslog", std::chrono::milliseconds Interval = std::chrono::seconds{2});
physicslog_writer(physicslog_writer const &) = delete;
physicslog_writer &operator=(physicslog_writer const &) = delete;
// stops, writing what is kept
~physicslog_writer();
// starts the log Name anew: its file is emptied and Header written into it, the next time the logs are written.
// the lines of it not written yet are dropped
void begin(std::string const &Name, std::string_view Header);
// Line at the end of the log Name. a log not begun is added to as its file stands
void append(std::string const &Name, std::string_view Line);
// writes what is kept, now
void flush();
// as flush, waited for no longer than Timeout: then false, and the writing goes on by itself, on a thread left
// behind. for the end of the process, the files held up or the disk not answering
bool flush_for(std::chrono::milliseconds Timeout);
// writes what is kept and ends the thread. what is given after is written by a flush, or at the end
void stop();
// the file of the log Name: <folder>/<name>.dat, with < > : " / \ | ? * and the control characters of the name
// replaced by _, and _ before a name Windows keeps for a device (con, nul, com1...). the bytes of the code page of a
// scenery (1250) stay as they are, also on a Windows set to UTF-8, where the standard library would throw making a
// path of them: there they become U+FFFD
std::filesystem::path file(std::string const &Name) const;
// the same, for the log of the simulator
std::string shown(std::string const &Name) const;
private:
struct pending {
bool fresh{false}; // its file is to be emptied first, and the header written into it
std::string header;
std::string text;
};
// the thread, on the first line given, unless stopped. called with m_mutex held
void start();
void run(std::stop_token const &Stop);
// as flush, letting nothing out: on the writer's thread, or at the end of the process, an exception would end the
// simulator. what was taken for a writing which failed as a whole is lost, the next one goes on with what came since
void flush_safely() noexcept;
// called with m_filemutex held
void write();
// the lines of the log Name written into its file. returns: true if they all were
bool write_log(std::string const &Name, pending const &Lines) const;
std::filesystem::path const m_folder;
std::string const m_shownfolder;
std::chrono::milliseconds const m_interval;
std::mutex m_mutex; // the lines kept and the thread
std::map<std::string, pending> m_pending;
bool m_stopped{false};
std::condition_variable m_wake;
std::jthread m_thread;
std::thread::id m_writer; // of the thread, kept after it is taken to be joined: the writer knows itself by it
std::mutex m_filemutex; // the files are written one batch at a time, so the lines of a log stay in order
std::set<std::string> m_failed; // the logs whose file couldn't be written, told once
};
// the physics logs of the drivers (physicslog yes), and those the black box writes of the user's vehicles
extern physicslog_writer PhysicsLogs;