DPDK patches and discussions
 help / color / mirror / Atom feed
From: "Juraj Linkeš" <juraj.linkes@pantheon.tech>
To: thomas@monjalon.net, Honnappa.Nagarahalli@arm.com,
	jspewock@iol.unh.edu, probb@iol.unh.edu, paul.szczepanek@arm.com,
	yoan.picchi@foss.arm.com, Luca.Vizzarro@arm.com
Cc: dev@dpdk.org, "Juraj Linkeš" <juraj.linkes@pantheon.tech>
Subject: [PATCH v8 14/21] dts: cpu docstring update
Date: Thu, 23 Nov 2023 16:13:37 +0100	[thread overview]
Message-ID: <20231123151344.162812-15-juraj.linkes@pantheon.tech> (raw)
In-Reply-To: <20231123151344.162812-1-juraj.linkes@pantheon.tech>

Format according to the Google format and PEP257, with slight
deviations.

Signed-off-by: Juraj Linkeš <juraj.linkes@pantheon.tech>
---
 dts/framework/testbed_model/cpu.py | 196 +++++++++++++++++++++--------
 1 file changed, 144 insertions(+), 52 deletions(-)

diff --git a/dts/framework/testbed_model/cpu.py b/dts/framework/testbed_model/cpu.py
index 1b392689f5..9e33b2825d 100644
--- a/dts/framework/testbed_model/cpu.py
+++ b/dts/framework/testbed_model/cpu.py
@@ -1,6 +1,22 @@
 # SPDX-License-Identifier: BSD-3-Clause
 # Copyright(c) 2023 PANTHEON.tech s.r.o.
 
+"""CPU core representation and filtering.
+
+This module provides a unified representation of logical CPU cores along
+with filtering capabilities.
+
+When symmetric multiprocessing (SMP or multithreading) is enabled on a server,
+the physical CPU cores are split into logical CPU cores with different IDs.
+
+:class:`LogicalCoreCountFilter` filters by the number of logical cores. It's possible to specify
+the socket from which to filter the number of logical cores. It's also possible to not use all
+logical CPU cores from each physical core (e.g. only the first logical core of each physical core).
+
+:class:`LogicalCoreListFilter` filters by logical core IDs. This mostly checks that
+the logical cores are actually present on the server.
+"""
+
 import dataclasses
 from abc import ABC, abstractmethod
 from collections.abc import Iterable, ValuesView
@@ -11,9 +27,17 @@
 
 @dataclass(slots=True, frozen=True)
 class LogicalCore(object):
-    """
-    Representation of a CPU core. A physical core is represented in OS
-    by multiple logical cores (lcores) if CPU multithreading is enabled.
+    """Representation of a logical CPU core.
+
+    A physical core is represented in OS by multiple logical cores (lcores)
+    if CPU multithreading is enabled. When multithreading is disabled, their IDs are the same.
+
+    Attributes:
+        lcore: The logical core ID of a CPU core. It's the same as `core` with
+            disabled multithreading.
+        core: The physical core ID of a CPU core.
+        socket: The physical socket ID where the CPU resides.
+        node: The NUMA node ID where the CPU resides.
     """
 
     lcore: int
@@ -22,27 +46,36 @@ class LogicalCore(object):
     node: int
 
     def __int__(self) -> int:
+        """The CPU is best represented by the logical core, as that's what we configure in EAL."""
         return self.lcore
 
 
 class LogicalCoreList(object):
