0votos

Carrera de "¡Baja la escalera!" en F#

por josejuan hace 4 años

Usando Microsoft Accelerator v2, corriendo con el target Multicore se muere, seguramente por la operación Min que la hace en pila ¿usando CUDA?.

Una variante que convierte al popular juguete en una carrera de la que debes calcular las mejores rutas de los corredores.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
open Microsoft.ParallelArrays 
type P = ParallelArrays 
 
type Row = IntParallelArray 
type Tree = Row list 
 
let row2row (a: Row) (b: Row) : Row = 
    let sa = a.GetLength(0) 
    let bL = P.Section(b, new SectionSpecifier(0, sa)) 
    let bR = P.Section(b, new SectionSpecifier(1, sa)) 
    P.Add(a, P.Min(bL, bR)) 
 
let rec costsTree (t: Tree) : Row * Tree = 
        match t with 
        | x::[] -> (x, [x]) 
        | x::xs -> let (y, ys) = costsTree xs 
                   let z       = row2row x y 
                   (z, z::ys) 
 
let randomRow (rnd: System.Random) (w: int) : Row = new IntParallelArray(Array.map (fun _ -> rnd.Next(10)) [|1 .. w|]) 
 
let randomTree (w: int) (r: int) : Tree = 
    let rnd = System.Random(1) 
    List.map (randomRow rnd) [w .. w + r] 
 
// para testear 
let tree1 : Tree = [ new IntParallelArray([|  3;0  |]) 
                   ; new IntParallelArray([| 3;1;0 |]) 
                   ; new IntParallelArray([|3;5;0;9|]) 
 
[<EntryPoint>] 
let main argv = 
    printfn "Generando árbol..." 
    let (w, r) = (System.Int32.Parse(argv.[0]), System.Int32.Parse(argv.[1])) 
    let tree = randomTree w r 
    printfn "Total rows: %A" (List.length tree) 
    printfn "Calculando rutas mínimas..." 
    let t0 = System.DateTime.UtcNow 
    let (s, _) = costsTree tree 
    let res = (new MulticoreTarget()).ToArray1D(s) 
    let t1 = System.DateTime.UtcNow 
    printfn "%A" res 
    printfn "%A" ((t1 - t0).TotalSeconds) 
    0 // devolver un código de salida entero 

Comenta la solución

Tienes que identificarte para poder publicar tu comentario.