| /external/v8/src/compiler/ |
| verifier.h | 15 class Schedule;
28 // Verifies properties of a schedule, such as dominance, phi placement, etc.
31 static void Run(Schedule* schedule);
|
| pipeline.h | 21 class Schedule;
32 // Run the pipeline on a machine graph and generate code. If {schedule}
33 // is {NULL}, then compute a new schedule for code generation.
35 Schedule* schedule = NULL);
50 Schedule* ComputeSchedule(Graph* graph);
52 Handle<Code> GenerateCode(Linkage* linkage, Graph* graph, Schedule* schedule,
|
| scheduler.h | 11 #include "src/compiler/schedule.h"
18 // Computes a schedule from a graph, placing nodes into basic blocks and
23 // Create a new schedule and place all nodes from the graph into it.
24 static Schedule* ComputeSchedule(Graph* graph);
26 // Compute the RPO of blocks in an existing schedule.
27 static BasicBlockVector* ComputeSpecialRPO(Schedule* schedule);
30 // Build and connect the CFG for a node graph, but don't schedule nodes.
31 static void ComputeCFG(Graph* graph, Schedule* schedule);
[all...] |
| schedule.cc | 8 #include "src/compiler/schedule.h"
33 OStream& operator<<(OStream& os, const Schedule& s) {
35 BasicBlockVector* rpo = const_cast<Schedule*>(&s)->rpo_order();
|
| pipeline.cc | 22 #include "src/compiler/schedule.h"
146 static void TraceSchedule(Schedule* schedule) {
149 os << "-- Schedule --------------------------------------\n" << *schedule; local
306 // Compute a schedule.
307 Schedule* schedule = ComputeSchedule(&graph); local
311 code = GenerateCode(&linkage, &graph, schedule, &source_positions);
331 Schedule* Pipeline::ComputeSchedule(Graph* graph)
333 Schedule* schedule = Scheduler::ComputeSchedule(graph); local
[all...] |
| raw-machine-assembler.cc | 18 schedule_(new (zone()) Schedule(zone())),
25 exit_label_(schedule()->end()),
26 current_block_(schedule()->start()) {
39 Schedule* RawMachineAssembler::Export() {
44 Schedule* schedule = schedule_; local
46 return schedule;
63 DCHECK(current_block_ != schedule()->end());
64 schedule()->AddGoto(CurrentBlock(), Use(label));
71 DCHECK(current_block_ != schedule()->end())
[all...] |
| schedule.h | 152 // A schedule represents the result of assigning nodes to basic blocks
153 // and ordering them within basic blocks. Prior to computing a schedule,
155 // by the graph's dependencies. A schedule is required to generate code.
156 class Schedule : public GenericGraph<BasicBlock> {
158 explicit Schedule(Zone* zone)
189 // Return a list of all the blocks in the schedule, in arbitrary order.
296 BasicBlockVector all_blocks_; // All basic blocks in the schedule.
301 OStream& operator<<(OStream& os, const Schedule& s);
|
| code-generator.h | 33 Schedule* schedule() const { return code()->schedule(); } function in class:v8::internal::compiler::FINAL
|
| scheduler.cc | 32 // between them within a Schedule) from the node graph.
38 Schedule* schedule_;
227 Scheduler::Scheduler(Zone* zone, Graph* graph, Schedule* schedule)
230 schedule_(schedule),
237 Schedule* Scheduler::ComputeSchedule(Graph* graph) {
238 Schedule* schedule; local
242 schedule = new (graph->zone()) Schedule(graph->zone())
[all...] |
| raw-machine-assembler.h | 23 class Schedule;
404 Schedule* Export();
412 Schedule* schedule() { function in class:v8::internal::compiler::RawMachineAssembler
422 Schedule* schedule_;
|
| verifier.cc | 20 #include "src/compiler/schedule.h"
256 static bool HasDominatingDef(Schedule* schedule, Node* node,
274 static void CheckInputsDominate(Schedule* schedule, BasicBlock* block,
284 if (!HasDominatingDef(schedule, node->InputAt(j), block, use_block,
295 void ScheduleVerifier::Run(Schedule* schedule) {
296 const int count = schedule->BasicBlockCount();
297 Zone tmp_zone(schedule->zone()->isolate())
[all...] |
| instruction-selector.h | 32 // Visit code for the entire graph with the included schedule.
192 Schedule* schedule() const { return sequence()->schedule(); } function in class:v8::internal::compiler::FINAL
|
| /external/v8/test/mjsunit/regress/ |
| regress-crbug-385002.js | 7 %Break(); // Schedule an interrupt that does not go away.
|
| /external/v8/test/cctest/compiler/ |
| test-schedule.cc | 13 #include "src/compiler/schedule.h"
24 Schedule schedule(scope.main_zone());
26 CHECK_NE(NULL, schedule.start());
27 CHECK_EQ(schedule.start(), *(schedule.all_blocks().begin()));
37 Schedule schedule(scope.main_zone());
39 BasicBlock* entry = schedule.start();
40 schedule.AddNode(entry, n0)
[all...] |
| test-codegen-deopt.cc | 17 #include "src/compiler/schedule.h"
60 void GenerateCodeFromSchedule(Schedule* schedule) {
63 os << *schedule; local
69 schedule);
119 Schedule* BuildGraphAndSchedule(Graph* graph) {
122 // Manually construct a schedule for the function below:
160 // Schedule the graph:
161 Schedule* schedule = m.Export() local
271 Schedule* schedule = m.Export(); local
[all...] |
| test-scheduler.cc | 17 #include "src/compiler/schedule.h"
34 static TestLoop* CreateLoop(Schedule* schedule, int count) {
39 loop->nodes[i] = schedule->NewBasicBlock();
40 if (i > 0) schedule->AddSuccessor(loop->nodes[i - 1], loop->nodes[i]);
42 schedule->AddSuccessor(loop->nodes[count - 1], loop->nodes[0]);
70 static int GetScheduledNodeCount(Schedule* schedule) {
72 for (BasicBlockVectorIter i = schedule->rpo_order()->begin();
73 i != schedule->rpo_order()->end(); ++i)
94 Schedule* schedule = Scheduler::ComputeSchedule(graph); local
1626 Schedule* schedule = ComputeAndVerifySchedule(19, &graph); local
[all...] |
| instruction-selector-tester.h | 60 Schedule* schedule = Export(); local
64 InstructionSequence sequence(&linkage, graph(), schedule);
|
| /external/guava/guava/src/com/google/common/util/concurrent/ |
| AbstractScheduledService.java | 44 * the {@link #startUp} and {@link #shutDown} methods and also uses that service to schedule the
52 * #runOneIteration} takes longer than its schedule defines, then subsequent executions may start
103 * service with a fixed schedule. If more flexibility is needed then consider subclassing
123 public Future<?> schedule(AbstractService service, ScheduledExecutorService executor,
142 public Future<?> schedule(AbstractService service, ScheduledExecutorService executor,
150 abstract Future<?> schedule(AbstractService service, ScheduledExecutorService executor,
199 runningTask = scheduler().schedule(delegate, executorService, task);
414 * use a dynamically changing schedule. After every execution of the task, assuming it hasn't
476 final Schedule schedule = CustomScheduler.this.getNextSchedule()
[all...] |
| /external/guava/guava-tests/test/com/google/common/util/concurrent/ |
| AbstractScheduledServiceTest.java | 319 Scheduler schedule = Scheduler.newFixedRateSchedule(initialDelay, delay, unit); local
320 schedule.schedule(null, new ScheduledThreadPoolExecutor(1) {
332 Scheduler schedule = Scheduler.newFixedDelaySchedule(initialDelay, delay, unit); local
333 schedule.schedule(null, new ScheduledThreadPoolExecutor(10) {
347 protected Schedule getNextSchedule() throws Exception {
349 return new Schedule(0, TimeUnit.SECONDS);
370 Future<?> future = scheduler.schedule(null, Executors.newScheduledThreadPool(10), task);
399 protected Schedule getNextSchedule() throws Exception
[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...] |
| ScheduleDAGSDNodes.h | 42 /// The schedule. Null SUnit*'s represent noop instructions.
105 /// Schedule - Order nodes according to selected style, filling
108 virtual void Schedule() = 0;
|
| ScheduleDAGFast.cpp | 84 void Schedule() override;
116 /// Schedule - Schedule the DAG using list scheduling.
117 void ScheduleDAGFast::Schedule() {
180 /// ScheduleNodeBottomUp - Add the node to the schedule. Decrement the pending
474 /// If the specific node is the last one that's available to schedule, do
548 // priority. If it is not ready put it back. Schedule the node.
656 void Schedule() override;
690 // Schedule glue operand right above N.
724 void ScheduleDAGLinearize::Schedule() {
[all...] |
| /external/lldb/examples/test/ |
| usage-pre-post-flight | 18 Schedule: normal
|
| usage-lldb-loggings | 19 Schedule: normal
80 Schedule: normal
|
| /external/clang/lib/CodeGen/ |
| CGOpenMPRuntime.cpp | [all...] |
