133 lines
2.8 KiB
Plaintext
133 lines
2.8 KiB
Plaintext
type Parking {
|
|
ready: Channel<Int>
|
|
gate: Channel<Int>
|
|
}
|
|
|
|
sync_idle() (result: Bool) {
|
|
bench.ready(0)
|
|
port.blocking_pause(config.lifetime())
|
|
result = true
|
|
}
|
|
|
|
idle() () {
|
|
blocking(bench.ready(0))
|
|
bench.pause(config.lifetime())
|
|
}
|
|
|
|
async_idle() (result: Bool) {
|
|
idle()
|
|
result = true
|
|
}
|
|
|
|
identity(value: Int) (result: Int) {
|
|
result = value
|
|
}
|
|
|
|
task_sum(value: Int, state: Int) (result: Int) {
|
|
job = run(identity(value))
|
|
result = state + wait(job)
|
|
}
|
|
|
|
sum(value: Int, state: Int) (result: Int) {
|
|
result = state + value
|
|
}
|
|
|
|
task_sample(index: Int, input: Bytes) () {
|
|
begin = dever.time.monotonic_nanos()
|
|
checksum = reduce(task_sum, input, 0)
|
|
end = dever.time.monotonic_nanos()
|
|
blocking(bench.report(begin, end, "tasks", length(input), checksum))
|
|
}
|
|
|
|
send_byte(value: Int, output: Channel<Int>) () {
|
|
send(output, value)
|
|
}
|
|
|
|
produce(input: Bytes, output: Channel<Int>) () {
|
|
each(send_byte, input, output)
|
|
close(output)
|
|
}
|
|
|
|
channel_sample(index: Int, input: Bytes) () {
|
|
output = channel(Int, config.channel_capacity())
|
|
begin = dever.time.monotonic_nanos()
|
|
producer = run(produce(input, output))
|
|
checksum = reduce(sum, stream(output), 0)
|
|
wait(producer)
|
|
end = dever.time.monotonic_nanos()
|
|
blocking(bench.report(begin, end, "channels", length(input), checksum))
|
|
}
|
|
|
|
wait_one(value: Int, parking: Parking) () {
|
|
send(parking.ready, value)
|
|
signaled(receive(parking.gate))
|
|
}
|
|
|
|
signaled(value: Int) () {}
|
|
|
|
signaled(value: null) () {
|
|
blocking(port.report_error("channel closed before expected signal"))
|
|
}
|
|
|
|
hold(parking: Parking) () {
|
|
parallel_each(wait_one, config.pending_input(), config.pending(), parking)
|
|
}
|
|
|
|
started(value: Int, ready: Channel<Int>) () {
|
|
signaled(receive(ready))
|
|
}
|
|
|
|
cancel_worker() () {
|
|
parking = Parking {
|
|
ready = channel(Int, config.pending())
|
|
gate = channel(Int, 1)
|
|
}
|
|
job = run(hold(parking))
|
|
each(started, config.pending_input(), parking.ready)
|
|
blocking(bench.ready(config.pending()))
|
|
bench.pause(config.idle_sample_ms())
|
|
begin = dever.time.monotonic_nanos()
|
|
stop(job)
|
|
end = dever.time.monotonic_nanos()
|
|
close(parking.ready)
|
|
close(parking.gate)
|
|
blocking(bench.report(begin, end, "cancel", config.pending(), config.pending()))
|
|
}
|
|
|
|
task_worker() () {
|
|
input = config.input()
|
|
blocking(bench.ready(0))
|
|
each(task_sample, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], input)
|
|
}
|
|
|
|
channel_worker() () {
|
|
input = config.input()
|
|
blocking(bench.ready(0))
|
|
each(channel_sample, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], input)
|
|
}
|
|
|
|
tasks() (result: Bool) {
|
|
task_worker()
|
|
result = true
|
|
}
|
|
|
|
nested_task_worker() () {
|
|
job = run(task_worker())
|
|
wait(job)
|
|
}
|
|
|
|
tasks_on_worker() (result: Bool) {
|
|
nested_task_worker()
|
|
result = true
|
|
}
|
|
|
|
channels() (result: Bool) {
|
|
channel_worker()
|
|
result = true
|
|
}
|
|
|
|
cancel() (result: Bool) {
|
|
cancel_worker()
|
|
result = true
|
|
}
|