mirror of
https://github.com/FEX-Emu/linux.git
synced 2024-12-22 17:33:01 +00:00
5a031f887c
Previously we use a magic number 10 to limit the number of time slices. It's not very good. This patch creates a new function perf_time__range_alloc() to allocate time slices buffer. The number of buffer entries is determined by the number of comma in string but at least it will allocate one entry even if no comma is found. Signed-off-by: Jin Yao <yao.jin@linux.intel.com> Suggested-by: Arnaldo Carvalho de Melo <acme@redhat.com> Reviewed-by: Jiri Olsa <jolsa@redhat.com> Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com> Cc: Andi Kleen <ak@linux.intel.com> Cc: Kan Liang <kan.liang@intel.com> Cc: Peter Zijlstra <peterz@infradead.org> Link: http://lkml.kernel.org/r/1515596433-24653-7-git-send-email-yao.jin@linux.intel.com Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
423 lines
7.9 KiB
C
423 lines
7.9 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sys/time.h>
|
|
#include <linux/time64.h>
|
|
#include <time.h>
|
|
#include <errno.h>
|
|
#include <inttypes.h>
|
|
#include <math.h>
|
|
|
|
#include "perf.h"
|
|
#include "debug.h"
|
|
#include "time-utils.h"
|
|
|
|
int parse_nsec_time(const char *str, u64 *ptime)
|
|
{
|
|
u64 time_sec, time_nsec;
|
|
char *end;
|
|
|
|
time_sec = strtoul(str, &end, 10);
|
|
if (*end != '.' && *end != '\0')
|
|
return -1;
|
|
|
|
if (*end == '.') {
|
|
int i;
|
|
char nsec_buf[10];
|
|
|
|
if (strlen(++end) > 9)
|
|
return -1;
|
|
|
|
strncpy(nsec_buf, end, 9);
|
|
nsec_buf[9] = '\0';
|
|
|
|
/* make it nsec precision */
|
|
for (i = strlen(nsec_buf); i < 9; i++)
|
|
nsec_buf[i] = '0';
|
|
|
|
time_nsec = strtoul(nsec_buf, &end, 10);
|
|
if (*end != '\0')
|
|
return -1;
|
|
} else
|
|
time_nsec = 0;
|
|
|
|
*ptime = time_sec * NSEC_PER_SEC + time_nsec;
|
|
return 0;
|
|
}
|
|
|
|
static int parse_timestr_sec_nsec(struct perf_time_interval *ptime,
|
|
char *start_str, char *end_str)
|
|
{
|
|
if (start_str && (*start_str != '\0') &&
|
|
(parse_nsec_time(start_str, &ptime->start) != 0)) {
|
|
return -1;
|
|
}
|
|
|
|
if (end_str && (*end_str != '\0') &&
|
|
(parse_nsec_time(end_str, &ptime->end) != 0)) {
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int split_start_end(char **start, char **end, const char *ostr, char ch)
|
|
{
|
|
char *start_str, *end_str;
|
|
char *d, *str;
|
|
|
|
if (ostr == NULL || *ostr == '\0')
|
|
return 0;
|
|
|
|
/* copy original string because we need to modify it */
|
|
str = strdup(ostr);
|
|
if (str == NULL)
|
|
return -ENOMEM;
|
|
|
|
start_str = str;
|
|
d = strchr(start_str, ch);
|
|
if (d) {
|
|
*d = '\0';
|
|
++d;
|
|
}
|
|
end_str = d;
|
|
|
|
*start = start_str;
|
|
*end = end_str;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int perf_time__parse_str(struct perf_time_interval *ptime, const char *ostr)
|
|
{
|
|
char *start_str = NULL, *end_str;
|
|
int rc;
|
|
|
|
rc = split_start_end(&start_str, &end_str, ostr, ',');
|
|
if (rc || !start_str)
|
|
return rc;
|
|
|
|
ptime->start = 0;
|
|
ptime->end = 0;
|
|
|
|
rc = parse_timestr_sec_nsec(ptime, start_str, end_str);
|
|
|
|
free(start_str);
|
|
|
|
/* make sure end time is after start time if it was given */
|
|
if (rc == 0 && ptime->end && ptime->end < ptime->start)
|
|
return -EINVAL;
|
|
|
|
pr_debug("start time %" PRIu64 ", ", ptime->start);
|
|
pr_debug("end time %" PRIu64 "\n", ptime->end);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static int parse_percent(double *pcnt, char *str)
|
|
{
|
|
char *c, *endptr;
|
|
double d;
|
|
|
|
c = strchr(str, '%');
|
|
if (c)
|
|
*c = '\0';
|
|
else
|
|
return -1;
|
|
|
|
d = strtod(str, &endptr);
|
|
if (endptr != str + strlen(str))
|
|
return -1;
|
|
|
|
*pcnt = d / 100.0;
|
|
return 0;
|
|
}
|
|
|
|
static int percent_slash_split(char *str, struct perf_time_interval *ptime,
|
|
u64 start, u64 end)
|
|
{
|
|
char *p, *end_str;
|
|
double pcnt, start_pcnt, end_pcnt;
|
|
u64 total = end - start;
|
|
int i;
|
|
|
|
/*
|
|
* Example:
|
|
* 10%/2: select the second 10% slice and the third 10% slice
|
|
*/
|
|
|
|
/* We can modify this string since the original one is copied */
|
|
p = strchr(str, '/');
|
|
if (!p)
|
|
return -1;
|
|
|
|
*p = '\0';
|
|
if (parse_percent(&pcnt, str) < 0)
|
|
return -1;
|
|
|
|
p++;
|
|
i = (int)strtol(p, &end_str, 10);
|
|
if (*end_str)
|
|
return -1;
|
|
|
|
if (pcnt <= 0.0)
|
|
return -1;
|
|
|
|
start_pcnt = pcnt * (i - 1);
|
|
end_pcnt = pcnt * i;
|
|
|
|
if (start_pcnt < 0.0 || start_pcnt > 1.0 ||
|
|
end_pcnt < 0.0 || end_pcnt > 1.0) {
|
|
return -1;
|
|
}
|
|
|
|
ptime->start = start + round(start_pcnt * total);
|
|
ptime->end = start + round(end_pcnt * total);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int percent_dash_split(char *str, struct perf_time_interval *ptime,
|
|
u64 start, u64 end)
|
|
{
|
|
char *start_str = NULL, *end_str;
|
|
double start_pcnt, end_pcnt;
|
|
u64 total = end - start;
|
|
int ret;
|
|
|
|
/*
|
|
* Example: 0%-10%
|
|
*/
|
|
|
|
ret = split_start_end(&start_str, &end_str, str, '-');
|
|
if (ret || !start_str)
|
|
return ret;
|
|
|
|
if ((parse_percent(&start_pcnt, start_str) != 0) ||
|
|
(parse_percent(&end_pcnt, end_str) != 0)) {
|
|
free(start_str);
|
|
return -1;
|
|
}
|
|
|
|
free(start_str);
|
|
|
|
if (start_pcnt < 0.0 || start_pcnt > 1.0 ||
|
|
end_pcnt < 0.0 || end_pcnt > 1.0 ||
|
|
start_pcnt > end_pcnt) {
|
|
return -1;
|
|
}
|
|
|
|
ptime->start = start + round(start_pcnt * total);
|
|
ptime->end = start + round(end_pcnt * total);
|
|
|
|
return 0;
|
|
}
|
|
|
|
typedef int (*time_pecent_split)(char *, struct perf_time_interval *,
|
|
u64 start, u64 end);
|
|
|
|
static int percent_comma_split(struct perf_time_interval *ptime_buf, int num,
|
|
const char *ostr, u64 start, u64 end,
|
|
time_pecent_split func)
|
|
{
|
|
char *str, *p1, *p2;
|
|
int len, ret, i = 0;
|
|
|
|
str = strdup(ostr);
|
|
if (str == NULL)
|
|
return -ENOMEM;
|
|
|
|
len = strlen(str);
|
|
p1 = str;
|
|
|
|
while (p1 < str + len) {
|
|
if (i >= num) {
|
|
free(str);
|
|
return -1;
|
|
}
|
|
|
|
p2 = strchr(p1, ',');
|
|
if (p2)
|
|
*p2 = '\0';
|
|
|
|
ret = (func)(p1, &ptime_buf[i], start, end);
|
|
if (ret < 0) {
|
|
free(str);
|
|
return -1;
|
|
}
|
|
|
|
pr_debug("start time %d: %" PRIu64 ", ", i, ptime_buf[i].start);
|
|
pr_debug("end time %d: %" PRIu64 "\n", i, ptime_buf[i].end);
|
|
|
|
i++;
|
|
|
|
if (p2)
|
|
p1 = p2 + 1;
|
|
else
|
|
break;
|
|
}
|
|
|
|
free(str);
|
|
return i;
|
|
}
|
|
|
|
static int one_percent_convert(struct perf_time_interval *ptime_buf,
|
|
const char *ostr, u64 start, u64 end, char *c)
|
|
{
|
|
char *str;
|
|
int len = strlen(ostr), ret;
|
|
|
|
/*
|
|
* c points to '%'.
|
|
* '%' should be the last character
|
|
*/
|
|
if (ostr + len - 1 != c)
|
|
return -1;
|
|
|
|
/*
|
|
* Construct a string like "xx%/1"
|
|
*/
|
|
str = malloc(len + 3);
|
|
if (str == NULL)
|
|
return -ENOMEM;
|
|
|
|
memcpy(str, ostr, len);
|
|
strcpy(str + len, "/1");
|
|
|
|
ret = percent_slash_split(str, ptime_buf, start, end);
|
|
if (ret == 0)
|
|
ret = 1;
|
|
|
|
free(str);
|
|
return ret;
|
|
}
|
|
|
|
int perf_time__percent_parse_str(struct perf_time_interval *ptime_buf, int num,
|
|
const char *ostr, u64 start, u64 end)
|
|
{
|
|
char *c;
|
|
|
|
/*
|
|
* ostr example:
|
|
* 10%/2,10%/3: select the second 10% slice and the third 10% slice
|
|
* 0%-10%,30%-40%: multiple time range
|
|
* 50%: just one percent
|
|
*/
|
|
|
|
memset(ptime_buf, 0, sizeof(*ptime_buf) * num);
|
|
|
|
c = strchr(ostr, '/');
|
|
if (c) {
|
|
return percent_comma_split(ptime_buf, num, ostr, start,
|
|
end, percent_slash_split);
|
|
}
|
|
|
|
c = strchr(ostr, '-');
|
|
if (c) {
|
|
return percent_comma_split(ptime_buf, num, ostr, start,
|
|
end, percent_dash_split);
|
|
}
|
|
|
|
c = strchr(ostr, '%');
|
|
if (c)
|
|
return one_percent_convert(ptime_buf, ostr, start, end, c);
|
|
|
|
return -1;
|
|
}
|
|
|
|
struct perf_time_interval *perf_time__range_alloc(const char *ostr, int *size)
|
|
{
|
|
const char *p1, *p2;
|
|
int i = 1;
|
|
struct perf_time_interval *ptime;
|
|
|
|
/*
|
|
* At least allocate one time range.
|
|
*/
|
|
if (!ostr)
|
|
goto alloc;
|
|
|
|
p1 = ostr;
|
|
while (p1 < ostr + strlen(ostr)) {
|
|
p2 = strchr(p1, ',');
|
|
if (!p2)
|
|
break;
|
|
|
|
p1 = p2 + 1;
|
|
i++;
|
|
}
|
|
|
|
alloc:
|
|
*size = i;
|
|
ptime = calloc(i, sizeof(*ptime));
|
|
return ptime;
|
|
}
|
|
|
|
bool perf_time__skip_sample(struct perf_time_interval *ptime, u64 timestamp)
|
|
{
|
|
/* if time is not set don't drop sample */
|
|
if (timestamp == 0)
|
|
return false;
|
|
|
|
/* otherwise compare sample time to time window */
|
|
if ((ptime->start && timestamp < ptime->start) ||
|
|
(ptime->end && timestamp > ptime->end)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool perf_time__ranges_skip_sample(struct perf_time_interval *ptime_buf,
|
|
int num, u64 timestamp)
|
|
{
|
|
struct perf_time_interval *ptime;
|
|
int i;
|
|
|
|
if ((timestamp == 0) || (num == 0))
|
|
return false;
|
|
|
|
if (num == 1)
|
|
return perf_time__skip_sample(&ptime_buf[0], timestamp);
|
|
|
|
/*
|
|
* start/end of multiple time ranges must be valid.
|
|
*/
|
|
for (i = 0; i < num; i++) {
|
|
ptime = &ptime_buf[i];
|
|
|
|
if (timestamp >= ptime->start &&
|
|
((timestamp < ptime->end && i < num - 1) ||
|
|
(timestamp <= ptime->end && i == num - 1))) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (i == num) ? true : false;
|
|
}
|
|
|
|
int timestamp__scnprintf_usec(u64 timestamp, char *buf, size_t sz)
|
|
{
|
|
u64 sec = timestamp / NSEC_PER_SEC;
|
|
u64 usec = (timestamp % NSEC_PER_SEC) / NSEC_PER_USEC;
|
|
|
|
return scnprintf(buf, sz, "%"PRIu64".%06"PRIu64, sec, usec);
|
|
}
|
|
|
|
int fetch_current_timestamp(char *buf, size_t sz)
|
|
{
|
|
struct timeval tv;
|
|
struct tm tm;
|
|
char dt[32];
|
|
|
|
if (gettimeofday(&tv, NULL) || !localtime_r(&tv.tv_sec, &tm))
|
|
return -1;
|
|
|
|
if (!strftime(dt, sizeof(dt), "%Y%m%d%H%M%S", &tm))
|
|
return -1;
|
|
|
|
scnprintf(buf, sz, "%s%02u", dt, (unsigned)tv.tv_usec / 10000);
|
|
|
|
return 0;
|
|
}
|