forked from OSchip/llvm-project
331 lines
9.6 KiB
C++
331 lines
9.6 KiB
C++
//===-- sketch.cpp ----------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
|
|
#include "lldb-perf/lib/Measurement.h"
|
|
#include "lldb-perf/lib/Metric.h"
|
|
#include "lldb-perf/lib/TestCase.h"
|
|
#include "lldb-perf/lib/Timer.h"
|
|
#include "lldb-perf/lib/Xcode.h"
|
|
|
|
#include <fstream>
|
|
#include <getopt.h>
|
|
#include <iostream>
|
|
#include <unistd.h>
|
|
|
|
using namespace lldb_perf;
|
|
|
|
static struct option g_long_options[] = {
|
|
{"verbose", no_argument, NULL, 'v'},
|
|
{"sketch", required_argument, NULL, 'c'},
|
|
{"foobar", required_argument, NULL, 'f'},
|
|
{"out-file", required_argument, NULL, 'o'},
|
|
{NULL, 0, NULL, 0}};
|
|
|
|
class SketchTest : public TestCase {
|
|
public:
|
|
SketchTest()
|
|
: m_fetch_frames_measurement(
|
|
[this]() -> void {
|
|
Xcode::FetchFrames(GetProcess(), false, false);
|
|
},
|
|
"fetch-frames",
|
|
"time to dump backtrace for every frame in every thread"),
|
|
m_file_line_bp_measurement(
|
|
[this](const char *file, uint32_t line) -> void {
|
|
Xcode::CreateFileLineBreakpoint(GetTarget(), file, line);
|
|
},
|
|
"file-line-bkpt", "time to set a breakpoint given a file and line"),
|
|
m_fetch_modules_measurement(
|
|
[this]() -> void { Xcode::FetchModules(GetTarget()); },
|
|
"fetch-modules", "time to get info for all modules in the process"),
|
|
m_fetch_vars_measurement(
|
|
[this](int depth) -> void {
|
|
SBProcess process(GetProcess());
|
|
auto threads_count = process.GetNumThreads();
|
|
for (size_t thread_num = 0; thread_num < threads_count;
|
|
thread_num++) {
|
|
SBThread thread(process.GetThreadAtIndex(thread_num));
|
|
SBFrame frame(thread.GetFrameAtIndex(0));
|
|
Xcode::FetchVariables(frame, depth, GetVerbose());
|
|
}
|
|
},
|
|
"fetch-vars",
|
|
"time to dump variables for the topmost frame in every thread"),
|
|
m_run_expr_measurement(
|
|
[this](SBFrame frame, const char *expr) -> void {
|
|
SBValue value(
|
|
frame.EvaluateExpression(expr, lldb::eDynamicCanRunTarget));
|
|
Xcode::FetchVariable(value, 0, GetVerbose());
|
|
},
|
|
"run-expr",
|
|
"time to evaluate an expression and display the result") {
|
|
m_app_path.clear();
|
|
m_out_path.clear();
|
|
m_doc_path.clear();
|
|
m_print_help = false;
|
|
}
|
|
|
|
virtual ~SketchTest() {}
|
|
|
|
virtual bool ParseOption(int short_option, const char *optarg) {
|
|
switch (short_option) {
|
|
case 0:
|
|
return false;
|
|
|
|
case -1:
|
|
return false;
|
|
|
|
case '?':
|
|
case 'h':
|
|
m_print_help = true;
|
|
break;
|
|
|
|
case 'v':
|
|
SetVerbose(true);
|
|
break;
|
|
|
|
case 'c': {
|
|
SBFileSpec file(optarg);
|
|
if (file.Exists())
|
|
SetExecutablePath(optarg);
|
|
else
|
|
fprintf(stderr, "error: file specified in --sketch (-c) option doesn't "
|
|
"exist: '%s'\n",
|
|
optarg);
|
|
} break;
|
|
|
|
case 'f': {
|
|
SBFileSpec file(optarg);
|
|
if (file.Exists())
|
|
SetDocumentPath(optarg);
|
|
else
|
|
fprintf(stderr, "error: file specified in --foobar (-f) option doesn't "
|
|
"exist: '%s'\n",
|
|
optarg);
|
|
} break;
|
|
|
|
case 'o':
|
|
SetResultFilePath(optarg);
|
|
break;
|
|
|
|
default:
|
|
m_print_help = true;
|
|
fprintf(stderr, "error: unrecognized option %c\n", short_option);
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
virtual struct option *GetLongOptions() { return g_long_options; }
|
|
|
|
virtual bool Setup(int &argc, const char **&argv) {
|
|
TestCase::Setup(argc, argv);
|
|
bool error = false;
|
|
|
|
if (GetExecutablePath() == NULL) {
|
|
// --sketch is mandatory
|
|
error = true;
|
|
fprintf(stderr, "error: the '--sketch=PATH' option is mandatory\n");
|
|
}
|
|
|
|
if (GetDocumentPath() == NULL) {
|
|
// --foobar is mandatory
|
|
error = true;
|
|
fprintf(stderr, "error: the '--foobar=PATH' option is mandatory\n");
|
|
}
|
|
|
|
if (error || GetPrintHelp()) {
|
|
puts(R"(
|
|
NAME
|
|
lldb_perf_sketch -- a tool that measures LLDB peformance while debugging sketch.
|
|
|
|
SYNOPSIS
|
|
lldb_perf_sketch --sketch=PATH --foobar=PATH [--out-file=PATH --verbose]
|
|
|
|
DESCRIPTION
|
|
Runs a set of static timing and memory tasks against sketch and outputs results
|
|
to a plist file.
|
|
)");
|
|
}
|
|
|
|
if (error) {
|
|
exit(1);
|
|
}
|
|
lldb::SBLaunchInfo launch_info = GetLaunchInfo();
|
|
m_target = m_debugger.CreateTarget(m_app_path.c_str());
|
|
m_file_line_bp_measurement("SKTDocument.m", 245);
|
|
m_file_line_bp_measurement("SKTDocument.m", 283);
|
|
m_file_line_bp_measurement("SKTText.m", 326);
|
|
return Launch(launch_info);
|
|
}
|
|
|
|
lldb::SBLaunchInfo GetLaunchInfo() {
|
|
const char *file_arg = m_doc_path.c_str();
|
|
const char *persist_arg = "-ApplePersistenceIgnoreState";
|
|
const char *persist_skip = "YES";
|
|
const char *empty = nullptr;
|
|
const char *args[] = {file_arg, persist_arg, persist_skip, empty};
|
|
return SBLaunchInfo(args);
|
|
}
|
|
|
|
void DoTest() {
|
|
m_fetch_frames_measurement();
|
|
m_fetch_modules_measurement();
|
|
m_fetch_vars_measurement(1);
|
|
}
|
|
|
|
virtual void TestStep(int counter, ActionWanted &next_action) {
|
|
static int launch = 1;
|
|
switch (counter % 10) {
|
|
case 0: {
|
|
DoTest();
|
|
if (counter == 0)
|
|
m_file_line_bp_measurement("SKTDocument.m", 254);
|
|
next_action.Continue();
|
|
} break;
|
|
|
|
case 1: {
|
|
DoTest();
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "properties");
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0),
|
|
"[properties description]");
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "typeName");
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "data");
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "[data description]");
|
|
next_action.Continue();
|
|
} break;
|
|
|
|
case 2: {
|
|
DoTest();
|
|
next_action.Continue();
|
|
} break;
|
|
|
|
case 3: {
|
|
DoTest();
|
|
next_action.StepOver(m_thread);
|
|
} break;
|
|
|
|
case 4: {
|
|
DoTest();
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "layoutManager");
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "contents");
|
|
next_action.StepOver(m_thread);
|
|
} break;
|
|
|
|
case 5: {
|
|
DoTest();
|
|
next_action.StepOver(m_thread);
|
|
} break;
|
|
|
|
case 6: {
|
|
DoTest();
|
|
next_action.StepOver(m_thread);
|
|
} break;
|
|
|
|
case 7: {
|
|
DoTest();
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "@\"an NSString\"");
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0),
|
|
"[(id)@\"an NSString\" description]");
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0), "@[@1,@2,@3]");
|
|
next_action.StepOut(m_thread);
|
|
} break;
|
|
|
|
case 8: {
|
|
DoTest();
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0),
|
|
"[graphics description]");
|
|
m_run_expr_measurement(m_thread.GetFrameAtIndex(0),
|
|
"[selectionIndexes description]");
|
|
m_run_expr_measurement(
|
|
m_thread.GetFrameAtIndex(0),
|
|
"(BOOL)NSIntersectsRect(rect, graphicDrawingBounds)");
|
|
}
|
|
next_action.CallNext();
|
|
break;
|
|
case 9:
|
|
if (++launch < 10)
|
|
next_action.Relaunch(GetLaunchInfo());
|
|
else
|
|
next_action.Kill();
|
|
break;
|
|
|
|
default: { next_action.Kill(); } break;
|
|
}
|
|
}
|
|
|
|
virtual void WriteResults(Results &results) {
|
|
m_fetch_frames_measurement.WriteAverageAndStandardDeviation(results);
|
|
m_file_line_bp_measurement.WriteAverageAndStandardDeviation(results);
|
|
m_fetch_modules_measurement.WriteAverageAndStandardDeviation(results);
|
|
m_fetch_vars_measurement.WriteAverageAndStandardDeviation(results);
|
|
m_run_expr_measurement.WriteAverageAndStandardDeviation(results);
|
|
results.Write(GetResultFilePath());
|
|
}
|
|
|
|
void SetExecutablePath(const char *str) {
|
|
if (str)
|
|
m_app_path.assign(str);
|
|
}
|
|
|
|
const char *GetExecutablePath() {
|
|
if (m_app_path.empty())
|
|
return NULL;
|
|
return m_app_path.c_str();
|
|
}
|
|
|
|
void SetDocumentPath(const char *str) {
|
|
if (str)
|
|
m_doc_path.assign(str);
|
|
}
|
|
|
|
const char *GetDocumentPath() {
|
|
if (m_doc_path.empty())
|
|
return NULL;
|
|
return m_doc_path.c_str();
|
|
}
|
|
|
|
void SetResultFilePath(const char *str) {
|
|
if (str)
|
|
m_out_path.assign(str);
|
|
}
|
|
|
|
const char *GetResultFilePath() {
|
|
if (m_out_path.empty())
|
|
return "/dev/stdout";
|
|
return m_out_path.c_str();
|
|
}
|
|
|
|
bool GetPrintHelp() { return m_print_help; }
|
|
|
|
private:
|
|
Measurement<lldb_perf::TimeGauge, std::function<void()>>
|
|
m_fetch_frames_measurement;
|
|
Measurement<lldb_perf::TimeGauge, std::function<void(const char *, uint32_t)>>
|
|
m_file_line_bp_measurement;
|
|
Measurement<lldb_perf::TimeGauge, std::function<void()>>
|
|
m_fetch_modules_measurement;
|
|
Measurement<lldb_perf::TimeGauge, std::function<void(int)>>
|
|
m_fetch_vars_measurement;
|
|
Measurement<lldb_perf::TimeGauge, std::function<void(SBFrame, const char *)>>
|
|
m_run_expr_measurement;
|
|
|
|
std::string m_app_path;
|
|
std::string m_doc_path;
|
|
std::string m_out_path;
|
|
bool m_print_help;
|
|
};
|
|
|
|
int main(int argc, const char *argv[]) {
|
|
SketchTest test;
|
|
return TestCase::Run(test, argc, argv);
|
|
}
|