refactoring

Author: nader-zouaoui

parser-tests/parser-tests.cpp

@@ -121,7 +121,7 @@ namespace parsertests
             parser.parse(argc, argv);
 
             Assert::IsTrue(parser.do_record.get());
-            Assert::AreEqual(std::wstring(L"notepad.exe test_arg"), parser.record_commandline);
+            Assert::AreEqual(std::wstring(L"notepad.exe test_arg"), parser.record_commandline.get());
             Assert::AreEqual(std::wstring(L"notepad.exe"), parser.sample_pe_file.get());
             Assert::AreEqual(std::wstring(L"notepad.pdb"), parser.sample_pdb_file.get());
             Assert::IsTrue(COMMAND_CLASS::RECORD == parser.command);

parser/arg-parser.cpp

@@ -50,27 +50,29 @@ void arg_parser::parse(
         arg_array.push_back(argv[i]);
 
     }
+    try_match_and_set_arg(raw_args, do_list);
+    try_match_and_set_arg(raw_args, do_help);
+    try_match_and_set_arg(raw_args, do_version);
+    try_match_and_set_arg(raw_args, do_test);
+    try_match_and_set_arg(raw_args, do_detect);
+    try_match_and_set_arg(raw_args, do_sample);
+    try_match_and_set_arg(raw_args, do_record);
+    try_match_and_set_arg(raw_args, do_count);
 
     while (raw_args.size() > 0)
     {
         size_t initial_size = raw_args.size();
         if (command == COMMAND_CLASS::NO_COMMAND) {
-            try_match_and_set_arg(raw_args, do_list);
-            try_match_and_set_arg(raw_args, do_help);
-            try_match_and_set_arg(raw_args, do_version);
-            try_match_and_set_arg(raw_args, do_test);
-            try_match_and_set_arg(raw_args, do_detect);
-            try_match_and_set_arg(raw_args, do_sample);
-            try_match_and_set_arg(raw_args, do_record);
-            try_match_and_set_arg(raw_args, do_count);
+            throw_invalid_arg(raw_args.front(), L"Error: at least one command is needed ");
         }
-
+        
         if (command == COMMAND_CLASS::SAMPLE || command == COMMAND_CLASS::RECORD)
             parse_sampling_args(raw_args);
+       
 
         if (commands_with_no_args.find(command) != commands_with_no_args.end()) goto standard_arguments;
 
-        if (try_match_and_set_bool_flag(raw_args, record_commandline_separator)) {
+        if (try_match_arg(raw_args, record_commandline)) {
             if (command != COMMAND_CLASS::RECORD && command != COMMAND_CLASS::STAT && command != COMMAND_CLASS::TIMELINE && command != COMMAND_CLASS::SPE)
                 throw_invalid_arg(raw_args.front(), L"warning: only `stat` and `record` support process spawn!");
 
@@ -203,17 +205,43 @@ void arg_parser::parse_sampling_args(wstr_vec& raw_args_vect)
             raw_args_vect.erase(raw_args_vect.begin());
         }
 
+        if (try_match_arg(raw_args_vect, events_string)) {
+            check_flag_value_existance(raw_args_vect);
+
+            raw_args_vect.erase(raw_args_vect.begin());
+
+        }
+
         if (initial_size == raw_args_vect.size()) break;
     }
 }
 
