mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-19 22:44:59 +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.
252 lines
7.6 KiB
C++
252 lines
7.6 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/.
|
|
*/
|
|
/*
|
|
MaSzyna EU07 locomotive simulator
|
|
Copyright (C) 2001-2004 Marcin Wozniak, Maciej Czapkiewicz and others
|
|
*/
|
|
/*
|
|
Authors:
|
|
MarcinW, McZapkie, Shaxbee, ABu, nbmx, youBy, Ra, winger, mamut, Q424,
|
|
Stele, firleju, szociu, hunter, ZiomalCl, OLI_EU and others
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "application/application.h"
|
|
#include "simulation/simulationtest.h"
|
|
#include "utilities/Globals.h"
|
|
#include "utilities/Logs.h"
|
|
#include "utilities/physicslog.h"
|
|
#include <cstdlib>
|
|
#include <exception>
|
|
#include <string_view>
|
|
#include <thread>
|
|
#include <vector>
|
|
#ifdef _WIN32
|
|
#include <cstdio>
|
|
#else
|
|
#include <sys/resource.h>
|
|
#endif
|
|
#ifdef WITHDUMPGEN
|
|
#ifdef _WIN32
|
|
#include <Windows.h>
|
|
#include <DbgHelp.h>
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma comment(linker, "/subsystem:windows /ENTRY:mainCRTStartup")
|
|
#endif
|
|
|
|
void export_e3d_standalone(std::string in, std::string out, int flags, bool dynamic);
|
|
int export_btf_standalone(std::string in, std::string out);
|
|
int generate_nodebank_previews(int Argc, char *Argv[]);
|
|
|
|
#include <ctime>
|
|
#include <string>
|
|
#include <sstream>
|
|
#include <iomanip>
|
|
#include <utilities/Globals.h>
|
|
|
|
#ifdef _WIN32
|
|
#pragma comment(lib, "Dbghelp.lib")
|
|
|
|
LONG WINAPI CrashHandler(EXCEPTION_POINTERS *ExceptionInfo)
|
|
{
|
|
// Get current local time
|
|
SYSTEMTIME st;
|
|
GetLocalTime(&st);
|
|
|
|
// Format: crash_YYYY-MM-DD_HH-MM-SS.dmp
|
|
std::ostringstream oss;
|
|
oss << "crash_" << std::setw(4) << std::setfill('0') << st.wYear << "-" << std::setw(2) << std::setfill('0') << st.wMonth << "-" << std::setw(2) << std::setfill('0') << st.wDay << "_"
|
|
<< std::setw(2) << std::setfill('0') << st.wHour << "-" << std::setw(2) << std::setfill('0') << st.wMinute << "-" << std::setw(2) << std::setfill('0') << st.wSecond << ".dmp";
|
|
|
|
std::string filename = oss.str();
|
|
|
|
HANDLE hFile = CreateFileA(filename.c_str(), GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
{
|
|
MINIDUMP_EXCEPTION_INFORMATION dumpInfo;
|
|
dumpInfo.ThreadId = GetCurrentThreadId();
|
|
dumpInfo.ExceptionPointers = ExceptionInfo;
|
|
dumpInfo.ClientPointers = FALSE;
|
|
|
|
// Wybrana kombinacja flag
|
|
MINIDUMP_TYPE dumpType = MINIDUMP_TYPE(MiniDumpWithFullMemory | MiniDumpWithHandleData | MiniDumpWithThreadInfo | MiniDumpWithUnloadedModules | MiniDumpWithIndirectlyReferencedMemory |
|
|
MiniDumpWithFullMemoryInfo | MiniDumpWithTokenInformation);
|
|
|
|
// in test mode nobody is there to close the box, and the run would wait for it until killed
|
|
if (false == Global.test.enabled)
|
|
MessageBoxA(nullptr, "Simulator crash occured :(\n", "Simulator crashed :(", MB_ICONERROR);
|
|
MiniDumpWriteDump(GetCurrentProcess(), GetCurrentProcessId(), hFile, dumpType, &dumpInfo, nullptr, nullptr);
|
|
|
|
CloseHandle(hFile);
|
|
}
|
|
|
|
return EXCEPTION_EXECUTE_HANDLER;
|
|
}
|
|
|
|
#endif
|
|
|
|
namespace
|
|
{
|
|
|
|
// the log is written by a thread of its own, which the closing of the application stops and waits for. on the ways
|
|
// out that skip the closing (a failed start, an exception) what was logged last would be lost with the process
|
|
void finish_log()
|
|
{
|
|
StopLogService();
|
|
if (auto const logservice{Global.threads.find("LogService")};
|
|
logservice != Global.threads.end() && logservice->second.joinable() && logservice->second.get_id() != std::this_thread::get_id())
|
|
logservice->second.join();
|
|
}
|
|
|
|
// ends a test run with its verdict on the standard output and in the exit code. a test the simulator didn't end
|
|
// (a failed start, an exception) ends with the error and Reason
|
|
[[noreturn]] void end_test_run(std::string_view const Reason)
|
|
{
|
|
simulation::test().conclude(simulation::test_result::error, Reason);
|
|
// the last two seconds of the physics logs, which the runner of the tests reads
|
|
PhysicsLogs.stop();
|
|
finish_log();
|
|
fflush(stdout);
|
|
fflush(stderr);
|
|
// skip destructors, there are ordering errors which causes segfaults
|
|
std::_Exit(simulation::test().exit_code());
|
|
}
|
|
|
|
// a test run (--test): whatever stops it, it ends with its verdict. any other run never gets here and ends as
|
|
// it always has
|
|
[[noreturn]] void run_test(int argc, char *argv[])
|
|
{
|
|
// for what doesn't reach the catch below: an exception leaving a noexcept function, or on Linux one leaving
|
|
// a thread (on Windows the handler is the main thread's only)
|
|
std::set_terminate([] { end_test_run(simulation::describe_exception(std::current_exception())); });
|
|
try
|
|
{
|
|
if (Application.init(argc, argv) == 0)
|
|
{
|
|
Application.run();
|
|
Application.exit();
|
|
}
|
|
}
|
|
catch (...)
|
|
{
|
|
end_test_run(simulation::describe_exception(std::current_exception()));
|
|
}
|
|
end_test_run("the simulator stopped before the test ended");
|
|
}
|
|
|
|
// the physics logs used to keep a file open for every vehicle with a driver, and on a scenery with some five hundred
|
|
// of them they took all the files the C library of Windows lets a process have open by default (512): the files
|
|
// opened after them, the shaders of the map among them, couldn't be read. they keep none open now (physicslog.h),
|
|
// but the limit is raised to the most either system allows still, for whatever else opens many files at once
|
|
void raise_open_files_limit()
|
|
{
|
|
#ifdef _WIN32
|
|
_setmaxstdio(8192);
|
|
#else
|
|
rlimit limit{};
|
|
if (getrlimit(RLIMIT_NOFILE, &limit) == 0 && limit.rlim_cur < limit.rlim_max)
|
|
{
|
|
limit.rlim_cur = limit.rlim_max;
|
|
setrlimit(RLIMIT_NOFILE, &limit);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
} // namespace
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
raise_open_files_limit();
|
|
#ifdef WITHDUMPGEN
|
|
#ifdef _WIN32
|
|
SetUnhandledExceptionFilter(CrashHandler);
|
|
#endif
|
|
#endif
|
|
// init start timestamp
|
|
Global.startTimestamp = std::chrono::steady_clock::now();
|
|
|
|
// quick short-circuit for standalone e3d export
|
|
if (argc == 6 && std::string(argv[1]) == "-e3d")
|
|
{
|
|
std::string in(argv[2]);
|
|
std::string out(argv[3]);
|
|
int flags = std::stoi(std::string(argv[4]));
|
|
int dynamic = std::stoi(std::string(argv[5]));
|
|
export_e3d_standalone(in, out, flags, dynamic);
|
|
}
|
|
// standalone generation of preview images of the node bank models: -generate-nodebank-previews [options]
|
|
else if (argc >= 2 && std::string(argv[1]) == "-generate-nodebank-previews")
|
|
{
|
|
auto const result{generate_nodebank_previews(argc, argv)};
|
|
fflush(stdout);
|
|
fflush(stderr);
|
|
std::_Exit(result);
|
|
}
|
|
// standalone conversion of text terrain file to binary format: -btf -s <text file> [-o <binary file>]
|
|
else if (argc >= 4 && std::string(argv[1]) == "-btf")
|
|
{
|
|
std::string in;
|
|
std::string out;
|
|
for (int i = 2; i + 1 < argc; i += 2)
|
|
{
|
|
std::string const option(argv[i]);
|
|
if (option == "-s")
|
|
{
|
|
in = argv[i + 1];
|
|
}
|
|
else if (option == "-o")
|
|
{
|
|
out = argv[i + 1];
|
|
}
|
|
}
|
|
auto const result{export_btf_standalone(in, out)};
|
|
fflush(stdout);
|
|
fflush(stderr);
|
|
std::_Exit(result);
|
|
}
|
|
// unattended test run of a scenery, which says its result in the exit code (eu07/maszyna#541)
|
|
else if (simulation::parse_test_command_line(std::vector<char const *>(argv, argv + argc)).enabled)
|
|
{
|
|
run_test(argc, argv);
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
auto result{Application.init(argc, argv)};
|
|
if (result == 0)
|
|
{
|
|
result = Application.run();
|
|
Application.exit();
|
|
}
|
|
}
|
|
catch (std::bad_alloc const &Error)
|
|
{
|
|
ErrorLog("Critical error, memory allocation failure: " + std::string(Error.what()));
|
|
}
|
|
#ifdef _WIN32
|
|
catch (std::runtime_error const &Error)
|
|
{
|
|
std::string msg = "Simulator crash occured :(\n";
|
|
msg += Error.what();
|
|
MessageBoxA(nullptr, msg.c_str(), "Simulator crashed :(", MB_ICONERROR);
|
|
}
|
|
#endif
|
|
}
|
|
#ifndef _WIN32
|
|
fflush(stdout);
|
|
fflush(stderr);
|
|
#endif
|
|
std::_Exit(0); // skip destructors, there are ordering errors which causes segfaults
|
|
}
|