2014-04-15 19:41:07 +02:00
|
|
|
/*
|
|
|
|
Minetest
|
|
|
|
Copyright (C) 2013 sapier, <sapier AT gmx DOT net>
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU Lesser General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU Lesser General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
|
|
|
with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
extern "C" {
|
|
|
|
#include "lua.h"
|
|
|
|
#include "lauxlib.h"
|
|
|
|
#include "lualib.h"
|
|
|
|
}
|
|
|
|
|
2014-04-27 23:55:49 +02:00
|
|
|
#include "server.h"
|
2014-04-15 19:41:07 +02:00
|
|
|
#include "s_async.h"
|
|
|
|
#include "log.h"
|
|
|
|
#include "filesys.h"
|
|
|
|
#include "porting.h"
|
|
|
|
#include "common/c_internal.h"
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
AsyncEngine::AsyncEngine() :
|
2014-04-15 21:10:30 +02:00
|
|
|
initDone(false),
|
|
|
|
jobIdCounter(0)
|
2014-04-15 19:41:07 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
AsyncEngine::~AsyncEngine()
|
|
|
|
{
|
2014-04-15 21:10:30 +02:00
|
|
|
|
|
|
|
// Request all threads to stop
|
|
|
|
for (std::vector<AsyncWorkerThread *>::iterator it = workerThreads.begin();
|
|
|
|
it != workerThreads.end(); it++) {
|
2015-04-07 12:13:12 +02:00
|
|
|
(*it)->stop();
|
2014-04-15 21:10:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Wake up all threads
|
|
|
|
for (std::vector<AsyncWorkerThread *>::iterator it = workerThreads.begin();
|
|
|
|
it != workerThreads.end(); it++) {
|
2015-04-07 12:13:12 +02:00
|
|
|
jobQueueCounter.post();
|
2014-04-15 21:10:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Wait for threads to finish
|
|
|
|
for (std::vector<AsyncWorkerThread *>::iterator it = workerThreads.begin();
|
|
|
|
it != workerThreads.end(); it++) {
|
2015-04-07 12:13:12 +02:00
|
|
|
(*it)->wait();
|
2014-04-15 21:10:30 +02:00
|
|
|
}
|
|
|
|
|
2014-04-15 19:41:07 +02:00
|
|
|
// Force kill all threads
|
2014-04-15 21:10:30 +02:00
|
|
|
for (std::vector<AsyncWorkerThread *>::iterator it = workerThreads.begin();
|
|
|
|
it != workerThreads.end(); it++) {
|
|
|
|
delete *it;
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
2015-04-07 12:13:12 +02:00
|
|
|
jobQueueMutex.lock();
|
2014-04-15 21:10:30 +02:00
|
|
|
jobQueue.clear();
|
2015-04-07 12:13:12 +02:00
|
|
|
jobQueueMutex.unlock();
|
2014-04-15 21:10:30 +02:00
|
|
|
workerThreads.clear();
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
bool AsyncEngine::registerFunction(const char* name, lua_CFunction func)
|
|
|
|
{
|
2014-04-15 21:10:30 +02:00
|
|
|
if (initDone) {
|
2014-04-15 19:41:07 +02:00
|
|
|
return false;
|
|
|
|
}
|
2016-10-06 19:20:12 +02:00
|
|
|
|
2014-04-15 21:10:30 +02:00
|
|
|
functionList[name] = func;
|
2014-04-15 19:41:07 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2014-04-15 21:10:30 +02:00
|
|
|
void AsyncEngine::initialize(unsigned int numEngines)
|
2014-04-15 19:41:07 +02:00
|
|
|
{
|
2014-04-15 21:10:30 +02:00
|
|
|
initDone = true;
|
2014-04-15 19:41:07 +02:00
|
|
|
|
|
|
|
for (unsigned int i = 0; i < numEngines; i++) {
|
2015-04-07 12:13:12 +02:00
|
|
|
AsyncWorkerThread *toAdd = new AsyncWorkerThread(this,
|
|
|
|
std::string("AsyncWorker-") + itos(i));
|
2014-04-15 21:10:30 +02:00
|
|
|
workerThreads.push_back(toAdd);
|
2015-04-07 12:13:12 +02:00
|
|
|
toAdd->start();
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2017-04-20 00:12:52 +02:00
|
|
|
unsigned int AsyncEngine::queueAsyncJob(const std::string &func,
|
|
|
|
const std::string ¶ms)
|
2014-04-15 19:41:07 +02:00
|
|
|
{
|
2015-04-07 12:13:12 +02:00
|
|
|
jobQueueMutex.lock();
|
2014-04-15 21:10:30 +02:00
|
|
|
LuaJobInfo toAdd;
|
|
|
|
toAdd.id = jobIdCounter++;
|
|
|
|
toAdd.serializedFunction = func;
|
|
|
|
toAdd.serializedParams = params;
|
2014-04-15 19:41:07 +02:00
|
|
|
|
2014-04-15 21:10:30 +02:00
|
|
|
jobQueue.push_back(toAdd);
|
2014-04-15 19:41:07 +02:00
|
|
|
|
2015-04-07 12:13:12 +02:00
|
|
|
jobQueueCounter.post();
|
2014-04-15 19:41:07 +02:00
|
|
|
|
2015-04-07 12:13:12 +02:00
|
|
|
jobQueueMutex.unlock();
|
2014-04-15 19:41:07 +02:00
|
|
|
|
2014-04-15 21:10:30 +02:00
|
|
|
return toAdd.id;
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
LuaJobInfo AsyncEngine::getJob()
|
|
|
|
{
|
2015-04-07 12:13:12 +02:00
|
|
|
jobQueueCounter.wait();
|
|
|
|
jobQueueMutex.lock();
|
2014-04-15 19:41:07 +02:00
|
|
|
|
|
|
|
LuaJobInfo retval;
|
|
|
|
|
2014-04-15 21:10:30 +02:00
|
|
|
if (!jobQueue.empty()) {
|
|
|
|
retval = jobQueue.front();
|
|
|
|
jobQueue.pop_front();
|
2014-04-15 19:41:07 +02:00
|
|
|
retval.valid = true;
|
|
|
|
}
|
2015-04-07 12:13:12 +02:00
|
|
|
jobQueueMutex.unlock();
|
2014-04-15 19:41:07 +02:00
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2017-04-20 00:12:52 +02:00
|
|
|
void AsyncEngine::putJobResult(const LuaJobInfo &result)
|
2014-04-15 19:41:07 +02:00
|
|
|
{
|
2015-04-07 12:13:12 +02:00
|
|
|
resultQueueMutex.lock();
|
2014-04-15 21:10:30 +02:00
|
|
|
resultQueue.push_back(result);
|
2015-04-07 12:13:12 +02:00
|
|
|
resultQueueMutex.unlock();
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2015-08-25 07:44:53 +02:00
|
|
|
void AsyncEngine::step(lua_State *L)
|
2014-04-15 19:41:07 +02:00
|
|
|
{
|
2015-08-25 07:44:53 +02:00
|
|
|
int error_handler = PUSH_ERROR_HANDLER(L);
|
2014-04-28 03:02:48 +02:00
|
|
|
lua_getglobal(L, "core");
|
2015-04-07 12:13:12 +02:00
|
|
|
resultQueueMutex.lock();
|
2014-04-15 21:10:30 +02:00
|
|
|
while (!resultQueue.empty()) {
|
|
|
|
LuaJobInfo jobDone = resultQueue.front();
|
|
|
|
resultQueue.pop_front();
|
2014-04-15 19:41:07 +02:00
|
|
|
|
|
|
|
lua_getfield(L, -1, "async_event_handler");
|
|
|
|
|
|
|
|
if (lua_isnil(L, -1)) {
|
2015-03-06 11:21:51 +01:00
|
|
|
FATAL_ERROR("Async event handler does not exist!");
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
luaL_checktype(L, -1, LUA_TFUNCTION);
|
|
|
|
|
2014-04-15 21:10:30 +02:00
|
|
|
lua_pushinteger(L, jobDone.id);
|
|
|
|
lua_pushlstring(L, jobDone.serializedResult.data(),
|
|
|
|
jobDone.serializedResult.size());
|
2014-04-15 19:41:07 +02:00
|
|
|
|
2015-08-25 07:44:53 +02:00
|
|
|
PCALL_RESL(L, lua_pcall(L, 2, 0, error_handler));
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
2015-04-07 12:13:12 +02:00
|
|
|
resultQueueMutex.unlock();
|
2015-08-25 07:44:53 +02:00
|
|
|
lua_pop(L, 2); // Pop core and error handler
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2014-04-15 21:10:30 +02:00
|
|
|
void AsyncEngine::pushFinishedJobs(lua_State* L) {
|
2014-04-15 19:41:07 +02:00
|
|
|
// Result Table
|
2015-04-07 12:13:12 +02:00
|
|
|
MutexAutoLock l(resultQueueMutex);
|
2014-04-15 19:41:07 +02:00
|
|
|
|
|
|
|
unsigned int index = 1;
|
2014-04-15 21:10:30 +02:00
|
|
|
lua_createtable(L, resultQueue.size(), 0);
|
2014-04-15 19:41:07 +02:00
|
|
|
int top = lua_gettop(L);
|
|
|
|
|
2014-04-15 21:10:30 +02:00
|
|
|
while (!resultQueue.empty()) {
|
|
|
|
LuaJobInfo jobDone = resultQueue.front();
|
|
|
|
resultQueue.pop_front();
|
2014-04-15 19:41:07 +02:00
|
|
|
|
2014-04-15 21:10:30 +02:00
|
|
|
lua_createtable(L, 0, 2); // Pre-allocate space for two map fields
|
2014-04-15 19:41:07 +02:00
|
|
|
int top_lvl2 = lua_gettop(L);
|
|
|
|
|
|
|
|
lua_pushstring(L, "jobid");
|
2014-04-15 21:10:30 +02:00
|
|
|
lua_pushnumber(L, jobDone.id);
|
2014-04-15 19:41:07 +02:00
|
|
|
lua_settable(L, top_lvl2);
|
|
|
|
|
|
|
|
lua_pushstring(L, "retval");
|
2014-04-15 21:10:30 +02:00
|
|
|
lua_pushlstring(L, jobDone.serializedResult.data(),
|
|
|
|
jobDone.serializedResult.size());
|
2014-04-15 19:41:07 +02:00
|
|
|
lua_settable(L, top_lvl2);
|
|
|
|
|
|
|
|
lua_rawseti(L, top, index++);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2014-04-15 21:10:30 +02:00
|
|
|
void AsyncEngine::prepareEnvironment(lua_State* L, int top)
|
|
|
|
{
|
2016-10-06 19:20:12 +02:00
|
|
|
for (UNORDERED_MAP<std::string, lua_CFunction>::iterator it = functionList.begin();
|
2014-04-15 21:10:30 +02:00
|
|
|
it != functionList.end(); it++) {
|
2014-04-15 19:41:07 +02:00
|
|
|
lua_pushstring(L, it->first.c_str());
|
|
|
|
lua_pushcfunction(L, it->second);
|
|
|
|
lua_settable(L, top);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
AsyncWorkerThread::AsyncWorkerThread(AsyncEngine* jobDispatcher,
|
2015-04-07 12:13:12 +02:00
|
|
|
const std::string &name) :
|
|
|
|
Thread(name),
|
2014-04-15 19:41:07 +02:00
|
|
|
ScriptApiBase(),
|
2015-04-07 12:13:12 +02:00
|
|
|
jobDispatcher(jobDispatcher)
|
2014-04-15 19:41:07 +02:00
|
|
|
{
|
|
|
|
lua_State *L = getStack();
|
|
|
|
|
|
|
|
// Prepare job lua environment
|
2014-04-28 03:02:48 +02:00
|
|
|
lua_getglobal(L, "core");
|
2014-04-15 19:41:07 +02:00
|
|
|
int top = lua_gettop(L);
|
|
|
|
|
2014-04-27 23:55:49 +02:00
|
|
|
// Push builtin initialization type
|
|
|
|
lua_pushstring(L, "async");
|
|
|
|
lua_setglobal(L, "INIT");
|
2014-04-15 19:41:07 +02:00
|
|
|
|
2014-04-15 21:10:30 +02:00
|
|
|
jobDispatcher->prepareEnvironment(L, top);
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
|
|
|
AsyncWorkerThread::~AsyncWorkerThread()
|
|
|
|
{
|
2015-04-07 12:13:12 +02:00
|
|
|
sanity_check(!isRunning());
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/******************************************************************************/
|
2015-04-07 12:13:12 +02:00
|
|
|
void* AsyncWorkerThread::run()
|
2014-04-15 19:41:07 +02:00
|
|
|
{
|
2014-04-27 23:55:49 +02:00
|
|
|
lua_State *L = getStack();
|
2014-04-15 19:41:07 +02:00
|
|
|
|
2014-04-27 23:55:49 +02:00
|
|
|
std::string script = getServer()->getBuiltinLuaPath() + DIR_DELIM + "init.lua";
|
2015-10-29 19:48:10 +01:00
|
|
|
try {
|
|
|
|
loadScript(script);
|
|
|
|
} catch (const ModError &e) {
|
|
|
|
errorstream << "Execution of async base environment failed: "
|
|
|
|
<< e.what() << std::endl;
|
|
|
|
FATAL_ERROR("Execution of async base environment failed");
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
2015-08-25 07:44:53 +02:00
|
|
|
int error_handler = PUSH_ERROR_HANDLER(L);
|
|
|
|
|
2014-05-31 01:38:11 +02:00
|
|
|
lua_getglobal(L, "core");
|
|
|
|
if (lua_isnil(L, -1)) {
|
2015-10-26 04:13:27 +01:00
|
|
|
FATAL_ERROR("Unable to find core within async environment!");
|
2014-05-31 01:38:11 +02:00
|
|
|
}
|
|
|
|
|
2014-04-15 19:41:07 +02:00
|
|
|
// Main loop
|
2015-04-07 12:13:12 +02:00
|
|
|
while (!stopRequested()) {
|
2014-04-15 19:41:07 +02:00
|
|
|
// Wait for job
|
2014-04-15 21:10:30 +02:00
|
|
|
LuaJobInfo toProcess = jobDispatcher->getJob();
|
2014-04-15 19:41:07 +02:00
|
|
|
|
2017-04-20 00:12:52 +02:00
|
|
|
if (!toProcess.valid || stopRequested()) {
|
2014-04-15 19:41:07 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
lua_getfield(L, -1, "job_processor");
|
|
|
|
if (lua_isnil(L, -1)) {
|
2015-10-26 04:13:27 +01:00
|
|
|
FATAL_ERROR("Unable to get async job processor!");
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
luaL_checktype(L, -1, LUA_TFUNCTION);
|
|
|
|
|
|
|
|
// Call it
|
|
|
|
lua_pushlstring(L,
|
|
|
|
toProcess.serializedFunction.data(),
|
|
|
|
toProcess.serializedFunction.size());
|
|
|
|
lua_pushlstring(L,
|
|
|
|
toProcess.serializedParams.data(),
|
|
|
|
toProcess.serializedParams.size());
|
|
|
|
|
2015-08-25 07:44:53 +02:00
|
|
|
int result = lua_pcall(L, 2, 1, error_handler);
|
2015-08-05 06:49:35 +02:00
|
|
|
if (result) {
|
|
|
|
PCALL_RES(result);
|
2014-04-15 19:41:07 +02:00
|
|
|
toProcess.serializedResult = "";
|
|
|
|
} else {
|
|
|
|
// Fetch result
|
|
|
|
size_t length;
|
|
|
|
const char *retval = lua_tolstring(L, -1, &length);
|
|
|
|
toProcess.serializedResult = std::string(retval, length);
|
|
|
|
}
|
|
|
|
|
2014-05-31 01:38:11 +02:00
|
|
|
lua_pop(L, 1); // Pop retval
|
2014-04-15 19:41:07 +02:00
|
|
|
|
|
|
|
// Put job result
|
2014-04-15 21:10:30 +02:00
|
|
|
jobDispatcher->putJobResult(toProcess);
|
2014-04-15 19:41:07 +02:00
|
|
|
}
|
2014-05-31 01:38:11 +02:00
|
|
|
|
2015-08-25 07:44:53 +02:00
|
|
|
lua_pop(L, 2); // Pop core and error handler
|
2014-05-31 01:38:11 +02:00
|
|
|
|
2014-04-15 19:41:07 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|