Что может сделать неоптимизированный код F # быстрее, чем оптимизированный код?

Итак, я решил попробовать F # и портировал на него один из алгоритмов, которые я написал на C #. В какой-то момент я заметил, что отладочная сборка выполняется быстрее, чем выпускная. Затем я поигрался с настройками оптимизации и получил следующие результаты:

Время показывает общее время выполнения алгоритма за 100000 запусков. Я использую компилятор F #, который поставляется с Visual Studio 2010 SP1. Целевая платформа - любой процессор.

Opt off, tail calls off: 5.81s
Opt off, tail calls on : 5.79s
Opt on , tail calls off: 6.48s
Opt on , tail calls on : 6.40s

Меня действительно озадачивает - почему оптимизация замедляет выполнение кода? Версия алгоритма для C # не демонстрирует такого поведения (хотя она реализована несколько иначе)

Это урезанная версия кода F #, это алгоритм, который находит шаблоны в молекулах. Весь код, на который опирается эта программа на F #, написан на F #.

namespace Motives
  module Internal = 
    type Motive = 
      { ResidueSet: Set<Residue>; AtomSet: Set<IAtom> }
      member this.Atoms : IAtom seq = 
        seq { 
          for r in this.ResidueSet do yield! r.Atoms
          yield! this.AtomSet
        }
      static member fromResidues (residues : Residue seq) = residues |> Seq.fold (fun (m: Set<Residue>) r -> m.Add(r)) Set.empty |> fun rs -> { ResidueSet = rs; AtomSet = Set.empty }
      static member fromAtoms (atoms : IAtom seq) = atoms |> Seq.fold (fun (m: Set<IAtom>) a -> m.Add(a)) Set.empty |>  fun atoms -> { ResidueSet = Set.empty; AtomSet = atoms }
      static member merge (m1: Motive) (m2: Motive) = { ResidueSet = Set.union m1.ResidueSet m2.ResidueSet; AtomSet = Set.union m1.AtomSet m2.AtomSet }
      static member distance (m1: Motive) (m2: Motive) = Seq.min (seq { for a in m1.Atoms do for b in m2.Atoms -> a.Position.DistanceTo(b.Position) })

    type Structure with 
      static member fromMotive (m: Motive) (parent: IStructure) (addBonds: bool) : IStructure = 
        let atoms = AtomCollection.FromUniqueAtoms(m.Atoms)
        let bonds = 
          match addBonds with 
          | true -> BondCollection.Create(atoms |> Seq.map (fun a -> parent.Bonds.[a]) |> Seq.concat)
          | _ -> BondCollection.Empty
        Structure.Create (parent.Id + "_" + atoms.[0].Id.ToString(), atoms, bonds)

    // KDTree used for range queries
    // AminoChains used for regex queries
    type StructureContext = 
      { Structure: IStructure; KDTree: Lazy<KDAtomTree>; AminoChains: Lazy<(Residue array * string) list> }
      static member create (structure: IStructure) =
        match structure.IsPdbStructure() with
        | false -> { Structure = structure; KDTree = Lazy.Create(fun () -> structure.Atoms.ToKDTree()); AminoChains = Lazy.CreateFromValue([]) }
        | true  -> 
          let aminoChains = new System.Func<(Residue array * string) list> (fun () ->
            let residues = structure.PdbResidues() |> Seq.filter (fun r -> r.IsAmino)
            residues
            |> Seq.groupBy (fun r -> r.ChainIdentifier)
            |> Seq.map (fun (k,rs) -> rs |> Array.ofSeq, String.concat "" (rs |> Seq.map (fun r -> r.ShortName)))
            |> List.ofSeq)
          { Structure = structure; KDTree = Lazy.Create(fun () -> structure.Atoms.ToKDTree()); AminoChains = Lazy.Create(aminoChains) }

    // Remember the named motives from named patterns
    type MatchContext = 
      { StructureContext: StructureContext; NamedMotives: Map<string, Motive> }
      static member merge (c1: MatchContext) (c2: MatchContext) = 
        { StructureContext = c1.StructureContext; NamedMotives = c2.NamedMotives |> Map.fold (fun m k v -> m.Add(k,v)) c1.NamedMotives }

    type MatchedMotive = Motive * MatchContext 

    type Pattern = 
      | EmptyPattern
      | GeneratingPattern of ( StructureContext -> MatchedMotive seq )
      | ConstraintPattern of ( MatchedMotive -> MatchedMotive option ) * Pattern
      static member matches (p: Pattern) (context: StructureContext) : MatchedMotive seq = 
        match p with  
        | GeneratingPattern generator -> generator context
        | ConstraintPattern (transform, pattern) ->
          Pattern.matches pattern context
          |> Seq.choose (fun m -> transform m)
        | _ -> Seq.empty

    let ringPattern (names: string list) =
      let fingerprint = 
        names 
        |> Seq.map (fun s -> ElementSymbol.Create(s).ToString()) 
        |> Seq.sort
        |> String.concat ""  
      let generator (context: StructureContext) =
        let rings = context.Structure.Rings().GetRingsByFingerprint(fingerprint)
        rings |> Seq.map (fun r -> Motive.fromAtoms r.Atoms, { StructureContext = context; NamedMotives = Map.empty })
      GeneratingPattern generator

  open Internal

  type MotiveFinder (pattern: string) =
    // I am using a hard coded pattern here for testing purposes
    let pattern = ringPattern ["C"; "C"; "C"; "C"; "C"; "O"]
    member this.Matches (structure: IStructure) =
      Pattern.matches pattern (StructureContext.create structure)
      |> Seq.map (fun (m, mc) -> Structure.fromMotive m mc.StructureContext.Structure false) 
      |> List.ofSeq 
      |> List.sortBy (fun s -> s.Atoms.[0].Id)

