#include <zephyr/kernel.h>
#include <zephyr/arch/cpu.h>
#include <zephyr/sys/arch_interface.h>
#include <zpp.hpp>
#include <chrono>

Include dependency graph for main.cpp:

Macros
#define	NUM_THREADS 3

#define	TCOUNT 10

#define	COUNT_LIMIT 12

#define	STACK_SIZE (1024 + CONFIG_TEST_EXTRA_STACK_SIZE)

Functions
void	inc_count (int my_id) noexcept

void	watch_count (int my_id) noexcept

int	main (void)

Macro Definition Documentation

◆ COUNT_LIMIT

#define COUNT_LIMIT 12

Definition at line 17 of file main.cpp.

◆ NUM_THREADS

#define NUM_THREADS 3

SPDX-License-Identifier: Apache-2.0

Definition at line 15 of file main.cpp.

◆ STACK_SIZE

#define STACK_SIZE (1024 + CONFIG_TEST_EXTRA_STACK_SIZE)

Definition at line 19 of file main.cpp.

◆ TCOUNT

#define TCOUNT 10

Definition at line 16 of file main.cpp.

Function Documentation

◆ inc_count()

void inc_count ( int my_id )

noexcept

Definition at line 34 of file main.cpp.

 {
   for (int i = 0; i < TCOUNT; i++) {
     {
       zpp::lock_guard<zpp::mutex> lg(count_mutex);
       count++;
  
       //
       // Check the value of count and signal waiting thread when
       // condition is reached.  Note that this occurs while mutex is
       // locked.
       //
  
       if (count == COUNT_LIMIT) {
         printk("%s: thread %d, count = %d  Threshold reached.",
                                                       __func__, my_id, count);
         count_threshold_cv.notify_one();
         printk("Just sent signal.\n");
       }
  
       printk("%s: thread %d, count = %d, unlocking mutex\n",
                                                       __func__, my_id, count);
     }
  
     // Sleep so threads can alternate on mutex lock
     zpp::this_thread::sleep_for(std::chrono::milliseconds(500));
   }
 }

References COUNT_LIMIT, zpp::this_thread::sleep_for(), and TCOUNT.

Referenced by main().

◆ main()

int main ( void )

Definition at line 86 of file main.cpp.

 {
   const zpp::thread_attr attrs(
         zpp::thread_prio::preempt(10),
         zpp::thread_inherit_perms::no,
         zpp::thread_suspend::no
       );
  
   t[0] = zpp::thread(tcb[0], tstack(0), attrs, watch_count, 1);
  
   t[1] = zpp::thread(tcb[1], tstack(1), attrs, inc_count, 2);
   t[2] = zpp::thread(tcb[2], tstack(2), attrs, inc_count, 3);
  
   // Wait for all threads to complete
   for (int i = 0; i < NUM_THREADS; i++) {
     t[i].join();
   }
  
   printk("Main(): Waited and joined with %d threads. Final value of count = %d. Done.\n",
         NUM_THREADS, count);
  
   return 0;
 }

References inc_count(), zpp::no, NUM_THREADS, zpp::thread_prio::preempt(), and watch_count().

◆ watch_count()

void watch_count ( int my_id )