13 changed files with 827 additions and 44 deletions
@ -0,0 +1,44 @@ |
|||||||
|
/** |
||||||
|
* Simple object that represents a job, capable of being scheduled on the |
||||||
|
* `SchedulerAPI`. Use `IsCompleted()` to mark job as completed. |
||||||
|
* Copyright 2022 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia 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 General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class MockJob extends SchedulerJob; |
||||||
|
|
||||||
|
var public string mark; |
||||||
|
var public int unitsLeft; |
||||||
|
|
||||||
|
// We use `default` value only |
||||||
|
var public string callStack; |
||||||
|
|
||||||
|
public function bool IsCompleted() |
||||||
|
{ |
||||||
|
return (unitsLeft <= 0); |
||||||
|
} |
||||||
|
|
||||||
|
public function DoWork(int allottedWorkUnits) |
||||||
|
{ |
||||||
|
unitsLeft -= allottedWorkUnits; |
||||||
|
if (IsCompleted()) { |
||||||
|
default.callStack = default.callStack $ mark; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
} |
||||||
@ -0,0 +1,216 @@ |
|||||||
|
/** |
||||||
|
* Set of tests for Scheduler API. |
||||||
|
* Copyright 2022 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia 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 General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class TEST_SchedulerAPI extends TestCase |
||||||
|
abstract; |
||||||
|
|
||||||
|
var int diskUses; |
||||||
|
|
||||||
|
protected static function UseDisk() |
||||||
|
{ |
||||||
|
default.diskUses += 1; |
||||||
|
} |
||||||
|
|
||||||
|
protected static function MockJob MakeJob(string mark, int totalUnits) |
||||||
|
{ |
||||||
|
local MockJob newJob; |
||||||
|
|
||||||
|
newJob = MockJob(__().memory.Allocate(class'MockJob')); |
||||||
|
newJob.mark = mark; |
||||||
|
newJob.unitsLeft = totalUnits; |
||||||
|
return newJob; |
||||||
|
} |
||||||
|
|
||||||
|
protected static function TESTS() |
||||||
|
{ |
||||||
|
Test_MockJob(); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function Test_MockJob() |
||||||
|
{ |
||||||
|
Context("Testing job scheduling."); |
||||||
|
SubText_SimpleScheduling(); |
||||||
|
SubText_ManyScheduling(); |
||||||
|
SubText_DiskScheduling(); |
||||||
|
SubText_DiskSchedulingDeallocate(); |
||||||
|
SubText_JobDiskMix(); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function SubText_SimpleScheduling() |
||||||
|
{ |
||||||
|
Issue("Simple scheduling doesn't process jobs in intended order"); |
||||||
|
class'MockJob'.default.callStack = ""; |
||||||
|
__().scheduler.ManualTick(); // Reset work units |
||||||
|
__().scheduler.AddJob(MakeJob("A", 2400)); |
||||||
|
__().scheduler.AddJob(MakeJob("B", 3000)); |
||||||
|
__().scheduler.AddJob(MakeJob("C", 7600)); |
||||||
|
__().scheduler.AddJob(MakeJob("D", 1000)); |
||||||
|
__().scheduler.ManualTick(); // 10,000 units => -2,500 units per job |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "AD"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 2); |
||||||
|
__().scheduler.ManualTick(); // 10,000 units => -5,000 units per job |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "ADB"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 1); |
||||||
|
__().scheduler.ManualTick(); // 10,000 units => -5,000 units per job |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "ADBC"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 0); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function SubText_ManyScheduling() |
||||||
|
{ |
||||||
|
Issue("After scheduling jobs over per-tick limit, scheduler doesn't process" |
||||||
|
@ "jobs in intended order"); |
||||||
|
class'MockJob'.default.callStack = ""; |
||||||
|
__().scheduler.ManualTick(); // Reset work units |
||||||
|
// 10,000 units => 2,000 units per job for 5 jobs |
||||||
|
__().scheduler.AddJob(MakeJob("A", 3000)); |
||||||
|
__().scheduler.AddJob(MakeJob("B", 3000)); |
||||||
|
__().scheduler.AddJob(MakeJob("C", 3000)); |
||||||
|
__().scheduler.AddJob(MakeJob("D", 1000)); |
||||||
|
__().scheduler.AddJob(MakeJob("E", 3000)); |
||||||
|
__().scheduler.AddJob(MakeJob("F", 3000)); |
||||||
|
__().scheduler.AddJob(MakeJob("G", 1000)); |
||||||
|
__().scheduler.AddJob(MakeJob("H", 5000)); |
||||||
|
__().scheduler.AddJob(MakeJob("I", 1000)); |
||||||
|
__().scheduler.ManualTick(); |
||||||
|
// A:1000, B:1000, C:1000, D:0, E:1000, F:3000, G:1000, H:5000, I:1000 |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "D"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 8); |
||||||
|
__().scheduler.ManualTick(); |
||||||
|
// A:0, B:1000, C:1000, D:0, E:1000, F:1000, G:0, H:3000, I:0 |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "DGIA"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 5); |
||||||
|
__().scheduler.ManualTick(); |
||||||
|
// A:0, B:0, C:0, D:0, E:0, F:0, G:0, H:1000, I:0 |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "DGIABCEF"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 1); |
||||||
|
__().scheduler.ManualTick(); |
||||||
|
// A:0, B:0, C:0, D:0, E:0, F:0, G:0, H:0, I:0 |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "DGIABCEFH"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 0); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function SubText_DiskScheduling() |
||||||
|
{ |
||||||
|
local Text objectInstance; |
||||||
|
|
||||||
|
Issue("Disk scheduling doesn't happen at expected intervals."); |
||||||
|
default.diskUses = 0; |
||||||
|
__().scheduler.ManualTick(1.0); // Pre-fill cooldown, just in case |
||||||
|
objectInstance = __().text.FromString("whatever"); |
||||||
|
__().scheduler.RequestDiskAccess(objectInstance).connect = UseDisk; |
||||||
|
__().scheduler.RequestDiskAccess(objectInstance).connect = UseDisk; |
||||||
|
__().scheduler.RequestDiskAccess(objectInstance).connect = UseDisk; |
||||||
|
__().scheduler.RequestDiskAccess(objectInstance).connect = UseDisk; |
||||||
|
__().scheduler.ManualTick(0.001); |
||||||
|
TEST_ExpectTrue(default.diskUses == 1); |
||||||
|
__().scheduler.ManualTick(0.21); |
||||||
|
TEST_ExpectTrue(default.diskUses == 1); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetDiskQueueSize() == 3); |
||||||
|
__().scheduler.ManualTick(0.2); |
||||||
|
TEST_ExpectTrue(default.diskUses == 2); |
||||||
|
__().scheduler.ManualTick(0.21); |
||||||
|
TEST_ExpectTrue(default.diskUses == 2); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetDiskQueueSize() == 2); |
||||||
|
__().scheduler.ManualTick(0.2); |
||||||
|
TEST_ExpectTrue(default.diskUses == 3); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetDiskQueueSize() == 1); |
||||||
|
__().scheduler.ManualTick(0.1); |
||||||
|
TEST_ExpectTrue(default.diskUses == 3); |
||||||
|
__().scheduler.ManualTick(0.1); |
||||||
|
TEST_ExpectTrue(default.diskUses == 3); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetDiskQueueSize() == 1); |
||||||
|
__().scheduler.ManualTick(0.1); |
||||||
|
TEST_ExpectTrue(default.diskUses == 4); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetDiskQueueSize() == 0); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function SubText_DiskSchedulingDeallocate() |
||||||
|
{ |
||||||
|
local Text objectInstance, deletedInstance; |
||||||
|
|
||||||
|
Issue("Disk scheduling cannot correctly handle deallocated receivers."); |
||||||
|
default.diskUses = 0; |
||||||
|
__().scheduler.ManualTick(1.0); // Pre-fill cooldown, just in case |
||||||
|
objectInstance = __().text.FromString("whatever"); |
||||||
|
deletedInstance = __().text.FromString("heh"); |
||||||
|
__().scheduler.RequestDiskAccess(objectInstance).connect = UseDisk; |
||||||
|
__().scheduler.RequestDiskAccess(deletedInstance).connect = UseDisk; |
||||||
|
__().scheduler.RequestDiskAccess(objectInstance).connect = UseDisk; |
||||||
|
__().scheduler.RequestDiskAccess(deletedInstance).connect = UseDisk; |
||||||
|
// Fuck off the `deletedInstance` object |
||||||
|
deletedInstance.FreeSelf(); |
||||||
|
// Test! |
||||||
|
__().scheduler.ManualTick(0.001); |
||||||
|
TEST_ExpectTrue(default.diskUses == 1); |
||||||
|
__().scheduler.ManualTick(0.21); |
||||||
|
TEST_ExpectTrue(default.diskUses == 1); |
||||||
|
__().scheduler.ManualTick(0.2); |
||||||
|
TEST_ExpectTrue(default.diskUses == 2); |
||||||
|
__().scheduler.ManualTick(0.21); |
||||||
|
TEST_ExpectTrue(default.diskUses == 2); |
||||||
|
__().scheduler.ManualTick(0.2); |
||||||
|
TEST_ExpectTrue(default.diskUses == 2); |
||||||
|
__().scheduler.ManualTick(1.0); |
||||||
|
TEST_ExpectTrue(default.diskUses == 2); |
||||||
|
} |
||||||
|
|
||||||
|
protected static function SubText_JobDiskMix() |
||||||
|
{ |
||||||
|
local Text objectInstance; |
||||||
|
|
||||||
|
Issue("Job and disk scheduling doesn't happen at expected intervals."); |
||||||
|
objectInstance = __().text.FromString("whatever"); |
||||||
|
class'MockJob'.default.callStack = ""; |
||||||
|
default.diskUses = 0; |
||||||
|
__().scheduler.ManualTick(1.0); // Reset work units |
||||||
|
// 0.2 * 10,000 = 2,000 units => 1,000 units per job for 2 jobs |
||||||
|
__().scheduler.AddJob(MakeJob("A", 30000)); |
||||||
|
__().scheduler.AddJob(MakeJob("B", 10000)); |
||||||
|
__().scheduler.RequestDiskAccess(objectInstance).connect = UseDisk; |
||||||
|
__().scheduler.RequestDiskAccess(objectInstance).connect = UseDisk; |
||||||
|
// Reset disk cooldown |
||||||
|
__().scheduler.ManualTick(0.2); |
||||||
|
// A:25000, B:5000 |
||||||
|
TEST_ExpectTrue(default.diskUses == 1); |
||||||
|
__().scheduler.ManualTick(0.2); // Disk on cooldown |
||||||
|
// A:20000, B:0 |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "B"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 1); |
||||||
|
TEST_ExpectTrue(default.diskUses == 1); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetDiskQueueSize() == 1); |
||||||
|
__().scheduler.ManualTick(0.2); // Disk got off cooldown, do writing |
||||||
|
// A:10000, B:0 |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "B"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 1); |
||||||
|
TEST_ExpectTrue(default.diskUses == 2); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetDiskQueueSize() == 0); |
||||||
|
__().scheduler.ManualTick(0.2); // Disk on cooldown |
||||||
|
// A:0, B:0 |
||||||
|
TEST_ExpectTrue(class'MockJob'.default.callStack == "BA"); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetJobsAmount() == 0); |
||||||
|
TEST_ExpectTrue(default.diskUses == 2); |
||||||
|
TEST_ExpectTrue(__().scheduler.GetDiskQueueSize() == 0); |
||||||
|
} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
caseName = "SchedulerAPI" |
||||||
|
caseGroup = "Scheduler" |
||||||
|
} |
||||||
@ -0,0 +1,421 @@ |
|||||||
|
/** |
||||||
|
* API that provides functions for scheduling jobs and expensive tasks such |
||||||
|
* as writing onto the disk. Also provides methods for users to inform API that |
||||||
|
* they've recently did an expensive operation, so that `SchedulerAPI` is to |
||||||
|
* try and use less resources when managing jobs. |
||||||
|
* Copyright 2022 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia 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 General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class SchedulerAPI extends AcediaObject |
||||||
|
config(AcediaSystem); |
||||||
|
|
||||||
|
/** |
||||||
|
* # `SchedulerAPI` |
||||||
|
* |
||||||
|
* UnrealScript is inherently single-threaded and whatever method you call, |
||||||
|
* it will be completely executed within a single game's tick. |
||||||
|
* This API is meant for scheduling various actions over time to help emulating |
||||||
|
* multi-threading by spreading some code executions over several different |
||||||
|
* game/server ticks. |
||||||
|
* |
||||||
|
* ## Usage |
||||||
|
* |
||||||
|
* ### Job scheduling |
||||||
|
* |
||||||
|
* One of the reasons which is faulty infinite loop detection system that |
||||||
|
* will crash the game/server if it thinks UnrealScript code has executed too |
||||||
|
* many operations (it is not about execution time, logging a lot of messages |
||||||
|
* with `Log()` can take a lot of time and not crash anything, while simple |
||||||
|
* loop, that would've finished much sooner, can trigger a crash). |
||||||
|
* This is a very atypical problem for mods to have, but Acedia's |
||||||
|
* introduction of databases and avarice link can lead to users trying to read |
||||||
|
* (from database or network) an object that is too big, leading to a crash. |
||||||
|
* Jobs are not about performance, they're about crash prevention. |
||||||
|
* |
||||||
|
* In case you have such a job of your own, that can potentially take too |
||||||
|
* many steps to finish without crashing, you can convert it into |
||||||
|
* a `SchedulerJob` (you make a subclass for your type of the job and |
||||||
|
* instantiate it for each execution of the job). This requires you to |
||||||
|
* restructure your algorithm in such a way, that it is able to run for some |
||||||
|
* finite (maybe small) amount of steps and postpone the rest of calculations |
||||||
|
* to the next tick and put it into a method |
||||||
|
* `SchedulerJob.DoWork(int allottedWorkUnits)`, where `allottedWorkUnits` is |
||||||
|
* how much your method is allowed to do during this call, assuming `10000` |
||||||
|
* units of work on their own won't lead to a crash. |
||||||
|
* Another method `SchedulerJob.IsCompleted()` needs to be setup to return |
||||||
|
* `true` iff your job is done. |
||||||
|
* After you prepared an instance of your job subclass, simply pass it to |
||||||
|
* `_.scheduler.AddJob()`. |
||||||
|
* |
||||||
|
* ### Disk usage requests |
||||||
|
* |
||||||
|
* Writing to the disk (saving data into config file, saving local database |
||||||
|
* changes) can be an expensive operation and to avoid lags in gameplay you |
||||||
|
* might want to spread such operations over time. |
||||||
|
* `_.scheduler.RequestDiskAccess()` method allows you to do that. It is not |
||||||
|
* exactly a signal, but it acts similar to one: to request a right to save to |
||||||
|
* the disk, just do the following: |
||||||
|
* `_.scheduler.RequestDiskAccess(<receiver>).connect = <disk_writing_method>` |
||||||
|
* and `disk_writing_method()` will be called once your turn come up. |
||||||
|
* |
||||||
|
* ## Manual ticking |
||||||
|
* |
||||||
|
* If any kind of level core (either server or client one) was created, |
||||||
|
* this API will automatically perform necessary actions every tick. |
||||||
|
* Otherwise, if only base API is available, there's no way to do that, but |
||||||
|
* you can manually decide when to tick this API by calling `ManualTick()` |
||||||
|
* method. |
||||||
|
*/ |
||||||
|
|
||||||
|
/** |
||||||
|
* How often can files be saved on disk. This is a relatively expensive |
||||||
|
* operation and we don't want to write a lot of different files at once. |
||||||
|
* But since we lack a way to exactly measure how much time that saving will |
||||||
|
* take, AcediaCore falls back to simply performing every saving with same |
||||||
|
* uniform time intervals in-between. |
||||||
|
* This variable decides how much time there should be between two file |
||||||
|
* writing accesses. |
||||||
|
* Negative and zero values mean that all writing disk access will be |
||||||
|
* granted as soon as possible, without any cooldowns. |
||||||
|
*/ |
||||||
|
var private config float diskSaveCooldown; |
||||||
|
/** |
||||||
|
* Maximum total work units for jobs allowed per tick. Jobs are expected to be |
||||||
|
* constructed such that they don't lead to a crash if they have to perform |
||||||
|
* this much work. |
||||||
|
* |
||||||
|
* Changing default value of `10000` is not advised. |
||||||
|
*/ |
||||||
|
var private config int maxWorkUnits; |
||||||
|
/** |
||||||
|
* How many different jobs can be performed per tick. This limit is added so |
||||||
|
* that `maxWorkUnits` won't be spread too thin if a lot of jobs get registered |
||||||
|
* at once. |
||||||
|
*/ |
||||||
|
var private config int maxJobsPerTick; |
||||||
|
|
||||||
|
// We can (and will) automatically tick |
||||||
|
var private bool tickAvailable; |
||||||
|
// `true` == it is safe to use server API for a tick |
||||||
|
// `false` == it is safe to use client API for a tick |
||||||
|
var private bool tickFromServer; |
||||||
|
// Our `Tick()` method is currently connected to the `OnTick()` signal. |
||||||
|
// Keeping track of this allows us to disconnect from `OnTick()` signal |
||||||
|
// when it is not necessary. |
||||||
|
var private bool connectedToTick; |
||||||
|
|
||||||
|
// How much time if left until we can write to the disk again? |
||||||
|
var private float currentDiskCooldown; |
||||||
|
|
||||||
|
// There is a limit (`maxJobsPerTick`) to how many different jobs we can |
||||||
|
// perform per tick and if we register an amount jobs over that limit, we need |
||||||
|
// to uniformly spread execution time between them. |
||||||
|
// To achieve that we simply cyclically (in order) go over `currentJobs` |
||||||
|
// array, each time executing exactly `maxJobsPerTick` jobs. |
||||||
|
// `nextJobToPerform` remembers what job is to be executed next tick. |
||||||
|
var private int nextJobToPerform; |
||||||
|
var private array<SchedulerJob> currentJobs; |
||||||
|
// Storing receiver objects, following example of signals/slots, is done |
||||||
|
// without increasing their reference count, allowing them to get deallocated |
||||||
|
// while we are still keeping their reference. |
||||||
|
// To avoid using such deallocated receivers, we keep track of the life |
||||||
|
// versions they've had when their disk requests were registered. |
||||||
|
var private array<SchedulerDiskRequest> diskQueue; |
||||||
|
var private array<AcediaObject> receivers; |
||||||
|
var private array<int> receiversLifeVersions; |
||||||
|
|
||||||
|
/** |
||||||
|
* Registers new scheduler job `newJob` to be executed in the API. |
||||||
|
* |
||||||
|
* @param newJob New job to be scheduled for execution. |
||||||
|
* Does nothing if given `newJob` is already added. |
||||||
|
*/ |
||||||
|
public function AddJob(SchedulerJob newJob) |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
|
||||||
|
if (newJob == none) { |
||||||
|
return; |
||||||
|
} |
||||||
|
for (i = 0; i < currentJobs.length; i += 1) |
||||||
|
{ |
||||||
|
if (currentJobs[i] == newJob) { |
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
newJob.NewRef(); |
||||||
|
currentJobs[currentJobs.length] = newJob; |
||||||
|
UpdateTickConnection(); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Requests another disk access. |
||||||
|
* |
||||||
|
* Use it like signal: `RequestDiskAccess(<receiver>).connect = <handler>`. |
||||||
|
* Since it is meant to be used as a signal, so DO NOT STORE/RELEASE returned |
||||||
|
* wrapper object `SchedulerDiskRequest`. |
||||||
|
* |
||||||
|
* @param receiver Same as for signal/slots, this is an object, responsible |
||||||
|
* for the disk request. If this object gets deallocated - request will be |
||||||
|
* thrown away. |
||||||
|
* Typically this should be an object in which connected method will be |
||||||
|
* executed. |
||||||
|
* @return Wrapper object that provides `connect` delegate. |
||||||
|
*/ |
||||||
|
public function SchedulerDiskRequest RequestDiskAccess(AcediaObject receiver) |
||||||
|
{ |
||||||
|
local SchedulerDiskRequest newRequest; |
||||||
|
|
||||||
|
if (receiver == none) return none; |
||||||
|
if (!receiver.IsAllocated()) return none; |
||||||
|
|
||||||
|
newRequest = |
||||||
|
SchedulerDiskRequest(_.memory.Allocate(class'SchedulerDiskRequest')); |
||||||
|
diskQueue[diskQueue.length] = newRequest; |
||||||
|
receivers[receivers.length] = receiver; |
||||||
|
receiversLifeVersions[receiversLifeVersions.length] = |
||||||
|
receiver.GetLifeVersion(); |
||||||
|
UpdateTickConnection(); |
||||||
|
return newRequest; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Tells you how many incomplete jobs are currently registered in |
||||||
|
* the scheduler. |
||||||
|
* |
||||||
|
* @return How many incomplete jobs are currently registered in the scheduler. |
||||||
|
*/ |
||||||
|
public function int GetJobsAmount() |
||||||
|
{ |
||||||
|
CleanCompletedJobs(); |
||||||
|
return currentJobs.length; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Tells you how many disk access requests are currently registered in |
||||||
|
* the scheduler. |
||||||
|
* |
||||||
|
* @return How many incomplete disk access requests are currently registered |
||||||
|
* in the scheduler. |
||||||
|
*/ |
||||||
|
public function int GetDiskQueueSize() |
||||||
|
{ |
||||||
|
CleanDiskQueue(); |
||||||
|
return diskQueue.length; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* In case neither server, nor client core is registered, scheduler must be |
||||||
|
* ticked manually. For that call this method each separate tick (or whatever |
||||||
|
* is your closest approximation available for that). |
||||||
|
* |
||||||
|
* Before manually invoking this method, you should check if scheduler |
||||||
|
* actually started to tick *automatically*. Use `_.scheduler.IsAutomated()` |
||||||
|
* for that. |
||||||
|
* |
||||||
|
* NOTE: If neither server-/client- core is created, nor `ManualTick()` is |
||||||
|
* invoked manually, `SchedulerAPI` won't actually do anything. |
||||||
|
* |
||||||
|
* @param delta Time (real one) that is supposedly passes from the moment |
||||||
|
* `ManualTick()` was called last time. Used for tracking disk access |
||||||
|
* cooldowns. How `SchedulerJob`s are executed is independent from this |
||||||
|
* value. |
||||||
|
*/ |
||||||
|
public final function ManualTick(optional float delta) |
||||||
|
{ |
||||||
|
Tick(delta, 1.0); |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Is scheduler ticking automated? It can only be automated if either |
||||||
|
* server or client level cores are created. Scheduler can automatically enable |
||||||
|
* automation and it cannot be prevented, but can be helped by using |
||||||
|
* `UpdateTickConnection()` method. |
||||||
|
* |
||||||
|
* @return `true` if scheduler's tick is automatically called and `false` |
||||||
|
* otherwise (and calling `ManualTick()` is required). |
||||||
|
*/ |
||||||
|
public function bool IsAutomated() |
||||||
|
{ |
||||||
|
return tickAvailable; |
||||||
|
} |
||||||
|
|
||||||
|
/** |
||||||
|
* Causes `SchedulerAPI` to try automating itself by searching for level cores |
||||||
|
* (checking if server/client APIs are enabled). |
||||||
|
*/ |
||||||
|
public function UpdateTickConnection() |
||||||
|
{ |
||||||
|
local bool needsConnection; |
||||||
|
local UnrealAPI api; |
||||||
|
|
||||||
|
if (!tickAvailable) |
||||||
|
{ |
||||||
|
if (_server.IsAvailable()) |
||||||
|
{ |
||||||
|
tickAvailable = true; |
||||||
|
tickFromServer = true; |
||||||
|
} |
||||||
|
else if (_client.IsAvailable()) |
||||||
|
{ |
||||||
|
tickAvailable = true; |
||||||
|
tickFromServer = false; |
||||||
|
} |
||||||
|
if (!tickAvailable) { |
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
needsConnection = (currentJobs.length > 0 || diskQueue.length > 0); |
||||||
|
if (connectedToTick == needsConnection) { |
||||||
|
return; |
||||||
|
} |
||||||
|
if (tickFromServer) { |
||||||
|
api = _server.unreal; |
||||||
|
} |
||||||
|
else { |
||||||
|
api = _client.unreal; |
||||||
|
} |
||||||
|
if (connectedToTick && !needsConnection) { |
||||||
|
api.OnTick(self).Disconnect(); |
||||||
|
} |
||||||
|
else if (!connectedToTick && needsConnection) { |
||||||
|
api.OnTick(self).connect = Tick; |
||||||
|
} |
||||||
|
connectedToTick = needsConnection; |
||||||
|
} |
||||||
|
|
||||||
|
private function Tick(float delta, float dilationCoefficient) |
||||||
|
{ |
||||||
|
delta = delta / dilationCoefficient; |
||||||
|
// Manage disk cooldown |
||||||
|
if (currentDiskCooldown > 0) { |
||||||
|
currentDiskCooldown -= delta; |
||||||
|
} |
||||||
|
if (currentDiskCooldown <= 0 && diskQueue.length > 0) |
||||||
|
{ |
||||||
|
currentDiskCooldown = diskSaveCooldown; |
||||||
|
ProcessDiskQueue(); |
||||||
|
} |
||||||
|
// Manage jobs |
||||||
|
if (currentJobs.length > 0) { |
||||||
|
ProcessJobs(); |
||||||
|
} |
||||||
|
UpdateTickConnection(); |
||||||
|
} |
||||||
|
|
||||||
|
private function ProcessJobs() |
||||||
|
{ |
||||||
|
local int unitsPerJob; |
||||||
|
local int jobsToPerform; |
||||||
|
|
||||||
|
CleanCompletedJobs(); |
||||||
|
jobsToPerform = Min(currentJobs.length, maxJobsPerTick); |
||||||
|
if (jobsToPerform <= 0) { |
||||||
|
return; |
||||||
|
} |
||||||
|
unitsPerJob = maxWorkUnits / jobsToPerform; |
||||||
|
while (jobsToPerform > 0) |
||||||
|
{ |
||||||
|
if (nextJobToPerform >= currentJobs.length) { |
||||||
|
nextJobToPerform = 0; |
||||||
|
} |
||||||
|
currentJobs[nextJobToPerform].DoWork(unitsPerJob); |
||||||
|
nextJobToPerform += 1; |
||||||
|
jobsToPerform -= 1; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private function ProcessDiskQueue() |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
|
||||||
|
// Even if we clean disk queue here, we still need to double check |
||||||
|
// lifetimes in the code below, since we have no idea what `.connect()` |
||||||
|
// calls might do |
||||||
|
CleanDiskQueue(); |
||||||
|
if (diskQueue.length <= 0) { |
||||||
|
return; |
||||||
|
} |
||||||
|
if (diskSaveCooldown > 0) |
||||||
|
{ |
||||||
|
if (receivers[i].GetLifeVersion() == receiversLifeVersions[i]) { |
||||||
|
diskQueue[i].connect(); |
||||||
|
} |
||||||
|
_.memory.Free(diskQueue[0]); |
||||||
|
diskQueue.Remove(0, 1); |
||||||
|
receivers.Remove(0, 1); |
||||||
|
receiversLifeVersions.Remove(0, 1); |
||||||
|
return; |
||||||
|
} |
||||||
|
for (i = 0; i < diskQueue.length; i += 1) |
||||||
|
{ |
||||||
|
if (receivers[i].GetLifeVersion() == receiversLifeVersions[i]) { |
||||||
|
diskQueue[i].connect(); |
||||||
|
} |
||||||
|
_.memory.Free(diskQueue[i]); |
||||||
|
} |
||||||
|
diskQueue.length = 0; |
||||||
|
receivers.length = 0; |
||||||
|
receiversLifeVersions.length = 0; |
||||||
|
} |
||||||
|
|
||||||
|
// Removes completed jobs |
||||||
|
private function CleanCompletedJobs() |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
|
||||||
|
while (i < currentJobs.length) |
||||||
|
{ |
||||||
|
if (currentJobs[i].IsCompleted()) |
||||||
|
{ |
||||||
|
if (i < nextJobToPerform) { |
||||||
|
nextJobToPerform -= 1; |
||||||
|
} |
||||||
|
currentJobs[i].FreeSelf(); |
||||||
|
currentJobs.Remove(i, 1); |
||||||
|
} |
||||||
|
else { |
||||||
|
i += 1; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
// Remove disk requests with deallocated receivers |
||||||
|
private function CleanDiskQueue() |
||||||
|
{ |
||||||
|
local int i; |
||||||
|
|
||||||
|
while (i < diskQueue.length) |
||||||
|
{ |
||||||
|
if (receivers[i].GetLifeVersion() == receiversLifeVersions[i]) |
||||||
|
{ |
||||||
|
i += 1; |
||||||
|
continue; |
||||||
|
} |
||||||
|
_.memory.Free(diskQueue[i]); |
||||||
|
diskQueue.Remove(i, 1); |
||||||
|
receivers.Remove(i, 1); |
||||||
|
receiversLifeVersions.Remove(i, 1); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
diskSaveCooldown = 0.25 |
||||||
|
maxWorkUnits = 10000 |
||||||
|
maxJobsPerTick = 5 |
||||||
|
} |
||||||
@ -0,0 +1,29 @@ |
|||||||
|
/** |
||||||
|
* Slot-like object that represents a request for a writing disk access, |
||||||
|
* capable of being scheduled on the `SchedulerAPI`. |
||||||
|
* Copyright 2022 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia 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 General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class SchedulerDiskRequest extends AcediaObject; |
||||||
|
|
||||||
|
delegate connect() |
||||||
|
{ |
||||||
|
} |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
} |
||||||
@ -0,0 +1,47 @@ |
|||||||
|
/** |
||||||
|
* Template object that represents a job, capable of being scheduled on the |
||||||
|
* `SchedulerAPI`. Use `IsCompleted()` to mark job as completed. |
||||||
|
* Copyright 2022 Anton Tarasenko |
||||||
|
*------------------------------------------------------------------------------ |
||||||
|
* This file is part of Acedia. |
||||||
|
* |
||||||
|
* Acedia is free software: you can redistribute it and/or modify |
||||||
|
* it under the terms of the GNU General Public License as published by |
||||||
|
* the Free Software Foundation, version 3 of the License, or |
||||||
|
* (at your option) any later version. |
||||||
|
* |
||||||
|
* Acedia 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 General Public License for more details. |
||||||
|
* |
||||||
|
* You should have received a copy of the GNU General Public License |
||||||
|
* along with Acedia. If not, see <https://www.gnu.org/licenses/>. |
||||||
|
*/ |
||||||
|
class SchedulerJob extends AcediaObject |
||||||
|
abstract; |
||||||
|
|
||||||
|
/** |
||||||
|
* Checks if caller `SchedulerJob` was completed. |
||||||
|
* Once this method returns `true`, it shouldn't start returning `false` again. |
||||||
|
* |
||||||
|
* @return `true` if `SchedulerJob` is already completed and doesn't need to |
||||||
|
* be further executed and `false` otherwise. |
||||||
|
*/ |
||||||
|
public function bool IsCompleted(); |
||||||
|
|
||||||
|
/** |
||||||
|
* Called when scheduler decides that `SchedulerJob` should be executed, taking |
||||||
|
* amount of abstract "work units" that it is allowed to spend for work. |
||||||
|
* |
||||||
|
* @param allottedWorkUnits Work units allotted to the caller |
||||||
|
* `SchedulerJob`. By default there is `10000` work units per second, so |
||||||
|
* you can expect about 10000 / 1000 = 10 work units per millisecond or, |
||||||
|
* on servers with 30 tick rate, about 10000 * (30 / 1000) = 300 work units |
||||||
|
* per tick to be allotted to all the scheduled jobs. |
||||||
|
*/ |
||||||
|
public function DoWork(int allottedWorkUnits); |
||||||
|
|
||||||
|
defaultproperties |
||||||
|
{ |
||||||
|
} |
||||||
Loading…
Reference in new issue