changes

Author: safesparrow

tests/FSharp.Compiler.Service.Tests2/DepResolving.fs

@@ -27,22 +27,22 @@
       <Link>Common.fs</Link>
     </Compile>
     <Compile Include="Utils.fs" />
+    <Compile Include="Types.fs" />
     <Compile Include="ASTVisit.fs" />
-    <Compile Include="TestASTVisit.fs" />
-    <Compile Include="DepResolving.fs" />
-    <Compile Include="TestDepResolving.fs" />
+    <Compile Include="FileInfoGathering.fs" />
     <Compile Include="Graph.fs" />
-    <Compile Include="RunCompiler.fs" />
+    <Compile Include="DepResolving.fs" />
     <None Include="Big.fs">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
-    <Compile Include="Types.fs" />
-    <Compile Include="Program.fs" />
     <Compile Include="Parallel.fs" />
     <Compile Include="GraphProcessing.fs" />
-    <Compile Include="FileInfoGathering.fs" />
-    <Compile Include="code2.fs" />
+    <Compile Include="ParallelTypeChecking.fs" />
     <Content Include="Docs.md" />
+    <Compile Include="Tests\TestASTVisit.fs" />
+    <Compile Include="Tests\TestDepResolving.fs" />
+    <Compile Include="Tests\RunCompiler.fs" />
+    <Compile Include="Program.fs" />
   </ItemGroup>
 
   <ItemGroup>

tests/FSharp.Compiler.Service.Tests2/FSharp.Compiler.Service.Tests2.fsproj

@@ -30,16 +30,20 @@ let private gatherBackingInfo (files : SourceFiles) : Files =
 
 type ExtractedData =
     {
-        ModuleRefs : LongIdent[]
+        /// Order of the file in the project. Files with lower number cannot depend on files with higher number
         Tops : LongIdent[]
         ContainsModuleAbbreviations : bool
+        /// All partial module references found in this file's AST
+        ModuleRefs : LongIdent[]
     }
 
+/// All the data about a single file needed for the dependency resolution algorithm
 type FileData =
     {
         File : File
         Data : ExtractedData
     }
+    with member this.CodeSize = this.File.CodeSize
 
 let private gatherFileData (file : File) : ExtractedData =
     let moduleRefs, containsModuleAbbreviations = ASTVisit.findModuleRefs file.AST

tests/FSharp.Compiler.Service.Tests2/FileInfoGathering.fs

@@ -69,7 +69,7 @@ let combineResults
 // TODO Could be replaced with a simpler recursive approach with memoised per-item results
 let processGraph<'Item, 'State, 'Result when 'Item : equality>
     (graph : Graph<'Item>)
-    (doWork : 'Item -> 'State -> 'State * 'Result)
+    (doWork : 'Item -> 'State -> 'Result)
     (folder : 'State -> 'Result -> 'State)
     (parallelism : int)
     : 'State
@@ -109,8 +109,10 @@ let processGraph<'Item, 'State, 'Result when 'Item : equality>
         let deps = lookupMany node.Info.Deps
         let transitiveDeps = lookupMany node.Info.TransitiveDeps
         let inputState = combineResults deps transitiveDeps folder
-        let res = doWork node.Info.Item inputState
-        node.Result <- Some res
+        let singleRes = doWork node.Info.Item inputState
+        let state = folder inputState singleRes
+        node.Result <- Some (state, singleRes)
+        
         // Need to double-check that only one dependency schedules this dependant
         let unblocked =
             node.Info.Dependants

tests/FSharp.Compiler.Service.Tests2/GraphProcessing.fs

@@ -1,6 +1,5 @@
-module FSharp.Compiler.Service.Tests.code
+module FSharp.Compiler.Service.Tests.ParallelTypeChecking
 
-open FSharp.Compiler.ParseAndCheckInputs
 open FSharp.Compiler.Service.Tests.Graph
 open FSharp.Compiler.Service.Tests.Types
 
@@ -9,27 +8,31 @@ type FileGraph = Graph<File>
 let calcFileGraph (files : SourceFiles) : FileGraph =
     failwith ""
 
+// TODO Use real things
 type State = string
 type SingleResult = int
 
+// TODO Use the real thing
 let typeCheckFile (file : File) (state : State) : SingleResult
     =
     file.Idx.Idx
 
+// TODO Use the real thing
 let folder (state : string) (result : int) =
-    $"{state}+{result}" 
+    $"{state}+{result}"
 
-let typeCheckGraph (graph : FileGraph) : TcState =
+// TODO We probably need to return partial results as well
+let typeCheckGraph (graph : FileGraph) : State =
     let parallelism = 4 // cpu count?
     let state =
         GraphProcessing.processGraph
             graph
             typeCheckFile
             folder
             parallelism
-     state
+    state
 
-let typeCheck (files : SourceFiles) : TcState =
+let typeCheck (files : SourceFiles) : State =
     let graph = calcFileGraph files
     let state = typeCheckGraph graph
     state

tests/FSharp.Compiler.Service.Tests2/code2.fs renamed to tests/FSharp.Compiler.Service.Tests2/ParallelTypeChecking.fs

@@ -0,0 +1,57 @@
+module FSharp.Compiler.Service.Tests2.RunCompiler
+
+open System
+open System.Collections.Concurrent
+open System.Collections.Generic
+open System.Threading
+open System.Threading.Tasks
+open FSharp.Compiler.Service.Tests
+open FSharp.Compiler.Service.Tests.Graph
+open NUnit.Framework
+
+[<Test>]
+let runCompiler () =
+    let args =
+        System.IO.File.ReadAllLines(@"C:\projekty\fsharp\heuristic\tests\FSharp.Compiler.Service.Tests2\args.txt") |> Array.skip 1
+    FSharp.Compiler.CommandLineMain.main args |> ignore
+    
+[<Test>]
+let runGrapher () =
+    // let args =
+    //     System.IO.File.ReadAllLines(@"C:\projekty\fsharp\heuristic\tests\FSharp.Compiler.Service.Tests2\args.txt") |> Array.skip 1
+    // FSharp.Compiler.CommandLineMain.main args |> ignore
+    
+    let deps : Graph<int> =
+        [|
+            0, [||]  // A
+            1, [|0|] // B1 -> A
+            2, [|1|] // B2 -> B1
+            3, [|0|] // C1 -> A
+            4, [|3|] // C2 -> C1
+            5, [|2; 4|] // D -> B2, C2
+        |]
+        |> readOnlyDict
+    
+    let dependants = deps |> Graph.reverse
+    let transitiveDeps = deps |> Graph.transitive
+    let transitiveDependants = transitiveDeps |> Graph.reverse
+    
+    let nodes =
+        deps.Keys
+        |> Seq.map (fun idx -> idx, {Idx = idx; Deps = [||]; Dependants = [||]; TransitiveDeps = [||]; Result = None; UnprocessedDepsCount = 0; _lock = Object()})
+        |> readOnlyDict
+    
+    let processs deps = deps |> Array.map (fun d -> nodes[d])
+    
+    let graph =
+        nodes
+        |> Seq.iter (fun (KeyValue(idx, node)) ->
+            node.Deps <- processs deps[idx]
+            node.TransitiveDeps <- processs transitiveDeps[idx]
+            node.Dependants <- processs dependants[idx]
+            node.UnprocessedDepsCount <- node.Deps.Length
+        )
+        nodes.Values
+        |> Seq.toArray
+    
+    GraphProcessing.processGraph graph