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@xxxxxxxxxxxxxx
For additional commands, e-mail: debate-help@xxxxxxxxxxxxxx