Commit e95770af authored by Ian Rogers's avatar Ian Rogers Committed by Arnaldo Carvalho de Melo

tools api: Add a lightweight buffered reading api

The synthesize benchmark shows the majority of execution time going to
fgets and sscanf, necessary to parse /proc/pid/maps. Add a new buffered
reading library that will be used to replace these calls in a follow-up
CL. Add tests for the library to perf test.

Committer tests:

  $ perf test api
  63: Test api io                                           : Ok
  $
Signed-off-by: default avatarIan Rogers <irogers@google.com>
Acked-by: default avatarJiri Olsa <jolsa@redhat.com>
Acked-by: default avatarNamhyung Kim <namhyung@kernel.org>
Tested-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Andrey Zhizhikin <andrey.z@gmail.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: Kan Liang <kan.liang@linux.intel.com>
Cc: Kefeng Wang <wangkefeng.wang@huawei.com>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Petr Mladek <pmladek@suse.com>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Link: http://lore.kernel.org/lkml/20200415054050.31645-3-irogers@google.comSigned-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 13edc237
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Lightweight buffered reading library.
*
* Copyright 2019 Google LLC.
*/
#ifndef __API_IO__
#define __API_IO__
struct io {
/* File descriptor being read/ */
int fd;
/* Size of the read buffer. */
unsigned int buf_len;
/* Pointer to storage for buffering read. */
char *buf;
/* End of the storage. */
char *end;
/* Currently accessed data pointer. */
char *data;
/* Set true on when the end of file on read error. */
bool eof;
};
static inline void io__init(struct io *io, int fd,
char *buf, unsigned int buf_len)
{
io->fd = fd;
io->buf_len = buf_len;
io->buf = buf;
io->end = buf;
io->data = buf;
io->eof = false;
}
/* Reads one character from the "io" file with similar semantics to fgetc. */
static inline int io__get_char(struct io *io)
{
char *ptr = io->data;
if (io->eof)
return -1;
if (ptr == io->end) {
ssize_t n = read(io->fd, io->buf, io->buf_len);
if (n <= 0) {
io->eof = true;
return -1;
}
ptr = &io->buf[0];
io->end = &io->buf[n];
}
io->data = ptr + 1;
return *ptr;
}
/* Read a hexadecimal value with no 0x prefix into the out argument hex. If the
* first character isn't hexadecimal returns -2, io->eof returns -1, otherwise
* returns the character after the hexadecimal value which may be -1 for eof.
* If the read value is larger than a u64 the high-order bits will be dropped.
*/
static inline int io__get_hex(struct io *io, __u64 *hex)
{
bool first_read = true;
*hex = 0;
while (true) {
int ch = io__get_char(io);
if (ch < 0)
return ch;
if (ch >= '0' && ch <= '9')
*hex = (*hex << 4) | (ch - '0');
else if (ch >= 'a' && ch <= 'f')
*hex = (*hex << 4) | (ch - 'a' + 10);
else if (ch >= 'A' && ch <= 'F')
*hex = (*hex << 4) | (ch - 'A' + 10);
else if (first_read)
return -2;
else
return ch;
first_read = false;
}
}
/* Read a positive decimal value with out argument dec. If the first character
* isn't a decimal returns -2, io->eof returns -1, otherwise returns the
* character after the decimal value which may be -1 for eof. If the read value
* is larger than a u64 the high-order bits will be dropped.
*/
static inline int io__get_dec(struct io *io, __u64 *dec)
{
bool first_read = true;
*dec = 0;
while (true) {
int ch = io__get_char(io);
if (ch < 0)
return ch;
if (ch >= '0' && ch <= '9')
*dec = (*dec * 10) + ch - '0';
else if (first_read)
return -2;
else
return ch;
first_read = false;
}
}
#endif /* __API_IO__ */
...@@ -56,6 +56,7 @@ perf-y += mem2node.o ...@@ -56,6 +56,7 @@ perf-y += mem2node.o
perf-y += maps.o perf-y += maps.o
perf-y += time-utils-test.o perf-y += time-utils-test.o
perf-y += genelf.o perf-y += genelf.o
perf-y += api-io.o
$(OUTPUT)tests/llvm-src-base.c: tests/bpf-script-example.c tests/Build $(OUTPUT)tests/llvm-src-base.c: tests/bpf-script-example.c tests/Build
$(call rule_mkdir) $(call rule_mkdir)
......
// SPDX-License-Identifier: GPL-2.0-only
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "debug.h"
#include "tests.h"
#include <api/io.h>
#include <linux/kernel.h>
#define TEMPL "/tmp/perf-test-XXXXXX"
#define EXPECT_EQUAL(val, expected) \
do { \
if (val != expected) { \
pr_debug("%s:%d: %d != %d\n", \
__FILE__, __LINE__, val, expected); \
ret = -1; \
} \
} while (0)
#define EXPECT_EQUAL64(val, expected) \
do { \
if (val != expected) { \
pr_debug("%s:%d: %lld != %lld\n", \
__FILE__, __LINE__, val, expected); \
ret = -1; \
} \
} while (0)
static int make_test_file(char path[PATH_MAX], const char *contents)
{
ssize_t contents_len = strlen(contents);
int fd;
strcpy(path, TEMPL);
fd = mkstemp(path);
if (fd < 0) {
pr_debug("mkstemp failed");
return -1;
}
if (write(fd, contents, contents_len) < contents_len) {
pr_debug("short write");
close(fd);
unlink(path);
return -1;
}
close(fd);
return 0;
}
static int setup_test(char path[PATH_MAX], const char *contents,
size_t buf_size, struct io *io)
{
if (make_test_file(path, contents))
return -1;
io->fd = open(path, O_RDONLY);
if (io->fd < 0) {
pr_debug("Failed to open '%s'\n", path);
unlink(path);
return -1;
}
io->buf = malloc(buf_size);
if (io->buf == NULL) {
pr_debug("Failed to allocate memory");
close(io->fd);
unlink(path);
return -1;
}
io__init(io, io->fd, io->buf, buf_size);
return 0;
}
static void cleanup_test(char path[PATH_MAX], struct io *io)
{
free(io->buf);
close(io->fd);
unlink(path);
}
static int do_test_get_char(const char *test_string, size_t buf_size)
{
char path[PATH_MAX];
struct io io;
int ch, ret = 0;
size_t i;
if (setup_test(path, test_string, buf_size, &io))
return -1;
for (i = 0; i < strlen(test_string); i++) {
ch = io__get_char(&io);
EXPECT_EQUAL(ch, test_string[i]);
EXPECT_EQUAL(io.eof, false);
}
ch = io__get_char(&io);
EXPECT_EQUAL(ch, -1);
EXPECT_EQUAL(io.eof, true);
cleanup_test(path, &io);
return ret;
}
static int test_get_char(void)
{
int i, ret = 0;
size_t j;
static const char *const test_strings[] = {
"12345678abcdef90",
"a\nb\nc\nd\n",
"\a\b\t\v\f\r",
};
for (i = 0; i <= 10; i++) {
for (j = 0; j < ARRAY_SIZE(test_strings); j++) {
if (do_test_get_char(test_strings[j], 1 << i))
ret = -1;
}
}
return ret;
}
static int do_test_get_hex(const char *test_string,
__u64 val1, int ch1,
__u64 val2, int ch2,
__u64 val3, int ch3,
bool end_eof)
{
char path[PATH_MAX];
struct io io;
int ch, ret = 0;
__u64 hex;
if (setup_test(path, test_string, 4, &io))
return -1;
ch = io__get_hex(&io, &hex);
EXPECT_EQUAL64(hex, val1);
EXPECT_EQUAL(ch, ch1);
ch = io__get_hex(&io, &hex);
EXPECT_EQUAL64(hex, val2);
EXPECT_EQUAL(ch, ch2);
ch = io__get_hex(&io, &hex);
EXPECT_EQUAL64(hex, val3);
EXPECT_EQUAL(ch, ch3);
EXPECT_EQUAL(io.eof, end_eof);
cleanup_test(path, &io);
return ret;
}
static int test_get_hex(void)
{
int ret = 0;
if (do_test_get_hex("12345678abcdef90",
0x12345678abcdef90, -1,
0, -1,
0, -1,
true))
ret = -1;
if (do_test_get_hex("1\n2\n3\n",
1, '\n',
2, '\n',
3, '\n',
false))
ret = -1;
if (do_test_get_hex("12345678ABCDEF90;a;b",
0x12345678abcdef90, ';',
0xa, ';',
0xb, -1,
true))
ret = -1;
if (do_test_get_hex("0x1x2x",
0, 'x',
1, 'x',
2, 'x',
false))
ret = -1;
if (do_test_get_hex("x1x",
0, -2,
1, 'x',
0, -1,
true))
ret = -1;
if (do_test_get_hex("10000000000000000000000000000abcdefgh99i",
0xabcdef, 'g',
0, -2,
0x99, 'i',
false))
ret = -1;
return ret;
}
static int do_test_get_dec(const char *test_string,
__u64 val1, int ch1,
__u64 val2, int ch2,
__u64 val3, int ch3,
bool end_eof)
{
char path[PATH_MAX];
struct io io;
int ch, ret = 0;
__u64 dec;
if (setup_test(path, test_string, 4, &io))
return -1;
ch = io__get_dec(&io, &dec);
EXPECT_EQUAL64(dec, val1);
EXPECT_EQUAL(ch, ch1);
ch = io__get_dec(&io, &dec);
EXPECT_EQUAL64(dec, val2);
EXPECT_EQUAL(ch, ch2);
ch = io__get_dec(&io, &dec);
EXPECT_EQUAL64(dec, val3);
EXPECT_EQUAL(ch, ch3);
EXPECT_EQUAL(io.eof, end_eof);
cleanup_test(path, &io);
return ret;
}
static int test_get_dec(void)
{
int ret = 0;
if (do_test_get_dec("12345678abcdef90",
12345678, 'a',
0, -2,
0, -2,
false))
ret = -1;
if (do_test_get_dec("1\n2\n3\n",
1, '\n',
2, '\n',
3, '\n',
false))
ret = -1;
if (do_test_get_dec("12345678;1;2",
12345678, ';',
1, ';',
2, -1,
true))
ret = -1;
if (do_test_get_dec("0x1x2x",
0, 'x',
1, 'x',
2, 'x',
false))
ret = -1;
if (do_test_get_dec("x1x",
0, -2,
1, 'x',
0, -1,
true))
ret = -1;
if (do_test_get_dec("10000000000000000000000000000000000000000000000000000000000123456789ab99c",
123456789, 'a',
0, -2,
99, 'c',
false))
ret = -1;
return ret;
}
int test__api_io(struct test *test __maybe_unused,
int subtest __maybe_unused)
{
int ret = 0;
if (test_get_char())
ret = TEST_FAIL;
if (test_get_hex())
ret = TEST_FAIL;
if (test_get_dec())
ret = TEST_FAIL;
return ret;
}
...@@ -309,6 +309,10 @@ static struct test generic_tests[] = { ...@@ -309,6 +309,10 @@ static struct test generic_tests[] = {
.desc = "Test jit_write_elf", .desc = "Test jit_write_elf",
.func = test__jit_write_elf, .func = test__jit_write_elf,
}, },
{
.desc = "Test api io",
.func = test__api_io,
},
{ {
.desc = "maps__merge_in", .desc = "maps__merge_in",
.func = test__maps__merge_in, .func = test__maps__merge_in,
......
...@@ -112,6 +112,7 @@ int test__mem2node(struct test *t, int subtest); ...@@ -112,6 +112,7 @@ int test__mem2node(struct test *t, int subtest);
int test__maps__merge_in(struct test *t, int subtest); int test__maps__merge_in(struct test *t, int subtest);
int test__time_utils(struct test *t, int subtest); int test__time_utils(struct test *t, int subtest);
int test__jit_write_elf(struct test *test, int subtest); int test__jit_write_elf(struct test *test, int subtest);
int test__api_io(struct test *test, int subtest);
bool test__bp_signal_is_supported(void); bool test__bp_signal_is_supported(void);
bool test__bp_account_is_supported(void); bool test__bp_account_is_supported(void);
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment