Ordered list of time stamp nodes. More...

#include <os-lists.h>

Inheritance diagram for os::rtos::internal::clock_timestamps_list:

Public Member Functions
Constructors & Destructor
	clock_timestamps_list ()
	Construct a list of clock time stamps.

	~clock_timestamps_list ()
	Destruct the list.

Public Member Functions
void	link (timestamp_node &node)
	Add a new thread node to the list.

volatile timestamp_node *	head (void) const
	Get list head.

void	check_timestamp (port::clock::timestamp_t now)
	Check list time stamps.

Public Member Functions
bool	uninitialized (void) const
	Check if the list is uninitialised.

void	clear (void)
	Clear the list.

bool	empty (void) const
	Check if the list is empty.

volatile static_double_list_links *	tail (void) const
	Get the list tail.

Protected Member Functions
Private Member Functions
void	insert_after (static_double_list_links &node, static_double_list_links *after)
	Insert a new node after existing node.

Protected Attributes
Private Member Variables
static_double_list_links	head_
	A list node used to point to head and tail.

Detailed Description

Definition at line 665 of file os-lists.h.

Constructor & Destructor Documentation

◆ clock_timestamps_list()

os::rtos::internal::clock_timestamps_list::clock_timestamps_list ( )

inline

Definition at line 957 of file os-lists.h.

958 {

959 }

◆ ~clock_timestamps_list()

os::rtos::internal::clock_timestamps_list::~clock_timestamps_list ( )

inline

Definition at line 961 of file os-lists.h.

962 {

963 }

Member Function Documentation

◆ check_timestamp()

void os::rtos::internal::clock_timestamps_list::check_timestamp ( port::clock::timestamp_t now )

Parameters

[in] now The current clock time stamp.

Returns: Nothing.

With the list ordered, check if the list head time stamp was reached and run the node action.

Repeat for all nodes that have overdue time stamps.

Definition at line 490 of file os-lists.cpp.

      {
        if (head_.next () == nullptr)
          {
            // This happens before the constructors are executed.
            return;
          }
 
        // Multiple threads can wait for the same time stamp, so
        // iterate until a node with future time stamp is identified.
        for (;;)
          {
            // ----- Enter critical section -----------------------------------
            interrupts::critical_section ics;
 
            if (empty ())
              {
                break;
              }
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wnull-dereference"
#endif
            clock::timestamp_t head_ts = head ()->timestamp;
#pragma GCC diagnostic pop
            if (now >= head_ts)
              {
#if defined(OS_TRACE_RTOS_LISTS_CLOCKS)
                trace::printf ("%s() %u \n", __func__,
                               static_cast<uint32_t> (sysclock.now ()));
#endif
                const_cast<timestamp_node*> (head ())->action ();
              }
            else
              {
                break;
              }
            // ----- Exit critical section ------------------------------------
          }
      }

References os::utils::static_double_list::empty(), head(), os::utils::static_double_list::head_, os::utils::static_double_list_links::next(), os::rtos::clock::now(), os::trace::printf(), os::rtos::sysclock, and os::rtos::internal::timestamp_node::timestamp.

◆ clear()

void os::utils::static_double_list::clear ( void )

inherited

Parameters: None.

Returns: Nothing.

Initialise the mandatory node with links to itself.

Definition at line 108 of file lists.cpp.

    {
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
      head_.next (const_cast<static_double_list_links*> (&head_));
      head_.prev (const_cast<static_double_list_links*> (&head_));
#pragma GCC diagnostic pop
    }

References os::utils::static_double_list::head_, os::utils::static_double_list_links::next(), and os::utils::static_double_list_links::prev().

Referenced by os::utils::double_list::double_list(), os::rtos::internal::ready_threads_list::link(), and os::rtos::internal::terminated_threads_list::link().

◆ empty()

bool os::utils::static_double_list::empty ( void ) const

inlineinherited

Parameters: None.

Return values

true	The list has no nodes.
false	The list has at least one node.

Definition at line 1001 of file lists.h.

    {
      // If it points to itself, it is empty.
      return (head_.next () == &head_) || (head_.next () == nullptr);
    }

References os::utils::static_double_list::head_, and os::utils::static_double_list_links::next().

Referenced by os::utils::double_list::~double_list(), check_timestamp(), link(), os::rtos::internal::ready_threads_list::link(), os::rtos::internal::waiting_threads_list::link(), os::rtos::internal::waiting_threads_list::resume_one(), and os::rtos::internal::ready_threads_list::unlink_head().

◆ head()

volatile timestamp_node * os::rtos::internal::clock_timestamps_list::head ( void ) const

inline

Parameters: None.

Returns: Casted pointer to head node.

Definition at line 966 of file os-lists.h.

      {
        return static_cast<volatile timestamp_node*> (double_list::head ());
      }

Referenced by check_timestamp(), and link().

◆ insert_after()

void os::utils::static_double_list::insert_after	(	static_double_list_links &	node,
		static_double_list_links *	after
	)

protectedinherited

Parameters

node	Reference to node to insert.
after	Reference to existing node.

Returns: Nothing.

Definition at line 121 of file lists.cpp.

    {
#if defined(OS_TRACE_UTILS_LISTS)
      trace::printf ("%s() n=%p after %p\n", __func__, &node, after);
#endif
 
      // Unlinked nodes must have both pointers null.
      // If not, most probably the node was already linked.
      // Or the memory is corrupted.
      assert (node.prev () == nullptr);
      assert (node.next () == nullptr);
 
      // The `after` node must be linked. Only the `next` pointer is
      // tested, since only it is used.
      assert (after->next () != nullptr);
 
      // Make the new node point to its neighbours.
      node.prev (after);
      node.next (after->next ());
 
      // Make the neighbours point to the node. The order is important.
      after->next ()->prev (&node);
      after->next (&node);
    }

