<div>Atomic operations are special operations where you don&#39;t have to worry about some other process messing with things while the operation is taking place.</div><div><br></div>For a simple example of why atomic operations are important:<div>
(taken from: <a href="http://en.wikipedia.org/wiki/Linearizability#Non-atomic">http://en.wikipedia.org/wiki/Linearizability#Non-atomic</a>)</div><div><span class="Apple-style-span" style="font-family: sans-serif; font-size: 13px; line-height: 19px; "><p style="margin-top: 0.4em; margin-right: 0px; margin-bottom: 0.5em; margin-left: 0px; line-height: 1.5em; ">
The naive, non-atomic implementation:</p><dl style="margin-top: 0.2em; margin-bottom: 0.5em; "><dd style="line-height: 1.5em; margin-left: 2em; margin-bottom: 0.1em; "><ol style="line-height: 1.5em; margin-top: 0.3em; margin-right: 0px; margin-bottom: 0.5em; margin-left: 3.2em; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; list-style-image: none; ">
<li style="margin-bottom: 0.1em; ">reads the value in the memory location;</li><li style="margin-bottom: 0.1em; ">adds one to the value;</li><li style="margin-bottom: 0.1em; ">writes the new value back into the memory location.</li>
</ol></dd></dl><p style="margin-top: 0.4em; margin-right: 0px; margin-bottom: 0.5em; margin-left: 0px; line-height: 1.5em; ">Now, imagine two processes are running incrementing a single, shared memory location:</p><ol style="line-height: 1.5em; margin-top: 0.3em; margin-right: 0px; margin-bottom: 0.5em; margin-left: 3.2em; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; list-style-image: none; ">
<li style="margin-bottom: 0.1em; ">the first process reads the value in memory location;</li><li style="margin-bottom: 0.1em; ">the first process adds one to the value;</li></ol><p style="margin-top: 0.4em; margin-right: 0px; margin-bottom: 0.5em; margin-left: 0px; line-height: 1.5em; ">
but before it can write the new value back to the memory location it is suspended, and the second process is allowed to run:</p><ol style="line-height: 1.5em; margin-top: 0.3em; margin-right: 0px; margin-bottom: 0.5em; margin-left: 3.2em; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; list-style-image: none; ">
<li style="margin-bottom: 0.1em; ">the second process reads the value in memory location, the <i>same</i> value that the first process read;</li><li style="margin-bottom: 0.1em; ">the second process adds one to the value;</li>
<li style="margin-bottom: 0.1em; ">the second process writes the new value into the memory location.</li></ol><p style="margin-top: 0.4em; margin-right: 0px; margin-bottom: 0.5em; margin-left: 0px; line-height: 1.5em; ">The second process is suspended and the first process allowed to run again:</p>
<ol style="line-height: 1.5em; margin-top: 0.3em; margin-right: 0px; margin-bottom: 0.5em; margin-left: 3.2em; padding-top: 0px; padding-right: 0px; padding-bottom: 0px; padding-left: 0px; list-style-image: none; "><li style="margin-bottom: 0.1em; ">
the first process writes a now-wrong value into the memory location, unaware that the other process has already updated the value in the memory location.</li></ol></span></div><div><br></div><div>Atomic operations fix this problem by preventing (STM is a little fancier and doesn&#39;t actually _prevent_, but you can pretend that it does) any other process from writing to the memory in question until the computation is finished and the result is written back.</div>
<div><br></div><div><br></div><div>For many simple cases something like atomicModifyIORef is all you really need. However, if you have cases where you need to make sure _multiple_ IORefs/MVars/TVars/etc.. are not written to until you&#39;re finished then you really need something like STMs &#39;atomically&#39; function. Which runs a block of STM operations &quot;atomically&quot;.</div>
<div><br></div><div><a href="http://en.wikipedia.org/wiki/Linearizability#Non-atomic"></a>Hope that helps,</div><div><br></div><div>- Job<br><br><div class="gmail_quote">On Wed, Jul 28, 2010 at 8:23 PM, Eitan Goldshtrom <span dir="ltr">&lt;<a href="mailto:thesourceofx@gmail.com">thesourceofx@gmail.com</a>&gt;</span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex;">





<div bgcolor="#ffffff" text="#000000">
<font face="Helvetica, Arial, sans-serif">Hi everyone. I was wondering
if someone could just guide me toward some good information, but if
anyone wants to help with a personal explanation I welcome it. I&#39;m
trying to write a threaded program and I&#39;m not sure how to manage my
memory. I read up on MVars and they make a lot of sense. My real
question is what is &quot;atomic&quot; and how does it apply to TVars? I don&#39;t
understand what atomic transactions are and I can&#39;t seem to find a
concise explanation. I also saw some stuff about TMVars? But I can&#39;t
find much on them either. Any help would be appreciated.<br>
<br>
-Eitan<br>
</font>
</div>

<br>_______________________________________________<br>
Haskell-Cafe mailing list<br>
<a href="mailto:Haskell-Cafe@haskell.org">Haskell-Cafe@haskell.org</a><br>
<a href="http://www.haskell.org/mailman/listinfo/haskell-cafe" target="_blank">http://www.haskell.org/mailman/listinfo/haskell-cafe</a><br>
<br></blockquote></div><br></div>