Presburger Arithmetic and Its Use in Verification

2.2. MULTICORE PARALLELISM ON .NET FRAMEWORK
allows users to write queries in a very declarative style which does not expose any
side effect and shows nature of problems very clearly:
let NUM_STEPS =100000000
let steps =1.0/(float NUM_STEPS)
let sqr x = x ∗ x
let linqCompute1() =
(Enumerable
.Range(0, NUM_STEPS)
.Select(fun i −> 4.0/(1.0+sqr((float i +0.5)∗steps)))
.Sum()
)∗steps
Computation is done in three steps. First, the range of 100,000,000 elements are
constructed as an instance of Enumerable class, and this type is a central element for
accommodating LINQ queries. Second, the Select method calculates intermediate
values for all indices. Finally, the Sum function aggregates all immediate results.
Due to the advantage of side effect free, LINQ queries are easy to parallelize. In
reality, .NET platform has supported LINQ queries in a parallel manner by PLINQ
constructs. The calculation π is turned into parallel execution by just changing
Enumerable to ParallelEnumerable to indicate usage of PLINQ:
let plinqCompute2() =
(ParallelEnumerable
.Range(0, NUM_STEPS)
.Select(fun i −> 4.0/(1.0+sqr((float i +0.5)∗steps)))
.Sum()
)∗steps
PLINQ provides users a cheap way to do parallelization in .NET framework; our
PLINQ version is 3-4× faster than the LINQ companion. One question raised is:
why not provide PLINQ as a default option for data querying in .NET. The reason
is that PLINQ is not always faster than its corresponding LINQ companion. To be
worth using PLINQ, a task should be big and contain rather independent subtasks.
Certainly, parallel processing by using PLINQ has drawbacks of little control over
degree of parallelism and the way tasks are split and distributed over processing
units.
Our third version is a simple for loop running 100,000,000 times and gradually
gathering results implemented by means of recursion in F#:
let compute3() =
let rec computeUtil(i, acc) =
if i =0then acc ∗ steps
else
let x =(float i +0.5)∗steps
computeUtil (i−1, acc +4.0/(1.0+x ∗ x))
computeUtil(NUM_STEPS, 0.0)
Its parallel equivalent is written using Parallel.For construct:
11