[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Softwarepatente abgelehnt



* Martin Uecker wrote:
> Die Kombinierbarkeit scheint mir aber eher direkt
> aus dem für funktionale Sprachen typischen Einsatz
> von Higher-Order-Kombinatoren zu stammen.

Es erleichtert vieles, mehr nicht.

> Es mag sein, daß Du in Deiner Applikation nicht an
> die Grenzen dieser Technik stößt.

Das tue ich schon. Ich kann eben keine IO in einer entsprechenden Aktion
machen. Aber das wurde bei der Modellierung bereits berücksichtigt.

> Es wunderte mich nur, daß bekannte Performance-Probleme (lock-freie
> Algorithmen werden seit mindestens zwei Jahrzehnten untersucht, siehe
> auch "optimistic concurrency control") nicht erwähnt werden.

Es ist eine Implementation von "optimistic locking". Performanceprobleme
sind mir aber noch nicht über den Weg gelaufen. Glück gehabt.

>> > Die Implementation in einer funktionalen Sprache ist natürlich
>> > elegant, auch wenn mir Concurrent Haskell zu imperativ ist.
>>
>> *Lach* Ich glaube das ist der abgefahrenste Vorwurf, den man machen kann.
>> Nein *schüttel* ich faß' es nicht.
>
> Lachst Du über die Behauptung Concurrent Haskell wäre imperativ?

Ja.

> Der "Concurrent"-Teil ist es schon:
>
> forkIO :: IO () -> IO ()
> newMVar :: IO (MVar a)
> takeMVar :: MVar a -> IO a
> putMVar :: MVar a -> a -> IO ()
>
> Imperativer geht es nicht mehr.

Ich sehe da die Anwendung einer Monade. Mit diesem Kunstgriff ist der
imperative Teil in eine besondere Form gebracht worden, die rein funktional
behandelt werden kann. Beispiel (aus dem Multicast Projekt):

data Action = OneShot {                       run :: IO () }
     	    | Every   { every :: IO TimeDiff, run :: IO () }

type Tag = String

data TagAction = Untagged {             realwork :: Action }
     	       | Tagged   { tag :: Tag, realwork :: Action }


data OrderableAction = OrderableAction { at :: ClockTime, action :: TagAction }

schedule :: With Config Integer -> IO ()
schedule withConfig = loop
 where loop = do
          todo <- modifyMVar scheduler $ \as -> case as of
   	      [] -> return ([], [])
      	      _  -> do time <- getClockTime
	      	       let (todo, waiting) = span ((<= time) . at) as
		       return (waiting, todo)

          sequence_ $ map (forkIO . run . realwork . action) todo

	  todo' <- sequence [ do d <- dIO
	  	   	      	 return x{at = addToClockTime d t}
	  	            | x@(OrderableAction t a) <- todo
			    , (Every dIO _) <- [realwork a]]
	  modifyMVar_ scheduler $ return . merge (sort todo')

	  microSec <- withConfig $ \(Config minTime maxTime) ->
	              withMVar scheduler $ \as -> case as of
	                (x:_) -> return . max minTime
	      	       	      	 	. min maxTime
	      	       	      		. timeDiffToMicroSeconds
	      	       	      		. (at x `diffClockTimes`)
			    	      =<< getClockTime
	                _     -> return maxTime
	  threadDelay (fromInteger microSec)

   	  loop

-- 
To unsubscribe, e-mail: debate-unsubscribe@lists.fitug.de
For additional commands, e-mail: debate-help@lists.fitug.de