mem-events.c 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467
  1. // SPDX-License-Identifier: GPL-2.0
  2. #include <stddef.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <errno.h>
  6. #include <sys/types.h>
  7. #include <sys/stat.h>
  8. #include <unistd.h>
  9. #include <api/fs/fs.h>
  10. #include <linux/kernel.h>
  11. #include "map_symbol.h"
  12. #include "mem-events.h"
  13. #include "debug.h"
  14. #include "symbol.h"
  15. unsigned int perf_mem_events__loads_ldlat = 30;
  16. #define E(t, n, s) { .tag = t, .name = n, .sysfs_name = s }
  17. struct perf_mem_event perf_mem_events[PERF_MEM_EVENTS__MAX] = {
  18. E("ldlat-loads", "cpu/mem-loads,ldlat=%u/P", "mem-loads"),
  19. E("ldlat-stores", "cpu/mem-stores/P", "mem-stores"),
  20. };
  21. #undef E
  22. #undef E
  23. static char mem_loads_name[100];
  24. static bool mem_loads_name__init;
  25. char * __weak perf_mem_events__name(int i)
  26. {
  27. if (i == PERF_MEM_EVENTS__LOAD) {
  28. if (!mem_loads_name__init) {
  29. mem_loads_name__init = true;
  30. scnprintf(mem_loads_name, sizeof(mem_loads_name),
  31. perf_mem_events[i].name,
  32. perf_mem_events__loads_ldlat);
  33. }
  34. return mem_loads_name;
  35. }
  36. return (char *)perf_mem_events[i].name;
  37. }
  38. int perf_mem_events__parse(const char *str)
  39. {
  40. char *tok, *saveptr = NULL;
  41. bool found = false;
  42. char *buf;
  43. int j;
  44. /* We need buffer that we know we can write to. */
  45. buf = malloc(strlen(str) + 1);
  46. if (!buf)
  47. return -ENOMEM;
  48. strcpy(buf, str);
  49. tok = strtok_r((char *)buf, ",", &saveptr);
  50. while (tok) {
  51. for (j = 0; j < PERF_MEM_EVENTS__MAX; j++) {
  52. struct perf_mem_event *e = &perf_mem_events[j];
  53. if (strstr(e->tag, tok))
  54. e->record = found = true;
  55. }
  56. tok = strtok_r(NULL, ",", &saveptr);
  57. }
  58. free(buf);
  59. if (found)
  60. return 0;
  61. pr_err("failed: event '%s' not found, use '-e list' to get list of available events\n", str);
  62. return -1;
  63. }
  64. int perf_mem_events__init(void)
  65. {
  66. const char *mnt = sysfs__mount();
  67. bool found = false;
  68. int j;
  69. if (!mnt)
  70. return -ENOENT;
  71. for (j = 0; j < PERF_MEM_EVENTS__MAX; j++) {
  72. char path[PATH_MAX];
  73. struct perf_mem_event *e = &perf_mem_events[j];
  74. struct stat st;
  75. scnprintf(path, PATH_MAX, "%s/devices/cpu/events/%s",
  76. mnt, e->sysfs_name);
  77. if (!stat(path, &st))
  78. e->supported = found = true;
  79. }
  80. return found ? 0 : -ENOENT;
  81. }
  82. void perf_mem_events__list(void)
  83. {
  84. int j;
  85. for (j = 0; j < PERF_MEM_EVENTS__MAX; j++) {
  86. struct perf_mem_event *e = &perf_mem_events[j];
  87. fprintf(stderr, "%-13s%-*s%s\n",
  88. e->tag,
  89. verbose > 0 ? 25 : 0,
  90. verbose > 0 ? perf_mem_events__name(j) : "",
  91. e->supported ? ": available" : "");
  92. }
  93. }
  94. static const char * const tlb_access[] = {
  95. "N/A",
  96. "HIT",
  97. "MISS",
  98. "L1",
  99. "L2",
  100. "Walker",
  101. "Fault",
  102. };
  103. int perf_mem__tlb_scnprintf(char *out, size_t sz, struct mem_info *mem_info)
  104. {
  105. size_t l = 0, i;
  106. u64 m = PERF_MEM_TLB_NA;
  107. u64 hit, miss;
  108. sz -= 1; /* -1 for null termination */
  109. out[0] = '\0';
  110. if (mem_info)
  111. m = mem_info->data_src.mem_dtlb;
  112. hit = m & PERF_MEM_TLB_HIT;
  113. miss = m & PERF_MEM_TLB_MISS;
  114. /* already taken care of */
  115. m &= ~(PERF_MEM_TLB_HIT|PERF_MEM_TLB_MISS);
  116. for (i = 0; m && i < ARRAY_SIZE(tlb_access); i++, m >>= 1) {
  117. if (!(m & 0x1))
  118. continue;
  119. if (l) {
  120. strcat(out, " or ");
  121. l += 4;
  122. }
  123. l += scnprintf(out + l, sz - l, tlb_access[i]);
  124. }
  125. if (*out == '\0')
  126. l += scnprintf(out, sz - l, "N/A");
  127. if (hit)
  128. l += scnprintf(out + l, sz - l, " hit");
  129. if (miss)
  130. l += scnprintf(out + l, sz - l, " miss");
  131. return l;
  132. }
  133. static const char * const mem_lvl[] = {
  134. "N/A",
  135. "HIT",
  136. "MISS",
  137. "L1",
  138. "LFB",
  139. "L2",
  140. "L3",
  141. "Local RAM",
  142. "Remote RAM (1 hop)",
  143. "Remote RAM (2 hops)",
  144. "Remote Cache (1 hop)",
  145. "Remote Cache (2 hops)",
  146. "I/O",
  147. "Uncached",
  148. };
  149. static const char * const mem_lvlnum[] = {
  150. [PERF_MEM_LVLNUM_ANY_CACHE] = "Any cache",
  151. [PERF_MEM_LVLNUM_LFB] = "LFB",
  152. [PERF_MEM_LVLNUM_RAM] = "RAM",
  153. [PERF_MEM_LVLNUM_PMEM] = "PMEM",
  154. [PERF_MEM_LVLNUM_NA] = "N/A",
  155. };
  156. int perf_mem__lvl_scnprintf(char *out, size_t sz, struct mem_info *mem_info)
  157. {
  158. size_t i, l = 0;
  159. u64 m = PERF_MEM_LVL_NA;
  160. u64 hit, miss;
  161. int printed;
  162. if (mem_info)
  163. m = mem_info->data_src.mem_lvl;
  164. sz -= 1; /* -1 for null termination */
  165. out[0] = '\0';
  166. hit = m & PERF_MEM_LVL_HIT;
  167. miss = m & PERF_MEM_LVL_MISS;
  168. /* already taken care of */
  169. m &= ~(PERF_MEM_LVL_HIT|PERF_MEM_LVL_MISS);
  170. if (mem_info && mem_info->data_src.mem_remote) {
  171. strcat(out, "Remote ");
  172. l += 7;
  173. }
  174. printed = 0;
  175. for (i = 0; m && i < ARRAY_SIZE(mem_lvl); i++, m >>= 1) {
  176. if (!(m & 0x1))
  177. continue;
  178. if (printed++) {
  179. strcat(out, " or ");
  180. l += 4;
  181. }
  182. l += scnprintf(out + l, sz - l, mem_lvl[i]);
  183. }
  184. if (mem_info && mem_info->data_src.mem_lvl_num) {
  185. int lvl = mem_info->data_src.mem_lvl_num;
  186. if (printed++) {
  187. strcat(out, " or ");
  188. l += 4;
  189. }
  190. if (mem_lvlnum[lvl])
  191. l += scnprintf(out + l, sz - l, mem_lvlnum[lvl]);
  192. else
  193. l += scnprintf(out + l, sz - l, "L%d", lvl);
  194. }
  195. if (l == 0)
  196. l += scnprintf(out + l, sz - l, "N/A");
  197. if (hit)
  198. l += scnprintf(out + l, sz - l, " hit");
  199. if (miss)
  200. l += scnprintf(out + l, sz - l, " miss");
  201. return l;
  202. }
  203. static const char * const snoop_access[] = {
  204. "N/A",
  205. "None",
  206. "Hit",
  207. "Miss",
  208. "HitM",
  209. };
  210. int perf_mem__snp_scnprintf(char *out, size_t sz, struct mem_info *mem_info)
  211. {
  212. size_t i, l = 0;
  213. u64 m = PERF_MEM_SNOOP_NA;
  214. sz -= 1; /* -1 for null termination */
  215. out[0] = '\0';
  216. if (mem_info)
  217. m = mem_info->data_src.mem_snoop;
  218. for (i = 0; m && i < ARRAY_SIZE(snoop_access); i++, m >>= 1) {
  219. if (!(m & 0x1))
  220. continue;
  221. if (l) {
  222. strcat(out, " or ");
  223. l += 4;
  224. }
  225. l += scnprintf(out + l, sz - l, snoop_access[i]);
  226. }
  227. if (mem_info &&
  228. (mem_info->data_src.mem_snoopx & PERF_MEM_SNOOPX_FWD)) {
  229. if (l) {
  230. strcat(out, " or ");
  231. l += 4;
  232. }
  233. l += scnprintf(out + l, sz - l, "Fwd");
  234. }
  235. if (*out == '\0')
  236. l += scnprintf(out, sz - l, "N/A");
  237. return l;
  238. }
  239. int perf_mem__lck_scnprintf(char *out, size_t sz, struct mem_info *mem_info)
  240. {
  241. u64 mask = PERF_MEM_LOCK_NA;
  242. int l;
  243. if (mem_info)
  244. mask = mem_info->data_src.mem_lock;
  245. if (mask & PERF_MEM_LOCK_NA)
  246. l = scnprintf(out, sz, "N/A");
  247. else if (mask & PERF_MEM_LOCK_LOCKED)
  248. l = scnprintf(out, sz, "Yes");
  249. else
  250. l = scnprintf(out, sz, "No");
  251. return l;
  252. }
  253. int perf_script__meminfo_scnprintf(char *out, size_t sz, struct mem_info *mem_info)
  254. {
  255. int i = 0;
  256. i += perf_mem__lvl_scnprintf(out, sz, mem_info);
  257. i += scnprintf(out + i, sz - i, "|SNP ");
  258. i += perf_mem__snp_scnprintf(out + i, sz - i, mem_info);
  259. i += scnprintf(out + i, sz - i, "|TLB ");
  260. i += perf_mem__tlb_scnprintf(out + i, sz - i, mem_info);
  261. i += scnprintf(out + i, sz - i, "|LCK ");
  262. i += perf_mem__lck_scnprintf(out + i, sz - i, mem_info);
  263. return i;
  264. }
  265. int c2c_decode_stats(struct c2c_stats *stats, struct mem_info *mi)
  266. {
  267. union perf_mem_data_src *data_src = &mi->data_src;
  268. u64 daddr = mi->daddr.addr;
  269. u64 op = data_src->mem_op;
  270. u64 lvl = data_src->mem_lvl;
  271. u64 snoop = data_src->mem_snoop;
  272. u64 lock = data_src->mem_lock;
  273. /*
  274. * Skylake might report unknown remote level via this
  275. * bit, consider it when evaluating remote HITMs.
  276. */
  277. bool mrem = data_src->mem_remote;
  278. int err = 0;
  279. #define HITM_INC(__f) \
  280. do { \
  281. stats->__f++; \
  282. stats->tot_hitm++; \
  283. } while (0)
  284. #define P(a, b) PERF_MEM_##a##_##b
  285. stats->nr_entries++;
  286. if (lock & P(LOCK, LOCKED)) stats->locks++;
  287. if (op & P(OP, LOAD)) {
  288. /* load */
  289. stats->load++;
  290. if (!daddr) {
  291. stats->ld_noadrs++;
  292. return -1;
  293. }
  294. if (lvl & P(LVL, HIT)) {
  295. if (lvl & P(LVL, UNC)) stats->ld_uncache++;
  296. if (lvl & P(LVL, IO)) stats->ld_io++;
  297. if (lvl & P(LVL, LFB)) stats->ld_fbhit++;
  298. if (lvl & P(LVL, L1 )) stats->ld_l1hit++;
  299. if (lvl & P(LVL, L2 )) stats->ld_l2hit++;
  300. if (lvl & P(LVL, L3 )) {
  301. if (snoop & P(SNOOP, HITM))
  302. HITM_INC(lcl_hitm);
  303. else
  304. stats->ld_llchit++;
  305. }
  306. if (lvl & P(LVL, LOC_RAM)) {
  307. stats->lcl_dram++;
  308. if (snoop & P(SNOOP, HIT))
  309. stats->ld_shared++;
  310. else
  311. stats->ld_excl++;
  312. }
  313. if ((lvl & P(LVL, REM_RAM1)) ||
  314. (lvl & P(LVL, REM_RAM2)) ||
  315. mrem) {
  316. stats->rmt_dram++;
  317. if (snoop & P(SNOOP, HIT))
  318. stats->ld_shared++;
  319. else
  320. stats->ld_excl++;
  321. }
  322. }
  323. if ((lvl & P(LVL, REM_CCE1)) ||
  324. (lvl & P(LVL, REM_CCE2)) ||
  325. mrem) {
  326. if (snoop & P(SNOOP, HIT))
  327. stats->rmt_hit++;
  328. else if (snoop & P(SNOOP, HITM))
  329. HITM_INC(rmt_hitm);
  330. }
  331. if ((lvl & P(LVL, MISS)))
  332. stats->ld_miss++;
  333. } else if (op & P(OP, STORE)) {
  334. /* store */
  335. stats->store++;
  336. if (!daddr) {
  337. stats->st_noadrs++;
  338. return -1;
  339. }
  340. if (lvl & P(LVL, HIT)) {
  341. if (lvl & P(LVL, UNC)) stats->st_uncache++;
  342. if (lvl & P(LVL, L1 )) stats->st_l1hit++;
  343. }
  344. if (lvl & P(LVL, MISS))
  345. if (lvl & P(LVL, L1)) stats->st_l1miss++;
  346. } else {
  347. /* unparsable data_src? */
  348. stats->noparse++;
  349. return -1;
  350. }
  351. if (!mi->daddr.ms.map || !mi->iaddr.ms.map) {
  352. stats->nomap++;
  353. return -1;
  354. }
  355. #undef P
  356. #undef HITM_INC
  357. return err;
  358. }
  359. void c2c_add_stats(struct c2c_stats *stats, struct c2c_stats *add)
  360. {
  361. stats->nr_entries += add->nr_entries;
  362. stats->locks += add->locks;
  363. stats->store += add->store;
  364. stats->st_uncache += add->st_uncache;
  365. stats->st_noadrs += add->st_noadrs;
  366. stats->st_l1hit += add->st_l1hit;
  367. stats->st_l1miss += add->st_l1miss;
  368. stats->load += add->load;
  369. stats->ld_excl += add->ld_excl;
  370. stats->ld_shared += add->ld_shared;
  371. stats->ld_uncache += add->ld_uncache;
  372. stats->ld_io += add->ld_io;
  373. stats->ld_miss += add->ld_miss;
  374. stats->ld_noadrs += add->ld_noadrs;
  375. stats->ld_fbhit += add->ld_fbhit;
  376. stats->ld_l1hit += add->ld_l1hit;
  377. stats->ld_l2hit += add->ld_l2hit;
  378. stats->ld_llchit += add->ld_llchit;
  379. stats->lcl_hitm += add->lcl_hitm;
  380. stats->rmt_hitm += add->rmt_hitm;
  381. stats->tot_hitm += add->tot_hitm;
  382. stats->rmt_hit += add->rmt_hit;
  383. stats->lcl_dram += add->lcl_dram;
  384. stats->rmt_dram += add->rmt_dram;
  385. stats->nomap += add->nomap;
  386. stats->noparse += add->noparse;
  387. }