mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-19 23:55:00 +01:00
"physicslog yes" kept the .dat of every vehicle with a driver open for the whole run and flushed it twenty times a second from the simulation's thread: some 580 open files on Tomaszewo. The lines are kept now and a thread of their own writes them every two seconds, each file opened only for the moment it is written to. The files, their lines and their text mode stay as they were. - The black box, with the physics logs off, writes the tapes of the user's vehicles through the same writer as it goes, not at the end. A log begins when the user is first in the vehicle and goes on while the user looks around outside, until another vehicle is taken; back in it, the log goes on after the gap. The vehicle's own driver keeps the log only if it is the primary one, as a passive one's clock stands still; otherwise the driver of its train does. - What is kept is written when the simulator closes, after the black box, at the end of a test run, and when the test watchdog ends a run. A crash loses the last two seconds. - On Tomaszewo with the black box alone, the one tape grows every two seconds. With "physicslog yes", the 581 logs grow and the simulator holds as many handles as without them; writing them takes the thread about 1.9 s, which the closing waits for once.
273 lines
8.8 KiB
C++
273 lines
8.8 KiB
C++
/*
|
|
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 "simulation/simulationtest.h"
|
|
|
|
#include "application/application.h"
|
|
#include "scene/scene.h"
|
|
#include "simulation/simulation.h"
|
|
#include "utilities/Globals.h"
|
|
#include "utilities/Logs.h"
|
|
#include "utilities/physicslog.h"
|
|
#include "utilities/utilities.h"
|
|
#include "vehicle/DynObj.h"
|
|
#include "world/Event.h"
|
|
#include "world/MemCell.h"
|
|
#ifdef _WIN32
|
|
#include "Console.h"
|
|
#endif
|
|
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <format>
|
|
#include <memory>
|
|
|
|
namespace {
|
|
|
|
bool is_moving(TDynamicObject const *Vehicle)
|
|
{
|
|
return std::abs(Vehicle->GetVelocity()) > 0.01;
|
|
}
|
|
|
|
// [s] of real time since the start of the simulator
|
|
double elapsed_wall_time()
|
|
{
|
|
return std::chrono::duration<double>(std::chrono::steady_clock::now() - Global.startTimestamp).count();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
namespace simulation {
|
|
|
|
test_manager &test()
|
|
{
|
|
static test_manager instance;
|
|
return instance;
|
|
}
|
|
|
|
void apply_test_mode_settings()
|
|
{
|
|
// nobody watches nor listens: no player vehicle, nothing drawn, no sound, no window in the way
|
|
Global.editor_session = false;
|
|
Global.local_start_vehicle = "ghostview";
|
|
Global.GfxRenderer = "null";
|
|
Global.NvRenderer = false;
|
|
Global.bSoundEnabled = false;
|
|
Global.python_enabled = false;
|
|
Global.bInactivePause = false;
|
|
Global.bFullScreen = false;
|
|
Global.fullscreen_windowed = false;
|
|
Global.VSync = false;
|
|
Global.iMultisampling = 0;
|
|
Global.gfx_usegles = false;
|
|
Global.minframetime = std::chrono::duration<float>(0.0f);
|
|
Global.extra_viewports.clear();
|
|
Global.headtrack_conf.joy.clear();
|
|
// a test runs on its own: no network, and no input from outside (eu07/maszyna#541)
|
|
Global.network_servers.clear();
|
|
Global.network_client.reset();
|
|
Global.InputGamepad = false;
|
|
Global.InputMouse = false;
|
|
Global.uart_conf.enable = false;
|
|
Global.motiontelemetry_conf.enable = false;
|
|
#ifdef WITH_ZMQ
|
|
Global.zmq_address.clear();
|
|
#endif
|
|
// nor anything to the outside: no keyboard leds, LPT or PoKeys desk (feedbackmode), no messages to a
|
|
// multiplayer server (multiplayer, which also holds some events back for it), no program run at the end
|
|
Global.iFeedbackMode = 0;
|
|
#ifdef _WIN32
|
|
Console::ModeSet(Global.iFeedbackMode, Global.iFeedbackPort);
|
|
#endif
|
|
Global.iMultiplayer = 0;
|
|
Global.exec_on_exit.clear();
|
|
// and the same way every time, unless given another seed (-seed, or randomseed in the settings)
|
|
if (!Global.random_seed)
|
|
Global.random_seed = seed_of("test");
|
|
// the real time limit, which the scenery may set too
|
|
test().watch_wall_clock(wall_clock_limit(Global.test.wall_timeout, Global.test.timeout));
|
|
}
|
|
|
|
void test_manager::init_result_cell() const
|
|
{
|
|
auto cell { std::make_unique<TMemCell>(scene::node_data{0, -1, std::string(result_cell), "memcell"}) };
|
|
// neither of the reported values, so that a cell nobody wrote to says nothing
|
|
cell->UpdateValues("", -1.0, 0.0, basic_event::flags::value1 | basic_event::flags::value2);
|
|
simulation::Region->insert(cell.get());
|
|
// the table owns its cells
|
|
simulation::Memory.insert(cell.release());
|
|
}
|
|
|
|
void test_manager::start()
|
|
{
|
|
if (m_started)
|
|
return;
|
|
m_started = true;
|
|
{
|
|
std::scoped_lock lock { m_lock };
|
|
m_progress = test_progress {};
|
|
}
|
|
if (simulation::Vehicles.sequence().empty())
|
|
{
|
|
// most likely the scenery wasn't found, or it isn't a test scenery
|
|
finish(test_result::error, "the scenery has no vehicles");
|
|
return;
|
|
}
|
|
for (auto const &name : Global.test.vehicles)
|
|
{
|
|
if (simulation::Vehicles.find(name) == nullptr)
|
|
{
|
|
finish(test_result::error, std::format("the scenery has no vehicle {} (test.vehicle)", name));
|
|
return;
|
|
}
|
|
}
|
|
// a pause set by the scenery or the settings would never be lifted, nobody is there to press the key
|
|
Global.iPause = 0;
|
|
auto tested { std::string("every vehicle") };
|
|
if (false == Global.test.vehicles.empty())
|
|
{
|
|
tested = "the consists of";
|
|
for (auto const &name : Global.test.vehicles)
|
|
tested += " " + name;
|
|
}
|
|
auto const walllimit { m_walllimit.load() };
|
|
WriteLog(std::format("test: started, testing {}, timeout {:.0f} s, real time limit {}, standstill {:.0f} s{}{}{}", tested, Global.test.timeout,
|
|
walllimit > 0.0 ? std::format("{:.0f} s", walllimit) : std::string("none"), Global.test.standstill,
|
|
Global.test.pass_on_standstill ? ", standstill passes" : "",
|
|
Global.test.fail_if_stop_overran ? "" : ", signals passed at danger allowed",
|
|
Global.test.no_movement_before_pass ? "" : ", pass without waiting for a stop"));
|
|
}
|
|
|
|
void test_manager::update(double const Deltatime)
|
|
{
|
|
if (false == m_started || m_finished)
|
|
return;
|
|
|
|
test_frame frame { Deltatime, std::nullopt, {}, tested_trains_at_rest() };
|
|
if (auto const *cell = simulation::Memory.find(std::string(result_cell)))
|
|
{
|
|
frame.reported = cell->Value1();
|
|
frame.reason = cell->Text();
|
|
}
|
|
|
|
auto const limits { test_limits { Global.test.timeout, Global.test.standstill, Global.test.pass_on_standstill, Global.test.no_movement_before_pass } };
|
|
std::optional<test_verdict> verdict;
|
|
auto passrequested { false };
|
|
{
|
|
std::scoped_lock lock { m_lock };
|
|
auto const requestedbefore { m_progress.passrequested };
|
|
verdict = evaluate_frame(m_progress, frame, limits);
|
|
passrequested = m_progress.passrequested && false == requestedbefore;
|
|
}
|
|
if (verdict.has_value())
|
|
{
|
|
finish(verdict->result, verdict->reason);
|
|
return;
|
|
}
|
|
if (passrequested)
|
|
{
|
|
WriteLog(std::format("test: pass requested at {:.1f} s{}, waiting for the tested trains to stop", m_progress.time,
|
|
frame.reason.empty() ? std::string() : std::format(" ({})", frame.reason)));
|
|
}
|
|
}
|
|
|
|
bool test_manager::tested_trains_at_rest() const
|
|
{
|
|
if (Global.test.vehicles.empty())
|
|
return std::ranges::none_of(simulation::Vehicles.sequence(), is_moving);
|
|
// the consists as they are now: a train the tested one couples to joins it, one it leaves behind doesn't
|
|
return std::ranges::none_of(Global.test.vehicles, [](std::string const &Name) {
|
|
auto *vehicle { simulation::Vehicles.find(Name) };
|
|
return vehicle != nullptr && vehicle->find_vehicle(coupling::coupler, is_moving) != nullptr;
|
|
});
|
|
}
|
|
|
|
void test_manager::signal_passed_at_danger(std::string_view const Vehicle, std::string_view const Signal)
|
|
{
|
|
auto const reason { std::format("{} passed signal {} at danger", Vehicle, Signal) };
|
|
if (false == Global.test.enabled)
|
|
{
|
|
WriteLog(reason, logtype::generic);
|
|
return;
|
|
}
|
|
if (false == Global.test.fail_if_stop_overran)
|
|
{
|
|
WriteLog(std::format("test: {} at {:.1f} s, allowed by test.fail_if_stop_overran", reason, m_progress.time));
|
|
return;
|
|
}
|
|
finish(test_result::signal_passed_at_danger, reason);
|
|
}
|
|
|
|
void test_manager::finish(test_result const Result, std::string_view const Reason)
|
|
{
|
|
if (conclude(Result, Reason))
|
|
Application.queue_quit(true);
|
|
}
|
|
|
|
bool test_manager::conclude(test_result const Result, std::string_view const Reason)
|
|
{
|
|
std::scoped_lock lock { m_lock };
|
|
if (m_finished || false == Global.test.enabled)
|
|
return false;
|
|
m_result = Result;
|
|
m_finished = true;
|
|
|
|
auto const line { std::format("test: {} (exit code {}) after {:.1f} s of simulation time: {}", to_string(Result), static_cast<int>(Result), m_progress.time, Reason) };
|
|
if (Result == test_result::pass)
|
|
WriteLog(line);
|
|
else
|
|
ErrorLog(line);
|
|
// the process has no console of its own; whoever started it with a redirected output gets the verdict there too
|
|
std::fprintf(stdout, "%s\n", line.c_str());
|
|
std::fflush(stdout);
|
|
return true;
|
|
}
|
|
|
|
int test_manager::exit_code() const
|
|
{
|
|
std::scoped_lock lock { m_lock };
|
|
return static_cast<int>(m_finished ? m_result : test_result::error);
|
|
}
|
|
|
|
void test_manager::watch_wall_clock(double const Limit)
|
|
{
|
|
m_walllimit = Limit;
|
|
if (Limit <= 0.0 || m_watchdog.joinable())
|
|
return;
|
|
m_watchdog = std::jthread([this](std::stop_token const &Stop) {
|
|
while (false == Stop.stop_requested())
|
|
{
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(100));
|
|
check_wall_clock(elapsed_wall_time());
|
|
}
|
|
});
|
|
}
|
|
|
|
void test_manager::check_wall_clock(double const Elapsed)
|
|
{
|
|
auto const limit { m_walllimit.load() };
|
|
if (limit <= 0.0 || Elapsed < limit)
|
|
return;
|
|
// the run hangs, or is too slow: it ends here, whatever the main thread is doing. a run whose test has ended
|
|
// but which doesn't close ends with its result
|
|
if (false == conclude(test_result::timeout, std::format("still running after {:.0f} s of real time (test.wall_timeout)", limit)))
|
|
ErrorLog(std::format("test: the simulator was still running {:.0f} s of real time after the start, ended", limit));
|
|
// what was logged last gets written, unless the log is held up by a hung thread
|
|
PhysicsLogs.flush();
|
|
StopLogService();
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(250));
|
|
std::_Exit(exit_code());
|
|
}
|
|
|
|
} // namespace simulation
|