Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
tools/rtla: Remove unneeded nr_cpus members
nr_cpus does not change at runtime, so keeping it in struct members is
unnecessary.
Use the global nr_cpus instead of struct members.
Signed-off-by: Costa Shulyupin <costa.shul@redhat.com>
Link: https://lore.kernel.org/r/20260306194953.2511960-4-costa.shul@redhat.com
Signed-off-by: Tomas Glozar <tglozar@redhat.com>
authored by
Costa Shulyupin
and committed by
Tomas Glozar
caf3fc0f
ea06305f
+38
-50
+8
-10
tools/tracing/rtla/src/osnoise_hist.c
+8
-10
tools/tracing/rtla/src/osnoise_hist.c
···
29
29
struct osnoise_hist_cpu *hist;
30
30
int entries;
31
31
int bucket_size;
32
-
int nr_cpus;
33
32
};
34
33
35
34
/*
···
40
41
int cpu;
41
42
42
43
/* one histogram for IRQ and one for thread, per CPU */
43
-
for (cpu = 0; cpu < data->nr_cpus; cpu++) {
44
+
for (cpu = 0; cpu < nr_cpus; cpu++) {
44
45
if (data->hist[cpu].samples)
45
46
free(data->hist[cpu].samples);
46
47
}
···
72
73
73
74
data->entries = entries;
74
75
data->bucket_size = bucket_size;
75
-
data->nr_cpus = nr_cpus;
76
76
77
77
data->hist = calloc(1, sizeof(*data->hist) * nr_cpus);
78
78
if (!data->hist)
···
244
246
if (!params->common.hist.no_index)
245
247
trace_seq_printf(s, "Index");
246
248
247
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
249
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
248
250
249
251
if (!data->hist[cpu].count)
250
252
continue;
···
273
275
if (!params->common.hist.no_index)
274
276
trace_seq_printf(trace->seq, "count:");
275
277
276
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
278
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
277
279
278
280
if (!data->hist[cpu].count)
279
281
continue;
···
285
287
if (!params->common.hist.no_index)
286
288
trace_seq_printf(trace->seq, "min: ");
287
289
288
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
290
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
289
291
290
292
if (!data->hist[cpu].count)
291
293
continue;
···
298
300
if (!params->common.hist.no_index)
299
301
trace_seq_printf(trace->seq, "avg: ");
300
302
301
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
303
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
302
304
303
305
if (!data->hist[cpu].count)
304
306
continue;
···
314
316
if (!params->common.hist.no_index)
315
317
trace_seq_printf(trace->seq, "max: ");
316
318
317
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
319
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
318
320
319
321
if (!data->hist[cpu].count)
320
322
continue;
···
349
351
trace_seq_printf(trace->seq, "%-6d",
350
352
bucket * data->bucket_size);
351
353
352
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
354
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
353
355
354
356
if (!data->hist[cpu].count)
355
357
continue;
···
385
387
if (!params->common.hist.no_index)
386
388
trace_seq_printf(trace->seq, "over: ");
387
389
388
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
390
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
389
391
390
392
if (!data->hist[cpu].count)
391
393
continue;
-3
tools/tracing/rtla/src/osnoise_top.c
-3
tools/tracing/rtla/src/osnoise_top.c
···
31
31
32
32
struct osnoise_top_data {
33
33
struct osnoise_top_cpu *cpu_data;
34
-
int nr_cpus;
35
34
};
36
35
37
36
/*
···
57
58
data = calloc(1, sizeof(*data));
58
59
if (!data)
59
60
return NULL;
60
-
61
-
data->nr_cpus = nr_cpus;
62
61
63
62
/* one set of histograms per CPU */
64
63
data->cpu_data = calloc(1, sizeof(*data->cpu_data) * nr_cpus);
+4
-6
tools/tracing/rtla/src/timerlat_aa.c
+4
-6
tools/tracing/rtla/src/timerlat_aa.c
···
102
102
* The analysis context and system wide view
103
103
*/
104
104
struct timerlat_aa_context {
105
-
int nr_cpus;
106
105
int dump_tasks;
107
106
enum stack_format stack_format;
108
107
···
758
759
irq_thresh = irq_thresh * 1000;
759
760
thread_thresh = thread_thresh * 1000;
760
761
761
-
for (cpu = 0; cpu < taa_ctx->nr_cpus; cpu++) {
762
+
for (cpu = 0; cpu < nr_cpus; cpu++) {
762
763
taa_data = timerlat_aa_get_data(taa_ctx, cpu);
763
764
764
765
if (irq_thresh && taa_data->tlat_irq_latency >= irq_thresh) {
···
786
787
787
788
printf("\n");
788
789
printf("Printing CPU tasks:\n");
789
-
for (cpu = 0; cpu < taa_ctx->nr_cpus; cpu++) {
790
+
for (cpu = 0; cpu < nr_cpus; cpu++) {
790
791
taa_data = timerlat_aa_get_data(taa_ctx, cpu);
791
792
tep = taa_ctx->tool->trace.tep;
792
793
···
812
813
if (!taa_ctx->taa_data)
813
814
return;
814
815
815
-
for (i = 0; i < taa_ctx->nr_cpus; i++) {
816
+
for (i = 0; i < nr_cpus; i++) {
816
817
taa_data = timerlat_aa_get_data(taa_ctx, i);
817
818
818
819
if (taa_data->prev_irqs_seq) {
···
862
863
struct timerlat_aa_data *taa_data;
863
864
int i;
864
865
865
-
for (i = 0; i < taa_ctx->nr_cpus; i++) {
866
+
for (i = 0; i < nr_cpus; i++) {
866
867
867
868
taa_data = timerlat_aa_get_data(taa_ctx, i);
868
869
···
1051
1052
1052
1053
__timerlat_aa_ctx = taa_ctx;
1053
1054
1054
-
taa_ctx->nr_cpus = nr_cpus;
1055
1055
taa_ctx->tool = tool;
1056
1056
taa_ctx->dump_tasks = dump_tasks;
1057
1057
taa_ctx->stack_format = stack_format;
+18
-20
tools/tracing/rtla/src/timerlat_hist.c
+18
-20
tools/tracing/rtla/src/timerlat_hist.c
···
44
44
struct timerlat_hist_cpu *hist;
45
45
int entries;
46
46
int bucket_size;
47
-
int nr_cpus;
48
47
};
49
48
50
49
/*
···
55
56
int cpu;
56
57
57
58
/* one histogram for IRQ and one for thread, per CPU */
58
-
for (cpu = 0; cpu < data->nr_cpus; cpu++) {
59
+
for (cpu = 0; cpu < nr_cpus; cpu++) {
59
60
if (data->hist[cpu].irq)
60
61
free(data->hist[cpu].irq);
61
62
···
93
94
94
95
data->entries = entries;
95
96
data->bucket_size = bucket_size;
96
-
data->nr_cpus = nr_cpus;
97
97
98
98
/* one set of histograms per CPU */
99
99
data->hist = calloc(1, sizeof(*data->hist) * nr_cpus);
···
202
204
{
203
205
struct timerlat_hist_data *data = tool->data;
204
206
int i, j, err;
205
-
long long value_irq[data->nr_cpus],
206
-
value_thread[data->nr_cpus],
207
-
value_user[data->nr_cpus];
207
+
long long value_irq[nr_cpus],
208
+
value_thread[nr_cpus],
209
+
value_user[nr_cpus];
208
210
209
211
/* Pull histogram */
210
212
for (i = 0; i < data->entries; i++) {
···
212
214
value_user);
213
215
if (err)
214
216
return err;
215
-
for (j = 0; j < data->nr_cpus; j++) {
217
+
for (j = 0; j < nr_cpus; j++) {
216
218
data->hist[j].irq[i] = value_irq[j];
217
219
data->hist[j].thread[i] = value_thread[j];
218
220
data->hist[j].user[i] = value_user[j];
···
224
226
value_irq, value_thread, value_user);
225
227
if (err)
226
228
return err;
227
-
for (i = 0; i < data->nr_cpus; i++) {
229
+
for (i = 0; i < nr_cpus; i++) {
228
230
data->hist[i].irq_count = value_irq[i];
229
231
data->hist[i].thread_count = value_thread[i];
230
232
data->hist[i].user_count = value_user[i];
···
234
236
value_irq, value_thread, value_user);
235
237
if (err)
236
238
return err;
237
-
for (i = 0; i < data->nr_cpus; i++) {
239
+
for (i = 0; i < nr_cpus; i++) {
238
240
data->hist[i].min_irq = value_irq[i];
239
241
data->hist[i].min_thread = value_thread[i];
240
242
data->hist[i].min_user = value_user[i];
···
244
246
value_irq, value_thread, value_user);
245
247
if (err)
246
248
return err;
247
-
for (i = 0; i < data->nr_cpus; i++) {
249
+
for (i = 0; i < nr_cpus; i++) {
248
250
data->hist[i].max_irq = value_irq[i];
249
251
data->hist[i].max_thread = value_thread[i];
250
252
data->hist[i].max_user = value_user[i];
···
254
256
value_irq, value_thread, value_user);
255
257
if (err)
256
258
return err;
257
-
for (i = 0; i < data->nr_cpus; i++) {
259
+
for (i = 0; i < nr_cpus; i++) {
258
260
data->hist[i].sum_irq = value_irq[i];
259
261
data->hist[i].sum_thread = value_thread[i];
260
262
data->hist[i].sum_user = value_user[i];
···
264
266
value_irq, value_thread, value_user);
265
267
if (err)
266
268
return err;
267
-
for (i = 0; i < data->nr_cpus; i++) {
269
+
for (i = 0; i < nr_cpus; i++) {
268
270
data->hist[i].irq[data->entries] = value_irq[i];
269
271
data->hist[i].thread[data->entries] = value_thread[i];
270
272
data->hist[i].user[data->entries] = value_user[i];
···
298
300
if (!params->common.hist.no_index)
299
301
trace_seq_printf(s, "Index");
300
302
301
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
303
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
302
304
303
305
if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
304
306
continue;
···
350
352
if (!params->common.hist.no_index)
351
353
trace_seq_printf(trace->seq, "count:");
352
354
353
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
355
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
354
356
355
357
if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
356
358
continue;
···
372
374
if (!params->common.hist.no_index)
373
375
trace_seq_printf(trace->seq, "min: ");
374
376
375
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
377
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
376
378
377
379
if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
378
380
continue;
···
400
402
if (!params->common.hist.no_index)
401
403
trace_seq_printf(trace->seq, "avg: ");
402
404
403
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
405
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
404
406
405
407
if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
406
408
continue;
···
428
430
if (!params->common.hist.no_index)
429
431
trace_seq_printf(trace->seq, "max: ");
430
432
431
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
433
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
432
434
433
435
if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
434
436
continue;
···
473
475
sum.min_thread = ~0;
474
476
sum.min_user = ~0;
475
477
476
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
478
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
477
479
478
480
if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
479
481
continue;
···
620
622
trace_seq_printf(trace->seq, "%-6d",
621
623
bucket * data->bucket_size);
622
624
623
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
625
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
624
626
625
627
if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
626
628
continue;
···
658
660
if (!params->common.hist.no_index)
659
661
trace_seq_printf(trace->seq, "over: ");
660
662
661
-
for_each_monitored_cpu(cpu, data->nr_cpus, ¶ms->common) {
663
+
for_each_monitored_cpu(cpu, nr_cpus, ¶ms->common) {
662
664
663
665
if (!data->hist[cpu].irq_count && !data->hist[cpu].thread_count)
664
666
continue;
+8
-11
tools/tracing/rtla/src/timerlat_top.c
+8
-11
tools/tracing/rtla/src/timerlat_top.c
···
41
41
42
42
struct timerlat_top_data {
43
43
struct timerlat_top_cpu *cpu_data;
44
-
int nr_cpus;
45
44
};
46
45
47
46
/*
···
69
70
data = calloc(1, sizeof(*data));
70
71
if (!data)
71
72
return NULL;
72
-
73
-
data->nr_cpus = nr_cpus;
74
73
75
74
/* one set of histograms per CPU */
76
75
data->cpu_data = calloc(1, sizeof(*data->cpu_data) * nr_cpus);
···
187
190
{
188
191
struct timerlat_top_data *data = tool->data;
189
192
int i, err;
190
-
long long value_irq[data->nr_cpus],
191
-
value_thread[data->nr_cpus],
192
-
value_user[data->nr_cpus];
193
+
long long value_irq[nr_cpus],
194
+
value_thread[nr_cpus],
195
+
value_user[nr_cpus];
193
196
194
197
/* Pull summary */
195
198
err = timerlat_bpf_get_summary_value(SUMMARY_CURRENT,
196
199
value_irq, value_thread, value_user);
197
200
if (err)
198
201
return err;
199
-
for (i = 0; i < data->nr_cpus; i++) {
202
+
for (i = 0; i < nr_cpus; i++) {
200
203
data->cpu_data[i].cur_irq = value_irq[i];
201
204
data->cpu_data[i].cur_thread = value_thread[i];
202
205
data->cpu_data[i].cur_user = value_user[i];
···
206
209
value_irq, value_thread, value_user);
207
210
if (err)
208
211
return err;
209
-
for (i = 0; i < data->nr_cpus; i++) {
212
+
for (i = 0; i < nr_cpus; i++) {
210
213
data->cpu_data[i].irq_count = value_irq[i];
211
214
data->cpu_data[i].thread_count = value_thread[i];
212
215
data->cpu_data[i].user_count = value_user[i];
···
216
219
value_irq, value_thread, value_user);
217
220
if (err)
218
221
return err;
219
-
for (i = 0; i < data->nr_cpus; i++) {
222
+
for (i = 0; i < nr_cpus; i++) {
220
223
data->cpu_data[i].min_irq = value_irq[i];
221
224
data->cpu_data[i].min_thread = value_thread[i];
222
225
data->cpu_data[i].min_user = value_user[i];
···
226
229
value_irq, value_thread, value_user);
227
230
if (err)
228
231
return err;
229
-
for (i = 0; i < data->nr_cpus; i++) {
232
+
for (i = 0; i < nr_cpus; i++) {
230
233
data->cpu_data[i].max_irq = value_irq[i];
231
234
data->cpu_data[i].max_thread = value_thread[i];
232
235
data->cpu_data[i].max_user = value_user[i];
···
236
239
value_irq, value_thread, value_user);
237
240
if (err)
238
241
return err;
239
-
for (i = 0; i < data->nr_cpus; i++) {
242
+
for (i = 0; i < nr_cpus; i++) {
240
243
data->cpu_data[i].sum_irq = value_irq[i];
241
244
data->cpu_data[i].sum_thread = value_thread[i];
242
245
data->cpu_data[i].sum_user = value_user[i];