From 0dd52587f202e829bc67cf080a96a168d37f62c2 Mon Sep 17 00:00:00 2001 From: Chet Husk Date: Sun, 17 Jul 2022 10:16:26 -0500 Subject: [PATCH 01/39] first activity plumbing --- eng/Versions.props | 1 + src/Compiler/Driver/fsc.fs | 2 +- src/fsc/fsc.targets | 3 +++ src/fsc/fscmain.fs | 20 ++++++++++++++++++++ 4 files changed, 25 insertions(+), 1 deletion(-) diff --git a/eng/Versions.props b/eng/Versions.props index 6571c5fb21a..fc37e7ec09c 100644 --- a/eng/Versions.props +++ b/eng/Versions.props @@ -87,6 +87,7 @@ 4.3.0 4.3.0 4.0.0 + 5.0.1 4.3.0 4.3.0 1.6.0 diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs index de5fbf9ebd8..fe7147c6c9e 100644 --- a/src/Compiler/Driver/fsc.fs +++ b/src/Compiler/Driver/fsc.fs @@ -1380,7 +1380,7 @@ let CompileFromCommandLineArguments with _ -> () } - + use mainActivity = new Activity("fcs:main") main1 ( ctok, argv, diff --git a/src/fsc/fsc.targets b/src/fsc/fsc.targets index 9e4e4e48067..7aaa9c76239 100644 --- a/src/fsc/fsc.targets +++ b/src/fsc/fsc.targets @@ -37,12 +37,15 @@ + + + diff --git a/src/fsc/fscmain.fs b/src/fsc/fscmain.fs index ebdf21af60d..3bca741c979 100644 --- a/src/fsc/fscmain.fs +++ b/src/fsc/fscmain.fs @@ -17,6 +17,10 @@ open FSharp.Compiler.Driver open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.CodeAnalysis open FSharp.Compiler.Text +open System.Diagnostics +open OpenTelemetry +open OpenTelemetry.Resources +open OpenTelemetry.Trace [] do () @@ -24,6 +28,20 @@ do () [] let main (argv) = + use tracerProvider = + Sdk.CreateTracerProviderBuilder() + .AddSource("fsc") + .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) + .AddConsoleExporter() + .Build(); + use activitySource = new ActivitySource("fsc") + use mainActivity = activitySource.StartActivity("main") + + let forceCleanup() = + mainActivity.Dispose() + activitySource.Dispose() + tracerProvider.Dispose() + let compilerName = // the 64 bit desktop version of the compiler is name fscAnyCpu.exe, all others are fsc.exe if @@ -67,6 +85,7 @@ let main (argv) = let stats = ILBinaryReader.GetStatistics() AppDomain.CurrentDomain.ProcessExit.Add(fun _ -> + forceCleanup() printfn "STATS: #ByteArrayFile = %d, #MemoryMappedFileOpen = %d, #MemoryMappedFileClosed = %d, #RawMemoryFile = %d, #WeakByteArrayFile = %d" stats.byteFileCount @@ -81,6 +100,7 @@ let main (argv) = let quitProcessExiter = { new Exiter with member _.Exit(n) = + forceCleanup() try exit n with _ -> From 237bf5933f098dcd52d0996ef1300a0592e2234e Mon Sep 17 00:00:00 2001 From: Chet Husk Date: Sun, 17 Jul 2022 12:29:51 -0500 Subject: [PATCH 02/39] very basic spans --- NuGet.config | 1 + src/Compiler/Driver/ParseAndCheckInputs.fs | 2 ++ src/Compiler/Driver/fsc.fs | 22 +++++++++++++++++++-- src/Compiler/FSharp.Compiler.Service.fsproj | 3 ++- src/Compiler/Facilities/Logger.fs | 7 ++++++- src/Compiler/Facilities/Logger.fsi | 5 +++++ src/fsc/fscProject/fsc.fsproj | 2 +- src/fsc/fscmain.fs | 17 +++++++++------- 8 files changed, 47 insertions(+), 12 deletions(-) diff --git a/NuGet.config b/NuGet.config index c6b6cb09dd7..72860d7241d 100644 --- a/NuGet.config +++ b/NuGet.config @@ -13,6 +13,7 @@ + diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index b0c820c6c67..2d0e5200625 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -4,6 +4,7 @@ module internal FSharp.Compiler.ParseAndCheckInputs open System +open System.Diagnostics open System.IO open System.Collections.Generic @@ -21,6 +22,7 @@ open FSharp.Compiler.CompilerConfig open FSharp.Compiler.CompilerDiagnostics open FSharp.Compiler.CompilerImports open FSharp.Compiler.Diagnostics +open FSharp.Compiler.Diagnostics.Activity open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.Features open FSharp.Compiler.IO diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs index fe7147c6c9e..1f6e122b653 100644 --- a/src/Compiler/Driver/fsc.fs +++ b/src/Compiler/Driver/fsc.fs @@ -39,6 +39,7 @@ open FSharp.Compiler.CompilerGlobalState open FSharp.Compiler.CreateILModule open FSharp.Compiler.DependencyManager open FSharp.Compiler.Diagnostics +open FSharp.Compiler.Diagnostics.Activity open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.IlxGen open FSharp.Compiler.InfoReader @@ -166,6 +167,8 @@ let TypeCheck inputs, exiter: Exiter ) = + use typecheckActivity = activitySource.StartActivity("typecheck_inputs") + try if isNil inputs then error (Error(FSComp.SR.fscNoImplementationFiles (), rangeStartup)) @@ -529,6 +532,7 @@ let main1 // Process command line, flags and collect filenames let sourceFiles = + use parseActivity = activitySource.StartActivity("fcs:main1:determine_sources") // The ParseCompilerOptions function calls imperative function to process "real" args // Rather than start processing, just collect names, then process them. @@ -562,6 +566,8 @@ let main1 // If there's a problem building TcConfig, abort let tcConfig = + use createConfigActivity = activitySource.StartActivity("fcs:main1:create_tc_config") + try TcConfig.Create(tcConfigB, validate = false) with e -> @@ -586,10 +592,12 @@ let main1 let foundationalTcConfigP = TcConfigProvider.Constant tcConfig let sysRes, otherRes, knownUnresolved = + use splitResolutionsActivity = activitySource.StartActivity("fcs:main1:split_resolutions") TcAssemblyResolutions.SplitNonFoundationalResolutions(tcConfig) // Import basic assemblies let tcGlobals, frameworkTcImports = + use frameworkImportsActivity = activitySource.StartActivity("fcs:main:import_framework_references") TcImports.BuildFrameworkTcImports(foundationalTcConfigP, sysRes, otherRes) |> NodeCode.RunImmediateWithoutCancellation @@ -642,6 +650,7 @@ let main1 ReportTime tcConfig "Import non-system references" let tcImports = + use nonFrameworkImportsActivity = activitySource.StartActivity("fcs:main1:import_non_framework_references") TcImports.BuildNonFrameworkTcImports(tcConfigP, frameworkTcImports, otherRes, knownUnresolved, dependencyProvider) |> NodeCode.RunImmediateWithoutCancellation @@ -660,6 +669,7 @@ let main1 use unwindParsePhase = PushThreadBuildPhaseUntilUnwind BuildPhase.TypeCheck let tcEnv0, openDecls0 = + use initialTcEnvActivity = activitySource.StartActivity("fcs:main1:get_initial_tc_env") GetInitialTcEnv(assemblyName, rangeStartup, tcConfig, tcImports, tcGlobals) // Type check the inputs @@ -719,7 +729,9 @@ let main1OfAst disposables: DisposablesTracker, inputs: ParsedInput list ) = - + + use main1AstActivity = activitySource.StartActivity("fcs:main1_ast") + let tryGetMetadataSnapshot = (fun _ -> None) let directoryBuildingFrom = Directory.GetCurrentDirectory() @@ -904,6 +916,8 @@ let main2 exiter: Exiter, ilSourceDocs)) = + use main2Activity = activitySource.StartActivity("fcs:main2") + if tcConfig.typeCheckOnly then exiter.Exit 0 @@ -1012,7 +1026,7 @@ let main3 exiter: Exiter, ilSourceDocs)) = - + use main3Activity = activitySource.StartActivity("fcs:main3") // Encode the signature data ReportTime tcConfig "Encode Interface Data" let exportRemapping = MakeExportRemapping generatedCcu generatedCcu.Contents @@ -1108,6 +1122,7 @@ let main4 exiter: Exiter, ilSourceDocs)) = + use main4Activity = activitySource.StartActivity("fcs:main4") match tcImportsCapture with | None -> () @@ -1212,6 +1227,7 @@ let main5 exiter: Exiter, ilSourceDocs)) = + use main5Activity = activitySource.StartActivity("fcs:main5") use unwindBuildPhase = PushThreadBuildPhaseUntilUnwind BuildPhase.Output @@ -1244,6 +1260,7 @@ let main6 exiter: Exiter, ilSourceDocs)) = + use main6Activity = activitySource.StartActivity("fcs:main6") ReportTime tcConfig "Write .NET Binary" @@ -1368,6 +1385,7 @@ let CompileFromCommandLineArguments tcImportsCapture, dynamicAssemblyCreator ) = + use mainActivity = activitySource.StartActivity("fcs:main") use disposables = new DisposablesTracker() let savedOut = Console.Out diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index 0a875a29c47..715338e2de7 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -3,7 +3,7 @@ - net472;netstandard2.0 + netstandard2.0;net472; Library $(NoWarn);44 $(NoWarn);57 @@ -497,6 +497,7 @@ + diff --git a/src/Compiler/Facilities/Logger.fs b/src/Compiler/Facilities/Logger.fs index dc425c506fe..3a62b996f86 100644 --- a/src/Compiler/Facilities/Logger.fs +++ b/src/Compiler/Facilities/Logger.fs @@ -2,8 +2,13 @@ namespace FSharp.Compiler.Diagnostics -open System.Diagnostics.Tracing open System +open System.Diagnostics +open System.Diagnostics.Tracing + +module Activity = + let activitySourceName = "fsc" + let activitySource = new ActivitySource(activitySourceName) type LogCompilerFunctionId = | Service_ParseAndCheckFileInProject = 1 diff --git a/src/Compiler/Facilities/Logger.fsi b/src/Compiler/Facilities/Logger.fsi index 08134122864..cbc990a3e5a 100644 --- a/src/Compiler/Facilities/Logger.fsi +++ b/src/Compiler/Facilities/Logger.fsi @@ -3,6 +3,11 @@ namespace FSharp.Compiler.Diagnostics open System +open System.Diagnostics + +module Activity = + val activitySourceName: string + val activitySource: ActivitySource type internal LogCompilerFunctionId = | Service_ParseAndCheckFileInProject = 1 diff --git a/src/fsc/fscProject/fsc.fsproj b/src/fsc/fscProject/fsc.fsproj index 03fbcd56d51..aaef6e053c9 100644 --- a/src/fsc/fscProject/fsc.fsproj +++ b/src/fsc/fscProject/fsc.fsproj @@ -4,7 +4,7 @@ $(ProtoTargetFramework) - net472;net6.0 + net6.0;net472; net6.0 x86 diff --git a/src/fsc/fscmain.fs b/src/fsc/fscmain.fs index 3bca741c979..3df75486f88 100644 --- a/src/fsc/fscmain.fs +++ b/src/fsc/fscmain.fs @@ -13,6 +13,7 @@ open Internal.Utilities.Library.Extras open FSharp.Compiler.AbstractIL open FSharp.Compiler.AbstractIL.ILBinaryReader open FSharp.Compiler.CompilerConfig +open FSharp.Compiler.Diagnostics.Activity open FSharp.Compiler.Driver open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.CodeAnalysis @@ -26,18 +27,20 @@ open OpenTelemetry.Trace do () [] -let main (argv) = +let main(argv) = - use tracerProvider = + // eventually this would need to only export to the OLTP collector, and even then only if configured. always-on is no good. + // when this configuration becomes opt-in, we'll also need to safely check activities around every StartActivity call, because those could + // be null + use tracerProvider = Sdk.CreateTracerProviderBuilder() - .AddSource("fsc") + .AddSource(activitySourceName) .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) .AddConsoleExporter() .Build(); - use activitySource = new ActivitySource("fsc") - use mainActivity = activitySource.StartActivity("main") - - let forceCleanup() = + use mainActivity = activitySource.StartActivity("main") + + let forceCleanup() = mainActivity.Dispose() activitySource.Dispose() tracerProvider.Dispose() From 524cd178fbce8a1c62b4240796bfc30365c90bb8 Mon Sep 17 00:00:00 2001 From: Chet Husk Date: Sun, 17 Jul 2022 14:06:46 -0500 Subject: [PATCH 03/39] better names --- src/Compiler/Driver/fsc.fs | 28 ++++++++++++++-------------- src/fsc/fsc.targets | 3 ++- src/fsc/fscmain.fs | 3 ++- 3 files changed, 18 insertions(+), 16 deletions(-) diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs index 1f6e122b653..413df392f07 100644 --- a/src/Compiler/Driver/fsc.fs +++ b/src/Compiler/Driver/fsc.fs @@ -477,6 +477,8 @@ let main1 diagnosticsLoggerProvider: DiagnosticsLoggerProvider, disposables: DisposablesTracker ) = + + use mainActivity = new Activity("main") // See Bug 735819 let lcidFromCodePage = @@ -532,7 +534,7 @@ let main1 // Process command line, flags and collect filenames let sourceFiles = - use parseActivity = activitySource.StartActivity("fcs:main1:determine_sources") + use parseActivity = activitySource.StartActivity("determine_source_files") // The ParseCompilerOptions function calls imperative function to process "real" args // Rather than start processing, just collect names, then process them. @@ -566,7 +568,7 @@ let main1 // If there's a problem building TcConfig, abort let tcConfig = - use createConfigActivity = activitySource.StartActivity("fcs:main1:create_tc_config") + use createConfigActivity = activitySource.StartActivity("create_tc_config") try TcConfig.Create(tcConfigB, validate = false) @@ -592,12 +594,12 @@ let main1 let foundationalTcConfigP = TcConfigProvider.Constant tcConfig let sysRes, otherRes, knownUnresolved = - use splitResolutionsActivity = activitySource.StartActivity("fcs:main1:split_resolutions") + use splitResolutionsActivity = activitySource.StartActivity("split_resolutions") TcAssemblyResolutions.SplitNonFoundationalResolutions(tcConfig) // Import basic assemblies let tcGlobals, frameworkTcImports = - use frameworkImportsActivity = activitySource.StartActivity("fcs:main:import_framework_references") + use frameworkImportsActivity = activitySource.StartActivity("import_framework_references") TcImports.BuildFrameworkTcImports(foundationalTcConfigP, sysRes, otherRes) |> NodeCode.RunImmediateWithoutCancellation @@ -650,7 +652,7 @@ let main1 ReportTime tcConfig "Import non-system references" let tcImports = - use nonFrameworkImportsActivity = activitySource.StartActivity("fcs:main1:import_non_framework_references") + use nonFrameworkImportsActivity = activitySource.StartActivity("import_non_framework_references") TcImports.BuildNonFrameworkTcImports(tcConfigP, frameworkTcImports, otherRes, knownUnresolved, dependencyProvider) |> NodeCode.RunImmediateWithoutCancellation @@ -669,7 +671,7 @@ let main1 use unwindParsePhase = PushThreadBuildPhaseUntilUnwind BuildPhase.TypeCheck let tcEnv0, openDecls0 = - use initialTcEnvActivity = activitySource.StartActivity("fcs:main1:get_initial_tc_env") + use initialTcEnvActivity = activitySource.StartActivity("get_initial_tc_env") GetInitialTcEnv(assemblyName, rangeStartup, tcConfig, tcImports, tcGlobals) // Type check the inputs @@ -730,7 +732,7 @@ let main1OfAst inputs: ParsedInput list ) = - use main1AstActivity = activitySource.StartActivity("fcs:main1_ast") + use main1AstActivity = activitySource.StartActivity("main1_of_ast") let tryGetMetadataSnapshot = (fun _ -> None) @@ -916,7 +918,7 @@ let main2 exiter: Exiter, ilSourceDocs)) = - use main2Activity = activitySource.StartActivity("fcs:main2") + use main2Activity = activitySource.StartActivity("main2") if tcConfig.typeCheckOnly then @@ -1026,7 +1028,7 @@ let main3 exiter: Exiter, ilSourceDocs)) = - use main3Activity = activitySource.StartActivity("fcs:main3") + use main3Activity = activitySource.StartActivity("main3") // Encode the signature data ReportTime tcConfig "Encode Interface Data" let exportRemapping = MakeExportRemapping generatedCcu generatedCcu.Contents @@ -1122,7 +1124,7 @@ let main4 exiter: Exiter, ilSourceDocs)) = - use main4Activity = activitySource.StartActivity("fcs:main4") + use main4Activity = activitySource.StartActivity("main4") match tcImportsCapture with | None -> () @@ -1227,7 +1229,7 @@ let main5 exiter: Exiter, ilSourceDocs)) = - use main5Activity = activitySource.StartActivity("fcs:main5") + use main5Activity = activitySource.StartActivity("main5") use unwindBuildPhase = PushThreadBuildPhaseUntilUnwind BuildPhase.Output @@ -1260,7 +1262,7 @@ let main6 exiter: Exiter, ilSourceDocs)) = - use main6Activity = activitySource.StartActivity("fcs:main6") + use main6Activity = activitySource.StartActivity("main6") ReportTime tcConfig "Write .NET Binary" @@ -1385,7 +1387,6 @@ let CompileFromCommandLineArguments tcImportsCapture, dynamicAssemblyCreator ) = - use mainActivity = activitySource.StartActivity("fcs:main") use disposables = new DisposablesTracker() let savedOut = Console.Out @@ -1398,7 +1399,6 @@ let CompileFromCommandLineArguments with _ -> () } - use mainActivity = new Activity("fcs:main") main1 ( ctok, argv, diff --git a/src/fsc/fsc.targets b/src/fsc/fsc.targets index 7aaa9c76239..4c2ee11d932 100644 --- a/src/fsc/fsc.targets +++ b/src/fsc/fsc.targets @@ -44,7 +44,8 @@ - + + diff --git a/src/fsc/fscmain.fs b/src/fsc/fscmain.fs index 3df75486f88..21b3ddb6d12 100644 --- a/src/fsc/fscmain.fs +++ b/src/fsc/fscmain.fs @@ -36,7 +36,8 @@ let main(argv) = Sdk.CreateTracerProviderBuilder() .AddSource(activitySourceName) .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) - .AddConsoleExporter() + .AddOtlpExporter() + .AddZipkinExporter() .Build(); use mainActivity = activitySource.StartActivity("main") From c62e89c210df7027a1ab0aec51a160944988e6e7 Mon Sep 17 00:00:00 2001 From: janusz Date: Sun, 17 Jul 2022 20:54:26 +0100 Subject: [PATCH 04/39] Allow parallel project analysis with an environment variable --- src/Compiler/Driver/CompilerImports.fs | 9 ++++++++- src/Compiler/Facilities/BuildGraph.fs | 8 +++++++- src/Compiler/Facilities/BuildGraph.fsi | 2 ++ 3 files changed, 17 insertions(+), 2 deletions(-) diff --git a/src/Compiler/Driver/CompilerImports.fs b/src/Compiler/Driver/CompilerImports.fs index 1e63aa45dd5..310d011d29b 100644 --- a/src/Compiler/Driver/CompilerImports.fs +++ b/src/Compiler/Driver/CompilerImports.fs @@ -2152,6 +2152,13 @@ and [] TcImports node { CheckDisposed() + // TODO inject top-down from FSharpChecker + let runInParallel = + Environment.GetEnvironmentVariable("FCS_PARALLEL_PROJECTS_ANALYSIS") + |> bool.TryParse + |> function | true, runInParallel -> runInParallel | false, _ -> false + let runMethod = if runInParallel then NodeCode.Parallel else NodeCode.Sequential + let! results = nms |> List.map (fun nm -> @@ -2162,7 +2169,7 @@ and [] TcImports errorR (Error(FSComp.SR.buildProblemReadingAssembly (nm.resolvedPath, e.Message), nm.originalReference.Range)) return None }) - |> NodeCode.Sequential + |> runMethod let dllinfos, phase2s = results |> Array.choose id |> List.ofArray |> List.unzip fixupOrphanCcus () diff --git a/src/Compiler/Facilities/BuildGraph.fs b/src/Compiler/Facilities/BuildGraph.fs index 8227b96043f..6170d726d75 100644 --- a/src/Compiler/Facilities/BuildGraph.fs +++ b/src/Compiler/Facilities/BuildGraph.fs @@ -182,6 +182,12 @@ type NodeCode private () = return results.ToArray() } + + static member Parallel (computations: NodeCode<'T> seq) = + computations + |> Seq.map (fun (Node x) -> x) + |> Async.Parallel + |> Node type private AgentMessage<'T> = GetValue of AsyncReplyChannel> * callerCancellationToken: CancellationToken @@ -331,7 +337,7 @@ type GraphNode<'T>(retryCompute: bool, computation: NodeCode<'T>) = // occur, making sure we are under the protection of the 'try'. // For example, NodeCode's 'try/finally' (TryFinally) uses async.TryFinally which does // implicit cancellation checks even before the try is entered, as do the - // de-sugaring of 'do!' and other CodeCode constructs. + // de-sugaring of 'do!' and other NodeCode constructs. let mutable taken = false try diff --git a/src/Compiler/Facilities/BuildGraph.fsi b/src/Compiler/Facilities/BuildGraph.fsi index 798653f5f4b..76001d940da 100644 --- a/src/Compiler/Facilities/BuildGraph.fsi +++ b/src/Compiler/Facilities/BuildGraph.fsi @@ -65,6 +65,8 @@ type NodeCode = static member Sequential: computations: NodeCode<'T> seq -> NodeCode<'T[]> + static member Parallel: computations: (NodeCode<'T> seq) -> NodeCode<'T[]> + /// Execute the cancellable computation synchronously using the ambient cancellation token of /// the NodeCode. static member FromCancellable: computation: Cancellable<'T> -> NodeCode<'T> From 4431af5960bcaece76660ec3995faaf7d8d178ac Mon Sep 17 00:00:00 2001 From: janusz Date: Sun, 17 Jul 2022 21:56:14 +0100 Subject: [PATCH 05/39] reformat CompilerImports.fs --- src/Compiler/Driver/CompilerImports.fs | 11 +++++++++-- 1 file changed, 9 insertions(+), 2 deletions(-) diff --git a/src/Compiler/Driver/CompilerImports.fs b/src/Compiler/Driver/CompilerImports.fs index 310d011d29b..991a9e23f6b 100644 --- a/src/Compiler/Driver/CompilerImports.fs +++ b/src/Compiler/Driver/CompilerImports.fs @@ -2156,8 +2156,15 @@ and [] TcImports let runInParallel = Environment.GetEnvironmentVariable("FCS_PARALLEL_PROJECTS_ANALYSIS") |> bool.TryParse - |> function | true, runInParallel -> runInParallel | false, _ -> false - let runMethod = if runInParallel then NodeCode.Parallel else NodeCode.Sequential + |> function + | true, runInParallel -> runInParallel + | false, _ -> false + + let runMethod = + if runInParallel then + NodeCode.Parallel + else + NodeCode.Sequential let! results = nms From 461876414574d7f86daf37c87948e3f789c68480 Mon Sep 17 00:00:00 2001 From: Chet Husk Date: Sun, 24 Jul 2022 10:21:44 -0500 Subject: [PATCH 06/39] more granularity --- src/Compiler/Driver/ParseAndCheckInputs.fs | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index 2d0e5200625..fee025a1161 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -1292,7 +1292,9 @@ let CheckOneInput } /// Typecheck a single file (or interactive entry into F# Interactive) -let TypeCheckOneInputEntry (ctok, checkForErrors, tcConfig: TcConfig, tcImports, tcGlobals, prefixPathOpt) tcState inp = +let TypeCheckOneInputEntry (ctok, checkForErrors, tcConfig: TcConfig, tcImports, tcGlobals, prefixPathOpt) tcState (inp: ParsedInput) = + use tcOneInputActivity = activitySource.StartActivity("CheckOneInput") + tcOneInputActivity.AddTag("inputName", inp.FileName) |> ignore<_> // 'use' ensures that the warning handler is restored at the end use unwindEL = PushDiagnosticsLoggerPhaseUntilUnwind(fun oldLogger -> @@ -1341,6 +1343,7 @@ let CheckClosedInputSetFinish (declaredImpls: CheckedImplFile list, tcState) = tcState, declaredImpls, ccuContents let CheckClosedInputSet (ctok, checkForErrors, tcConfig, tcImports, tcGlobals, prefixPathOpt, tcState, inputs) = + use tcActivity = activitySource.StartActivity("CheckClosedInputSet") // tcEnvAtEndOfLastFile is the environment required by fsi.exe when incrementally adding definitions let results, tcState = (tcState, inputs) From 01e165bcd6cb1d52f36ec93b96e4d9be04fe79e5 Mon Sep 17 00:00:00 2001 From: janusz Date: Tue, 30 Aug 2022 23:10:39 +0100 Subject: [PATCH 07/39] WIP --- src/Compiler/FSharp.Compiler.Service.fsproj | 2 ++ src/Compiler/Service/service.fs | 25 +++++++++++++++++++++ src/fsc/fscProject/fsc.fsproj | 4 ---- 3 files changed, 27 insertions(+), 4 deletions(-) diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index ec1c8842034..af2321e44fb 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -502,6 +502,8 @@ + + diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index e58b5be8261..e4bb3c8d7d9 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -35,6 +35,8 @@ open FSharp.Compiler.Text open FSharp.Compiler.Text.Range open FSharp.Compiler.TcGlobals open FSharp.Compiler.BuildGraph +open OpenTelemetry +open OpenTelemetry.Resources [] module EnvMisc = @@ -1199,6 +1201,27 @@ type BackgroundCompiler static member ActualCheckFileCount = actualCheckFileCount +module Foo = + open FSharp.Compiler.Diagnostics.Activity + open OpenTelemetry.Trace + + let init () = + use tracerProvider = + Sdk.CreateTracerProviderBuilder() + .AddSource(activitySourceName) + .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) + .AddOtlpExporter() + .AddZipkinExporter() + .Build(); + use mainActivity = activitySource.StartActivity("main") + + let forceCleanup() = + mainActivity.Dispose() + activitySource.Dispose() + tracerProvider.Dispose() + + forceCleanup + [] // There is typically only one instance of this type in an IDE process. type FSharpChecker @@ -1226,6 +1249,8 @@ type FSharpChecker enableBackgroundItemKeyStoreAndSemanticClassification, enablePartialTypeChecking ) + + do Foo.init() |> ignore static let globalInstance = lazy FSharpChecker.Create() diff --git a/src/fsc/fscProject/fsc.fsproj b/src/fsc/fscProject/fsc.fsproj index cb9456bb3a9..fdfd38db98b 100644 --- a/src/fsc/fscProject/fsc.fsproj +++ b/src/fsc/fscProject/fsc.fsproj @@ -2,10 +2,6 @@ - - $(ProtoTargetFramework) - net6.0;net472; - net6.0 net472;net7.0 net7.0 From 30fd5785782ba1ab407e181608ffdb5627009a0f Mon Sep 17 00:00:00 2001 From: janusz Date: Wed, 31 Aug 2022 00:01:28 +0100 Subject: [PATCH 08/39] Don't dispose of the telemetry objects immediately --- src/Compiler/Service/service.fs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index e4bb3c8d7d9..3386dee5271 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -1206,14 +1206,14 @@ module Foo = open OpenTelemetry.Trace let init () = - use tracerProvider = + let tracerProvider = Sdk.CreateTracerProviderBuilder() .AddSource(activitySourceName) - .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) + .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="FSharpChecker", serviceVersion = "42.42.42.42")) .AddOtlpExporter() .AddZipkinExporter() .Build(); - use mainActivity = activitySource.StartActivity("main") + let mainActivity = activitySource.StartActivity("main") let forceCleanup() = mainActivity.Dispose() From 16fcfd40061c727f61f1a8d33cdd9638d3ee7c87 Mon Sep 17 00:00:00 2001 From: janusz Date: Wed, 31 Aug 2022 01:54:59 +0100 Subject: [PATCH 09/39] Hacks to make telemetry work in incremental builder --- src/Compiler/Driver/ParseAndCheckInputs.fs | 5 +-- src/Compiler/FSharp.Compiler.Service.fsproj | 1 - src/Compiler/Service/service.fs | 18 +++++------ .../CompilerServiceBenchmarks/Program.fs | 31 +++++++++++++++++-- 4 files changed, 40 insertions(+), 15 deletions(-) diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index 6f2b44c8b2b..183c9d47767 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -1140,6 +1140,9 @@ let CheckOneInput cancellable { try + use tcOneInputActivity = activitySource.StartActivity("CheckOneInput") + tcOneInputActivity.AddTag("inputName", inp.FileName) |> ignore<_> + CheckSimulateException tcConfig let m = inp.Range @@ -1293,8 +1296,6 @@ let CheckOneInput /// Typecheck a single file (or interactive entry into F# Interactive) let TypeCheckOneInputEntry (ctok, checkForErrors, tcConfig: TcConfig, tcImports, tcGlobals, prefixPathOpt) tcState (inp: ParsedInput) = - use tcOneInputActivity = activitySource.StartActivity("CheckOneInput") - tcOneInputActivity.AddTag("inputName", inp.FileName) |> ignore<_> // 'use' ensures that the warning handler is restored at the end use unwindEL = PushDiagnosticsLoggerPhaseUntilUnwind(fun oldLogger -> diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index af2321e44fb..a2f7bcd3204 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -3,7 +3,6 @@ - netstandard2.0;net472; netstandard2.0 Library $(NoWarn);44 diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index 3386dee5271..d1da7208696 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -1209,18 +1209,15 @@ module Foo = let tracerProvider = Sdk.CreateTracerProviderBuilder() .AddSource(activitySourceName) - .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="FSharpChecker", serviceVersion = "42.42.42.42")) + .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) .AddOtlpExporter() .AddZipkinExporter() - .Build(); - let mainActivity = activitySource.StartActivity("main") - + .Build() + let forceCleanup() = - mainActivity.Dispose() activitySource.Dispose() tracerProvider.Dispose() - - forceCleanup + forceCleanup() [] // There is typically only one instance of this type in an IDE process. @@ -1249,9 +1246,10 @@ type FSharpChecker enableBackgroundItemKeyStoreAndSemanticClassification, enablePartialTypeChecking ) - - do Foo.init() |> ignore - + + // let _ = Foo.init() + // let _ = FSharp.Compiler.Diagnostics.Activity.activitySource.StartActivity("main") + static let globalInstance = lazy FSharpChecker.Create() // STATIC ROOT: FSharpLanguageServiceTestable.FSharpChecker.braceMatchCache. Most recently used cache for brace matching. Accessed on the diff --git a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs index fa0474dbf5e..24d5d054eea 100644 --- a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs +++ b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs @@ -1,7 +1,34 @@ -open BenchmarkDotNet.Running +open BenchmarkDotNet.Configs +open BenchmarkDotNet.Running open FSharp.Compiler.Benchmarks +open OpenTelemetry +open OpenTelemetry.Resources +open OpenTelemetry.Trace + +open FSharp.Compiler.Diagnostics.Activity [] let main args = - BenchmarkSwitcher.FromAssembly(typeof.Assembly).Run(args) |> ignore + let b = DecentlySizedStandAloneFileBenchmark() + + // eventually this would need to only export to the OLTP collector, and even then only if configured. always-on is no good. + // when this configuration becomes opt-in, we'll also need to safely check activities around every StartActivity call, because those could + // be null + use tracerProvider = + Sdk.CreateTracerProviderBuilder() + .AddSource(activitySourceName) + .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="program", serviceVersion = "42.42.42.44")) + .AddOtlpExporter() + .AddZipkinExporter() + .Build(); + use mainActivity = activitySource.StartActivity("main") + + let forceCleanup() = + mainActivity.Dispose() + activitySource.Dispose() + tracerProvider.Dispose() + + b.Setup() + b.Run() + forceCleanup() 0 From 0702fc1e9c54621d7443b94e92dcda6fc2eca763 Mon Sep 17 00:00:00 2001 From: janusz Date: Wed, 31 Aug 2022 02:34:47 +0100 Subject: [PATCH 10/39] More hacks to get nested project information in the trace --- src/Compiler/Service/service.fs | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index d1da7208696..e04ab9da837 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -343,7 +343,11 @@ type BackgroundCompiler member x.EvaluateRawContents() = node { Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "GetAssemblyData", nm) - return! self.GetAssemblyData(opts, userOpName + ".CheckReferencedProject(" + nm + ")") + let act = Activity.activitySource.StartActivity("CheckReferencedProject") + act.AddTag("Project", nm) |> ignore + let! x = self.GetAssemblyData(opts, userOpName + ".CheckReferencedProject(" + nm + ")") + act.Dispose() + return x } member x.TryGetLogicalTimeStamp(cache) = From f72b57044bce2df9d837997620aef5f667987bdb Mon Sep 17 00:00:00 2001 From: janusz Date: Fri, 2 Sep 2022 01:49:37 +0100 Subject: [PATCH 11/39] more hacks --- src/Compiler/Service/IncrementalBuild.fs | 9 +- src/Compiler/Service/service.fs | 114 ++++++++++++++++------- 2 files changed, 86 insertions(+), 37 deletions(-) diff --git a/src/Compiler/Service/IncrementalBuild.fs b/src/Compiler/Service/IncrementalBuild.fs index 45e50d441bf..9019f278259 100644 --- a/src/Compiler/Service/IncrementalBuild.fs +++ b/src/Compiler/Service/IncrementalBuild.fs @@ -1038,6 +1038,8 @@ module IncrementalBuilderStateHelpers = let rec createFinalizeBoundModelGraphNode (initialState: IncrementalBuilderInitialState) (boundModels: ImmutableArray>.Builder) = GraphNode(node { + let act = Activity.activitySource.StartActivity("GetCheckResultsAndImplementationsForProject") + act.AddTag("projectName", initialState.outfile) |> ignore // Compute last bound model then get all the evaluated models. let! _ = boundModels[boundModels.Count - 1].GetOrComputeValue() let boundModels = @@ -1053,6 +1055,7 @@ module IncrementalBuilderStateHelpers = initialState.outfile boundModels let result = (result, DateTime.UtcNow) + act.Dispose() return result }) @@ -1351,6 +1354,8 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc member builder.GetCheckResultsAndImplementationsForProject() = node { + // let act = Activity.activitySource.StartActivity("GetCheckResultsAndImplementationsForProject") + // act.AddTag("projectName", initialState.outfile) |> ignore let cache = TimeStampCache(defaultTimeStamp) do! checkFileTimeStamps cache let! result = currentState.finalizedBoundModel.GetOrComputeValue() @@ -1358,7 +1363,9 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc | (ilAssemRef, tcAssemblyDataOpt, tcAssemblyExprOpt, boundModel), timestamp -> let cache = TimeStampCache defaultTimeStamp let projectTimeStamp = builder.GetLogicalTimeStampForProject(cache) - return PartialCheckResults (boundModel, timestamp, projectTimeStamp), ilAssemRef, tcAssemblyDataOpt, tcAssemblyExprOpt + let res = PartialCheckResults (boundModel, timestamp, projectTimeStamp), ilAssemRef, tcAssemblyDataOpt, tcAssemblyExprOpt + act.Dispose() + return res } member builder.GetFullCheckResultsAndImplementationsForProject() = diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index e04ab9da837..604ae6065e5 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -343,10 +343,10 @@ type BackgroundCompiler member x.EvaluateRawContents() = node { Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "GetAssemblyData", nm) - let act = Activity.activitySource.StartActivity("CheckReferencedProject") - act.AddTag("Project", nm) |> ignore + //let act = Activity.activitySource.StartActivity("CheckReferencedProject") + //act.AddTag("Project", nm) |> ignore let! x = self.GetAssemblyData(opts, userOpName + ".CheckReferencedProject(" + nm + ")") - act.Dispose() + //act.Dispose() return x } @@ -587,6 +587,9 @@ type BackgroundCompiler member _.ParseFile(fileName: string, sourceText: ISourceText, options: FSharpParsingOptions, cache: bool, userOpName: string) = async { + use act = Activity.activitySource.StartActivity("CompileToDynamicAssembly1") + act.AddTag("filename", fileName) |> ignore + act.AddTag("UserOpName", userOpName) |> ignore if cache then let hash = sourceText.GetHashCode() |> int64 @@ -1407,6 +1410,8 @@ type FSharpChecker let _userOpName = defaultArg userOpName "Unknown" async { + use act = Activity.activitySource.StartActivity("CompileToDynamicAssembly1") + act.AddTag("UserOpName", _userOpName) |> ignore let ctok = CompilationThreadToken() CompileHelpers.setOutputStreams execute @@ -1449,6 +1454,9 @@ type FSharpChecker let _userOpName = defaultArg userOpName "Unknown" async { + use act = Activity.activitySource.StartActivity("CompileToDynamicAssembly2") + act.AddTag("Assembly", assemblyName) |> ignore + act.AddTag("UserOpName", _userOpName) |> ignore let ctok = CompilationThreadToken() CompileHelpers.setOutputStreams execute @@ -1541,17 +1549,23 @@ type FSharpChecker options: FSharpProjectOptions, ?userOpName: string ) = - let userOpName = defaultArg userOpName "Unknown" - - backgroundCompiler.CheckFileInProjectAllowingStaleCachedResults( - parseResults, - fileName, - fileVersion, - SourceText.ofString source, - options, - userOpName - ) - |> Async.AwaitNodeCode + async { + use act = Activity.activitySource.StartActivity("CheckFileInProjectAllowingStaleCachedResults") + act.AddTag("Project", options.ProjectFileName) |> ignore + act.AddTag("filename", fileName) |> ignore + act.AddTag("UserOpName", userOpName) |> ignore + let userOpName = defaultArg userOpName "Unknown" + return! + backgroundCompiler.CheckFileInProjectAllowingStaleCachedResults( + parseResults, + fileName, + fileVersion, + SourceText.ofString source, + options, + userOpName + ) + |> Async.AwaitNodeCode + } /// Typecheck a source code file, returning a handle to the results of the /// parse including the reconstructed types in the file. @@ -1564,10 +1578,16 @@ type FSharpChecker options: FSharpProjectOptions, ?userOpName: string ) = - let userOpName = defaultArg userOpName "Unknown" - - backgroundCompiler.CheckFileInProject(parseResults, fileName, fileVersion, sourceText, options, userOpName) - |> Async.AwaitNodeCode + async { + use act = Activity.activitySource.StartActivity("CheckFileInProject") + act.AddTag("Project", options.ProjectFileName) |> ignore + act.AddTag("filename", fileName) |> ignore + act.AddTag("UserOpName", userOpName) |> ignore + let userOpName = defaultArg userOpName "Unknown" + return! + backgroundCompiler.CheckFileInProject(parseResults, fileName, fileVersion, sourceText, options, userOpName) + |> Async.AwaitNodeCode + } /// Typecheck a source code file, returning a handle to the results of the /// parse including the reconstructed types in the file. @@ -1578,17 +1598,30 @@ type FSharpChecker sourceText: ISourceText, options: FSharpProjectOptions, ?userOpName: string - ) = - let userOpName = defaultArg userOpName "Unknown" - - backgroundCompiler.ParseAndCheckFileInProject(fileName, fileVersion, sourceText, options, userOpName) - |> Async.AwaitNodeCode + ) = + async { + let act = Activity.activitySource.StartActivity("ParseAndCheckFileInProject") + act.AddTag("Project", options.ProjectFileName) |> ignore + act.AddTag("filename", fileName) |> ignore + act.AddTag("UserOpName", userOpName) |> ignore + let userOpName = defaultArg userOpName "Unknown" + let! x = + backgroundCompiler.ParseAndCheckFileInProject(fileName, fileVersion, sourceText, options, userOpName) + |> Async.AwaitNodeCode + act.Dispose() + return x + } member _.ParseAndCheckProject(options, ?userOpName: string) = - let userOpName = defaultArg userOpName "Unknown" - - backgroundCompiler.ParseAndCheckProject(options, userOpName) - |> Async.AwaitNodeCode + async { + let userOpName = defaultArg userOpName "Unknown" + use act = Activity.activitySource.StartActivity("ParseAndCheckProject") + act.AddTag("Project", options.ProjectFileName) |> ignore + act.AddTag("UserOpName", userOpName) |> ignore + return! + backgroundCompiler.ParseAndCheckProject(options, userOpName) + |> Async.AwaitNodeCode + } member _.FindBackgroundReferencesInFile ( @@ -1598,17 +1631,26 @@ type FSharpChecker ?canInvalidateProject: bool, ?userOpName: string ) = - let canInvalidateProject = defaultArg canInvalidateProject true - let userOpName = defaultArg userOpName "Unknown" - - backgroundCompiler.FindReferencesInFile(fileName, options, symbol, canInvalidateProject, userOpName) - |> Async.AwaitNodeCode + async { + let canInvalidateProject = defaultArg canInvalidateProject true + let userOpName = defaultArg userOpName "Unknown" + use act = Activity.activitySource.StartActivity("FindBackgroundReferencesInFile") + act.AddTag("Project", options.ProjectFileName) |> ignore + act.AddTag("UserOpName", userOpName) |> ignore + return! + backgroundCompiler.FindReferencesInFile(fileName, options, symbol, canInvalidateProject, userOpName) + |> Async.AwaitNodeCode + } member _.GetBackgroundSemanticClassificationForFile(fileName: string, options: FSharpProjectOptions, ?userOpName) = - let userOpName = defaultArg userOpName "Unknown" - - backgroundCompiler.GetSemanticClassificationForFile(fileName, options, userOpName) - |> Async.AwaitNodeCode + async { + let userOpName = defaultArg userOpName "Unknown" + use act = Activity.activitySource.StartActivity("FindBackgroundReferencesInFile") + act.AddTag("Project", options.ProjectFileName) |> ignore + return! + backgroundCompiler.GetSemanticClassificationForFile(fileName, options, userOpName) + |> Async.AwaitNodeCode + } /// For a given script file, get the ProjectOptions implied by the #load closure member _.GetProjectOptionsFromScript From f8170b8f3417027ebe7a8904e3540fee0bd46293 Mon Sep 17 00:00:00 2001 From: janusz Date: Sat, 3 Sep 2022 00:52:53 +0100 Subject: [PATCH 12/39] Improve activity logging for the background checker --- src/Compiler/Checking/CheckDeclarations.fs | 16 ++++++++++++---- src/Compiler/Driver/fsc.fs | 1 + src/Compiler/Facilities/BuildGraph.fs | 11 +++++++++++ src/Compiler/Facilities/BuildGraph.fsi | 3 +++ src/Compiler/Service/FSharpCheckerResults.fs | 2 ++ src/Compiler/Service/IncrementalBuild.fs | 15 +++++++++------ src/Compiler/Service/service.fs | 20 ++++++++++++-------- 7 files changed, 50 insertions(+), 18 deletions(-) diff --git a/src/Compiler/Checking/CheckDeclarations.fs b/src/Compiler/Checking/CheckDeclarations.fs index 0d9b0df134b..bbe0171e68e 100644 --- a/src/Compiler/Checking/CheckDeclarations.fs +++ b/src/Compiler/Checking/CheckDeclarations.fs @@ -5,6 +5,7 @@ module internal FSharp.Compiler.CheckDeclarations open System open System.Collections.Generic +open FSharp.Compiler.Diagnostics open Internal.Utilities.Collections open Internal.Utilities.Library open Internal.Utilities.Library.Extras @@ -5167,11 +5168,14 @@ let CheckOneImplFile env, rootSigOpt: ModuleOrNamespaceType option, synImplFile) = - - let (ParsedImplFileInput (_, isScript, qualNameOfFile, scopedPragmas, _, implFileFrags, isLastCompiland, _)) = synImplFile + + let (ParsedImplFileInput (fileName, isScript, qualNameOfFile, scopedPragmas, _, implFileFrags, isLastCompiland, _)) = synImplFile let infoReader = InfoReader(g, amap) cancellable { + use act = Activity.activitySource.StartActivity("CheckOneSigFile") + act.AddTag("fileName", fileName) |> ignore + act.AddTag("qualifiedNameOfFile", qualNameOfFile.Text) |> ignore let cenv = cenv.Create (g, isScript, niceNameGen, amap, thisCcu, false, Option.isSome rootSigOpt, conditionalDefines, tcSink, (LightweightTcValForUsingInBuildMethodCall g), isInternalTestSpanStackReferring, @@ -5297,8 +5301,12 @@ let CheckOneImplFile /// Check an entire signature file -let CheckOneSigFile (g, niceNameGen, amap, thisCcu, checkForErrors, conditionalDefines, tcSink, isInternalTestSpanStackReferring) tcEnv (ParsedSigFileInput (qualifiedNameOfFile = qualNameOfFile; modules = sigFileFrags)) = - cancellable { +let CheckOneSigFile (g, niceNameGen, amap, thisCcu, checkForErrors, conditionalDefines, tcSink, isInternalTestSpanStackReferring) tcEnv (ParsedSigFileInput (fileName = fileName; qualifiedNameOfFile = qualNameOfFile; modules = sigFileFrags)) = + cancellable { + use act = Activity.activitySource.StartActivity("CheckOneSigFile") + act.AddTag("fileName", fileName) |> ignore + act.AddTag("qualifiedNameOfFile", qualNameOfFile.Text) |> ignore + let cenv = cenv.Create (g, false, niceNameGen, amap, thisCcu, true, false, conditionalDefines, tcSink, diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs index 928eecf5e35..54757f4f374 100644 --- a/src/Compiler/Driver/fsc.fs +++ b/src/Compiler/Driver/fsc.fs @@ -168,6 +168,7 @@ let TypeCheck exiter: Exiter ) = use typecheckActivity = activitySource.StartActivity("typecheck_inputs") + typecheckActivity.AddTag("assemblyName", assemblyName) |> ignore try if isNil inputs then diff --git a/src/Compiler/Facilities/BuildGraph.fs b/src/Compiler/Facilities/BuildGraph.fs index 6170d726d75..6c5b828e332 100644 --- a/src/Compiler/Facilities/BuildGraph.fs +++ b/src/Compiler/Facilities/BuildGraph.fs @@ -92,6 +92,17 @@ type NodeCodeBuilder() = [] member _.Combine(Node (p1): NodeCode, Node (p2): NodeCode<'T>) : NodeCode<'T> = Node(async.Combine(p1, p2)) + [] + member _.Using(value: Activity, binder: Activity -> NodeCode<'U>) = + Node( + async { + try + return! binder value |> Async.AwaitNodeCode + finally + (value :> IDisposable).Dispose() + } + ) + [] member _.Using(value: CompilationGlobalsScope, binder: CompilationGlobalsScope -> NodeCode<'U>) = Node( diff --git a/src/Compiler/Facilities/BuildGraph.fsi b/src/Compiler/Facilities/BuildGraph.fsi index 76001d940da..f292bbc7040 100644 --- a/src/Compiler/Facilities/BuildGraph.fsi +++ b/src/Compiler/Facilities/BuildGraph.fsi @@ -3,6 +3,7 @@ module internal FSharp.Compiler.BuildGraph open System +open System.Diagnostics open System.Threading open System.Threading.Tasks open FSharp.Compiler.DiagnosticsLogger @@ -46,6 +47,8 @@ type NodeCodeBuilder = /// A limited form 'use' for establishing the compilation globals. (Note /// that a proper generic 'use' could be implemented but has not currently been necessary) member Using: CompilationGlobalsScope * (CompilationGlobalsScope -> NodeCode<'T>) -> NodeCode<'T> + + member Using: Activity * (Activity -> NodeCode<'T>) -> NodeCode<'T> /// Specifies code that can be run as part of the build graph. val node: NodeCodeBuilder diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs index b01819fc2b7..810c9cdc179 100644 --- a/src/Compiler/Service/FSharpCheckerResults.fs +++ b/src/Compiler/Service/FSharpCheckerResults.fs @@ -2347,6 +2347,8 @@ module internal ParseAndCheckFile = let parseFile (sourceText: ISourceText, fileName, options: FSharpParsingOptions, userOpName: string, suggestNamesForErrors: bool) = Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "parseFile", fileName) + use act = Activity.activitySource.StartActivity("parseFile") + act.AddTag("fileName", fileName) |> ignore let errHandler = ErrorHandler(true, fileName, options.DiagnosticOptions, sourceText, suggestNamesForErrors) diff --git a/src/Compiler/Service/IncrementalBuild.fs b/src/Compiler/Service/IncrementalBuild.fs index 9019f278259..0a661629702 100644 --- a/src/Compiler/Service/IncrementalBuild.fs +++ b/src/Compiler/Service/IncrementalBuild.fs @@ -116,6 +116,9 @@ module IncrementalBuildSyntaxTree = let mutable weakCache: WeakReference<_> option = None let parse(sigNameOpt: QualifiedNameOfFile option) = + use act = Activity.activitySource.StartActivity("SyntaxTree.parse") + act.AddTag("fileName", source.FilePath) |> ignore + act.AddTag("buildPhase", BuildPhase.Parse) |> ignore let diagnosticsLogger = CompilationDiagnosticLogger("Parse", tcConfig.diagnosticsOptions) // Return the disposable object that cleans up use _holder = new CompilationGlobalsScope(diagnosticsLogger, BuildPhase.Parse) @@ -123,6 +126,7 @@ module IncrementalBuildSyntaxTree = try IncrementalBuilderEventTesting.MRU.Add(IncrementalBuilderEventTesting.IBEParsed fileName) let canSkip = sigNameOpt.IsSome && FSharpImplFileSuffixes |> List.exists (FileSystemUtils.checkSuffix fileName) + act.AddTag("canSkip", canSkip) |> ignore let input = if canSkip then ParsedInput.ImplFile( @@ -465,6 +469,8 @@ type BoundModel private (tcConfig: TcConfig, let! res = defaultTypeCheck () return res | Some syntaxTree -> + use act = Activity.activitySource.StartActivity("TypeCheck") + act.AddTag("fileName", syntaxTree.FileName) |> ignore let sigNameOpt = if partialCheck then this.BackingSignature @@ -502,6 +508,7 @@ type BoundModel private (tcConfig: TcConfig, partialCheck) |> NodeCode.FromCancellable + use _ = Activity.activitySource.StartActivity("TypeCheck_BuildState") Logger.LogBlockMessageStop fileName LogCompilerFunctionId.IncrementalBuild_TypeCheck fileChecked.Trigger fileName @@ -1038,8 +1045,8 @@ module IncrementalBuilderStateHelpers = let rec createFinalizeBoundModelGraphNode (initialState: IncrementalBuilderInitialState) (boundModels: ImmutableArray>.Builder) = GraphNode(node { - let act = Activity.activitySource.StartActivity("GetCheckResultsAndImplementationsForProject") - act.AddTag("projectName", initialState.outfile) |> ignore + use act = Activity.activitySource.StartActivity("GetCheckResultsAndImplementationsForProject") + act.AddTag("projectOutFile", initialState.outfile) |> ignore // Compute last bound model then get all the evaluated models. let! _ = boundModels[boundModels.Count - 1].GetOrComputeValue() let boundModels = @@ -1055,7 +1062,6 @@ module IncrementalBuilderStateHelpers = initialState.outfile boundModels let result = (result, DateTime.UtcNow) - act.Dispose() return result }) @@ -1354,8 +1360,6 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc member builder.GetCheckResultsAndImplementationsForProject() = node { - // let act = Activity.activitySource.StartActivity("GetCheckResultsAndImplementationsForProject") - // act.AddTag("projectName", initialState.outfile) |> ignore let cache = TimeStampCache(defaultTimeStamp) do! checkFileTimeStamps cache let! result = currentState.finalizedBoundModel.GetOrComputeValue() @@ -1364,7 +1368,6 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc let cache = TimeStampCache defaultTimeStamp let projectTimeStamp = builder.GetLogicalTimeStampForProject(cache) let res = PartialCheckResults (boundModel, timestamp, projectTimeStamp), ilAssemRef, tcAssemblyDataOpt, tcAssemblyExprOpt - act.Dispose() return res } diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index 604ae6065e5..c265d06f69c 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -343,10 +343,7 @@ type BackgroundCompiler member x.EvaluateRawContents() = node { Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "GetAssemblyData", nm) - //let act = Activity.activitySource.StartActivity("CheckReferencedProject") - //act.AddTag("Project", nm) |> ignore let! x = self.GetAssemblyData(opts, userOpName + ".CheckReferencedProject(" + nm + ")") - //act.Dispose() return x } @@ -396,6 +393,8 @@ type BackgroundCompiler /// creates an incremental builder used by the command line compiler. let CreateOneIncrementalBuilder (options: FSharpProjectOptions, userOpName) = node { + use act = Activity.activitySource.StartActivity("CreateOneIncrementalBuilder") + act.AddTag("project", options.ProjectFileName) |> ignore Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "CreateOneIncrementalBuilder", options.ProjectFileName) let projectReferences = getProjectReferences options userOpName @@ -776,10 +775,14 @@ type BackgroundCompiler /// Type-check the result obtained by parsing. Force the evaluation of the antecedent type checking context if needed. member bc.CheckFileInProject(parseResults: FSharpParseFileResults, fileName, fileVersion, sourceText: ISourceText, options, userOpName) = node { + use act = Activity.activitySource.StartActivity("Service_CheckFileInProject") + act.AddTag("project", options.ProjectFileName) |> ignore + act.AddTag("fileName", fileName) |> ignore let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) match builderOpt with - | None -> return FSharpCheckFileAnswer.Succeeded(FSharpCheckFileResults.MakeEmpty(fileName, creationDiags, keepAssemblyContents)) + | None -> + return FSharpCheckFileAnswer.Succeeded(FSharpCheckFileResults.MakeEmpty(fileName, creationDiags, keepAssemblyContents)) | Some builder -> // Check the cache. We can only use cached results when there is no work to do to bring the background builder up-to-date let! cachedResults = bc.GetCachedCheckFileResult(builder, fileName, sourceText, options) @@ -795,6 +798,9 @@ type BackgroundCompiler /// Parses and checks the source file and returns untyped AST and check results. member bc.ParseAndCheckFileInProject(fileName: string, fileVersion, sourceText: ISourceText, options: FSharpProjectOptions, userOpName) = node { + use act = Activity.activitySource.StartActivity("Service_ParseAndCheckFileInProject") + act.AddTag("project", options.ProjectFileName) |> ignore + act.AddTag("fileName", fileName) |> ignore let strGuid = "_ProjectId=" + (options.ProjectId |> Option.defaultValue "null") Logger.LogBlockMessageStart (fileName + strGuid) LogCompilerFunctionId.Service_ParseAndCheckFileInProject @@ -1600,16 +1606,14 @@ type FSharpChecker ?userOpName: string ) = async { - let act = Activity.activitySource.StartActivity("ParseAndCheckFileInProject") + use act = Activity.activitySource.StartActivity("ParseAndCheckFileInProject") act.AddTag("Project", options.ProjectFileName) |> ignore act.AddTag("filename", fileName) |> ignore act.AddTag("UserOpName", userOpName) |> ignore let userOpName = defaultArg userOpName "Unknown" - let! x = + return! backgroundCompiler.ParseAndCheckFileInProject(fileName, fileVersion, sourceText, options, userOpName) |> Async.AwaitNodeCode - act.Dispose() - return x } member _.ParseAndCheckProject(options, ?userOpName: string) = From a1f74c9e5a0436f59273c2204b95b9c9ec55a1d3 Mon Sep 17 00:00:00 2001 From: janusz Date: Sat, 3 Sep 2022 14:22:46 +0100 Subject: [PATCH 13/39] * Make the code do nothing if no listeners are hooked up. * Cleanup --- src/Compiler/Checking/CheckDeclarations.fs | 13 +-- src/Compiler/Driver/ParseAndCheckInputs.fs | 6 +- src/Compiler/Driver/fsc.fs | 29 +++-- src/Compiler/Facilities/BuildGraph.fs | 3 +- src/Compiler/Facilities/BuildGraph.fsi | 3 +- src/Compiler/Facilities/Logger.fs | 30 +++++- src/Compiler/Facilities/Logger.fsi | 21 +++- src/Compiler/Service/FSharpCheckerResults.fs | 5 +- src/Compiler/Service/IncrementalBuild.fs | 19 ++-- src/Compiler/Service/service.fs | 102 ++++++++---------- src/fsc/fscmain.fs | 8 +- .../CompilerServiceBenchmarks/Program.fs | 11 +- 12 files changed, 139 insertions(+), 111 deletions(-) diff --git a/src/Compiler/Checking/CheckDeclarations.fs b/src/Compiler/Checking/CheckDeclarations.fs index bbe0171e68e..f2e00c12928 100644 --- a/src/Compiler/Checking/CheckDeclarations.fs +++ b/src/Compiler/Checking/CheckDeclarations.fs @@ -5173,9 +5173,7 @@ let CheckOneImplFile let infoReader = InfoReader(g, amap) cancellable { - use act = Activity.activitySource.StartActivity("CheckOneSigFile") - act.AddTag("fileName", fileName) |> ignore - act.AddTag("qualifiedNameOfFile", qualNameOfFile.Text) |> ignore + use _ = Activity.instance.Start "CheckOneImplFile" [|"fileName", fileName; "qualifiedNameOfFile", qualNameOfFile.Text|] let cenv = cenv.Create (g, isScript, niceNameGen, amap, thisCcu, false, Option.isSome rootSigOpt, conditionalDefines, tcSink, (LightweightTcValForUsingInBuildMethodCall g), isInternalTestSpanStackReferring, @@ -5303,9 +5301,12 @@ let CheckOneImplFile /// Check an entire signature file let CheckOneSigFile (g, niceNameGen, amap, thisCcu, checkForErrors, conditionalDefines, tcSink, isInternalTestSpanStackReferring) tcEnv (ParsedSigFileInput (fileName = fileName; qualifiedNameOfFile = qualNameOfFile; modules = sigFileFrags)) = cancellable { - use act = Activity.activitySource.StartActivity("CheckOneSigFile") - act.AddTag("fileName", fileName) |> ignore - act.AddTag("qualifiedNameOfFile", qualNameOfFile.Text) |> ignore + use _ = + Activity.instance.Start "CheckOneSigFile" + [| + "fileName", fileName + "qualifiedNameOfFile", qualNameOfFile.Text + |] let cenv = cenv.Create diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index 183c9d47767..2a29b909826 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -22,7 +22,6 @@ open FSharp.Compiler.CompilerConfig open FSharp.Compiler.CompilerDiagnostics open FSharp.Compiler.CompilerImports open FSharp.Compiler.Diagnostics -open FSharp.Compiler.Diagnostics.Activity open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.Features open FSharp.Compiler.IO @@ -1140,8 +1139,7 @@ let CheckOneInput cancellable { try - use tcOneInputActivity = activitySource.StartActivity("CheckOneInput") - tcOneInputActivity.AddTag("inputName", inp.FileName) |> ignore<_> + use _ = Activity.instance.Start "CheckOneInput" [|"inputName", inp.FileName|] CheckSimulateException tcConfig @@ -1344,7 +1342,7 @@ let CheckClosedInputSetFinish (declaredImpls: CheckedImplFile list, tcState) = tcState, declaredImpls, ccuContents let CheckClosedInputSet (ctok, checkForErrors, tcConfig, tcImports, tcGlobals, prefixPathOpt, tcState, inputs) = - use tcActivity = activitySource.StartActivity("CheckClosedInputSet") + use tcActivity = Activity.instance.StartNoTags("CheckClosedInputSet") // tcEnvAtEndOfLastFile is the environment required by fsi.exe when incrementally adding definitions let results, tcState = (tcState, inputs) diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs index 54757f4f374..fde26ac3870 100644 --- a/src/Compiler/Driver/fsc.fs +++ b/src/Compiler/Driver/fsc.fs @@ -39,7 +39,6 @@ open FSharp.Compiler.CompilerGlobalState open FSharp.Compiler.CreateILModule open FSharp.Compiler.DependencyManager open FSharp.Compiler.Diagnostics -open FSharp.Compiler.Diagnostics.Activity open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.IlxGen open FSharp.Compiler.InfoReader @@ -167,8 +166,7 @@ let TypeCheck inputs, exiter: Exiter ) = - use typecheckActivity = activitySource.StartActivity("typecheck_inputs") - typecheckActivity.AddTag("assemblyName", assemblyName) |> ignore + use _ = Activity.instance.Start "typecheck_inputs" [|"assemblyName", assemblyName|] try if isNil inputs then @@ -535,7 +533,7 @@ let main1 // Process command line, flags and collect filenames let sourceFiles = - use parseActivity = activitySource.StartActivity("determine_source_files") + use parseActivity = Activity.instance.StartNoTags("determine_source_files") // The ParseCompilerOptions function calls imperative function to process "real" args // Rather than start processing, just collect names, then process them. @@ -569,7 +567,7 @@ let main1 // If there's a problem building TcConfig, abort let tcConfig = - use createConfigActivity = activitySource.StartActivity("create_tc_config") + use createConfigActivity = Activity.instance.StartNoTags("create_tc_config") try TcConfig.Create(tcConfigB, validate = false) @@ -595,12 +593,12 @@ let main1 let foundationalTcConfigP = TcConfigProvider.Constant tcConfig let sysRes, otherRes, knownUnresolved = - use splitResolutionsActivity = activitySource.StartActivity("split_resolutions") + use splitResolutionsActivity = Activity.instance.StartNoTags("split_resolutions") TcAssemblyResolutions.SplitNonFoundationalResolutions(tcConfig) // Import basic assemblies let tcGlobals, frameworkTcImports = - use frameworkImportsActivity = activitySource.StartActivity("import_framework_references") + use frameworkImportsActivity = Activity.instance.StartNoTags("import_framework_references") TcImports.BuildFrameworkTcImports(foundationalTcConfigP, sysRes, otherRes) |> NodeCode.RunImmediateWithoutCancellation @@ -653,7 +651,7 @@ let main1 ReportTime tcConfig "Import non-system references" let tcImports = - use nonFrameworkImportsActivity = activitySource.StartActivity("import_non_framework_references") + use nonFrameworkImportsActivity = Activity.instance.StartNoTags("import_non_framework_references") TcImports.BuildNonFrameworkTcImports(tcConfigP, frameworkTcImports, otherRes, knownUnresolved, dependencyProvider) |> NodeCode.RunImmediateWithoutCancellation @@ -672,7 +670,7 @@ let main1 use unwindParsePhase = PushThreadBuildPhaseUntilUnwind BuildPhase.TypeCheck let tcEnv0, openDecls0 = - use initialTcEnvActivity = activitySource.StartActivity("get_initial_tc_env") + use initialTcEnvActivity = Activity.instance.StartNoTags("get_initial_tc_env") GetInitialTcEnv(assemblyName, rangeStartup, tcConfig, tcImports, tcGlobals) // Type check the inputs @@ -733,7 +731,7 @@ let main1OfAst inputs: ParsedInput list ) = - use main1AstActivity = activitySource.StartActivity("main1_of_ast") + use main1AstActivity = Activity.instance.StartNoTags("main1_of_ast") let tryGetMetadataSnapshot = (fun _ -> None) @@ -919,8 +917,7 @@ let main2 exiter: Exiter, ilSourceDocs)) = - use main2Activity = activitySource.StartActivity("main2") - + use main2Activity = Activity.instance.StartNoTags("main2") if tcConfig.typeCheckOnly then exiter.Exit 0 @@ -1029,7 +1026,7 @@ let main3 exiter: Exiter, ilSourceDocs)) = - use main3Activity = activitySource.StartActivity("main3") + use main3Activity = Activity.instance.StartNoTags("main3") // Encode the signature data ReportTime tcConfig "Encode Interface Data" let exportRemapping = MakeExportRemapping generatedCcu generatedCcu.Contents @@ -1125,7 +1122,7 @@ let main4 exiter: Exiter, ilSourceDocs)) = - use main4Activity = activitySource.StartActivity("main4") + use main4Activity = Activity.instance.StartNoTags("main4") match tcImportsCapture with | None -> () @@ -1229,7 +1226,7 @@ let main5 exiter: Exiter, ilSourceDocs)) = - use main5Activity = activitySource.StartActivity("main5") + use main5Activity = Activity.instance.StartNoTags("main5") use unwindBuildPhase = PushThreadBuildPhaseUntilUnwind BuildPhase.Output @@ -1262,7 +1259,7 @@ let main6 exiter: Exiter, ilSourceDocs)) = - use main6Activity = activitySource.StartActivity("main6") + use main6Activity = Activity.instance.StartNoTags("main6") ReportTime tcConfig "Write .NET Binary" diff --git a/src/Compiler/Facilities/BuildGraph.fs b/src/Compiler/Facilities/BuildGraph.fs index 6c5b828e332..ccc710b88c8 100644 --- a/src/Compiler/Facilities/BuildGraph.fs +++ b/src/Compiler/Facilities/BuildGraph.fs @@ -7,6 +7,7 @@ open System.Threading open System.Threading.Tasks open System.Diagnostics open System.Globalization +open FSharp.Compiler.Diagnostics.Activity open FSharp.Compiler.DiagnosticsLogger open Internal.Utilities.Library @@ -93,7 +94,7 @@ type NodeCodeBuilder() = member _.Combine(Node (p1): NodeCode, Node (p2): NodeCode<'T>) : NodeCode<'T> = Node(async.Combine(p1, p2)) [] - member _.Using(value: Activity, binder: Activity -> NodeCode<'U>) = + member _.Using(value: ActivityFacade, binder: ActivityFacade -> NodeCode<'U>) = Node( async { try diff --git a/src/Compiler/Facilities/BuildGraph.fsi b/src/Compiler/Facilities/BuildGraph.fsi index f292bbc7040..14c276d0f58 100644 --- a/src/Compiler/Facilities/BuildGraph.fsi +++ b/src/Compiler/Facilities/BuildGraph.fsi @@ -6,6 +6,7 @@ open System open System.Diagnostics open System.Threading open System.Threading.Tasks +open FSharp.Compiler.Diagnostics.Activity open FSharp.Compiler.DiagnosticsLogger open Internal.Utilities.Library @@ -48,7 +49,7 @@ type NodeCodeBuilder = /// that a proper generic 'use' could be implemented but has not currently been necessary) member Using: CompilationGlobalsScope * (CompilationGlobalsScope -> NodeCode<'T>) -> NodeCode<'T> - member Using: Activity * (Activity -> NodeCode<'T>) -> NodeCode<'T> + member Using: ActivityFacade * (ActivityFacade -> NodeCode<'T>) -> NodeCode<'T> /// Specifies code that can be run as part of the build graph. val node: NodeCodeBuilder diff --git a/src/Compiler/Facilities/Logger.fs b/src/Compiler/Facilities/Logger.fs index 3a62b996f86..76fd3f2d897 100644 --- a/src/Compiler/Facilities/Logger.fs +++ b/src/Compiler/Facilities/Logger.fs @@ -7,8 +7,34 @@ open System.Diagnostics open System.Diagnostics.Tracing module Activity = - let activitySourceName = "fsc" - let activitySource = new ActivitySource(activitySourceName) + + type ActivityFacade(activity : Activity option) = + member this.AddTag key (value : #obj) = match activity with | Some activity -> activity.AddTag(key, value) |> ignore | None -> () + member this.Perform action = match activity with | Some activity -> action activity | None -> () + member this.Dispose() = match activity with | Some activity -> activity.Dispose() | None -> () + interface IDisposable with + member this.Dispose() = this.Dispose() + + let start (source : ActivitySource) (activityName : string) (tags : (string * #obj) seq) = + let activity = source.StartActivity(activityName) |> Option.ofObj + let facade = new ActivityFacade(activity) + for key, value in tags do + facade.AddTag key value + facade + + let startNoTags (source : ActivitySource) (activityName : string) = start source activityName [] + + type ActivitySourceFacade(source : ActivitySource) = + member this.Start (name : string) (tags : (string * #obj) seq) = start source name tags + member this.StartNoTags name = startNoTags source name + member this.Name = source.Name + member this.Dispose() = source.Dispose() + interface IDisposable with + member this.Dispose() = this.Dispose() + + let private activitySourceName = "fsc" + let private activitySource = new ActivitySource(activitySourceName) + let instance = new ActivitySourceFacade(activitySource) type LogCompilerFunctionId = | Service_ParseAndCheckFileInProject = 1 diff --git a/src/Compiler/Facilities/Logger.fsi b/src/Compiler/Facilities/Logger.fsi index cbc990a3e5a..4af6a50dd46 100644 --- a/src/Compiler/Facilities/Logger.fsi +++ b/src/Compiler/Facilities/Logger.fsi @@ -5,9 +5,24 @@ namespace FSharp.Compiler.Diagnostics open System open System.Diagnostics -module Activity = - val activitySourceName: string - val activitySource: ActivitySource +module Activity = + + type ActivityFacade = + interface IDisposable + new : Activity option -> ActivityFacade + member AddTag : string -> #obj -> unit + member Perform : (Activity -> unit) -> unit + member Dispose : unit -> unit + + type ActivitySourceFacade = + interface IDisposable + new : ActivitySource -> ActivitySourceFacade + member Start : string -> (string * #obj) seq -> ActivityFacade + member StartNoTags : string -> ActivityFacade + member Name : string + member Dispose : unit -> unit + + val instance: ActivitySourceFacade type internal LogCompilerFunctionId = | Service_ParseAndCheckFileInProject = 1 diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs index 810c9cdc179..9f6ab96c75b 100644 --- a/src/Compiler/Service/FSharpCheckerResults.fs +++ b/src/Compiler/Service/FSharpCheckerResults.fs @@ -2347,9 +2347,8 @@ module internal ParseAndCheckFile = let parseFile (sourceText: ISourceText, fileName, options: FSharpParsingOptions, userOpName: string, suggestNamesForErrors: bool) = Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "parseFile", fileName) - use act = Activity.activitySource.StartActivity("parseFile") - act.AddTag("fileName", fileName) |> ignore - + use act = Activity.instance.Start "parseFile" [|"fileName", fileName|] + let errHandler = ErrorHandler(true, fileName, options.DiagnosticOptions, sourceText, suggestNamesForErrors) diff --git a/src/Compiler/Service/IncrementalBuild.fs b/src/Compiler/Service/IncrementalBuild.fs index 0a661629702..3b3ff42a962 100644 --- a/src/Compiler/Service/IncrementalBuild.fs +++ b/src/Compiler/Service/IncrementalBuild.fs @@ -116,9 +116,12 @@ module IncrementalBuildSyntaxTree = let mutable weakCache: WeakReference<_> option = None let parse(sigNameOpt: QualifiedNameOfFile option) = - use act = Activity.activitySource.StartActivity("SyntaxTree.parse") - act.AddTag("fileName", source.FilePath) |> ignore - act.AddTag("buildPhase", BuildPhase.Parse) |> ignore + use act = + Activity.instance.Start "SyntaxTree.parse" + [| + "fileName", source.FilePath + "buildPhase", BuildPhase.Parse.ToString() + |] let diagnosticsLogger = CompilationDiagnosticLogger("Parse", tcConfig.diagnosticsOptions) // Return the disposable object that cleans up use _holder = new CompilationGlobalsScope(diagnosticsLogger, BuildPhase.Parse) @@ -126,7 +129,7 @@ module IncrementalBuildSyntaxTree = try IncrementalBuilderEventTesting.MRU.Add(IncrementalBuilderEventTesting.IBEParsed fileName) let canSkip = sigNameOpt.IsSome && FSharpImplFileSuffixes |> List.exists (FileSystemUtils.checkSuffix fileName) - act.AddTag("canSkip", canSkip) |> ignore + act.AddTag "canSkip" canSkip let input = if canSkip then ParsedInput.ImplFile( @@ -469,8 +472,7 @@ type BoundModel private (tcConfig: TcConfig, let! res = defaultTypeCheck () return res | Some syntaxTree -> - use act = Activity.activitySource.StartActivity("TypeCheck") - act.AddTag("fileName", syntaxTree.FileName) |> ignore + use _ = Activity.instance.Start "TypeCheck" [|"fileName", syntaxTree.FileName|] let sigNameOpt = if partialCheck then this.BackingSignature @@ -508,7 +510,7 @@ type BoundModel private (tcConfig: TcConfig, partialCheck) |> NodeCode.FromCancellable - use _ = Activity.activitySource.StartActivity("TypeCheck_BuildState") + use _ = Activity.instance.StartNoTags("TypeCheck_BuildState") Logger.LogBlockMessageStop fileName LogCompilerFunctionId.IncrementalBuild_TypeCheck fileChecked.Trigger fileName @@ -1045,8 +1047,7 @@ module IncrementalBuilderStateHelpers = let rec createFinalizeBoundModelGraphNode (initialState: IncrementalBuilderInitialState) (boundModels: ImmutableArray>.Builder) = GraphNode(node { - use act = Activity.activitySource.StartActivity("GetCheckResultsAndImplementationsForProject") - act.AddTag("projectOutFile", initialState.outfile) |> ignore + use _ = Activity.instance.Start "GetCheckResultsAndImplementationsForProject" [|"projectOutFile", initialState.outfile|] // Compute last bound model then get all the evaluated models. let! _ = boundModels[boundModels.Count - 1].GetOrComputeValue() let boundModels = diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index c265d06f69c..383913cc8fe 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -393,8 +393,7 @@ type BackgroundCompiler /// creates an incremental builder used by the command line compiler. let CreateOneIncrementalBuilder (options: FSharpProjectOptions, userOpName) = node { - use act = Activity.activitySource.StartActivity("CreateOneIncrementalBuilder") - act.AddTag("project", options.ProjectFileName) |> ignore + use _ = Activity.instance.Start "CreateOneIncrementalBuilder" [|"project", options.ProjectFileName|] Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "CreateOneIncrementalBuilder", options.ProjectFileName) let projectReferences = getProjectReferences options userOpName @@ -586,9 +585,7 @@ type BackgroundCompiler member _.ParseFile(fileName: string, sourceText: ISourceText, options: FSharpParsingOptions, cache: bool, userOpName: string) = async { - use act = Activity.activitySource.StartActivity("CompileToDynamicAssembly1") - act.AddTag("filename", fileName) |> ignore - act.AddTag("UserOpName", userOpName) |> ignore + use _ = Activity.instance.Start "CompileToDynamicAssembly1" [|"filename", fileName; "UserOpName", userOpName|] if cache then let hash = sourceText.GetHashCode() |> int64 @@ -775,9 +772,7 @@ type BackgroundCompiler /// Type-check the result obtained by parsing. Force the evaluation of the antecedent type checking context if needed. member bc.CheckFileInProject(parseResults: FSharpParseFileResults, fileName, fileVersion, sourceText: ISourceText, options, userOpName) = node { - use act = Activity.activitySource.StartActivity("Service_CheckFileInProject") - act.AddTag("project", options.ProjectFileName) |> ignore - act.AddTag("fileName", fileName) |> ignore + use _ = Activity.instance.Start "Service_CheckFileInProject" [|"project", options.ProjectFileName; "fileName", fileName|] let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) match builderOpt with @@ -798,9 +793,7 @@ type BackgroundCompiler /// Parses and checks the source file and returns untyped AST and check results. member bc.ParseAndCheckFileInProject(fileName: string, fileVersion, sourceText: ISourceText, options: FSharpProjectOptions, userOpName) = node { - use act = Activity.activitySource.StartActivity("Service_ParseAndCheckFileInProject") - act.AddTag("project", options.ProjectFileName) |> ignore - act.AddTag("fileName", fileName) |> ignore + use _ = Activity.instance.Start "Service_ParseAndCheckFileInProject" [|"project", options.ProjectFileName; "fileName", fileName|] let strGuid = "_ProjectId=" + (options.ProjectId |> Option.defaultValue "null") Logger.LogBlockMessageStart (fileName + strGuid) LogCompilerFunctionId.Service_ParseAndCheckFileInProject @@ -1214,24 +1207,6 @@ type BackgroundCompiler static member ActualCheckFileCount = actualCheckFileCount -module Foo = - open FSharp.Compiler.Diagnostics.Activity - open OpenTelemetry.Trace - - let init () = - let tracerProvider = - Sdk.CreateTracerProviderBuilder() - .AddSource(activitySourceName) - .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) - .AddOtlpExporter() - .AddZipkinExporter() - .Build() - - let forceCleanup() = - activitySource.Dispose() - tracerProvider.Dispose() - forceCleanup() - [] // There is typically only one instance of this type in an IDE process. type FSharpChecker @@ -1260,9 +1235,6 @@ type FSharpChecker enablePartialTypeChecking ) - // let _ = Foo.init() - // let _ = FSharp.Compiler.Diagnostics.Activity.activitySource.StartActivity("main") - static let globalInstance = lazy FSharpChecker.Create() // STATIC ROOT: FSharpLanguageServiceTestable.FSharpChecker.braceMatchCache. Most recently used cache for brace matching. Accessed on the @@ -1416,8 +1388,7 @@ type FSharpChecker let _userOpName = defaultArg userOpName "Unknown" async { - use act = Activity.activitySource.StartActivity("CompileToDynamicAssembly1") - act.AddTag("UserOpName", _userOpName) |> ignore + use _ = Activity.instance.Start "CompileToDynamicAssembly1" [|"UserOpName", _userOpName|] let ctok = CompilationThreadToken() CompileHelpers.setOutputStreams execute @@ -1460,9 +1431,7 @@ type FSharpChecker let _userOpName = defaultArg userOpName "Unknown" async { - use act = Activity.activitySource.StartActivity("CompileToDynamicAssembly2") - act.AddTag("Assembly", assemblyName) |> ignore - act.AddTag("UserOpName", _userOpName) |> ignore + use _ = Activity.instance.Start "CompileToDynamicAssembly2" [|"Assembly", assemblyName; "UserOpName", _userOpName|] let ctok = CompilationThreadToken() CompileHelpers.setOutputStreams execute @@ -1556,10 +1525,13 @@ type FSharpChecker ?userOpName: string ) = async { - use act = Activity.activitySource.StartActivity("CheckFileInProjectAllowingStaleCachedResults") - act.AddTag("Project", options.ProjectFileName) |> ignore - act.AddTag("filename", fileName) |> ignore - act.AddTag("UserOpName", userOpName) |> ignore + use _ = + Activity.instance.Start "CheckFileInProjectAllowingStaleCachedResults" + [| + "Project", options.ProjectFileName + "filename", fileName + "UserOpName", userOpName |> Option.defaultValue "" + |] let userOpName = defaultArg userOpName "Unknown" return! backgroundCompiler.CheckFileInProjectAllowingStaleCachedResults( @@ -1585,10 +1557,13 @@ type FSharpChecker ?userOpName: string ) = async { - use act = Activity.activitySource.StartActivity("CheckFileInProject") - act.AddTag("Project", options.ProjectFileName) |> ignore - act.AddTag("filename", fileName) |> ignore - act.AddTag("UserOpName", userOpName) |> ignore + use _ = + Activity.instance.Start "CheckFileInProject" + [| + "Project", options.ProjectFileName + "filename", fileName + "UserOpName", userOpName |> Option.defaultValue "" + |] let userOpName = defaultArg userOpName "Unknown" return! backgroundCompiler.CheckFileInProject(parseResults, fileName, fileVersion, sourceText, options, userOpName) @@ -1606,11 +1581,14 @@ type FSharpChecker ?userOpName: string ) = async { - use act = Activity.activitySource.StartActivity("ParseAndCheckFileInProject") - act.AddTag("Project", options.ProjectFileName) |> ignore - act.AddTag("filename", fileName) |> ignore - act.AddTag("UserOpName", userOpName) |> ignore let userOpName = defaultArg userOpName "Unknown" + use _ = + Activity.instance.Start "ParseAndCheckFileInProject" + [| + "Project", options.ProjectFileName + "filename", fileName + "UserOpName", userOpName + |] return! backgroundCompiler.ParseAndCheckFileInProject(fileName, fileVersion, sourceText, options, userOpName) |> Async.AwaitNodeCode @@ -1619,9 +1597,12 @@ type FSharpChecker member _.ParseAndCheckProject(options, ?userOpName: string) = async { let userOpName = defaultArg userOpName "Unknown" - use act = Activity.activitySource.StartActivity("ParseAndCheckProject") - act.AddTag("Project", options.ProjectFileName) |> ignore - act.AddTag("UserOpName", userOpName) |> ignore + use _ = + Activity.instance.Start "ParseAndCheckProject" + [| + "Project", options.ProjectFileName + "UserOpName", userOpName + |] return! backgroundCompiler.ParseAndCheckProject(options, userOpName) |> Async.AwaitNodeCode @@ -1638,9 +1619,12 @@ type FSharpChecker async { let canInvalidateProject = defaultArg canInvalidateProject true let userOpName = defaultArg userOpName "Unknown" - use act = Activity.activitySource.StartActivity("FindBackgroundReferencesInFile") - act.AddTag("Project", options.ProjectFileName) |> ignore - act.AddTag("UserOpName", userOpName) |> ignore + use _ = + Activity.instance.Start "FindBackgroundReferencesInFile" + [| + "Project", options.ProjectFileName + "UserOpName", userOpName + |] return! backgroundCompiler.FindReferencesInFile(fileName, options, symbol, canInvalidateProject, userOpName) |> Async.AwaitNodeCode @@ -1649,8 +1633,12 @@ type FSharpChecker member _.GetBackgroundSemanticClassificationForFile(fileName: string, options: FSharpProjectOptions, ?userOpName) = async { let userOpName = defaultArg userOpName "Unknown" - use act = Activity.activitySource.StartActivity("FindBackgroundReferencesInFile") - act.AddTag("Project", options.ProjectFileName) |> ignore + use _ = + Activity.instance.Start "FindBackgroundReferencesInFile" + [| + "Project", options.ProjectFileName + "UserOpName", userOpName + |] return! backgroundCompiler.GetSemanticClassificationForFile(fileName, options, userOpName) |> Async.AwaitNodeCode diff --git a/src/fsc/fscmain.fs b/src/fsc/fscmain.fs index 7e4d566398c..01097d20e74 100644 --- a/src/fsc/fscmain.fs +++ b/src/fsc/fscmain.fs @@ -13,7 +13,7 @@ open Internal.Utilities.Library.Extras open FSharp.Compiler.AbstractIL open FSharp.Compiler.AbstractIL.ILBinaryReader open FSharp.Compiler.CompilerConfig -open FSharp.Compiler.Diagnostics.Activity +open FSharp.Compiler.Diagnostics open FSharp.Compiler.Driver open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.CodeAnalysis @@ -34,16 +34,16 @@ let main(argv) = // be null use tracerProvider = Sdk.CreateTracerProviderBuilder() - .AddSource(activitySourceName) + .AddSource(Activity.instance.Name) .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) .AddOtlpExporter() .AddZipkinExporter() .Build(); - use mainActivity = activitySource.StartActivity("main") + use mainActivity = Activity.instance.StartNoTags "main" let forceCleanup() = mainActivity.Dispose() - activitySource.Dispose() + Activity.instance.Dispose() tracerProvider.Dispose() let compilerName = diff --git a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs index 24d5d054eea..a544aebef0b 100644 --- a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs +++ b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs @@ -1,11 +1,12 @@ -open BenchmarkDotNet.Configs +open System +open BenchmarkDotNet.Configs open BenchmarkDotNet.Running open FSharp.Compiler.Benchmarks open OpenTelemetry open OpenTelemetry.Resources open OpenTelemetry.Trace -open FSharp.Compiler.Diagnostics.Activity +open FSharp.Compiler.Diagnostics [] let main args = @@ -16,16 +17,16 @@ let main args = // be null use tracerProvider = Sdk.CreateTracerProviderBuilder() - .AddSource(activitySourceName) + .AddSource(Activity.instance.Name) .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="program", serviceVersion = "42.42.42.44")) .AddOtlpExporter() .AddZipkinExporter() .Build(); - use mainActivity = activitySource.StartActivity("main") + use mainActivity = Activity.instance.StartNoTags("main") let forceCleanup() = mainActivity.Dispose() - activitySource.Dispose() + Activity.instance.Dispose() tracerProvider.Dispose() b.Setup() From ad5d138bdd11f56e3de03fbe1dd0ebf8be37a225 Mon Sep 17 00:00:00 2001 From: janusz Date: Sat, 3 Sep 2022 15:28:25 +0100 Subject: [PATCH 14/39] Use Jaeger exporter in FSC --- src/fsc/fscmain.fs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/fsc/fscmain.fs b/src/fsc/fscmain.fs index 01097d20e74..c5c1ec601f9 100644 --- a/src/fsc/fscmain.fs +++ b/src/fsc/fscmain.fs @@ -36,8 +36,7 @@ let main(argv) = Sdk.CreateTracerProviderBuilder() .AddSource(Activity.instance.Name) .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) - .AddOtlpExporter() - .AddZipkinExporter() + .AddJaegerExporter() .Build(); use mainActivity = Activity.instance.StartNoTags "main" From 57ca46bc05f68d537beb156834569c0c58c5eb3c Mon Sep 17 00:00:00 2001 From: janusz Date: Sat, 3 Sep 2022 15:29:51 +0100 Subject: [PATCH 15/39] Revert "Allow parallel project analysis with an environment variable" This reverts commit c62e89c2 --- src/Compiler/Driver/CompilerImports.fs | 16 +--------------- src/Compiler/Facilities/BuildGraph.fs | 8 +------- src/Compiler/Facilities/BuildGraph.fsi | 2 -- 3 files changed, 2 insertions(+), 24 deletions(-) diff --git a/src/Compiler/Driver/CompilerImports.fs b/src/Compiler/Driver/CompilerImports.fs index 5208d6f803f..b7738705788 100644 --- a/src/Compiler/Driver/CompilerImports.fs +++ b/src/Compiler/Driver/CompilerImports.fs @@ -2141,20 +2141,6 @@ and [] TcImports node { CheckDisposed() - // TODO inject top-down from FSharpChecker - let runInParallel = - Environment.GetEnvironmentVariable("FCS_PARALLEL_PROJECTS_ANALYSIS") - |> bool.TryParse - |> function - | true, runInParallel -> runInParallel - | false, _ -> false - - let runMethod = - if runInParallel then - NodeCode.Parallel - else - NodeCode.Sequential - let! results = nms |> List.map (fun nm -> @@ -2165,7 +2151,7 @@ and [] TcImports errorR (Error(FSComp.SR.buildProblemReadingAssembly (nm.resolvedPath, e.Message), nm.originalReference.Range)) return None }) - |> runMethod + |> NodeCode.Sequential let dllinfos, phase2s = results |> Array.choose id |> List.ofArray |> List.unzip fixupOrphanCcus () diff --git a/src/Compiler/Facilities/BuildGraph.fs b/src/Compiler/Facilities/BuildGraph.fs index ccc710b88c8..163b1b2316e 100644 --- a/src/Compiler/Facilities/BuildGraph.fs +++ b/src/Compiler/Facilities/BuildGraph.fs @@ -194,12 +194,6 @@ type NodeCode private () = return results.ToArray() } - - static member Parallel (computations: NodeCode<'T> seq) = - computations - |> Seq.map (fun (Node x) -> x) - |> Async.Parallel - |> Node type private AgentMessage<'T> = GetValue of AsyncReplyChannel> * callerCancellationToken: CancellationToken @@ -349,7 +343,7 @@ type GraphNode<'T>(retryCompute: bool, computation: NodeCode<'T>) = // occur, making sure we are under the protection of the 'try'. // For example, NodeCode's 'try/finally' (TryFinally) uses async.TryFinally which does // implicit cancellation checks even before the try is entered, as do the - // de-sugaring of 'do!' and other NodeCode constructs. + // de-sugaring of 'do!' and other CodeCode constructs. let mutable taken = false try diff --git a/src/Compiler/Facilities/BuildGraph.fsi b/src/Compiler/Facilities/BuildGraph.fsi index 14c276d0f58..69241ad921a 100644 --- a/src/Compiler/Facilities/BuildGraph.fsi +++ b/src/Compiler/Facilities/BuildGraph.fsi @@ -69,8 +69,6 @@ type NodeCode = static member Sequential: computations: NodeCode<'T> seq -> NodeCode<'T[]> - static member Parallel: computations: (NodeCode<'T> seq) -> NodeCode<'T[]> - /// Execute the cancellable computation synchronously using the ambient cancellation token of /// the NodeCode. static member FromCancellable: computation: Cancellable<'T> -> NodeCode<'T> From 057a110f94eb15c38b6d83da2c2fba6af5a039e6 Mon Sep 17 00:00:00 2001 From: janusz Date: Sat, 3 Sep 2022 15:37:01 +0100 Subject: [PATCH 16/39] * Remove references to OpenTelemetry * Move activities to BackgroundChecker layer, deduplicate --- src/Compiler/FSharp.Compiler.Service.fsproj | 2 -- src/Compiler/Facilities/BuildGraph.fs | 13 ++++---- src/Compiler/Service/service.fs | 33 +++++++------------ src/fsc/fscmain.fs | 25 +------------- .../CompilerServiceBenchmarks/Program.fs | 32 ++---------------- 5 files changed, 21 insertions(+), 84 deletions(-) diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index a2f7bcd3204..b9cb5a84450 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -501,8 +501,6 @@ - - diff --git a/src/Compiler/Facilities/BuildGraph.fs b/src/Compiler/Facilities/BuildGraph.fs index 163b1b2316e..e32a14ae886 100644 --- a/src/Compiler/Facilities/BuildGraph.fs +++ b/src/Compiler/Facilities/BuildGraph.fs @@ -94,29 +94,30 @@ type NodeCodeBuilder() = member _.Combine(Node (p1): NodeCode, Node (p2): NodeCode<'T>) : NodeCode<'T> = Node(async.Combine(p1, p2)) [] - member _.Using(value: ActivityFacade, binder: ActivityFacade -> NodeCode<'U>) = + member _.Using(value: CompilationGlobalsScope, binder: CompilationGlobalsScope -> NodeCode<'U>) = Node( async { + DiagnosticsThreadStatics.DiagnosticsLogger <- value.DiagnosticsLogger + DiagnosticsThreadStatics.BuildPhase <- value.BuildPhase + try return! binder value |> Async.AwaitNodeCode finally (value :> IDisposable).Dispose() } ) - + [] - member _.Using(value: CompilationGlobalsScope, binder: CompilationGlobalsScope -> NodeCode<'U>) = + member _.Using(value: ActivityFacade, binder: ActivityFacade -> NodeCode<'U>) = Node( async { - DiagnosticsThreadStatics.DiagnosticsLogger <- value.DiagnosticsLogger - DiagnosticsThreadStatics.BuildPhase <- value.BuildPhase - try return! binder value |> Async.AwaitNodeCode finally (value :> IDisposable).Dispose() } ) + let node = NodeCodeBuilder() diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index 383913cc8fe..7dc7b22613a 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -35,8 +35,6 @@ open FSharp.Compiler.Text open FSharp.Compiler.Text.Range open FSharp.Compiler.TcGlobals open FSharp.Compiler.BuildGraph -open OpenTelemetry -open OpenTelemetry.Resources [] module EnvMisc = @@ -343,8 +341,7 @@ type BackgroundCompiler member x.EvaluateRawContents() = node { Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "GetAssemblyData", nm) - let! x = self.GetAssemblyData(opts, userOpName + ".CheckReferencedProject(" + nm + ")") - return x + return! self.GetAssemblyData(opts, userOpName + ".CheckReferencedProject(" + nm + ")") } member x.TryGetLogicalTimeStamp(cache) = @@ -739,6 +736,13 @@ type BackgroundCompiler userOpName ) = node { + use _ = + Activity.instance.Start "CheckFileInProjectAllowingStaleCachedResults" + [| + "Project", options.ProjectFileName + "filename", fileName + "UserOpName", userOpName |> Option.defaultValue "" + |] let! cachedResults = node { let! builderOpt, creationDiags = getAnyBuilder (options, userOpName) @@ -772,12 +776,11 @@ type BackgroundCompiler /// Type-check the result obtained by parsing. Force the evaluation of the antecedent type checking context if needed. member bc.CheckFileInProject(parseResults: FSharpParseFileResults, fileName, fileVersion, sourceText: ISourceText, options, userOpName) = node { - use _ = Activity.instance.Start "Service_CheckFileInProject" [|"project", options.ProjectFileName; "fileName", fileName|] + use _ = Activity.instance.Start "CheckFileInProject" [|"project", options.ProjectFileName; "fileName", fileName; "userOpName", userOpName|] let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) match builderOpt with - | None -> - return FSharpCheckFileAnswer.Succeeded(FSharpCheckFileResults.MakeEmpty(fileName, creationDiags, keepAssemblyContents)) + | None -> return FSharpCheckFileAnswer.Succeeded(FSharpCheckFileResults.MakeEmpty(fileName, creationDiags, keepAssemblyContents)) | Some builder -> // Check the cache. We can only use cached results when there is no work to do to bring the background builder up-to-date let! cachedResults = bc.GetCachedCheckFileResult(builder, fileName, sourceText, options) @@ -1234,7 +1237,7 @@ type FSharpChecker enableBackgroundItemKeyStoreAndSemanticClassification, enablePartialTypeChecking ) - + static let globalInstance = lazy FSharpChecker.Create() // STATIC ROOT: FSharpLanguageServiceTestable.FSharpChecker.braceMatchCache. Most recently used cache for brace matching. Accessed on the @@ -1525,13 +1528,6 @@ type FSharpChecker ?userOpName: string ) = async { - use _ = - Activity.instance.Start "CheckFileInProjectAllowingStaleCachedResults" - [| - "Project", options.ProjectFileName - "filename", fileName - "UserOpName", userOpName |> Option.defaultValue "" - |] let userOpName = defaultArg userOpName "Unknown" return! backgroundCompiler.CheckFileInProjectAllowingStaleCachedResults( @@ -1557,13 +1553,6 @@ type FSharpChecker ?userOpName: string ) = async { - use _ = - Activity.instance.Start "CheckFileInProject" - [| - "Project", options.ProjectFileName - "filename", fileName - "UserOpName", userOpName |> Option.defaultValue "" - |] let userOpName = defaultArg userOpName "Unknown" return! backgroundCompiler.CheckFileInProject(parseResults, fileName, fileVersion, sourceText, options, userOpName) diff --git a/src/fsc/fscmain.fs b/src/fsc/fscmain.fs index c5c1ec601f9..15f607b7656 100644 --- a/src/fsc/fscmain.fs +++ b/src/fsc/fscmain.fs @@ -13,37 +13,16 @@ open Internal.Utilities.Library.Extras open FSharp.Compiler.AbstractIL open FSharp.Compiler.AbstractIL.ILBinaryReader open FSharp.Compiler.CompilerConfig -open FSharp.Compiler.Diagnostics open FSharp.Compiler.Driver open FSharp.Compiler.DiagnosticsLogger open FSharp.Compiler.CodeAnalysis open FSharp.Compiler.Text -open System.Diagnostics -open OpenTelemetry -open OpenTelemetry.Resources -open OpenTelemetry.Trace [] do () [] -let main(argv) = - - // eventually this would need to only export to the OLTP collector, and even then only if configured. always-on is no good. - // when this configuration becomes opt-in, we'll also need to safely check activities around every StartActivity call, because those could - // be null - use tracerProvider = - Sdk.CreateTracerProviderBuilder() - .AddSource(Activity.instance.Name) - .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="fsc", serviceVersion = "42.42.42.42")) - .AddJaegerExporter() - .Build(); - use mainActivity = Activity.instance.StartNoTags "main" - - let forceCleanup() = - mainActivity.Dispose() - Activity.instance.Dispose() - tracerProvider.Dispose() +let main (argv) = let compilerName = // the 64 bit desktop version of the compiler is name fscAnyCpu.exe, all others are fsc.exe @@ -85,7 +64,6 @@ let main(argv) = let stats = ILBinaryReader.GetStatistics() AppDomain.CurrentDomain.ProcessExit.Add(fun _ -> - forceCleanup() printfn "STATS: #ByteArrayFile = %d, #MemoryMappedFileOpen = %d, #MemoryMappedFileClosed = %d, #RawMemoryFile = %d, #WeakByteArrayFile = %d" stats.byteFileCount @@ -99,7 +77,6 @@ let main(argv) = let quitProcessExiter = { new Exiter with member _.Exit(n) = - forceCleanup() try exit n with _ -> diff --git a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs index a544aebef0b..fa0474dbf5e 100644 --- a/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs +++ b/tests/benchmarks/FCSBenchmarks/CompilerServiceBenchmarks/Program.fs @@ -1,35 +1,7 @@ -open System -open BenchmarkDotNet.Configs -open BenchmarkDotNet.Running +open BenchmarkDotNet.Running open FSharp.Compiler.Benchmarks -open OpenTelemetry -open OpenTelemetry.Resources -open OpenTelemetry.Trace - -open FSharp.Compiler.Diagnostics [] let main args = - let b = DecentlySizedStandAloneFileBenchmark() - - // eventually this would need to only export to the OLTP collector, and even then only if configured. always-on is no good. - // when this configuration becomes opt-in, we'll also need to safely check activities around every StartActivity call, because those could - // be null - use tracerProvider = - Sdk.CreateTracerProviderBuilder() - .AddSource(Activity.instance.Name) - .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService(serviceName ="program", serviceVersion = "42.42.42.44")) - .AddOtlpExporter() - .AddZipkinExporter() - .Build(); - use mainActivity = Activity.instance.StartNoTags("main") - - let forceCleanup() = - mainActivity.Dispose() - Activity.instance.Dispose() - tracerProvider.Dispose() - - b.Setup() - b.Run() - forceCleanup() + BenchmarkSwitcher.FromAssembly(typeof.Assembly).Run(args) |> ignore 0 From ca51e57eb4df76d749a3ea22c1787e4445498c61 Mon Sep 17 00:00:00 2001 From: janusz Date: Sat, 3 Sep 2022 15:42:00 +0100 Subject: [PATCH 17/39] Fix build --- src/Compiler/Service/service.fs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index 7dc7b22613a..f698a64c8d9 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -741,7 +741,7 @@ type BackgroundCompiler [| "Project", options.ProjectFileName "filename", fileName - "UserOpName", userOpName |> Option.defaultValue "" + "UserOpName", userOpName |] let! cachedResults = node { From e5a381655d8cf7b76b362dc0f0afffcf50a0f45d Mon Sep 17 00:00:00 2001 From: janusz Date: Sat, 3 Sep 2022 17:17:10 +0100 Subject: [PATCH 18/39] Revert unneeded changes/PR feedback --- src/Compiler/Service/IncrementalBuild.fs | 3 +-- src/Compiler/Service/service.fs | 23 ++++++++++------------- src/fsc/fsc.targets | 3 --- 3 files changed, 11 insertions(+), 18 deletions(-) diff --git a/src/Compiler/Service/IncrementalBuild.fs b/src/Compiler/Service/IncrementalBuild.fs index 3b3ff42a962..66d338a1b2b 100644 --- a/src/Compiler/Service/IncrementalBuild.fs +++ b/src/Compiler/Service/IncrementalBuild.fs @@ -1368,8 +1368,7 @@ type IncrementalBuilder(initialState: IncrementalBuilderInitialState, state: Inc | (ilAssemRef, tcAssemblyDataOpt, tcAssemblyExprOpt, boundModel), timestamp -> let cache = TimeStampCache defaultTimeStamp let projectTimeStamp = builder.GetLogicalTimeStampForProject(cache) - let res = PartialCheckResults (boundModel, timestamp, projectTimeStamp), ilAssemRef, tcAssemblyDataOpt, tcAssemblyExprOpt - return res + return PartialCheckResults (boundModel, timestamp, projectTimeStamp), ilAssemRef, tcAssemblyDataOpt, tcAssemblyExprOpt } member builder.GetFullCheckResultsAndImplementationsForProject() = diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index f698a64c8d9..af56a8a0869 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -1527,19 +1527,16 @@ type FSharpChecker options: FSharpProjectOptions, ?userOpName: string ) = - async { - let userOpName = defaultArg userOpName "Unknown" - return! - backgroundCompiler.CheckFileInProjectAllowingStaleCachedResults( - parseResults, - fileName, - fileVersion, - SourceText.ofString source, - options, - userOpName - ) - |> Async.AwaitNodeCode - } + let userOpName = defaultArg userOpName "Unknown" + backgroundCompiler.CheckFileInProjectAllowingStaleCachedResults( + parseResults, + fileName, + fileVersion, + SourceText.ofString source, + options, + userOpName + ) + |> Async.AwaitNodeCode /// Typecheck a source code file, returning a handle to the results of the /// parse including the reconstructed types in the file. diff --git a/src/fsc/fsc.targets b/src/fsc/fsc.targets index 2c9cb61d813..f93bfec20d3 100644 --- a/src/fsc/fsc.targets +++ b/src/fsc/fsc.targets @@ -51,9 +51,6 @@ - - - From 679d2aa6f29474613b6d25a0a5d77c5be9c5fe35 Mon Sep 17 00:00:00 2001 From: janusz Date: Sat, 3 Sep 2022 17:24:48 +0100 Subject: [PATCH 19/39] Remove nuget.org --- NuGet.config | 1 - 1 file changed, 1 deletion(-) diff --git a/NuGet.config b/NuGet.config index 72860d7241d..c6b6cb09dd7 100644 --- a/NuGet.config +++ b/NuGet.config @@ -13,7 +13,6 @@ - From bdb546b7403a66daef9db0d150ffd622c5033c76 Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 5 Sep 2022 00:46:08 +0100 Subject: [PATCH 20/39] Fantomas formatting --- src/Compiler/Driver/ParseAndCheckInputs.fs | 9 +-- src/Compiler/Driver/fsc.fs | 18 +++-- src/Compiler/Facilities/BuildGraph.fsi | 2 +- src/Compiler/Facilities/Logger.fsi | 18 ++--- src/Compiler/Service/FSharpCheckerResults.fs | 26 ++------ src/Compiler/Service/service.fs | 69 ++++++++++++-------- 6 files changed, 74 insertions(+), 68 deletions(-) diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index 2a29b909826..8f98ee14480 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -857,10 +857,7 @@ let ProcessMetaCommandsFromInput | ParsedHashDirective ("nowarn", ParsedHashDirectiveArguments numbers, m) -> List.fold (fun state d -> nowarnF state (m, d)) state numbers - | ParsedHashDirective (("reference" - | "r"), - ParsedHashDirectiveArguments args, - m) -> + | ParsedHashDirective (("reference" | "r"), ParsedHashDirectiveArguments args, m) -> matchedm <- m ProcessDependencyManagerDirective Directive.Resolution args m state @@ -1139,8 +1136,8 @@ let CheckOneInput cancellable { try - use _ = Activity.instance.Start "CheckOneInput" [|"inputName", inp.FileName|] - + use _ = Activity.instance.Start "CheckOneInput" [| "inputName", inp.FileName |] + CheckSimulateException tcConfig let m = inp.Range diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs index fde26ac3870..f135a5e5c49 100644 --- a/src/Compiler/Driver/fsc.fs +++ b/src/Compiler/Driver/fsc.fs @@ -166,7 +166,8 @@ let TypeCheck inputs, exiter: Exiter ) = - use _ = Activity.instance.Start "typecheck_inputs" [|"assemblyName", assemblyName|] + use _ = + Activity.instance.Start "typecheck_inputs" [| "assemblyName", assemblyName |] try if isNil inputs then @@ -476,7 +477,7 @@ let main1 diagnosticsLoggerProvider: DiagnosticsLoggerProvider, disposables: DisposablesTracker ) = - + use mainActivity = new Activity("main") // See Bug 735819 @@ -598,7 +599,9 @@ let main1 // Import basic assemblies let tcGlobals, frameworkTcImports = - use frameworkImportsActivity = Activity.instance.StartNoTags("import_framework_references") + use frameworkImportsActivity = + Activity.instance.StartNoTags("import_framework_references") + TcImports.BuildFrameworkTcImports(foundationalTcConfigP, sysRes, otherRes) |> NodeCode.RunImmediateWithoutCancellation @@ -651,7 +654,9 @@ let main1 ReportTime tcConfig "Import non-system references" let tcImports = - use nonFrameworkImportsActivity = Activity.instance.StartNoTags("import_non_framework_references") + use nonFrameworkImportsActivity = + Activity.instance.StartNoTags("import_non_framework_references") + TcImports.BuildNonFrameworkTcImports(tcConfigP, frameworkTcImports, otherRes, knownUnresolved, dependencyProvider) |> NodeCode.RunImmediateWithoutCancellation @@ -730,9 +735,9 @@ let main1OfAst disposables: DisposablesTracker, inputs: ParsedInput list ) = - + use main1AstActivity = Activity.instance.StartNoTags("main1_of_ast") - + let tryGetMetadataSnapshot = (fun _ -> None) let directoryBuildingFrom = Directory.GetCurrentDirectory() @@ -1396,6 +1401,7 @@ let CompileFromCommandLineArguments with _ -> () } + main1 ( ctok, argv, diff --git a/src/Compiler/Facilities/BuildGraph.fsi b/src/Compiler/Facilities/BuildGraph.fsi index 69241ad921a..2620c2eb296 100644 --- a/src/Compiler/Facilities/BuildGraph.fsi +++ b/src/Compiler/Facilities/BuildGraph.fsi @@ -48,7 +48,7 @@ type NodeCodeBuilder = /// A limited form 'use' for establishing the compilation globals. (Note /// that a proper generic 'use' could be implemented but has not currently been necessary) member Using: CompilationGlobalsScope * (CompilationGlobalsScope -> NodeCode<'T>) -> NodeCode<'T> - + member Using: ActivityFacade * (ActivityFacade -> NodeCode<'T>) -> NodeCode<'T> /// Specifies code that can be run as part of the build graph. diff --git a/src/Compiler/Facilities/Logger.fsi b/src/Compiler/Facilities/Logger.fsi index 4af6a50dd46..379ca9cddfd 100644 --- a/src/Compiler/Facilities/Logger.fsi +++ b/src/Compiler/Facilities/Logger.fsi @@ -9,18 +9,18 @@ module Activity = type ActivityFacade = interface IDisposable - new : Activity option -> ActivityFacade - member AddTag : string -> #obj -> unit - member Perform : (Activity -> unit) -> unit - member Dispose : unit -> unit + new: Activity option -> ActivityFacade + member AddTag: string -> #obj -> unit + member Perform: (Activity -> unit) -> unit + member Dispose: unit -> unit type ActivitySourceFacade = interface IDisposable - new : ActivitySource -> ActivitySourceFacade - member Start : string -> (string * #obj) seq -> ActivityFacade - member StartNoTags : string -> ActivityFacade - member Name : string - member Dispose : unit -> unit + new: ActivitySource -> ActivitySourceFacade + member Start: string -> (string * #obj) seq -> ActivityFacade + member StartNoTags: string -> ActivityFacade + member Name: string + member Dispose: unit -> unit val instance: ActivitySourceFacade diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs index 9f6ab96c75b..b72907bcfd6 100644 --- a/src/Compiler/Service/FSharpCheckerResults.fs +++ b/src/Compiler/Service/FSharpCheckerResults.fs @@ -247,9 +247,7 @@ type FSharpSymbolUse(denv: DisplayEnv, symbol: FSharpSymbol, inst: TyparInstanti // 'seq' in 'seq { ... }' gets colored as keywords | Item.Value vref, ItemOccurence.Use when valRefEq denv.g denv.g.seq_vref vref -> true // custom builders, custom operations get colored as keywords - | (Item.CustomBuilder _ - | Item.CustomOperation _), - ItemOccurence.Use -> true + | (Item.CustomBuilder _ | Item.CustomOperation _), ItemOccurence.Use -> true | _ -> false member _.IsFromOpenStatement = itemOcc = ItemOccurence.Open @@ -2310,14 +2308,8 @@ module internal ParseAndCheckFile = matchBraces stackAfterMatch - | LPAREN - | LBRACE _ - | LBRACK - | LBRACE_BAR - | LBRACK_BAR - | LQUOTE _ - | LBRACK_LESS as tok, - _ -> matchBraces ((tok, lexbuf.LexemeRange) :: stack) + | LPAREN | LBRACE _ | LBRACK | LBRACE_BAR | LBRACK_BAR | LQUOTE _ | LBRACK_LESS as tok, _ -> + matchBraces ((tok, lexbuf.LexemeRange) :: stack) // INTERP_STRING_BEGIN_PART corresponds to $"... {" at the start of an interpolated string // @@ -2326,9 +2318,7 @@ module internal ParseAndCheckFile = // interpolation expression) // // Either way we start a new potential match at the last character - | INTERP_STRING_BEGIN_PART _ - | INTERP_STRING_PART _ as tok, - _ -> + | INTERP_STRING_BEGIN_PART _ | INTERP_STRING_PART _ as tok, _ -> let m = lexbuf.LexemeRange let m2 = @@ -2336,9 +2326,7 @@ module internal ParseAndCheckFile = matchBraces ((tok, m2) :: stack) - | (EOF _ - | LEX_FAILURE _), - _ -> () + | (EOF _ | LEX_FAILURE _), _ -> () | _ -> matchBraces stack matchBraces []) @@ -2347,8 +2335,8 @@ module internal ParseAndCheckFile = let parseFile (sourceText: ISourceText, fileName, options: FSharpParsingOptions, userOpName: string, suggestNamesForErrors: bool) = Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "parseFile", fileName) - use act = Activity.instance.Start "parseFile" [|"fileName", fileName|] - + use act = Activity.instance.Start "parseFile" [| "fileName", fileName |] + let errHandler = ErrorHandler(true, fileName, options.DiagnosticOptions, sourceText, suggestNamesForErrors) diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index af56a8a0869..5fafdc544c2 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -390,7 +390,7 @@ type BackgroundCompiler /// creates an incremental builder used by the command line compiler. let CreateOneIncrementalBuilder (options: FSharpProjectOptions, userOpName) = node { - use _ = Activity.instance.Start "CreateOneIncrementalBuilder" [|"project", options.ProjectFileName|] + use _ = Activity.instance.Start "CreateOneIncrementalBuilder" [| "project", options.ProjectFileName |] Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "CreateOneIncrementalBuilder", options.ProjectFileName) let projectReferences = getProjectReferences options userOpName @@ -582,7 +582,9 @@ type BackgroundCompiler member _.ParseFile(fileName: string, sourceText: ISourceText, options: FSharpParsingOptions, cache: bool, userOpName: string) = async { - use _ = Activity.instance.Start "CompileToDynamicAssembly1" [|"filename", fileName; "UserOpName", userOpName|] + use _ = + Activity.instance.Start "CompileToDynamicAssembly1" [| "filename", fileName; "UserOpName", userOpName |] + if cache then let hash = sourceText.GetHashCode() |> int64 @@ -737,12 +739,14 @@ type BackgroundCompiler ) = node { use _ = - Activity.instance.Start "CheckFileInProjectAllowingStaleCachedResults" + Activity.instance.Start + "CheckFileInProjectAllowingStaleCachedResults" [| "Project", options.ProjectFileName "filename", fileName - "UserOpName", userOpName + "UserOpName", userOpName |] + let! cachedResults = node { let! builderOpt, creationDiags = getAnyBuilder (options, userOpName) @@ -776,7 +780,15 @@ type BackgroundCompiler /// Type-check the result obtained by parsing. Force the evaluation of the antecedent type checking context if needed. member bc.CheckFileInProject(parseResults: FSharpParseFileResults, fileName, fileVersion, sourceText: ISourceText, options, userOpName) = node { - use _ = Activity.instance.Start "CheckFileInProject" [|"project", options.ProjectFileName; "fileName", fileName; "userOpName", userOpName|] + use _ = + Activity.instance.Start + "CheckFileInProject" + [| + "project", options.ProjectFileName + "fileName", fileName + "userOpName", userOpName + |] + let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) match builderOpt with @@ -796,7 +808,9 @@ type BackgroundCompiler /// Parses and checks the source file and returns untyped AST and check results. member bc.ParseAndCheckFileInProject(fileName: string, fileVersion, sourceText: ISourceText, options: FSharpProjectOptions, userOpName) = node { - use _ = Activity.instance.Start "Service_ParseAndCheckFileInProject" [|"project", options.ProjectFileName; "fileName", fileName|] + use _ = + Activity.instance.Start "Service_ParseAndCheckFileInProject" [| "project", options.ProjectFileName; "fileName", fileName |] + let strGuid = "_ProjectId=" + (options.ProjectId |> Option.defaultValue "null") Logger.LogBlockMessageStart (fileName + strGuid) LogCompilerFunctionId.Service_ParseAndCheckFileInProject @@ -1391,7 +1405,7 @@ type FSharpChecker let _userOpName = defaultArg userOpName "Unknown" async { - use _ = Activity.instance.Start "CompileToDynamicAssembly1" [|"UserOpName", _userOpName|] + use _ = Activity.instance.Start "CompileToDynamicAssembly1" [| "UserOpName", _userOpName |] let ctok = CompilationThreadToken() CompileHelpers.setOutputStreams execute @@ -1434,7 +1448,9 @@ type FSharpChecker let _userOpName = defaultArg userOpName "Unknown" async { - use _ = Activity.instance.Start "CompileToDynamicAssembly2" [|"Assembly", assemblyName; "UserOpName", _userOpName|] + use _ = + Activity.instance.Start "CompileToDynamicAssembly2" [| "Assembly", assemblyName; "UserOpName", _userOpName |] + let ctok = CompilationThreadToken() CompileHelpers.setOutputStreams execute @@ -1528,6 +1544,7 @@ type FSharpChecker ?userOpName: string ) = let userOpName = defaultArg userOpName "Unknown" + backgroundCompiler.CheckFileInProjectAllowingStaleCachedResults( parseResults, fileName, @@ -1551,6 +1568,7 @@ type FSharpChecker ) = async { let userOpName = defaultArg userOpName "Unknown" + return! backgroundCompiler.CheckFileInProject(parseResults, fileName, fileVersion, sourceText, options, userOpName) |> Async.AwaitNodeCode @@ -1565,17 +1583,20 @@ type FSharpChecker sourceText: ISourceText, options: FSharpProjectOptions, ?userOpName: string - ) = + ) = async { let userOpName = defaultArg userOpName "Unknown" + use _ = - Activity.instance.Start "ParseAndCheckFileInProject" + Activity.instance.Start + "ParseAndCheckFileInProject" [| "Project", options.ProjectFileName "filename", fileName - "UserOpName", userOpName + "UserOpName", userOpName |] - return! + + return! backgroundCompiler.ParseAndCheckFileInProject(fileName, fileVersion, sourceText, options, userOpName) |> Async.AwaitNodeCode } @@ -1583,12 +1604,10 @@ type FSharpChecker member _.ParseAndCheckProject(options, ?userOpName: string) = async { let userOpName = defaultArg userOpName "Unknown" + use _ = - Activity.instance.Start "ParseAndCheckProject" - [| - "Project", options.ProjectFileName - "UserOpName", userOpName - |] + Activity.instance.Start "ParseAndCheckProject" [| "Project", options.ProjectFileName; "UserOpName", userOpName |] + return! backgroundCompiler.ParseAndCheckProject(options, userOpName) |> Async.AwaitNodeCode @@ -1605,12 +1624,10 @@ type FSharpChecker async { let canInvalidateProject = defaultArg canInvalidateProject true let userOpName = defaultArg userOpName "Unknown" + use _ = - Activity.instance.Start "FindBackgroundReferencesInFile" - [| - "Project", options.ProjectFileName - "UserOpName", userOpName - |] + Activity.instance.Start "FindBackgroundReferencesInFile" [| "Project", options.ProjectFileName; "UserOpName", userOpName |] + return! backgroundCompiler.FindReferencesInFile(fileName, options, symbol, canInvalidateProject, userOpName) |> Async.AwaitNodeCode @@ -1619,12 +1636,10 @@ type FSharpChecker member _.GetBackgroundSemanticClassificationForFile(fileName: string, options: FSharpProjectOptions, ?userOpName) = async { let userOpName = defaultArg userOpName "Unknown" + use _ = - Activity.instance.Start "FindBackgroundReferencesInFile" - [| - "Project", options.ProjectFileName - "UserOpName", userOpName - |] + Activity.instance.Start "FindBackgroundReferencesInFile" [| "Project", options.ProjectFileName; "UserOpName", userOpName |] + return! backgroundCompiler.GetSemanticClassificationForFile(fileName, options, userOpName) |> Async.AwaitNodeCode From 3133d0c92e61effb64a7b1888fe5bf01d10e99ee Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 5 Sep 2022 00:48:44 +0100 Subject: [PATCH 21/39] Update baseline --- ...mpilerService.SurfaceArea.netstandard.expected | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected index b808314ad58..a2b7b3ea1dc 100644 --- a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected +++ b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected @@ -2279,6 +2279,21 @@ FSharp.Compiler.DependencyManager.ResolvingErrorReport: System.IAsyncResult Begi FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void .ctor(System.Object, IntPtr) FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void EndInvoke(System.IAsyncResult) FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void Invoke(FSharp.Compiler.DependencyManager.ErrorReportType, Int32, System.String) +FSharp.Compiler.Diagnostics.Activity +FSharp.Compiler.Diagnostics.Activity+ActivityFacade: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[System.Diagnostics.Activity]) +FSharp.Compiler.Diagnostics.Activity+ActivityFacade: Void AddTag[?](System.String, ?) +FSharp.Compiler.Diagnostics.Activity+ActivityFacade: Void Dispose() +FSharp.Compiler.Diagnostics.Activity+ActivityFacade: Void Perform(Microsoft.FSharp.Core.FSharpFunc`2[System.Diagnostics.Activity,Microsoft.FSharp.Core.Unit]) +FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: ActivityFacade StartNoTags(System.String) +FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: ActivityFacade Start[?](System.String, System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.String,?]]) +FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: System.String Name +FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: System.String get_Name() +FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: Void .ctor(System.Diagnostics.ActivitySource) +FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: Void Dispose() +FSharp.Compiler.Diagnostics.Activity: ActivitySourceFacade get_instance() +FSharp.Compiler.Diagnostics.Activity: ActivitySourceFacade instance +FSharp.Compiler.Diagnostics.Activity: FSharp.Compiler.Diagnostics.Activity+ActivityFacade +FSharp.Compiler.Diagnostics.Activity: FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade FSharp.Compiler.Diagnostics.CompilerDiagnostics FSharp.Compiler.Diagnostics.CompilerDiagnostics: System.Collections.Generic.IEnumerable`1[System.String] GetSuggestedNames(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.Unit], System.String) FSharp.Compiler.Diagnostics.CompilerDiagnostics: System.String GetErrorMessage(FSharp.Compiler.Diagnostics.FSharpDiagnosticKind) From eabca75e1f4f1700284de237273e6c6f72a94e05 Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 5 Sep 2022 01:31:11 +0100 Subject: [PATCH 22/39] Fantomas formatting --- src/Compiler/Driver/ParseAndCheckInputs.fs | 5 ++++- src/Compiler/Service/FSharpCheckerResults.fs | 22 +++++++++++++++----- 2 files changed, 21 insertions(+), 6 deletions(-) diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index 8f98ee14480..1c69a149786 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -857,7 +857,10 @@ let ProcessMetaCommandsFromInput | ParsedHashDirective ("nowarn", ParsedHashDirectiveArguments numbers, m) -> List.fold (fun state d -> nowarnF state (m, d)) state numbers - | ParsedHashDirective (("reference" | "r"), ParsedHashDirectiveArguments args, m) -> + | ParsedHashDirective (("reference" + | "r"), + ParsedHashDirectiveArguments args, + m) -> matchedm <- m ProcessDependencyManagerDirective Directive.Resolution args m state diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs index b72907bcfd6..b25b1c4ca72 100644 --- a/src/Compiler/Service/FSharpCheckerResults.fs +++ b/src/Compiler/Service/FSharpCheckerResults.fs @@ -247,7 +247,9 @@ type FSharpSymbolUse(denv: DisplayEnv, symbol: FSharpSymbol, inst: TyparInstanti // 'seq' in 'seq { ... }' gets colored as keywords | Item.Value vref, ItemOccurence.Use when valRefEq denv.g denv.g.seq_vref vref -> true // custom builders, custom operations get colored as keywords - | (Item.CustomBuilder _ | Item.CustomOperation _), ItemOccurence.Use -> true + | (Item.CustomBuilder _ + | Item.CustomOperation _), + ItemOccurence.Use -> true | _ -> false member _.IsFromOpenStatement = itemOcc = ItemOccurence.Open @@ -2308,8 +2310,14 @@ module internal ParseAndCheckFile = matchBraces stackAfterMatch - | LPAREN | LBRACE _ | LBRACK | LBRACE_BAR | LBRACK_BAR | LQUOTE _ | LBRACK_LESS as tok, _ -> - matchBraces ((tok, lexbuf.LexemeRange) :: stack) + | LPAREN + | LBRACE _ + | LBRACK + | LBRACE_BAR + | LBRACK_BAR + | LQUOTE _ + | LBRACK_LESS as tok, + _ -> matchBraces ((tok, lexbuf.LexemeRange) :: stack) // INTERP_STRING_BEGIN_PART corresponds to $"... {" at the start of an interpolated string // @@ -2318,7 +2326,9 @@ module internal ParseAndCheckFile = // interpolation expression) // // Either way we start a new potential match at the last character - | INTERP_STRING_BEGIN_PART _ | INTERP_STRING_PART _ as tok, _ -> + | INTERP_STRING_BEGIN_PART _ + | INTERP_STRING_PART _ as tok, + _ -> let m = lexbuf.LexemeRange let m2 = @@ -2326,7 +2336,9 @@ module internal ParseAndCheckFile = matchBraces ((tok, m2) :: stack) - | (EOF _ | LEX_FAILURE _), _ -> () + | (EOF _ + | LEX_FAILURE _), + _ -> () | _ -> matchBraces stack matchBraces []) From 83dcc9769b484946f4ef302ea15862fef09e96ce Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 5 Sep 2022 20:55:48 +0100 Subject: [PATCH 23/39] Make the Activity module internal, remove from the surface --- src/Compiler/Facilities/Logger.fsi | 2 +- ...mpilerService.SurfaceArea.netstandard.expected | 15 --------------- 2 files changed, 1 insertion(+), 16 deletions(-) diff --git a/src/Compiler/Facilities/Logger.fsi b/src/Compiler/Facilities/Logger.fsi index 379ca9cddfd..73e8f443fe5 100644 --- a/src/Compiler/Facilities/Logger.fsi +++ b/src/Compiler/Facilities/Logger.fsi @@ -5,7 +5,7 @@ namespace FSharp.Compiler.Diagnostics open System open System.Diagnostics -module Activity = +module internal Activity = type ActivityFacade = interface IDisposable diff --git a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected index a2b7b3ea1dc..b808314ad58 100644 --- a/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected +++ b/tests/FSharp.Compiler.Service.Tests/FSharp.CompilerService.SurfaceArea.netstandard.expected @@ -2279,21 +2279,6 @@ FSharp.Compiler.DependencyManager.ResolvingErrorReport: System.IAsyncResult Begi FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void .ctor(System.Object, IntPtr) FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void EndInvoke(System.IAsyncResult) FSharp.Compiler.DependencyManager.ResolvingErrorReport: Void Invoke(FSharp.Compiler.DependencyManager.ErrorReportType, Int32, System.String) -FSharp.Compiler.Diagnostics.Activity -FSharp.Compiler.Diagnostics.Activity+ActivityFacade: Void .ctor(Microsoft.FSharp.Core.FSharpOption`1[System.Diagnostics.Activity]) -FSharp.Compiler.Diagnostics.Activity+ActivityFacade: Void AddTag[?](System.String, ?) -FSharp.Compiler.Diagnostics.Activity+ActivityFacade: Void Dispose() -FSharp.Compiler.Diagnostics.Activity+ActivityFacade: Void Perform(Microsoft.FSharp.Core.FSharpFunc`2[System.Diagnostics.Activity,Microsoft.FSharp.Core.Unit]) -FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: ActivityFacade StartNoTags(System.String) -FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: ActivityFacade Start[?](System.String, System.Collections.Generic.IEnumerable`1[System.Tuple`2[System.String,?]]) -FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: System.String Name -FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: System.String get_Name() -FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: Void .ctor(System.Diagnostics.ActivitySource) -FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade: Void Dispose() -FSharp.Compiler.Diagnostics.Activity: ActivitySourceFacade get_instance() -FSharp.Compiler.Diagnostics.Activity: ActivitySourceFacade instance -FSharp.Compiler.Diagnostics.Activity: FSharp.Compiler.Diagnostics.Activity+ActivityFacade -FSharp.Compiler.Diagnostics.Activity: FSharp.Compiler.Diagnostics.Activity+ActivitySourceFacade FSharp.Compiler.Diagnostics.CompilerDiagnostics FSharp.Compiler.Diagnostics.CompilerDiagnostics: System.Collections.Generic.IEnumerable`1[System.String] GetSuggestedNames(Microsoft.FSharp.Core.FSharpFunc`2[Microsoft.FSharp.Core.FSharpFunc`2[System.String,Microsoft.FSharp.Core.Unit],Microsoft.FSharp.Core.Unit], System.String) FSharp.Compiler.Diagnostics.CompilerDiagnostics: System.String GetErrorMessage(FSharp.Compiler.Diagnostics.FSharpDiagnosticKind) From 80459f929e6cdf33039aff3063a12cb6f9235587 Mon Sep 17 00:00:00 2001 From: janusz Date: Sat, 17 Sep 2022 16:39:14 +0100 Subject: [PATCH 24/39] Fix System.Diagnostics.DiagnosticSource package version --- src/Compiler/FSharp.Compiler.Service.fsproj | 2 ++ src/Compiler/FSharp.Compiler.Service.nuspec | 1 + 2 files changed, 3 insertions(+) diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index cda9116b0d8..b23c73f8018 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -57,6 +57,7 @@ + @@ -489,6 +490,7 @@ + diff --git a/src/Compiler/FSharp.Compiler.Service.nuspec b/src/Compiler/FSharp.Compiler.Service.nuspec index c7b55ebb613..ab4ad707bbb 100644 --- a/src/Compiler/FSharp.Compiler.Service.nuspec +++ b/src/Compiler/FSharp.Compiler.Service.nuspec @@ -11,6 +11,7 @@ + From a776c86f2097daf774a0402595dbb2609f1b057c Mon Sep 17 00:00:00 2001 From: Tomas Grosup Date: Mon, 10 Oct 2022 16:18:28 +0200 Subject: [PATCH 25/39] Tracing via dotnet ActivitySource --- src/Compiler/Checking/CheckDeclarations.fs | 9 +- src/Compiler/Driver/CompilerOptions.fs | 12 +- src/Compiler/Driver/ParseAndCheckInputs.fs | 5 +- src/Compiler/Driver/fsc.fs | 28 ----- src/Compiler/Facilities/BuildGraph.fs | 9 +- src/Compiler/Facilities/BuildGraph.fsi | 3 +- src/Compiler/Facilities/Logger.fs | 114 ++----------------- src/Compiler/Facilities/Logger.fsi | 48 +------- src/Compiler/Service/FSharpCheckerResults.fs | 4 +- src/Compiler/Service/IncrementalBuild.fs | 27 ++--- src/Compiler/Service/service.fs | 112 ++++++++++-------- 11 files changed, 109 insertions(+), 262 deletions(-) diff --git a/src/Compiler/Checking/CheckDeclarations.fs b/src/Compiler/Checking/CheckDeclarations.fs index f2e00c12928..56c7d6e2b9b 100644 --- a/src/Compiler/Checking/CheckDeclarations.fs +++ b/src/Compiler/Checking/CheckDeclarations.fs @@ -5173,7 +5173,12 @@ let CheckOneImplFile let infoReader = InfoReader(g, amap) cancellable { - use _ = Activity.instance.Start "CheckOneImplFile" [|"fileName", fileName; "qualifiedNameOfFile", qualNameOfFile.Text|] + use _ = + Activity.Start "CheckDeclarations.CheckOneImplFile" + [| + "fileName", fileName + "qualifiedNameOfFile", qualNameOfFile.Text + |] let cenv = cenv.Create (g, isScript, niceNameGen, amap, thisCcu, false, Option.isSome rootSigOpt, conditionalDefines, tcSink, (LightweightTcValForUsingInBuildMethodCall g), isInternalTestSpanStackReferring, @@ -5302,7 +5307,7 @@ let CheckOneImplFile let CheckOneSigFile (g, niceNameGen, amap, thisCcu, checkForErrors, conditionalDefines, tcSink, isInternalTestSpanStackReferring) tcEnv (ParsedSigFileInput (fileName = fileName; qualifiedNameOfFile = qualNameOfFile; modules = sigFileFrags)) = cancellable { use _ = - Activity.instance.Start "CheckOneSigFile" + Activity.Start "CheckDeclarations.CheckOneSigFile" [| "fileName", fileName "qualifiedNameOfFile", qualNameOfFile.Text diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs index 2a950193cc1..8c6ddc27849 100644 --- a/src/Compiler/Driver/CompilerOptions.fs +++ b/src/Compiler/Driver/CompilerOptions.fs @@ -2304,13 +2304,13 @@ let PrintWholeAssemblyImplementation (tcConfig: TcConfig) outfile header expr = //---------------------------------------------------------------------------- let mutable tPrev: (DateTime * DateTime * float * int[]) option = None -let mutable nPrev: string option = None - -let ReportTime (tcConfig: TcConfig) descr = +let mutable nPrev: (string * IDisposable) option = None +let ReportTime (tcConfig: TcConfig) descr = match nPrev with | None -> () - | Some prevDescr -> + | Some (prevDescr,prevActivity) -> + use _ = prevActivity // Finish the previous diagnostics activity by .Dispose() at the end of this block if tcConfig.pause then dprintf "[done '%s', entering '%s'] press to continue... " prevDescr descr Console.ReadLine() |> ignore @@ -2349,7 +2349,7 @@ let ReportTime (tcConfig: TcConfig) descr = let tStart = match tPrev, nPrev with - | Some (tStart, tPrev, utPrev, gcPrev), Some prevDescr -> + | Some (tStart, tPrev, utPrev, gcPrev), Some (prevDescr, _) -> let spanGC = [| for i in 0..maxGen -> GC.CollectionCount i - gcPrev[i] |] let t = tNow - tStart let tDelta = tNow - tPrev @@ -2376,7 +2376,7 @@ let ReportTime (tcConfig: TcConfig) descr = tPrev <- Some(tStart, tNow, utNow, gcNow) - nPrev <- Some descr + nPrev <- Some (descr, Activity.StartNoTags descr) let ignoreFailureOnMono1_1_16 f = try diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index 33a5c08a031..78503b2691b 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -1138,7 +1138,7 @@ let CheckOneInput cancellable { try - use _ = Activity.instance.Start "CheckOneInput" [| "inputName", inp.FileName |] + use _ = Activity.Start "ParseAndCheckInputs.CheckOneInput" [| "inputName", inp.FileName |] CheckSimulateException tcConfig @@ -1320,10 +1320,8 @@ let CheckMultipleInputsFinish (results, tcState: TcState) = let CheckOneInputAndFinish (checkForErrors, tcConfig: TcConfig, tcImports, tcGlobals, prefixPathOpt, tcSink, tcState, input) = cancellable { - Logger.LogBlockStart LogCompilerFunctionId.CompileOps_TypeCheckOneInputAndFinishEventually let! results, tcState = CheckOneInput(checkForErrors, tcConfig, tcImports, tcGlobals, prefixPathOpt, tcSink, tcState, input, false) let result = CheckMultipleInputsFinish([ results ], tcState) - Logger.LogBlockStop LogCompilerFunctionId.CompileOps_TypeCheckOneInputAndFinishEventually return result } @@ -1341,7 +1339,6 @@ let CheckClosedInputSetFinish (declaredImpls: CheckedImplFile list, tcState) = tcState, declaredImpls, ccuContents let CheckClosedInputSet (ctok, checkForErrors, tcConfig, tcImports, tcGlobals, prefixPathOpt, tcState, inputs) = - use tcActivity = Activity.instance.StartNoTags("CheckClosedInputSet") // tcEnvAtEndOfLastFile is the environment required by fsi.exe when incrementally adding definitions let results, tcState = (tcState, inputs) diff --git a/src/Compiler/Driver/fsc.fs b/src/Compiler/Driver/fsc.fs index 0e9186b9311..6d784400953 100644 --- a/src/Compiler/Driver/fsc.fs +++ b/src/Compiler/Driver/fsc.fs @@ -166,9 +166,6 @@ let TypeCheck inputs, exiter: Exiter ) = - use _ = - Activity.instance.Start "typecheck_inputs" [| "assemblyName", assemblyName |] - try if isNil inputs then error (Error(FSComp.SR.fscNoImplementationFiles (), rangeStartup)) @@ -478,8 +475,6 @@ let main1 disposables: DisposablesTracker ) = - use mainActivity = new Activity("main") - // See Bug 735819 let lcidFromCodePage = if @@ -536,8 +531,6 @@ let main1 // Process command line, flags and collect filenames let sourceFiles = - use parseActivity = Activity.instance.StartNoTags("determine_source_files") - // The ParseCompilerOptions function calls imperative function to process "real" args // Rather than start processing, just collect names, then process them. try @@ -570,8 +563,6 @@ let main1 // If there's a problem building TcConfig, abort let tcConfig = - use createConfigActivity = Activity.instance.StartNoTags("create_tc_config") - try TcConfig.Create(tcConfigB, validate = false) with e -> @@ -596,14 +587,10 @@ let main1 let foundationalTcConfigP = TcConfigProvider.Constant tcConfig let sysRes, otherRes, knownUnresolved = - use splitResolutionsActivity = Activity.instance.StartNoTags("split_resolutions") TcAssemblyResolutions.SplitNonFoundationalResolutions(tcConfig) // Import basic assemblies let tcGlobals, frameworkTcImports = - use frameworkImportsActivity = - Activity.instance.StartNoTags("import_framework_references") - TcImports.BuildFrameworkTcImports(foundationalTcConfigP, sysRes, otherRes) |> NodeCode.RunImmediateWithoutCancellation @@ -656,9 +643,6 @@ let main1 ReportTime tcConfig "Import non-system references" let tcImports = - use nonFrameworkImportsActivity = - Activity.instance.StartNoTags("import_non_framework_references") - TcImports.BuildNonFrameworkTcImports(tcConfigP, frameworkTcImports, otherRes, knownUnresolved, dependencyProvider) |> NodeCode.RunImmediateWithoutCancellation @@ -677,7 +661,6 @@ let main1 use unwindParsePhase = PushThreadBuildPhaseUntilUnwind BuildPhase.TypeCheck let tcEnv0, openDecls0 = - use initialTcEnvActivity = Activity.instance.StartNoTags("get_initial_tc_env") GetInitialTcEnv(assemblyName, rangeStartup, tcConfig, tcImports, tcGlobals) // Type check the inputs @@ -738,8 +721,6 @@ let main1OfAst inputs: ParsedInput list ) = - use main1AstActivity = Activity.instance.StartNoTags("main1_of_ast") - let tryGetMetadataSnapshot = (fun _ -> None) let directoryBuildingFrom = Directory.GetCurrentDirectory() @@ -924,8 +905,6 @@ let main2 exiter: Exiter, ilSourceDocs)) = - use main2Activity = Activity.instance.StartNoTags("main2") - if tcConfig.typeCheckOnly then exiter.Exit 0 @@ -1033,7 +1012,6 @@ let main3 exiter: Exiter, ilSourceDocs)) = - use main3Activity = Activity.instance.StartNoTags("main3") // Encode the signature data ReportTime tcConfig "Encode Interface Data" let exportRemapping = MakeExportRemapping generatedCcu generatedCcu.Contents @@ -1129,8 +1107,6 @@ let main4 exiter: Exiter, ilSourceDocs)) = - use main4Activity = Activity.instance.StartNoTags("main4") - match tcImportsCapture with | None -> () | Some f -> f tcImports @@ -1233,8 +1209,6 @@ let main5 exiter: Exiter, ilSourceDocs)) = - use main5Activity = Activity.instance.StartNoTags("main5") - use unwindBuildPhase = PushThreadBuildPhaseUntilUnwind BuildPhase.Output // Static linking, if any @@ -1266,8 +1240,6 @@ let main6 exiter: Exiter, ilSourceDocs)) = - use main6Activity = Activity.instance.StartNoTags("main6") - ReportTime tcConfig "Write .NET Binary" use unwindBuildPhase = PushThreadBuildPhaseUntilUnwind BuildPhase.Output diff --git a/src/Compiler/Facilities/BuildGraph.fs b/src/Compiler/Facilities/BuildGraph.fs index e32a14ae886..cc6d75559f0 100644 --- a/src/Compiler/Facilities/BuildGraph.fs +++ b/src/Compiler/Facilities/BuildGraph.fs @@ -7,7 +7,6 @@ open System.Threading open System.Threading.Tasks open System.Diagnostics open System.Globalization -open FSharp.Compiler.Diagnostics.Activity open FSharp.Compiler.DiagnosticsLogger open Internal.Utilities.Library @@ -108,13 +107,11 @@ type NodeCodeBuilder() = ) [] - member _.Using(value: ActivityFacade, binder: ActivityFacade -> NodeCode<'U>) = + member _.Using(value: IDisposable, binder: IDisposable -> NodeCode<'U>) = Node( async { - try - return! binder value |> Async.AwaitNodeCode - finally - (value :> IDisposable).Dispose() + use _ = value + return! binder value |> Async.AwaitNodeCode } ) diff --git a/src/Compiler/Facilities/BuildGraph.fsi b/src/Compiler/Facilities/BuildGraph.fsi index 2620c2eb296..673517fe50d 100644 --- a/src/Compiler/Facilities/BuildGraph.fsi +++ b/src/Compiler/Facilities/BuildGraph.fsi @@ -6,7 +6,6 @@ open System open System.Diagnostics open System.Threading open System.Threading.Tasks -open FSharp.Compiler.Diagnostics.Activity open FSharp.Compiler.DiagnosticsLogger open Internal.Utilities.Library @@ -49,7 +48,7 @@ type NodeCodeBuilder = /// that a proper generic 'use' could be implemented but has not currently been necessary) member Using: CompilationGlobalsScope * (CompilationGlobalsScope -> NodeCode<'T>) -> NodeCode<'T> - member Using: ActivityFacade * (ActivityFacade -> NodeCode<'T>) -> NodeCode<'T> + member Using: IDisposable * (IDisposable -> NodeCode<'T>) -> NodeCode<'T> /// Specifies code that can be run as part of the build graph. val node: NodeCodeBuilder diff --git a/src/Compiler/Facilities/Logger.fs b/src/Compiler/Facilities/Logger.fs index 76fd3f2d897..9852cab6d7d 100644 --- a/src/Compiler/Facilities/Logger.fs +++ b/src/Compiler/Facilities/Logger.fs @@ -6,113 +6,15 @@ open System open System.Diagnostics open System.Diagnostics.Tracing -module Activity = - - type ActivityFacade(activity : Activity option) = - member this.AddTag key (value : #obj) = match activity with | Some activity -> activity.AddTag(key, value) |> ignore | None -> () - member this.Perform action = match activity with | Some activity -> action activity | None -> () - member this.Dispose() = match activity with | Some activity -> activity.Dispose() | None -> () - interface IDisposable with - member this.Dispose() = this.Dispose() - - let start (source : ActivitySource) (activityName : string) (tags : (string * #obj) seq) = - let activity = source.StartActivity(activityName) |> Option.ofObj - let facade = new ActivityFacade(activity) - for key, value in tags do - facade.AddTag key value - facade - - let startNoTags (source : ActivitySource) (activityName : string) = start source activityName [] - - type ActivitySourceFacade(source : ActivitySource) = - member this.Start (name : string) (tags : (string * #obj) seq) = start source name tags - member this.StartNoTags name = startNoTags source name - member this.Name = source.Name - member this.Dispose() = source.Dispose() - interface IDisposable with - member this.Dispose() = this.Dispose() - - let private activitySourceName = "fsc" - let private activitySource = new ActivitySource(activitySourceName) - let instance = new ActivitySourceFacade(activitySource) - -type LogCompilerFunctionId = - | Service_ParseAndCheckFileInProject = 1 - | Service_CheckOneFile = 2 - | Service_IncrementalBuildersCache_BuildingNewCache = 3 - | Service_IncrementalBuildersCache_GettingCache = 4 - | CompileOps_TypeCheckOneInputAndFinishEventually = 5 - | IncrementalBuild_CreateItemKeyStoreAndSemanticClassification = 6 - | IncrementalBuild_TypeCheck = 7 - -/// This is for ETW tracing across FSharp.Compiler. -[] -type FSharpCompilerEventSource() = - inherit EventSource() - - static let instance = new FSharpCompilerEventSource() - static member Instance = instance - - [] - member this.Log(functionId: LogCompilerFunctionId) = - if this.IsEnabled() then this.WriteEvent(1, int functionId) - - [] - member this.LogMessage(message: string, functionId: LogCompilerFunctionId) = - if this.IsEnabled() then - this.WriteEvent(2, message, int functionId) - - [] - member this.BlockStart(functionId: LogCompilerFunctionId) = - if this.IsEnabled() then this.WriteEvent(3, int functionId) - - [] - member this.BlockStop(functionId: LogCompilerFunctionId) = - if this.IsEnabled() then this.WriteEvent(4, int functionId) - - [] - member this.BlockMessageStart(message: string, functionId: LogCompilerFunctionId) = - if this.IsEnabled() then - this.WriteEvent(5, message, int functionId) - - [] - member this.BlockMessageStop(message: string, functionId: LogCompilerFunctionId) = - if this.IsEnabled() then - this.WriteEvent(6, message, int functionId) - [] -module Logger = - - let Log functionId = - FSharpCompilerEventSource.Instance.Log(functionId) - - let LogMessage message functionId = - FSharpCompilerEventSource.Instance.LogMessage(message, functionId) - - let LogBlockStart functionId = - FSharpCompilerEventSource.Instance.BlockStart(functionId) - - let LogBlockStop functionId = - FSharpCompilerEventSource.Instance.BlockStop(functionId) - - let LogBlockMessageStart message functionId = - FSharpCompilerEventSource.Instance.BlockMessageStart(message, functionId) - - let LogBlockMessageStop message functionId = - FSharpCompilerEventSource.Instance.BlockMessageStop(message, functionId) - - let LogBlock functionId = - FSharpCompilerEventSource.Instance.BlockStart(functionId) +module Activity = - { new IDisposable with - member _.Dispose() = - FSharpCompilerEventSource.Instance.BlockStop(functionId) - } + let private activitySource = new ActivitySource("fsc") - let LogBlockMessage message functionId = - FSharpCompilerEventSource.Instance.BlockMessageStart(message, functionId) + let Start name (tags:(string * #obj) seq) : IDisposable = + let act = activitySource.StartActivity(name) + for key,value in tags do + act.AddTag(key,value) |> ignore + act - { new IDisposable with - member _.Dispose() = - FSharpCompilerEventSource.Instance.BlockMessageStop(message, functionId) - } + let StartNoTags name: IDisposable = activitySource.StartActivity(name) \ No newline at end of file diff --git a/src/Compiler/Facilities/Logger.fsi b/src/Compiler/Facilities/Logger.fsi index 73e8f443fe5..58215ac80f5 100644 --- a/src/Compiler/Facilities/Logger.fsi +++ b/src/Compiler/Facilities/Logger.fsi @@ -5,49 +5,11 @@ namespace FSharp.Compiler.Diagnostics open System open System.Diagnostics -module internal Activity = - - type ActivityFacade = - interface IDisposable - new: Activity option -> ActivityFacade - member AddTag: string -> #obj -> unit - member Perform: (Activity -> unit) -> unit - member Dispose: unit -> unit - - type ActivitySourceFacade = - interface IDisposable - new: ActivitySource -> ActivitySourceFacade - member Start: string -> (string * #obj) seq -> ActivityFacade - member StartNoTags: string -> ActivityFacade - member Name: string - member Dispose: unit -> unit - - val instance: ActivitySourceFacade - -type internal LogCompilerFunctionId = - | Service_ParseAndCheckFileInProject = 1 - | Service_CheckOneFile = 2 - | Service_IncrementalBuildersCache_BuildingNewCache = 3 - | Service_IncrementalBuildersCache_GettingCache = 4 - | CompileOps_TypeCheckOneInputAndFinishEventually = 5 - | IncrementalBuild_CreateItemKeyStoreAndSemanticClassification = 6 - | IncrementalBuild_TypeCheck = 7 - +/// For activities following the dotnet distributed tracing concept +/// https://learn.microsoft.com/en-us/dotnet/core/diagnostics/distributed-tracing-concepts?source=recommendations [] -module internal Logger = - - val Log: LogCompilerFunctionId -> unit - - val LogMessage: message: string -> LogCompilerFunctionId -> unit - - val LogBlockStart: LogCompilerFunctionId -> unit - - val LogBlockStop: LogCompilerFunctionId -> unit - - val LogBlockMessageStart: message: string -> LogCompilerFunctionId -> unit - - val LogBlockMessageStop: message: string -> LogCompilerFunctionId -> unit +module internal Activity = - val LogBlock: LogCompilerFunctionId -> IDisposable + val StartNoTags: name: string -> IDisposable - val LogBlockMessage: message: string -> LogCompilerFunctionId -> IDisposable + val Start: name: string -> tags: (string * #obj) seq -> IDisposable \ No newline at end of file diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs index b25b1c4ca72..731f820ce60 100644 --- a/src/Compiler/Service/FSharpCheckerResults.fs +++ b/src/Compiler/Service/FSharpCheckerResults.fs @@ -2347,7 +2347,7 @@ module internal ParseAndCheckFile = let parseFile (sourceText: ISourceText, fileName, options: FSharpParsingOptions, userOpName: string, suggestNamesForErrors: bool) = Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "parseFile", fileName) - use act = Activity.instance.Start "parseFile" [| "fileName", fileName |] + use act = Activity.Start "ParseAndCheckFile.parseFile" [| "fileName", fileName |] let errHandler = ErrorHandler(true, fileName, options.DiagnosticOptions, sourceText, suggestNamesForErrors) @@ -2504,7 +2504,7 @@ module internal ParseAndCheckFile = ) = cancellable { - use _logBlock = Logger.LogBlock LogCompilerFunctionId.Service_CheckOneFile + use _ = Activity.Start "ParseAndCheckFile.CheckOneFile" [| "mainInputFileName", mainInputFileName; "Length", sourceText.Length.ToString() |] let parsedMainInput = parseResults.ParseTree diff --git a/src/Compiler/Service/IncrementalBuild.fs b/src/Compiler/Service/IncrementalBuild.fs index 66d338a1b2b..4b5807c879b 100644 --- a/src/Compiler/Service/IncrementalBuild.fs +++ b/src/Compiler/Service/IncrementalBuild.fs @@ -116,12 +116,7 @@ module IncrementalBuildSyntaxTree = let mutable weakCache: WeakReference<_> option = None let parse(sigNameOpt: QualifiedNameOfFile option) = - use act = - Activity.instance.Start "SyntaxTree.parse" - [| - "fileName", source.FilePath - "buildPhase", BuildPhase.Parse.ToString() - |] + let diagnosticsLogger = CompilationDiagnosticLogger("Parse", tcConfig.diagnosticsOptions) // Return the disposable object that cleans up use _holder = new CompilationGlobalsScope(diagnosticsLogger, BuildPhase.Parse) @@ -129,7 +124,13 @@ module IncrementalBuildSyntaxTree = try IncrementalBuilderEventTesting.MRU.Add(IncrementalBuilderEventTesting.IBEParsed fileName) let canSkip = sigNameOpt.IsSome && FSharpImplFileSuffixes |> List.exists (FileSystemUtils.checkSuffix fileName) - act.AddTag "canSkip" canSkip + use act = + Activity.Start "IncrementalBuildSyntaxTree.parse" + [| + "fileName", source.FilePath + "buildPhase", BuildPhase.Parse.ToString() + "canSkip", canSkip.ToString() + |] let input = if canSkip then ParsedInput.ImplFile( @@ -472,7 +473,7 @@ type BoundModel private (tcConfig: TcConfig, let! res = defaultTypeCheck () return res | Some syntaxTree -> - use _ = Activity.instance.Start "TypeCheck" [|"fileName", syntaxTree.FileName|] + use _ = Activity.Start "BoundModel.TypeCheck" [|"fileName", syntaxTree.FileName|] let sigNameOpt = if partialCheck then this.BackingSignature @@ -497,8 +498,6 @@ type BoundModel private (tcConfig: TcConfig, let hadParseErrors = not (Array.isEmpty parseErrors) let input, moduleNamesDict = DeduplicateParsedInputModuleName prevModuleNamesDict input - Logger.LogBlockMessageStart fileName LogCompilerFunctionId.IncrementalBuild_TypeCheck - let! (tcEnvAtEndOfFile, topAttribs, implFile, ccuSigForFile), tcState = CheckOneInput ((fun () -> hadParseErrors || diagnosticsLogger.ErrorCount > 0), @@ -510,9 +509,6 @@ type BoundModel private (tcConfig: TcConfig, partialCheck) |> NodeCode.FromCancellable - use _ = Activity.instance.StartNoTags("TypeCheck_BuildState") - Logger.LogBlockMessageStop fileName LogCompilerFunctionId.IncrementalBuild_TypeCheck - fileChecked.Trigger fileName let newErrors = Array.append parseErrors (capturingDiagnosticsLogger.Diagnostics |> List.toArray) let tcEnvAtEndOfFile = if keepAllBackgroundResolutions then tcEnvAtEndOfFile else tcState.TcEnvFromImpls @@ -540,7 +536,7 @@ type BoundModel private (tcConfig: TcConfig, // Build symbol keys let itemKeyStore, semanticClassification = if enableBackgroundItemKeyStoreAndSemanticClassification then - Logger.LogBlockMessageStart fileName LogCompilerFunctionId.IncrementalBuild_CreateItemKeyStoreAndSemanticClassification + use _ = Activity.Start "IncrementalBuild.CreateItemKeyStoreAndSemanticClassification" [|"fileName",fileName|] let sResolutions = sink.GetResolutions() let builder = ItemKeyStoreBuilder() let preventDuplicates = HashSet({ new IEqualityComparer with @@ -558,7 +554,6 @@ type BoundModel private (tcConfig: TcConfig, sckBuilder.WriteAll semanticClassification let res = builder.TryBuildAndReset(), sckBuilder.TryBuildAndReset() - Logger.LogBlockMessageStop fileName LogCompilerFunctionId.IncrementalBuild_CreateItemKeyStoreAndSemanticClassification res else None, None @@ -1047,7 +1042,7 @@ module IncrementalBuilderStateHelpers = let rec createFinalizeBoundModelGraphNode (initialState: IncrementalBuilderInitialState) (boundModels: ImmutableArray>.Builder) = GraphNode(node { - use _ = Activity.instance.Start "GetCheckResultsAndImplementationsForProject" [|"projectOutFile", initialState.outfile|] + use _ = Activity.Start "GetCheckResultsAndImplementationsForProject" [|"projectOutFile", initialState.outfile|] // Compute last bound model then get all the evaluated models. let! _ = boundModels[boundModels.Count - 1].GetOrComputeValue() let boundModels = diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index 5fafdc544c2..6ac04d1ff92 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -390,7 +390,7 @@ type BackgroundCompiler /// creates an incremental builder used by the command line compiler. let CreateOneIncrementalBuilder (options: FSharpProjectOptions, userOpName) = node { - use _ = Activity.instance.Start "CreateOneIncrementalBuilder" [| "project", options.ProjectFileName |] + use _ = Activity.Start "BackgroundCompiler.CreateOneIncrementalBuilder" [| "project", options.ProjectFileName |] Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "CreateOneIncrementalBuilder", options.ProjectFileName) let projectReferences = getProjectReferences options userOpName @@ -518,7 +518,6 @@ type BackgroundCompiler node { match! getBuilder with | builderOpt, creationDiags when builderOpt.IsNone || not builderOpt.Value.IsReferencesInvalidated -> - Logger.Log LogCompilerFunctionId.Service_IncrementalBuildersCache_GettingCache return builderOpt, creationDiags | _ -> // The builder could be re-created, @@ -549,9 +548,7 @@ type BackgroundCompiler let getAnyBuilder (options, userOpName) = match tryGetAnyBuilder options with - | Some getBuilder -> - Logger.Log LogCompilerFunctionId.Service_IncrementalBuildersCache_GettingCache - getBuilder + | Some getBuilder -> getBuilder | _ -> getOrCreateBuilder (options, userOpName) static let mutable actualParseFileCount = 0 @@ -582,8 +579,7 @@ type BackgroundCompiler member _.ParseFile(fileName: string, sourceText: ISourceText, options: FSharpParsingOptions, cache: bool, userOpName: string) = async { - use _ = - Activity.instance.Start "CompileToDynamicAssembly1" [| "filename", fileName; "UserOpName", userOpName |] + use _ = Activity.Start "BackgroundCompiler.ParseFile" [| "filename", fileName; "UserOpName", userOpName; "cache", cache.ToString() |] if cache then let hash = sourceText.GetHashCode() |> int64 @@ -609,6 +605,7 @@ type BackgroundCompiler /// Fetch the parse information from the background compiler (which checks w.r.t. the FileSystem API) member _.GetBackgroundParseResultsForFileInProject(fileName, options, userOpName) = node { + use _ = Activity.Start "BackgroundCompiler.GetBackgroundParseResultsForFileInProject" [| "filename", fileName; "UserOpName", userOpName |] let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) match builderOpt with @@ -636,6 +633,7 @@ type BackgroundCompiler member _.GetCachedCheckFileResult(builder: IncrementalBuilder, fileName, sourceText: ISourceText, options) = node { + use _ = Activity.Start "BackgroundCompiler.GetCachedCheckFileResult" [| "filename", fileName |] let hash = sourceText.GetHashCode() |> int64 let key = (fileName, hash, options) let cachedResultsOpt = parseCacheLock.AcquireLock(fun ltok -> checkFileInProjectCache.TryGet(ltok, key)) @@ -739,8 +737,8 @@ type BackgroundCompiler ) = node { use _ = - Activity.instance.Start - "CheckFileInProjectAllowingStaleCachedResults" + Activity.Start + "BackgroundCompiler.CheckFileInProjectAllowingStaleCachedResults" [| "Project", options.ProjectFileName "filename", fileName @@ -781,8 +779,8 @@ type BackgroundCompiler member bc.CheckFileInProject(parseResults: FSharpParseFileResults, fileName, fileVersion, sourceText: ISourceText, options, userOpName) = node { use _ = - Activity.instance.Start - "CheckFileInProject" + Activity.Start + "BackgroundCompiler.CheckFileInProject" [| "project", options.ProjectFileName "fileName", fileName @@ -809,17 +807,18 @@ type BackgroundCompiler member bc.ParseAndCheckFileInProject(fileName: string, fileVersion, sourceText: ISourceText, options: FSharpProjectOptions, userOpName) = node { use _ = - Activity.instance.Start "Service_ParseAndCheckFileInProject" [| "project", options.ProjectFileName; "fileName", fileName |] - - let strGuid = "_ProjectId=" + (options.ProjectId |> Option.defaultValue "null") - Logger.LogBlockMessageStart (fileName + strGuid) LogCompilerFunctionId.Service_ParseAndCheckFileInProject + Activity.Start + "BackgroundCompiler.ParseAndCheckFileInProject" + [| + "project", options.ProjectFileName + "fileName", fileName + "userOpName", userOpName + |] let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) match builderOpt with | None -> - Logger.LogBlockMessageStop (fileName + strGuid + "-Failed_Aborted") LogCompilerFunctionId.Service_ParseAndCheckFileInProject - let parseTree = EmptyParsedInput(fileName, (false, false)) let parseResults = FSharpParseFileResults(creationDiags, parseTree, true, [||]) return (parseResults, FSharpCheckFileAnswer.Aborted) @@ -829,8 +828,6 @@ type BackgroundCompiler match cachedResults with | Some (parseResults, checkResults) -> - Logger.LogBlockMessageStop (fileName + strGuid + "-Successful_Cached") LogCompilerFunctionId.Service_ParseAndCheckFileInProject - return (parseResults, FSharpCheckFileAnswer.Succeeded checkResults) | _ -> let! tcPrior = builder.GetCheckResultsBeforeFileInProject fileName @@ -850,14 +847,21 @@ type BackgroundCompiler let! checkResults = bc.CheckOneFileImpl(parseResults, sourceText, fileName, options, fileVersion, builder, tcPrior, tcInfo, creationDiags) - Logger.LogBlockMessageStop (fileName + strGuid + "-Successful") LogCompilerFunctionId.Service_ParseAndCheckFileInProject - return (parseResults, checkResults) } /// Fetch the check information from the background compiler (which checks w.r.t. the FileSystem API) member _.GetBackgroundCheckResultsForFileInProject(fileName, options, userOpName) = node { + use _ = + Activity.Start + "BackgroundCompiler.ParseAndCheckFileInProject" + [| + "project", options.ProjectFileName + "fileName", fileName + "userOpName", userOpName + |] + let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) match builderOpt with @@ -941,6 +945,15 @@ type BackgroundCompiler userOpName: string ) = node { + use _ = + Activity.Start + "BackgroundCompiler.FindReferencesInFile" + [| + "project", options.ProjectFileName + "fileName", fileName + "userOpName", userOpName + "symbol", symbol.FullName + |] let! builderOpt, _ = getOrCreateBuilderWithInvalidationFlag (options, canInvalidateProject, userOpName) match builderOpt with @@ -959,6 +972,14 @@ type BackgroundCompiler member _.GetSemanticClassificationForFile(fileName: string, options: FSharpProjectOptions, userOpName: string) = node { + use _ = + Activity.Start + "BackgroundCompiler.GetSemanticClassificationForFile" + [| + "project", options.ProjectFileName + "fileName", fileName + "userOpName", userOpName + |] let! builderOpt, _ = getOrCreateBuilder (options, userOpName) match builderOpt with @@ -974,6 +995,14 @@ type BackgroundCompiler /// Try to get recent approximate type check results for a file. member _.TryGetRecentCheckResultsForFile(fileName: string, options: FSharpProjectOptions, sourceText: ISourceText option, _userOpName: string) = + use _ = + Activity.Start + "BackgroundCompiler.GetSemanticClassificationForFile" + [| + "project", options.ProjectFileName + "fileName", fileName + "userOpName", _userOpName + |] match sourceText with | Some sourceText -> let hash = sourceText.GetHashCode() |> int64 @@ -1046,6 +1075,7 @@ type BackgroundCompiler member _.GetAssemblyData(options, userOpName) = node { + use _ = Activity.Start "BackgroundCompiler.GetAssemblyData" [|"project", options.ProjectFileName; "userOpName", userOpName |] let! builderOpt, _ = getOrCreateBuilder (options, userOpName) match builderOpt with @@ -1066,6 +1096,7 @@ type BackgroundCompiler /// Parse and typecheck the whole project. member bc.ParseAndCheckProject(options, userOpName) = + use _ = Activity.Start "BackgroundCompiler.ParseAndCheckProject" [| "project", options.ProjectFileName; "userOpName", userOpName |] bc.ParseAndCheckProjectImpl(options, userOpName) member _.GetProjectOptionsFromScript @@ -1082,6 +1113,7 @@ type BackgroundCompiler optionsStamp: int64 option, _userOpName ) = + use _ = Activity.Start "BackgroundCompiler.GetProjectOptionsFromScript" [| "fileName", fileName; "userOpName", _userOpName |] cancellable { use diagnostics = new DiagnosticsScope() @@ -1166,6 +1198,7 @@ type BackgroundCompiler |> Cancellable.toAsync member bc.InvalidateConfiguration(options: FSharpProjectOptions, userOpName) = + use _ = Activity.Start "BackgroundCompiler.InvalidateConfiguration" [| "project", options.ProjectFileName; "userOpName", userOpName |] if incrementalBuildersCache.ContainsSimilarKey(AnyCallerThread, options) then parseCacheLock.AcquireLock(fun ltok -> for sourceFile in options.SourceFiles do @@ -1175,11 +1208,13 @@ type BackgroundCompiler () member bc.ClearCache(options: seq, _userOpName) = + use _ = Activity.Start "BackgroundCompiler.ClearCache" [| "userOpName", _userOpName |] lock gate (fun () -> options |> Seq.iter (fun options -> incrementalBuildersCache.RemoveAnySimilar(AnyCallerThread, options))) member _.NotifyProjectCleaned(options: FSharpProjectOptions, userOpName) = + use _ = Activity.Start "BackgroundCompiler.NotifyProjectCleaned" [| "project", options.ProjectFileName; "userOpName", userOpName |] async { let! ct = Async.CancellationToken // If there was a similar entry (as there normally will have been) then re-establish an empty builder . This @@ -1199,6 +1234,7 @@ type BackgroundCompiler member _.ProjectChecked = projectChecked.Publish member _.ClearCaches() = + use _ = Activity.StartNoTags "BackgroundCompiler.ClearCaches" lock gate (fun () -> parseCacheLock.AcquireLock(fun ltok -> checkFileInProjectCache.Clear(ltok) @@ -1209,6 +1245,7 @@ type BackgroundCompiler scriptClosureCache.Clear AnyCallerThread) member _.DownsizeCaches() = + use _ = Activity.StartNoTags "BackgroundCompiler.DownsizeCaches" lock gate (fun () -> parseCacheLock.AcquireLock(fun ltok -> checkFileInProjectCache.Resize(ltok, newKeepStrongly = 1) @@ -1275,6 +1312,7 @@ type FSharpChecker ?enablePartialTypeChecking ) = + use _ = Activity.StartNoTags "FSharpChecker.Create" let legacyReferenceResolver = match legacyReferenceResolver with | Some rr -> rr @@ -1311,6 +1349,7 @@ type FSharpChecker member _.MatchBraces(fileName, sourceText: ISourceText, options: FSharpParsingOptions, ?userOpName: string) = let userOpName = defaultArg userOpName "Unknown" + use _ = Activity.Start "FSharpChecker.MatchBraces" [| "fileName", fileName; "userOpName", userOpName |] let hash = sourceText.GetHashCode() |> int64 async { @@ -1362,7 +1401,7 @@ type FSharpChecker member _.Compile(argv: string[], ?userOpName: string) = let _userOpName = defaultArg userOpName "Unknown" - + use _ = Activity.Start "FSharpChecker.Compile" [| "userOpName", _userOpName |] async { let ctok = CompilationThreadToken() return CompileHelpers.compileFromArgs (ctok, argv, legacyReferenceResolver, None, None) @@ -1405,7 +1444,7 @@ type FSharpChecker let _userOpName = defaultArg userOpName "Unknown" async { - use _ = Activity.instance.Start "CompileToDynamicAssembly1" [| "UserOpName", _userOpName |] + use _ = Activity.Start "CompileToDynamicAssembly1" [| "UserOpName", _userOpName |] let ctok = CompilationThreadToken() CompileHelpers.setOutputStreams execute @@ -1449,7 +1488,7 @@ type FSharpChecker async { use _ = - Activity.instance.Start "CompileToDynamicAssembly2" [| "Assembly", assemblyName; "UserOpName", _userOpName |] + Activity.Start "CompileToDynamicAssembly2" [| "Assembly", assemblyName; "UserOpName", _userOpName |] let ctok = CompilationThreadToken() CompileHelpers.setOutputStreams execute @@ -1503,7 +1542,7 @@ type FSharpChecker /// For example, the type provider approvals file may have changed. member ic.InvalidateAll() = ic.ClearCaches() - member ic.ClearCaches() = + member ic.ClearCaches() = let utok = AnyCallerThread braceMatchCache.Clear(utok) backgroundCompiler.ClearCaches() @@ -1511,6 +1550,7 @@ type FSharpChecker // This is for unit testing only member ic.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients() = + use _ = Activity.StartNoTags "FsharpChecker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients" ic.ClearCaches() GC.Collect() GC.WaitForPendingFinalizers() @@ -1586,16 +1626,6 @@ type FSharpChecker ) = async { let userOpName = defaultArg userOpName "Unknown" - - use _ = - Activity.instance.Start - "ParseAndCheckFileInProject" - [| - "Project", options.ProjectFileName - "filename", fileName - "UserOpName", userOpName - |] - return! backgroundCompiler.ParseAndCheckFileInProject(fileName, fileVersion, sourceText, options, userOpName) |> Async.AwaitNodeCode @@ -1604,10 +1634,6 @@ type FSharpChecker member _.ParseAndCheckProject(options, ?userOpName: string) = async { let userOpName = defaultArg userOpName "Unknown" - - use _ = - Activity.instance.Start "ParseAndCheckProject" [| "Project", options.ProjectFileName; "UserOpName", userOpName |] - return! backgroundCompiler.ParseAndCheckProject(options, userOpName) |> Async.AwaitNodeCode @@ -1624,10 +1650,6 @@ type FSharpChecker async { let canInvalidateProject = defaultArg canInvalidateProject true let userOpName = defaultArg userOpName "Unknown" - - use _ = - Activity.instance.Start "FindBackgroundReferencesInFile" [| "Project", options.ProjectFileName; "UserOpName", userOpName |] - return! backgroundCompiler.FindReferencesInFile(fileName, options, symbol, canInvalidateProject, userOpName) |> Async.AwaitNodeCode @@ -1636,10 +1658,6 @@ type FSharpChecker member _.GetBackgroundSemanticClassificationForFile(fileName: string, options: FSharpProjectOptions, ?userOpName) = async { let userOpName = defaultArg userOpName "Unknown" - - use _ = - Activity.instance.Start "FindBackgroundReferencesInFile" [| "Project", options.ProjectFileName; "UserOpName", userOpName |] - return! backgroundCompiler.GetSemanticClassificationForFile(fileName, options, userOpName) |> Async.AwaitNodeCode From 6ce22da18e550ffa2a79a052e266920ed168a4d3 Mon Sep 17 00:00:00 2001 From: Tomas Grosup Date: Mon, 10 Oct 2022 18:17:27 +0200 Subject: [PATCH 26/39] Fantomas applied --- src/Compiler/Checking/CheckDeclarations.fs | 4 +- src/Compiler/Driver/CompilerOptions.fs | 7 +- src/Compiler/Driver/ParseAndCheckInputs.fs | 3 +- src/Compiler/Facilities/Logger.fsi | 2 +- src/Compiler/Service/FSharpCheckerResults.fs | 8 +- src/Compiler/Service/service.fs | 93 ++++++++++++-------- 6 files changed, 74 insertions(+), 43 deletions(-) diff --git a/src/Compiler/Checking/CheckDeclarations.fs b/src/Compiler/Checking/CheckDeclarations.fs index ca9e2d002b4..dbea68cf195 100644 --- a/src/Compiler/Checking/CheckDeclarations.fs +++ b/src/Compiler/Checking/CheckDeclarations.fs @@ -5313,8 +5313,8 @@ let CheckOneSigFile (g, amap, thisCcu, checkForErrors, conditionalDefines, tcSin use _ = Activity.Start "CheckDeclarations.CheckOneSigFile" [| - "fileName", fileName - "qualifiedNameOfFile", qualNameOfFile.Text + "fileName", sigFile.FileName + "qualifiedNameOfFile", sigFile.QualifiedName.Text |] let cenv = cenv.Create diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs index c30a27b3f42..d775442d379 100644 --- a/src/Compiler/Driver/CompilerOptions.fs +++ b/src/Compiler/Driver/CompilerOptions.fs @@ -2315,11 +2315,12 @@ let PrintWholeAssemblyImplementation (tcConfig: TcConfig) outfile header expr = let mutable tPrev: (DateTime * DateTime * float * int[]) option = None let mutable nPrev: (string * IDisposable) option = None -let ReportTime (tcConfig: TcConfig) descr = +let ReportTime (tcConfig: TcConfig) descr = match nPrev with | None -> () - | Some (prevDescr,prevActivity) -> + | Some (prevDescr, prevActivity) -> use _ = prevActivity // Finish the previous diagnostics activity by .Dispose() at the end of this block + if tcConfig.pause then dprintf "[done '%s', entering '%s'] press to continue... " prevDescr descr Console.ReadLine() |> ignore @@ -2385,7 +2386,7 @@ let ReportTime (tcConfig: TcConfig) descr = tPrev <- Some(tStart, tNow, utNow, gcNow) - nPrev <- Some (descr, Activity.StartNoTags descr) + nPrev <- Some(descr, Activity.StartNoTags descr) let ignoreFailureOnMono1_1_16 f = try diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index 1da65af83bd..bf3d432bddf 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -1201,7 +1201,8 @@ let CheckOneInputAux cancellable { try - use _ = Activity.Start "ParseAndCheckInputs.CheckOneInput" [| "inputName", inp.FileName |] + use _ = + Activity.Start "ParseAndCheckInputs.CheckOneInput" [| "inputName", inp.FileName |] CheckSimulateException tcConfig diff --git a/src/Compiler/Facilities/Logger.fsi b/src/Compiler/Facilities/Logger.fsi index 58215ac80f5..4eba109adf7 100644 --- a/src/Compiler/Facilities/Logger.fsi +++ b/src/Compiler/Facilities/Logger.fsi @@ -12,4 +12,4 @@ module internal Activity = val StartNoTags: name: string -> IDisposable - val Start: name: string -> tags: (string * #obj) seq -> IDisposable \ No newline at end of file + val Start: name: string -> tags: (string * #obj) seq -> IDisposable diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs index a0bfc35cb94..99d1c186da8 100644 --- a/src/Compiler/Service/FSharpCheckerResults.fs +++ b/src/Compiler/Service/FSharpCheckerResults.fs @@ -2499,7 +2499,13 @@ module internal ParseAndCheckFile = ) = cancellable { - use _ = Activity.Start "ParseAndCheckFile.CheckOneFile" [| "mainInputFileName", mainInputFileName; "Length", sourceText.Length.ToString() |] + use _ = + Activity.Start + "ParseAndCheckFile.CheckOneFile" + [| + "mainInputFileName", mainInputFileName + "Length", sourceText.Length.ToString() + |] let parsedMainInput = parseResults.ParseTree diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index add708b8dea..fe068d87a82 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -274,7 +274,9 @@ type BackgroundCompiler /// creates an incremental builder used by the command line compiler. let CreateOneIncrementalBuilder (options: FSharpProjectOptions, userOpName) = node { - use _ = Activity.Start "BackgroundCompiler.CreateOneIncrementalBuilder" [| "project", options.ProjectFileName |] + use _ = + Activity.Start "BackgroundCompiler.CreateOneIncrementalBuilder" [| "project", options.ProjectFileName |] + Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "CreateOneIncrementalBuilder", options.ProjectFileName) let projectReferences = getProjectReferences options userOpName @@ -403,8 +405,7 @@ type BackgroundCompiler | Some getBuilder -> node { match! getBuilder with - | builderOpt, creationDiags when builderOpt.IsNone || not builderOpt.Value.IsReferencesInvalidated -> - return builderOpt, creationDiags + | builderOpt, creationDiags when builderOpt.IsNone || not builderOpt.Value.IsReferencesInvalidated -> return builderOpt, creationDiags | _ -> // The builder could be re-created, // clear the check file caches that are associated with it. @@ -465,7 +466,8 @@ type BackgroundCompiler member _.ParseFile(fileName: string, sourceText: ISourceText, options: FSharpParsingOptions, cache: bool, userOpName: string) = async { - use _ = Activity.Start "BackgroundCompiler.ParseFile" [| "filename", fileName; "UserOpName", userOpName; "cache", cache.ToString() |] + use _ = + Activity.Start "BackgroundCompiler.ParseFile" [| "filename", fileName; "UserOpName", userOpName; "cache", cache.ToString() |] if cache then let hash = sourceText.GetHashCode() |> int64 @@ -491,7 +493,9 @@ type BackgroundCompiler /// Fetch the parse information from the background compiler (which checks w.r.t. the FileSystem API) member _.GetBackgroundParseResultsForFileInProject(fileName, options, userOpName) = node { - use _ = Activity.Start "BackgroundCompiler.GetBackgroundParseResultsForFileInProject" [| "filename", fileName; "UserOpName", userOpName |] + use _ = + Activity.Start "BackgroundCompiler.GetBackgroundParseResultsForFileInProject" [| "filename", fileName; "UserOpName", userOpName |] + let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) match builderOpt with @@ -693,8 +697,8 @@ type BackgroundCompiler member bc.ParseAndCheckFileInProject(fileName: string, fileVersion, sourceText: ISourceText, options: FSharpProjectOptions, userOpName) = node { use _ = - Activity.Start - "BackgroundCompiler.ParseAndCheckFileInProject" + Activity.Start + "BackgroundCompiler.ParseAndCheckFileInProject" [| "project", options.ProjectFileName "fileName", fileName @@ -713,8 +717,7 @@ type BackgroundCompiler let! cachedResults = bc.GetCachedCheckFileResult(builder, fileName, sourceText, options) match cachedResults with - | Some (parseResults, checkResults) -> - return (parseResults, FSharpCheckFileAnswer.Succeeded checkResults) + | Some (parseResults, checkResults) -> return (parseResults, FSharpCheckFileAnswer.Succeeded checkResults) | _ -> let! tcPrior = builder.GetCheckResultsBeforeFileInProject fileName let! tcInfo = tcPrior.GetOrComputeTcInfo() @@ -740,8 +743,8 @@ type BackgroundCompiler member _.GetBackgroundCheckResultsForFileInProject(fileName, options, userOpName) = node { use _ = - Activity.Start - "BackgroundCompiler.ParseAndCheckFileInProject" + Activity.Start + "BackgroundCompiler.ParseAndCheckFileInProject" [| "project", options.ProjectFileName "fileName", fileName @@ -832,14 +835,15 @@ type BackgroundCompiler ) = node { use _ = - Activity.Start - "BackgroundCompiler.FindReferencesInFile" + Activity.Start + "BackgroundCompiler.FindReferencesInFile" [| "project", options.ProjectFileName "fileName", fileName "userOpName", userOpName "symbol", symbol.FullName |] + let! builderOpt, _ = getOrCreateBuilderWithInvalidationFlag (options, canInvalidateProject, userOpName) match builderOpt with @@ -859,13 +863,14 @@ type BackgroundCompiler member _.GetSemanticClassificationForFile(fileName: string, options: FSharpProjectOptions, userOpName: string) = node { use _ = - Activity.Start - "BackgroundCompiler.GetSemanticClassificationForFile" + Activity.Start + "BackgroundCompiler.GetSemanticClassificationForFile" [| "project", options.ProjectFileName "fileName", fileName - "userOpName", userOpName + "userOpName", userOpName |] + let! builderOpt, _ = getOrCreateBuilder (options, userOpName) match builderOpt with @@ -882,13 +887,14 @@ type BackgroundCompiler /// Try to get recent approximate type check results for a file. member _.TryGetRecentCheckResultsForFile(fileName: string, options: FSharpProjectOptions, sourceText: ISourceText option, _userOpName: string) = use _ = - Activity.Start - "BackgroundCompiler.GetSemanticClassificationForFile" - [| - "project", options.ProjectFileName - "fileName", fileName - "userOpName", _userOpName - |] + Activity.Start + "BackgroundCompiler.GetSemanticClassificationForFile" + [| + "project", options.ProjectFileName + "fileName", fileName + "userOpName", _userOpName + |] + match sourceText with | Some sourceText -> let hash = sourceText.GetHashCode() |> int64 @@ -961,7 +967,9 @@ type BackgroundCompiler member _.GetAssemblyData(options, userOpName) = node { - use _ = Activity.Start "BackgroundCompiler.GetAssemblyData" [|"project", options.ProjectFileName; "userOpName", userOpName |] + use _ = + Activity.Start "BackgroundCompiler.GetAssemblyData" [| "project", options.ProjectFileName; "userOpName", userOpName |] + let! builderOpt, _ = getOrCreateBuilder (options, userOpName) match builderOpt with @@ -982,7 +990,9 @@ type BackgroundCompiler /// Parse and typecheck the whole project. member bc.ParseAndCheckProject(options, userOpName) = - use _ = Activity.Start "BackgroundCompiler.ParseAndCheckProject" [| "project", options.ProjectFileName; "userOpName", userOpName |] + use _ = + Activity.Start "BackgroundCompiler.ParseAndCheckProject" [| "project", options.ProjectFileName; "userOpName", userOpName |] + bc.ParseAndCheckProjectImpl(options, userOpName) member _.GetProjectOptionsFromScript @@ -999,7 +1009,9 @@ type BackgroundCompiler optionsStamp: int64 option, _userOpName ) = - use _ = Activity.Start "BackgroundCompiler.GetProjectOptionsFromScript" [| "fileName", fileName; "userOpName", _userOpName |] + use _ = + Activity.Start "BackgroundCompiler.GetProjectOptionsFromScript" [| "fileName", fileName; "userOpName", _userOpName |] + cancellable { use diagnostics = new DiagnosticsScope() @@ -1084,7 +1096,9 @@ type BackgroundCompiler |> Cancellable.toAsync member bc.InvalidateConfiguration(options: FSharpProjectOptions, userOpName) = - use _ = Activity.Start "BackgroundCompiler.InvalidateConfiguration" [| "project", options.ProjectFileName; "userOpName", userOpName |] + use _ = + Activity.Start "BackgroundCompiler.InvalidateConfiguration" [| "project", options.ProjectFileName; "userOpName", userOpName |] + if incrementalBuildersCache.ContainsSimilarKey(AnyCallerThread, options) then parseCacheLock.AcquireLock(fun ltok -> for sourceFile in options.SourceFiles do @@ -1095,12 +1109,15 @@ type BackgroundCompiler member bc.ClearCache(options: seq, _userOpName) = use _ = Activity.Start "BackgroundCompiler.ClearCache" [| "userOpName", _userOpName |] + lock gate (fun () -> options |> Seq.iter (fun options -> incrementalBuildersCache.RemoveAnySimilar(AnyCallerThread, options))) member _.NotifyProjectCleaned(options: FSharpProjectOptions, userOpName) = - use _ = Activity.Start "BackgroundCompiler.NotifyProjectCleaned" [| "project", options.ProjectFileName; "userOpName", userOpName |] + use _ = + Activity.Start "BackgroundCompiler.NotifyProjectCleaned" [| "project", options.ProjectFileName; "userOpName", userOpName |] + async { let! ct = Async.CancellationToken // If there was a similar entry (as there normally will have been) then re-establish an empty builder . This @@ -1120,7 +1137,8 @@ type BackgroundCompiler member _.ProjectChecked = projectChecked.Publish member _.ClearCaches() = - use _ = Activity.StartNoTags "BackgroundCompiler.ClearCaches" + use _ = Activity.StartNoTags "BackgroundCompiler.ClearCaches" + lock gate (fun () -> parseCacheLock.AcquireLock(fun ltok -> checkFileInProjectCache.Clear(ltok) @@ -1131,7 +1149,8 @@ type BackgroundCompiler scriptClosureCache.Clear AnyCallerThread) member _.DownsizeCaches() = - use _ = Activity.StartNoTags "BackgroundCompiler.DownsizeCaches" + use _ = Activity.StartNoTags "BackgroundCompiler.DownsizeCaches" + lock gate (fun () -> parseCacheLock.AcquireLock(fun ltok -> checkFileInProjectCache.Resize(ltok, newKeepStrongly = 1) @@ -1222,7 +1241,8 @@ type FSharpChecker ?parallelReferenceResolution ) = - use _ = Activity.StartNoTags "FSharpChecker.Create" + use _ = Activity.StartNoTags "FSharpChecker.Create" + let legacyReferenceResolver = match legacyReferenceResolver with | Some rr -> rr @@ -1264,7 +1284,7 @@ type FSharpChecker member _.MatchBraces(fileName, sourceText: ISourceText, options: FSharpParsingOptions, ?userOpName: string) = let userOpName = defaultArg userOpName "Unknown" - use _ = Activity.Start "FSharpChecker.MatchBraces" [| "fileName", fileName; "userOpName", userOpName |] + use _ = Activity.Start "FSharpChecker.MatchBraces" [| "fileName", fileName; "userOpName", userOpName |] let hash = sourceText.GetHashCode() |> int64 async { @@ -1316,7 +1336,8 @@ type FSharpChecker member _.Compile(argv: string[], ?userOpName: string) = let _userOpName = defaultArg userOpName "Unknown" - use _ = Activity.Start "FSharpChecker.Compile" [| "userOpName", _userOpName |] + use _ = Activity.Start "FSharpChecker.Compile" [| "userOpName", _userOpName |] + async { let ctok = CompilationThreadToken() return CompileHelpers.compileFromArgs (ctok, argv, legacyReferenceResolver, None, None) @@ -1326,7 +1347,7 @@ type FSharpChecker /// For example, the type provider approvals file may have changed. member ic.InvalidateAll() = ic.ClearCaches() - member ic.ClearCaches() = + member ic.ClearCaches() = let utok = AnyCallerThread braceMatchCache.Clear(utok) backgroundCompiler.ClearCaches() @@ -1334,7 +1355,9 @@ type FSharpChecker // This is for unit testing only member ic.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients() = - use _ = Activity.StartNoTags "FsharpChecker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients" + use _ = + Activity.StartNoTags "FsharpChecker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients" + ic.ClearCaches() GC.Collect() GC.WaitForPendingFinalizers() From bca4a450821447468cf9f9b1cb11ec0797bfa567 Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 10 Oct 2022 19:09:39 +0100 Subject: [PATCH 27/39] Use consistent casing in tag names --- src/Compiler/Driver/ParseAndCheckInputs.fs | 2 +- src/Compiler/Facilities/Logger.fs | 2 +- src/Compiler/Facilities/Logger.fsi | 2 +- src/Compiler/Service/FSharpCheckerResults.fs | 4 ++-- src/Compiler/Service/IncrementalBuild.fs | 2 +- src/Compiler/Service/service.fs | 12 ++++++------ 6 files changed, 12 insertions(+), 12 deletions(-) diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index 42b5d802b05..f2892f9fc46 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -1199,7 +1199,7 @@ let CheckOneInputAux cancellable { try use _ = - Activity.Start "ParseAndCheckInputs.CheckOneInput" [| "inputName", inp.FileName |] + Activity.Start "ParseAndCheckInputs.CheckOneInput" [| "fileName", inp.FileName |] CheckSimulateException tcConfig diff --git a/src/Compiler/Facilities/Logger.fs b/src/Compiler/Facilities/Logger.fs index 9852cab6d7d..82b5dd110fc 100644 --- a/src/Compiler/Facilities/Logger.fs +++ b/src/Compiler/Facilities/Logger.fs @@ -11,7 +11,7 @@ module Activity = let private activitySource = new ActivitySource("fsc") - let Start name (tags:(string * #obj) seq) : IDisposable = + let Start name (tags:(string * string) seq) : IDisposable = let act = activitySource.StartActivity(name) for key,value in tags do act.AddTag(key,value) |> ignore diff --git a/src/Compiler/Facilities/Logger.fsi b/src/Compiler/Facilities/Logger.fsi index 4eba109adf7..8f144650c8b 100644 --- a/src/Compiler/Facilities/Logger.fsi +++ b/src/Compiler/Facilities/Logger.fsi @@ -12,4 +12,4 @@ module internal Activity = val StartNoTags: name: string -> IDisposable - val Start: name: string -> tags: (string * #obj) seq -> IDisposable + val Start: name: string -> tags: (string * string) seq -> IDisposable diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs index 479daef23c7..0e3145729ed 100644 --- a/src/Compiler/Service/FSharpCheckerResults.fs +++ b/src/Compiler/Service/FSharpCheckerResults.fs @@ -2491,8 +2491,8 @@ module internal ParseAndCheckFile = Activity.Start "ParseAndCheckFile.CheckOneFile" [| - "mainInputFileName", mainInputFileName - "Length", sourceText.Length.ToString() + "fileName", mainInputFileName + "length", sourceText.Length.ToString() |] let parsedMainInput = parseResults.ParseTree diff --git a/src/Compiler/Service/IncrementalBuild.fs b/src/Compiler/Service/IncrementalBuild.fs index 5cc3367b76f..abe212b66fd 100644 --- a/src/Compiler/Service/IncrementalBuild.fs +++ b/src/Compiler/Service/IncrementalBuild.fs @@ -536,7 +536,7 @@ type BoundModel private (tcConfig: TcConfig, // Build symbol keys let itemKeyStore, semanticClassification = if enableBackgroundItemKeyStoreAndSemanticClassification then - use _ = Activity.Start "IncrementalBuild.CreateItemKeyStoreAndSemanticClassification" [|"fileName",fileName|] + use _ = Activity.Start "IncrementalBuild.CreateItemKeyStoreAndSemanticClassification" [|"fileName", fileName|] let sResolutions = sink.GetResolutions() let builder = ItemKeyStoreBuilder() let preventDuplicates = HashSet({ new IEqualityComparer with diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index fe068d87a82..a72809d3c9c 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -467,7 +467,7 @@ type BackgroundCompiler member _.ParseFile(fileName: string, sourceText: ISourceText, options: FSharpParsingOptions, cache: bool, userOpName: string) = async { use _ = - Activity.Start "BackgroundCompiler.ParseFile" [| "filename", fileName; "UserOpName", userOpName; "cache", cache.ToString() |] + Activity.Start "BackgroundCompiler.ParseFile" [| "fileName", fileName; "userOpName", userOpName; "cache", cache.ToString() |] if cache then let hash = sourceText.GetHashCode() |> int64 @@ -494,7 +494,7 @@ type BackgroundCompiler member _.GetBackgroundParseResultsForFileInProject(fileName, options, userOpName) = node { use _ = - Activity.Start "BackgroundCompiler.GetBackgroundParseResultsForFileInProject" [| "filename", fileName; "UserOpName", userOpName |] + Activity.Start "BackgroundCompiler.GetBackgroundParseResultsForFileInProject" [| "fileName", fileName; "userOpName", userOpName |] let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) @@ -523,7 +523,7 @@ type BackgroundCompiler member _.GetCachedCheckFileResult(builder: IncrementalBuilder, fileName, sourceText: ISourceText, options) = node { - use _ = Activity.Start "BackgroundCompiler.GetCachedCheckFileResult" [| "filename", fileName |] + use _ = Activity.Start "BackgroundCompiler.GetCachedCheckFileResult" [| "fileName", fileName |] let hash = sourceText.GetHashCode() |> int64 let key = (fileName, hash, options) let cachedResultsOpt = parseCacheLock.AcquireLock(fun ltok -> checkFileInProjectCache.TryGet(ltok, key)) @@ -630,9 +630,9 @@ type BackgroundCompiler Activity.Start "BackgroundCompiler.CheckFileInProjectAllowingStaleCachedResults" [| - "Project", options.ProjectFileName - "filename", fileName - "UserOpName", userOpName + "project", options.ProjectFileName + "fileName", fileName + "userOpName", userOpName |] let! cachedResults = From b71bf73850215565481cc670655972230849e8a4 Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 10 Oct 2022 19:47:24 +0100 Subject: [PATCH 28/39] Remove old code --- tests/fsharp/core/math/numbers/test.fsx | 4 ---- tests/fsharp/core/printing/testLoadFile2.fsx | 4 ---- 2 files changed, 8 deletions(-) diff --git a/tests/fsharp/core/math/numbers/test.fsx b/tests/fsharp/core/math/numbers/test.fsx index dfdc2b005a3..d9b8eb2edd7 100644 --- a/tests/fsharp/core/math/numbers/test.fsx +++ b/tests/fsharp/core/math/numbers/test.fsx @@ -3,10 +3,6 @@ module Core_math_numbers #endif -#if NETCOREAPP -open CoreClrUtilities -#endif - #light #nowarn "49";; #nowarn "44";; diff --git a/tests/fsharp/core/printing/testLoadFile2.fsx b/tests/fsharp/core/printing/testLoadFile2.fsx index 0135662d80b..d5ea4e8af36 100644 --- a/tests/fsharp/core/printing/testLoadFile2.fsx +++ b/tests/fsharp/core/printing/testLoadFile2.fsx @@ -1,7 +1,3 @@ -#if NETCOREAPP -open CoreClrUtilities -#endif - #light let x1 = 1 let x2 = "hello" From b8574873e57f19fe751a70a803566303989b8d92 Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 10 Oct 2022 20:07:38 +0100 Subject: [PATCH 29/39] Rename activity file, fix NRE, rename start methods --- src/Compiler/Driver/CompilerOptions.fs | 2 +- src/Compiler/FSharp.Compiler.Service.fsproj | 4 +-- src/Compiler/Facilities/Activity.fs | 29 +++++++++++++++++++ .../Facilities/{Logger.fsi => Activity.fsi} | 5 ++-- src/Compiler/Facilities/Logger.fs | 20 ------------- src/Compiler/Service/service.fs | 8 ++--- 6 files changed, 38 insertions(+), 30 deletions(-) create mode 100644 src/Compiler/Facilities/Activity.fs rename src/Compiler/Facilities/{Logger.fsi => Activity.fsi} (75%) delete mode 100644 src/Compiler/Facilities/Logger.fs diff --git a/src/Compiler/Driver/CompilerOptions.fs b/src/Compiler/Driver/CompilerOptions.fs index d775442d379..d8a967f729c 100644 --- a/src/Compiler/Driver/CompilerOptions.fs +++ b/src/Compiler/Driver/CompilerOptions.fs @@ -2386,7 +2386,7 @@ let ReportTime (tcConfig: TcConfig) descr = tPrev <- Some(tStart, tNow, utNow, gcNow) - nPrev <- Some(descr, Activity.StartNoTags descr) + nPrev <- Some(descr, Activity.startNoTags descr) let ignoreFailureOnMono1_1_16 f = try diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index c3d3bb0f672..067b9dd5332 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -133,8 +133,8 @@ - - + + diff --git a/src/Compiler/Facilities/Activity.fs b/src/Compiler/Facilities/Activity.fs new file mode 100644 index 00000000000..831428c4ca5 --- /dev/null +++ b/src/Compiler/Facilities/Activity.fs @@ -0,0 +1,29 @@ +// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. + +namespace FSharp.Compiler.Diagnostics + +open System +open System.Diagnostics + +[] +module Activity = + + let private dummyDisposable = + { + new IDisposable with + member this.Dispose() = () + } + + let private activitySourceName = "fsc" + let private activitySource = new ActivitySource(activitySourceName) + + let start name (tags : (string * string) seq) : IDisposable = + match activitySource.StartActivity(name) |> Option.ofObj with + | Some activity -> + for key, value in tags do + activity.AddTag(key, value) |> ignore + activity :> IDisposable + | None -> + dummyDisposable + + let startNoTags name: IDisposable = activitySource.StartActivity(name) \ No newline at end of file diff --git a/src/Compiler/Facilities/Logger.fsi b/src/Compiler/Facilities/Activity.fsi similarity index 75% rename from src/Compiler/Facilities/Logger.fsi rename to src/Compiler/Facilities/Activity.fsi index 8f144650c8b..edf0d890c19 100644 --- a/src/Compiler/Facilities/Logger.fsi +++ b/src/Compiler/Facilities/Activity.fsi @@ -3,13 +3,12 @@ namespace FSharp.Compiler.Diagnostics open System -open System.Diagnostics /// For activities following the dotnet distributed tracing concept /// https://learn.microsoft.com/en-us/dotnet/core/diagnostics/distributed-tracing-concepts?source=recommendations [] module internal Activity = - val StartNoTags: name: string -> IDisposable + val startNoTags: name: string -> IDisposable - val Start: name: string -> tags: (string * string) seq -> IDisposable + val start: name: string -> tags: (string * string) seq -> IDisposable diff --git a/src/Compiler/Facilities/Logger.fs b/src/Compiler/Facilities/Logger.fs deleted file mode 100644 index 82b5dd110fc..00000000000 --- a/src/Compiler/Facilities/Logger.fs +++ /dev/null @@ -1,20 +0,0 @@ -// Copyright (c) Microsoft Corporation. All Rights Reserved. See License.txt in the project root for license information. - -namespace FSharp.Compiler.Diagnostics - -open System -open System.Diagnostics -open System.Diagnostics.Tracing - -[] -module Activity = - - let private activitySource = new ActivitySource("fsc") - - let Start name (tags:(string * string) seq) : IDisposable = - let act = activitySource.StartActivity(name) - for key,value in tags do - act.AddTag(key,value) |> ignore - act - - let StartNoTags name: IDisposable = activitySource.StartActivity(name) \ No newline at end of file diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index a72809d3c9c..de1c039df8c 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -1137,7 +1137,7 @@ type BackgroundCompiler member _.ProjectChecked = projectChecked.Publish member _.ClearCaches() = - use _ = Activity.StartNoTags "BackgroundCompiler.ClearCaches" + use _ = Activity.startNoTags "BackgroundCompiler.ClearCaches" lock gate (fun () -> parseCacheLock.AcquireLock(fun ltok -> @@ -1149,7 +1149,7 @@ type BackgroundCompiler scriptClosureCache.Clear AnyCallerThread) member _.DownsizeCaches() = - use _ = Activity.StartNoTags "BackgroundCompiler.DownsizeCaches" + use _ = Activity.startNoTags "BackgroundCompiler.DownsizeCaches" lock gate (fun () -> parseCacheLock.AcquireLock(fun ltok -> @@ -1241,7 +1241,7 @@ type FSharpChecker ?parallelReferenceResolution ) = - use _ = Activity.StartNoTags "FSharpChecker.Create" + use _ = Activity.startNoTags "FSharpChecker.Create" let legacyReferenceResolver = match legacyReferenceResolver with @@ -1356,7 +1356,7 @@ type FSharpChecker // This is for unit testing only member ic.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients() = use _ = - Activity.StartNoTags "FsharpChecker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients" + Activity.startNoTags "FsharpChecker.ClearLanguageServiceRootCachesAndCollectAndFinalizeAllTransients" ic.ClearCaches() GC.Collect() From 6684413bb07abf1bb724b5a6e821bfdcf65085a5 Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 10 Oct 2022 20:19:56 +0100 Subject: [PATCH 30/39] Fix build --- src/Compiler/Checking/CheckDeclarations.fs | 4 +-- src/Compiler/Driver/ParseAndCheckInputs.fs | 2 +- src/Compiler/Service/FSharpCheckerResults.fs | 4 +-- src/Compiler/Service/IncrementalBuild.fs | 8 ++--- src/Compiler/Service/service.fs | 38 ++++++++++---------- 5 files changed, 28 insertions(+), 28 deletions(-) diff --git a/src/Compiler/Checking/CheckDeclarations.fs b/src/Compiler/Checking/CheckDeclarations.fs index dbea68cf195..fd286614e70 100644 --- a/src/Compiler/Checking/CheckDeclarations.fs +++ b/src/Compiler/Checking/CheckDeclarations.fs @@ -5178,7 +5178,7 @@ let CheckOneImplFile cancellable { use _ = - Activity.Start "CheckDeclarations.CheckOneImplFile" + Activity.start "CheckDeclarations.CheckOneImplFile" [| "fileName", fileName "qualifiedNameOfFile", qualNameOfFile.Text @@ -5311,7 +5311,7 @@ let CheckOneImplFile let CheckOneSigFile (g, amap, thisCcu, checkForErrors, conditionalDefines, tcSink, isInternalTestSpanStackReferring) tcEnv (sigFile: ParsedSigFileInput) = cancellable { use _ = - Activity.Start "CheckDeclarations.CheckOneSigFile" + Activity.start "CheckDeclarations.CheckOneSigFile" [| "fileName", sigFile.FileName "qualifiedNameOfFile", sigFile.QualifiedName.Text diff --git a/src/Compiler/Driver/ParseAndCheckInputs.fs b/src/Compiler/Driver/ParseAndCheckInputs.fs index f2892f9fc46..467e003380a 100644 --- a/src/Compiler/Driver/ParseAndCheckInputs.fs +++ b/src/Compiler/Driver/ParseAndCheckInputs.fs @@ -1199,7 +1199,7 @@ let CheckOneInputAux cancellable { try use _ = - Activity.Start "ParseAndCheckInputs.CheckOneInput" [| "fileName", inp.FileName |] + Activity.start "ParseAndCheckInputs.CheckOneInput" [| "fileName", inp.FileName |] CheckSimulateException tcConfig diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs index 0e3145729ed..3e5aa78d187 100644 --- a/src/Compiler/Service/FSharpCheckerResults.fs +++ b/src/Compiler/Service/FSharpCheckerResults.fs @@ -2331,7 +2331,7 @@ module internal ParseAndCheckFile = let parseFile (sourceText: ISourceText, fileName, options: FSharpParsingOptions, userOpName: string, suggestNamesForErrors: bool) = Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "parseFile", fileName) - use act = Activity.Start "ParseAndCheckFile.parseFile" [| "fileName", fileName |] + use act = Activity.start "ParseAndCheckFile.parseFile" [| "fileName", fileName |] let errHandler = DiagnosticsHandler(true, fileName, options.DiagnosticOptions, sourceText, suggestNamesForErrors) @@ -2488,7 +2488,7 @@ module internal ParseAndCheckFile = cancellable { use _ = - Activity.Start + Activity.start "ParseAndCheckFile.CheckOneFile" [| "fileName", mainInputFileName diff --git a/src/Compiler/Service/IncrementalBuild.fs b/src/Compiler/Service/IncrementalBuild.fs index abe212b66fd..b8d9e4f648c 100644 --- a/src/Compiler/Service/IncrementalBuild.fs +++ b/src/Compiler/Service/IncrementalBuild.fs @@ -125,7 +125,7 @@ module IncrementalBuildSyntaxTree = IncrementalBuilderEventTesting.MRU.Add(IncrementalBuilderEventTesting.IBEParsed fileName) let canSkip = sigNameOpt.IsSome && FSharpImplFileSuffixes |> List.exists (FileSystemUtils.checkSuffix fileName) use act = - Activity.Start "IncrementalBuildSyntaxTree.parse" + Activity.start "IncrementalBuildSyntaxTree.parse" [| "fileName", source.FilePath "buildPhase", BuildPhase.Parse.ToString() @@ -473,7 +473,7 @@ type BoundModel private (tcConfig: TcConfig, let! res = defaultTypeCheck () return res | Some syntaxTree -> - use _ = Activity.Start "BoundModel.TypeCheck" [|"fileName", syntaxTree.FileName|] + use _ = Activity.start "BoundModel.TypeCheck" [|"fileName", syntaxTree.FileName|] let sigNameOpt = if partialCheck then this.BackingSignature @@ -536,7 +536,7 @@ type BoundModel private (tcConfig: TcConfig, // Build symbol keys let itemKeyStore, semanticClassification = if enableBackgroundItemKeyStoreAndSemanticClassification then - use _ = Activity.Start "IncrementalBuild.CreateItemKeyStoreAndSemanticClassification" [|"fileName", fileName|] + use _ = Activity.start "IncrementalBuild.CreateItemKeyStoreAndSemanticClassification" [|"fileName", fileName|] let sResolutions = sink.GetResolutions() let builder = ItemKeyStoreBuilder() let preventDuplicates = HashSet({ new IEqualityComparer with @@ -1041,7 +1041,7 @@ module IncrementalBuilderStateHelpers = let rec createFinalizeBoundModelGraphNode (initialState: IncrementalBuilderInitialState) (boundModels: ImmutableArray>.Builder) = GraphNode(node { - use _ = Activity.Start "GetCheckResultsAndImplementationsForProject" [|"projectOutFile", initialState.outfile|] + use _ = Activity.start "GetCheckResultsAndImplementationsForProject" [|"projectOutFile", initialState.outfile|] // Compute last bound model then get all the evaluated models. let! _ = boundModels[boundModels.Count - 1].GetOrComputeValue() let boundModels = diff --git a/src/Compiler/Service/service.fs b/src/Compiler/Service/service.fs index de1c039df8c..90215b6a8f5 100644 --- a/src/Compiler/Service/service.fs +++ b/src/Compiler/Service/service.fs @@ -275,7 +275,7 @@ type BackgroundCompiler let CreateOneIncrementalBuilder (options: FSharpProjectOptions, userOpName) = node { use _ = - Activity.Start "BackgroundCompiler.CreateOneIncrementalBuilder" [| "project", options.ProjectFileName |] + Activity.start "BackgroundCompiler.CreateOneIncrementalBuilder" [| "project", options.ProjectFileName |] Trace.TraceInformation("FCS: {0}.{1} ({2})", userOpName, "CreateOneIncrementalBuilder", options.ProjectFileName) let projectReferences = getProjectReferences options userOpName @@ -467,7 +467,7 @@ type BackgroundCompiler member _.ParseFile(fileName: string, sourceText: ISourceText, options: FSharpParsingOptions, cache: bool, userOpName: string) = async { use _ = - Activity.Start "BackgroundCompiler.ParseFile" [| "fileName", fileName; "userOpName", userOpName; "cache", cache.ToString() |] + Activity.start "BackgroundCompiler.ParseFile" [| "fileName", fileName; "userOpName", userOpName; "cache", cache.ToString() |] if cache then let hash = sourceText.GetHashCode() |> int64 @@ -494,7 +494,7 @@ type BackgroundCompiler member _.GetBackgroundParseResultsForFileInProject(fileName, options, userOpName) = node { use _ = - Activity.Start "BackgroundCompiler.GetBackgroundParseResultsForFileInProject" [| "fileName", fileName; "userOpName", userOpName |] + Activity.start "BackgroundCompiler.GetBackgroundParseResultsForFileInProject" [| "fileName", fileName; "userOpName", userOpName |] let! builderOpt, creationDiags = getOrCreateBuilder (options, userOpName) @@ -523,7 +523,7 @@ type BackgroundCompiler member _.GetCachedCheckFileResult(builder: IncrementalBuilder, fileName, sourceText: ISourceText, options) = node { - use _ = Activity.Start "BackgroundCompiler.GetCachedCheckFileResult" [| "fileName", fileName |] + use _ = Activity.start "BackgroundCompiler.GetCachedCheckFileResult" [| "fileName", fileName |] let hash = sourceText.GetHashCode() |> int64 let key = (fileName, hash, options) let cachedResultsOpt = parseCacheLock.AcquireLock(fun ltok -> checkFileInProjectCache.TryGet(ltok, key)) @@ -627,7 +627,7 @@ type BackgroundCompiler ) = node { use _ = - Activity.Start + Activity.start "BackgroundCompiler.CheckFileInProjectAllowingStaleCachedResults" [| "project", options.ProjectFileName @@ -669,7 +669,7 @@ type BackgroundCompiler member bc.CheckFileInProject(parseResults: FSharpParseFileResults, fileName, fileVersion, sourceText: ISourceText, options, userOpName) = node { use _ = - Activity.Start + Activity.start "BackgroundCompiler.CheckFileInProject" [| "project", options.ProjectFileName @@ -697,7 +697,7 @@ type BackgroundCompiler member bc.ParseAndCheckFileInProject(fileName: string, fileVersion, sourceText: ISourceText, options: FSharpProjectOptions, userOpName) = node { use _ = - Activity.Start + Activity.start "BackgroundCompiler.ParseAndCheckFileInProject" [| "project", options.ProjectFileName @@ -743,7 +743,7 @@ type BackgroundCompiler member _.GetBackgroundCheckResultsForFileInProject(fileName, options, userOpName) = node { use _ = - Activity.Start + Activity.start "BackgroundCompiler.ParseAndCheckFileInProject" [| "project", options.ProjectFileName @@ -835,7 +835,7 @@ type BackgroundCompiler ) = node { use _ = - Activity.Start + Activity.start "BackgroundCompiler.FindReferencesInFile" [| "project", options.ProjectFileName @@ -863,7 +863,7 @@ type BackgroundCompiler member _.GetSemanticClassificationForFile(fileName: string, options: FSharpProjectOptions, userOpName: string) = node { use _ = - Activity.Start + Activity.start "BackgroundCompiler.GetSemanticClassificationForFile" [| "project", options.ProjectFileName @@ -887,7 +887,7 @@ type BackgroundCompiler /// Try to get recent approximate type check results for a file. member _.TryGetRecentCheckResultsForFile(fileName: string, options: FSharpProjectOptions, sourceText: ISourceText option, _userOpName: string) = use _ = - Activity.Start + Activity.start "BackgroundCompiler.GetSemanticClassificationForFile" [| "project", options.ProjectFileName @@ -968,7 +968,7 @@ type BackgroundCompiler member _.GetAssemblyData(options, userOpName) = node { use _ = - Activity.Start "BackgroundCompiler.GetAssemblyData" [| "project", options.ProjectFileName; "userOpName", userOpName |] + Activity.start "BackgroundCompiler.GetAssemblyData" [| "project", options.ProjectFileName; "userOpName", userOpName |] let! builderOpt, _ = getOrCreateBuilder (options, userOpName) @@ -991,7 +991,7 @@ type BackgroundCompiler /// Parse and typecheck the whole project. member bc.ParseAndCheckProject(options, userOpName) = use _ = - Activity.Start "BackgroundCompiler.ParseAndCheckProject" [| "project", options.ProjectFileName; "userOpName", userOpName |] + Activity.start "BackgroundCompiler.ParseAndCheckProject" [| "project", options.ProjectFileName; "userOpName", userOpName |] bc.ParseAndCheckProjectImpl(options, userOpName) @@ -1010,7 +1010,7 @@ type BackgroundCompiler _userOpName ) = use _ = - Activity.Start "BackgroundCompiler.GetProjectOptionsFromScript" [| "fileName", fileName; "userOpName", _userOpName |] + Activity.start "BackgroundCompiler.GetProjectOptionsFromScript" [| "fileName", fileName; "userOpName", _userOpName |] cancellable { use diagnostics = new DiagnosticsScope() @@ -1097,7 +1097,7 @@ type BackgroundCompiler member bc.InvalidateConfiguration(options: FSharpProjectOptions, userOpName) = use _ = - Activity.Start "BackgroundCompiler.InvalidateConfiguration" [| "project", options.ProjectFileName; "userOpName", userOpName |] + Activity.start "BackgroundCompiler.InvalidateConfiguration" [| "project", options.ProjectFileName; "userOpName", userOpName |] if incrementalBuildersCache.ContainsSimilarKey(AnyCallerThread, options) then parseCacheLock.AcquireLock(fun ltok -> @@ -1108,7 +1108,7 @@ type BackgroundCompiler () member bc.ClearCache(options: seq, _userOpName) = - use _ = Activity.Start "BackgroundCompiler.ClearCache" [| "userOpName", _userOpName |] + use _ = Activity.start "BackgroundCompiler.ClearCache" [| "userOpName", _userOpName |] lock gate (fun () -> options @@ -1116,7 +1116,7 @@ type BackgroundCompiler member _.NotifyProjectCleaned(options: FSharpProjectOptions, userOpName) = use _ = - Activity.Start "BackgroundCompiler.NotifyProjectCleaned" [| "project", options.ProjectFileName; "userOpName", userOpName |] + Activity.start "BackgroundCompiler.NotifyProjectCleaned" [| "project", options.ProjectFileName; "userOpName", userOpName |] async { let! ct = Async.CancellationToken @@ -1284,7 +1284,7 @@ type FSharpChecker member _.MatchBraces(fileName, sourceText: ISourceText, options: FSharpParsingOptions, ?userOpName: string) = let userOpName = defaultArg userOpName "Unknown" - use _ = Activity.Start "FSharpChecker.MatchBraces" [| "fileName", fileName; "userOpName", userOpName |] + use _ = Activity.start "FSharpChecker.MatchBraces" [| "fileName", fileName; "userOpName", userOpName |] let hash = sourceText.GetHashCode() |> int64 async { @@ -1336,7 +1336,7 @@ type FSharpChecker member _.Compile(argv: string[], ?userOpName: string) = let _userOpName = defaultArg userOpName "Unknown" - use _ = Activity.Start "FSharpChecker.Compile" [| "userOpName", _userOpName |] + use _ = Activity.start "FSharpChecker.Compile" [| "userOpName", _userOpName |] async { let ctok = CompilationThreadToken() From 549b3f8a3c6472906144155faa2a7b26abbc0d32 Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 10 Oct 2022 21:13:18 +0100 Subject: [PATCH 31/39] Don't use dummyDisposable --- src/Compiler/Facilities/Activity.fs | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/src/Compiler/Facilities/Activity.fs b/src/Compiler/Facilities/Activity.fs index 831428c4ca5..aa4b0c44dd5 100644 --- a/src/Compiler/Facilities/Activity.fs +++ b/src/Compiler/Facilities/Activity.fs @@ -8,12 +8,6 @@ open System.Diagnostics [] module Activity = - let private dummyDisposable = - { - new IDisposable with - member this.Dispose() = () - } - let private activitySourceName = "fsc" let private activitySource = new ActivitySource(activitySourceName) @@ -24,6 +18,6 @@ module Activity = activity.AddTag(key, value) |> ignore activity :> IDisposable | None -> - dummyDisposable + null let startNoTags name: IDisposable = activitySource.StartActivity(name) \ No newline at end of file From e1be12743584a2c7a3b55acd32569981ec75e357 Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 10 Oct 2022 21:17:06 +0100 Subject: [PATCH 32/39] Fantomas formatting --- src/Compiler/Facilities/Activity.fs | 12 ++++++------ src/Compiler/Service/FSharpCheckerResults.fs | 7 +------ 2 files changed, 7 insertions(+), 12 deletions(-) diff --git a/src/Compiler/Facilities/Activity.fs b/src/Compiler/Facilities/Activity.fs index aa4b0c44dd5..ab61b33f790 100644 --- a/src/Compiler/Facilities/Activity.fs +++ b/src/Compiler/Facilities/Activity.fs @@ -6,18 +6,18 @@ open System open System.Diagnostics [] -module Activity = - +module Activity = + let private activitySourceName = "fsc" let private activitySource = new ActivitySource(activitySourceName) - let start name (tags : (string * string) seq) : IDisposable = + let start name (tags: (string * string) seq) : IDisposable = match activitySource.StartActivity(name) |> Option.ofObj with | Some activity -> for key, value in tags do activity.AddTag(key, value) |> ignore + activity :> IDisposable - | None -> - null + | None -> null - let startNoTags name: IDisposable = activitySource.StartActivity(name) \ No newline at end of file + let startNoTags name : IDisposable = activitySource.StartActivity(name) diff --git a/src/Compiler/Service/FSharpCheckerResults.fs b/src/Compiler/Service/FSharpCheckerResults.fs index 3e5aa78d187..cf4c3d92fc8 100644 --- a/src/Compiler/Service/FSharpCheckerResults.fs +++ b/src/Compiler/Service/FSharpCheckerResults.fs @@ -2488,12 +2488,7 @@ module internal ParseAndCheckFile = cancellable { use _ = - Activity.start - "ParseAndCheckFile.CheckOneFile" - [| - "fileName", mainInputFileName - "length", sourceText.Length.ToString() - |] + Activity.start "ParseAndCheckFile.CheckOneFile" [| "fileName", mainInputFileName; "length", sourceText.Length.ToString() |] let parsedMainInput = parseResults.ParseTree From dcfea0498d674655ba9e0a250f7abd614e0d99a6 Mon Sep 17 00:00:00 2001 From: janusz Date: Tue, 11 Oct 2022 08:50:38 +0100 Subject: [PATCH 33/39] Apply fixes from T-Gro to avoid NRE --- src/Compiler/Facilities/Activity.fs | 11 +++++++---- src/Compiler/Utilities/illib.fs | 2 +- 2 files changed, 8 insertions(+), 5 deletions(-) diff --git a/src/Compiler/Facilities/Activity.fs b/src/Compiler/Facilities/Activity.fs index ab61b33f790..107f9437982 100644 --- a/src/Compiler/Facilities/Activity.fs +++ b/src/Compiler/Facilities/Activity.fs @@ -4,6 +4,7 @@ namespace FSharp.Compiler.Diagnostics open System open System.Diagnostics +open Internal.Utilities.Library [] module Activity = @@ -12,12 +13,14 @@ module Activity = let private activitySource = new ActivitySource(activitySourceName) let start name (tags: (string * string) seq) : IDisposable = - match activitySource.StartActivity(name) |> Option.ofObj with - | Some activity -> + let activity = activitySource.StartActivity(name) + + match activity with + | null -> () + | activity -> for key, value in tags do activity.AddTag(key, value) |> ignore - activity :> IDisposable - | None -> null + activity let startNoTags name : IDisposable = activitySource.StartActivity(name) diff --git a/src/Compiler/Utilities/illib.fs b/src/Compiler/Utilities/illib.fs index fcb2a84c35b..d0bb8f7843b 100644 --- a/src/Compiler/Utilities/illib.fs +++ b/src/Compiler/Utilities/illib.fs @@ -997,7 +997,7 @@ type CancellableBuilder() = match compRes with | ValueOrCancelled.Value res -> - (resource :> IDisposable).Dispose() + Microsoft.FSharp.Core.LanguagePrimitives.IntrinsicFunctions.Dispose resource match res with | Choice1Of2 r -> ValueOrCancelled.Value r From 8c053c34f01e24f57d3d2e5a75f5eba8c87286c9 Mon Sep 17 00:00:00 2001 From: janusz Date: Tue, 11 Oct 2022 09:02:45 +0100 Subject: [PATCH 34/39] Fantomas formatting one more time --- src/Compiler/Facilities/Activity.fs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Compiler/Facilities/Activity.fs b/src/Compiler/Facilities/Activity.fs index 107f9437982..9a4a8cd5968 100644 --- a/src/Compiler/Facilities/Activity.fs +++ b/src/Compiler/Facilities/Activity.fs @@ -17,7 +17,7 @@ module Activity = match activity with | null -> () - | activity -> + | activity -> for key, value in tags do activity.AddTag(key, value) |> ignore From 2b9210f9b6c85c6016b01b68779709475001cb34 Mon Sep 17 00:00:00 2001 From: Tomas Grosup Date: Tue, 11 Oct 2022 12:37:13 +0200 Subject: [PATCH 35/39] Fix CI by nuspec dependency version assignment --- src/Compiler/FSharp.Compiler.Service.nuspec | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Compiler/FSharp.Compiler.Service.nuspec b/src/Compiler/FSharp.Compiler.Service.nuspec index ab4ad707bbb..6551e7fd53b 100644 --- a/src/Compiler/FSharp.Compiler.Service.nuspec +++ b/src/Compiler/FSharp.Compiler.Service.nuspec @@ -11,7 +11,7 @@ - + From 0c95dc944998712ecbcb3e3e3f38fe9d008bd408 Mon Sep 17 00:00:00 2001 From: Tomas Grosup Date: Tue, 11 Oct 2022 20:22:53 +0200 Subject: [PATCH 36/39] Updating DiagnosticSource version and reflecting in vsintegraion projects --- eng/Versions.props | 2 +- vsintegration/Directory.Build.targets | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/eng/Versions.props b/eng/Versions.props index bec5570e719..50af294b851 100644 --- a/eng/Versions.props +++ b/eng/Versions.props @@ -88,7 +88,7 @@ 4.5.1 6.0.0 1.6.0 - 5.0.1 + 6.0.0 4.5.5 4.7.0 6.0.0 diff --git a/vsintegration/Directory.Build.targets b/vsintegration/Directory.Build.targets index 21ec3caa91f..8175eb49227 100644 --- a/vsintegration/Directory.Build.targets +++ b/vsintegration/Directory.Build.targets @@ -15,6 +15,7 @@ + From fb61e375bb95998c58158fae26f56a3f151efe89 Mon Sep 17 00:00:00 2001 From: Tomas Grosup Date: Tue, 11 Oct 2022 20:33:34 +0200 Subject: [PATCH 37/39] Reflecting newer package version in the code (more overloads available) --- src/Compiler/Facilities/Activity.fs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Compiler/Facilities/Activity.fs b/src/Compiler/Facilities/Activity.fs index 9a4a8cd5968..96b238eda59 100644 --- a/src/Compiler/Facilities/Activity.fs +++ b/src/Compiler/Facilities/Activity.fs @@ -12,7 +12,7 @@ module Activity = let private activitySourceName = "fsc" let private activitySource = new ActivitySource(activitySourceName) - let start name (tags: (string * string) seq) : IDisposable = + let start (name:string) (tags: (string * string) seq) : IDisposable = let activity = activitySource.StartActivity(name) match activity with @@ -23,4 +23,4 @@ module Activity = activity - let startNoTags name : IDisposable = activitySource.StartActivity(name) + let startNoTags (name:string) : IDisposable = activitySource.StartActivity(name) From ab1b6934f45aa6c7412bca867f698a72e1c12f99 Mon Sep 17 00:00:00 2001 From: Tomas Grosup Date: Tue, 11 Oct 2022 20:43:10 +0200 Subject: [PATCH 38/39] Applying Fantomas --- src/Compiler/Facilities/Activity.fs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Compiler/Facilities/Activity.fs b/src/Compiler/Facilities/Activity.fs index 96b238eda59..c6d4e637fba 100644 --- a/src/Compiler/Facilities/Activity.fs +++ b/src/Compiler/Facilities/Activity.fs @@ -12,7 +12,7 @@ module Activity = let private activitySourceName = "fsc" let private activitySource = new ActivitySource(activitySourceName) - let start (name:string) (tags: (string * string) seq) : IDisposable = + let start (name: string) (tags: (string * string) seq) : IDisposable = let activity = activitySource.StartActivity(name) match activity with @@ -23,4 +23,4 @@ module Activity = activity - let startNoTags (name:string) : IDisposable = activitySource.StartActivity(name) + let startNoTags (name: string) : IDisposable = activitySource.StartActivity(name) From 336b120f5b9211b5d29204ca5041367cb9a3e0f7 Mon Sep 17 00:00:00 2001 From: janusz Date: Mon, 24 Oct 2022 02:09:21 +0100 Subject: [PATCH 39/39] Add a comment and move Activity.fs/fsi to Utilities/ --- src/Compiler/FSharp.Compiler.Service.fsproj | 4 ++-- src/Compiler/Facilities/BuildGraph.fsi | 4 ++-- src/Compiler/{Facilities => Utilities}/Activity.fs | 1 - src/Compiler/{Facilities => Utilities}/Activity.fsi | 0 4 files changed, 4 insertions(+), 5 deletions(-) rename src/Compiler/{Facilities => Utilities}/Activity.fs (96%) rename src/Compiler/{Facilities => Utilities}/Activity.fsi (100%) diff --git a/src/Compiler/FSharp.Compiler.Service.fsproj b/src/Compiler/FSharp.Compiler.Service.fsproj index 067b9dd5332..0f892619b83 100644 --- a/src/Compiler/FSharp.Compiler.Service.fsproj +++ b/src/Compiler/FSharp.Compiler.Service.fsproj @@ -93,6 +93,8 @@ FSStrings.resx FSStrings.resources + + @@ -133,8 +135,6 @@ - - diff --git a/src/Compiler/Facilities/BuildGraph.fsi b/src/Compiler/Facilities/BuildGraph.fsi index 9110df4dfae..b94c6e30b26 100644 --- a/src/Compiler/Facilities/BuildGraph.fsi +++ b/src/Compiler/Facilities/BuildGraph.fsi @@ -44,10 +44,10 @@ type NodeCodeBuilder = member Combine: x1: NodeCode * x2: NodeCode<'T> -> NodeCode<'T> - /// A limited form 'use' for establishing the compilation globals. (Note - /// that a proper generic 'use' could be implemented but has not currently been necessary) + /// A limited form 'use' for establishing the compilation globals. member Using: CompilationGlobalsScope * (CompilationGlobalsScope -> NodeCode<'T>) -> NodeCode<'T> + /// A generic 'use' that disposes of the IDisposable at the end of the computation. member Using: IDisposable * (IDisposable -> NodeCode<'T>) -> NodeCode<'T> /// Specifies code that can be run as part of the build graph. diff --git a/src/Compiler/Facilities/Activity.fs b/src/Compiler/Utilities/Activity.fs similarity index 96% rename from src/Compiler/Facilities/Activity.fs rename to src/Compiler/Utilities/Activity.fs index c6d4e637fba..2ae87433ce5 100644 --- a/src/Compiler/Facilities/Activity.fs +++ b/src/Compiler/Utilities/Activity.fs @@ -4,7 +4,6 @@ namespace FSharp.Compiler.Diagnostics open System open System.Diagnostics -open Internal.Utilities.Library [] module Activity = diff --git a/src/Compiler/Facilities/Activity.fsi b/src/Compiler/Utilities/Activity.fsi similarity index 100% rename from src/Compiler/Facilities/Activity.fsi rename to src/Compiler/Utilities/Activity.fsi