| /external/llvm/lib/CodeGen/ |
| InterferenceCache.cpp | 83 Blocks.resize(MF->getNumBlockIDs());
130 BlockInterference *BI = &Blocks[MBBNum];
182 BI = &Blocks[MBBNum];
|
| SpillPlacement.cpp | 13 // basic blocks are weighted by the block frequency and added to become the node
16 // Transparent basic blocks have the variable live through, but don't care if it
17 // is spilled or in a register. These blocks become connections in the Hopfield
76 /// Bias - Normalized contributions from non-transparent blocks.
88 /// Links - (Weight, BundleNo) for all transparent blocks connecting to other
92 /// connected basic blocks.
123 // Normalize w relative to all connected blocks from that direction.
139 // Normalize w relative to all connected blocks from that direction.
213 // allocate registers when so many different blocks are involved.
216 // connected blocks need to be interested before we consider expanding th
[all...] |
| MachineBlockPlacement.cpp | 14 // a topological ordering of basic blocks) in the absence of a *strong* signal
17 // blocks adjacent to each other.
20 // at each stage walks through the basic blocks, trying to coalesce them into
22 // probabilities). Finally, it walks the blocks in topological order, and the
23 // first time it reaches a chain of basic blocks, it schedules them in the
62 /// \brief A chain of blocks which will be laid out contiguously.
64 /// This is the datastructure representing a chain of consecutive blocks that
67 /// a sequence of basic blocks which have some external (correctness)
74 /// \brief The sequence of blocks belonging to this chain.
76 /// This is the sequence of blocks for a particular chain. These will be lai
[all...] |
| RegAllocGreedy.cpp | 175 /// All basic blocks where the current register has uses.
750 // Add constraints for use-blocks. Note that these are the only constraints
758 /// live-through blocks in Blocks.
760 ArrayRef<unsigned> Blocks) {
766 for (unsigned i = 0; i != Blocks.size(); ++i) {
767 unsigned Number = Blocks[i];
808 // Keep track of through blocks that have not been added to SpillPlacer.
818 // Find new through blocks in the periphery of PrefRegBundles.
821 // Look at all blocks connected to Bundle in the full graph
[all...] |
| MachineLICM.cpp | 83 // Exit blocks for CurLoop.
111 // If a MBB does not dominate loop exiting blocks then it may not safe
235 /// blocks dominated by the specified header block, and that are in the
505 const std::vector<MachineBasicBlock*> Blocks = CurLoop->getBlocks();
506 for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
507 MachineBasicBlock *BB = Blocks[i];
587 const std::vector<MachineBasicBlock*> Blocks = CurLoop->getBlocks();
588 for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
589 MachineBasicBlock *BB = Blocks[i];
636 // Check loop exiting blocks
[all...] |
| MachineTraceMetrics.cpp | 191 // pickTracePred() is called on the post-ordered blocks. During the downwards
320 // revisit blocks.
324 MutableArrayRef<MachineTraceMetrics::TraceBlockInfo> Blocks;
328 LoopBounds(MutableArrayRef<MachineTraceMetrics::TraceBlockInfo> blocks,
330 : Blocks(blocks), Loops(loops), Downward(false) {}
345 // Skip already visited To blocks.
346 MachineTraceMetrics::TraceBlockInfo &TBI = LB.Blocks[To->getNumber()];
421 // Invalidate height resources of blocks above MBB.
447 // Invalidate depth resources of blocks below MBB
[all...] |
| /external/v8/src/ia32/ |
| lithium-gap-resolver-ia32.cc | 107 // as this one's destination blocks this one so recursively perform all
111 if (other_move.Blocks(destination) && !other_move.IsPending()) {
141 if (other_move.Blocks(destination)) {
464 if (other_move.Blocks(source)) {
466 } else if (other_move.Blocks(destination)) {
|
| /external/v8/src/arm/ |
| lithium-gap-resolver-arm.cc | 115 // as this one's destination blocks this one so recursively perform all
119 if (other_move.Blocks(destination) && !other_move.IsPending()) {
135 if (other_move.Blocks(destination)) {
|
| /external/v8/src/mips/ |
| lithium-gap-resolver-mips.cc | 116 // as this one's destination blocks this one so recursively perform all
120 if (other_move.Blocks(destination) && !other_move.IsPending()) {
136 if (other_move.Blocks(destination)) {
|
| /external/llvm/tools/llvm-diff/ |
| DifferenceEngine.cpp | 121 /// The current mapping from old blocks to new blocks.
122 DenseMap<BasicBlock*, BasicBlock*> Blocks;
129 if (!Blocks.count(*I)) Count++;
136 /// predecessor blocks it has remaining.
149 /// A queue of unified blocks to process.
152 /// Try to unify the given two blocks. Enqueues them for processing
157 BasicBlock *&Ref = Blocks[L];
392 return Blocks[cast<BlockAddress>(L)->getBasicBlock()]
448 return Blocks[cast<BasicBlock>(L)] != R
[all...] |
| /external/llvm/tools/bugpoint/ |
| Miscompilation.cpp | 43 cl::desc("Don't extract blocks when searching for miscompilations"),
459 /// TestFuncs - Extract all blocks for the miscompiled functions except for the
460 /// specified blocks. If the problem still exists, return true.
468 outs() << "but these " << BBs.size() << " blocks are extracted: ";
473 outs() << "blocks are extracted.";
516 /// extract as many basic blocks from the region as possible without obscuring
526 std::vector<BasicBlock*> Blocks;
530 Blocks.push_back(I);
532 // Use the list reducer to identify blocks that can be extracted without
533 // obscuring the bug. The Blocks list will end up containing blocks that mus
[all...] |
| /external/llvm/include/llvm/Support/ |
| GCOV.h | 183 SmallVector<GCOVBlock *, 16> Blocks;
|
| /external/clang/lib/AST/ |
| CommentParser.cpp | 748 SmallVector<BlockContentComment *, 8> Blocks;
750 Blocks.push_back(parseBlockContent());
756 return S.actOnFullComment(S.copyArray(llvm::makeArrayRef(Blocks)));
|
| CommentSema.cpp | 543 ArrayRef<BlockContentComment *> Blocks) {
544 FullComment *FC = new (Allocator) FullComment(Blocks, ThisDeclInfo);
[all...] |
| /external/llvm/include/llvm/Analysis/ |
| LoopInfoImpl.h | 27 /// getExitingBlocks - Return all blocks inside the loop that have successors
28 /// outside of the loop. These are the blocks _inside of the current loop_
34 // Sort the blocks vector so that we can use binary search to do quick
62 /// getExitBlocks - Return all of the successor blocks of this loop. These
63 /// are the blocks _outside of the current loop_ which are branched to.
68 // Sort the blocks vector so that we can use binary search to do quick
98 // Sort the blocks vector so that we can use binary search to do quick
201 assert((Blocks.empty() || LIB[getHeader()] == this) &&
213 L->Blocks.push_back(NewBB);
239 assert(!Blocks.empty() && "Loop header is missing")
[all...] |
| /external/clang/include/clang/AST/ |
| CommentSema.h | 190 FullComment *actOnFullComment(ArrayRef<BlockContentComment *> Blocks);
|
| /external/llvm/lib/Transforms/Utils/ |
| LoopSimplify.cpp | 18 // Loop exit-block insertion guarantees that all exit blocks from the loop
19 // (blocks which are outside of the loop that have predecessors inside of the
31 // Note that the simplifycfg pass will clean up blocks which are split out but
64 STATISTIC(NumInserted, "Number of pre-header or exit blocks inserted");
148 // Check to see that no blocks (other than the header) in this loop have
150 // loops, but can occur if the blocks are unreachable. Since they are
183 // If there are exiting blocks with branches on undef, resolve the undef in
220 // loop preheader/header will dominate the exit blocks. If the exit block has
338 // (spliting edges doesn't count). If blocks, CFG edges, or other values
414 /// blocks. This method is used to split exit blocks that have predecessor
[all...] |
| /frameworks/base/docs/html/design/ |
| design_toc.cs | 50 <div class="nav-section-header"><a href="<?cs var:toroot ?>design/building-blocks/index.html">Building Blocks</a></div>
52 <li><a href="<?cs var:toroot ?>design/building-blocks/tabs.html">Tabs</a></li>
53 <li><a href="<?cs var:toroot ?>design/building-blocks/lists.html">Lists</a></li>
54 <li><a href="<?cs var:toroot ?>design/building-blocks/grid-lists.html">Grid Lists</a></li>
55 <li><a href="<?cs var:toroot ?>design/building-blocks/scrolling.html">Scrolling</a></li>
56 <li><a href="<?cs var:toroot ?>design/building-blocks/spinners.html">Spinners</a></li>
57 <li><a href="<?cs var:toroot ?>design/building-blocks/buttons.html">Buttons</a></li>
58 <li><a href="<?cs var:toroot ?>design/building-blocks/text-fields.html">Text Fields</a></li>
59 <li><a href="<?cs var:toroot ?>design/building-blocks/seek-bars.html">Seek Bars</a></li
[all...] |
| /external/clang/lib/Basic/ |
| Module.cpp | 58 .Case("blocks", LangOpts.Blocks)
|
| /external/llvm/lib/Target/Hexagon/ |
| HexagonHardwareLoops.cpp | 880 const std::vector<MachineBasicBlock*> Blocks = L->getBlocks();
881 for (unsigned i = 0, e = Blocks.size(); i != e; ++i) {
882 MachineBasicBlock *MBB = Blocks[i];
[all...] |
| /external/v8/src/ |
| lithium.h | 227 bool Blocks(LOperand* operand) const {
|
| /external/ceres-solver/docs/ |
| faq.tex | 11 Why does Ceres use blocks (ParameterBlocks and ResidualBlocks) ?
14 Most non-linear solvers we are aware of, define the problem and residuals in terms of scalars and it is possible to do this with Ceres also. However, it is our experience that in most problems small groups of scalars occur together. For example the three components of a translation vector and the four components of the quaternion that define the pose of a camera. Same is true for residuals, where it is common to have small vectors of residuals rather than just scalars. There are a number of advantages of using blocks. It saves on indexing information, which for large problems can be substantial. Blocks translate into contiguous storage in memory which is more cache friendly and last but not the least, it allows us to use SIMD/SSE based BLAS routines to significantly speed up various matrix operations.
21 In most problems there is a natural parameter block structure, as there is a semantic meaning associated with groups of scalars -- mean vector of a distribution, color of a pixel etc. To group two scalar variables, ask yourself if residual blocks will always use these two variables together. If the answer is yes, then the two variables belong to the same parameter block.
28 While it is often the case that problems have a natural blocking of parameters into parameter blocks, it is not always clear what a good residual block structure is. One rule of thumb for non-linear least squares problems since they often come from data fitting problems is to create one residual block per observation. So if you are solving a Structure from Motion problem, one 2 dimensional residual block per 2d image projection is a good idea.
32 For example consider the following residual block of size 18 which depends on four parameter blocks of size 4 each. Shown below is the Jacobian structure of this residual block, the numbers in the columns indicate the size, and the numbers in the rows show a grouping of the matrix that best capture its sparsity structure. \texttt{X} indicates a non-zero block, the rest of the blocks are zero.
45 Notice that out of the 20 cells, only 8 are non-zero, in fact out of the 288 entries only 48 entries are non-zero, thus we are hiding substantial sparsity from the solver, and using up much more memory. It is much better to break this up into 5 residual blocks. One residual block of size 2 that depends on all four parameter block and four residual blocks of size 4 each that depend on one parameter block at a time.
|
| /external/clang/lib/Rewrite/Frontend/ |
| RewriteObjC.cpp | 122 SmallVector<BlockExpr *, 32> Blocks;
[all...] |
| RewriteModernObjC.cpp | 131 SmallVector<BlockExpr *, 32> Blocks;
[all...] |
| /external/clang/lib/Frontend/ |
| InitPreprocessor.cpp | 414 if (LangOpts.Blocks) {
[all...] |
