Seite 3: Countdown-Test

Listing 1: Implementation eines Countdowns unter Python

def countdown(n):
    while n>0:
        n -= 1
        print(n)

import trio

async def time_countdown(n):
    async with trio.open_nursery() as nursery:
        computational_result_aiter = nursery.start_soon(trio_parallel.run_sync, countdown,n)

import trio
import sys
import multiprocessing

counterN1 = 500000
counterN2 = 1000000
counterN3 = 10000000

if __name__ == '__main__':
    multiprocessing.freeze_support()
    trio.run(time_countdown,counterN3)

public class Countdown {
    private long value = 0;
    private volatile boolean cancelled = false;
    
    public Countdown(long n) {
        this.value = n; 
    }
    
    public synchronized long getValue() {
        return value;
    }
    
    public synchronized void decrement() {
        if (! isCancelled()) {
            while (value > 0) {
                this.value--;
                System.out.println("Current value:"+this.value);
            }
            this.cancel();
        } 
    }

    public boolean isCancelled() {
        return this.cancelled;
    }

    private void cancel() {
        this.cancelled = true;
    }

}

public class CountingTask implements Callable <CountingTask>{
    private Countdown countdown;
    
    public CountingTask(Countdown c) {
        this.countdown = c;
    }
    
    public CountingTask call() {
            if (!Thread.currentThread().isInterrupted()) {
                this.countdown.decrement();
            }
            return this;
    }

}

public class CountdownService  {
    // ruft die Zahl der CPU-Kerne ab   
    public static final int MAX_THREADS = Runtime.getRuntime().availableProcessors();
    private ExecutorService executorService;
    private Countdown countdown;
    private int numThreads = 0;
    private Set<Callable<CountingTask>> tasks = Collections.synchronizedSet(new HashSet<Callable<CountingTask>>());
    private List<Future<CountingTask>> futures;
    
    public CountdownService(Countdown c, int n) {
        this.countdown = c;
        this.numThreads = n;
        this.executorService = Executors.newFixedThreadPool(MAX_THREADS);
        this.futures = new ArrayList<Future<CountingTask>>();
    }
    
    // erstellt die Tasks
    public void prepare() {
        for (int i = 0; i < this.numThreads; i++) {
            CountingTask task = new CountingTask(this.countdown);
            this.tasks.add(task);
        }
    }
    
    // initialisiert die Callables
    public void init() {
        if (!this.executorService.isShutdown()) {
            try {
                futures = executorService.invokeAll(tasks);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
   
}

public void startCountdown(int n, int numThreads) {
         Countdown c = new Countdown(n);
         CountdownService countdown = new CountdownService(c, numThreads);
         countdown.prepare();
         countdown.init();
}

module MyCounter () where
...

import Control.Monad (forever)
import Control.Concurrent.STM
import Control.Concurrent.MVar
import Control.Concurrent (forkIO,threadDelay)
import System.Exit as Exit
import qualified Lib as Lib

-- komplexe Datentypen
data MyCounter = MyCounter Int deriving (Eq)
data Countdown = C MyCounter | M MAX | N MIN deriving (Show,Eq)
data MAX = MAX Int deriving (Eq)
data MIN = MIN Int deriving (Eq)
type CounterVar = TVar Countdown

-- vergleicht den Zähler mit dem Infimum oder Supremum
myCompare :: Countdown -> Countdown -> Ordering
(M (MAX n)) `myCompare` (C (MyCounter i))
    | n == i = EQ
    | n < i = LT
    | otherwise = GT
(N (MIN n)) `myCompare` (C (MyCounter i))
    | n == i = EQ
    | n < i = LT
    | otherwise = GT
c@(C (MyCounter _)) `myCompare` m@(N (MIN _)) = m `myCompare` c
c@(C (MyCounter _)) `myCompare` m@(M (MAX _)) = m `myCompare` c

-- erstellt einen neuen Countdown mit einem Infimum oder Supremum 
resetCounter :: Countdown -> IO CounterVar
resetCounter (M (MAX n)) = do
    tstore <- atomically $ newTVar (C (MyCounter n))
    return tstore   
resetCounter (N (MIN n)) = do
    tstore <- atomically $ newTVar (C (MyCounter n))
    return tstore   

-- reduziert den Countdown um eins
decCounter' :: Countdown -> Countdown
decCounter' (C (MyCounter c)) = C (MyCounter (c - 1))

decCounter :: CounterVar -> Int ->  IO ()
decCounter tstore i =  do
    -- Wert aus der gemeinsam genutzten Variable abrufen
    c <- Lib.getTVar tstore
    let min' = N (MIN 0)
        newCounter = decCounter' c
        res = auxCompare min' c
    -- prüfen ob der Countdown das Infimum oder Supremum erreicht hat
    if  (auxCompare min' c == LT )
        then do
          -- neuen Wert in die TVar ablegen 
          Lib.modifyTVar_ tstore newCounter
   -- rekursiver Aufruf von decCounter
          decCounter tstore (Steps (succ n)) i

     -- Ansonsnte decCounter verlassen
        else (putStrLn $ "Finished Thread Number: " ++ (show i)) >> return ()
    where
        auxCompare x y = x `myCompare` y

import Control.Concurrent.Async (replicateConcurrently_,async,wait,mapConcurrently_)

countdowntest :: Maybe Int -> Maybe Int -> IO ()
countdowntest mn mt = do
    -- mn: N
    -- mt: Zahl der Threads    
    case (mn,mt) of
        (Just n,Just t) -> do
            tstore <- C.resetCounter (C.M (C.MAX n))
            let nList = [1..t]
            mapConcurrently_ (\i -> C.decCounter tstore (C.Steps 0) i) nList
            c <- Lib.getTVar tstore
            putStrLn $ "Countdown from " ++ (show n) ++ " using " ++ (show t) ++ " cores stopped at: " ++ (show c)
        _ -> putStrLn "The countdown command takes exactly two numbers."