-    """
-    Convert these options into a list of logical core ids.
-    lcore_list=[LogicalCore1, LogicalCore2] - a list of LogicalCores
-    lcore_list=[0,1,2,3] - a list of int indices
-    lcore_list=['0','1','2-3'] - a list of str indices; ranges are supported
-    lcore_list='0,1,2-3' - a comma delimited str of indices; ranges are supported
-
-    The class creates a unified format used across the framework and allows
-    the user to use either a str representation (using str(instance) or directly
-    in f-strings) or a list representation (by accessing instance.lcore_list).
-    Empty lcore_list is allowed.
+    r"""A unified way to store :class:`LogicalCore`\s.
+
+    Create a unified format used across the framework and allow the user to use
+    either a :class:`str` representation (using ``str(instance)`` or directly in f-strings)
+    or a :class:`list` representation (by accessing the `lcore_list` property,
+    which stores logical core IDs).
     """
 
     _lcore_list: list[int]
     _lcore_str: str
 
     def __init__(self, lcore_list: list[int] | list[str] | list[LogicalCore] | str):
+        """Process `lcore_list`, then sort.
+
+        There are four supported logical core list formats::
+
+            lcore_list=[LogicalCore1, LogicalCore2]  # a list of LogicalCores
+            lcore_list=[0,1,2,3]        # a list of int indices
+            lcore_list=['0','1','2-3']  # a list of str indices; ranges are supported
+            lcore_list='0,1,2-3'        # a comma delimited str of indices; ranges are supported
+
+        Args:
+            lcore_list: Various ways to represent multiple logical cores.
+                Empty `lcore_list` is allowed.
+        """
         self._lcore_list = []
         if isinstance(lcore_list, str):
             lcore_list = lcore_list.split(",")
@@ -58,6 +91,7 @@ def __init__(self, lcore_list: list[int] | list[str] | list[LogicalCore] | str):
 
     @property
     def lcore_list(self) -> list[int]:
+        """The logical core IDs."""
         return self._lcore_list
 
     def _get_consecutive_lcores_range(self, lcore_ids_list: list[int]) -> list[str]:
@@ -83,28 +117,30 @@ def _get_consecutive_lcores_range(self, lcore_ids_list: list[int]) -> list[str]:
         return formatted_core_list
 
     def __str__(self) -> str:
+        """The consecutive ranges of logical core IDs."""
         return self._lcore_str
 
 
 @dataclasses.dataclass(slots=True, frozen=True)
 class LogicalCoreCount(object):
-    """
-    Define the number of logical cores to use.
-    If sockets is not None, socket_count is ignored.
-    """
+    """Define the number of logical cores per physical cores per sockets."""
 
+    #: Use this many logical cores per each physical core.
     lcores_per_core: int = 1
+    #: Use this many physical cores per each socket.
     cores_per_socket: int = 2
+    #: Use this many sockets.
     socket_count: int = 1
+    #: Use exactly these sockets. This takes precedence over `socket_count`,
+    #: so when `sockets` is not :data:`None`, `socket_count` is ignored.
     sockets: list[int] | None = None
 
 
 class LogicalCoreFilter(ABC):
-    """
-    Filter according to the input filter specifier. Each filter needs to be
-    implemented in a derived class.
-    This class only implements operations common to all filters, such as sorting
-    the list to be filtered beforehand.
+    """Common filtering class.
+
+    Each filter needs to be implemented in a subclass. This base class sorts the list of cores
+    and defines the filtering method, which must be implemented by subclasses.
     """
 
     _filter_specifier: LogicalCoreCount | LogicalCoreList
@@ -116,6 +152,17 @@ def __init__(
         filter_specifier: LogicalCoreCount | LogicalCoreList,
         ascending: bool = True,
     ):
+        """Filter according to the input filter specifier.
+
+        The input `lcore_list` is copied and sorted by physical core before filtering.
+        The list is copied so that the original is left intact.
+
+        Args:
+            lcore_list: The logical CPU cores to filter.
+            filter_specifier: Filter cores from `lcore_list` according to this filter.
+            ascending: Sort cores in ascending order (lowest to highest IDs). If data:`False`,
+                sort in descending order.
+        """
         self._filter_specifier = filter_specifier
 
         # sorting by core is needed in case hyperthreading is enabled
