mirror of
https://github.com/Relintai/pandemonium_engine.git
synced 2024-12-22 11:56:49 +01:00
212 lines
7.0 KiB
C++
212 lines
7.0 KiB
C++
/*************************************************************************/
|
|
/* thread_pool_job.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* PANDEMONIUM ENGINE */
|
|
/* https://github.com/Relintai/pandemonium_engine */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2022-present Péter Magyar. */
|
|
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
|
|
|
|
#include "thread_pool_job.h"
|
|
|
|
#include "core/variant/variant.h"
|
|
|
|
#include "core/os/os.h"
|
|
|
|
bool ThreadPoolJob::get_complete() const {
|
|
return _complete;
|
|
}
|
|
void ThreadPoolJob::set_complete(const bool value) {
|
|
bool call_signal = false;
|
|
if (!_complete && value) {
|
|
call_signal = true;
|
|
}
|
|
|
|
_complete = value;
|
|
|
|
if (call_signal) {
|
|
call_deferred("emit_signal", "completed");
|
|
}
|
|
}
|
|
|
|
bool ThreadPoolJob::get_cancelled() const {
|
|
return _cancelled;
|
|
}
|
|
void ThreadPoolJob::set_cancelled(const bool value) {
|
|
_cancelled = value;
|
|
}
|
|
|
|
float ThreadPoolJob::get_max_allocated_time() const {
|
|
return _max_allocated_time;
|
|
}
|
|
void ThreadPoolJob::set_max_allocated_time(const float value) {
|
|
_max_allocated_time = value;
|
|
}
|
|
|
|
int ThreadPoolJob::get_start_time() const {
|
|
return _start_time;
|
|
}
|
|
void ThreadPoolJob::set_start_time(const int value) {
|
|
_start_time = value;
|
|
}
|
|
|
|
int ThreadPoolJob::get_current_run_stage() const {
|
|
return _current_run_stage;
|
|
}
|
|
void ThreadPoolJob::set_current_run_stage(const int value) {
|
|
_current_run_stage = value;
|
|
}
|
|
|
|
int ThreadPoolJob::get_stage() const {
|
|
return _stage;
|
|
}
|
|
void ThreadPoolJob::set_stage(const int value) {
|
|
_stage = value;
|
|
}
|
|
|
|
void ThreadPoolJob::reset_stages() {
|
|
_current_run_stage = 0;
|
|
_stage = 0;
|
|
}
|
|
|
|
Variant ThreadPoolJob::get_object() const {
|
|
return _object;
|
|
}
|
|
void ThreadPoolJob::set_object(const Variant &value) {
|
|
_object = value;
|
|
}
|
|
|
|
StringName ThreadPoolJob::get_method() const {
|
|
return _method;
|
|
}
|
|
void ThreadPoolJob::set_method(const StringName &value) {
|
|
_method = value;
|
|
}
|
|
|
|
float ThreadPoolJob::get_current_execution_time() {
|
|
return (OS::get_singleton()->get_system_time_msecs() - _start_time) / 1000.0;
|
|
}
|
|
|
|
bool ThreadPoolJob::should_do(const bool just_check) {
|
|
if (just_check) {
|
|
return _current_run_stage == _stage;
|
|
}
|
|
|
|
if (_current_run_stage < _stage) {
|
|
++_current_run_stage;
|
|
return false;
|
|
}
|
|
|
|
++_current_run_stage;
|
|
++_stage;
|
|
|
|
return true;
|
|
}
|
|
bool ThreadPoolJob::should_return() {
|
|
if (_cancelled) {
|
|
return true;
|
|
}
|
|
|
|
if (_max_allocated_time < 0.00001) {
|
|
return false;
|
|
}
|
|
|
|
return get_current_execution_time() >= _max_allocated_time;
|
|
}
|
|
|
|
void ThreadPoolJob::execute() {
|
|
_current_run_stage = 0;
|
|
|
|
_start_time = OS::get_singleton()->get_system_time_msecs();
|
|
|
|
call("_execute");
|
|
}
|
|
|
|
void ThreadPoolJob::_execute() {
|
|
set_complete(true);
|
|
}
|
|
|
|
ThreadPoolJob::ThreadPoolJob() {
|
|
_complete = true;
|
|
_cancelled = false;
|
|
|
|
_max_allocated_time = 0;
|
|
_start_time = 0;
|
|
|
|
_current_run_stage = 0;
|
|
_stage = 0;
|
|
|
|
_object = NULL;
|
|
|
|
_argcount = 0;
|
|
|
|
_argptr = memnew_arr(Variant, 5);
|
|
}
|
|
ThreadPoolJob::~ThreadPoolJob() {
|
|
memdelete_arr(_argptr);
|
|
}
|
|
|
|
void ThreadPoolJob::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("get_complete"), &ThreadPoolJob::get_complete);
|
|
ClassDB::bind_method(D_METHOD("set_complete", "value"), &ThreadPoolJob::set_complete);
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "complete"), "set_complete", "get_complete");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_cancelled"), &ThreadPoolJob::get_cancelled);
|
|
ClassDB::bind_method(D_METHOD("set_cancelled", "value"), &ThreadPoolJob::set_cancelled);
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "cancelled"), "set_cancelled", "get_cancelled");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_max_allocated_time"), &ThreadPoolJob::get_max_allocated_time);
|
|
ClassDB::bind_method(D_METHOD("set_max_allocated_time", "value"), &ThreadPoolJob::set_max_allocated_time);
|
|
ADD_PROPERTY(PropertyInfo(Variant::REAL, "max_allocated_time"), "set_max_allocated_time", "get_max_allocated_time");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_start_time"), &ThreadPoolJob::get_start_time);
|
|
ClassDB::bind_method(D_METHOD("set_start_time", "value"), &ThreadPoolJob::set_start_time);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "start_time"), "set_start_time", "get_start_time");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_current_run_stage"), &ThreadPoolJob::get_current_run_stage);
|
|
ClassDB::bind_method(D_METHOD("set_current_run_stage", "value"), &ThreadPoolJob::set_current_run_stage);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "current_run_stage"), "set_current_run_stage", "get_current_run_stage");
|
|
|
|
ClassDB::bind_method(D_METHOD("get_stage"), &ThreadPoolJob::get_stage);
|
|
ClassDB::bind_method(D_METHOD("set_stage", "value"), &ThreadPoolJob::set_stage);
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "stage"), "set_stage", "get_stage");
|
|
|
|
ClassDB::bind_method(D_METHOD("reset_stages"), &ThreadPoolJob::reset_stages);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_current_execution_time"), &ThreadPoolJob::get_current_execution_time);
|
|
|
|
ClassDB::bind_method(D_METHOD("should_do", "just_check"), &ThreadPoolJob::should_do, DEFVAL(false));
|
|
ClassDB::bind_method(D_METHOD("should_return"), &ThreadPoolJob::should_return);
|
|
|
|
BIND_VMETHOD(MethodInfo("_execute"));
|
|
|
|
ClassDB::bind_method(D_METHOD("execute"), &ThreadPoolJob::execute);
|
|
ClassDB::bind_method(D_METHOD("_execute"), &ThreadPoolJob::_execute);
|
|
|
|
ADD_SIGNAL(MethodInfo("completed"));
|
|
}
|