Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Test support for libpfm4 event encodings.
4 *
5 * Copyright 2020 Google LLC.
6 */
7#include "tests.h"
8#include "util/debug.h"
9#include "util/evlist.h"
10#include "util/pfm.h"
11
12#include <linux/kernel.h>
13
14#ifdef HAVE_LIBPFM
15static int count_pfm_events(struct perf_evlist *evlist)
16{
17 struct perf_evsel *evsel;
18 int count = 0;
19
20 perf_evlist__for_each_entry(evlist, evsel) {
21 count++;
22 }
23 return count;
24}
25
26static int test__pfm_events(struct test_suite *test __maybe_unused,
27 int subtest __maybe_unused)
28{
29 struct evlist *evlist;
30 struct option opt;
31 size_t i;
32 const struct {
33 const char *events;
34 int nr_events;
35 } table[] = {
36 {
37 .events = "",
38 .nr_events = 0,
39 },
40 {
41 .events = "instructions",
42 .nr_events = 1,
43 },
44 {
45 .events = "instructions,cycles",
46 .nr_events = 2,
47 },
48 {
49 .events = "stereolab",
50 .nr_events = 0,
51 },
52 {
53 .events = "instructions,instructions",
54 .nr_events = 2,
55 },
56 {
57 .events = "stereolab,instructions",
58 .nr_events = 0,
59 },
60 {
61 .events = "instructions,stereolab",
62 .nr_events = 1,
63 },
64 };
65
66 for (i = 0; i < ARRAY_SIZE(table); i++) {
67 evlist = evlist__new();
68 if (evlist == NULL)
69 return -ENOMEM;
70
71 opt.value = evlist;
72 parse_libpfm_events_option(&opt,
73 table[i].events,
74 0);
75 TEST_ASSERT_EQUAL(table[i].events,
76 count_pfm_events(&evlist->core),
77 table[i].nr_events);
78 TEST_ASSERT_EQUAL(table[i].events,
79 evlist->core.nr_groups,
80 0);
81
82 evlist__delete(evlist);
83 }
84 return 0;
85}
86
87static int test__pfm_group(struct test_suite *test __maybe_unused,
88 int subtest __maybe_unused)
89{
90 struct evlist *evlist;
91 struct option opt;
92 size_t i;
93 const struct {
94 const char *events;
95 int nr_events;
96 int nr_groups;
97 } table[] = {
98 {
99 .events = "{},",
100 .nr_events = 0,
101 .nr_groups = 0,
102 },
103 {
104 .events = "{instructions}",
105 .nr_events = 1,
106 .nr_groups = 1,
107 },
108 {
109 .events = "{instructions},{}",
110 .nr_events = 1,
111 .nr_groups = 1,
112 },
113 {
114 .events = "{},{instructions}",
115 .nr_events = 1,
116 .nr_groups = 1,
117 },
118 {
119 .events = "{instructions},{instructions}",
120 .nr_events = 2,
121 .nr_groups = 2,
122 },
123 {
124 .events = "{instructions,cycles},{instructions,cycles}",
125 .nr_events = 4,
126 .nr_groups = 2,
127 },
128 {
129 .events = "{stereolab}",
130 .nr_events = 0,
131 .nr_groups = 0,
132 },
133 {
134 .events =
135 "{instructions,cycles},{instructions,stereolab}",
136 .nr_events = 3,
137 .nr_groups = 1,
138 },
139 {
140 .events = "instructions}",
141 .nr_events = 1,
142 .nr_groups = 0,
143 },
144 {
145 .events = "{{instructions}}",
146 .nr_events = 0,
147 .nr_groups = 0,
148 },
149 };
150
151 for (i = 0; i < ARRAY_SIZE(table); i++) {
152 evlist = evlist__new();
153 if (evlist == NULL)
154 return -ENOMEM;
155
156 opt.value = evlist;
157 parse_libpfm_events_option(&opt,
158 table[i].events,
159 0);
160 TEST_ASSERT_EQUAL(table[i].events,
161 count_pfm_events(&evlist->core),
162 table[i].nr_events);
163 TEST_ASSERT_EQUAL(table[i].events,
164 evlist->core.nr_groups,
165 table[i].nr_groups);
166
167 evlist__delete(evlist);
168 }
169 return 0;
170}
171#else
172static int test__pfm_events(struct test_suite *test __maybe_unused,
173 int subtest __maybe_unused)
174{
175 return TEST_SKIP;
176}
177
178static int test__pfm_group(struct test_suite *test __maybe_unused,
179 int subtest __maybe_unused)
180{
181 return TEST_SKIP;
182}
183#endif
184
185static struct test_case pfm_tests[] = {
186 TEST_CASE_REASON("test of individual --pfm-events", pfm_events, "not compiled in"),
187 TEST_CASE_REASON("test groups of --pfm-events", pfm_group, "not compiled in"),
188 { .name = NULL, }
189};
190
191struct test_suite suite__pfm = {
192 .desc = "Test libpfm4 support",
193 .test_cases = pfm_tests,
194};
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Test support for libpfm4 event encodings.
4 *
5 * Copyright 2020 Google LLC.
6 */
7#include "tests.h"
8#include "util/debug.h"
9#include "util/evlist.h"
10#include "util/pfm.h"
11
12#include <linux/kernel.h>
13
14#ifdef HAVE_LIBPFM
15static int test__pfm_events(void);
16static int test__pfm_group(void);
17#endif
18
19static const struct {
20 int (*func)(void);
21 const char *desc;
22} pfm_testcase_table[] = {
23#ifdef HAVE_LIBPFM
24 {
25 .func = test__pfm_events,
26 .desc = "test of individual --pfm-events",
27 },
28 {
29 .func = test__pfm_group,
30 .desc = "test groups of --pfm-events",
31 },
32#endif
33};
34
35#ifdef HAVE_LIBPFM
36static int count_pfm_events(struct perf_evlist *evlist)
37{
38 struct perf_evsel *evsel;
39 int count = 0;
40
41 perf_evlist__for_each_entry(evlist, evsel) {
42 count++;
43 }
44 return count;
45}
46
47static int test__pfm_events(void)
48{
49 struct evlist *evlist;
50 struct option opt;
51 size_t i;
52 const struct {
53 const char *events;
54 int nr_events;
55 } table[] = {
56 {
57 .events = "",
58 .nr_events = 0,
59 },
60 {
61 .events = "instructions",
62 .nr_events = 1,
63 },
64 {
65 .events = "instructions,cycles",
66 .nr_events = 2,
67 },
68 {
69 .events = "stereolab",
70 .nr_events = 0,
71 },
72 {
73 .events = "instructions,instructions",
74 .nr_events = 2,
75 },
76 {
77 .events = "stereolab,instructions",
78 .nr_events = 0,
79 },
80 {
81 .events = "instructions,stereolab",
82 .nr_events = 1,
83 },
84 };
85
86 for (i = 0; i < ARRAY_SIZE(table); i++) {
87 evlist = evlist__new();
88 if (evlist == NULL)
89 return -ENOMEM;
90
91 opt.value = evlist;
92 parse_libpfm_events_option(&opt,
93 table[i].events,
94 0);
95 TEST_ASSERT_EQUAL(table[i].events,
96 count_pfm_events(&evlist->core),
97 table[i].nr_events);
98 TEST_ASSERT_EQUAL(table[i].events,
99 evlist->core.nr_groups,
100 0);
101
102 evlist__delete(evlist);
103 }
104 return 0;
105}
106
107static int test__pfm_group(void)
108{
109 struct evlist *evlist;
110 struct option opt;
111 size_t i;
112 const struct {
113 const char *events;
114 int nr_events;
115 int nr_groups;
116 } table[] = {
117 {
118 .events = "{},",
119 .nr_events = 0,
120 .nr_groups = 0,
121 },
122 {
123 .events = "{instructions}",
124 .nr_events = 1,
125 .nr_groups = 1,
126 },
127 {
128 .events = "{instructions},{}",
129 .nr_events = 1,
130 .nr_groups = 1,
131 },
132 {
133 .events = "{},{instructions}",
134 .nr_events = 1,
135 .nr_groups = 1,
136 },
137 {
138 .events = "{instructions},{instructions}",
139 .nr_events = 2,
140 .nr_groups = 2,
141 },
142 {
143 .events = "{instructions,cycles},{instructions,cycles}",
144 .nr_events = 4,
145 .nr_groups = 2,
146 },
147 {
148 .events = "{stereolab}",
149 .nr_events = 0,
150 .nr_groups = 0,
151 },
152 {
153 .events =
154 "{instructions,cycles},{instructions,stereolab}",
155 .nr_events = 3,
156 .nr_groups = 1,
157 },
158 {
159 .events = "instructions}",
160 .nr_events = 1,
161 .nr_groups = 0,
162 },
163 {
164 .events = "{{instructions}}",
165 .nr_events = 0,
166 .nr_groups = 0,
167 },
168 };
169
170 for (i = 0; i < ARRAY_SIZE(table); i++) {
171 evlist = evlist__new();
172 if (evlist == NULL)
173 return -ENOMEM;
174
175 opt.value = evlist;
176 parse_libpfm_events_option(&opt,
177 table[i].events,
178 0);
179 TEST_ASSERT_EQUAL(table[i].events,
180 count_pfm_events(&evlist->core),
181 table[i].nr_events);
182 TEST_ASSERT_EQUAL(table[i].events,
183 evlist->core.nr_groups,
184 table[i].nr_groups);
185
186 evlist__delete(evlist);
187 }
188 return 0;
189}
190#endif
191
192const char *test__pfm_subtest_get_desc(int i)
193{
194 if (i < 0 || i >= (int)ARRAY_SIZE(pfm_testcase_table))
195 return NULL;
196 return pfm_testcase_table[i].desc;
197}
198
199int test__pfm_subtest_get_nr(void)
200{
201 return (int)ARRAY_SIZE(pfm_testcase_table);
202}
203
204int test__pfm(struct test *test __maybe_unused, int i __maybe_unused)
205{
206#ifdef HAVE_LIBPFM
207 if (i < 0 || i >= (int)ARRAY_SIZE(pfm_testcase_table))
208 return TEST_FAIL;
209 return pfm_testcase_table[i].func();
210#else
211 return TEST_SKIP;
212#endif
213}