| /external/v8/src/compiler/ |
| basic-block-instrumentor.h | 19 class Schedule;
24 Graph* graph, Schedule* schedule);
|
| machine-graph-verifier.h | 17 class Schedule;
23 static void Run(Graph* graph, Schedule const* const schedule,
|
| verifier.h | 18 class Schedule;
57 // Verifies properties of a schedule, such as dominance, phi placement, etc.
60 static void Run(Schedule* schedule);
|
| pipeline.h | 31 class Schedule;
48 // Run the pipeline on a machine graph and generate code. The {schedule} must
52 Graph* graph, Schedule* schedule,
60 // Run the pipeline on a machine graph and generate code. If {schedule} is
61 // {nullptr}, then compute a new schedule for code generation.
64 Schedule* schedule = nullptr);
71 // Run the pipeline on a machine graph and generate code. If {schedule} is
72 // {nullptr}, then compute a new schedule for code generation
[all...] |
| scheduler.h | 11 #include "src/compiler/schedule.h"
27 // Computes a schedule from a graph, placing nodes into basic blocks and
35 // The complete scheduling algorithm. Creates a new schedule and places all
37 static Schedule* ComputeSchedule(Zone* zone, Graph* graph, Flags flags);
39 // Compute the RPO of blocks in an existing schedule.
40 static BasicBlockVector* ComputeSpecialRPO(Zone* zone, Schedule* schedule);
66 Schedule* schedule_;
76 Scheduler(Zone* zone, Graph* graph, Schedule* schedule, Flags flags)
[all...] |
| schedule.cc | 5 #include "src/compiler/schedule.h"
128 Schedule::Schedule(Zone* zone, size_t node_count_hint)
139 BasicBlock* Schedule::block(Node* node) const {
147 bool Schedule::IsScheduled(Node* node) {
153 BasicBlock* Schedule::GetBlockById(BasicBlock::Id block_id) {
159 bool Schedule::SameBasicBlock(Node* a, Node* b) const {
165 BasicBlock* Schedule::NewBasicBlock() {
173 void Schedule::PlanNode(BasicBlock* block, Node* node) {
184 void Schedule::AddNode(BasicBlock* block, Node* node)
[all...] |
| graph-visualizer.h | 24 class Schedule;
53 AsC1V(const char* phase, const Schedule* schedule,
56 : schedule_(schedule),
60 const Schedule* schedule_;
|
| effect-control-linearizer.h | 28 class Schedule;
33 EffectControlLinearizer(JSGraph* graph, Schedule* schedule, Zone* temp_zone,
140 Schedule* schedule() const { return schedule_; } function in class:v8::internal::compiler::EffectControlLinearizer
149 Schedule* schedule_;
|
| schedule.h | 179 // A schedule represents the result of assigning nodes to basic blocks
180 // and ordering them within basic blocks. Prior to computing a schedule,
182 // by the graph's dependencies. A schedule is required to generate code.
183 class V8_EXPORT_PRIVATE Schedule final : public NON_EXPORTED_BASE(ZoneObject) {
185 explicit Schedule(Zone* zone, size_t node_count_hint = 0);
265 // Ensure split-edge form for a hand-assembled schedule.
279 BasicBlockVector all_blocks_; // All basic blocks in the schedule.
285 DISALLOW_COPY_AND_ASSIGN(Schedule);
288 V8_EXPORT_PRIVATE std::ostream& operator<<(std::ostream&, const Schedule&);
|
| /external/eigen/unsupported/Eigen/CXX11/src/ThreadPool/ |
| ThreadPoolInterface.h | 19 virtual void Schedule(std::function<void()> fn) = 0;
|
| /external/eigen/unsupported/test/ |
| cxx11_tensor_notification.cpp | 42 thread_pool.Schedule(func);
66 thread_pool.Schedule(func);
67 thread_pool.Schedule(func);
68 thread_pool.Schedule(func);
69 thread_pool.Schedule(func);
|
| cxx11_non_blocking_thread_pool.cpp | 36 // Schedule kThreads tasks and ensure that they all are running.
38 tp.Schedule([&]() {
52 // Now, while the previous tasks exit, schedule another kThreads tasks and
55 tp.Schedule([&, i]() {
60 // continue running and quarter of tasks schedule another 2 tasks each.
72 tp.Schedule([&]() {
88 tp.Schedule([&]() {
|
| /external/llvm/lib/CodeGen/ |
| MachinePipeliner.cpp | 38 // 3) Attempt to schedule the nodes in the specified order using the MII.
53 // where an instruction may be inserted in the pipelined schedule.
195 /// and attempts to schedule the instructions using the SMS algorithm.
198 /// The minimum initiation interval between iterations for this schedule.
200 /// Set to true if a valid pipelined schedule is found for the loop.
227 /// Instructions to change when emitting the final schedule.
267 void schedule();
332 /// Set the Minimum Initiation Interval for this schedule attempt.
335 MachineInstr *applyInstrChange(MachineInstr *MI, SMSchedule &Schedule,
365 bool schedulePipeline(SMSchedule &Schedule);
819 void SwingSchedulerDAG::schedule() { function in class:SwingSchedulerDAG
[all...] |
| /external/eigen/unsupported/Eigen/CXX11/src/Tensor/ |
| TensorDeviceThreadPool.h | 154 pool_->Schedule(std::bind(&FunctionWrapperWithNotification<Function, Args...>::run, n, f, args...));
162 pool_->Schedule(std::bind(
168 pool_->Schedule(std::bind(f, args...));
258 pool_->Schedule([=, &handleRange]() { handleRange(mid, last); });
259 pool_->Schedule([=, &handleRange]() { handleRange(first, mid); });
|
| /external/guava/guava-tests/test/com/google/common/util/concurrent/ |
| AbstractScheduledServiceTest.java | 301 Scheduler schedule = Scheduler.newFixedRateSchedule(initialDelay, delay, unit); local
302 schedule.schedule(null, new ScheduledThreadPoolExecutor(1) {
314 Scheduler schedule = Scheduler.newFixedDelaySchedule(initialDelay, delay, unit); local
315 schedule.schedule(null, new ScheduledThreadPoolExecutor(10) {
329 protected Schedule getNextSchedule() throws Exception {
331 return new Schedule(0, TimeUnit.SECONDS);
352 Future<?> future = scheduler.schedule(null, Executors.newScheduledThreadPool(10), task);
381 protected Schedule getNextSchedule() throws Exception
[all...] |
| /external/guava/guava/src/com/google/common/util/concurrent/ |
| AbstractScheduledService.java | 46 * the {@link #startUp} and {@link #shutDown} methods and also uses that service to schedule the
54 * #runOneIteration} takes longer than its schedule defines, then subsequent executions may start
105 * service with a fixed schedule. If more flexibility is needed then consider subclassing
125 public Future<?> schedule(AbstractService service, ScheduledExecutorService executor,
144 public Future<?> schedule(AbstractService service, ScheduledExecutorService executor,
152 abstract Future<?> schedule(AbstractService service, ScheduledExecutorService executor,
201 runningTask = scheduler().schedule(delegate, executorService, task);
391 * use a dynamically changing schedule. After every execution of the task, assuming it hasn't
453 final Schedule schedule = CustomScheduler.this.getNextSchedule()
[all...] |
| /art/compiler/optimizing/ |
| scheduler.cc | 478 // Schedule condition inputs that can be materialized immediately before their use.
508 // Remove the condition from the list of candidates and schedule it.
551 // If both critical paths are equal, schedule instructions with a higher latency
556 void HScheduler::Schedule(HGraph* graph) {
567 Schedule(block);
572 void HScheduler::Schedule(HBasicBlock* block) {
610 // Schedule all nodes.
612 Schedule(selector_->PopHighestPriorityNode(&candidates_, scheduling_graph_));
625 void HScheduler::Schedule(SchedulingNode* scheduling_node) {
648 Schedule(scheduling_node->GetInstruction())
[all...] |
| scheduler.h | 40 // we can and want to schedule:
44 // 2) Schedule the dependency graph.
49 // - The heuristics used to decide what node to schedule in the topological sort
91 // Since we schedule backwards (starting from the last instruction in each basic
102 // As we schedule backwards, `B` will be selected for scheduling before `A` is.
115 // We schedule `n3` as the last (and only) instruction. All its predecessors
130 // The only candidate available for scheduling is `n2`. Schedule it before
215 // `HScheduler::Schedule(SchedulingNode* scheduling_node)`).
235 // becomes a valid candidate to schedule.
439 void Schedule(HGraph* graph)
[all...] |
| /external/llvm/lib/CodeGen/SelectionDAG/ |
| ScheduleDAGVLIW.cpp | 11 // The basic approach uses a priority queue of available nodes to schedule.
13 // order), checked for legality to schedule, and emitted if legal.
15 // Nodes may not be legal to schedule either due to structural hazards (e.g.
84 void Schedule() override;
94 /// Schedule - Schedule the DAG using list scheduling.
95 void ScheduleDAGVLIW::Schedule() {
151 /// scheduleNodeTopDown - Add the node to the schedule. Decrement the pending
185 // priority. If it is not ready put it back. Schedule the node.
238 // If we found a node to schedule, do it now
[all...] |
| /external/swiftshader/third_party/LLVM/lib/CodeGen/SelectionDAG/ |
| ScheduleDAGList.cpp | 11 // The basic approach uses a priority queue of available nodes to schedule.
13 // order), checked for legality to schedule, and emitted if legal.
15 // Nodes may not be legal to schedule either due to structural hazards (e.g.
78 void Schedule();
88 /// Schedule - Schedule the DAG using list scheduling.
89 void ScheduleDAGList::Schedule() {
140 /// ScheduleNodeTopDown - Add the node to the schedule. Decrement the pending
174 // priority. If it is not ready put it back. Schedule the node.
224 // If we found a node to schedule, do it now
[all...] |
| ScheduleDAGSDNodes.h | 108 /// Schedule - Order nodes according to selected style, filling
111 virtual void Schedule() = 0;
|
| /prebuilts/go/darwin-x86/src/cmd/compile/internal/ssa/ |
| schedule.go | 60 // Schedule the Values in each Block. After this phase returns, the
63 // reasonable valid schedule using a priority queue. TODO(khr):
64 // schedule smarter.
65 func schedule(f *Func) { func
113 // Schedule stores as early as possible. This tends to
118 // Schedule the pseudo-op of reading part of a tuple
125 // Schedule flag register generation as late as possible.
183 // Schedule values dependent on the control value at the end.
211 // Schedule highest priority value, update use counts, repeat.
216 // Note that schedule is assembled backwards
[all...] |
| /prebuilts/go/linux-x86/src/cmd/compile/internal/ssa/ |
| schedule.go | 60 // Schedule the Values in each Block. After this phase returns, the
63 // reasonable valid schedule using a priority queue. TODO(khr):
64 // schedule smarter.
65 func schedule(f *Func) { func
113 // Schedule stores as early as possible. This tends to
118 // Schedule the pseudo-op of reading part of a tuple
125 // Schedule flag register generation as late as possible.
183 // Schedule values dependent on the control value at the end.
211 // Schedule highest priority value, update use counts, repeat.
216 // Note that schedule is assembled backwards
[all...] |
| /device/linaro/bootloader/edk2/AppPkg/Applications/Sockets/WebServer/ |
| DxeServicesTable.c | 191 "Schedule",
192 (VOID *)pDS->Schedule,
|
| /external/clang/include/clang/Basic/ |
| OpenMPKinds.h | 58 /// \brief OpenMP attributes for 'schedule' clause.
66 /// \brief OpenMP modifiers for 'schedule' clause.
125 OpenMPScheduleClauseKind Schedule = OMPC_SCHEDULE_unknown;
|
