37729a8661
The partition processor is a simple class that allows lists of data to be processed in chunks per invocation. It is designed to minimise per frame processing whilst keeping the code simple and the performance acceptable.
test code (use with F-14):
var pptest = func{
var xx= frame_utils.PartitionProcessor.new("TEST", 6);
var obj = {}; # just for testing
for (ii=0;ii<5;ii+=1) {
xx.process(obj, awg_9.tgts_list,
func(pp, obj, data){
print("init");
obj.designated = -1;
obj.search = "Nimitz";
obj.completed = 0;
}
,
func(pp, obj, u){
printf("%-5d : %s",pp.data_index, u.Callsign.getValue());
if (u.Callsign.getValue() == obj.search)
obj.designated = pp.data_index;
return 1;
},
func(pp, obj, data)
{
obj.completed = 1;
printf("Completed: %s = %d\n", obj.search, obj.designated);
}
);
if (obj.completed)
break;
}
if (!obj.completed)
print("partial list processed");
}
pptest();
125 lines
4.7 KiB
Text
125 lines
4.7 KiB
Text
#---------------------------------------------------------------------------
|
|
#
|
|
# Title : Frame Utils
|
|
#
|
|
# File Type : Implementation File
|
|
#
|
|
# Description : Objects related to frame processing
|
|
#
|
|
# Author : Richard Harrison (richard@zaretto.com)
|
|
#
|
|
# Creation Date : 05-05-2019
|
|
#
|
|
# Version : 1.0
|
|
#
|
|
# Copyright (C) 2019 Richard Harrison Released under GPL V2
|
|
#
|
|
#---------------------------------------------------------------------------*/
|
|
|
|
|
|
#---------------------------------------------------------------------------*/
|
|
# Partition data and process
|
|
#
|
|
# This manages the processing of data in a manner suitable for real time
|
|
# operations. Given a data array [0..size] this will process a number
|
|
# of array elements each time it is called This allows for a simple way
|
|
# to split up intensive processing across multiple frames.
|
|
#
|
|
# The limit is the number of elements to process per invocation.
|
|
# A future improvement will be to also limit the
|
|
# maximum amount of time to spend processing
|
|
#
|
|
# Usually one of more instances of this class will be contained within
|
|
# another object, however this will work equally well in global space.
|
|
#
|
|
# example usage (object);
|
|
#
|
|
# var VSD_Device =
|
|
# {
|
|
# new : func(designation, model_element, target_module_id, root_node)
|
|
# {
|
|
# ...
|
|
# obj.process_targets = PartitionProcessor.new("VSD-targets", 20, nil);
|
|
# obj.process_targets.set_max_time_usec(500);
|
|
# ...
|
|
# me.process_targets.set_timestamp(notification.Timestamp);
|
|
#
|
|
# then invoke.
|
|
# me.process_targets.process(me, awg_9.tgts_list,
|
|
# func(pp, obj, data){
|
|
# # initialisation; called before processing element[0]
|
|
# # params
|
|
# # pp is the partition processor that called this
|
|
# # obj is the reference object (first argument in the .process)
|
|
# # data is the entire data array.
|
|
# }
|
|
# ,
|
|
# func(pp, obj, element){
|
|
# # proces individual element;
|
|
# # params
|
|
# # pp is the partition processor that called this
|
|
# # obj is the reference object (first argument in the .process)
|
|
# # element is the element data[pp.data_index]
|
|
# # return 0 to stop processing any more elements and call the completed method
|
|
# # return 1 to continue processing.
|
|
# },
|
|
# func(pp, obj, data)
|
|
# {
|
|
# # completed; called after the last element processed
|
|
# # params
|
|
# # pp is the partition processor that called this
|
|
# # obj is the reference object (first argument in the .process)
|
|
# # data is the entire data array.
|
|
# });
|
|
|
|
var PartitionProcessor =
|
|
{
|
|
new : func(_name, _size){
|
|
var obj = {
|
|
parents : [PartitionProcessor],
|
|
data_index : 0,
|
|
ppos : 0,
|
|
name : _name,
|
|
end : 0,
|
|
partition_size : _size,
|
|
};
|
|
return obj;
|
|
},
|
|
|
|
process : func (object, data, init_method, process_method, complete_method){
|
|
|
|
if (me.end != size(data)) {
|
|
# data changed during processing restart at the beginning.
|
|
me.data_index = 0;
|
|
}
|
|
|
|
if (me.data_index == 0) {
|
|
me.end = size(data);
|
|
init_method(me, object, data);
|
|
}
|
|
|
|
if (me.end == 0)
|
|
return;
|
|
|
|
me.start_pos = me.data_index;
|
|
|
|
for (me.ppos=0;me.ppos < me.partition_size; me.ppos += 1) {
|
|
if (me.data_index >= me.end) {
|
|
complete_method(me, object, data);
|
|
me.data_index = 0;
|
|
return;
|
|
}
|
|
if (!process_method(me, object, data[me.data_index])) {
|
|
complete_method(me, object, data);
|
|
me.data_index = 0;
|
|
return; # halt processing requested.
|
|
} else
|
|
me.data_index += 1;
|
|
|
|
if (me.data_index == me.start_pos) {
|
|
complete_method(me, object, data);
|
|
return;
|
|
}
|
|
}
|
|
},
|
|
};
|