HomeSort by: relevance | last modified time | path
    Searched refs:Task (Results 1 - 22 of 22) sorted by relevancy

  /src/external/apache2/llvm/dist/llvm/lib/Support/
ThreadPool.cpp 32 PackagedTaskTy Task;
41 // Yeah, we have a task, grab it and release the lock on the queue
45 // empty, there is still a task in flight.
47 Task = std::move(Tasks.front());
50 // Run the task we just grabbed
51 Task();
60 // Notify task completion if this is the last active thread, in case
75 std::shared_future<void> ThreadPool::asyncImpl(TaskTy Task) {
76 /// Wrap the Task in a packaged_task to return a future object.
77 PackagedTaskTy PackagedTask(std::move(Task));
    [all...]
Parallel.cpp 105 auto Task = WorkStack.top();
108 Task();
  /src/external/apache2/llvm/dist/llvm/include/llvm/LTO/
Caching.h 27 std::function<void(unsigned Task, std::unique_ptr<MemoryBuffer> MB)>;
LTOBackend.h 37 bool opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
54 Error thinBackend(const Config &C, unsigned Task, AddStreamFn AddStream,
Config.h 188 /// single native object file. Each task has a unique identifier between 0 and
189 /// getMaxTasks()-1, which is supplied to the callback via the Task parameter.
190 /// A task represents the entire pipeline for ThinLTO and regular
191 /// (non-parallel) LTO, but a parallel code generation task will be split into
194 /// LTO may decide to stop processing a task at any time, for example if the
202 /// that task is aborted.
206 /// multiple threads with the same task ID, or the same module.
210 using ModuleHookFn = std::function<bool(unsigned Task, const Module &)>;
LTO.h 204 std::function<std::unique_ptr<NativeObjectStream>(unsigned Task)>;
216 /// if (AddStreamFn AddStream = Cache(Task, Key))
219 std::function<AddStreamFn(unsigned Task, StringRef Key)>;
299 /// Cache) for each task identifier.
  /src/external/apache2/llvm/dist/llvm/lib/LTO/
Caching.cpp 36 return [=](unsigned Task, StringRef Key) -> AddStreamFn {
53 AddBuffer(Task, std::move(*MBOrErr));
77 unsigned Task;
81 unsigned Task)
84 Task(Task) {}
130 AddBuffer(Task, std::move(*MBOrErr));
134 return [=](size_t Task) -> std::unique_ptr<NativeObjectStream> {
148 AddBuffer, std::move(*Temp), std::string(EntryPath.str()), Task);
LTOBackend.cpp 99 Hook = [=](unsigned Task, const Module &M) {
102 if (LinkerHook && !LinkerHook(Task, M))
108 // named from the provided OutputFileName with the Task ID appended.
111 if (Task != (unsigned)-1)
112 PathPrefix += utostr(Task) + ".";
342 bool lto::opt(const Config &Conf, TargetMachine *TM, unsigned Task, Module &Mod,
370 return !Conf.PostOptModuleHook || Conf.PostOptModuleHook(Task, Mod);
374 AddStreamFn AddStream, unsigned Task, Module &Mod,
376 if (Conf.PreCodeGenModuleHook && !Conf.PreCodeGenModuleHook(Task, Mod))
394 sys::path::append(DwoFile, std::to_string(Task) + ".dwo")
    [all...]
LTO.cpp 1167 unsigned Task, BitcodeModule BM,
1205 AddStreamFn AddStream, NativeObjectCache Cache, unsigned Task,
1218 return thinBackend(Conf, Task, AddStream, **MOrErr, CombinedIndex,
1236 if (AddStreamFn CacheAddStream = Cache(Task, Key))
1243 unsigned Task, BitcodeModule BM,
1264 AddStream, Cache, Task, BM, CombinedIndex, ImportList, ExportList,
1344 unsigned Task, BitcodeModule BM,
LTOCodeGenerator.cpp 249 [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
  /src/external/apache2/llvm/dist/llvm/include/llvm/Support/
ThreadPool.h 51 /// Asynchronous submission of a task to the pool. The returned future can be
52 /// used to wait for the task to finish and is *non-blocking* on destruction.
55 auto Task =
57 return asyncImpl(std::move(Task));
60 /// Asynchronous submission of a task to the pool. The returned future can be
61 /// used to wait for the task to finish and is *non-blocking* on destruction.
76 /// Asynchronous submission of a task to the pool. The returned future can be
77 /// used to wait for the task to finish and is *non-blocking* on destruction.
TaskQueue.h 9 // This file defines a crude C++11 based task queue.
32 /// guarantees that if task B is enqueued after task A, task B begins after
33 /// task A completes and there is no overlap between the two.
40 template <typename Callable> struct Task {
42 explicit Task(Callable C, TaskQueue &Parent)
68 /// Construct a task queue with no work.
77 /// Asynchronous submission of a task to the queue. The returned future can be
78 /// used to wait for the task (and all previous tasks that have not ye
    [all...]
  /src/external/apache2/llvm/dist/llvm/tools/gold/
gold-plugin.cpp 813 /// indicating whether a temp file should be generated, and an optional task id.
915 Conf.PreOptModuleHook = [](size_t Task, const Module &M) { return false; };
919 Conf.PostInternalizeModuleHook = [](size_t Task, const Module &M) {
923 Task);
1070 // Note that getOutputFileName will append a unique ID for each task
1083 [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
1084 Files[Task].second = !SaveTemps;
1086 Files[Task].first, Task);
1091 auto AddBuffer = [&](size_t Task, std::unique_ptr<MemoryBuffer> MB)
    [all...]
  /src/external/apache2/llvm/dist/llvm/tools/llvm-lto2/
llvm-lto2.cpp 366 [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
367 std::string Path = OutputFilename + "." + utostr(Task);
375 auto AddBuffer = [&](size_t Task, std::unique_ptr<MemoryBuffer> MB) {
376 *AddStream(Task)->OS << MB->getBuffer();
  /src/external/apache2/llvm/dist/llvm/examples/SpeculativeJIT/
SpeculativeJIT.cpp 116 [this](std::unique_ptr<Task> T) {
119 std::unique_ptr<Task> T(UnownedT);
  /src/external/apache2/llvm/dist/llvm/include/llvm/ExecutionEngine/Orc/
Core.h 1220 /// Represents an abstract task for ORC to run.
1221 class Task : public RTTIExtends<Task, RTTIRoot> {
1225 /// Description of the task to be performed. Used for logging.
1228 /// Run the task.
1235 /// A materialization task.
1236 class MaterializationTask : public RTTIExtends<MaterializationTask, Task> {
1265 using DispatchTaskFunction = unique_function<void(std::unique_ptr<Task> T)>;
1338 /// Set the task dispatch function.
1415 void dispatchTask(std::unique_ptr<Task> T)
    [all...]
  /src/external/apache2/llvm/dist/llvm/lib/Transforms/Utils/
BypassSlowDivision.cpp 152 // First, make sure that the task is valid.
466 FastDivInsertionTask Task(I, BypassWidths);
467 if (Value *Replacement = Task.getReplacement(PerBBDivCache)) {
  /src/external/gpl3/gcc.old/dist/libphobos/src/std/
parallelism.d 10 `std.parallelism` is based on the concept of a `Task`. A `Task` is an
12 executed in parallel with any other `Task`. Using `Task`
15 represent an additional level of abstraction over `Task`. They
16 automatically create one or more `Task` objects, or closely related types
19 After creation, a `Task` may be executed in a new thread, or submitted
20 to a `TaskPool` for execution. A `TaskPool` encapsulates a task queue
22 number of `Task`s onto a smaller number of threads. A task queue is
    [all...]
  /src/external/apache2/llvm/dist/clang/lib/CodeGen/
BackendUtil.cpp 1521 auto AddStream = [&](size_t Task) {
1572 Conf.PreCodeGenModuleHook = [](size_t Task, const Module &Mod) {
1577 Conf.PreCodeGenModuleHook = [&](size_t Task, const Module &Mod) {
1583 Conf.PreCodeGenModuleHook = [&](size_t Task, const Module &Mod) {
  /src/external/apache2/llvm/dist/llvm/tools/llvm-lto/
llvm-lto.cpp 1052 [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
1055 PartFilename += "." + utostr(Task);
  /src/external/apache2/llvm/dist/llvm/lib/ExecutionEngine/Orc/
LLJIT.cpp 1129 ES->setDispatchTask([this](std::unique_ptr<Task> T) {
1135 std::unique_ptr<Task> T(UnownedT);
Core.cpp 32 char Task::ID = 0;
177 class RunQueryCompleteTask : public Task {
1753 void Task::anchor() {}
1756 OS << "Materialization task: " << MU->getName() << " in "
2809 void ExecutionSession::dumpDispatchInfo(Task &T) {

Completed in 69 milliseconds