main.cpp File Reference

#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:

Go to the source code of this file.

Macros
#define	NUM_THREADS   20
#define	STACK_SIZE   (1024 + CONFIG_TEST_EXTRA_STACK_SIZE)

Functions
int	main (void)

Macro Definition Documentation

NUM_THREADS

#define NUM_THREADS   20

Definition at line 14 of file main.cpp.

STACK_SIZE

#define STACK_SIZE   (1024 + CONFIG_TEST_EXTRA_STACK_SIZE)

Definition at line 15 of file main.cpp.

Function Documentation

main()

int main

(

void

)

Definition at line 56 of file main.cpp.

{
  const zpp::thread_attr attrs(
        zpp::thread_prio::preempt(10),
        zpp::thread_inherit_perms::no,
        zpp::thread_suspend::no
      );
 
  for (int i = 0; i < NUM_THREADS; i++) {
    t[i] = zpp::thread(tcb[i], tstack(i), attrs, &worker_thread, i);
  }
 
  //zpp::this_thread::sleep_for(std::chrono::seconds(1));
 
  printk("[thread %s] all threads started\n", __func__);
 
  {
    zpp::lock_guard lg(m);
 
  //
  // are the other threads still busy?
  //
  while (done < NUM_THREADS) {
    printk("[thread %s] done is %d which is < %d so waiting on cond\n",
          __func__, done, (int)NUM_THREADS);
 
    // block this thread until another thread signals cond. While
    // blocked, the mutex is released, then re-acquired before this
    // thread is woken up and the call returns.
    auto res = cv.wait(m);
    __ASSERT_NO_MSG(res == true);
 
    printk("[thread %s] wake - cond was signalled.\n", __func__);
 
    // we go around the loop with the lock held
  }
 
  } // zpp::lock_guard scope
 
  for (int i = 0; i < NUM_THREADS; i++) {
    auto res = t[i].join();
    __ASSERT_NO_MSG(res == true);
  }
 
  printk("[thread %s] done == %d so everyone is done\n",
    __func__, (int)NUM_THREADS);
 
  return 0;
}

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