Back to Questions
877
views1
comment
Dictionaries of operations and inlining
f#compiler

Hi,

I am writing a generic function working on vectors. This function takes a dictionary of operations, i.e. an object containing function values for each operation on vectors.
The dictionary contains a function value for the addition of two vectors, and an optional function value for addition of 6 vectors. The optional function value can be used to avoid creating temporary vectors when summing 6 vectors.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

type Add6<'vector> = 'vector * 'vector * 'vector * 'vector * 'vector * 'vector -> 'vector


// Dictionary of operations.
type VecOps<'vector, 'scalar> = {
    up: 'vector
    add: 'vector * 'vector -> 'vector
    add6: Add6<'vector> option
    scale: 'scalar -> 'vector -> 'vector
}


let inline average (vec_ops: VecOps<_, _>) old v1 v2 v3 v4 =
    let (*) k v = vec_ops.scale k v
    let (+) u v = vec_ops.add(u, v)
    
    match vec_ops.add6 with
    // No addMany available, use pair-wise additions (will create many intermediate vectors).
    | None ->
        old + (1.0/6.0) * (v1 + 2.0 * (v2 + v3) + v4)
    // addMany available, use it.
    | Some add ->
        let tmp = add (v1, v2, v2, v3, v3, v4)
        vec_ops.add (old, (vec_ops.scale (1.0/6.0) tmp))

This function is declared inlined to allow the compiler to "see through" the dictionary and simplify the generated code. In particular, I would like the match to be removed. For instance, if vec_ops.add6 is None, it would be nice if the compiler generated:

1
2
3
4

let instantiated_average  old v1 v2 v3 v4 =
        old + (1.0/6.0) * (v1 + 2.0 * (v2 + v3) + v4)

This actually works fine when function "average" uses parameters instead of a dictionary.

1

let inline average2 (scale: float -> 'vec -> 'vec) (add: 'vec * 'vec -> 'vec) (add6: 'vec Add6 option) old v1 v2 v3 v4 =

It even works sometimes with dictionaries, apparently when the dictionary is small enough. Is there a way to control the code optimization heuristics to help the compiler generate the efficient code?

.

I think I have found a satisfying compromise.

I write generic functions using one parameter for each operation, which seems to guarantee that the compiler will perform the optimizations I want it to do.

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

let inline average2 (scale: float * 'vec -> 'vec) (add: 'vec * 'vec -> 'vec) (add6: 'vec Add6 option) old v1 v2 v3 v4 =
    let (*) k v = scale(k, v)
    let (+) u v = add(u, v)
    
    match add6 with
    // No addMany available, use pair-wise additions (will create many intermediate vectors).
    | None ->
        old + (1.0/6.0) * (v1 + 2.0 * (v2 + v3) + v4)
    // addMany available, use it.
    | Some addM ->
        let tmp = addM(v1, v2, v2, v3, v3, v4)
        old + (1.0/6.0) * tmp

As this is not very friendly towards users of the generic code, I provide an empty class with a single static method returning a record of the specialized generic functions:

1
2
3
4
5
6
7
8
9

type SpecializedFuncs<'Vector> = {
    average : 'Vector -> 'Vector -> 'Vector -> 'Vector -> 'Vector -> 'Vector
    ...
}

type SpecializedFuncsFactory<'Vector> =
    static member inline instantiate(scale, add2, ?add6) =
        {average = average2 scale add2 add6;
         ...}

Using a class and a method allows me to make some parameters optional, which is nicer than forcing the user to pass a None value. Named parameters are another nice feature of methods which come handy here.

1
2
3
4
5
6
7
8

// Instantiate, using add6
let funcs = SpecializedFuncsFactory<Vec3d>.instantiate(scale = scale_Vec3d, add2 = plus_Vec3d, add6 = add6_Vec3d)
let average_Vec3d = funcs.average


// Instantiate, not using add6
let funcs' = SpecializedFuncsFactory<Vec3d>(scale = scale_Vec3d, add2 = plus_Vec3d)
let average_Vec3d' = funcs'.average
By on 10/22/2008 1:02 PM ()

    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