@@ -124,31 +171,45 @@ def __init__(
 
     @abstractmethod
     def filter(self) -> list[LogicalCore]:
-        """
-        Use self._filter_specifier to filter self._lcores_to_filter
-        and return the list of filtered LogicalCores.
-        self._lcores_to_filter is a sorted copy of the original list,
-        so it may be modified.
+        r"""Filter the cores.
+
+        Use `self._filter_specifier` to filter `self._lcores_to_filter` and return
+        the filtered :class:`LogicalCore`\s.
+        `self._lcores_to_filter` is a sorted copy of the original list, so it may be modified.
+
+        Returns:
+            The filtered cores.
         """
 
 
 class LogicalCoreCountFilter(LogicalCoreFilter):
-    """
+    """Filter cores by specified counts.
+
     Filter the input list of LogicalCores according to specified rules:
-    Use cores from the specified number of sockets or from the specified socket ids.
-    If sockets is specified, it takes precedence over socket_count.
-    From each of those sockets, use only cores_per_socket of cores.
-    And for each core, use lcores_per_core of logical cores. Hypertheading
-    must be enabled for this to take effect.
-    If ascending is True, use cores with the lowest numerical id first
-    and continue in ascending order. If False, start with the highest
-    id and continue in descending order. This ordering affects which
-    sockets to consider first as well.
+
+        * The input `filter_specifier` is :class:`LogicalCoreCount`,
+        * Use cores from the specified number of sockets or from the specified socket ids,
+        * If `sockets` is specified, it takes precedence over `socket_count`,
+        * From each of those sockets, use only `cores_per_socket` of cores,
+        * And for each core, use `lcores_per_core` of logical cores. Hypertheading
+          must be enabled for this to take effect.
     """
 
     _filter_specifier: LogicalCoreCount
 
     def filter(self) -> list[LogicalCore]:
+        """Filter the cores according to :class:`LogicalCoreCount`.
+
+        Start by filtering the allowed sockets. The cores matching the allowed sockets are returned.
+        The cores of each socket are stored in separate lists.
+
+        Then filter the allowed physical cores from those lists of cores per socket. When filtering
+        physical cores, store the desired number of logical cores per physical core which then
+        together constitute the final filtered list.
+
+        Returns:
+            The filtered cores.
+        """
         sockets_to_filter = self._filter_sockets(self._lcores_to_filter)
         filtered_lcores = []
         for socket_to_filter in sockets_to_filter:
@@ -158,24 +219,37 @@ def filter(self) -> list[LogicalCore]:
     def _filter_sockets(
         self, lcores_to_filter: Iterable[LogicalCore]
     ) -> ValuesView[list[LogicalCore]]:
-        """
-        Remove all lcores that don't match the specified socket(s).
-        If self._filter_specifier.sockets is not None, keep lcores from those sockets,
-        otherwise keep lcores from the first
-        self._filter_specifier.socket_count sockets.
+        """Filter a list of cores per each allowed socket.
+
+        The sockets may be specified in two ways, either a number or a specific list of sockets.
+        In case of a specific list, we just need to return the cores from those sockets.
+        If filtering a number of cores, we need to go through all cores and note which sockets
+        appear and only filter from the first n that appear.
+
+        Args:
+            lcores_to_filter: The cores to filter. These must be sorted by the physical core.
+
+        Returns:
+            A list of lists of logical CPU cores. Each list contains cores from one socket.
         """
         allowed_sockets: set[int] = set()
         socket_count = self._filter_specifier.socket_count
         if self._filter_specifier.sockets:
+            # when sockets in filter is specified, the sockets are already set
             socket_count = len(self._filter_specifier.sockets)
             allowed_sockets = set(self._filter_specifier.sockets)
 
+        # filter socket_count sockets from all sockets by checking the socket of each CPU
         filtered_lcores: dict[int, list[LogicalCore]] = {}
         for lcore in lcores_to_filter:
             if not self._filter_specifier.sockets:
+                # this is when sockets is not set, so we do the actual filtering
+                # when it is set, allowed_sockets is already defined and can't be changed
                 if len(allowed_sockets) < socket_count:
+                    # allowed_sockets is a set, so adding an existing socket won't re-add it
                     allowed_sockets.add(lcore.socket)
             if lcore.socket in allowed_sockets:
+                # separate lcores into sockets; this makes it easier in further processing
                 if lcore.socket in filtered_lcores:
                     filtered_lcores[lcore.socket].append(lcore)
                 else:
@@ -192,12 +266,13 @@ def _filter_sockets(
     def _filter_cores_from_socket(
         self, lcores_to_filter: Iterable[LogicalCore]
     ) -> list[LogicalCore]:
-        """
-        Keep only the first self._filter_specifier.cores_per_socket cores.
-        In multithreaded environments, keep only
-        the first self._filter_specifier.lcores_per_core lcores of those cores.
-        """
+        """Filter a list of cores from the given socket.
+
+        Go through the cores and note how many logical cores per physical core have been filtered.
 
+        Returns:
+            The filtered logical CPU cores.
+        """
         # no need to use ordered dict, from Python3.7 the dict
         # insertion order is preserved (LIFO).
         lcore_count_per_core_map: dict[int, int] = {}
@@ -238,15 +313,21 @@ def _filter_cores_from_socket(
 
 
 class LogicalCoreListFilter(LogicalCoreFilter):
-    """
-    Filter the input list of Logical Cores according to the input list of
-    lcore indices.
-    An empty LogicalCoreList won't filter anything.
+    """Filter the logical CPU cores by logical CPU core IDs.
+
+    This is a simple filter that looks at logical CPU IDs and only filter those that match.
+
+    The input filter is :class:`LogicalCoreList`. An empty LogicalCoreList won't filter anything.
     """
 
     _filter_specifier: LogicalCoreList
 
     def filter(self) -> list[LogicalCore]:
+        """Filter based on logical CPU core ID.
+
+        Return:
+            The filtered logical CPU cores.
+        """
         if not len(self._filter_specifier.lcore_list):
             return self._lcores_to_filter
 
@@ -269,6 +350,17 @@ def lcore_filter(
     filter_specifier: LogicalCoreCount | LogicalCoreList,
     ascending: bool,
 ) -> LogicalCoreFilter:
+    """Factory for providing the filter that corresponds to `filter_specifier`.
+
+    Args:
+        core_list: The logical CPU cores to filter.
+        filter_specifier: The filter to use.
+        ascending: Sort cores in ascending order (lowest to highest IDs). If :data:`False`,
+            sort in descending order.
+
+    Returns:
+        The filter that corresponds to `filter_specifier`.
+    """
     if isinstance(filter_specifier, LogicalCoreList):
         return LogicalCoreListFilter(core_list, filter_specifier, ascending)
     elif isinstance(filter_specifier, LogicalCoreCount):
-- 
2.34.1


  parent reply	other threads:[~2023-11-23 15:16 UTC|newest]

Thread overview: 255+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2023-03-23 10:40 [RFC PATCH v1 0/4] dts: add dts api docs Juraj Linkeš
2023-03-23 10:40 ` [RFC PATCH v1 1/4] dts: code adjustments for sphinx Juraj Linkeš
2023-03-23 10:40 ` [RFC PATCH v1 2/4] dts: add doc generation dependencies Juraj Linkeš
2023-03-23 10:40 ` [RFC PATCH v1 3/4] dts: add doc generation Juraj Linkeš
2023-03-23 10:40 ` [RFC PATCH v1 4/4] dts: format docstrigs to google format Juraj Linkeš
2023-04-28 19:33   ` Jeremy Spewock
2023-04-03  9:17 ` [RFC PATCH v1 0/4] dts: add dts api docs Juraj Linkeš
2023-04-03  9:42   ` Bruce Richardson
2023-04-25  8:20     ` Juraj Linkeš
2023-04-25  8:44       ` Bruce Richardson
2023-04-25  8:57         ` Juraj Linkeš
2023-04-25  9:43           ` Bruce Richardson
2023-05-03 11:33             ` Juraj Linkeš
2023-05-04 12:37 ` [RFC PATCH v2 " Juraj Linkeš
2023-05-04 12:37   ` [RFC PATCH v2 1/4] dts: code adjustments for sphinx Juraj Linkeš
2023-05-04 12:37   ` [RFC PATCH v2 2/4] dts: add doc generation dependencies Juraj Linkeš
2023-05-04 12:37   ` [RFC PATCH v2 3/4] dts: add doc generation Juraj Linkeš
2023-05-04 12:45     ` Bruce Richardson
2023-05-05  7:53       ` Juraj Linkeš
2023-05-05 10:24         ` Bruce Richardson
2023-05-05 10:41           ` Juraj Linkeš
2023-05-05 10:56     ` Bruce Richardson
2023-05-05 11:13       ` Juraj Linkeš
2023-05-05 13:28         ` Bruce Richardson
2023-05-09  9:23           ` Juraj Linkeš
2023-05-09  9:40             ` Bruce Richardson
2023-05-10 12:19               ` Juraj Linkeš
2023-05-04 12:37   ` [RFC PATCH v2 4/4] dts: format docstrigs to google format Juraj Linkeš
2023-05-05 14:06   ` [RFC PATCH v2 0/4] dts: add dts api docs Bruce Richardson
2023-05-09 15:28     ` Juraj Linkeš
2023-05-11  8:55     ` Juraj Linkeš
2023-05-11  9:14   ` [RFC PATCH v3 " Juraj Linkeš
2023-05-11  9:14     ` [RFC PATCH v3 1/4] dts: code adjustments for sphinx Juraj Linkeš
2023-05-11  9:14     ` [RFC PATCH v3 2/4] dts: add doc generation dependencies Juraj Linkeš
2023-05-11  9:14     ` [RFC PATCH v3 3/4] dts: add doc generation Juraj Linkeš
2023-05-11  9:14     ` [RFC PATCH v3 4/4] dts: format docstrigs to google format Juraj Linkeš
2023-06-21 18:27       ` Jeremy Spewock
2023-05-17 16:56     ` [RFC PATCH v3 0/4] dts: add dts api docs Bruce Richardson
2023-05-22  9:17       ` Juraj Linkeš
2023-08-31 10:04     ` [RFC PATCH v4 " Juraj Linkeš
2023-08-31 10:04       ` [RFC PATCH v4 1/4] dts: code adjustments for sphinx Juraj Linkeš
2023-10-22 14:30         ` Yoan Picchi
2023-10-23  6:44           ` Juraj Linkeš
2023-10-23 11:52             ` Yoan Picchi
2023-10-24  6:39               ` Juraj Linkeš
2023-10-24 12:21                 ` Yoan Picchi
2023-08-31 10:04       ` [RFC PATCH v4 2/4] dts: add doc generation dependencies Juraj Linkeš
2023-10-27 15:27         ` Yoan Picchi
2023-08-31 10:04       ` [RFC PATCH v4 3/4] dts: add doc generation Juraj Linkeš
2023-09-20  7:08         ` Juraj Linkeš
2023-10-26 16:43         ` Yoan Picchi
2023-10-27  9:52           ` Juraj Linkeš
2023-08-31 10:04       ` [RFC PATCH v4 4/4] dts: format docstrigs to google format Juraj Linkeš
2023-09-01 17:02         ` Jeremy Spewock
2023-10-31 12:10         ` Yoan Picchi
2023-11-02 10:17           ` Juraj Linkeš
2023-11-06 17:15       ` [PATCH v5 00/23] dts: add dts api docs Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 01/23] dts: code adjustments for doc generation Juraj Linkeš
2023-11-08 13:35           ` Yoan Picchi
2023-11-15  7:46             ` Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 02/23] dts: add docstring checker Juraj Linkeš
2023-11-07 17:38           ` Yoan Picchi
2023-11-06 17:15         ` [PATCH v5 03/23] dts: add basic developer docs Juraj Linkeš
2023-11-07 14:39           ` Yoan Picchi
2023-11-08  9:01             ` Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 04/23] dts: exceptions docstring update Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 05/23] dts: settings " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 06/23] dts: logger and " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 07/23] dts: dts runner and main " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 08/23] dts: test suite " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 09/23] dts: test result " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 10/23] dts: config " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 11/23] dts: remote session " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 12/23] dts: interactive " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 13/23] dts: port and virtual device " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 14/23] dts: cpu " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 15/23] dts: os session " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 16/23] dts: posix and linux sessions " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 17/23] dts: node " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 18/23] dts: sut and tg nodes " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 19/23] dts: base traffic generators " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 20/23] dts: scapy tg " Juraj Linkeš
2023-11-06 17:15         ` [PATCH v5 21/23] dts: test suites " Juraj Linkeš
2023-11-06 17:16         ` [PATCH v5 22/23] dts: add doc generation dependencies Juraj Linkeš
2023-11-06 17:16         ` [PATCH v5 23/23] dts: add doc generation Juraj Linkeš
2023-11-08 12:53         ` [PATCH v6 01/23] dts: code adjustments for " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 02/23] dts: add docstring checker Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 03/23] dts: add basic developer docs Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 04/23] dts: exceptions docstring update Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 05/23] dts: settings " Juraj Linkeš
2023-11-08 16:17             ` Yoan Picchi
2023-11-15 10:09               ` Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 06/23] dts: logger and " Juraj Linkeš
2023-11-08 17:14             ` Yoan Picchi
2023-11-15 10:11               ` Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 07/23] dts: dts runner and main " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 08/23] dts: test suite " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 09/23] dts: test result " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 10/23] dts: config " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 11/23] dts: remote session " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 12/23] dts: interactive " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 13/23] dts: port and virtual device " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 14/23] dts: cpu " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 15/23] dts: os session " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 16/23] dts: posix and linux sessions " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 17/23] dts: node " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 18/23] dts: sut and tg nodes " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 19/23] dts: base traffic generators " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 20/23] dts: scapy tg " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 21/23] dts: test suites " Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 22/23] dts: add doc generation dependencies Juraj Linkeš
2023-11-08 16:00             ` Yoan Picchi
2023-11-15 10:00               ` Juraj Linkeš
2023-11-08 12:53           ` [PATCH v6 23/23] dts: add doc generation Juraj Linkeš
2023-11-15 13:09             ` [PATCH v7 00/21] dts: docstrings update Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 01/21] dts: code adjustments for doc generation Juraj Linkeš
2023-11-16 21:04                 ` Jeremy Spewock
2023-11-20 16:10                   ` Juraj Linkeš
2023-11-20 16:02                 ` Yoan Picchi
2023-11-15 13:09               ` [PATCH v7 02/21] dts: add docstring checker Juraj Linkeš
2023-11-20 16:03                 ` Yoan Picchi
2023-11-15 13:09               ` [PATCH v7 03/21] dts: add basic developer docs Juraj Linkeš
2023-11-20 16:03                 ` Yoan Picchi
2023-11-15 13:09               ` [PATCH v7 04/21] dts: exceptions docstring update Juraj Linkeš
2023-11-20 16:22                 ` Yoan Picchi
2023-11-20 16:35                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 05/21] dts: settings " Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 06/21] dts: logger and utils " Juraj Linkeš
2023-11-20 16:23                 ` Yoan Picchi
2023-11-20 16:36                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 07/21] dts: dts runner and main " Juraj Linkeš
2023-11-16 21:51                 ` Jeremy Spewock
2023-11-20 16:13                   ` Juraj Linkeš
2023-11-20 17:43                 ` Yoan Picchi
2023-11-21  9:10                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 08/21] dts: test suite " Juraj Linkeš
2023-11-16 22:16                 ` Jeremy Spewock
2023-11-20 16:25                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 09/21] dts: test result " Juraj Linkeš
2023-11-16 22:47                 ` Jeremy Spewock
2023-11-20 16:33                   ` Juraj Linkeš
2023-11-30 21:20                     ` Jeremy Spewock
2023-11-15 13:09               ` [PATCH v7 10/21] dts: config " Juraj Linkeš
2023-11-21 15:08                 ` Yoan Picchi
2023-11-22 10:42                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 11/21] dts: remote session " Juraj Linkeš
2023-11-21 15:36                 ` Yoan Picchi
2023-11-22 11:13                   ` Juraj Linkeš
2023-11-22 11:25                     ` Yoan Picchi
2023-11-15 13:09               ` [PATCH v7 12/21] dts: interactive " Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 13/21] dts: port and virtual device " Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 14/21] dts: cpu " Juraj Linkeš
2023-11-21 17:45                 ` Yoan Picchi
2023-11-22 11:18                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 15/21] dts: os session " Juraj Linkeš
2023-11-22 11:50                 ` Yoan Picchi
2023-11-22 13:27                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 16/21] dts: posix and linux sessions " Juraj Linkeš
2023-11-22 13:24                 ` Yoan Picchi
2023-11-22 13:35                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 17/21] dts: node " Juraj Linkeš
2023-11-22 12:18                 ` Yoan Picchi
2023-11-22 13:28                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 18/21] dts: sut and tg nodes " Juraj Linkeš
2023-11-22 13:12                 ` Yoan Picchi
2023-11-22 13:34                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 19/21] dts: base traffic generators " Juraj Linkeš
2023-11-21 16:20                 ` Yoan Picchi
2023-11-22 11:38                   ` Juraj Linkeš
2023-11-22 11:56                     ` Yoan Picchi
2023-11-22 13:11                       ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 20/21] dts: scapy tg " Juraj Linkeš
2023-11-21 16:33                 ` Yoan Picchi
2023-11-22 13:18                   ` Juraj Linkeš
2023-11-15 13:09               ` [PATCH v7 21/21] dts: test suites " Juraj Linkeš
2023-11-16 17:36                 ` Yoan Picchi
2023-11-20 10:17                   ` Juraj Linkeš
2023-11-20 12:50                     ` Yoan Picchi
2023-11-22 13:40                       ` Juraj Linkeš
2023-11-23 15:13               ` [PATCH v8 00/21] dts: docstrings update Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 01/21] dts: code adjustments for doc generation Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 02/21] dts: add docstring checker Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 03/21] dts: add basic developer docs Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 04/21] dts: exceptions docstring update Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 05/21] dts: settings " Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 06/21] dts: logger and utils " Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 07/21] dts: dts runner and main " Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 08/21] dts: test suite " Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 09/21] dts: test result " Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 10/21] dts: config " Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 11/21] dts: remote session " Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 12/21] dts: interactive " Juraj Linkeš
2023-11-30 21:49                   ` Jeremy Spewock
2023-12-04  9:50                     ` Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 13/21] dts: port and virtual device " Juraj Linkeš
2023-11-23 15:13                 ` Juraj Linkeš [this message]
2023-11-23 15:13                 ` [PATCH v8 15/21] dts: os session " Juraj Linkeš
2023-12-01 17:33                   ` Jeremy Spewock
2023-12-04  9:53                     ` Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 16/21] dts: posix and linux sessions " Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 17/21] dts: node " Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 18/21] dts: sut and tg nodes " Juraj Linkeš
2023-12-01 18:06                   ` Jeremy Spewock
2023-12-04 10:02                     ` Juraj Linkeš
2023-12-04 11:02                       ` Bruce Richardson
2023-11-23 15:13                 ` [PATCH v8 19/21] dts: base traffic generators " Juraj Linkeš
2023-12-01 18:05                   ` Jeremy Spewock
2023-12-04 10:03                     ` Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 20/21] dts: scapy tg " Juraj Linkeš
2023-12-01 18:17                   ` Jeremy Spewock
2023-12-04 10:07                     ` Juraj Linkeš
2023-11-23 15:13                 ` [PATCH v8 21/21] dts: test suites " Juraj Linkeš
2023-12-01 16:00                 ` [PATCH v8 00/21] dts: docstrings update Yoan Picchi
2023-12-01 18:23                   ` Jeremy Spewock
2023-12-04 10:24                 ` [PATCH v9 " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 01/21] dts: code adjustments for doc generation Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 02/21] dts: add docstring checker Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 03/21] dts: add basic developer docs Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 04/21] dts: exceptions docstring update Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 05/21] dts: settings " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 06/21] dts: logger and utils " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 07/21] dts: dts runner and main " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 08/21] dts: test suite " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 09/21] dts: test result " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 10/21] dts: config " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 11/21] dts: remote session " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 12/21] dts: interactive " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 13/21] dts: port and virtual device " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 14/21] dts: cpu " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 15/21] dts: os session " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 16/21] dts: posix and linux sessions " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 17/21] dts: node " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 18/21] dts: sut and tg nodes " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 19/21] dts: base traffic generators " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 20/21] dts: scapy tg " Juraj Linkeš
2023-12-04 10:24                   ` [PATCH v9 21/21] dts: test suites " Juraj Linkeš
2023-12-05 18:39                     ` Jeremy Spewock
2023-12-21 11:48                   ` [PATCH v9 00/21] dts: docstrings update Thomas Monjalon
2023-11-15 13:36             ` [PATCH v1 0/2] dts: api docs generation Juraj Linkeš
2023-11-15 13:36               ` [PATCH v1 1/2] dts: add doc generation dependencies Juraj Linkeš
2023-11-15 13:36               ` [PATCH v1 2/2] dts: add doc generation Juraj Linkeš
2024-01-22 12:00               ` [PATCH v2 0/3] dts: API docs generation Juraj Linkeš
2024-01-22 12:00                 ` [PATCH v2 1/3] dts: add doc generation dependencies Juraj Linkeš
2024-01-22 12:00                 ` [PATCH v2 2/3] dts: add API doc sources Juraj Linkeš
2024-01-22 12:00                 ` [PATCH v2 3/3] dts: add API doc generation Juraj Linkeš
2024-01-22 16:35               ` [PATCH v3 0/3] dts: API docs generation Juraj Linkeš
2024-01-22 16:35                 ` [PATCH v3 1/3] dts: add doc generation dependencies Juraj Linkeš
2024-01-22 16:35                 ` [PATCH v3 2/3] dts: add API doc sources Juraj Linkeš
2024-01-22 16:35                 ` [PATCH v3 3/3] dts: add API doc generation Juraj Linkeš
2024-01-29 17:09                   ` Jeremy Spewock
     [not found]                   ` <CAJvnSUCNjo0p-yhROF1MNLKhjiAw2QTyTHO2hpOaVVUn0xnJ0A@mail.gmail.com>
2024-02-29 18:12                     ` Nicholas Pratte
2024-04-12 10:14               ` [PATCH v4 0/3] dts: API docs generation Juraj Linkeš
2024-04-12 10:14                 ` [PATCH v4 1/3] dts: add doc generation dependencies Juraj Linkeš
2024-04-12 10:14                 ` [PATCH v4 2/3] dts: add API doc sources Juraj Linkeš
2024-04-12 10:14                 ` [PATCH v4 3/3] dts: add API doc generation Juraj Linkeš

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20231123151344.162812-15-juraj.linkes@pantheon.tech \
    --to=juraj.linkes@pantheon.tech \
    --cc=Honnappa.Nagarahalli@arm.com \
    --cc=Luca.Vizzarro@arm.com \
    --cc=dev@dpdk.org \
    --cc=jspewock@iol.unh.edu \
    --cc=paul.szczepanek@arm.com \
    --cc=probb@iol.unh.edu \
    --cc=thomas@monjalon.net \
    --cc=yoan.picchi@foss.arm.com \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).