In this blog post we implement a version of dining philosophers problem in Pony. Wikipedia states the problem as follows:

Five silent philosophers sit at a round table with bowls of spaghetti. Forks are placed between each pair of adjacent philosophers.

Each philosopher must alternately think and eat. However, a philosopher can only eat spaghetti when they have both left and right forks. Each fork can be held by only one philosopher and so a philosopher can use the fork only if it is not being used by another philosopher. After an individual philosopher finishes eating, they need to put down both forks so that the forks become available to others. A philosopher can take the fork on their right or the one on their left as they become available, but cannot start eating before getting both forks.

Eating is not limited by the remaining amounts of spaghetti or stomach space; an infinite supply and an infinite demand are assumed.

The problem is how to design a discipline of behaviour (a concurrent algorithm) such that no philosopher will starve; i.e., each can forever continue to alternate between eating and thinking, assuming that no philosopher can know when others may want to eat or think.

You can find the file with the pony implementation on my GitHub

Actors based solution

Since Pony is an actors-based programming language, we take on this problem in the default actor way.

When a philosopher wants to start eating, they request both sticks form the table (which is also and actor). Eating can only commence once both sticks are acquired. If the philosopher fails to acquire a stick, they go on to think a bit longer and try again later.

Main

The main of the program creates a table with 5 sticks and 5 philosophers.

actor Main
  new create(env: Env) =>
    let number  = USize(5)
    env.out.print("Let's eat!")
    let table = Table(number)
    for i in Range(0, number) do
      Philosopher(i,env, table, i, (i+1) % number)()
    end

Stick class

We represent a stick using a class that has a default reference capability of iso. This means that there may be at most one actor in possession of a stick.

class iso Stick
  let _id:USize val

  new iso create(id':USize)=> _id = id'
  fun box id():USize => _id
  fun box eq(that: Stick box): Bool => this._id == that._id

Table actor

A table actor gets a USize as argument to its constructor. This indicates the number of sticks and seats. An array is made of optional sticks (that is None or Stick iso).

actor Table
  let _sticks: Array[(Stick|None)] ref

  new create(num: USize) =>
    _sticks = Array[(Stick|None)]()
    for i in Range(0,num) do
      _sticks.push( Stick(i) )
    end

There are two messages the table actor accepts: takeStick and realeaseStick. They are both implemented as a behaviour in Pony. These behaviours are different from the notion of behaviours in other actor based languages in which they are used as a synchronisation mechanism.

For the first behaviour, we get a request for a certain stick and who to give it to. Because the sticks in our array are iso we cannot just take a stick with _sticks(num) and send it back to the philosopher as this would create a new alias. To solve this we perform a destructive read, using update. The return type of Array.update is a (Stick iso|None)^. This is an ephemeral type, which means that there are no aliases to the returned value. We are allowed to send it back to the philosopher.

  be takeStick(num: USize, who:Philosopher)=>
    try  who.stick(num, _sticks.update(num,None)?)
    else who.stick(num, None)
    end

When a stick is returned, it is sent with a realeaseStick call. We take that stick and use match to verify if we got a stick. Take not of how we use consume in the match. By doing this we do not create an extra alias to the stick. Our initial stick is consumed and placed in s. Since s is an iso we can call the box method s.id() to get the id of the stick such that we can put it back in the array at the right place. To place the stick in the array we need to consume the stick s again.

  be realeaseStick(stick:(Stick iso | None)) =>
    try match (consume stick)
        | let s:Stick iso => _sticks.update(s.id(),consume s)?
    end end

Philosopher actor

The philosopher is the most complicated actor.

To create one we save the number of the philosopher and the required sticks in instance variables. We also set the _sticksPending tuple to (false,false). This tuple keeps track of which sticks we have requested but haven’t received or been denied. We also keep a Rand in the actor to generate random sleep times.

actor Philosopher
   ...

  new create(number': USize, env: Env, table: Table tag, left_stick:USize, right_stick:USize) =>
    number = number'
    _sticks = (left_stick,right_stick)
    _sticksOwn1 = None
    _sticksOwn2 = None
    _sticksPending = (false,false)
    _table = table
    _env = env
    rand = Rand(133742 + (number'.u64()))

The apply behaviour, which is called at the start of the program, waits a random amount of time and requests sticks.

  be apply() =>
    let l:Philosopher tag = this
    _env.out.print("@THINK " + number.string())
    this.doDelayed({(l:Philosopher tag) => l.requestSticks(); None })

This is carried out by simply sending a takeStick request to the table. After asking sticks we must wait for a stick message as response from the table. To keep track of which sticks we do not have an answer for we set _sticksPending to true for both sticks.

  be requestSticks()=>
    _env.out.print("Request sticks " + number.string()) 
    _sticksPending = (true,true)
    _table.takeStick(_sticks._1,this)
    _table.takeStick(_sticks._2,this)

When stick messages arrive, we store the Stick or None in _sticksOwn1 and _sticksOwn2. We update _sticksPending. If have got a response for all sticks, we validate that we have both sticks. If one of the sticks is missing, we return all sticks we have. In the fortunate case that we have both sticks, we eat.

  be stick(num:USize, s: (Stick|None)) =>
    match (consume s)
    | let x:Stick => 
        if     x.id() == _sticks._1 then _sticksOwn1 = consume x
        elseif x.id() == _sticks._2 then _sticksOwn2 = consume x
        end
    end

    _sticksPending = (
      if num == _sticks._1 then false else _sticksPending._1 end, 
      if num == _sticks._2 then false else _sticksPending._2 end
    )

    if ((_sticksPending._1) or (_sticksPending._2)) then return end

    // Check if none of the sticks are None
    recover 
      match _sticksOwn1
      | None => this.returnSticks()
      else 
        match _sticksOwn2
        | None => this.returnSticks()
        else
          eat() // We have both sticks
        end
      end
    end

Eating is simple. We print that we are eating and return the sticks after some time.

  fun ref eat() =>
    state = Eating
    _env.out.print("@EATING " + number.string())
    this.doDelayed({(l:Philosopher tag) => l.returnSticks(); None } iso)

When the sticks are returned we set our state to Thinking and send back the sticks to the table. Since we mustn’t create aliases to our Sticks, we first use a destructive read to get the iso in a local variable we can consume. Once the sticks are sent, we can go back to our apply().

  be returnSticks() =>
    _env.out.print("Return sticks "+number.string())
    state = Thinking
    let s1 = _sticksOwn1 = None; _table.realeaseStick(consume s1)
    let s2 = _sticksOwn2 = None; _table.realeaseStick(consume s2)
    this()