lldb-perf-stepping.cpp [plain text]
#include <CoreFoundation/CoreFoundation.h>
#include "lldb-perf/lib/Timer.h"
#include "lldb-perf/lib/Metric.h"
#include "lldb-perf/lib/Measurement.h"
#include "lldb-perf/lib/TestCase.h"
#include "lldb-perf/lib/Xcode.h"
#include <unistd.h>
#include <string>
#include <getopt.h>
using namespace lldb_perf;
class StepTest : public TestCase
{
typedef void (*no_function) (void);
public:
StepTest(bool use_single_stepping = false) :
m_main_source("stepping-testcase.cpp"),
m_use_single_stepping(use_single_stepping),
m_time_measurements(nullptr)
{
}
virtual
~StepTest() {}
virtual bool
Setup (int& argc, const char**& argv)
{
TestCase::Setup (argc, argv);
const char *single_step_cmd = "settings set target.use-fast-stepping false";
const char *fast_step_cmd = "settings set target.use-fast-stepping true";
const char *cmd_to_use;
if (m_use_single_stepping)
cmd_to_use = single_step_cmd;
else
cmd_to_use = fast_step_cmd;
SBCommandReturnObject return_object;
m_debugger.GetCommandInterpreter().HandleCommand(cmd_to_use,
return_object);
if (!return_object.Succeeded())
{
if (return_object.GetError() != NULL)
printf ("Got an error running settings set: %s.\n", return_object.GetError());
else
printf ("Failed running settings set, no error.\n");
}
m_target = m_debugger.CreateTarget(m_app_path.c_str());
m_first_bp = m_target.BreakpointCreateBySourceRegex("Here is some code to stop at originally.", m_main_source);
const char* file_arg = m_app_path.c_str();
const char* empty = nullptr;
const char* args[] = {file_arg, empty};
SBLaunchInfo launch_info (args);
return Launch (launch_info);
}
void
WriteResults (Results &results)
{
m_individual_step_times.push_back(m_time_measurements.Stop());
size_t num_time_measurements = m_individual_step_times.size();
Results::Dictionary& results_dict = results.GetDictionary();
const char *short_format_string = "step-time-%0.2d";
const size_t short_size = strlen(short_format_string) + 5;
char short_buffer[short_size];
const char *long_format_string = "The time it takes for step %d in the step sequence.";
const size_t long_size = strlen(long_format_string) + 5;
char long_buffer[long_size];
for (size_t i = 0; i < num_time_measurements; i++)
{
snprintf (short_buffer, short_size, short_format_string, i);
snprintf (long_buffer, long_size, long_format_string, i);
results_dict.AddDouble(short_buffer,
long_buffer,
m_individual_step_times[i]);
}
results_dict.AddDouble ("total-time", "Total time spent stepping.", m_time_measurements.GetMetric().GetSum());
results_dict.AddDouble ("stddev-time", "StdDev of time spent stepping.", m_time_measurements.GetMetric().GetStandardDeviation());
results.Write(m_out_path.c_str());
}
const char *
GetExecutablePath () const
{
if (m_app_path.empty())
return NULL;
return m_app_path.c_str();
}
const char *
GetResultFilePath () const
{
if (m_out_path.empty())
return NULL;
return m_out_path.c_str();
}
void
SetExecutablePath (const char *path)
{
if (path && path[0])
m_app_path = path;
else
m_app_path.clear();
}
void
SetResultFilePath (const char *path)
{
if (path && path[0])
m_out_path = path;
else
m_out_path.clear();
}
void
SetUseSingleStep (bool use_it)
{
m_use_single_stepping = use_it;
}
private:
virtual void
TestStep (int counter, ActionWanted &next_action)
{
if (counter > 0)
{
m_individual_step_times.push_back(m_time_measurements.Stop());
}
if (counter == 0)
m_first_bp.SetEnabled(false);
next_action.StepOver(m_process.GetThreadAtIndex(0));
m_time_measurements.Start();
}
SBBreakpoint m_first_bp;
SBFileSpec m_main_source;
TimeMeasurement<no_function> m_time_measurements;
std::vector<double> m_individual_step_times;
bool m_use_single_stepping;
std::string m_app_path;
std::string m_out_path;
};
struct Options
{
std::string test_file_path;
std::string out_file;
bool verbose;
bool fast_step;
bool error;
bool print_help;
Options() :
verbose (false),
fast_step (true),
error (false),
print_help (false)
{
}
};
static struct option g_long_options[] = {
{ "verbose", no_argument, NULL, 'v' },
{ "single-step", no_argument, NULL, 's' },
{ "test-file", required_argument, NULL, 't' },
{ "out-file", required_argument, NULL, 'o' },
{ NULL, 0, NULL, 0 }
};
std::string
GetShortOptionString (struct option *long_options)
{
std::string option_string;
for (int i = 0; long_options[i].name != NULL; ++i)
{
if (long_options[i].flag == NULL)
{
option_string.push_back ((char) long_options[i].val);
switch (long_options[i].has_arg)
{
default:
case no_argument:
break;
case required_argument:
option_string.push_back (':');
break;
case optional_argument:
option_string.append (2, ':');
break;
}
}
}
return option_string;
}
int main(int argc, const char * argv[])
{
std::string short_option_string (GetShortOptionString(g_long_options));
StepTest test;
Options option_data;
bool done = false;
#if __GLIBC__
optind = 0;
#else
optreset = 1;
optind = 1;
#endif
while (!done)
{
int long_options_index = -1;
const int short_option = ::getopt_long_only (argc,
const_cast<char **>(argv),
short_option_string.c_str(),
g_long_options,
&long_options_index);
switch (short_option)
{
case 0:
break;
case -1:
done = true;
break;
case '?':
option_data.print_help = true;
break;
case 'h':
option_data.print_help = true;
break;
case 'v':
option_data.verbose = true;
break;
case 's':
option_data.fast_step = false;
test.SetUseSingleStep(true);
break;
case 't':
{
SBFileSpec file(optarg);
if (file.Exists())
test.SetExecutablePath(optarg);
else
fprintf(stderr, "error: file specified in --test-file (-t) option doesn't exist: '%s'\n", optarg);
}
break;
case 'o':
test.SetResultFilePath(optarg);
break;
default:
option_data.error = true;
option_data.print_help = true;
fprintf (stderr, "error: unrecognized option %c\n", short_option);
break;
}
}
if (option_data.print_help)
{
puts(R"(
NAME
lldb-perf-stepping -- a tool that measures LLDB peformance of simple stepping operations.
SYNOPSIS
lldb-perf-stepping --test-file=FILE [--out-file=PATH --verbose --fast-step]
DESCRIPTION
Runs a set of stepping operations, timing each step and outputs results
to a plist file.
)");
exit(0);
}
if (option_data.error)
{
exit(1);
}
if (test.GetExecutablePath() == NULL)
{
option_data.print_help = true;
option_data.error = true;
fprintf (stderr, "error: the '--test-file=PATH' option is mandatory\n");
}
argc -= optind;
argv += optind;
test.SetVerbose(true);
TestCase::Run(test, argc, argv);
return 0;
}