1// Copyright 2018 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include <lib/zx/channel.h>
6#include <lib/zx/event.h>
7#include <lib/zx/eventpair.h>
8#include <lib/zx/fifo.h>
9#include <lib/zx/job.h>
10#include <lib/zx/port.h>
11#include <lib/zx/process.h>
12#include <lib/zx/thread.h>
13#include <lib/zx/vmar.h>
14#include <perftest/perftest.h>
15
16namespace {
17
18// These tests measure the times taken to create and close various types of
19// Zircon handle.  Strictly speaking, they test creating Zircon objects as
20// well as creating handles.
21//
22// In each test, closing the handles is done implicitly by destructors.
23
24bool ChannelCreateTest(perftest::RepeatState* state) {
25    state->DeclareStep("create");
26    state->DeclareStep("close");
27    while (state->KeepRunning()) {
28        zx::channel handle1;
29        zx::channel handle2;
30        ZX_ASSERT(zx::channel::create(0, &handle1, &handle2) == ZX_OK);
31        state->NextStep();
32    }
33    return true;
34}
35
36bool EventCreateTest(perftest::RepeatState* state) {
37    state->DeclareStep("create");
38    state->DeclareStep("close");
39    while (state->KeepRunning()) {
40        zx::event handle;
41        ZX_ASSERT(zx::event::create(0, &handle) == ZX_OK);
42        state->NextStep();
43    }
44    return true;
45}
46
47bool EventPairCreateTest(perftest::RepeatState* state) {
48    state->DeclareStep("create");
49    state->DeclareStep("close");
50    while (state->KeepRunning()) {
51        zx::eventpair handle1;
52        zx::eventpair handle2;
53        ZX_ASSERT(zx::eventpair::create(0, &handle1, &handle2) == ZX_OK);
54        state->NextStep();
55    }
56    return true;
57}
58
59bool FifoCreateTest(perftest::RepeatState* state) {
60    state->DeclareStep("create");
61    state->DeclareStep("close");
62    while (state->KeepRunning()) {
63        zx::fifo handle1;
64        zx::fifo handle2;
65        const uint32_t kElementCount = 2;
66        const uint32_t kElementSize = 2048;
67        ZX_ASSERT(zx::fifo::create(kElementCount, kElementSize, 0, &handle1,
68                                   &handle2) == ZX_OK);
69        state->NextStep();
70    }
71    return true;
72}
73
74bool PortCreateTest(perftest::RepeatState* state) {
75    state->DeclareStep("create");
76    state->DeclareStep("close");
77    while (state->KeepRunning()) {
78        zx::port handle;
79        ZX_ASSERT(zx::port::create(0, &handle) == ZX_OK);
80        state->NextStep();
81    }
82    return true;
83}
84
85// Note that this only creates a Zircon process object.  It does not start
86// the process.
87bool ProcessCreateTest(perftest::RepeatState* state) {
88    state->DeclareStep("create");
89    state->DeclareStep("close");
90    while (state->KeepRunning()) {
91        zx::process process;
92        zx::vmar root_vmar;
93        static const char kName[] = "perftest-process";
94        ZX_ASSERT(zx::process::create(
95                      *zx::job::default_job(), kName, sizeof(kName) - 1, 0,
96                      &process, &root_vmar) == ZX_OK);
97        state->NextStep();
98    }
99    return true;
100}
101
102// Note that this only creates a Zircon thread object.  It does not start
103// the thread.
104bool ThreadCreateTest(perftest::RepeatState* state) {
105    state->DeclareStep("create");
106    state->DeclareStep("close");
107    while (state->KeepRunning()) {
108        zx::thread handle;
109        static const char kName[] = "perftest-process";
110        ZX_ASSERT(zx::thread::create(*zx::process::self(), kName,
111                                     sizeof(kName) - 1, 0, &handle) == ZX_OK);
112        state->NextStep();
113    }
114    return true;
115}
116
117bool VmoCreateTest(perftest::RepeatState* state) {
118    state->DeclareStep("create");
119    state->DeclareStep("close");
120    while (state->KeepRunning()) {
121        zx::vmo handle;
122        const size_t kSizeInBytes = 64 * 1024;
123        ZX_ASSERT(zx::vmo::create(kSizeInBytes, 0, &handle) == ZX_OK);
124        state->NextStep();
125    }
126    return true;
127}
128
129void RegisterTests() {
130    perftest::RegisterTest("HandleCreate_Channel", ChannelCreateTest);
131    perftest::RegisterTest("HandleCreate_Event", EventCreateTest);
132    perftest::RegisterTest("HandleCreate_EventPair", EventPairCreateTest);
133    perftest::RegisterTest("HandleCreate_Fifo", FifoCreateTest);
134    perftest::RegisterTest("HandleCreate_Port", PortCreateTest);
135    perftest::RegisterTest("HandleCreate_Process", ProcessCreateTest);
136    perftest::RegisterTest("HandleCreate_Thread", ThreadCreateTest);
137    perftest::RegisterTest("HandleCreate_Vmo", VmoCreateTest);
138}
139PERFTEST_CTOR(RegisterTests);
140
141}  // namespace
142