Home | History | Annotate | Download | only in util 
      1 #include <stdlib.h>
      2 
      3 #include "util.h"
      4 #include "values.h"
      5 
      6 void perf_read_values_init(struct perf_read_values *values)
      7 {
      8 	values->threads_max = 16;
      9 	values->pid = malloc(values->threads_max * sizeof(*values->pid));
     10 	values->tid = malloc(values->threads_max * sizeof(*values->tid));
     11 	values->value = malloc(values->threads_max * sizeof(*values->value));
     12 	if (!values->pid || !values->tid || !values->value)
     13 		die("failed to allocate read_values threads arrays");
     14 	values->threads = 0;
     15 
     16 	values->counters_max = 16;
     17 	values->counterrawid = malloc(values->counters_max
     18 				      * sizeof(*values->counterrawid));
     19 	values->countername = malloc(values->counters_max
     20 				     * sizeof(*values->countername));
     21 	if (!values->counterrawid || !values->countername)
     22 		die("failed to allocate read_values counters arrays");
     23 	values->counters = 0;
     24 }
     25 
     26 void perf_read_values_destroy(struct perf_read_values *values)
     27 {
     28 	int i;
     29 
     30 	if (!values->threads_max || !values->counters_max)
     31 		return;
     32 
     33 	for (i = 0; i < values->threads; i++)
     34 		free(values->value[i]);
     35 	free(values->pid);
     36 	free(values->tid);
     37 	free(values->counterrawid);
     38 	for (i = 0; i < values->counters; i++)
     39 		free(values->countername[i]);
     40 	free(values->countername);
     41 }
     42 
     43 static void perf_read_values__enlarge_threads(struct perf_read_values *values)
     44 {
     45 	values->threads_max *= 2;
     46 	values->pid = realloc(values->pid,
     47 			      values->threads_max * sizeof(*values->pid));
     48 	values->tid = realloc(values->tid,
     49 			      values->threads_max * sizeof(*values->tid));
     50 	values->value = realloc(values->value,
     51 				values->threads_max * sizeof(*values->value));
     52 	if (!values->pid || !values->tid || !values->value)
     53 		die("failed to enlarge read_values threads arrays");
     54 }
     55 
     56 static int perf_read_values__findnew_thread(struct perf_read_values *values,
     57 					    u32 pid, u32 tid)
     58 {
     59 	int i;
     60 
     61 	for (i = 0; i < values->threads; i++)
     62 		if (values->pid[i] == pid && values->tid[i] == tid)
     63 			return i;
     64 
     65 	if (values->threads == values->threads_max)
     66 		perf_read_values__enlarge_threads(values);
     67 
     68 	i = values->threads++;
     69 	values->pid[i] = pid;
     70 	values->tid[i] = tid;
     71 	values->value[i] = malloc(values->counters_max * sizeof(**values->value));
     72 	if (!values->value[i])
     73 		die("failed to allocate read_values counters array");
     74 
     75 	return i;
     76 }
     77 
     78 static void perf_read_values__enlarge_counters(struct perf_read_values *values)
     79 {
     80 	int i;
     81 
     82 	values->counters_max *= 2;
     83 	values->counterrawid = realloc(values->counterrawid,
     84 				       values->counters_max * sizeof(*values->counterrawid));
     85 	values->countername = realloc(values->countername,
     86 				      values->counters_max * sizeof(*values->countername));
     87 	if (!values->counterrawid || !values->countername)
     88 		die("failed to enlarge read_values counters arrays");
     89 
     90 	for (i = 0; i < values->threads; i++) {
     91 		values->value[i] = realloc(values->value[i],
     92 					   values->counters_max * sizeof(**values->value));
     93 		if (!values->value[i])
     94 			die("failed to enlarge read_values counters arrays");
     95 	}
     96 }
     97 
     98 static int perf_read_values__findnew_counter(struct perf_read_values *values,
     99 					     u64 rawid, const char *name)
    100 {
    101 	int i;
    102 
    103 	for (i = 0; i < values->counters; i++)
    104 		if (values->counterrawid[i] == rawid)
    105 			return i;
    106 
    107 	if (values->counters == values->counters_max)
    108 		perf_read_values__enlarge_counters(values);
    109 
    110 	i = values->counters++;
    111 	values->counterrawid[i] = rawid;
    112 	values->countername[i] = strdup(name);
    113 
    114 	return i;
    115 }
    116 
    117 void perf_read_values_add_value(struct perf_read_values *values,
    118 				u32 pid, u32 tid,
    119 				u64 rawid, const char *name, u64 value)
    120 {
    121 	int tindex, cindex;
    122 
    123 	tindex = perf_read_values__findnew_thread(values, pid, tid);
    124 	cindex = perf_read_values__findnew_counter(values, rawid, name);
    125 
    126 	values->value[tindex][cindex] = value;
    127 }
    128 
    129 static void perf_read_values__display_pretty(FILE *fp,
    130 					     struct perf_read_values *values)
    131 {
    132 	int i, j;
    133 	int pidwidth, tidwidth;
    134 	int *counterwidth;
    135 
    136 	counterwidth = malloc(values->counters * sizeof(*counterwidth));
    137 	if (!counterwidth)
    138 		die("failed to allocate counterwidth array");
    139 	tidwidth = 3;
    140 	pidwidth = 3;
    141 	for (j = 0; j < values->counters; j++)
    142 		counterwidth[j] = strlen(values->countername[j]);
    143 	for (i = 0; i < values->threads; i++) {
    144 		int width;
    145 
    146 		width = snprintf(NULL, 0, "%d", values->pid[i]);
    147 		if (width > pidwidth)
    148 			pidwidth = width;
    149 		width = snprintf(NULL, 0, "%d", values->tid[i]);
    150 		if (width > tidwidth)
    151 			tidwidth = width;
    152 		for (j = 0; j < values->counters; j++) {
    153 			width = snprintf(NULL, 0, "%" PRIu64, values->value[i][j]);
    154 			if (width > counterwidth[j])
    155 				counterwidth[j] = width;
    156 		}
    157 	}
    158 
    159 	fprintf(fp, "# %*s  %*s", pidwidth, "PID", tidwidth, "TID");
    160 	for (j = 0; j < values->counters; j++)
    161 		fprintf(fp, "  %*s", counterwidth[j], values->countername[j]);
    162 	fprintf(fp, "\n");
    163 
    164 	for (i = 0; i < values->threads; i++) {
    165 		fprintf(fp, "  %*d  %*d", pidwidth, values->pid[i],
    166 			tidwidth, values->tid[i]);
    167 		for (j = 0; j < values->counters; j++)
    168 			fprintf(fp, "  %*" PRIu64,
    169 				counterwidth[j], values->value[i][j]);
    170 		fprintf(fp, "\n");
    171 	}
    172 	free(counterwidth);
    173 }
    174 
    175 static void perf_read_values__display_raw(FILE *fp,
    176 					  struct perf_read_values *values)
    177 {
    178 	int width, pidwidth, tidwidth, namewidth, rawwidth, countwidth;
    179 	int i, j;
    180 
    181 	tidwidth = 3; /* TID */
    182 	pidwidth = 3; /* PID */
    183 	namewidth = 4; /* "Name" */
    184 	rawwidth = 3; /* "Raw" */
    185 	countwidth = 5; /* "Count" */
    186 
    187 	for (i = 0; i < values->threads; i++) {
    188 		width = snprintf(NULL, 0, "%d", values->pid[i]);
    189 		if (width > pidwidth)
    190 			pidwidth = width;
    191 		width = snprintf(NULL, 0, "%d", values->tid[i]);
    192 		if (width > tidwidth)
    193 			tidwidth = width;
    194 	}
    195 	for (j = 0; j < values->counters; j++) {
    196 		width = strlen(values->countername[j]);
    197 		if (width > namewidth)
    198 			namewidth = width;
    199 		width = snprintf(NULL, 0, "%" PRIx64, values->counterrawid[j]);
    200 		if (width > rawwidth)
    201 			rawwidth = width;
    202 	}
    203 	for (i = 0; i < values->threads; i++) {
    204 		for (j = 0; j < values->counters; j++) {
    205 			width = snprintf(NULL, 0, "%" PRIu64, values->value[i][j]);
    206 			if (width > countwidth)
    207 				countwidth = width;
    208 		}
    209 	}
    210 
    211 	fprintf(fp, "# %*s  %*s  %*s  %*s  %*s\n",
    212 		pidwidth, "PID", tidwidth, "TID",
    213 		namewidth, "Name", rawwidth, "Raw",
    214 		countwidth, "Count");
    215 	for (i = 0; i < values->threads; i++)
    216 		for (j = 0; j < values->counters; j++)
    217 			fprintf(fp, "  %*d  %*d  %*s  %*" PRIx64 "  %*" PRIu64,
    218 				pidwidth, values->pid[i],
    219 				tidwidth, values->tid[i],
    220 				namewidth, values->countername[j],
    221 				rawwidth, values->counterrawid[j],
    222 				countwidth, values->value[i][j]);
    223 }
    224 
    225 void perf_read_values_display(FILE *fp, struct perf_read_values *values, int raw)
    226 {
    227 	if (raw)
    228 		perf_read_values__display_raw(fp, values);
    229 	else
    230 		perf_read_values__display_pretty(fp, values);
    231 }
    232