Metered concurrency: Difference between revisions

 

The interface for the counting semaphore is defined in an Ada package specification:

protected type Counting_Semaphore(Max : Positive) is

entry Acquire;

Lock_Count : Natural := 0;

end Counting_Semaphore;

The ''Acquire'' entry has a condition associated with it. A task can only execute the ''Acquire'' entry when ''Lock_Count'' is less than ''Max''. This is the key to making this structure behave as a counting semaphore. This condition, and all the other aspects of ''Counting_Semaphore'' are contained in the package body.

 

------------------------

end Counting_Semaphore;

 

We now need a set of tasks to properly call an instance of ''Counting_Semaphore''.

with Ada.Text_Io; use Ada.Text_Io;

 

Crew(I).Start(2.0, I);

end loop;

 

=={{header|ALGOL 68}}==

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny]}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to PAR and SEMA being unimplemented}}

 

PROC job = (INT n)VOID: (

( DOWN sem ; job(2) ; UP sem ) ,

( DOWN sem ; job(3) ; UP sem )

Output:

<pre>

Job 1 acquired Semaphore ... Job 1 releasing Semaphore

Job 2 acquired Semaphore ... Job 2 releasing Semaphore

</pre>

 

=={{header|C}}==

{{works with|POSIX}}

#include <pthread.h>

#include <stdlib.h>

 

return sem_destroy(&sem);

 

=={{header|C sharp}}==

C# has built in semaphore system where acquire is called via Wait(), release with Release() and count with semaphore.CurrentCount.

using System.Threading;

using System.Threading.Tasks;

}

}

 

=={{header|D}}==

import std.stdio ;

import std.thread ;

foreach(inout c ; crew)

c.wait ;

===Phobos with tools===

Using the scrapple.tools extension library for Phobos ..

 

import tools.threads, tools.log, tools.time, tools.threadpool;

for (int i = 0; i < 10; ++i)

done.acquire;

=={{header|E}}==

This semaphore slightly differs from the task description; the release operation is not on the semaphore itself but given out with each acquisition, and cannot be invoked too many times.

 

var current := 0

def waiters := <elib:vat.makeQueue>()

for i in 1..5 {

work(i, 2000, semaphore, timer, println)

=={{header|Euphoria}}==

sems = {}

constant COUNTER = 1, QUEUE = 2

while length(task_list())>1 do

task_yield()

 

Output:

+ Task 10 released semaphore.

+ Task 9 released semaphore.</pre>

 

=={{header|Go}}==

===Buffered channel===

import (

"log"

"time"

)

// log package serializes output

var fmt = log.New(os.Stdout, "", 0)

// library analogy per WP article

const nRooms = 10

const nStudents = 20

func main() {

// WaitGroup used to wait for all students to have studied

// before terminating program

studied.Wait()

}

// report per task descrption. also exercise count operation

fmt.Printf("Room entered. Count is %d. Studying...\n",

time.Sleep(2 * time.Second) // sleep per task description

 

===Sync.Cond===

A more traditional approach implementing a counting semaphore object with sync.Cond. It has a constructor and methods for the three operations requested by the task.

 

import (

"os"

"sync"

"time"

)

 

type countSem struct {

}

 

func newCount(n int) *countSem {

}

 

func (cs *countSem) count() int {

}

 

func (cs *countSem) acquire() {

}

}

 

func (cs *countSem) release() {

}

 

studyRoom.release()

studied.Done()

 

 

 

 

}

 

}

}

 

 

=={{header|Haskell}}==

The QSem (quantity semaphore) waitQSem and signalQSem functions are the Haskell acquire and release equivalents, and the MVar (synchronizing variable) functions are used to put the workers statuses on the main thread for printing. Note that this code is likely only compatible with GHC due to the use of "threadDelay" from Control.Concurrent.

 

 

worker :: QSem -> MVar String -> Int -> IO ()

worker q m n = do

 

main :: IO ()

main = do

 

=={{header|Java}}==

private int lockCount = 0;

private int maxCount;

 

}

 

=={{header|Oz}}==

Counting semaphores can be implemented in terms of mutexes (called "locks" in Oz) and dataflow variables (used as condition variables here). The mutex protects both the counter and the mutable reference to the dataflow variable.

fun {NewSemaphore N}

sem(max:N count:{NewCell 0} 'lock':{NewLock} sync:{NewCell _})

for I in 1..10 do

{StartWorker I}

 

=={{header|Perl}}==

See [http://search.cpan.org/dist/Coro/Coro/Semaphore.pm Coro::Semaphore].

 

=={{header|PicoLisp}}==

(for U 4 # Create 4 concurrent units

(unless (fork)

(wait 2000)

(prinl "Unit " U " releasing the semaphore") )

=={{header|PureBasic}}==

This launches a few threads in parallel, but restricted by the counter.

After a thread has completed it releases the Semaphore and a new thread will

be able to start.

#Parallels=3

Global Semaphore=CreateSemaphore(#Parallels)

WaitThread(i)

EndIf

Sample output

<pre>Thread #0 active.

Python threading module includes a semaphore implementation. This code show how to use it.

 

import threading

 

running = 0

for t in workers:

 

=={{header|Raven}}==

Counting semaphores are built in:

 

4 semaphore as sem

 

group

10 each drop worker

 

Thread joining is automatic by default.

 

=={{header|Tcl}}==

{{works with|Tcl|8.6}}

Uses the Thread package, which is expected to form part of the overall Tcl 8.6 release.

package require Thread

 

foreach t $threads {

thread::release -wait $t

 

=={{header|UnixPipes}}==

The number of concurrent jobs can be set by issuing that many echo '1''s at the begining to sem.

 

 

acquire() {

( acquire < sem ; job 3 ; release > sem ) &

 

 

=={{header|Visual Basic .NET}}==

This code shows using a local semaphore. Semaphores can also be named, in which case they will be shared system wide.

 

sem.WaitOne() 'Blocks until a resouce can be aquired

Dim oldCount = sem.Release() 'Returns a resource to the pool

 

{{omit from|TI-83 BASIC}} {{omit from|TI-89 BASIC}} <!-- Does not have concurrency or background processes. -->