zephyr

History

Nicolas Pitre 6311766d9a pointer-type args: cast appropriately to be 64-bit compatible Using void pointers as universal arguments is widely used. However, when compiling a 64-bit target, the compiler doesn't like when an int is converted to a pointer and vice versa despite the presence of a cast. This is due to a width mismatch between ints (32 bits) and pointers (64 bits). The trick is to cast to a widening integer type such as intptr_t and then cast to void. When appropriate, the INT_TO_POINTER macro is used instead of this double cast to make things clearer. The converse with POINTER_TO_INT is also done which also serves as good code annotations. While at it, remove unneeded casts to specific pointer types from void in the vicinity, and move to typed variable upon function entry to make the code cleaner. Signed-off-by: Nicolas Pitre <npitre@baylibre.com>		2019-06-12 08:20:52 -07:00
..
src	pointer-type args: cast appropriately to be 64-bit compatible	2019-06-12 08:20:52 -07:00
CMakeLists.txt	license: cleanup: add SPDX Apache-2.0 license identifier	2019-04-07 08:45:22 -04:00
README.rst	doc: getting_started: Support multi-OS instructions	2018-01-18 16:53:31 -05:00
prj.conf	tests: More SMP disablement	2019-03-20 11:33:29 -05:00
prj_tickless.conf	tests: samples: Re-enable SMP on a few tests	2019-03-23 19:28:15 -04:00
sample.yaml	tests/samples: cleanup tags	2018-10-16 09:17:51 -04:00

README.rst

.. _dining-philosophers-sample:

Dining Philosophers
###################

Overview
********

An implementation of a solution to the Dining Philosophers problem (a classic
multi-thread synchronization problem).  This particular implementation
demonstrates the usage of multiple preemptible and cooperative threads of
differing priorities, as well as dynamic mutexes and thread sleeping.

The philosopher always tries to get the lowest fork first (f1 then f2).  When
done, he will give back the forks in the reverse order (f2 then f1).  If he
gets two forks, he is EATING.  Otherwise, he is THINKING. Transitional states
are shown as well, such as STARVING when the philosopher is hungry but the
forks are not available, and HOLDING ONE FORK when a philosopher is waiting
for the second fork to be available.

Each Philosopher will randomly alternate between the EATING and THINKING state.

It is possible to run the demo in coop-only or preempt-only mode. To achieve
this, set these values for CONFIG_NUM_COOP_PRIORITIES and
CONFIG_NUM_PREEMPT_PRIORITIES in prj.conf:

preempt-only:

  CONFIG_NUM_PREEMPT_PRIORITIES 6
  CONFIG_NUM_COOP_PRIORITIES 0

coop-only:

  CONFIG_NUM_PREEMPT_PRIORITIES 0
  CONFIG_NUM_COOP_PRIORITIES 6

In these cases, the philosopher threads will run with priorities 0 to 5
(preempt-only) and -7 to -2 (coop-only).

Building and Running
********************

This project outputs to the console.  It can be built and executed
on QEMU as follows:

.. zephyr-app-commands::
   :zephyr-app: samples/philosophers
   :host-os: unix
   :board: qemu_x86
   :goals: run
   :compact:

Sample Output
=============

.. code-block:: console

   Philosopher 0 [P: 3]  HOLDING ONE FORK
   Philosopher 1 [P: 2]  HOLDING ONE FORK
   Philosopher 2 [P: 1]  EATING  [ 1900 ms ]
   Philosopher 3 [P: 0]  THINKING [ 2500 ms ]
   Philosopher 4 [C:-1]  THINKING [ 2200 ms ]
   Philosopher 5 [C:-2]  THINKING [ 1700 ms ]