aboutsummaryrefslogtreecommitdiff
path: root/tools
diff options
context:
space:
mode:
Diffstat (limited to 'tools')
-rw-r--r--tools/schedule.js102
1 files changed, 102 insertions, 0 deletions
diff --git a/tools/schedule.js b/tools/schedule.js
new file mode 100644
index 0000000..02dc883
--- /dev/null
+++ b/tools/schedule.js
@@ -0,0 +1,102 @@
+// A mixed paradigm scheduler
+
+// The core managed data type: a queue will be pushed a number of these and asked to manage it.
+function Job(data, prio=0, wt=1){
+ // Data is an array;
+ // Ideally, Both prio and wt are functions which take one argument: how many write cycles they've been waiting. This helps manage time-sensitive jobs.
+ // But this is too computationally difficult, so they are integer constants.
+
+ // Immutable Properties
+ this.data = data; //A set of work to be done (like character writes)
+ this.prio = prio; // If a.prio > b.prio, all of `a.data` will be sent before any of `b.data`
+ this.wt = wt; // After numerous calls, (amount called of a/amount called of b) = a.wt/b.wt if a.prio = b.prio
+ this.maxr = data.length/wt; // A utility calculation: If a job has a lower maxr, it will run out of data earlier.
+
+ // Mutable Properties
+ this.wacc = 0; // mutable property: Queue will change this to keep track between dequeues of how much "left over" push real estate this should have.
+ this.start; // The write # this job was introduced on. Also for Queue use.
+}
+
+function Queue(maxExport, call, delay){
+ // Every delay ms, Queue executes `call(maxExport # of objs in queue)`
+ let jobs = {}; // Links priorities to unordered arrays of jobs
+ let prios = []; // Array of priorities (keys of jobs), sorted.
+ let open = false;
+ let disab = true;
+ let writes = 0;
+
+ this.enqueue = function(job){
+ job.start = writes;
+ let prio = job.prio;
+ if (!jobs[prio]) jobs[prio] = [];
+ jobs[prio].splice(0, Math.abs(bs(jobs[prio], job, (el, ne) => el.maxr - ne.maxr)), job);
+ push(job);
+ prios.splice(0, Math.abs(bs(prios, prio, (el, ne) => el-ne)), prio)
+ if (open) dequeue();
+ }
+
+ this.enable = function(){
+ disab = false;
+ if (open) dequeue();
+ }
+
+ this.disable = function(){
+ disab = true;
+ }
+
+ function dequeue(){
+ if (disab){
+ open = true;
+ return;
+ }
+ if (prios.length == 0){
+ open = true;
+ return;
+ }
+ open = false;
+ let data = [];
+ while (data.length < maxExport){
+ data.push(...getNumOrAll(prios[prios.length-1]), maxExport-data.length);
+ }
+
+ writes++;
+ call(data);
+ setTimeout(dequeue, delayms);
+ }
+
+ function getNumOrAll(prio, num){
+ /*
+
+ Step 1: (Pre-)sort by job.data.length/job.weight.
+ Step 2: Start at lowest, and pop all until job.data.length>job.normweight*num (decreasing num as popping and recalc job.normweight). Delete the job.
+ Step 3: Then, pop job.normweight*num//1 elems from remaining, without num decrease or normweight recalc. But keep job.wacc = job.normweight*num%1
+ Step 4: Shallow copy job array, and sort by job.wacc.
+ Step 5: Iterate through array (high->low), and subtract 1 until the length of output is num.
+ Step 6: If empty, remove prio && jobs[prio]; return.
+ */
+ let jobq = jobs[prio];
+ let dequeued = [];
+ let weightsum = Math.sum(jobq.map(job => job.wt)).reduce((acc, cur)=>acc+cur);
+ while (job[0].data.length<(job[0].wacc+job[0].wt*num/weightsum)){
+ weightsum -= job.wt;
+ dequeued.push(...jobq.shift().data);
+ }
+ for (job of jobq){
+ job.wacc += job.wt*num/weightsum;
+ let data = job.data;
+ let topop = job.wacc-job.wacc%1;
+ job.wacc -= topop
+ dequeued.push(...data.splice(-topop));
+ }
+ for (job of jobq.splice().sort((el, ne) => el.wacc-ne.wacc)){
+ if (dequeued.length == num) break;
+ job.wacc--;
+ dequeue.push(job.pop());
+ }
+ if (jobq.length == 0){
+ delete jobs[prio];
+ prios.splice(bs(prios, prio, (el, ne)=>el-ne), 1);
+ }
+ return dequeued;
+ }
+}