///////////////////////////////////////////////////////////////////
// performance test

let warmUp = (new MotiveFinder("")).Matches (StructureReader.ReadPdb(filename, computeBonds = true))
printfn "%i" (List.length warmUp)

let structure = StructureReader.ReadPdb(filename, computeBonds = true)
let stopWatch = System.Diagnostics.Stopwatch.StartNew()
let nruns = 100000
let result = 
  seq { 
    for i in 1 .. nruns do
      yield (new MotiveFinder("")).Matches structure 
  } |> Seq.nth (nruns-1)

stopWatch.Stop()
printfn "Time elapsed: %f seconds" stopWatch.Elapsed.TotalSeconds

РЕДАКТИРОВАТЬ2:

Я, кажется, сузил проблему до реализации типа Set.

Для этого кода:

let stopWatch = System.Diagnostics.Stopwatch.StartNew()
let runs = 1000000
let result = 
  seq {
    for i in 1 .. runs do
      let setA = [ 1 .. (i % 10) + 5 ] |> Set.ofList
      let setB = [ 1 .. (i % 10) + 5 ] |> Set.ofList
      yield Set.union setA setB
  } |> Seq.nth (runs - 1)

stopWatch.Stop()
printfn "Time elapsed: %f seconds" stopWatch.Elapsed.TotalSeconds
printfn "%A" result

Я получаю ~ 7,5 с при выключенной оптимизации и ~ 8,0 с при включенной оптимизации. По-прежнему цель = любой процессор (а у меня процессор i7-860).

РЕДАКТИРОВАТЬ3: И сразу после того, как я опубликовал предыдущую правку, я решил, что должен попробовать только в списках.

Так что для

let stopWatch = System.Diagnostics.Stopwatch.StartNew()
let runs = 1000000
let result1 = 
  seq {
    for i in 1 .. runs do
      let list = [ 1 .. i % 100 + 5 ]
      yield list
  } |> Seq.nth (runs - 1)

stopWatch.Stop()
printfn "Time elapsed: %f seconds" stopWatch.Elapsed.TotalSeconds
printfn "%A" result1

я получаю ~ 3 с с опцией. выкл. и ~ 3,5 с с опт. на.

РЕДАКТИРОВАТЬ4:

Если я удалю секвенсор и просто сделаю

let stopWatch = System.Diagnostics.Stopwatch.StartNew()
let runs = 1000000
let mutable ret : int list = []
for i in 1 .. runs do
  let list = [ 1 .. i % 100 + 5 ]
  ret <- list

stopWatch1.Stop()
printfn "Time elapsed: %f seconds" stopWatch.Elapsed.TotalSeconds
printfn "%A" ret

, я получу ~ 3 секунды с включенной и выключенной оптимизацией.Так что, похоже, проблема где-то в оптимизации кода построителя seq.

Как ни странно, я написал тестовое приложение на C #:

var watch = Stopwatch.StartNew();

int runs = 1000000;

var result = Enumerable.Range(1, runs)
  .Select(i => Microsoft.FSharp.Collections.ListModule.OfSeq(Enumerable.Range(1, i % 100 + 5)))
  .ElementAt(runs - 1);

watch.Stop();

Console.WriteLine(result);
Console.WriteLine("Time: {0}s", watch.Elapsed.TotalSeconds);

И код выполняется почти в два раза быстрее, чем решение F #, за ~ 1,7 с.

РЕДАКТИРОВАТЬ5:

Основываясь на обсуждении с Джоном Харропом, я обнаружил причину, по которой оптимизированный код работает медленнее (я до сих пор не знаю, почему).

Если я изменю Motive.Atoms с

member this.Atoms : IAtom seq = 
  seq { 
    for r in this.ResidueSet do yield! r.Atoms
      yield! this.AtomSet
  }

на

member this.Atoms : IAtom seq = 
  Seq.append (this.ResidueSet |> Seq.collect (fun r -> r.Atoms)) this.AtomSet

, то программа выполнит ~ 7.1 с как в оптимизированной, так и в неоптимизированной версии. Это медленнее, чем версия seq , но, по крайней мере, согласованно.

Получается, что компилятор F # просто не может оптимизировать выражения вычислений и фактически делает их медленнее, пытаясь это сделать.