Back to Questions
1.5k
views4
comments
immutability and parallelism in F#
f#

Hi.

I would like to understand better immutability and parallelism in F#.

so for example I have an object Account like

1
2
3
4

 class Account
 {
     public double Amount { get; set; }
 }

and a WCF service with this service operation

1
2
3
4
5
6
7
8
9
10
11
12
13

public Account ExtractMoney(Account account, double amount)
{
    Object obj = new Object();

    lock(obj)
    {               
        //actual is current acount from the data base
        if (account.Amount <= actual.Amount)
            account.Amount -= amount;
        else
             throw new Exception();
   }
}

for example.

In C#imperative style I would simply return back modiffied account.

How money extraction could be done using F#'s immutability and parallelism?

Thanks and best regards.

.

Hi,

first I think that your could would have some concurency problems anyway because of your use of lock (locking a object you just created won't give you anything but overhead - you need to lock the SAME object everytime). Also note that you won't solve the problem by making obj a class-field if you don't use the WCF-service in single-instance mode.

Now to the question: I guess that depends - do you want to ensure that the accounts balance is consistent at any time than I don't think this problem is likely to be parallelisable (you would need to to everything in a transaction that would lock every other access - so you are back to single thread access).

Immutablilty lends itself for using with parallel computation because you don't have to worry about locks, transactions and so on, because you won't change a value in memory but generate new ones. So every thread accesing a value can be sure it won't change due to some side-effects of another thread.

But as you want to mirror those side-effects to show in your Account-object you are stuck.

Maybe you can give us some more information about the system you are trying to build?

By on 3/6/2011 10:19 PM ()

I'm just trying to understand parallelism and how immutability can help write better parallel programming in F#, C# or whatever.

Suppose I have a bank account object in a multi-threaded envelopment(asp.net app, wcf service, etc.) now two users want to extract money from the same account, for example. Now with lock I can keep account balance consistent and return the modified account back from the method. How do I modify an account immutable object in F#? isn't an overhead to create a new value each time I modify something.What should I do with old values? and why locks aren't necessary? How else can I prevent a function running in parallel from inconsistently modifying an account for example?

By on 3/8/2011 1:30 AM ()

Short answer to "How do I modify an account immutable object in F#": You don't! Because that's what immutable means.

In this kind of situation you won't use immutable data but your old lock-mechanism or some kind of timestamped data of you won't cache your data at all and use transactions or whatever.

You will never have real parallel access to those kind of objects because thats what your buisiness model tells you NOT to do (you can't extract money from your account at to places at the same time).

Immutability helps you in situations where you can compute parts of a probleme at the same time (for example calculating the mandelbrot-set, multiplication of really big matrices, ...) because now you are forced to write your algorithms in a way where you can't write to the same objects at the same time and cause havok.

But here you have to think of the parts of your problem as "transformation" steps - IMHO that helps.

By on 3/8/2011 6:48 AM ()

This article

Build Concurrent Apps From Simple F# Expressions

and your answer made things a little easier.

I think I have confounded multi-threading with parallelism(which is also a kind of multi-threading)

If I understand it correctly, parallelism is used to operate on parts of a more complex object, like a big matrix for example, where the order of execution of concurrent operations is unknown and where immutability makes the order of executed operations irrelevant. This is in contrast to mutable objects where I operate on an object as a whole, and where the object's state change makes the results of an operation unpredictable.

By on 3/9/2011 12:22 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper