Provided by: hwloc-nox_2.11.0-2_amd64 bug

NAME

       lstopo, lstopo-no-graphics, hwloc-ls - Show the topology of the system

SYNOPSIS

       lstopo [ options ]... [ filename ]

       lstopo-no-graphics [ options ]... [ filename ]

       hwloc-ls [ options ]... [ filename ]

       Note  that hwloc(7) provides a detailed explanation of the hwloc system; it should be read
       before reading this man page

OPTIONS

       --of <format>, --output-format <format>
              Enforce the output in the given format.  See the OUTPUT FORMATS section below.

       -i <path>, --input <path>
              Read the topology from <path> instead of discovering  the  topology  of  the  local
              machine.

              If <path> is a file, it may be a XML file exported by a previous hwloc program.  If
              <path> is "-", the standard input may be used as a XML file.

              On Linux, <path> may be a directory containing the  topology  files  gathered  from
              another machine topology with hwloc-gather-topology.

              On  x86,  <path>  may  be  a directory containing a cpuid dump gathered with hwloc-
              gather-cpuid.

              When the archivemount program is available, <path> may also be a tarball containing
              such Linux or x86 topology files.

       -i <specification>, --input <specification>
              Simulate  a  fake  hierarchy  (instead  of  discovering  the  topology on the local
              machine). If <specification> is "node:2 pu:3", the topology will contain  two  NUMA
              nodes with 3 processing units in each of them.  The <specification> string must end
              with a number of PUs.

       --if <format>, --input-format <format>
              Enforce the input in the given format, among xml, fsroot, cpuid and synthetic.

       --export-xml-flags <flags>
              Enforce flags when exporting to the XML format.  Flags  may  be  given  as  numeric
              values   or   as   a  comma-separated  list  of  flag  names  that  are  passed  to
              hwloc_topology_export_xml().  Those names may be substrings of actual flag names as
              long  as a single one matches.  A value of 1 (or v1) reverts to the format of hwloc
              v1.x.  The default is 0 (or none).

       --export-synthetic-flags <flags>
              Enforce flags when exporting to the  synthetic  format.   Flags  may  be  given  as
              numeric  values  or  as  a  comma-separated  list  of flag names that are passed to
              hwloc_topology_export_synthetic().  Those names may be substrings  of  actual  flag
              names  as  long  as a single one matches.  A value of 2 (or no_attr) reverts to the
              format of hwloc v1.9.  A value of 3 (or no_ext,no_attr)  reverts  to  the  original
              minimalistic format (before v1.9).  The default is 0 (or none).

       -v --verbose
              Include  additional  detail.   The hwloc-info tool may be used to display even more
              information about specific objects.

       -q --quiet -s --silent
              Reduce the amount of details to show.

       --distances
              Only display distance matrices.

       --distances-transform <links|merge-switch-ports|transitive-closure>
              Try applying a transformation to distances structures before displaying them.   See
              hwloc_distances_transform() for details.  More transformations may be applied using
              hwloc-annotate(1) (and it may save their output to XML).

       --memattrs
              Only display memory attributes.  All of  them  are  displayed  (while  the  default
              textual output selects memory attribute details depending on the verbosity level).

       --cpukinds
              Only  display  CPU kinds.  CPU kinds are displayed in order, starting from the most
              energy efficient ones up to the rather higher performance and power hungry ones.

       --windows-processor-groups
              On Windows, only  show  information  about  processor  groups.   All  of  them  are
              displayed,  while the default verbose output only shows them if there are more than
              one.

       -f --force
              If the destination file already exists, overwrite it.

       -l --logical
              Display hwloc logical indexes of all objects, with prefix "L#".  By  default,  both
              logical  and physical/OS indexes are displayed for PUs and NUMA nodes, logical only
              for cores, dies and packages, and no index for other types.

       -p --physical
              Display OS/physical indexes of all objects, with prefix  "P#".   By  default,  both
              logical  and physical/OS indexes are displayed for PUs and NUMA nodes, logical only
              for cores, dies and packages, and no index for other types.

       --logical-index-prefix <prefix>
              Replace " L#" with the given prefix for logical indexes.

       --os-index-prefix <prefix>
              Replace " P#" with the given prefix for physical/OS indexes.

       -c --cpuset
              Display the cpuset of each object.

       -C --cpuset-only
              Only display the cpuset of each object; do not  display  anything  else  about  the
              object.

       --cpuset-output-format <hwloc|list|taskset> --cof <hwloc|list|taskset>
              Change  the  format  of  displayed CPU set strings.  By default, the hwloc-specific
              format is used.  If list is given, the output is a comma-separated  of  numbers  or
              ranges, e.g. 2,4-5,8 .  If taskset is given, output cpusets are compatible with the
              taskset program (replaces the former --taskset option).

              This option should be combined with --cpuset or --cpuset-only,  otherwise  it  will
              imply --cpuset.

       --only <type>
              Only show objects of the given type in the textual output.

              <type> may contain a filter to select specific objects among the type. For instance
              --only NUMA[HBM] only shows NUMA nodes marked  with  subtype  "HBM",  while  --only
              "numa[mcdram]" only shows MCDRAM NUMA nodes on KNL.

       --filter <type>:<kind>, --filter <type>
              Filter  objects  of  type <type>, or of any type if <type> is "all".  "io", "cache"
              and "icache" are also supported.

              <kind> specifies the filtering behavior.  If "none" or not specified,  all  objects
              of  the  given  type  are  removed.   If  "all", all objects are kept as usual.  If
              "structure", objects are kept when  they  bring  structure  to  the  topology.   If
              "important"  (only  applicable  to  I/O),  only  important  objects  are kept.  See
              hwloc_topology_set_type_filter() for more details.

              hwloc supports filtering any type except PUs and NUMA nodes.  lstopo also offers PU
              and  NUMA  node  filtering by hiding them in the graphical and textual outputs, but
              any object included in them (for instance Misc) will be hidden as well.  Note  that
              PUs  and  NUMA nodes may not be ignored in the XML output.  Note also that the top-
              level object type cannot be ignored (usually Machine or System).

       --ignore <type>
              This is the old way to specify --filter <type>:none.

       --no-smt
              Ignore PUs.  This is identical to --filter PU:none.

       --no-caches
              Do not show caches.  This is identical to --filter cache:none.

       --no-useless-caches
              This is identical to --filter cache:structure.

       --no-icaches
              This is identical to --filter icache:none.

       --disallowed
              Include objects disallowed by administrative limitations (e.g  Cgroups  on  Linux).
              Offline PUs and NUMA nodes are still ignored.

       --allow <all|local|0xff|nodeset=0xf0>
              Include objects disallowed by administrative limitations (implies --disallowed) and
              also change the set of allowed ones.

              If local is given, only objects  available  to  the  current  process  are  allowed
              (default  behavior  when loading from the native operating system backend).  It may
              be  useful  if  the  topology  was  created  by  another  process  (with  different
              administrative  restrictions such as Linux Cgroups) and loaded here loaded from XML
              or synthetic.  This case implies --thissystem.

              If all, all objects are allowed.

              If a bitmap is given as a hexadecimal string, it is used as the set of allowed PUs.

              If a bitmap is given after prefix nodeset=, it is the set of allowed NUMA nodes.

       --flags <flags>
              Enforce topology flags.  Flags may be given  as  numeric  values  or  as  a  comma-
              separated  list of flag names that are passed to hwloc_topology_set_flags().  Those
              names may be substrings of actual flag names as long as a single one  matches,  for
              instance disallowed,thissystem_allowed.  The default is 8 (or import).

       --merge
              Do   not   show  levels  that  do  not  have  a  hierarchical  impact.   This  sets
              HWLOC_TYPE_FILTER_KEEP_STRUCTURE for  all  object  types.   This  is  identical  to
              --filter all:structure.

       --no-factorize --no-factorize=<type>
              Never factorize identical objects in the graphical output.

              If  an  object  type is given, only factorizing of these objects is disabled.  This
              only applies to normal CPU-side objects, it is independent from PCI collapsing.

       --factorize --factorize=[<type>,]<N>[,<L>[,<F>]
              Factorize identical children in the graphical output (enabled by default).

              If <N> is specified (4 by default), factorizing only occurs when there are strictly
              more than N identical children.  If <L> and <F> are specified, they set the numbers
              of first and last children to keep after factorizing.

              If an object type is given, only factorizing of these objects is configured.   This
              only applies to normal CPU-side object, it is independent from PCI collapsing.

       --no-collapse
              Do  not  collapse identical PCI devices.  By default, identical sibling PCI devices
              (such as many virtual functions inside a single physical device) are collapsed.

       --no-cpukinds
              Do not show different kinds of CPUs in the  graphical  output.   By  default,  when
              supported, different types of lines, thickness and bold font may be used to display
              PU boxes of different kinds.

       --restrict <cpuset>
              Restrict the topology to the given cpuset.  This removes some PUs  and  their  now-
              child-less parents.

              Beware  that  restricting  the  PUs in a topology may change the logical indexes of
              many objects, including NUMA nodes.

       --restrict nodeset=<nodeset>
              Restrict the topology to the given  nodeset.   (unless  --restrict-flags  specifies
              something  different).   This  removes  some  NUMA  nodes  and their now-child-less
              parents.

              Beware that restricting the NUMA nodes in a topology may change the logical indexes
              of many objects, including PUs.

       --restrict binding
              Restrict the topology to the current process binding.  This option requires the use
              of the actual current machine topology (or any other topology with --thissystem  or
              with HWLOC_THISSYSTEM set to 1 in the environment).

              Beware  that  restricting  the  topology  may  change  the  logical indexes of many
              objects, including PUs and NUMA nodes.

       --restrict-flags <flags>
              Enforce flags when restricting the topology.  Flags may be given as numeric  values
              or   as   a   comma-separated   list   of   flag   names   that   are   passed   to
              hwloc_topology_restrict().  Those names may be substrings of actual flag  names  as
              long as a single one matches, for instance bynodeset,memless.  The default is 0 (or
              none).

       --no-io
              Do not show any I/O device or bridge.  This is identical to --filter  io:none.   By
              default,   common   devices  (GPUs,  NICs,  block  devices,  ...)  and  interesting
              bridges/switches are shown.

       --no-bridges
              Do not show any I/O bridge except  hostbridges.   This  is  identical  to  --filter
              bridge:none.   By  default,  common  devices  (GPUs,  NICs, block devices, ...) and
              interesting bridges/switches are shown.

       --whole-io
              Show all I/O devices and bridges.   This  is  identical  to  --filter  io:all.   By
              default,  only  common  devices  (GPUs,  NICs,  block devices, ...) and interesting
              bridges/switches are shown.

       --thissystem
              Assume that the selected backend provides the topology for the system on  which  we
              are running.  This is useful when loading a custom topology such as an XML file and
              using --restrict binding or --allow all.

       --pid <pid>
              Detect topology as seen by  process  <pid>,  i.e.  as  if  process  <pid>  did  the
              discovery  itself.   Note  that  this  can  for  instance change the set of allowed
              processors.  Also show this process current CPU and Memory binding by  marking  the
              corresponding  PUs and NUMA nodes (in Green in the graphical output, see the COLORS
              section below, or by appending (binding) to the verbose  text  output).   If  0  is
              given as pid, the current binding for the lstopo process will be shown.

       --ps --top
              Show  existing  processes  as  misc  objects  in  the  output.  To  avoid uselessly
              cluttering the output, only processes that are  restricted  to  some  part  of  the
              machine  are  shown.   On  Linux,  kernel threads are not shown.  If many processes
              appear, the output may become hard to read anyway, making the hwloc-ps program more
              practical.

              See --misc-from for a customizable variant using hwloc-ps.

       --misc-from <file>
              Add Misc objects as described in <file> containing entries such as:

                  name=myMisc1
                  cpuset=0x5

                  name=myMisc2
                  cpuset=0x7
                  subtype=myOptionalSubtype

              This  is  useful  for  combining  with  hwloc-ps --lstopo-misc (see EXAMPLES below)
              because hwloc-ps is far more customizable than lstopo's --top option.

       --children-order <order>
              Change the order of the different kinds of children with respect to their parent in
              the graphical output.  <order> may be a comma-separated list of keywords among:

              memory:above displays memory children above other children (and above the parent if
              it is a cache).  PUs are therefore below their local NUMA  nodes,  like  hwloc  1.x
              did.

              io:right and misc:right place I/O or Misc children on the right of CPU children.

              io:below  and misc:below place I/O or Misc children below CPU children.

              plain places everything not specified together with normal CPU children.

              If  only  plain  is  specified, lstopo displays the topology in a basic manner that
              strictly matches the actual tree: Memory, I/O and Misc children  are  listed  below
              their  parent  just  like  any other child.  PUs are therefore on the side of their
              local NUMA nodes, below a common ancestor.   This  output  may  result  in  strange
              layouts  since  the  size  of  Memory,  CPU and I/O children may be very different,
              causing the placement algorithm to poorly arrange them in rows.

              The default order is memory:above,io:right,misc:right which means  Memory  children
              are above CPU children while I/O and Misc are together on the right.

              Up to hwloc 2.5, the default was rather to memory:above,plain.

              Additionally,  memory:above,  io:right,  io:below, misc:right and misc:below may be
              suffixed with  :horiz,  :vert  or  :rect  to  force  the  horizontal,  vertical  or
              rectangular layout of children inside these sections.

              See also the GRAPHICAL OUTPUT and LAYOUT sections below.

       --fontsize <size>
              Set the size of text font in the graphical output.

              The default is 10.

              Boxes  are  scaled  according to the text size.  The LSTOPO_TEXT_XSCALE environment
              variable may be used to further scale the width of  boxes  (its  default  value  is
              1.0).

              The --fontsize option is ignored in the ASCII backend.

       --gridsize <size>
              Set the margin between elements in the graphical output.

              The default is 7. It was 10 prior to hwloc 2.1.

              This option is ignored in the ASCII backend.

       --linespacing <size>
              Set the spacing between lines of text in the graphical output.

              The default is 4.

              The option was included in --gridsize prior to hwloc 2.1 (and its default was 10).

              This option is ignored in the ASCII backend.

       --thickness <size>
              Set the thickness of lines and boxes in the graphical output.

              The default is 1.

              This option is ignored in the ASCII backend.

       --horiz, --horiz=<type1,...>
              Force  a  horizontal  graphical layout instead of nearly 4/3 ratio in the graphical
              output.  If a comma-separated list of  object  types  is  given,  the  layout  only
              applies  to  the  corresponding container objects.  Ignored for bridges since their
              children are always vertically aligned.

       --vert, --vert=<type1,...>
              Force a vertical graphical layout instead of nearly  4/3  ratio  in  the  graphical
              output.   If  a  comma-separated  list  of  object  types is given, the layout only
              applies to the corresponding container objects.

       --rect, --rect=<type1,...>
              Force a rectangular graphical layout with nearly 4/3 ratio in the graphical output.
              If  a comma-separated list of object types is given, the layout only applies to the
              corresponding container objects.  Ignored for  bridges  since  their  children  are
              always vertically aligned.

       --no-text, --no-text=<type1,...>
              Do  not  display  any  text in boxes in the graphical output.  If a comma-separated
              list of object types is given, text is  disabled  for  the  corresponding  objects.
              This is mostly useful for removing text from Group objects.

       --text, --text=<type1,...>
              Display text in boxes in the graphical output (default).  If a comma-separated list
              of object types is given, text is reenabled for the corresponding  objects  (if  it
              was previously disabled with --no-text).

       --no-index, --no-index=<type1,...>
              Do  not  show object indexes in the graphical output.  If a comma-separated list of
              object types is given, indexes are disabled for the corresponding objects.

       --index, --index=<type1,...>
              Show object indexes in the graphical output (default).  If a  comma-separated  list
              of  object  types is given, indexes are reenabled for the corresponding objects (if
              they were previously disabled with --no-index).

       --no-attrs, --no-attrs=<type1,...>
              Do not show object attributes (such as memory size, cache size,  PCI  bus  ID,  PCI
              link  speed,  etc.)   in the graphical output.  If a comma-separated list of object
              types is given, attributes are disabled for the corresponding objects.

       --attrs, --attrs=<type1,...>
              Show object attributes (such as memory size, cache  size,  PCI  bus  ID,  PCI  link
              speed,  etc.)   in  the  graphical  output (default).  If a comma-separated list of
              object types is given, attributes are reenabled for the corresponding  objects  (if
              they were previously disabled with --no-attrs).

       --no-legend
              Remove all text legend lines at the bottom of the graphical output.

       --no-default-legend
              Remove default text legend lines at the bottom of the graphical output.  User-added
              legend lines with --append-legend or the "lstopoLegend" info are still displayed if
              any.

       --append-legend <line>
              Append  the  line  of text to the bottom of the legend in the graphical output.  If
              adding multiple lines, each line should be given separately by passing this  option
              multiple  times.  Additional legend lines may also be specified inside the topology
              using the "lstopoLegend" info attributes on the topology root object.

       --grey, --greyscale
              Use greyscale instead of colors in the graphical output.

       --palette <grey|greyscale|defaut|colors|white|none>
              Change the color palette.  Passing grey or greyscale is identical to passing --grey
              or  --greyscale.   Passing  white  or none uses white instead of colors for all box
              backgrounds.  Passing default or colors reverts back to the default color palette.

       --palette type=#rrggbb
              Replace the color of the given box type  with  the  given  3x8bit  hexadecimal  RGB
              combination  (e.g.  #ff0000  is  red).  Existing types are machine, group, package,
              group_in_package, die, core, pu, numanode, memories (box containing multiple memory
              children), cache, pcidev, osdev, bridge, and misc.

              See also CUSTOM COLOR below for customizing individual objects.

       --binding-color <none|#rrggbb>
              Do  not  colorize  PUs  and  NUMA  nodes  according to the binding in the graphical
              output.  Or change the color to the given 3x8bit hexadecimal RGB combination  (e.g.
              #ff0000 is red).

       --disallowed-color <none|#rrggbb>
              Do  not  colorize disallowed PUs and NUMA nodes in the graphical output.  Or change
              the color to the given 3x8bit hexadecimal RGB combination (e.g. #00ff00 is green).

       --top-color <none|#rrggbb>
              Do not colorize task objects in the graphical  output  when  --top  is  given.   Or
              change  the  color to the given 3x8bit hexadecimal RGB combination (e.g. #0000ff is
              blue).  This is actually applied to Misc objects of subtype Process or Thread.

       --version
              Report version and exit.

       -h --help
              Display help message and exit.

DESCRIPTION

       lstopo and lstopo-no-graphics are capable of displaying a topological map of the system in
       a  variety of different output formats.  The only difference between lstopo and lstopo-no-
       graphics is that graphical outputs are only supported by lstopo, to reduce dependencies on
       external libraries.  hwloc-ls is identical to lstopo-no-graphics.

       The  filename  specified  directly  implies  the  output format that will be used; see the
       OUTPUT FORMATS section, below.  Output formats that support color will  indicate  specific
       characteristics about individual CPUs by their color; see the COLORS section, below.

OUTPUT FORMATS

       By  default,  if no output filename is specified, the output is sent to a graphical window
       if possible in the current environment (DISPLAY environment variable set on  Unix,  etc.).
       Otherwise,  a text summary is displayed in the console.  The console is also used when the
       program runs from a terminal and the output is  redirected  to  a  pipe  or  file.   These
       default  behaviors  may  be  changed by passing --of console to force console mode or --of
       window for graphical window.

       The filename on the command line usually determines the format of the output.  There are a
       few  filenames  that indicate specific output formats and devices (e.g., a filename of "-"
       will output a text summary to stdout), but most  filenames  indicate  the  desired  output
       format by their suffix (e.g., "topo.png" will output a PNG-format file).

       The  format  of the output may also be changed with "--of".  For instance, "--of pdf" will
       generate a PDF-format file on the standard output, while "--of fig  toto"  will  output  a
       Xfig-format file named "toto".

       The  list  of  currently  supported  formats  is given below. Any of them may be used with
       "--of" or as a filename suffix.

       default
              Send the output to a window or to the console depending on the environment.

       window Send the output to a graphical window.

       console
              Send a text summary to stdout.  Binding or unallowed processors are only  annotated
              in this mode if verbose; see the COLORS section, below.

       ascii  Output an ASCII art representation of the map (formerly called txt).  If outputting
              to stdout and if  colors  are  supported  on  the  terminal,  the  output  will  be
              colorized.

       tikz or tex
              Output  a  LaTeX  tikzpicture representation of the map that can be compiled with a
              LaTeX compiler.

       fig    Output a representation of the map that can be loaded in Xfig.

       svg    Output a SVG representation of the map, using Cairo (by default, if supported) or a
              native SVG backend (fallback, always supported).  See cairosvg and nativesvg below.

       cairosvg or svg(cairo)
              If  lstopo was compiled with the proper support, output a SVG representation of the
              map using Cairo.

       nativesvg or svg(native)
              Output a SVG representation of the map using the native SVG  backend.   It  may  be
              less pretty than the Cairo output, but it is always supported, and SVG objects have
              attributes for identifying and manipulating them.  See dynamic_SVG_example.html for
              an example.

       pdf    If lstopo was compiled with the proper support, lstopo outputs a PDF representation
              of the map.

       ps     If lstopo was compiled  with  the  proper  support,  lstopo  outputs  a  Postscript
              representation of the map.

       png    If lstopo was compiled with the proper support, lstopo outputs a PNG representation
              of the map.

       synthetic
              If the topology  is  symmetric  (which  requires  that  the  root  object  has  its
              symmetric_subtree  field set), lstopo outputs a synthetic description string.  This
              output may be reused as an input synthetic topology description  later.   See  also
              the  Synthetic  topologies  section  in  the documentation.  Note that Misc and I/O
              devices are ignored during this export.

       xml    lstopo outputs an XML representation of the map.  It may be reused later,  even  on
              another  machine,  with  lstopo --input, the HWLOC_XMLFILE environment variable, or
              the hwloc_topology_set_xml() function.

       The following special names may be used:

       -      Send a text summary to stdout.

       /dev/stdout
              Send a text summary to stdout.  It is effectively the same as specifying "-".

       -.<format>
              If the entire filename is "-.<format>", lstopo behaves as if "--of <format> -"  was
              given, which means a file of the given format is sent to the standard output.

       See the output of "lstopo --help" for a specific list of what graphical output formats are
       supported in your hwloc installation.

GRAPHICAL OUTPUT

       The graphical output is made of nested boxes representing the inclusion of objects in  the
       hierarchy of resources.  Usually a Machine box contains one or several Package boxes, that
       contain multiple Core boxes, with one or several PUs each.

   Caches
       Caches are displayed in a slightly different manner because they do not  actually  include
       computing  resources such as cores.  For instance, a L2 Cache shared by a pair of Cores is
       drawn as a Cache box on top of two Core boxes (instead of having  Core  boxes  inside  the
       Cache box).

   NUMA nodes and Memory-side Caches
       By  default,  NUMA  nodes  boxes are drawn on top of their local computing resources.  For
       instance, a processor Package containing one NUMA node and four Cores is  displayed  as  a
       Package  box  containing the NUMA node box above four Core boxes.  If a NUMA node is local
       to the L3 Cache, the NUMA node is displayed above  that  Cache  box.   All  this  specific
       drawing  strategy  for  memory  objects  may  be  disabled  by passing command-line option
       --children-order plain.

       If multiple NUMA nodes are attached to the same parent object, they are  displayed  inside
       an additional unnamed memory box.

       If  some  Memory-side  Caches  exist  in front of some NUMA nodes, they are drawn as boxes
       immediately above them.

   PCI bridges, PCI devices and OS devices
       The PCI hierarchy is not drawn as a set of included boxes but rather as a tree of  bridges
       (that  may  actually  be  switches) with links between them.  The tree starts with a small
       square on the left for the hostbridge or root complex.  It ends with PCI device  boxes  on
       the  right.   Intermediate  PCI bridges/switches may appear as additional small squares in
       the middle.

       PCI devices on the right of the tree are boxes  containing  their  PCI  bus  ID  (such  as
       00:02.3).   They  may  also  contain  sub-boxes  for  OS  device objects such as a network
       interface eth0 or a CUDA GPU cuda0.

       When there is a single link (horizontal line) on the right of a PCI bridge, it means  that
       a  single device or bridge is connected on the secondary PCI bus behind that bridge.  When
       there is a vertical line, it means that multiple devices and/or bridges are  connected  to
       the same secondary PCI bus.

       The  datarate  of  a  PCI link may be written (in GB/s) right below its drawn line (if the
       operating system and/or libraries are able to report that information).  This datarate  is
       the  currently  configured  speed  of the entire PCI link (sum of the bandwidth of all PCI
       lanes in that link).  It may change during execution since some devices are able  to  slow
       their PCI links down when idle.

LAYOUT

       In its graphical output, lstopo uses simple rectangular heuristics to try to achieve a 4/3
       ratio between  width  and  height.   Although  the  hierarchy  of  resources  is  properly
       reflected,  the exact physical organization (NUMA distances, rings, complete graphs, etc.)
       is currently ignored.

       The layout of a level may be changed with --vert, --horiz, and --rect to  force  a  parent
       object   to   arrange   its  children  in  vertical,  horizontal  or  rectangular  manners
       respectively.

       The position of Memory, I/O and Misc children with respect to other children  objects  may
       be  changed  using  --children-order.   This  effectivement divides children into multiple
       sections.  The layout of children is first computed inside each section,  before  sections
       are placed inside (or below) the parent box.

       The  vertical/horizontal/rectangular  layout  of  these  additional  sections  may also be
       configured through --children-order.

COLORS

       Individual CPUs and NUMA nodes are colored in the graphical  output  formats  to  indicate
       different characteristics:

       Green  The  topology  is reported as seen by a specific process (see --pid), and the given
              CPU or NUMA node is in this process CPU or Memory binding mask.

       White  The CPU or NUMA node is in the  allowed  set  (see  below).   If  the  topology  is
              reported  as seen by a specific process (see --pid), the object is also not in this
              process binding mask.

       Red    The CPU or NUMA node is not in the allowed set (see below).

       The "allowed set" is the set of CPUs or NUMA nodes to which the current process is allowed
       to  bind.   The  allowed set is usually either inherited from the parent process or set by
       administrative qpolicies on the system.  Linux cpusets are one  example  of  limiting  the
       allowed  set  for  a process and its children to be less than the full set of CPUs or NUMA
       nodes on the system.

       Different processes may therefore have different CPUs or NUMA nodes in  the  allowed  set.
       Hence,  invoking  lstopo  in  different  contexts  and/or  as  different users may display
       different colors for the same individual CPUs (e.g., running lstopo  in  one  context  may
       show  a  specific  CPU as red, but running lstopo in a different context may show the same
       CPU as white).

       Some lstopo output modes, e.g. the console mode (default  non-graphical  output),  do  not
       support  colors  at all.  The console mode displays the above characteristics by appending
       text to each PU line if verbose messages are enabled.

CUSTOM COLORS

       The colors of different kinds of boxes may be configured with --palette.

       The color of each object in the graphical output may also  be  enforced  by  specifying  a
       "lstopoStyle"  info  attribute in that object.  Its value should be a semi-colon separated
       list of "<attribute>=#rrggbb" where rr, gg and bb are the RGB components of a color,  each
       between 0 and 255, in hexadecimal (00 to ff).  <attribute> may be

       Background
              Sets the background color of the main object box.

       Text   Sets the color of the text showing the object name, type, index, etc.

       Text2  Sets  the color of the additional text near the object, for instance the link speed
              behind a PCI bridge.

       The "lstopoStyle" info may be added to a  temporarily-saved  XML  topologies  with  hwloc-
       annotate, or with hwloc_obj_add_info().  For instance, to display all core objects in blue
       (with white names):

           lstopo save.xml
           hwloc-annotate      save.xml      save.xml       core:all       info       lstopoStyle
       "Background=#0000ff;Text=#ffffff"
           lstopo -i save.xml

EXAMPLES

       To display the machine topology in textual mode:

           lstopo-no-graphics

       To display the machine topology in ascii-art mode:

           lstopo-no-graphics -.ascii

       To  display  in graphical mode (assuming that the DISPLAY environment variable is set to a
       relevant value):

           lstopo

       To export the topology to a PNG file:

           lstopo file.png

       To export an XML file on a machine and later display the corresponding graphical output on
       another machine:

           machine1$ lstopo file.xml
           <transfer file.xml from machine1 to machine2>
           machine2$ lstopo --input file.xml

       To  save  the  current  machine  topology  to  XML  and later reload it faster while still
       considering it as the current machine:

          $ lstopo file.xml
          <...>
          $ lstopo --input file.xml --thissystem

       To restrict an XML topology to only physical processors 0, 1, 4 and 5:

           lstopo --input file.xml --restrict 0x33 newfile.xml

       To restrict an XML topology to only numa node whose logical index is 1:

           lstopo --input file.xml --restrict $(hwloc-calc --input file.xml node:1) newfile.xml

       To display a summary of the topology:

           lstopo -s

       To get more details about the topology:

           lstopo -v

       To only show cores:

           lstopo --only core

       To show cpusets:

           lstopo --cpuset

       To only show the cpusets of package:

           lstopo --only package --cpuset-only

       Simulate a fake hierarchy; this example shows with 2 NUMA nodes of 2 processor units:

           lstopo --input "node:2 2"

       To count the number of logical processors in the system

          lstopo --only pu | wc -l

       To append the kernel release and version to the graphical legend:

          lstopo --append-legend "Kernel release: $(uname -r)" --append-legend  "Kernel  version:
       $(uname -v)"

       To show where a process and its children are bound by combining with hwloc-ps:

          hwloc-ps --pid-children 23 --lstopo-misc - | lstopo --misc-from -

NOTES

       lstopo  displays memory and cache sizes with units such as kB (1 kilobyte = 1000 bytes) or
       GB (1 gigabyte = 1000*1000*1000 bytes) while it actually means  KiB  (1  kibibyte  =  1024
       bytes) or GiB (1 gibibytes = 1024*1024*1024 bytes) .

SEE ALSO

       hwloc(7),  hwloc-info(1),  hwloc-bind(1),  hwloc-annotate(1),  hwloc-ps(1),  hwloc-gather-
       topology(1), hwloc-gather-cpuid(1)