talezero/integration
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
5db04b3abc69e4dd36b575ed79b69e7f1baf99fa
integration/luprex/cpp/core/drivenengine.cpp

1000 lines
30 KiB
C++
Raw Blame History

#include "wrap-string.hpp"
#include "wrap-vector.hpp"
#include "util.hpp"
#include "drivenengine.hpp"
#include "world.hpp"
#include <string_view>
#include <utility>
#include <cstring>
#include <cstdio>
#include <fstream>
#include <cassert>
DrivenEngineReg *DrivenEngineReg::All;
DrivenEngineReg::DrivenEngineReg(const char *n, DrivenEngineMaker fn) {
name = n;
maker = fn;
next = All;
All = this;
}
DrivenEngineInitializer DrivenEngineInitializerReg::func;
DrivenEngineInitializerReg::DrivenEngineInitializerReg(DrivenEngineInitializer fn) {
assert(func == nullptr);
func = fn;
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// DrivenEngine private methods
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
int DrivenEngine::find_unused_chid() {
// Note: channel ID zero is special, it is never reused.
for (int i = 0; i < DRV_MAX_CHAN; i++) {
int id = next_unused_chid_++;
if (next_unused_chid_ == DRV_MAX_CHAN) next_unused_chid_ = 1;
if (channels_[id] == nullptr) return id;
}
assert(false);
return 0;
}
Channel *DrivenEngine::get_chid(int chid) const {
assert(unsigned(chid) < DRV_MAX_CHAN);
assert(channels_[chid].get() != nullptr);
return channels_[chid].get();
}
static DrivenEngine *make_engine(std::string_view kind) {
for (auto reg = DrivenEngineReg::All; reg != nullptr; reg=reg->next) {
if (kind == reg->name) {
UniqueDrivenEngine result = reg->maker();
return result.release();
}
}
return nullptr;
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// Class Channel
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
Channel::Channel(DrivenEngine *de, int chid, int port, const eng::string &target, bool stop) {
chid_ = chid;
port_ = port;
closed_ = false;
target_ = target;
stop_driver_ = stop;
sb_in_ = eng::make_shared<StreamBuffer>();
sb_out_ = eng::make_shared<StreamBuffer>();
}
std::string_view Channel::peek_outgoing() const {
return sb_out_->view();
}
void Channel::sent_outgoing(int nbytes) {
sb_out_->read_bytes(nbytes);
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// DrivenEngine Client-Side API
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void DrivenEngine::listen_port(int port) {
assert(listen_ports_.size() < DRV_MAX_LISTEN_PORTS);
listen_ports_.push_back(port);
}
double DrivenEngine::get_clock() {
return clock_;
}
SharedChannel DrivenEngine::new_outgoing_channel(const eng::string &target) {
int chid = find_unused_chid();
new_outgoing_.push_back(chid);
SharedChannel result = eng::make_shared<Channel>(this, chid, 0, target, stop_driver_);
channels_[chid] = result;
return result;
}
SharedChannel DrivenEngine::new_incoming_channel() {
if (accepted_channels_.empty()) {
return nullptr;
} else {
SharedChannel result = std::move(accepted_channels_.back());
accepted_channels_.pop_back();
return result;
}
}
SharedChannel DrivenEngine::get_stdio_channel() {
return stdio_channel_;
}
void DrivenEngine::set_console_prompt(const eng::string &prompt) {
console_prompt_ = prompt;
}
util::LuaSourcePtr DrivenEngine::get_lua_source() {
return std::move(lua_source_);
}
void DrivenEngine::rescan_lua_source() {
rescan_lua_source_ = true;
}
void DrivenEngine::set_visible_world_and_actor(World *w, int64_t id) {
visible_world_ = w;
visible_actor_id_ = id;
}
void DrivenEngine::stop_driver() {
stop_driver_ = true;
for (int i = 0; i < DRV_MAX_CHAN; i++) {
if (channels_[i] != nullptr) {
channels_[i]->stop_driver_ = true;
}
}
}
DrivenEngine::DrivenEngine() {
next_unused_chid_ = 1;
stdio_channel_ = eng::make_shared<Channel>(this, 0, 0, "", false);
channels_[0] = stdio_channel_;
rescan_lua_source_ = false;
clock_ = 0.0;
stop_driver_ = false;
}
DrivenEngine::~DrivenEngine() {}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// LOGFILE EVENT IDS.
//
// There's one event ID for each mutator, plus one for 'release'.
//
// There are no event IDs for getters, these aren't considered loggable events.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
enum DrvAction {
PLAY_INITIALIZE,
PLAY_CLEAR_NEW_OUTGOING,
PLAY_SENT_OUTGOING,
PLAY_RECV_INCOMING,
PLAY_NOTIFY_CLOSE,
PLAY_NOTIFY_ACCEPT,
PLAY_INVOKE_EVENT_UPDATE,
PLAY_SET_LUA_SOURCE,
PLAY_RELEASE,
};
inline static const char *action_string(DrvAction act) {
switch(act) {
case PLAY_INITIALIZE: return "PLAY_INITIALIZE";
case PLAY_CLEAR_NEW_OUTGOING: return "PLAY_CLEAR_NEW_OUTGOING";
case PLAY_SENT_OUTGOING: return "PLAY_SENT_OUTGOING";
case PLAY_RECV_INCOMING: return "PLAY_RECV_INCOMING";
case PLAY_NOTIFY_CLOSE: return "PLAY_NOTIFY_CLOSE";
case PLAY_NOTIFY_ACCEPT: return "PLAY_NOTIFY_ACCEPT";
case PLAY_INVOKE_EVENT_UPDATE: return "PLAY_INVOKE_EVENT_UPDATE";
case PLAY_SET_LUA_SOURCE: return "PLAY_SET_LUA_SOURCE";
case PLAY_RELEASE: return "PLAY_RELEASE";
default: return "unknown";
}
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// RLOG and WLOG, functions to read and write binary data to logfiles.
//
// After doing an rlog operation, you should check the stream
// for "good" to find out if there was any error.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
class PlayLogfile : public std::ofstream { using std::ofstream::ofstream; };
class ReplayLogfile : public std::ifstream { using std::ifstream::ifstream; };
static uint8_t rlog_uint8(EngineWrapper *w) {
uint8_t result;
w->rlog->read((char *)&result, 1);
if (!w->rlog->good()) return 0;
return result;
}
static uint32_t rlog_uint32(EngineWrapper *w) {
uint32_t result;
w->rlog->read((char *)&result, 4);
if (!w->rlog->good()) return 0;
return result;
}
static uint64_t rlog_uint64(EngineWrapper *w) {
uint64_t result;
w->rlog->read((char *)&result, 8);
if (!w->rlog->good()) return 0;
return result;
}
static double rlog_double(EngineWrapper *w) {
double result;
w->rlog->read((char *)&result, 8);
if (!w->rlog->good()) return 0.0;
return result;
}
std::string_view rlog_short_string(EngineWrapper *w) {
uint32_t len = rlog_uint8(w);
if (len == 255) {
len = rlog_uint32(w);
}
assert (len <= DRV_SHORTSTRING_SIZE);
if (len > 0) w->rlog->read(w->databuffer, len);
if (!w->rlog->good()) return std::string_view();
return std::string_view(w->databuffer, len);
}
std::string rlog_string(EngineWrapper *w) {
uint32_t len = rlog_uint8(w);
if (len == 255) {
len = rlog_uint32(w);
}
std::string result(len, ' ');
if (len > 0) w->rlog->read(&result[0], len);
if (!w->rlog->good()) return "";
return result;
}
static void wlog_uint8(EngineWrapper *w, uint8_t v) {
w->wlog->put((char)v);
}
static void wlog_uint32(EngineWrapper *w, uint32_t v) {
w->wlog->write((const char *)&v, 4);
}
static void wlog_uint64(EngineWrapper *w, uint64_t v) {
w->wlog->write((const char *)&v, 8);
}
static void wlog_double(EngineWrapper *w, double v) {
w->wlog->write((const char *)&v, 8);
}
static void wlog_short_string(EngineWrapper *w, std::string_view v) {
assert (v.size() <= DRV_SHORTSTRING_SIZE);
if (v.size() >= 255) {
wlog_uint8(w, 0xFF);
wlog_uint32(w, v.size());
} else {
wlog_uint8(w, v.size());
}
w->wlog->write(v.data(), v.size());
}
static void wlog_string(EngineWrapper *w, std::string_view v) {
if (v.size() >= 255) {
wlog_uint8(w, 0xFF);
wlog_uint32(w, v.size());
} else {
wlog_uint8(w, v.size());
}
w->wlog->write(v.data(), v.size());
}
static void wlog_cmd_hash(EngineWrapper *w, DrvAction act, uint32_t hash) {
wlog_uint8(w, act);
wlog_uint32(w, hash);
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// reset_wrapper
//
// Shut down a EngineWrapper, store an optional error message.
//
// release
//
// Shut down an EngineWrapper cleanly, with no error message, and
// log the step if the logfile is open.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
static void reset_wrapper(EngineWrapper *w, const char *format, ...) {
va_list argp;
va_start(argp, format);
memset(w->error, 0, DRV_ERRMSG_SIZE);
vsnprintf(w->error, DRV_ERRMSG_SIZE, format, argp);
w->error[DRV_ERRMSG_SIZE - 1] = 0;
if (w->wlog != nullptr) {
w->wlog->close();
delete w->wlog;
w->wlog = nullptr;
}
if (w->rlog != nullptr) {
w->rlog->close();
delete w->rlog;
w->rlog = nullptr;
}
if (w->engine != nullptr) {
delete w->engine;
w->engine = nullptr;
}
}
static void release(EngineWrapper *w) {
if (w->wlog != nullptr) {
wlog_cmd_hash(w, PLAY_RELEASE, eng::memhash());
}
reset_wrapper(w, "");
};
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// DRIVER Methods: Getters
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void DrivenEngine::drv_get_listen_ports(uint32_t *nports, const uint32_t **ports) const {
*nports = listen_ports_.size();
*ports = &listen_ports_[0];
}
void DrivenEngine::drv_get_new_outgoing(uint32_t *nchids, const uint32_t **chids) const {
*nchids = new_outgoing_.size();
*chids = &new_outgoing_[0];
}
const char *DrivenEngine::drv_get_target(uint32_t chid) const {
return get_chid(chid)->target_.c_str();
}
bool DrivenEngine::drv_get_channel_released(uint32_t chid) const {
return channels_[chid].use_count() == 1;
}
void DrivenEngine::drv_get_outgoing(uint32_t chid, uint32_t *len, const char **data) const {
std::string_view v = get_chid(chid)->peek_outgoing();
*len = v.size();
*data = v.data();
}
bool DrivenEngine::drv_get_outgoing_empty(uint32_t chid) const {
std::string_view v = get_chid(chid)->peek_outgoing();
return (v.size() == 0);
}
void DrivenEngine::drv_get_console_prompt(uint32_t *len, const char **data) const {
*len = console_prompt_.size();
*data = console_prompt_.c_str();
}
double DrivenEngine::drv_get_clock() const {
return clock_;
}
bool DrivenEngine::drv_get_rescan_lua_source() const {
return rescan_lua_source_;
}
bool DrivenEngine::drv_get_stop_driver() const {
return stop_driver_;
}
uint64_t DrivenEngine::drv_get_actor_id() const {
return visible_actor_id_;
}
void DrivenEngine::drv_get_tangibles_near(uint64_t tanid, double rx, double ry, double rz, uint32_t *count, int64_t **ids) {
uint32_t hash1 = eng::memhash();
scan_result_.clear();
if ((visible_world_ != 0) && (tanid != 0)) {
PlaneScan scan;
scan.set_near(tanid, true);
scan.set_omit_nowhere(true);
scan.set_sorted(false);
scan.set_radius(util::XYZ(rx, ry, rz));
scan.set_shape(PlaneScan::CYLINDER);
visible_world_->get_near(scan, &scan_result_);
}
*count = scan_result_.size();
if (*count > 0) {
*ids = &scan_result_[0];
} else {
*ids = nullptr;
}
uint32_t hash2 = eng::memhash();
assert(hash1 == hash2);
}
void DrivenEngine::drv_get_animation_queue_hashes(uint32_t count, const int64_t *ids, uint64_t *hashes) {
if (visible_world_ == 0) {
for (int i = 0; i < int(count); i++) {
hashes[i] = 0;
}
} else {
visible_world_->get_animation_queue_hashes(count, ids, hashes);
}
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// DRIVER Methods: Mutators
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void DrivenEngine::drv_initialize(uint32_t srcpklen, const char *srcpk, int argc, char **argv) {
drv_set_lua_source(srcpklen, srcpk);
event_init(argc, argv);
}
void DrivenEngine::drv_clear_new_outgoing() {
new_outgoing_.clear();
}
void DrivenEngine::drv_sent_outgoing(uint32_t chid, uint32_t nbytes) {
return get_chid(chid)->sent_outgoing(nbytes);
}
void DrivenEngine::drv_recv_incoming(uint32_t chid, uint32_t nbytes, const char *bytes) {
if (nbytes > 0) {
std::string_view sbytes(bytes, nbytes);
Channel *ch = get_chid(chid);
ch->sb_in_->write_bytes(sbytes);
}
}
void DrivenEngine::drv_notify_close(uint32_t chid, uint32_t len, const char *data) {
Channel *ch = get_chid(chid);
ch->closed_ = true;
ch->error_ = std::string(data, len);
channels_[chid].reset();
}
uint32_t DrivenEngine::drv_notify_accept(uint32_t port) {
int chid = find_unused_chid();
channels_[chid] = eng::make_shared<Channel>(this, chid, port, "", stop_driver_);
accepted_channels_.push_back(channels_[chid]);
return chid;
}
void DrivenEngine::drv_invoke_event_update(double clock) {
clock_ = clock;
event_update();
}
void DrivenEngine::drv_set_lua_source(uint32_t srcpklen, const char *srcpk) {
StreamBuffer sb(srcpk, srcpklen);
uint32_t nfiles = sb.read_uint32();
lua_source_.reset(new util::LuaSourceVec);
lua_source_->resize(nfiles);
for (uint32_t i = 0; i < nfiles; i++) {
(*lua_source_)[i].first = sb.read_string();
}
for (uint32_t i = 0; i < nfiles; i++) {
(*lua_source_)[i].second = sb.read_string();
}
rescan_lua_source_ = false;
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// C Wrappers: Getters
//
// These wrappers make it possible to call the drv_get routines using C
// functions instead of methods. This is important if the engine is compiled
// with one C++ compiler, but the driver is compiled with a different C++
// compiler.
//
// Some of these take parameter 'EngineWrapper', some take 'EngineWrapper',
// and some come in two versions. This all depends on whether they are used
// during play, during replay, or both.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
static void drv_get_listen_ports(EngineWrapper *w, uint32_t *nports, const uint32_t **ports) {
return w->engine->drv_get_listen_ports(nports, ports);
}
static void drv_get_new_outgoing(EngineWrapper *w, uint32_t *nchanids, const uint32_t **chanids) {
return w->engine->drv_get_new_outgoing(nchanids, chanids);
}
static const char *drv_get_target(EngineWrapper *w, uint32_t chid) {
return w->engine->drv_get_target(chid);
}
static bool drv_get_channel_released(EngineWrapper *w, uint32_t chid) {
return w->engine->drv_get_channel_released(chid);
}
static void drv_get_outgoing(EngineWrapper *w, uint32_t chid, uint32_t *len, const char **data) {
return w->engine->drv_get_outgoing(chid, len, data);
}
static bool drv_get_outgoing_empty(EngineWrapper *w, uint32_t chid) {
return w->engine->drv_get_outgoing_empty(chid);
}
static void drv_get_console_prompt(EngineWrapper *w, uint32_t *len, const char **data) {
return w->engine->drv_get_console_prompt(len, data);
}
static double drv_get_clock(EngineWrapper *w) {
return w->engine->drv_get_clock();
}
static bool drv_get_rescan_lua_source(EngineWrapper *w) {
return w->engine->drv_get_rescan_lua_source();
}
static bool drv_get_stop_driver(EngineWrapper *w) {
return w->engine->drv_get_stop_driver();
}
static uint64_t drv_get_actor_id(EngineWrapper *w) {
return w->engine->drv_get_actor_id();
}
static void drv_get_tangibles_near(EngineWrapper *w, uint64_t tanid, double rx, double ry, double rz, uint32_t *count, int64_t **ids) {
return w->engine->drv_get_tangibles_near(tanid, rx, ry, rz, count, ids);
}
static void drv_get_animation_queue_hashes(EngineWrapper *w, uint32_t count, const int64_t *ids, uint64_t *hashes) {
return w->engine->drv_get_animation_queue_hashes(count, ids, hashes);
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// C Wrappers: Mutators
//
// The wrapper for a mutator consists of two parts: the wrapper which is used at
// 'play' time, and the wrapper which is used at 'replay' time.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
static void play_initialize(EngineWrapper *w, uint32_t argc, char **argv, uint32_t srcpklen, const char *srcpk, const char *logfn) {
if (w->engine != nullptr) {
return reset_wrapper(w, "Cannot initialize wrapper, it's already initialized.");
}
// Clear the error message.
memset(w->error, 0, DRV_ERRMSG_SIZE);
// Open the logfile, if any is specified.
if ((logfn != nullptr) && (logfn[0] != 0)) {
w->wlog = new PlayLogfile(logfn, std::ios_base::out | std::ios_base::binary | std::ios_base::trunc);
if (!w->wlog->good()) {
return reset_wrapper(w, "Could not open replay log for writing: %s", logfn);
}
} else {
w->wlog = nullptr;
}
// If we have a logfile, then log this initialization.
if (w->wlog != nullptr) {
wlog_cmd_hash(w, PLAY_INITIALIZE, eng::memhash());
wlog_uint32(w, argc);
for (uint32_t i = 0; i < argc; i++) {
wlog_string(w, argv[i]);
}
wlog_string(w, std::string_view(srcpk, srcpklen));
w->wlog->flush();
}
// Create the engine of the appropriate type.
if (argc < 1) {
std::ostringstream oss;
oss << "Must pass an engine type on the command line. Known types:\n";
for (auto reg = DrivenEngineReg::All; reg != nullptr; reg=reg->next) {
oss << " " << reg->name << std::endl;
}
std::string err = oss.str();
return reset_wrapper(w, err.c_str());
}
w->engine = make_engine(argv[0]);
if (w->engine == nullptr) {
return reset_wrapper(w, "No such driven engine type: %s", argv[0]);
}
// Call the engine initialization sequence.
w->engine->drv_initialize(srcpklen, srcpk, argc - 1, argv + 1);
}
static void replay_initialize(EngineWrapper *w) {
assert(w->rlog != nullptr);
std::vector<std::string> argvstr;
uint32_t argc = rlog_uint32(w);
for (uint32_t i = 0; i < argc; i++) {
argvstr.push_back(rlog_string(w));
}
std::string srcpk = rlog_string(w);
if (!w->rlog->good()) {
return reset_wrapper(w, "replay log corrupt in replay_initialize");
}
// We need to convert the argument vector from an array
// of C++ strings into the canonical argc, argv format.
std::vector<char *> argvec;
for (uint32_t i = 0; i < argc; i++) {
argvec.push_back(&argvstr[i][0]);
}
char **argv = &argvec[0];
// Create the engine.
w->engine = make_engine(argv[0]);
if (w->engine == nullptr) {
return reset_wrapper(w, "No such driven engine type: %s", argvstr[0]);
}
w->engine->drv_initialize(srcpk.size(), srcpk.c_str(), argc - 1, argv + 1);
}
////////////////////////
static void play_clear_new_outgoing(EngineWrapper *w) {
assert(w->rlog == nullptr);
if (w->wlog != nullptr) {
wlog_cmd_hash(w, PLAY_CLEAR_NEW_OUTGOING, eng::memhash());
w->wlog->flush();
}
w->engine->drv_clear_new_outgoing();
}
static void replay_clear_new_outgoing(EngineWrapper *w) {
w->engine->drv_clear_new_outgoing();
}
////////////////////////
static void play_sent_outgoing(EngineWrapper *w, uint32_t chid, uint32_t nbytes) {
assert(w->rlog == nullptr);
if (w->wlog != nullptr) {
uint32_t ndata; const char *data;
w->engine->drv_get_outgoing(chid, &ndata, &data);
assert(nbytes <= ndata);
wlog_cmd_hash(w, PLAY_SENT_OUTGOING, eng::memhash());
wlog_uint32(w, chid);
wlog_uint32(w, nbytes);
wlog_uint64(w, SpookyHash::QkHash64(data, nbytes));
w->wlog->flush();
}
w->engine->drv_sent_outgoing(chid, nbytes);
}
static void replay_sent_outgoing(EngineWrapper *w) {
uint32_t chid = rlog_uint32(w);
uint32_t nbytes = rlog_uint32(w);
uint64_t hash = rlog_uint64(w);
if (!w->rlog->good()) {
return reset_wrapper(w, "replay log corrupt in replay_sent_outgoing");
}
uint32_t ndata; const char *data;
w->engine->drv_get_outgoing(chid, &ndata, &data);
if ((nbytes > ndata) || (hash != SpookyHash::QkHash64(data, nbytes))) {
return reset_wrapper(w, "nondeterministic in replay_sent_outgoing");
}
if (w->replay_cb_sent_outgoing != nullptr) {
w->replay_cb_sent_outgoing(w->replay_cb_vp, chid, ndata, data);
}
w->engine->drv_sent_outgoing(chid, nbytes);
}
////////////////////////
static void play_recv_incoming(EngineWrapper *w, uint32_t chid, uint32_t len, const char *data) {
assert(w->rlog == nullptr);
if (w->wlog != nullptr) {
wlog_cmd_hash(w, PLAY_RECV_INCOMING, eng::memhash());
wlog_uint32(w, chid);
wlog_short_string(w, std::string_view(data, len));
w->wlog->flush();
}
w->engine->drv_recv_incoming(chid, len, data);
}
static void replay_recv_incoming(EngineWrapper *w) {
uint32_t chid = rlog_uint32(w);
std::string_view data = rlog_short_string(w);
if (!w->rlog->good()) {
return reset_wrapper(w, "replay log corrupt in replay_recv_incoming");
}
w->engine->drv_recv_incoming(chid, data.size(), data.data());
}
////////////////////////
static void play_notify_close(EngineWrapper *w, uint32_t chid, uint32_t len, const char *data) {
assert(w->rlog == nullptr);
if (w->wlog != nullptr) {
wlog_cmd_hash(w, PLAY_NOTIFY_CLOSE, eng::memhash());
wlog_uint32(w, chid);
wlog_string(w, std::string_view(data, len));
w->wlog->flush();
}
w->engine->drv_notify_close(chid, len, data);
}
static void replay_notify_close(EngineWrapper *w) {
uint32_t chid = rlog_uint32(w);
std::string message = rlog_string(w);
if (!w->rlog->good()) {
return reset_wrapper(w, "replay log corrupt in replay_notify_close");
}
w->engine->drv_notify_close(chid, message.size(), message.c_str());
}
////////////////////////
static uint32_t play_notify_accept(EngineWrapper *w, uint32_t port) {
assert(w->rlog == nullptr);
if (w->wlog != nullptr) {
wlog_cmd_hash(w, PLAY_NOTIFY_ACCEPT, eng::memhash());
wlog_uint32(w, port);
w->wlog->flush();
}
return w->engine->drv_notify_accept(port);
}
static void replay_notify_accept(EngineWrapper *w) {
uint32_t port = rlog_uint32(w);
if (!w->rlog->good()) {
return reset_wrapper(w, "replay log corrupt in replay_notify_accept");
}
w->engine->drv_notify_accept(port);
}
////////////////////////
static void play_invoke_event_update(EngineWrapper *w, double clock) {
assert(w->rlog == nullptr);
if (w->wlog != nullptr) {
wlog_cmd_hash(w, PLAY_INVOKE_EVENT_UPDATE, eng::memhash());
wlog_double(w, clock);
w->wlog->flush();
}
w->engine->drv_invoke_event_update(clock);
}
static void replay_invoke_event_update(EngineWrapper *w) {
double clock = rlog_double(w);
if (!w->rlog->good()) {
return reset_wrapper(w, "replay log corrupt in replay_event_update");
}
w->engine->drv_invoke_event_update(clock);
}
////////////////////////
void play_set_lua_source(EngineWrapper *w, uint32_t srcpklen, const char *srcpk) {
assert(w->rlog == nullptr);
if (w->wlog != nullptr) {
wlog_cmd_hash(w, PLAY_SET_LUA_SOURCE, eng::memhash());
wlog_string(w, std::string_view(srcpk, srcpklen));
w->wlog->flush();
}
w->engine->drv_set_lua_source(srcpklen, srcpk);
}
void replay_set_lua_source(EngineWrapper *w) {
std::string srcpack = rlog_string(w);
if (!w->rlog->good()) {
return reset_wrapper(w, "replay log corrupt in replay_set_lua_source");
}
w->engine->drv_set_lua_source(srcpack.size(), srcpack.c_str());
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// Replay Core
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
static void replaycore_initialize(EngineWrapper *w, const char *logfn) {
if (w->engine != nullptr) {
return reset_wrapper(w, "Cannot initialize wrapper, it's already initialized.");
return;
}
// Clear the error message.
memset(w->error, 0, DRV_ERRMSG_SIZE);
// Open the logfile.
w->rlog = new ReplayLogfile(logfn, std::ios_base::in | std::ios_base::binary);
if (!w->rlog->good()) {
return reset_wrapper(w, "Could not open replay log for reading: %s", logfn);
}
// Read one step from the logfile, and make sure it's an initialize step.
uint8_t code = rlog_uint8(w);
int hash = rlog_uint32(w);
if (!w->rlog->good()) {
return reset_wrapper(w, "logfile corrupt in initial step");
}
if (hash != eng::memhash()) {
return reset_wrapper(w, "nondeterminism detected in initial step");
}
if (code != PLAY_INITIALIZE) {
return reset_wrapper(w, "replay log doesn't begin with initialize step");
}
// Replay the initialize step from the logfile.
// Doing this immediately, rather than waiting for the driver
// to call 'step', enforces the invariant that after calling
// initialize, there's an engine.
replay_initialize(w);
}
static void replaycore_step(EngineWrapper *w) {
if (w->rlog == nullptr) {
return;
}
uint8_t code = rlog_uint8(w);
if (w->rlog->eof()) {
return reset_wrapper(w, "logfile terminated abruptly");
}
int hash = rlog_uint32(w);
if (!w->rlog->good()) {
return reset_wrapper(w, "logfile corrupt in replay step");
}
if (hash != eng::memhash()) {
return reset_wrapper(w, "nondeterminism detected");
}
switch (code) {
case PLAY_CLEAR_NEW_OUTGOING: replay_clear_new_outgoing(w); return;
case PLAY_SENT_OUTGOING: replay_sent_outgoing(w); return;
case PLAY_RECV_INCOMING: replay_recv_incoming(w); return;
case PLAY_NOTIFY_CLOSE: replay_notify_close(w); return;
case PLAY_NOTIFY_ACCEPT: replay_notify_accept(w); return;
case PLAY_INVOKE_EVENT_UPDATE: replay_invoke_event_update(w); return;
case PLAY_SET_LUA_SOURCE: replay_set_lua_source(w); return;
case PLAY_RELEASE: release(w); return;
default: return reset_wrapper(w, "Replay log corrupt in command dispatcher");
}
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// Wrapper Initialization
//
// To access the engine across a DLL boundary, you first use
// GetProcAddress or dlsym to fetch the addresses of 'init_play_engine'
// and 'init_replay_engine'. Then, you use those two functions to
// initialize a EngineWrapper or a EngineWrapper, which contain the addresses
// of all the other functions you need. These are the only two functions
// marked 'DLLEXPORT', all other functions are exported from the DLL
// indirectly.
//
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
#if defined(__linux__)
#define DLLEXPORT __attribute__((visibility("default")))
#elif defined(_WIN32)
#define DLLEXPORT __declspec(dllexport)
#endif
static void init_engine_wrapper_helper(EngineWrapper *w) {
static bool called_initializer;
assert(DrivenEngineInitializerReg::func != nullptr);
if (!called_initializer) {
DrivenEngineInitializerReg::func();
called_initializer = true;
}
memset(w, 0, sizeof(EngineWrapper));
w->get_listen_ports = drv_get_listen_ports;
w->get_new_outgoing = drv_get_new_outgoing;
w->get_target = drv_get_target;
w->get_channel_released = drv_get_channel_released;
w->get_outgoing = drv_get_outgoing;
w->get_outgoing_empty = drv_get_outgoing_empty;
w->get_console_prompt = drv_get_console_prompt;
w->get_clock = drv_get_clock;
w->get_rescan_lua_source = drv_get_rescan_lua_source;
w->get_stop_driver = drv_get_stop_driver;
w->get_actor_id = drv_get_actor_id;
w->get_tangibles_near = drv_get_tangibles_near;
w->get_animation_queue_hashes = drv_get_animation_queue_hashes;
w->play_initialize = play_initialize;
w->play_clear_new_outgoing = play_clear_new_outgoing;
w->play_sent_outgoing = play_sent_outgoing;
w->play_recv_incoming = play_recv_incoming;
w->play_notify_close = play_notify_close;
w->play_notify_accept = play_notify_accept;
w->play_invoke_event_update = play_invoke_event_update;
w->play_set_lua_source = play_set_lua_source;
w->replay_initialize = replaycore_initialize;
w->replay_step = replaycore_step;
w->hook_dprint = util::hook_dprint;
w->release = release;
};
extern "C" {
DLLEXPORT void init_engine_wrapper(EngineWrapper *w) {
init_engine_wrapper_helper(w);
}
}
Reference in New Issue View Git Blame Copy Permalink