| {{/* |
| // Copyright 2022 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| */}} |
| |
| #![allow(unused_imports)] |
| use { |
| fidl::{ |
| encoding::{Context, Decode, Decoder, Encoder, with_tls_encode_buf, WireFormatVersion}, |
| handle::Handle, handle::HandleDisposition, handle::HandleInfo, handle::HandleOp, |
| ObjectType, Rights, |
| }, |
| fidl_test_benchmarkfidl{{ .CrateSuffix }} as test_benchmarkfidl{{ .CrateSuffix }}, |
| fuchsia_async as fasync, |
| fuchsia_criterion::criterion::{BatchSize, Bencher, black_box}, |
| futures::{future, stream::StreamExt}, |
| fuchsia_zircon as zx, |
| gidl_util::{HandleDef, HandleSubtype, copy_handle, create_handles, select_handle_infos}, |
| std::mem::ManuallyDrop |
| }; |
| |
| // BENCHMARKS is aggregated by a generated benchmark_suite.rs file, which is ultimately |
| // used in benchmarks in src/tests/benchmarks/fidl/rust/src/main.rs. |
| pub const BENCHMARKS: [(&'static str, fn(&mut Bencher)); {{ .NumBenchmarks }}] = [ |
| {{- range .Benchmarks }} |
| ("Builder/{{ .ChromeperfPath }}", benchmark_{{ .Name }}_builder), |
| ("Encode/{{ .ChromeperfPath }}", benchmark_{{ .Name }}_encode), |
| ("Decode/{{ .ChromeperfPath }}", benchmark_{{ .Name }}_decode), |
| {{ if .EnableSendEventBenchmark }} |
| ("SendEvent/{{ .ChromeperfPath }}", benchmark_{{ .Name }}_send_event), |
| {{- end -}} |
| {{ if .EnableEchoCallBenchmark }} |
| ("EchoCall/{{ .ChromeperfPath }}", benchmark_{{ .Name }}_echo_call), |
| {{- end -}} |
| {{- end }} |
| ]; |
| |
| const _V2_CONTEXT: Context = Context { wire_format_version: WireFormatVersion::V2 }; |
| |
| {{ range .Benchmarks }} |
| fn benchmark_{{ .Name }}_builder(b: &mut Bencher) { |
| {{- if .HandleDefs }} |
| b.iter_batched_ref( |
| || { |
| create_handles(&{{ .HandleDefs }}) |
| }, |
| |handle_defs| { |
| black_box({{ .Value }}); {{- /* semicolon: include drop time. */}} |
| }, |
| {{- /* Consider using LargeInput or NumIterations if this causes memory issues. */}} |
| BatchSize::SmallInput, |
| ); |
| {{- else }} |
| b.iter( |
| || { |
| black_box({{ .Value }}); {{- /* semicolon: include drop time. */}} |
| }, |
| ); |
| {{- end }} |
| } |
| |
| fn benchmark_{{ .Name }}_encode(b: &mut Bencher) { |
| b.iter_batched_ref( |
| || { |
| {{- if .HandleDefs }} |
| let handle_defs = create_handles(&{{ .HandleDefs }}); |
| {{- end }} |
| {{ .Value }} |
| }, |
| |value| { |
| {{- /* Encode to TLS buffers since that's what the bindings do in practice. */}} |
| with_tls_encode_buf(|bytes, handles| { |
| Encoder::encode_with_context::<{{ .ValueType }}>(_V2_CONTEXT, bytes, handles, {{ if not .IsResource }}&*{{ end }}value).unwrap(); |
| {{- /* Return the underlying heap storage of handles, since with_tls_encode_buf |
| clears it after calling this closure, which otherwise would close all the |
| handles. By returning the actual handles, we avoid including handle close |
| time in the benchmark. Note that this means the handle vector must reallocate |
| on every iteration if handles are used. */}} |
| {{- if .HandleDefs }} |
| std::mem::take(handles) |
| {{- end }} |
| }) {{- /* no semicolon: exclude drop time. */}} |
| }, |
| {{- /* Consider using LargeInput or NumIterations if this causes memory issues. */}} |
| BatchSize::SmallInput, |
| ); |
| } |
| |
| fn benchmark_{{ .Name }}_decode(b: &mut Bencher) { |
| b.iter_batched_ref( |
| || { |
| {{- if .HandleDefs }} |
| let handle_defs = create_handles(&{{ .HandleDefs }}); |
| {{- end }} |
| let mut bytes = Vec::<u8>::new(); |
| let mut handles = Vec::<HandleDisposition<'static>>::new(); |
| let original_value = &{{ if .IsResource}}mut {{ end }}{{ .Value }}; |
| Encoder::encode_with_context::<{{ .ValueType }}>(_V2_CONTEXT, &mut bytes, &mut handles, original_value).unwrap(); |
| let handle_infos = fidl::convert_handle_dispositions_to_infos(handles).unwrap(); |
| {{- /* Wrap handle in an Option to allow low-overhead measurement of drop time */}} |
| (bytes, handle_infos, ManuallyDrop::new(fidl::new_empty!({{ .ValueType }}))) |
| }, |
| |(bytes, handle_infos, manually_drop_value)| { |
| // Cast &mut ManuallyDrop<T> to &mut T. |
| let value : &mut {{ .ValueType }} = unsafe { std::mem::transmute(manually_drop_value as *mut _) }; |
| Decoder::decode_with_context::<{{ .ValueType }}>(_V2_CONTEXT, bytes, handle_infos, value).unwrap(); |
| // Count the drop time in the benchmark. |
| unsafe { ManuallyDrop::drop(manually_drop_value) }; |
| }, |
| {{- /* Consider using LargeInput or NumIterations if this causes memory issues. */}} |
| BatchSize::SmallInput, |
| ); |
| } |
| |
| {{ if .EnableSendEventBenchmark }} |
| async fn {{ .Name }}_send_event_receiver_thread(receiver_fidl_chan_end: zx::Channel, sender_fifo: std::sync::mpsc::SyncSender<()>) { |
| let async_receiver_fidl_chan_end = fasync::Channel::from_channel(receiver_fidl_chan_end); |
| let proxy = {{ .ValueType }}EventProtocolProxy::new(async_receiver_fidl_chan_end); |
| let mut event_stream = proxy.take_event_stream(); |
| while let Some(_event) = event_stream.next().await { |
| sender_fifo.send(()).unwrap(); |
| }; |
| } |
| |
| fn benchmark_{{ .Name }}_send_event(b: &mut Bencher) { |
| let thread; |
| { |
| let (sender_fifo, receiver_fifo) = std::sync::mpsc::sync_channel(1); |
| let (sender_fidl_chan_end, receiver_fidl_chan_end) = zx::Channel::create(); |
| thread = std::thread::spawn(|| { |
| fasync::LocalExecutor::new() |
| .run_singlethreaded(async move { |
| {{ .Name }}_send_event_receiver_thread(receiver_fidl_chan_end, sender_fifo).await; |
| }); |
| }); |
| fasync::LocalExecutor::new() |
| .run_singlethreaded(async move { |
| let async_sender_fidl_chan_end = fasync::Channel::from_channel(sender_fidl_chan_end); |
| let sender = <{{ .ValueType }}EventProtocolRequestStream as fidl::endpoints::RequestStream>::from_channel(async_sender_fidl_chan_end); |
| {{- if .IsResource }} |
| b.iter_batched(|| { |
| {{- else }} |
| b.iter_batched_ref(|| { |
| {{- end }} |
| {{- if .HandleDefs }} |
| let handle_defs = create_handles(&{{ .HandleDefs }}); |
| {{- end }} |
| {{ .Value }} |
| }, |
| |value| { |
| fidl::endpoints::RequestStream::control_handle(&sender).send_send_(value).unwrap(); |
| receiver_fifo.recv().unwrap(); |
| }, |
| BatchSize::SmallInput); |
| }); |
| } |
| thread.join().unwrap(); |
| } |
| {{- end -}} |
| |
| {{ if .EnableEchoCallBenchmark }} |
| async fn {{ .Name }}_echo_call_server_thread(server_end: zx::Channel) { |
| let async_server_end = fasync::Channel::from_channel(server_end); |
| let stream = <{{ .ValueType }}EchoCallRequestStream as fidl::endpoints::RequestStream>::from_channel(async_server_end); |
| const MAX_CONCURRENT: usize = 10; |
| stream.for_each_concurrent(MAX_CONCURRENT, |request| { |
| match request { |
| Ok({{ .ValueType }}EchoCallRequest::Echo { val, responder }) => { |
| responder.send({{ if not .IsResource }}&{{ end }} val).unwrap(); |
| }, |
| Err(_) => { |
| panic!("unexpected err request") |
| }, |
| } |
| future::ready(()) |
| }).await; |
| } |
| |
| fn benchmark_{{ .Name }}_echo_call(b: &mut Bencher) { |
| let thread; |
| { |
| let (client_end, server_end) = zx::Channel::create(); |
| thread = std::thread::spawn(|| { |
| fasync::LocalExecutor::new() |
| .run_singlethreaded(async move { |
| {{ .Name }}_echo_call_server_thread(server_end).await; |
| }); |
| }); |
| let proxy = {{ .ValueType }}EchoCallSynchronousProxy::new(client_end); |
| {{- if .IsResource }} |
| b.iter_batched(|| { |
| {{- else }} |
| b.iter_batched_ref(|| { |
| {{- end }} |
| {{- if .HandleDefs }} |
| let handle_defs = create_handles(&{{ .HandleDefs }}); |
| {{- end }} |
| {{ .Value }} |
| }, |
| |value| { |
| proxy.echo(value, zx::Time::after(zx::Duration::from_seconds(1))).unwrap(); |
| }, |
| BatchSize::SmallInput); |
| } |
| thread.join().unwrap(); |
| } |
| {{- end -}} |
| {{ end }} |
