[Gikoskos]

IIRC there was at least one language that implemented CCRs natively in its syntax. I want to say it's Ada but I could be wrong. If anyone else knows about it please correct me.

To understand it better here's the solution to the producer/consumer problem (from wikipedia), using mutexes and semaphores:

  mtx buffer_mutex;
  sem fillCount = 0;
  sem emptyCount = BUFFER_SIZE;
  
  procedure producer() 
  {
      while (true) 
      {
          item = produceItem();
          down(emptyCount);
          down(buffer_mutex);
          putItemIntoBuffer(item);
          up(buffer_mutex);
          up(fillCount);
      }
  }
  
  procedure consumer() 
  {
      while (true) 
      {
          down(fillCount);
          down(buffer_mutex);
          item = removeItemFromBuffer();
          up(buffer_mutex);
          up(emptyCount);
          consumeItem(item);
      }
  }

and the same problem solved using CCRs:

  int avl = 0;
  
  procedure producer() 
  {
      while (true) 
      {
          item = produceItem();
          region R when (avl < BUFFER_SIZE)
          {
              putItemIntoBuffer(item);
              avl++;
          }
      }
  }
  
  procedure consumer() 
  {
     while (true) 
     {
         region R when (avl > 0)
         {
             item = removeItemFromBuffer();
             avl--;
         }
         consumeItem(item);
     }
  }

The most important thing about CCRs is that they are supposed to guarantee fairness, along with mutual exclusion. A well-designed solution uses two binary semaphore queues to achieve this.

If anyone wants to see what an implementation looks like here's a small C library I wrote a while ago, to use for some of my own personal projects, and to solve some homework for Uni https://github.com/Gikoskos/libccr

[okl]

> I want to say it's Ada but I could be wrong.

Yes, entry barriers: http://www.ada-auth.org/standards/12rm/html/RM-9-5-2.html#S0...

The consumer/producer routines (entries) conceptually belong to the object/resource that is operated on (protected object) but are executed by the calling task.