def call(self, arg: CallArg, __, proxor: IProcessorAPI) -> CallResult:
return CallResult([
Call(arg + 1,
Address(actor='source', proc='feed'),
call_step=proxor.step_count + 10),
Call(arg, Address(processor='C', actor='compute', proc='data1'))
])
def parse_connection(configs: List[MockProcessorConfig], lines,
li_ref) -> None:
line = lines[li_ref[0]]
left, right = [x.strip() for x in line.split('->') if len(x)]
left_addr = Address.create_from_expression(left)
right_addr = Address.create_from_expression(right)
proc_config = find_proc_config(configs, left_addr)
proc_config.call_gen_configs.append(MockCallGenConfig(right_addr))
li_ref[0] = li_ref[0] + 1
while (li_ref[0] < len(lines)
and is_indent_level(3, lines[li_ref[0]])):
parse_connection_config() # TODO
li_ref[0] = li_ref[0] + 1
def call(self, arg: CallArg, _, proxor: IProcessorAPI) -> CallResult:
logging.warning('PONG - time: {}, pong'.format(repr_time(proxor.time)))
# Note that busy waiting still happens even though the simulation
# hardware of the pong agent is very slow (due to the sleep below)
time.sleep(0.2)
out_call = Call(arg, Address(processor='A', actor='ping'))
return CallResult([out_call])
def create_timer_call(self,
proxor: IProcessorAPI,
immediate: bool = False) -> Call:
call_step_count = int(proxor.frequency / self._timer_freq)
if call_step_count <= 0:
raise ValueError(
"Period freq {} to high for processor freq {}".format(
self._timer_freq, proxor.frequency))
call_step_count = call_step_count + self._jitter_call_steps(proxor)
call_step = (0 if immediate else (call_step_count + proxor.step_count))
return Call(None,
Address(actor=self._actor_name, proc=self.name),
call_step=call_step)
def call(self, arg: CallArg, _, __) -> CallResult:
return CallResult([Call(arg, Address(actor='ping'))])
def create_call() -> Call:
return Call(None, Address(actor='pong'))
def call(self, arg: CallArg, __, proxor: IProcessorAPI) -> CallResult:
result = [arg, self._actor.accum]
self._actor.accum = []
return CallResult([Call(result, Address(processor='D', actor='sink'))])
def call(self, arg: CallArg, __, proxor: IProcessorAPI) -> CallResult:
return CallResult([
Call(None, Address(actor='source', proc='feed')),
Call(1, Address(processor='C', actor='compute', proc='data2'))
], 4)
def compute_main(processor: Processor) -> None:
processor.add_actor(ComputeActor())
processor.put_calls(
[Call(None, Address(actor='compute', proc='send'), call_step=5)])
def create_call() -> Token:
return Call(None, Address(processor='B', actor='pong'))
def call(self, arg: CallArg, _, proxor: IProcessorAPI) -> CallResult:
return CallResult(
[Call(self._actor._value, Address(processor='C', actor='sink'))])
def call(self, arg: CallArg, __, proxor: IProcessorAPI) -> CallResult:
return CallResult([Call(arg, Address(processor='C', actor='sink'))],
random.randint(0, 5))
def pong_main(processor: Processor) -> None:
processor.add_actor(PongActor())
return [Address(actor='pong')]
def ping_main(processor: Processor) -> None:
processor.add_actor(PingActor(3))
processor.put_calls([Call(None, Address(actor='ping'))])
def call(self, arg: CallArg, __, proxor: IProcessorAPI) -> CallResult:
return CallResult([
Call(arg + 1, Address(actor='source', proc='feed')),
Call(arg, Address(processor='B', actor='sink'))
])
def source_main(processor: Processor) -> None:
processor.put_calls([
Call('OK',
Address(processor='B', actor='compute'),
call_step=random.randint(0, 10))
])
def source_main(processor: Processor) -> None:
processor.add_actor(SourceActor())
processor.put_calls([Call(0, Address(actor='source'))])
def actor_C_main(processor: Processor) -> None:
processor.add_actor(CountActor(target=Address(processor='A')))
processor.put_calls([Call(0, Address(actor='counter'))])
