-
Notifications
You must be signed in to change notification settings - Fork 168
/
lstopo-draw.c
1638 lines (1454 loc) · 55.4 KB
/
lstopo-draw.c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* Copyright © 2009 CNRS
* Copyright © 2009-2021 Inria. All rights reserved.
* Copyright © 2009-2013, 2015 Université Bordeaux
* Copyright © 2009-2011 Cisco Systems, Inc. All rights reserved.
* See COPYING in top-level directory.
*/
#include "private/autogen/config.h"
#include "hwloc.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include "lstopo.h"
#define EPOXY_R_COLOR 0xe7
#define EPOXY_G_COLOR 0xff
#define EPOXY_B_COLOR 0xb5
#define DARK_EPOXY_R_COLOR ((EPOXY_R_COLOR * 100) / 110)
#define DARK_EPOXY_G_COLOR ((EPOXY_G_COLOR * 100) / 110)
#define DARK_EPOXY_B_COLOR ((EPOXY_B_COLOR * 100) / 110)
#define DARKER_EPOXY_R_COLOR ((DARK_EPOXY_R_COLOR * 100) / 110)
#define DARKER_EPOXY_G_COLOR ((DARK_EPOXY_G_COLOR * 100) / 110)
#define DARKER_EPOXY_B_COLOR ((DARK_EPOXY_B_COLOR * 100) / 110)
#ifdef HWLOC_HAVE_GCC_W_MISSING_FIELD_INITIALIZERS
#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
#endif
/* each of these colors must be declared in declare_colors() */
struct lstopo_color BLACK_COLOR = { 0, 0, 0, 0 };
struct lstopo_color WHITE_COLOR = { 0xff, 0xff, 0xff, 0 };
struct lstopo_color PACKAGE_COLOR = { DARK_EPOXY_R_COLOR, DARK_EPOXY_G_COLOR, DARK_EPOXY_B_COLOR, 0 };
struct lstopo_color DIE_COLOR = { EPOXY_R_COLOR, EPOXY_G_COLOR, EPOXY_B_COLOR, 0 };
struct lstopo_color MEMORY_COLOR = { 0xef, 0xdf, 0xde, 0 };
struct lstopo_color MEMORIES_COLOR = { 0xf2, 0xe8, 0xe8, 0}; /* slightly lighter than MEMORY_COLOR */
struct lstopo_color CORE_COLOR = { 0xbe, 0xbe, 0xbe, 0 };
struct lstopo_color THREAD_COLOR = { 0xff, 0xff, 0xff, 0 };
struct lstopo_color BINDING_COLOR = { 0, 0xff, 0, 0 };
struct lstopo_color DISALLOWED_COLOR = { 0xff, 0, 0, 0 };
struct lstopo_color CACHE_COLOR = { 0xff, 0xff, 0xff, 0 };
struct lstopo_color MACHINE_COLOR = { 0xff, 0xff, 0xff, 0 };
struct lstopo_color GROUP_IN_PACKAGE_COLOR = { EPOXY_R_COLOR, EPOXY_G_COLOR, EPOXY_B_COLOR, 0 };
struct lstopo_color MISC_COLOR = { 0xff, 0xff, 0xff, 0 };
struct lstopo_color PCI_DEVICE_COLOR = { DARKER_EPOXY_R_COLOR, DARKER_EPOXY_G_COLOR, DARKER_EPOXY_B_COLOR, 0 };
struct lstopo_color OS_DEVICE_COLOR = { 0xde, 0xde, 0xde, 0 };
struct lstopo_color BRIDGE_COLOR = { 0xff, 0xff, 0xff, 0 };
#ifdef HWLOC_HAVE_GCC_W_MISSING_FIELD_INITIALIZERS
#pragma GCC diagnostic warning "-Wmissing-field-initializers"
#endif
static struct lstopo_color *colors = NULL;
static struct lstopo_color *
declare_color(struct lstopo_output *loutput, struct lstopo_color *color)
{
memset(&color->private, 0, sizeof(color->private));
/* call the backend callback if any */
if (loutput->methods->declare_color) {
int ret = loutput->methods->declare_color(loutput, color);
if (ret < 0)
return NULL;
}
/* insert */
color->next = colors;
colors = color;
return color;
}
void
declare_colors(struct lstopo_output *output)
{
/* don't bother looking for duplicate colors here,
* we want to be able to use those structs so always queue them
*/
declare_color(output, &BLACK_COLOR);
declare_color(output, &WHITE_COLOR);
declare_color(output, &PACKAGE_COLOR);
declare_color(output, &DIE_COLOR);
declare_color(output, &MEMORY_COLOR);
declare_color(output, &MEMORIES_COLOR);
declare_color(output, &CORE_COLOR);
declare_color(output, &THREAD_COLOR);
declare_color(output, &BINDING_COLOR);
declare_color(output, &DISALLOWED_COLOR);
declare_color(output, &CACHE_COLOR);
declare_color(output, &MACHINE_COLOR);
declare_color(output, &GROUP_IN_PACKAGE_COLOR);
declare_color(output, &MISC_COLOR);
declare_color(output, &PCI_DEVICE_COLOR);
declare_color(output, &OS_DEVICE_COLOR);
declare_color(output, &BRIDGE_COLOR);
}
void
destroy_colors(struct lstopo_output *loutput)
{
struct lstopo_color *tmp = colors;
while (tmp) {
struct lstopo_color *next = tmp->next;
if (loutput->methods->destroy_color)
loutput->methods->destroy_color(loutput, tmp);
if (tmp->free)
free(tmp);
tmp = next;
}
colors = NULL; /* so that it works after refresh */
}
static struct lstopo_color *
find_or_declare_rgb_color(struct lstopo_output *loutput, int r, int g, int b)
{
struct lstopo_color *color, *tmp;
for(tmp = colors; tmp; tmp = tmp->next)
if (tmp->r == r && tmp->g == g && tmp->b == b)
return tmp;
color = malloc(sizeof(*color));
if (!color)
return NULL;
color->r = r & 255;
color->g = g & 255;
color->b = b & 255;
color->free = 1;
tmp = declare_color(loutput, color);
if (!tmp)
free(color);
return tmp;
}
static unsigned
get_textwidth(void *output,
const char *text, unsigned length,
unsigned fontsize)
{
struct lstopo_output *loutput = output;
unsigned width;
#ifdef HWLOC_DEBUG
assert(loutput->methods->textsize);
#endif
loutput->methods->textsize(output, text, length, fontsize, &width);
width = loutput->text_xscale * ((float)width);
return width;
}
/*
* foo_draw functions take a OBJ, computes which size it needs, recurse into
* sublevels with drawing=PREPARE to recursively compute the needed size
* without actually drawing anything, then draw things about OBJ (chip draw,
* cache size information etc) at (X,Y), recurse into sublevels again to
* actually draw things, and return in RETWIDTH and RETHEIGHT the amount of
* space that the drawing took.
*
* For generic detailed comments, see the node_draw function.
*
* border is added around the objects
* separator is added between objects
*/
typedef void (*foo_draw)(struct lstopo_output *loutput, hwloc_obj_t obj, unsigned depth, unsigned x, unsigned y);
static foo_draw get_type_fun(hwloc_obj_type_t type);
/* next child, in all children list, with memory before CPU, ignoring PU if needed.
* similar to hwloc_get_next_child() but returns memory children first.
*/
#define NEXT_CHILD_INIT_STATE -1
static hwloc_obj_t next_child(struct lstopo_output *loutput, hwloc_obj_t parent, unsigned kind, hwloc_obj_t prev, int *statep)
{
int state;
hwloc_obj_t obj;
if (prev) {
obj = prev->next_sibling;
state = *statep;
} else {
obj = NULL;
state = NEXT_CHILD_INIT_STATE;
}
again:
if (!obj && state <= -1 && (kind & LSTOPO_CHILD_KIND_MEMORY)) {
obj = parent->memory_first_child;
state = 0;
}
if (!obj && state <= 0 && (kind & LSTOPO_CHILD_KIND_NORMAL)) {
obj = parent->first_child;
state = 1;
}
if (!obj && state <= 1 && (kind & LSTOPO_CHILD_KIND_IO)) {
obj = parent->io_first_child;
state = 2;
}
if (!obj && state <= 2 && (kind & LSTOPO_CHILD_KIND_MISC)) {
obj = parent->misc_first_child;
state = 3;
}
if (!obj)
return NULL;
if (loutput->factorize_enabled && parent->arity > loutput->factorize_min[obj->type]) {
if (((struct lstopo_obj_userdata *)obj->userdata)->factorized < 0) {
obj = obj->next_sibling;
goto again;
}
}
if (obj->type == HWLOC_OBJ_PU && loutput->ignore_pus) {
obj = obj->next_sibling;
goto again;
}
if (obj->type == HWLOC_OBJ_NUMANODE && loutput->ignore_numanodes) {
obj = obj->next_sibling;
goto again;
}
if (loutput->pci_collapse_enabled && obj->type == HWLOC_OBJ_PCI_DEVICE) {
struct lstopo_obj_userdata *lud = obj->userdata;
if (lud->pci_collapsed == -1) {
obj = obj->next_sibling;
goto again;
}
}
*statep = state;
return obj;
}
static float pci_link_speed(hwloc_obj_t obj)
{
if (obj->type == HWLOC_OBJ_PCI_DEVICE)
return obj->attr->pcidev.linkspeed;
if (obj->type == HWLOC_OBJ_BRIDGE && obj->attr->bridge.upstream_type == HWLOC_OBJ_BRIDGE_PCI)
return obj->attr->bridge.upstream.pci.linkspeed;
return 0.;
}
/********************************
* Placing children in rectangle
*/
/* preferred width/height compromise */
#define RATIO (4.f/3.f)
/* returns a score <= 1. close to 1 is better */
static __hwloc_inline
float rectangle_score(unsigned width, unsigned height, float ratio)
{
float score = ((float) width)/height/ratio;
if (score > 1)
score = 1/score;
return score;
}
static void find_children_rectangle(struct lstopo_output *loutput, hwloc_obj_t parent,
unsigned kind, unsigned separator,
unsigned *rowsp, unsigned *columnsp,
float ratio)
{
unsigned rows = 0, columns = 0, n;
unsigned numsubobjs = 0, obj_totwidth = 0, obj_totheight = 0;
unsigned obj_avgwidth, obj_avgheight;
unsigned area = 0;
float idealtotheight, under_score, over_score, best_score = 0.f;
hwloc_obj_t child;
int ncstate;
/* Total area for subobjects */
child = NULL;
while ((child=next_child(loutput, parent, kind, child, &ncstate)) != NULL) {
struct lstopo_obj_userdata *clud = child->userdata;
numsubobjs++;
obj_totwidth += clud->width + separator;
obj_totheight += clud->height + separator;
area += (clud->width + separator) * (clud->height + separator);
}
/* Average object size */
obj_avgwidth = obj_totwidth / numsubobjs;
obj_avgheight = obj_totheight / numsubobjs;
/* Try to find a rectangle fitting exactly */
for (n = (unsigned) (float) floor(sqrt(numsubobjs));
rows >= (unsigned) (float) ceil(pow(numsubobjs, 0.33)) && n > 1;
n--) {
float old_best_score = best_score;
unsigned p = numsubobjs / n;
float np_score; /* n rows x p columns */
float pn_score; /* p rows x n columns */
if (p <= 1 || p * n != numsubobjs)
continue;
/* Try both n*p and n*p rectangles */
np_score = rectangle_score(p * obj_avgwidth, obj_avgheight * n, ratio);
pn_score = rectangle_score(n * obj_avgwidth, obj_avgheight * p, ratio);
if (np_score > pn_score) {
if (np_score > best_score) {
rows = n;
columns = p;
best_score = np_score;
}
} else {
if (pn_score > best_score) {
rows = p;
columns = n;
best_score = pn_score;
}
}
if (old_best_score == best_score)
/* Score didn't improve, no need to try further.
* The graph score(n) is an inverted U, with np_score on the left and pn_score on the right.
* Se start somewhere in the middle and walk to both ends simultaneously,
* Only one side can improve towards the maximum, we stop once once it stops improving.
* The other side can just decrease for ever.
*/
goto done;
}
if (best_score)
/* We got a rectangle fitting exactly, it may not be perfect but it's good looking */
goto done;
/* Try to find a rectangle with an incomplete last row */
/* Ideal total height for spreading that area with ratio */
idealtotheight = (float) sqrt(area/ratio);
/* approximation of number of rows */
rows = (unsigned) (idealtotheight / obj_avgheight);
columns = rows ? (numsubobjs + rows - 1) / rows : 1;
/* Score obtained by underestimation */
under_score = rectangle_score(columns * obj_avgwidth, rows * obj_avgheight, ratio);
/* try to overestimate too */
rows++;
columns = (numsubobjs + rows - 1) / rows;
/* Score obtained by overestimation */
over_score = rectangle_score(columns * obj_avgwidth, rows * obj_avgheight, ratio);
/* Revert back to under estimation if it was better */
if (rows > 1 && under_score > over_score) {
rows--;
columns = (numsubobjs + rows - 1) / rows;
}
done:
*rowsp = rows;
*columnsp = columns;
}
/**************************
* Placing children
*/
static void
place_children_horiz(struct lstopo_output *loutput, hwloc_obj_t parent,
unsigned kind, unsigned border, unsigned separator,
unsigned *width, unsigned *height)
{
unsigned curx = 0;
unsigned maxh = 0;
hwloc_obj_t child;
int ncstate;
for(child = next_child(loutput, parent, kind, NULL, &ncstate);
child;
child = next_child(loutput, parent, kind, child, &ncstate)) {
struct lstopo_obj_userdata *clud = child->userdata;
clud->xrel = curx + border;
clud->yrel = border;
if (clud->height > maxh)
maxh = clud->height;
curx += separator + clud->width;
}
*width = curx - separator + 2*border;
*height = maxh + 2*border;
}
/* bridge object height: small empty box */
#define BRIDGE_HEIGHT (gridsize)
static void
place_children_vert(struct lstopo_output *loutput, hwloc_obj_t parent,
unsigned kind, unsigned border, unsigned separator,
unsigned *width, unsigned *height)
{
unsigned cury = 0;
unsigned maxw = 0;
unsigned gridsize = loutput->gridsize;
unsigned fontsize = loutput->fontsize;
int bridge_parent_with_pcilinkspeed = parent->type == HWLOC_OBJ_BRIDGE
&& loutput->show_text_enabled && loutput->show_text[HWLOC_OBJ_BRIDGE];
hwloc_obj_t child;
int ncstate;
for(child = next_child(loutput, parent, kind, NULL, &ncstate);
child;
child = next_child(loutput, parent, kind, child, &ncstate)) {
struct lstopo_obj_userdata *clud = child->userdata;
unsigned child_height = clud->height;
clud->xrel = border;
clud->yrel = cury + border;
if (clud->width > maxw)
maxw = clud->width;
if (bridge_parent_with_pcilinkspeed && pci_link_speed(child) != 0.)
/* make sure padding between children is enough to display pci link speed */
if (child_height <= BRIDGE_HEIGHT + fontsize)
child_height = BRIDGE_HEIGHT + fontsize;
cury += separator + child_height;
}
*width = maxw + 2*border;
*height = cury - separator + 2*border;
}
static void
place_children_rect(struct lstopo_output *loutput, hwloc_obj_t parent,
unsigned kind, unsigned border, unsigned separator,
unsigned *width, unsigned *height)
{
unsigned rows, columns;
unsigned totwidth, totheight; /* total children array size, without borders */
unsigned rowwidth; /* current row width */
unsigned maxheight; /* max height for current row */
hwloc_obj_t child;
int ncstate;
float ratio;
int i;
if (parent->type == HWLOC_OBJ_CORE)
ratio = 1/RATIO;
else
ratio = RATIO;
find_children_rectangle(loutput, parent, kind, separator, &rows, &columns, ratio);
rowwidth = 0;
maxheight = 0;
totwidth = 0;
totheight = 0;
for(i = 0, child = next_child(loutput, parent, kind, NULL, &ncstate);
child;
i++, child = next_child(loutput, parent, kind, child, &ncstate)) {
struct lstopo_obj_userdata *clud = child->userdata;
/* Newline? */
if (i && i%columns == 0) {
/* Update total width using new row */
if (rowwidth > totwidth)
totwidth = rowwidth;
rowwidth = 0;
/* Update total height */
totheight += maxheight + separator;
maxheight = 0;
}
/* Add new child */
clud->xrel = rowwidth + border;
clud->yrel = totheight + border;
rowwidth += clud->width + separator;
if (clud->height > maxheight)
maxheight = clud->height;
}
/* Update total width using last row */
if (rowwidth > totwidth)
totwidth = rowwidth;
/* Remove spurious separator on the right */
totwidth -= separator;
/* Update total height using last row */
totheight += maxheight; /* no separator */
*width = totwidth + 2*border;
*height = totheight + 2*border;
}
static void
place__children(struct lstopo_output *loutput, hwloc_obj_t parent,
unsigned kind,
enum lstopo_orient_e *orientp,
unsigned border, unsigned separator,
unsigned *widthp, unsigned *heightp)
{
if (*orientp == LSTOPO_ORIENT_HORIZ) {
/* force horizontal */
place_children_horiz(loutput, parent, kind, border, separator, widthp, heightp);
} else if (*orientp == LSTOPO_ORIENT_VERT) {
/* force vertical */
place_children_vert(loutput, parent, kind, border, separator, widthp, heightp);
} else {
/* NONE or forced RECT, do a rectangular placement */
place_children_rect(loutput, parent, kind, border, separator, widthp, heightp);
}
}
/* Recurse into children to get their size.
* Place them.
* Save their position and the parent total size for later.
*/
static void
place_children(struct lstopo_output *loutput, hwloc_obj_t parent,
unsigned xrel, unsigned yrel /* position of children within parent */)
{
struct lstopo_obj_userdata *plud = parent->userdata;
enum lstopo_orient_e orient = loutput->force_orient[parent->type];
unsigned border = loutput->gridsize;
unsigned separator = loutput->gridsize;
unsigned separator_below_cache = loutput->gridsize;
unsigned normal_children_separator = loutput->gridsize;
unsigned totwidth = plud->width, totheight = plud->height;
unsigned children_width = 0, children_height = 0;
unsigned above_children_width, above_children_height;
unsigned existing_kinds;
int normal_children_are_PUs;
hwloc_obj_t child;
int ncstate;
unsigned i;
/* defaults */
plud->children.box = 0;
plud->above_children.box = 0;
/* list the kinds of children that exist in that parent */
existing_kinds = (parent->arity ? LSTOPO_CHILD_KIND_NORMAL : 0)
| (parent->memory_arity ? LSTOPO_CHILD_KIND_MEMORY : 0)
| (parent->io_arity ? LSTOPO_CHILD_KIND_IO : 0)
| (parent->misc_arity ? LSTOPO_CHILD_KIND_MISC : 0);
/* now assign them below or above the parent */
if (loutput->plain_children_order || hwloc_obj_type_is_memory(parent->type)) {
plud->children.kinds = existing_kinds;
plud->above_children.kinds = 0;
} else {
plud->children.kinds = existing_kinds & ~LSTOPO_CHILD_KIND_MEMORY;
plud->above_children.kinds = existing_kinds & LSTOPO_CHILD_KIND_MEMORY;
}
/* bridge children always vertical */
if (parent->type == HWLOC_OBJ_BRIDGE)
orient = LSTOPO_ORIENT_VERT;
/* if factorizing children, use horizontal by default */
if (orient == LSTOPO_ORIENT_NONE
&& parent->symmetric_subtree
&& parent->first_child
&& loutput->factorize_enabled
&& parent->arity > loutput->factorize_min[parent->first_child->type]) {
orient = LSTOPO_ORIENT_HORIZ;
}
/* if there are memory children and using plain children layout, use horizontal by default */
if (orient == LSTOPO_ORIENT_NONE
&& parent->memory_arity
&& loutput->plain_children_order)
orient = LSTOPO_ORIENT_HORIZ;
/* recurse into children to prepare their sizes,
* and check whether all normal children are PUs. */
normal_children_are_PUs = (parent->arity > 0);
for(i = 0, child = next_child(loutput, parent, LSTOPO_CHILD_KIND_ALL, NULL, &ncstate);
child;
i++, child = next_child(loutput, parent, LSTOPO_CHILD_KIND_ALL, child, &ncstate)) {
get_type_fun(child->type)(loutput, child, 0, 0, 0);
if (hwloc_obj_type_is_normal(child->type) && child->type != HWLOC_OBJ_PU)
normal_children_are_PUs = 0;
}
if (!i)
return;
/* no separator between PUs */
if (normal_children_are_PUs)
normal_children_separator = 0;
/* add separator between a cache parent and its children */
if (hwloc_obj_type_is_cache(parent->type) || parent->type == HWLOC_OBJ_MEMCACHE) {
if (normal_children_are_PUs || parent->type == HWLOC_OBJ_MEMCACHE)
/* except between cache parent and PU children */
separator_below_cache = 0;
/* update children placement */
yrel += separator_below_cache;
}
/* place children below the parent */
if (plud->children.kinds)
place__children(loutput, parent, plud->children.kinds, &orient, 0, normal_children_separator, &children_width, &children_height);
/* place children above the parent, if any*/
if (plud->above_children.kinds) {
enum lstopo_orient_e morient = LSTOPO_ORIENT_HORIZ;
int need_box;
assert(plud->above_children.kinds == LSTOPO_CHILD_KIND_MEMORY);
/* we need a memory children box if parent isn't a memory object
* and if there are multiple objects in the box
*/
need_box = !hwloc_obj_type_is_memory(parent->type)
&& (parent->memory_arity + parent->memory_first_child->memory_arity > 1);
place__children(loutput, parent, plud->above_children.kinds, &morient, need_box ? border : 0, separator, &above_children_width, &above_children_height);
if (parent->type == HWLOC_OBJ_MEMCACHE)
above_children_height -= separator;
if (need_box) {
/* if there are multiple memory children, add a box, as large as the parent */
if (above_children_width < children_width) {
above_children_width = children_width;
}
plud->above_children.boxcolor = &MEMORIES_COLOR;
plud->above_children.box = 1;
} else {
/* if there's a single memory child without wide memory box, enlarge that child */
struct lstopo_obj_userdata *clud = parent->memory_first_child->userdata;
if (clud->width < children_width) {
clud->width = children_width;
above_children_width = children_width;
}
}
}
/* adjust parent size */
if (hwloc_obj_type_is_cache(parent->type) || parent->type == HWLOC_OBJ_MEMCACHE) {
/* cache children are below */
if (children_width > totwidth)
totwidth = children_width;
if (children_height)
totheight += children_height + separator_below_cache;
if (plud->above_children.kinds) {
totheight += above_children_height + separator;
if (above_children_width > totwidth)
totwidth = above_children_width;
}
} else if (parent->type == HWLOC_OBJ_BRIDGE) {
/* bridge children are on the right, within any space between bridge and children */
if (children_width)
totwidth += children_width;
if (children_height > totheight)
totheight = children_height;
} else {
/* normal objects have children inside their box, with space around them */
if (children_width + 2*border > totwidth)
totwidth = children_width + 2*border;
if (children_height)
totheight += children_height + border;
if (plud->above_children.kinds) {
totheight += above_children_height + separator;
if (above_children_width + 2*border > totwidth)
totwidth = above_children_width + 2*border;
}
}
/* save config for draw_children() later */
plud->orient = orient;
plud->width = totwidth;
plud->height = totheight;
plud->children.width = children_width;
plud->children.height = children_height;
plud->children.xrel = xrel;
plud->children.yrel = yrel;
if (plud->above_children.kinds) {
plud->above_children.width = above_children_width;
plud->above_children.height = above_children_height;
plud->above_children.xrel = xrel;
plud->above_children.yrel = yrel;
plud->children.yrel += above_children_height + separator;
}
}
/***********************
* Drawing children
*/
static void
draw__children(struct lstopo_output *loutput, hwloc_obj_t parent,
struct lstopo_children_position *children,
unsigned depth,
unsigned x, unsigned y)
{
hwloc_obj_t child;
int ncstate;
if (children->box)
loutput->methods->box(loutput, children->boxcolor, depth, x, children->width, y, children->height, parent, 1);
for(child = next_child(loutput, parent, children->kinds, NULL, &ncstate);
child;
child = next_child(loutput, parent, children->kinds, child, &ncstate)) {
struct lstopo_obj_userdata *clud = child->userdata;
get_type_fun(child->type)(loutput, child, depth-1, x + clud->xrel, y + clud->yrel);
}
}
static void
draw_children(struct lstopo_output *loutput, hwloc_obj_t parent, unsigned depth,
unsigned x, unsigned y)
{
struct lstopo_obj_userdata *plud = parent->userdata;
if (plud->children.kinds)
draw__children(loutput, parent, &plud->children, depth, x + plud->children.xrel, y + plud->children.yrel);
if (plud->above_children.kinds)
draw__children(loutput, parent, &plud->above_children, depth, x + plud->above_children.xrel, y + plud->above_children.yrel);
}
/*******
* Misc
*/
static int
lstopo_obj_snprintf(struct lstopo_output *loutput, char *text, size_t textlen, hwloc_obj_t obj)
{
enum lstopo_index_type_e index_type = loutput->index_type;
unsigned idx;
const char *indexprefix;
char typestr[32];
char indexstr[32]= "";
char index2str[32] = "";
char attrstr[256];
char totmemstr[64] = "";
int attrlen;
/* For Misc and Group, name replaces type+index+attrs */
if (obj->name && (obj->type == HWLOC_OBJ_MISC || obj->type == HWLOC_OBJ_GROUP)) {
return snprintf(text, textlen, "%s", obj->name);
}
/* For OSDev, OSDev-type+name replaces type+index+attrs */
if (obj->type == HWLOC_OBJ_OS_DEVICE) {
/* consider the name as an index and remove it if LSTOPO_INDEX_TYPE_NONE */
if (index_type != LSTOPO_INDEX_TYPE_NONE) {
hwloc_obj_type_snprintf(typestr, sizeof(typestr), obj, 0);
return snprintf(text, textlen, "%s %s", typestr, obj->name);
} else {
return hwloc_obj_type_snprintf(text, textlen, obj, 0);
}
}
/* subtype replaces the basic type name */
if (obj->subtype) {
snprintf(typestr, sizeof(typestr), "%s", obj->subtype);
} else {
hwloc_obj_type_snprintf(typestr, sizeof(typestr), obj, 0);
}
if (index_type == LSTOPO_INDEX_TYPE_DEFAULT) {
if (obj->type == HWLOC_OBJ_PU || obj->type == HWLOC_OBJ_NUMANODE) {
/* by default we show logical+physical for PU/NUMA */
idx = obj->logical_index;
indexprefix = " L#";
} else if (obj->type == HWLOC_OBJ_PACKAGE || obj->type == HWLOC_OBJ_DIE || obj->type == HWLOC_OBJ_CORE) {
/* logical only for package+core (so that we see easily how many packages/cores there are */
idx = obj->logical_index;
indexprefix = " L#";
} else {
/* nothing for others */
idx = HWLOC_UNKNOWN_INDEX;
indexprefix = "";
}
} else if (index_type == LSTOPO_INDEX_TYPE_LOGICAL) {
idx = obj->logical_index;
indexprefix = " L#";
} else if (index_type == LSTOPO_INDEX_TYPE_PHYSICAL) {
idx = obj->os_index;
indexprefix = " P#";
} else {
/* shutup the compiler */
idx = 0;
indexprefix = "";
}
if (loutput->show_indexes[obj->type]
&& index_type != LSTOPO_INDEX_TYPE_NONE
&& idx != (unsigned)-1 && obj->depth != 0
&& obj->type != HWLOC_OBJ_PCI_DEVICE
&& (obj->type != HWLOC_OBJ_BRIDGE || obj->attr->bridge.upstream_type == HWLOC_OBJ_BRIDGE_HOST))
snprintf(indexstr, sizeof(indexstr), "%s%u", indexprefix, idx);
if (index_type == LSTOPO_INDEX_TYPE_DEFAULT && obj->type == HWLOC_OBJ_NUMANODE && loutput->show_indexes[obj->type])
/* NUMA have both P# and L# on the same line (PU is split on 2 lines) */
snprintf(index2str, sizeof(index2str), " P#%u", obj->os_index);
if (loutput->show_attrs_enabled && loutput->show_attrs[obj->type]) {
attrlen = hwloc_obj_attr_snprintf(attrstr, sizeof(attrstr), obj, " ", 0);
/* display the root total_memory (cannot be local_memory since root cannot be a NUMA node) */
if (!obj->parent && obj->total_memory)
snprintf(totmemstr, sizeof(totmemstr), " (%lu%s total)",
(unsigned long) hwloc_memory_size_printf_value(obj->total_memory, 0),
hwloc_memory_size_printf_unit(obj->total_memory, 0));
} else
attrlen = 0;
if (attrlen > 0)
return snprintf(text, textlen, "%s%s%s (%s)%s", typestr, indexstr, index2str, attrstr, totmemstr);
else
return snprintf(text, textlen, "%s%s%s%s", typestr, indexstr, index2str, totmemstr);
}
static void
lstopo__prepare_custom_styles(struct lstopo_output *loutput, hwloc_obj_t obj)
{
struct lstopo_obj_userdata *lud = obj->userdata;
struct lstopo_style *s = &lud->style;
hwloc_obj_t child;
unsigned forcer, forceg, forceb;
const char *stylestr;
struct lstopo_color *lcolor;
lud->style_set = 0;
stylestr = hwloc_obj_get_info_by_name(obj, "lstopoStyle");
if (stylestr) {
while (*stylestr != '\0') {
if (sscanf(stylestr, "%02x%02x%02x", &forcer, &forceg, &forceb) == 3
|| sscanf(stylestr, "Background=#%02x%02x%02x", &forcer, &forceg, &forceb) == 3) {
lcolor = find_or_declare_rgb_color(loutput, forcer, forceg, forceb);
if (lcolor) {
s->bg = lcolor;
lud->style_set |= LSTOPO_STYLE_BG;
if (!(lud->style_set & LSTOPO_STYLE_T)) {
s->t = (lcolor->r + lcolor->g + lcolor->b < 0xff) ? &WHITE_COLOR : &BLACK_COLOR;
lud->style_set |= LSTOPO_STYLE_T;
}
}
} else if (sscanf(stylestr, "Text=#%02x%02x%02x", &forcer, &forceg, &forceb) == 3) {
lcolor = find_or_declare_rgb_color(loutput, forcer, forceg, forceb);
if (lcolor) {
s->t = lcolor;
lud->style_set |= LSTOPO_STYLE_T;
}
} else if (sscanf(stylestr, "Text2=#%02x%02x%02x", &forcer, &forceg, &forceb) == 3) {
lcolor = find_or_declare_rgb_color(loutput, forcer, forceg, forceb);
if (lcolor) {
s->t2 = lcolor;
lud->style_set |= LSTOPO_STYLE_T2;
}
}
stylestr = strchr(stylestr, ';');
if (!stylestr)
break;
stylestr++;
}
}
for_each_child(child, obj)
lstopo__prepare_custom_styles(loutput, child);
for_each_memory_child(child, obj)
lstopo__prepare_custom_styles(loutput, child);
for_each_io_child(child, obj)
lstopo__prepare_custom_styles(loutput, child);
for_each_misc_child(child, obj)
lstopo__prepare_custom_styles(loutput, child);
}
void
lstopo_prepare_custom_styles(struct lstopo_output *loutput)
{
lstopo__prepare_custom_styles(loutput, hwloc_get_root_obj(loutput->topology));
}
static void
lstopo_set_object_color(struct lstopo_output *loutput,
hwloc_obj_t obj,
struct lstopo_style *s)
{
struct lstopo_obj_userdata *lud = obj->userdata;
s->bg = &BLACK_COLOR;
s->t = &BLACK_COLOR;
s->t2 = &BLACK_COLOR;
switch (obj->type) {
case HWLOC_OBJ_MACHINE:
s->bg = &MACHINE_COLOR;
break;
case HWLOC_OBJ_GROUP: {
hwloc_obj_t parent;
s->bg = &MISC_COLOR;
parent = obj->parent;
while (parent) {
if (parent->type == HWLOC_OBJ_PACKAGE) {
s->bg = &GROUP_IN_PACKAGE_COLOR;
break;
}
parent = parent->parent;
}
break;
}
case HWLOC_OBJ_MISC:
s->bg = &MISC_COLOR;
break;
case HWLOC_OBJ_NUMANODE:
if (loutput->show_disallowed && lstopo_numa_disallowed(loutput, obj)) {
s->bg = &DISALLOWED_COLOR;
} else if (loutput->show_binding && lstopo_numa_binding(loutput, obj)) {
s->bg = &BINDING_COLOR;
} else {
s->bg = &MEMORY_COLOR;
}
break;
case HWLOC_OBJ_PACKAGE:
s->bg = &PACKAGE_COLOR;
break;
case HWLOC_OBJ_DIE:
s->bg = &DIE_COLOR;
break;
case HWLOC_OBJ_CORE:
s->bg = &CORE_COLOR;
break;
case HWLOC_OBJ_L1CACHE:
case HWLOC_OBJ_L2CACHE:
case HWLOC_OBJ_L3CACHE:
case HWLOC_OBJ_L4CACHE:
case HWLOC_OBJ_L5CACHE:
case HWLOC_OBJ_L1ICACHE:
case HWLOC_OBJ_L2ICACHE:
case HWLOC_OBJ_L3ICACHE:
case HWLOC_OBJ_MEMCACHE:
s->bg = &CACHE_COLOR;
break;
case HWLOC_OBJ_PU:
if (loutput->show_disallowed && lstopo_pu_disallowed(loutput, obj)) {
s->bg = &DISALLOWED_COLOR;
} else if (loutput->show_binding && lstopo_pu_binding(loutput, obj)) {
s->bg = &BINDING_COLOR;
} else {
s->bg = &THREAD_COLOR;
}
break;
case HWLOC_OBJ_BRIDGE:
s->bg = &BRIDGE_COLOR;
break;
case HWLOC_OBJ_PCI_DEVICE:
s->bg = &PCI_DEVICE_COLOR;
break;
case HWLOC_OBJ_OS_DEVICE:
s->bg = &OS_DEVICE_COLOR;
break;
default:
assert(0);
}
if (lud->style_set & LSTOPO_STYLE_BG)
s->bg = lud->style.bg;
if (lud->style_set & LSTOPO_STYLE_T)
s->t = lud->style.t;
if (lud->style_set & LSTOPO_STYLE_T2)
s->t2 = lud->style.t2;
}
static void
prepare_text(struct lstopo_output *loutput, hwloc_obj_t obj)
{
struct lstopo_obj_userdata *lud = obj->userdata;
unsigned fontsize = loutput->fontsize;
unsigned i;
int n;
/* sane defaults */
lud->ntext = 0;
lud->textwidth = 0;
if (!loutput->show_text_enabled || !loutput->show_text[obj->type])
return;
/* main object identifier line */
if (obj->type == HWLOC_OBJ_PCI_DEVICE && loutput->show_attrs_enabled && loutput->show_attrs[HWLOC_OBJ_PCI_DEVICE]) {
/* PCI text collapsing */
char busid[32];
char _text[64];
lstopo_obj_snprintf(loutput, _text, sizeof(_text), obj);
lstopo_busid_snprintf(loutput, busid, sizeof(busid), obj, lud->pci_collapsed, loutput->need_pci_domain);
if (loutput->pci_collapse_enabled && lud->pci_collapsed > 1) {
n = snprintf(lud->text[0].text, sizeof(lud->text[0].text), "%d x { %s %s }", lud->pci_collapsed, _text, busid);
} else {
n = snprintf(lud->text[0].text, sizeof(lud->text[0].text), "%s %s", _text, busid);
}
} else {
/* normal object text */
n = lstopo_obj_snprintf(loutput, lud->text[0].text, sizeof(lud->text[0].text), obj);
}
lud->ntext = 1;
/* additional lines of text */