Hi,
Somewhat related to this...
Next month we have a paper coming up at EuroSys about a middle-ground between
using STM and programming directly with CAS:
http://research.microsoft.com/en-us/um/people/tharris/papers/2012-eurosys.pdf
This was done in the context of shared memory data
Hi,
I think this could be a nice addition.
What do you think about a slight change:
readTVarWhen :: TVar a - (a - bool) - STM a
This would retry until the (a-bool) function returns true (and, of course, as
with a normal retry, the implementation would need to watch all of the TVars
that
January 2008 00:14
To: haskell-cafe@haskell.org
Subject: [Haskell-cafe] Control.Concurrent.STM.old?
Does the 'old' function referenced in the SPJ and Tim Harris data
invariants paper stil exist? It is of type STM a - STM a and allowed
invariants to compare old TVar values with new ones. I can't find
The problem with Haskell is not finding opportunities to parallelize,
they are legion. Actually, quite the opposite, there's so much that your
code ends up slower than a sequential realization. The hard part is
making a good cost-model and a good way to create coarser chunks of
work. It's
Hi,
After seeing how close I could come to creating onRetry/retryWith I have a
question about the semantics of your idea for retryWith.
Normally after a retry the STM block is rolled back and put to sleep and
will
only be awakened and re-executed if one of the STM variables it had read
,
Tim
-Original Message-
From: [EMAIL PROTECTED] [mailto:[EMAIL PROTECTED] On Behalf Of Benjamin Franksen
Sent: 24 November 2006 03:16
To: haskell@haskell.org
Cc: haskell-cafe@haskell.org
Subject: [Haskell] Re: [Haskell-cafe] SimonPJ and Tim Harris explain STM - video
[sorry for quoting so
Hi,
I've checked a number of changes to the transactional memory support
into GHC head:
1. The main change is to add support for dynamically checked data
invariants of the kind described in
http://research.microsoft.com/~tharris/papers/2006-transact.pdf. There
are two operations: always X ::
Hi,
I had to chuckle at this one in particular, since the implementation
of transactions in Haskell was based on experiences with prototype
software TM in Java and C#! In truth, Haskell adds a few things to
the mix that make STM dramatically better. Most important are STM
and STRef---it's
But in the worst case its just a sequential computation, so any gain
from
parallelism is still a gain...
The trade-offs involved look like they'd be very complicated in
practice. For instance, considering speculative execution on SMT /
multi-core environments:
- The mechanisms used to
