f# - Desbordamiento de pila a pesar de la posición de llamada de cola, pero solo en 64 bits

64bit stack-overflow

Question

Originado a partir de esta pregunta , tengo este pequeño código F # ( github ) para generar valores aleatorios de acuerdo con una distribución normal:

// val nextSingle : (unit -> float32)
let nextSingle =
let r = System.Random()
r.NextDouble >> float32
// val gauss : (float32 -> float32 -> seq<float32>)
let gauss mean stdDev =
let rec gauss ready = seq {
match ready with
| Some spare ->
yield spare * stdDev + mean
yield! gauss None
| _ ->
let rec loop () =
let u = nextSingle() * 2.f - 1.f
let v = nextSingle() * 2.f - 1.f
let s = pown u 2 + pown v 2
if s >= 1.f || s = 0.f then loop() else
u, v, s
let u, v, s = loop()
let mul = (*)(sqrt(-2.f * log s / s))
yield mul u * stdDev + mean
yield! mul v |> Some |> gauss
}
gauss None

Para mí, parece que esto solo debería llamarse a sí mismo en la posición de llamada final, ergo nunca causar una StackOverflowException cuando TCO está habilitado. Pero lo hace cuando se ejecuta 64 bits . No funciona cuando se ejecuta la casilla de 32 bits (es decir, "Prefiere 32 bits" en la configuración del proyecto).

Estoy usando .NET Framework 4.5.2 y F # 4.4.0.0.

¿Alguien puede explicar qué está causando el problema?

Answer 1

Parece un error en el mecanismo de compilación de la expresión de la secuencia del compilador. Aquí hay una reproducción simplificada:

let rec loop r = seq {
if r > 0 then
let rec unused() = unused()
yield r
yield! loop r
}
printfn "%i" (Seq.nth 10000000 (loop 1))

Obviamente, la presencia de la definición recursiva no utilizada no debería afectar si esto genera un desbordamiento de la pila, pero lo hace.