mono/profiler/log-args.c

   1 #include <config.h>
   2
   3 #include "log.h"
   4
   5 #ifdef HAVE_UNISTD_H
   6 #include <unistd.h>
   7 #endif
   8
   9 #ifdef HAVE_SCHED_GETAFFINITY
  10 #include <sched.h>
  11
  12 #  ifndef GLIBC_HAS_CPU_COUNT
  13 static int
  14 CPU_COUNT(cpu_set_t *set)
  15 {
  16         int i, count = 0;
  17
  18         for (int i = 0; i < CPU_SETSIZE; i++)
  19                 if (CPU_ISSET(i, set))
  20                         count++;
  21         return count;
  22 }
  23 #  endif
  24 #endif
  25
  26 typedef struct {
  27         const char *event_name;
  28         const int mask;
  29 } NameAndMask;
  30
  31 static NameAndMask event_list[] = {
  32         { "domain", PROFLOG_DOMAIN_EVENTS },
  33         { "assembly", PROFLOG_ASSEMBLY_EVENTS },
  34         { "module", PROFLOG_MODULE_EVENTS },
  35         { "class", PROFLOG_CLASS_EVENTS },
  36         { "jit", PROFLOG_JIT_COMPILATION_EVENTS },
  37         { "exception", PROFLOG_EXCEPTION_EVENTS },
  38         { "gcalloc", PROFLOG_ALLOCATION_EVENTS },
  39         { "gc", PROFLOG_GC_EVENTS },
  40         { "thread", PROFLOG_THREAD_EVENTS },
  41         { "calls", PROFLOG_CALL_EVENTS },
  42         //{ "inscov", PROFLOG_INS_COVERAGE_EVENTS }, //this is a profiler API event, but there's no actual event for us to emit here
  43         //{ "sampling", PROFLOG_SAMPLING_EVENTS }, //it makes no sense to enable/disable this event by itself
  44         { "monitor", PROFLOG_MONITOR_EVENTS },
  45         { "gcmove", PROFLOG_GC_MOVES_EVENTS },
  46         { "gcroot", PROFLOG_GC_ROOT_EVENTS },
  47         { "context", PROFLOG_CONTEXT_EVENTS },
  48         { "finalization", PROFLOG_FINALIZATION_EVENTS },
  49         { "counter", PROFLOG_COUNTER_EVENTS },
  50         { "gchandle", PROFLOG_GC_HANDLE_EVENTS },
  51
  52         { "typesystem", PROFLOG_TYPELOADING_ALIAS },
  53         { "coverage", PROFLOG_CODECOV_ALIAS },
  54         //{ "sample", PROFLOG_PERF_SAMPLING_ALIAS }, //takes args, explicitly handles
  55         { "alloc", PROFLOG_GC_ALLOC_ALIAS },
  56         //{ "heapshot", PROFLOG_HEAPSHOT_ALIAS }, //takes args, explicitly handled
  57         { "legacy", PROFLOG_LEGACY_ALIAS },
  58 };
  59
  60 static void usage (void);
  61 static void set_hsmode (ProfilerConfig *config, const char* val);
  62 static void set_sample_freq (ProfilerConfig *config, const char *val);
  63 static int mono_cpu_count (void);
  64
  65
  66 static gboolean
  67 match_option (const char *arg, const char *opt_name, const char **rval)
  68 {
  69         if (rval) {
  70                 const char *end = strchr (arg, '=');
  71
  72                 *rval = NULL;
  73                 if (!end)
  74                         return !strcmp (arg, opt_name);
  75
  76                 if (strncmp (arg, opt_name, strlen (opt_name)) || (end - arg) > strlen (opt_name) + 1)
  77                         return FALSE;
  78                 *rval = end + 1;
  79                 return TRUE;
  80         } else {
  81                 //FIXME how should we handle passing a value to an arg that doesn't expect it?
  82                 return !strcmp (arg, opt_name);
  83         }
  84 }
  85
  86 static void
  87 parse_arg (const char *arg, ProfilerConfig *config)
  88 {
  89         const char *val;
  90
  91         if (match_option (arg, "help", NULL)) {
  92                 usage ();
  93         } else if (match_option (arg, "report", NULL)) {
  94                 config->do_report = TRUE;
  95         } else if (match_option (arg, "debug", NULL)) {
  96                 config->do_debug = TRUE;
  97         } else if (match_option (arg, "debug-coverage", NULL)) {
  98                 config->debug_coverage = TRUE;
  99         } else if (match_option (arg, "sampling-real", NULL)) {
 100                 config->sampling_mode = MONO_PROFILER_SAMPLE_MODE_REAL;
 101         } else if (match_option (arg, "sampling-process", NULL)) {
 102                 config->sampling_mode = MONO_PROFILER_SAMPLE_MODE_PROCESS;
 103         } else if (match_option (arg, "heapshot", &val)) {
 104                 config->enable_mask |= PROFLOG_HEAPSHOT_ALIAS;
 105                 set_hsmode (config, val);
 106         } else if (match_option (arg, "sample", &val)) {
 107                 set_sample_freq (config, val);
 108                 if (config->sample_freq)
 109                         config->enable_mask |= PROFLOG_PERF_SAMPLING_ALIAS;
 110         } else if (match_option (arg, "zip", NULL)) {
 111                 config->use_zip = TRUE;
 112         } else if (match_option (arg, "output", &val)) {
 113                 config->output_filename = g_strdup (val);
 114         } else if (match_option (arg, "port", &val)) {
 115                 char *end;
 116                 config->command_port = strtoul (val, &end, 10);
 117         } else if (match_option (arg, "maxframes", &val)) {
 118                 char *end;
 119                 int num_frames = strtoul (val, &end, 10);
 120                 if (num_frames > MAX_FRAMES)
 121                         num_frames = MAX_FRAMES;
 122                 config->notraces = num_frames == 0;
 123                 config->num_frames = num_frames;
 124         } else if (match_option (arg, "maxsamples", &val)) {
 125                 char *end;
 126                 int max_samples = strtoul (val, &end, 10);
 127                 if (max_samples)
 128                         config->max_allocated_sample_hits = max_samples;
 129         } else if (match_option (arg, "calldepth", &val)) {
 130                 char *end;
 131                 config->max_call_depth = strtoul (val, &end, 10);
 132         } else if (match_option (arg, "covfilter-file", &val)) {
 133                 if (config->cov_filter_files == NULL)
 134                         config->cov_filter_files = g_ptr_array_new ();
 135                 g_ptr_array_add (config->cov_filter_files, g_strdup (val));
 136         } else if (match_option (arg, "onlycoverage", NULL)) {
 137                 config->only_coverage = TRUE;
 138         } else {
 139                 int i;
 140
 141                 for (i = 0; i < G_N_ELEMENTS (event_list); ++i){
 142                         if (!strcmp (arg, event_list [i].event_name)) {
 143                                 config->enable_mask |= event_list [i].mask;
 144                                 break;
 145                         } else if (!strncmp (arg, "no", 2) && !strcmp (arg + 2, event_list [i].event_name)) {
 146                                 config->disable_mask |= event_list [i].mask;
 147                                 break;
 148                         }
 149                 }
 150                 if (i == G_N_ELEMENTS (event_list)) {
 151                         printf ("Could not parse argument %s\n", arg);
 152                 }
 153         }
 154 }
 155
 156 static void
 157 load_args_from_env_or_default (ProfilerConfig *config)
 158 {
 159         //XXX change this to header constants
 160
 161         config->max_allocated_sample_hits = mono_cpu_count () * 1000;
 162         config->sampling_mode = MONO_PROFILER_SAMPLE_MODE_PROCESS;
 163         config->sample_freq = 100;
 164         config->max_call_depth = 100;
 165         config->num_frames = MAX_FRAMES;
 166 }
 167
 168
 169 void
 170 proflog_parse_args (ProfilerConfig *config, const char *desc)
 171 {
 172         const char *p;
 173         gboolean in_quotes = FALSE;
 174         char quote_char = '\0';
 175         char *buffer = malloc (strlen (desc));
 176         int buffer_pos = 0;
 177
 178         load_args_from_env_or_default (config);
 179
 180         for (p = desc; *p; p++){
 181                 switch (*p){
 182                 case ',':
 183                         if (!in_quotes) {
 184                                 if (buffer_pos != 0){
 185                                         buffer [buffer_pos] = 0;
 186                                         parse_arg (buffer, config);
 187                                         buffer_pos = 0;
 188                                 }
 189                         } else {
 190                                 buffer [buffer_pos++] = *p;
 191                         }
 192                         break;
 193
 194                 case '\\':
 195                         if (p [1]) {
 196                                 buffer [buffer_pos++] = p[1];
 197                                 p++;
 198                         }
 199                         break;
 200                 case '\'':
 201                 case '"':
 202                         if (in_quotes) {
 203                                 if (quote_char == *p)
 204                                         in_quotes = FALSE;
 205                                 else
 206                                         buffer [buffer_pos++] = *p;
 207                         } else {
 208                                 in_quotes = TRUE;
 209                                 quote_char = *p;
 210                         }
 211                         break;
 212                 default:
 213                         buffer [buffer_pos++] = *p;
 214                         break;
 215                 }
 216         }
 217
 218         if (buffer_pos != 0) {
 219                 buffer [buffer_pos] = 0;
 220                 parse_arg (buffer, config);
 221         }
 222
 223         g_free (buffer);
 224
 225         //Compure config effective mask
 226         config->effective_mask = config->enable_mask & ~config->disable_mask;
 227 }
 228
 229 static void
 230 set_hsmode (ProfilerConfig *config, const char* val)
 231 {
 232         char *end;
 233         unsigned int count;
 234         if (!val)
 235                 return;
 236         if (strcmp (val, "ondemand") == 0) {
 237                 config->hs_mode_ondemand = TRUE;
 238                 return;
 239         }
 240
 241         count = strtoul (val, &end, 10);
 242         if (val == end) {
 243                 usage ();
 244                 return;
 245         }
 246
 247         if (strcmp (end, "ms") == 0)
 248                 config->hs_mode_ms = count;
 249         else if (strcmp (end, "gc") == 0)
 250                 config->hs_mode_gc = count;
 251         else
 252                 usage ();
 253 }
 254
 255 /*
 256 Sampling frequency allows for one undocumented, hidden and ignored argument. The sampling kind.
 257 Back in the day when this was done using perf, we could specify one of: cycles,instr,cacherefs,cachemiss,branches,branchmiss
 258 With us moving ot userland sampling, those options are now meaningless.
 259 */
 260 static void
 261 set_sample_freq (ProfilerConfig *config, const char *val)
 262 {
 263         if (!val)
 264                 return;
 265
 266         const char *p = val;
 267
 268         // Is it only the frequency (new option style)?
 269         if (isdigit (*p))
 270                 goto parse;
 271
 272         // Skip the sample type for backwards compatibility.
 273         while (isalpha (*p))
 274                 p++;
 275
 276         // Skip the forward slash only if we got a sample type.
 277         if (p != val && *p == '/') {
 278                 p++;
 279
 280                 char *end;
 281
 282         parse:
 283                 config->sample_freq = strtoul (p, &end, 10);
 284
 285                 if (p == end) {
 286                         usage ();
 287                         return;
 288                 }
 289
 290                 p = end;
 291         }
 292
 293         if (*p)
 294                 usage ();
 295 }
 296
 297 static void
 298 usage (void)
 299 {
 300         printf ("Log profiler version %d.%d (format: %d)\n", LOG_VERSION_MAJOR, LOG_VERSION_MINOR, LOG_DATA_VERSION);
 301         printf ("Usage: mono --profile=log[:OPTION1[,OPTION2...]] program.exe\n");
 302         printf ("Options:\n");
 303         printf ("\thelp                 show this usage info\n");
 304         printf ("\t[no]'event'          enable/disable a profiling event. Valid values: domain, assembly, module, class, jit, exception, gcalloc, gc, thread, monitor, gcmove, gcroot, context, finalization, counter, gchandle\n");
 305         printf ("\t[no]typesystem       enable/disable typesystem related events such as class and assembly loading\n");
 306         printf ("\t[no]alloc            enable/disable recording allocation info\n");
 307         printf ("\t[no]calls            enable/disable recording enter/leave method events\n");
 308         printf ("\t[no]legacy           enable/disable pre mono 5.4 default profiler events\n");
 309         printf ("\tsample[=frequency]   enable/disable statistical sampling of threads (frequency in Hz, 100 by default)\n");
 310         printf ("\theapshot[=MODE]      record heap shot info (by default at each major collection)\n");
 311         printf ("\t                     MODE: every XXms milliseconds, every YYgc collections, ondemand\n");
 312         printf ("\t[no]coverage         enable collection of code coverage data\n");
 313         printf ("\tcovfilter=ASSEMBLY   add an assembly to the code coverage filters\n");
 314         printf ("\t                     add a + to include the assembly or a - to exclude it\n");
 315         printf ("\t                     covfilter=-mscorlib\n");
 316         printf ("\tcovfilter-file=FILE  use FILE to generate the list of assemblies to be filtered\n");
 317         printf ("\tmaxframes=NUM        collect up to NUM stack frames\n");
 318         printf ("\tcalldepth=NUM        ignore method events for call chain depth bigger than NUM\n");
 319         printf ("\toutput=FILENAME      write the data to file FILENAME (The file is always overwriten)\n");
 320         printf ("\toutput=+FILENAME     write the data to file FILENAME.pid (The file is always overwriten)\n");
 321         printf ("\toutput=|PROGRAM      write the data to the stdin of PROGRAM\n");
 322         printf ("\t                     %%t is subtituted with date and time, %%p with the pid\n");
 323         printf ("\treport               create a report instead of writing the raw data to a file\n");
 324         printf ("\tzip                  compress the output data\n");
 325         printf ("\tport=PORTNUM         use PORTNUM for the listening command server\n");
 326 }
 327
 328 static int
 329 mono_cpu_count (void)
 330 {
 331 #ifdef PLATFORM_ANDROID
 332         /* Android tries really hard to save power by powering off CPUs on SMP phones which
 333          * means the normal way to query cpu count returns a wrong value with userspace API.
 334          * Instead we use /sys entries to query the actual hardware CPU count.
 335          */
 336         int count = 0;
 337         char buffer[8] = {'\0'};
 338         int present = open ("/sys/devices/system/cpu/present", O_RDONLY);
 339         /* Format of the /sys entry is a cpulist of indexes which in the case
 340          * of present is always of the form "0-(n-1)" when there is more than
 341          * 1 core, n being the number of CPU cores in the system. Otherwise
 342          * the value is simply 0
 343          */
 344         if (present != -1 && read (present, (char*)buffer, sizeof (buffer)) > 3)
 345                 count = strtol (((char*)buffer) + 2, NULL, 10);
 346         if (present != -1)
 347                 close (present);
 348         if (count > 0)
 349                 return count + 1;
 350 #endif
 351
 352 #if defined(HOST_ARM) || defined (HOST_ARM64)
 353
 354         /* ARM platforms tries really hard to save power by powering off CPUs on SMP phones which
 355          * means the normal way to query cpu count returns a wrong value with userspace API. */
 356
 357 #ifdef _SC_NPROCESSORS_CONF
 358         {
 359                 int count = sysconf (_SC_NPROCESSORS_CONF);
 360                 if (count > 0)
 361                         return count;
 362         }
 363 #endif
 364
 365 #else
 366
 367 #ifdef HAVE_SCHED_GETAFFINITY
 368         {
 369                 cpu_set_t set;
 370                 if (sched_getaffinity (getpid (), sizeof (set), &set) == 0)
 371                         return CPU_COUNT (&set);
 372         }
 373 #endif
 374 #ifdef _SC_NPROCESSORS_ONLN
 375         {
 376                 int count = sysconf (_SC_NPROCESSORS_ONLN);
 377                 if (count > 0)
 378                         return count;
 379         }
 380 #endif
 381
 382 #endif /* defined(HOST_ARM) || defined (HOST_ARM64) */
 383
 384 #ifdef USE_SYSCTL
 385         {
 386                 int count;
 387                 int mib [2];
 388                 size_t len = sizeof (int);
 389                 mib [0] = CTL_HW;
 390                 mib [1] = HW_NCPU;
 391                 if (sysctl (mib, 2, &count, &len, NULL, 0) == 0)
 392                         return count;
 393         }
 394 #endif
 395 #ifdef HOST_WIN32
 396         {
 397                 SYSTEM_INFO info;
 398                 GetSystemInfo (&info);
 399                 return info.dwNumberOfProcessors;
 400         }
 401 #endif
 402
 403         static gboolean warned;
 404
 405         if (!warned) {
 406                 g_warning ("Don't know how to determine CPU count on this platform; assuming 1");
 407                 warned = TRUE;
 408         }
 409
 410         return 1;
 411 }