| // Copyright 2018 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. | |
| #include <lib/syslog/cpp/macros.h> | |
| #include <lib/trace-provider/provider.h> | |
| #include <lib/zx/time.h> | |
| #include <zircon/status.h> | |
| #include <memory> | |
| #include "src/performance/trace/tests/basic_integration_tests.h" | |
| namespace tracing::test { | |
| namespace { | |
| const char kFillBufferProviderName[] = "fill-buffer"; | |
| bool RunFillBufferTest(size_t buffer_size_in_mb, const std::string& buffering_mode) { | |
| async::Loop loop(&kAsyncLoopConfigNoAttachToCurrentThread); | |
| // If we're streaming then we need intermediate buffer saving to be acted on while we're | |
| // writing the buffer. So run the provider loop in the background. | |
| loop.StartThread(); | |
| std::unique_ptr<trace::TraceProvider> provider; | |
| bool already_started; | |
| if (!CreateProviderSynchronously(loop, kFillBufferProviderName, &provider, &already_started)) { | |
| return false; | |
| } | |
| // The program may not be being run under tracing. If it is tracing should have already started. | |
| // Things are a little different because the provider loop is running in the background. | |
| if (already_started) { | |
| // At this point we're registered with trace-manager, and we know tracing | |
| // has started. But we haven't received the Start() request yet, which | |
| // contains the trace buffer (as a vmo) and other things. So wait for it. | |
| async::Loop wait_loop(&kAsyncLoopConfigNoAttachToCurrentThread); | |
| if (!WaitForTracingToStart(wait_loop, kStartTimeout)) { | |
| FX_LOGS(ERROR) << "Provider " << kFillBufferProviderName | |
| << " failed waiting for tracing to start"; | |
| return false; | |
| } | |
| } | |
| // Generate at least 4MB of test records. | |
| // This stress tests streaming mode buffer saving (with buffer size of 1MB). | |
| constexpr size_t kMinNumBuffersFilled = 4; | |
| FillBuffer(kMinNumBuffersFilled, buffer_size_in_mb); | |
| loop.Quit(); | |
| loop.JoinThreads(); | |
| // The loop is no longer running at this point. This is ok as the engine doesn't need the loop | |
| // to finish writing to the buffer: Tracing will be terminated when |provider| goes out of | |
| // scope. But this is something to be aware of. | |
| return true; | |
| } | |
| bool VerifyFillBufferTest(size_t buffer_size_in_mb, const std::string& buffering_mode, | |
| const std::string& test_output_file) { | |
| const tracing::BufferingModeSpec* mode_spec = tracing::LookupBufferingMode(buffering_mode); | |
| if (mode_spec == nullptr) { | |
| FX_LOGS(ERROR) << "Bad buffering mode: " << buffering_mode; | |
| return false; | |
| } | |
| return VerifyFullBuffer(test_output_file, mode_spec->mode, buffer_size_in_mb); | |
| } | |
| } // namespace | |
| const IntegrationTest kFillBufferIntegrationTest = { | |
| kFillBufferProviderName, | |
| &RunFillBufferTest, // for run command | |
| &VerifyFillBufferTest, // for verify command | |
| }; | |
| } // namespace tracing::test |