CbC/CbC_llvm: clang-tools-extra/clangd/TUScheduler.h comparison

comparison clang-tools-extra/clangd/TUScheduler.h @ 221:79ff65ed7e25

LLVM12 Original

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Tue, 15 Jun 2021 19:15:29 +0900
parents	0572611fdcc8
children	c4bab56944e8

comparison

equal deleted inserted replaced

-:42394fc6a535
+:79ff65ed7e25
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_TOOLS_EXTRA_CLANGD_TUSCHEDULER_H
 #define LLVM_CLANG_TOOLS_EXTRA_CLANGD_TUSCHEDULER_H
+#include "ASTSignals.h"
 #include "Compiler.h"
 #include "Diagnostics.h"
 #include "GlobalCompilationDatabase.h"
 #include "index/CanonicalIncludes.h"
 #include "support/Function.h"
+#include "support/MemoryTree.h"
 #include "support/Path.h"
 #include "support/Threading.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include <chrono>
+#include <string>
 namespace clang {
 namespace clangd {
 class ParsedAST;
 struct PreambleData;
 struct InputsAndPreamble {
 llvm::StringRef Contents;
 const tooling::CompileCommand &Command;
 // This can be nullptr if no preamble is available.
 const PreambleData *Preamble;
+// This can be nullptr if no ASTSignals are available.
+const ASTSignals *Signals;
 };
 /// Determines whether diagnostics should be generated for a file snapshot.
 enum class WantDiagnostics {
 Yes,  /// Diagnostics must be generated for this snapshot.
 /// accessed from the main file AST, e.g. redecls of functions from preamble,
 /// etc. Clients are expected to process only the AST nodes from the main file
 /// in this callback (obtained via ParsedAST::getLocalTopLevelDecls) to obtain
 /// optimal performance.
 ///
-/// When information about the file (diagnostics, syntax highlighting) is
+/// When information about the file (e.g. diagnostics) is
 /// published to clients, this should be wrapped in Publish, e.g.
 ///   void onMainAST(...) {
-///     Highlights = computeHighlights();
+///     Diags = renderDiagnostics();
-///     Publish([&] { notifyHighlights(Path, Highlights); });
+///     Publish([&] { notifyDiagnostics(Path, Diags); });
 ///   }
 /// This guarantees that clients will see results in the correct sequence if
 /// the file is concurrently closed and/or reopened. (The lambda passed to
 /// Publish() may never run in this case).
 virtual void onMainAST(PathRef Path, ParsedAST &AST, PublishFn Publish) {}
 virtual void onFailedAST(PathRef Path, llvm::StringRef Version,
 std::vector<Diag> Diags, PublishFn Publish) {}
 /// Called whenever the TU status is updated.
 virtual void onFileUpdated(PathRef File, const TUStatus &Status) {}
+/// Preamble for the TU have changed. This might imply new semantics (e.g.
+/// different highlightings). Any actions on the file are guranteed to see new
+/// preamble after the callback.
+virtual void onPreamblePublished(PathRef File) {}
 };
 /// Handles running tasks for ClangdServer and managing the resources (e.g.,
 /// preambles and ASTs) for opened files.
 /// TUScheduler is not thread-safe, only one thread should be providing updates
 /// This tries to ensure we rebuild once the user stops typing.
 DebouncePolicy UpdateDebounce;
 /// Determines when to keep idle ASTs in memory for future use.
 ASTRetentionPolicy RetentionPolicy;
+/// Used to create a context that wraps each single operation.
+/// Typically to inject per-file configuration.
+/// If the path is empty, context sholud be "generic".
+std::function<Context(PathRef)> ContextProvider;
 };
 TUScheduler(const GlobalCompilationDatabase &CDB, const Options &Opts,
 std::unique_ptr<ParsingCallbacks> ASTCallbacks = nullptr);
 ~TUScheduler();
 struct FileStats {
-std::size_t UsedBytes = 0;
+std::size_t UsedBytesAST = 0;
+std::size_t UsedBytesPreamble = 0;
 unsigned PreambleBuilds = 0;
 unsigned ASTBuilds = 0;
 };
 /// Returns resources used for each of the currently open files.
 /// Results are inherently racy as they measure activity of other threads.
 /// Remove \p File from the list of tracked files and schedule removal of its
 /// resources. Pending diagnostics for closed files may not be delivered, even
 /// if requested with WantDiags::Auto or WantDiags::Yes.
 void remove(PathRef File);
-/// Returns a snapshot of all file buffer contents, per last update().
-llvm::StringMap<std::string> getAllFileContents() const;
 /// Schedule an async task with no dependencies.
-void run(llvm::StringRef Name, llvm::unique_function<void()> Action);
+/// Path may be empty (it is used only to set the Context).
+void run(llvm::StringRef Name, llvm::StringRef Path,
+llvm::unique_function<void()> Action);
+/// Similar to run, except the task is expected to be quick.
+/// This function will not honor AsyncThreadsCount (except
+/// if threading is disabled with AsyncThreadsCount=0)
+/// It is intended to run quick tasks that need to run ASAP
+void runQuick(llvm::StringRef Name, llvm::StringRef Path,
+llvm::unique_function<void()> Action);
 /// Defines how a runWithAST action is implicitly cancelled by other actions.
 enum ASTActionInvalidation {
 /// The request will run unless explicitly cancelled.
 NoInvalidation,
 public:
 /// Responsible for retaining and rebuilding idle ASTs. An implementation is
 /// an LRU cache.
 class ASTCache;
+/// Tracks headers included by open files, to get known-good compile commands.
+class HeaderIncluderCache;
 // The file being built/processed in the current thread. This is a hack in
 // order to get the file name into the index implementations. Do not depend on
 // this inside clangd.
 // FIXME: remove this when there is proper index support via build system
 // integration.
+// FIXME: move to ClangdServer via createProcessingContext.
 static llvm::Optional<llvm::StringRef> getFileBeingProcessedInContext();
+void profile(MemoryTree &MT) const;
 private:
+void runWithSemaphore(llvm::StringRef Name, llvm::StringRef Path,
+llvm::unique_function<void()> Action, Semaphore &Sem);
 const GlobalCompilationDatabase &CDB;
-const bool StorePreamblesInMemory;
+Options Opts;
 std::unique_ptr<ParsingCallbacks> Callbacks; // not nullptr
 Semaphore Barrier;
+Semaphore QuickRunBarrier;
 llvm::StringMap<std::unique_ptr<FileData>> Files;
 std::unique_ptr<ASTCache> IdleASTs;
+std::unique_ptr<HeaderIncluderCache> HeaderIncluders;
 // None when running tasks synchronously and non-None when running tasks
 // asynchronously.
 llvm::Optional<AsyncTaskRunner> PreambleTasks;
 llvm::Optional<AsyncTaskRunner> WorkerThreads;
-DebouncePolicy UpdateDebounce;
+// Used to create contexts for operations that are not bound to a particular
+// file (e.g. index queries).
+std::string LastActiveFile;
 };
 } // namespace clangd
 } // namespace clang

Mercurial > hg > CbC > CbC_llvm

comparison clang-tools-extra/clangd/TUScheduler.h @ 221:79ff65ed7e25