#include "LibLsp/JsonRpc/RemoteEndPoint.h" #include "LibLsp/JsonRpc/StreamMessageProducer.h" #include "LibLsp/lsp/ProtocolJsonHandler.h" #include "LibLsp/lsp/general/exit.h" #include "LibLsp/lsp/general/initialize.h" #include "LibLsp/lsp/utils.h" #include "LibLsp/lsp/working_files.h" #include "test_helpers.h" #include #include #include #include #include #include #include #include namespace { using test::CollectingIssueHandler; using test::DummyLog; using test::Expect; using test::MakeLspFrame; using test::StringOStream; int& PerfWarnings() { static int warnings = 0; return warnings; } class Timer { public: Timer() : start_(std::chrono::steady_clock::now()) { } double elapsedMs() const { auto const elapsed = std::chrono::steady_clock::now() - start_; return std::chrono::duration(elapsed).count(); } private: std::chrono::steady_clock::time_point start_; }; void EmitMetric(std::string const& name, int count, double elapsed_ms) { double const throughput = elapsed_ms > 0.0 ? (static_cast(count) * 1000.0 / elapsed_ms) : 0.0; std::cout << "PERF_METRIC name=" << name << " count=" << count << " elapsed_ms=" << elapsed_ms << " throughput_per_sec=" << throughput << std::endl; } void WarnIf(bool condition, std::string const& name, std::string const& reason, double value) { if (!condition) { return; } ++PerfWarnings(); std::cout << "PERF_WARN name=" << name << " reason=\"" << reason << "\" value=" << value << std::endl; } bool WaitForPerfOutputContaining(std::shared_ptr const& output_stream, std::string const& needle) { for (int i = 0; i < 200; ++i) { if (output_stream->snapshot().find(needle) != std::string::npos) { return true; } std::this_thread::sleep_for(std::chrono::milliseconds(5)); } return false; } bool WaitForCount(std::atomic const& value, int expected) { for (int i = 0; i < 200; ++i) { if (value.load(std::memory_order_relaxed) >= expected) { return true; } std::this_thread::sleep_for(std::chrono::milliseconds(5)); } return false; } void PerfStreamSmallFrames() { // Trend smoke for the buffered header path: many tiny frames should parse // quickly and report throughput without gating normal CTest. int const count = 10000; std::string input_data; input_data.reserve(static_cast(count) * 80); for (int i = 0; i < count; ++i) { input_data += MakeLspFrame(std::string(R"({"jsonrpc":"2.0","method":"small","seq":)") + std::to_string(i) + "}"); } std::istringstream input_storage(std::move(input_data)); auto input = lsp::make_istream(input_storage); CollectingIssueHandler issues; LSPStreamMessageProducer producer(issues, input); int delivered = 0; Timer timer; producer.listen( [&](std::string&&) { ++delivered; }); double const elapsed_ms = timer.elapsedMs(); Expect(delivered == count, "perf smoke stream.small_frames must deliver every frame"); EmitMetric("stream.small_frames", count, elapsed_ms); WarnIf(elapsed_ms > 1500.0, "stream.small_frames", "elapsed_ms exceeded smoke threshold", elapsed_ms); } void PerfStreamLargeBodies() { // Trend smoke for large body handling: reports throughput while correctness // stays guarded by the hard-fail stream tests. int const count = 256; std::string body = R"({"jsonrpc":"2.0","method":"large","payload":")"; body.append(8192, 'x'); body += "\"}"; std::string input_data; input_data.reserve((body.size() + 64) * static_cast(count)); for (int i = 0; i < count; ++i) { input_data += MakeLspFrame(body); } std::istringstream input_storage(std::move(input_data)); auto input = lsp::make_istream(input_storage); CollectingIssueHandler issues; LSPStreamMessageProducer producer(issues, input); int delivered = 0; Timer timer; producer.listen( [&](std::string&&) { ++delivered; }); double const elapsed_ms = timer.elapsedMs(); Expect(delivered == count, "perf smoke stream.large_bodies must deliver every frame"); EmitMetric("stream.large_bodies", count, elapsed_ms); WarnIf(elapsed_ms > 2000.0, "stream.large_bodies", "elapsed_ms exceeded smoke threshold", elapsed_ms); } void PerfRemoteEndpointDispatch() { // Measures end-to-end producer-to-worker dispatch for a burst of requests; // slow runs emit PERF_WARN instead of failing by default. DummyLog log; auto json_handler = std::make_shared(); auto endpoint = std::make_shared(log); int const count = 512; std::string input_data; input_data.reserve(static_cast(count) * 90); for (int i = 0; i < count; ++i) { input_data += MakeLspFrame( std::string(R"({"jsonrpc":"2.0","id":)") + std::to_string(10000 + i) + R"(,"method":"initialize","params":{}})"); } std::istringstream input_storage(std::move(input_data)); auto input_stream = lsp::make_istream(input_storage); auto output_stream = std::make_shared(); std::atomic handled {0}; RemoteEndPoint point(json_handler, endpoint, log, lsp::JSONStreamStyle::Standard, 4); point.registerHandler( [&](td_initialize::request const& req) -> lsp::ResponseOrError { handled.fetch_add(1, std::memory_order_relaxed); td_initialize::response rsp; rsp.id = req.id; return rsp; }); Timer timer; point.startProcessingMessages(input_stream, output_stream); bool const handled_every_request = WaitForCount(handled, count); bool const got_last_response = WaitForPerfOutputContaining(output_stream, "\"id\":" + std::to_string(10000 + count - 1)); double const elapsed_ms = timer.elapsedMs(); point.stop(); Expect(got_last_response, "perf smoke remote.dispatch must receive the last response"); Expect(handled_every_request, "perf smoke remote.dispatch must handle every request"); EmitMetric("remote.dispatch", count, elapsed_ms); WarnIf(elapsed_ms > 2500.0, "remote.dispatch", "elapsed_ms exceeded smoke threshold", elapsed_ms); } double RunRemoteEndpointLargeJsonNotifications(int workers) { DummyLog log; auto json_handler = std::make_shared(); auto endpoint = std::make_shared(log); int const count = 256; std::string body = R"({"jsonrpc":"2.0","method":"exit","params":{"payload":")"; body.append(32768, 'x'); body += R"("}})"; std::string input_data; input_data.reserve((body.size() + 64) * static_cast(count)); for (int i = 0; i < count; ++i) { input_data += MakeLspFrame(body); } std::istringstream input_storage(std::move(input_data)); auto input_stream = lsp::make_istream(input_storage); auto output_stream = std::make_shared(); std::atomic handled {0}; RemoteEndPoint point(json_handler, endpoint, log, lsp::JSONStreamStyle::Standard, static_cast(workers)); point.registerHandler( [&](Notify_Exit::notify const&) { handled.fetch_add(1, std::memory_order_relaxed); }); Timer timer; point.startProcessingMessages(input_stream, output_stream); bool const handled_every_notification = WaitForCount(handled, count); double const elapsed_ms = timer.elapsedMs(); point.stop(); Expect(handled_every_notification, "perf smoke remote.large_json_notifications must handle every notification"); EmitMetric("remote.large_json_notifications.workers" + std::to_string(workers), count, elapsed_ms); return elapsed_ms; } void PerfRemoteEndpointLargeJsonNotifications() { // Exercises the full RemoteEndPoint path for large notification bodies, // comparing one worker against a parsing pool to track the expected parallelism. double const one_worker_ms = RunRemoteEndpointLargeJsonNotifications(1); double const four_workers_ms = RunRemoteEndpointLargeJsonNotifications(4); double const speedup = four_workers_ms > 0.0 ? one_worker_ms / four_workers_ms : 0.0; std::cout << "PERF_COMPARE name=remote.large_json_notifications speedup=" << speedup << "x" << " workers1_ms=" << one_worker_ms << " workers4_ms=" << four_workers_ms << std::endl; WarnIf( four_workers_ms > one_worker_ms * 1.5, "remote.large_json_notifications", "four-worker parsing slower than one-worker baseline", four_workers_ms); } void PerfWorkingFilesRangeEdits() { // Measures repeated tail edits on a large file to watch line-index rebuild // cost without using a flaky default wall-clock assertion. WorkingFiles files; AbsolutePath path("/tmp/lspcpp-working-files-perf-smoke.cpp"); std::string text; for (int i = 0; i < 20000; ++i) { text += "line "; text += std::to_string(i); text += "\n"; } lsTextDocumentItem open; open.uri = lsDocumentUri(path); open.languageId = "cpp"; open.version = 1; open.text = text; auto file = files.OnOpen(open); Expect(file->LineOffsetCountForTest() == 20001, "perf smoke WorkingFiles must build line offset index"); int const edits = 1000; Timer timer; for (int i = 0; i < edits; ++i) { lsTextDocumentDidChangeParams change; change.textDocument.uri = lsDocumentUri(path); change.textDocument.version = optional(i + 2); lsTextDocumentContentChangeEvent edit; edit.range = lsRange(lsPosition(19999, 5), lsPosition(19999, 9)); edit.text = "tail"; change.contentChanges.push_back(edit); files.OnChange(change); } double const elapsed_ms = timer.elapsedMs(); Expect(file->LineOffsetCountForTest() == 20001, "perf smoke WorkingFiles must keep line offset index rebuilt"); EmitMetric("working_files.range_edits", edits, elapsed_ms); WarnIf(elapsed_ms > 3000.0, "working_files.range_edits", "elapsed_ms exceeded smoke threshold", elapsed_ms); } void PerfWorkingFilesOffsetLookupComparison() { // Micro-benchmark: same tail position as ranged edit start/end, comparing // utils::GetOffsetForPosition (scan from BOF) vs WorkingFile line_offsets. int const line_count = 20000; int const iterations = 1000; int const lookups_per_iteration = 2; std::string text; text.reserve(static_cast(line_count) * 16); for (int i = 0; i < line_count; ++i) { text += "line "; text += std::to_string(i); text += "\n"; } WorkingFiles files; AbsolutePath path("/tmp/lspcpp-working-files-offset-perf.cpp"); lsTextDocumentItem open; open.uri = lsDocumentUri(path); open.languageId = "cpp"; open.version = 1; open.text = text; auto file = files.OnOpen(open); lsPosition const start_pos(19999, 5); lsPosition const end_pos(19999, 9); int const uncached_start = lsp::GetOffsetForPosition(start_pos, text); int const uncached_end = lsp::GetOffsetForPosition(end_pos, text); int const cached_start = file->GetOffsetForPosition(start_pos); int const cached_end = file->GetOffsetForPosition(end_pos); Expect(uncached_start == cached_start, "perf smoke cached start offset must match uncached"); Expect(uncached_end == cached_end, "perf smoke cached end offset must match uncached"); int const total_lookups = iterations * lookups_per_iteration; Timer uncached_timer; for (int i = 0; i < iterations; ++i) { (void)lsp::GetOffsetForPosition(start_pos, text); (void)lsp::GetOffsetForPosition(end_pos, text); } double const uncached_ms = uncached_timer.elapsedMs(); Timer cached_timer; for (int i = 0; i < iterations; ++i) { (void)file->GetOffsetForPosition(start_pos); (void)file->GetOffsetForPosition(end_pos); } double const cached_ms = cached_timer.elapsedMs(); EmitMetric("working_files.offset_lookup.uncached", total_lookups, uncached_ms); EmitMetric("working_files.offset_lookup.cached", total_lookups, cached_ms); double const speedup = cached_ms > 0.0 ? uncached_ms / cached_ms : 0.0; std::cout << "PERF_COMPARE name=working_files.offset_lookup speedup=" << speedup << "x" << " uncached_ms=" << uncached_ms << " cached_ms=" << cached_ms << std::endl; Expect(speedup >= 1.0, "perf smoke cached offset lookup must not be slower than uncached scan"); WarnIf(speedup < 5.0, "working_files.offset_lookup", "cached speedup below 5x smoke threshold", speedup); } } // namespace int main(int argc, char** argv) { test::InitTestFilter(argc, argv); RUN_TEST(PerfStreamSmallFrames); RUN_TEST(PerfStreamLargeBodies); RUN_TEST(PerfRemoteEndpointDispatch); RUN_TEST(PerfRemoteEndpointLargeJsonNotifications); RUN_TEST(PerfWorkingFilesRangeEdits); RUN_TEST(PerfWorkingFilesOffsetLookupComparison); #ifdef LSPCPP_PERF_WARNINGS_AS_ERRORS if (PerfWarnings() != 0) { return 1; } #endif return test::Failures() == 0 ? 0 : 1; } .