+void arg_parser::parse_event_list(wstring i_events) {
+    events_string.value = i_events;
+    if (command == COMMAND_CLASS::SAMPLE || command == COMMAND_CLASS::RECORD) {
+        if (i_events.rfind(ARM_SPE_EVENT_PREFIX)) command = COMMAND_CLASS::SPE;
+
+        if (i_events.rfind(L"{") != std::wstring::npos) {
+            throw_invalid_arg(L"{", L"Error: Event groups are only available in the stat command");
+        }
+    }
+    if (command == COMMAND_CLASS::STAT) {
+        if (i_events.rfind(ARM_SPE_EVENT_PREFIX)) 
+            throw_invalid_arg(ARM_SPE_EVENT_PREFIX, L"Error: SPE sampling is not available with the stat command");
+    }
+    if (commands_with_events_and_metrics.find(command) == commands_with_events_and_metrics.end()) {
+        throw_invalid_arg(events_string.key, L"Error: Event list is only supported with the commands: stat, record, sample");
+    }
+}
+
 void arg_parser::parse_cpu_core(wstr_vec& raw_args_vect, uint8_t MAX_CPU_CORES)
 {
     wstring cores = raw_args_vect.front();
     if (TokenizeWideStringOfInts(cores.c_str(), L',', cores_idx.value) == false)
     {
         throw_invalid_arg(raw_args_vect.front());
     }
+    // TODO: add CPU core ranges
     if (cores_idx.value.size() > MAX_CPU_CORES)
     {
         std::wostringstream error_message;
@@ -255,12 +283,12 @@ void arg_parser::parse_record_commandline(wstr_vec& raw_args_vect)
         if (sample_pe_file.value.empty())
         {
             sample_pe_file.value = arg;
-            record_commandline = arg;
+            record_commandline.value = arg;
             fill_pdb_and_image_name_if_empty();
 
         }
         else
-            record_commandline += L" " + arg;
+            record_commandline.value += L" " + arg;
 
         raw_args_vect.erase(raw_args_vect.begin());
     }

parser/arg-parser.h

@@ -43,6 +43,8 @@ using namespace std;
 
 typedef std::vector<std::wstring> wstr_vec;
 
+#define ARM_SPE_EVENT_PREFIX L"arm_spe_0"
+
 #pragma region arg structs
 enum COMMAND_CLASS {
     STAT,
@@ -58,8 +60,15 @@ enum COMMAND_CLASS {
     TIMELINE,
     NO_COMMAND
 };
+static const std::set<COMMAND_CLASS> commands_with_events_and_metrics = { 
+    COMMAND_CLASS::STAT, 
+    COMMAND_CLASS::SAMPLE, 
+    COMMAND_CLASS::RECORD,
+    COMMAND_CLASS::TIMELINE,
+    COMMAND_CLASS::SPE 
+};
 
-const std::set<COMMAND_CLASS> commands_with_no_args = {
+static const std::set<COMMAND_CLASS> commands_with_no_args = {
     COMMAND_CLASS::HELP,
     COMMAND_CLASS::VERSION,
     COMMAND_CLASS::LIST,
@@ -154,11 +163,11 @@ class arg_parser
       COMMAND_CLASS::RECORD
     };
     arg_type do_count = {
-          L"stat",
-          L"",
-          L"",
-          false,
-          COMMAND_CLASS::STAT
+      L"stat",
+      L"",
+      L"",
+      false,
+      COMMAND_CLASS::STAT
     };
 
 #pragma endregion
@@ -214,12 +223,12 @@ class arg_parser
       L"Enable disassemble output on sampling mode. Implies 'annotate'.",
       false,
     };
-    flag_type<bool> record_commandline_separator = {
+    flag_type<wstring> record_commandline = {
       L"--",
       L"",
       L"-- Process name is defined by COMMAND. User can pass verbatim arguments to the process with[ARGS].",
-      false,
-    };
+      L"",
+    };     // <sample_pe_file> <arg> <arg> <arg> ...
 
     flag_type<std::vector<uint8_t>> cores_idx = {
       L"-c",
@@ -275,6 +284,21 @@ class arg_parser
       L"Specify the PDB filename (and path), PDB file should directly corresponds to a PE file set with `- - pe_file`.",
       L"",
     };
+    flag_type<std::wstring> events_string = {
+        L"-e",
+        L"",
+        LR"(        Specify comma separated list of event names (or raw events) to count, for
+        example `ld_spec,vfp_spec,r10`. Use curly braces to group events.
+        Specify comma separated list of event names with sampling frequency to
+        sample, for example `ld_spec:100000`.
+
+        Raw events: specify raw evens with `r<VALUE>` where `<VALUE>` is a 16-bit
+        hexadecimal event index value without leading `0x`. For example `r10` is
+        event with index `0x10`.
+
+        Note: see list of available event names using `list` command.)",
+        L"",
+    };
 #pragma endregion
 
 #pragma region Attributes
@@ -288,15 +312,14 @@ class arg_parser
     bool do_timeline;
     bool do_man;
     bool do_export_perf_data;
-  bool do_cwd = false;        // Set current working dir for storing output files
+    bool do_cwd = false;        // Set current working dir for storing output files
     bool report_l3_cache_metric;
     bool report_ddr_bw_metric;
     uint8_t dmc_idx;
     double count_interval;
     int count_timeline;
     std::wstring man_query_args;
 
-  std::wstring record_commandline;        // <sample_pe_file> <arg> <arg> <arg> ...
     std::wstring timeline_output_file;
   std::wstring m_cwd;       // Current working dir for storing output files
     std::map<uint32_t, uint32_t> sampling_inverval;     //!< [event_index] -> event_sampling_interval
@@ -317,6 +340,7 @@ class arg_parser
     void fill_pdb_and_image_name_if_empty();
     void check_record_required_args();
     void parse_sampling_args(wstr_vec& raw_args_vect);
+    void parse_event_list(wstring events_string);
     void parse_cpu_core(wstr_vec& raw_args_vect, uint8_t MAX_CPU_CORES);
     bool try_match_and_set_bool_flag(wstr_vec& raw_args_vect, flag_type<bool>& flag);
     bool try_match_and_set_arg(wstr_vec& raw_args_vect, arg_type& flag);