References os::utils::static_double_list_links::next(), os::utils::static_double_list_links::prev(), and os::trace::printf().

Referenced by os::rtos::internal::thread_children_list::link(), link(), os::rtos::internal::ready_threads_list::link(), os::rtos::internal::waiting_threads_list::link(), and os::rtos::internal::terminated_threads_list::link().

◆ link()

void os::rtos::internal::clock_timestamps_list::link ( timestamp_node & node )

Parameters

[in] node Reference to a list node.

Returns: Nothing.

The list is kept in ascending time stamp order.

Based on time stamp, the node is inserted

at the end of the list,
at the beginning of the list,
in the middle of the list, which requires a partial list traversal (done from the end).

To satisfy the circular double linked list requirements, an empty list still contains the head node with references to itself.

Definition at line 413 of file os-lists.cpp.

      {
        clock::timestamp_t timestamp = node.timestamp;
 
        timeout_thread_node* after = static_cast<timeout_thread_node*> (
            const_cast<utils::static_double_list_links*> (tail ()));
 
        if (empty ())
          {
            // Insert at the end of the list.
#if defined(OS_TRACE_RTOS_LISTS_CLOCKS)
            trace::printf ("clock %s() empty +%u\n", __func__,
                           static_cast<uint32_t> (timestamp));
#endif
          }
        else if (timestamp >= after->timestamp)
          {
            // Insert at the end of the list.
#if defined(OS_TRACE_RTOS_LISTS_CLOCKS)
            trace::printf ("clock %s() back %u +%u\n", __func__,
                           static_cast<uint32_t> (after->timestamp),
                           static_cast<uint32_t> (timestamp));
#endif
          }
        else if (timestamp < head ()->timestamp)
          {
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
            // Insert at the beginning of the list
            // and update the new head.
            after = static_cast<timeout_thread_node*> (
                const_cast<utils::static_double_list_links*> (&head_));
#if defined(OS_TRACE_RTOS_LISTS_CLOCKS)
            trace::printf ("clock %s() front +%u %u\n", __func__,
                           static_cast<uint32_t> (timestamp),
                           static_cast<uint32_t> (head ()->timestamp));
#endif
#pragma GCC diagnostic pop
          }
        else
          {
            // Insert in the middle of the list.
            // The loop is guaranteed to terminate.
            while (timestamp < after->timestamp)
              {
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
                after = static_cast<timeout_thread_node*> (
                    const_cast<utils::static_double_list_links*> (
                        after->prev ()));
              }
#if defined(OS_TRACE_RTOS_LISTS_CLOCKS)
            trace::printf ("clock %s() middle %u +%u\n", __func__,
                           static_cast<uint32_t> (after->timestamp),
                           static_cast<uint32_t> (timestamp));
#endif
#pragma GCC diagnostic pop
          }
 
        insert_after (node, after);
      }

References os::utils::static_double_list::empty(), head(), os::utils::static_double_list::head_, os::utils::static_double_list::insert_after(), os::utils::static_double_list_links::prev(), os::trace::printf(), os::utils::static_double_list::tail(), and os::rtos::internal::timestamp_node::timestamp.

◆ tail()

volatile static_double_list_links * os::utils::static_double_list::tail ( void ) const

inlineinherited

Parameters: None.

Returns: Pointer to tail node.

Definition at line 1014 of file lists.h.

    {
      return (head_.prev ());
    }

References os::utils::static_double_list::head_, and os::utils::static_double_list_links::prev().

Referenced by os::rtos::internal::thread_children_list::link(), link(), os::rtos::internal::ready_threads_list::link(), os::rtos::internal::waiting_threads_list::link(), and os::rtos::internal::terminated_threads_list::link().

◆ uninitialized()

bool os::utils::static_double_list::uninitialized ( void ) const

inlineinherited

Parameters: None.

Return values

true	The list was not initialised.
false	The list was initialised.

Definition at line 994 of file lists.h.

    {
      // If it points to nowhere, it is not yet initialised.
      return (head_.prev () == nullptr);
    }

References os::utils::static_double_list::head_, and os::utils::static_double_list_links::prev().

Member Data Documentation

◆ head_

static_double_list_links os::utils::static_double_list::head_

protectedinherited

To simplify processing, the list always has a node.

Definition at line 473 of file lists.h.

Referenced by os::rtos::internal::waiting_threads_list::begin(), check_timestamp(), os::utils::static_double_list::clear(), os::utils::static_double_list::empty(), os::rtos::internal::waiting_threads_list::end(), os::utils::static_double_list::head(), link(), os::rtos::internal::ready_threads_list::link(), os::rtos::internal::waiting_threads_list::link(), os::rtos::internal::terminated_threads_list::link(), os::utils::static_double_list::tail(), and os::utils::static_double_list::uninitialized().

The documentation for this class was generated from the following files:

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ clock_timestamps_list()

◆ ~clock_timestamps_list()

Member Function Documentation

◆ check_timestamp()

◆ clear()

◆ empty()

◆ head()

◆ insert_after()

◆ link()

◆ tail()

◆ uninitialized()

Member Data Documentation

◆ head_