[cfe-commits] r49635 - in /cfe/trunk: include/clang/Rewrite/RewriteRope.h lib/Rewrite/DeltaTree.cpp lib/Rewrite/Rewriter.cpp
Chris Lattner
sabre at nondot.org
Mon Apr 14 00:17:30 PDT 2008
Author: lattner
Date: Mon Apr 14 02:17:29 2008
New Revision: 49635
URL: http://llvm.org/viewvc/llvm-project?rev=49635&view=rev
Log:
Change the RewriteRope::Chunks data structure from an std::list into
a nice shiny B+ Tree variant. This fixes the last of the known algorithmic
issues with the rewriter, allowing a significant speedup. For example,
-emit-html on Ted's 500K .i file speeds up from 26.8s -> 0.64s in a
debug build (41x!) and 5.475s -> 0.132s (41x!) in an optimized build.
This code is functional but needs to be cleaned up, ifdefs removed, better
commented, and moved to a .cpp file. I plan to do this tomorrow.
Modified:
cfe/trunk/include/clang/Rewrite/RewriteRope.h
cfe/trunk/lib/Rewrite/DeltaTree.cpp
cfe/trunk/lib/Rewrite/Rewriter.cpp
Modified: cfe/trunk/include/clang/Rewrite/RewriteRope.h
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/include/clang/Rewrite/RewriteRope.h?rev=49635&r1=49634&r2=49635&view=diff
==============================================================================
--- cfe/trunk/include/clang/Rewrite/RewriteRope.h (original)
+++ cfe/trunk/include/clang/Rewrite/RewriteRope.h Mon Apr 14 02:17:29 2008
@@ -18,11 +18,24 @@
#include <list>
#include <cstring>
+#include "llvm/Support/Casting.h"
+
+//#define USE_ROPE_VECTOR
+
namespace clang {
struct RopeRefCountString {
unsigned RefCount;
char Data[1]; // Variable sized.
+
+ void addRef() {
+ if (this) ++RefCount;
+ }
+
+ void dropRef() {
+ if (this && --RefCount == 0)
+ delete [] (char*)this;
+ }
};
struct RopePiece {
@@ -30,18 +43,29 @@
unsigned StartOffs;
unsigned EndOffs;
+ RopePiece() : StrData(0), StartOffs(0), EndOffs(0) {}
+
RopePiece(RopeRefCountString *Str, unsigned Start, unsigned End)
: StrData(Str), StartOffs(Start), EndOffs(End) {
- ++StrData->RefCount;
+ StrData->addRef();
}
RopePiece(const RopePiece &RP)
: StrData(RP.StrData), StartOffs(RP.StartOffs), EndOffs(RP.EndOffs) {
- ++StrData->RefCount;
+ StrData->addRef();
}
~RopePiece() {
- if (--StrData->RefCount == 0)
- delete [] (char*)StrData;
+ StrData->dropRef();
+ }
+
+ void operator=(const RopePiece &RHS) {
+ if (StrData != RHS.StrData) {
+ StrData->dropRef();
+ StrData = RHS.StrData;
+ StrData->addRef();
+ }
+ StartOffs = RHS.StartOffs;
+ EndOffs = RHS.EndOffs;
}
const char &operator[](unsigned Offset) const {
@@ -53,8 +77,668 @@
unsigned size() const { return EndOffs-StartOffs; }
};
+
+
+
+#ifndef USE_ROPE_VECTOR
+ using llvm::dyn_cast;
+ using llvm::cast;
+
+/// This is an adapted B+ Tree, ... erases don't keep the tree balanced.
+
+class RopePieceBTreeNode;
+struct InsertResult {
+ RopePieceBTreeNode *LHS, *RHS;
+};
+
+class RopePieceBTreeNode {
+protected:
+ /// WidthFactor - This controls the number of K/V slots held in the BTree:
+ /// how wide it is. Each level of the BTree is guaranteed to have at least
+ /// 'WidthFactor' elements in it (either ropepieces or children), (except the
+ /// root, which may have less) and may have at most 2*WidthFactor elements.
+ enum { WidthFactor = 8 };
+
+ /// Size - This is the number of bytes of file this node (including any
+ /// potential children) covers.
+ unsigned Size;
+
+ /// IsLeaf - True if this is an instance of RopePieceBTreeLeaf, false if it is
+ /// an instance of RopePieceBTreeInterior.
+ bool IsLeaf;
+
+ RopePieceBTreeNode(bool isLeaf) : IsLeaf(isLeaf) {}
+ ~RopePieceBTreeNode() {}
+public:
+
+ bool isLeaf() const { return IsLeaf; }
+ unsigned size() const { return Size; }
+
+ void Destroy();
+
+ /// split - Split the range containing the specified offset so that we are
+ /// guaranteed that there is a place to do an insertion at the specified
+ /// offset. The offset is relative, so "0" is the start of the node. This
+ /// returns true if the insertion could not be done in place, and returns
+ /// information in 'Res' about the piece that is percolated up.
+ bool split(unsigned Offset, InsertResult *Res);
+
+ /// insert - Insert the specified ropepiece into this tree node at the
+ /// specified offset. The offset is relative, so "0" is the start of the
+ /// node. This returns true if the insertion could not be done in place, and
+ /// returns information in 'Res' about the piece that is percolated up.
+ bool insert(unsigned Offset, const RopePiece &R, InsertResult *Res);
-class RewriteRope;
+ /// erase - Remove NumBytes from this node at the specified offset. We are
+ /// guaranteed that there is a split at Offset.
+ void erase(unsigned Offset, unsigned NumBytes);
+
+ static inline bool classof(const RopePieceBTreeNode *) { return true; }
+
+};
+
+
+
+
+class RopePieceBTreeLeaf : public RopePieceBTreeNode {
+ /// NumPieces - This holds the number of rope pieces currently active in the
+ /// Pieces array.
+ unsigned char NumPieces;
+
+ /// Pieces - This tracks the file chunks currently in this leaf.
+ ///
+ RopePiece Pieces[2*WidthFactor];
+
+ /// NextLeaf - This is a pointer to the next leaf in the tree, allowing
+ /// efficient in-order forward iteration of the tree without traversal.
+ const RopePieceBTreeLeaf *NextLeaf;
+public:
+ RopePieceBTreeLeaf() : RopePieceBTreeNode(true), NextLeaf(0) {}
+
+ bool isFull() const { return NumPieces == 2*WidthFactor; }
+
+ /// clear - Remove all rope pieces from this leaf.
+ void clear() {
+ while (NumPieces)
+ Pieces[--NumPieces] = RopePiece();
+ Size = 0;
+ }
+
+ unsigned getNumPieces() const { return NumPieces; }
+
+ const RopePiece &getPiece(unsigned i) const {
+ assert(i < getNumPieces() && "Invalid piece ID");
+ return Pieces[i];
+ }
+
+ const RopePieceBTreeLeaf *getNextLeafInOrder() const { return NextLeaf; }
+ void setNextLeafInOrder(const RopePieceBTreeLeaf *NL) { NextLeaf = NL; }
+
+ void FullRecomputeSizeLocally() {
+ Size = 0;
+ for (unsigned i = 0, e = getNumPieces(); i != e; ++i)
+ Size += getPiece(i).size();
+ }
+
+ /// split - Split the range containing the specified offset so that we are
+ /// guaranteed that there is a place to do an insertion at the specified
+ /// offset. The offset is relative, so "0" is the start of the node. This
+ /// returns true if the insertion could not be done in place, and returns
+ /// information in 'Res' about the piece that is percolated up.
+ bool split(unsigned Offset, InsertResult *Res);
+
+ /// insert - Insert the specified ropepiece into this tree node at the
+ /// specified offset. The offset is relative, so "0" is the start of the
+ /// node. This returns true if the insertion could not be done in place, and
+ /// returns information in 'Res' about the piece that is percolated up.
+ bool insert(unsigned Offset, const RopePiece &R, InsertResult *Res);
+
+
+ /// erase - Remove NumBytes from this node at the specified offset. We are
+ /// guaranteed that there is a split at Offset.
+ void erase(unsigned Offset, unsigned NumBytes);
+
+ static inline bool classof(const RopePieceBTreeLeaf *) { return true; }
+ static inline bool classof(const RopePieceBTreeNode *N) {
+ return N->isLeaf();
+ }
+};
+
+/// split - Split the range containing the specified offset so that we are
+/// guaranteed that there is a place to do an insertion at the specified
+/// offset. The offset is relative, so "0" is the start of the node. This
+/// returns true if the insertion could not be done in place, and returns
+/// information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeLeaf::split(unsigned Offset, InsertResult *Res) {
+ // Find the insertion point. We are guaranteed that there is a split at the
+ // specified offset so find it.
+ if (Offset == 0 || Offset == size()) {
+ // Fastpath for a common case. There is already a splitpoint at the end.
+ return false;
+ }
+
+ // Find the piece that this offset lands in.
+ unsigned PieceOffs = 0;
+ unsigned i = 0;
+ while (Offset >= PieceOffs+Pieces[i].size()) {
+ PieceOffs += Pieces[i].size();
+ ++i;
+ }
+
+ // If there is already a split point at the specified offset, just return
+ // success.
+ if (PieceOffs == Offset)
+ return false;
+
+ // Otherwise, we need to split piece 'i' at Offset-PieceOffs. Convert Offset
+ // to being Piece relative.
+ unsigned IntraPieceOffset = Offset-PieceOffs;
+
+ // We do this by shrinking the RopePiece and then doing an insert of the tail.
+ RopePiece Tail(Pieces[i].StrData, Pieces[i].StartOffs+IntraPieceOffset,
+ Pieces[i].EndOffs);
+ Size -= Pieces[i].size();
+ Pieces[i].EndOffs = Pieces[i].StartOffs+IntraPieceOffset;
+ Size += Pieces[i].size();
+
+ return insert(Offset, Tail, Res);
+}
+
+
+/// insert - Insert the specified RopePiece into this tree node at the
+/// specified offset. The offset is relative, so "0" is the start of the
+/// node. This returns true if the insertion could not be done in place, and
+/// returns information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeLeaf::insert(unsigned Offset, const RopePiece &R,
+ InsertResult *Res) {
+ // If this node is not full, insert the piece.
+ if (!isFull()) {
+ // Find the insertion point. We are guaranteed that there is a split at the
+ // specified offset so find it.
+ unsigned i = 0, e = getNumPieces();
+ if (Offset == size()) {
+ // Fastpath for a common case.
+ i = e;
+ } else {
+ unsigned SlotOffs = 0;
+ for (; Offset > SlotOffs; ++i)
+ SlotOffs += getPiece(i).size();
+ assert(SlotOffs == Offset && "Split didn't occur before insertion!");
+ }
+
+ // For an insertion into a non-full leaf node, just insert the value in
+ // its sorted position. This requires moving later values over.
+ for (; i != e; --e)
+ Pieces[e] = Pieces[e-1];
+ Pieces[i] = R;
+ ++NumPieces;
+ Size += R.size();
+ return false;
+ }
+
+ // Otherwise, if this is leaf is full, split it in two halves. Since this
+ // node is full, it contains 2*WidthFactor values. We move the first
+ // 'WidthFactor' values to the LHS child (which we leave in this node) and
+ // move the last 'WidthFactor' values into the RHS child.
+
+ // Create the new node.
+ RopePieceBTreeLeaf *NewNode = new RopePieceBTreeLeaf();
+
+ // Move over the last 'WidthFactor' values from here to NewNode.
+ std::copy(&Pieces[WidthFactor], &Pieces[2*WidthFactor],
+ &NewNode->Pieces[0]);
+ // Replace old pieces with null RopePieces to drop refcounts.
+ std::fill(&Pieces[WidthFactor], &Pieces[2*WidthFactor], RopePiece());
+
+ // Decrease the number of values in the two nodes.
+ NewNode->NumPieces = NumPieces = WidthFactor;
+
+ // Recompute the two nodes' size.
+ NewNode->FullRecomputeSizeLocally();
+ FullRecomputeSizeLocally();
+
+ // Update the list of leaves.
+ NewNode->setNextLeafInOrder(this->getNextLeafInOrder());
+ this->setNextLeafInOrder(NewNode);
+
+ assert(Res && "No result location specified");
+ Res->LHS = this;
+ Res->RHS = NewNode;
+
+ if (this->size() >= Offset)
+ this->insert(Offset, R, 0 /*can't fail*/);
+ else
+ NewNode->insert(Offset - this->size(), R, 0 /*can't fail*/);
+ return true;
+}
+
+/// erase - Remove NumBytes from this node at the specified offset. We are
+/// guaranteed that there is a split at Offset.
+inline void RopePieceBTreeLeaf::erase(unsigned Offset, unsigned NumBytes) {
+ // Since we are guaranteed that there is a split at Offset, we start by
+ // finding the Piece that starts there.
+ unsigned PieceOffs = 0;
+ unsigned i = 0;
+ for (; Offset > PieceOffs; ++i)
+ PieceOffs += getPiece(i).size();
+ assert(PieceOffs == Offset && "Split didn't occur before erase!");
+
+ unsigned StartPiece = i;
+
+ // Figure out how many pieces completely cover 'NumBytes'. We want to remove
+ // all of them.
+ for (; Offset+NumBytes > PieceOffs+getPiece(i).size(); ++i)
+ PieceOffs += getPiece(i).size();
+
+ // If we exactly include the last one, include it in the region to delete.
+ if (Offset+NumBytes == PieceOffs+getPiece(i).size())
+ PieceOffs += getPiece(i).size(), ++i;
+
+ // If we completely cover some RopePieces, erase them now.
+ if (i != StartPiece) {
+ unsigned NumDeleted = i-StartPiece;
+ for (; i != getNumPieces(); ++i)
+ Pieces[i-NumDeleted] = Pieces[i];
+
+ // Drop references to dead rope pieces.
+ std::fill(&Pieces[getNumPieces()-NumDeleted], &Pieces[getNumPieces()],
+ RopePiece());
+ NumPieces -= NumDeleted;
+
+ unsigned CoverBytes = PieceOffs-Offset;
+ NumBytes -= CoverBytes;
+ Size -= CoverBytes;
+ }
+
+ // If we completely removed some stuff, we could be done.
+ if (NumBytes == 0) return;
+
+ // Okay, now might be erasing part of some Piece. If this is the case, then
+ // move the start point of the piece.
+ assert(getPiece(StartPiece).size() > NumBytes);
+ Pieces[StartPiece].StartOffs += NumBytes;
+
+ // The size of this node just shrunk by NumBytes.
+ Size -= NumBytes;
+}
+
+// Holds up to 2*WidthFactor children.
+class RopePieceBTreeInterior : public RopePieceBTreeNode {
+ /// NumChildren - This holds the number of children currently active in the
+ /// Children array.
+ unsigned char NumChildren;
+ RopePieceBTreeNode *Children[2*WidthFactor];
+public:
+ RopePieceBTreeInterior() : RopePieceBTreeNode(false) {}
+
+ RopePieceBTreeInterior(RopePieceBTreeNode *LHS, RopePieceBTreeNode *RHS)
+ : RopePieceBTreeNode(false) {
+ Children[0] = LHS;
+ Children[1] = RHS;
+ NumChildren = 2;
+ Size = LHS->size() + RHS->size();
+ }
+
+ bool isFull() const { return NumChildren == 2*WidthFactor; }
+
+ unsigned getNumChildren() const { return NumChildren; }
+ const RopePieceBTreeNode *getChild(unsigned i) const {
+ assert(i < NumChildren && "invalid child #");
+ return Children[i];
+ }
+ RopePieceBTreeNode *getChild(unsigned i) {
+ assert(i < NumChildren && "invalid child #");
+ return Children[i];
+ }
+
+ void FullRecomputeSizeLocally() {
+ Size = 0;
+ for (unsigned i = 0, e = getNumChildren(); i != e; ++i)
+ Size += getChild(i)->size();
+ }
+
+
+ /// split - Split the range containing the specified offset so that we are
+ /// guaranteed that there is a place to do an insertion at the specified
+ /// offset. The offset is relative, so "0" is the start of the node. This
+ /// returns true if the insertion could not be done in place, and returns
+ /// information in 'Res' about the piece that is percolated up.
+ bool split(unsigned Offset, InsertResult *Res);
+
+
+ /// insert - Insert the specified ropepiece into this tree node at the
+ /// specified offset. The offset is relative, so "0" is the start of the
+ /// node. This returns true if the insertion could not be done in place, and
+ /// returns information in 'Res' about the piece that is percolated up.
+ bool insert(unsigned Offset, const RopePiece &R, InsertResult *Res);
+
+ /// HandleChildPiece - A child propagated an insertion result up to us.
+ /// Insert the new child, and/or propagate the result further up the tree.
+ bool HandleChildPiece(unsigned i, InsertResult &Res);
+
+ /// erase - Remove NumBytes from this node at the specified offset. We are
+ /// guaranteed that there is a split at Offset.
+ void erase(unsigned Offset, unsigned NumBytes);
+
+ static inline bool classof(const RopePieceBTreeInterior *) { return true; }
+ static inline bool classof(const RopePieceBTreeNode *N) {
+ return !N->isLeaf();
+ }
+};
+
+/// split - Split the range containing the specified offset so that we are
+/// guaranteed that there is a place to do an insertion at the specified
+/// offset. The offset is relative, so "0" is the start of the node. This
+/// returns true if the insertion could not be done in place, and returns
+/// information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeInterior::split(unsigned Offset, InsertResult *Res) {
+ // Figure out which child to split.
+ if (Offset == 0 || Offset == size())
+ return false; // If we have an exact offset, we're already split.
+
+ unsigned ChildOffset = 0;
+ unsigned i = 0;
+ for (; Offset >= ChildOffset+getChild(i)->size(); ++i)
+ ChildOffset += getChild(i)->size();
+
+ // If already split there, we're done.
+ if (ChildOffset == Offset)
+ return false;
+
+ // Otherwise, recursively split the child.
+ if (getChild(i)->split(Offset-ChildOffset, Res))
+ return HandleChildPiece(i, *Res);
+ return false; // Done!
+}
+
+/// insert - Insert the specified ropepiece into this tree node at the
+/// specified offset. The offset is relative, so "0" is the start of the
+/// node. This returns true if the insertion could not be done in place, and
+/// returns information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeInterior::insert(unsigned Offset, const RopePiece &R,
+ InsertResult *Res) {
+ // Find the insertion point. We are guaranteed that there is a split at the
+ // specified offset so find it.
+ unsigned i = 0, e = getNumChildren();
+
+ unsigned ChildOffs = 0;
+ if (Offset == size()) {
+ // Fastpath for a common case. Insert at end of last child.
+ i = e-1;
+ ChildOffs = size()-getChild(i)->size();
+ } else {
+ for (; Offset > ChildOffs+getChild(i)->size(); ++i)
+ ChildOffs += getChild(i)->size();
+ }
+
+ Size += R.size();
+
+ // Insert at the end of this child.
+ if (getChild(i)->insert(Offset-ChildOffs, R, Res))
+ return HandleChildPiece(i, *Res);
+
+ return false;
+}
+
+/// HandleChildPiece - A child propagated an insertion result up to us.
+/// Insert the new child, and/or propagate the result further up the tree.
+inline bool RopePieceBTreeInterior::HandleChildPiece(unsigned i,
+ InsertResult &Res) {
+ // Otherwise the child propagated a subtree up to us as a new child. See if
+ // we have space for it here.
+ if (!isFull()) {
+ // Replace child 'i' with the two children specified in Res.
+ if (i + 1 != getNumChildren())
+ memmove(&Children[i+2], &Children[i+1],
+ (getNumChildren()-i-1)*sizeof(Children[0]));
+ Children[i] = Res.LHS;
+ Children[i+1] = Res.RHS;
+ ++NumChildren;
+ return false;
+ }
+
+ // Okay, this node is full. Split it in half, moving WidthFactor children to
+ // a newly allocated interior node.
+
+ // Create the new node.
+ RopePieceBTreeInterior *NewNode = new RopePieceBTreeInterior();
+
+ // Move over the last 'WidthFactor' values from here to NewNode.
+ memcpy(&NewNode->Children[0], &Children[WidthFactor],
+ WidthFactor*sizeof(Children[0]));
+
+ // Decrease the number of values in the two nodes.
+ NewNode->NumChildren = NumChildren = WidthFactor;
+
+ // Finally, insert the two new children in the side the can (now) hold them.
+ if (i < WidthFactor)
+ this->HandleChildPiece(i, Res);
+ else
+ NewNode->HandleChildPiece(i-WidthFactor, Res);
+
+ // Recompute the two nodes' size.
+ NewNode->FullRecomputeSizeLocally();
+ FullRecomputeSizeLocally();
+
+ Res.LHS = this;
+ Res.RHS = NewNode;
+ return true;
+}
+
+/// erase - Remove NumBytes from this node at the specified offset. We are
+/// guaranteed that there is a split at Offset.
+inline void RopePieceBTreeInterior::erase(unsigned Offset, unsigned NumBytes) {
+ // This will shrink this node by NumBytes.
+ Size -= NumBytes;
+
+ // Find the first child that overlaps with Offset.
+ unsigned i = 0;
+ for (; Offset >= getChild(i)->size(); ++i)
+ Offset -= getChild(i)->size();
+
+ // Propagate the delete request into overlapping children, or completely
+ // delete the children as appropriate.
+ while (NumBytes) {
+ RopePieceBTreeNode *CurChild = getChild(i);
+
+ // If we are deleting something contained entirely in the child, pass on the
+ // request.
+ if (Offset+NumBytes < CurChild->size()) {
+ CurChild->erase(Offset, NumBytes);
+ return;
+ }
+
+ // If this deletion request starts somewhere in the middle of the child, it
+ // must be deleting to the end of the child.
+ if (Offset) {
+ unsigned BytesFromChild = CurChild->size()-Offset;
+ CurChild->erase(Offset, BytesFromChild);
+ NumBytes -= BytesFromChild;
+ ++i;
+ continue;
+ }
+
+ // If the deletion request completely covers the child, delete it and move
+ // the rest down.
+ NumBytes -= CurChild->size();
+ CurChild->Destroy();
+ --NumChildren;
+ if (i+1 != getNumChildren())
+ memmove(&Children[i], &Children[i+1],
+ (getNumChildren()-i)*sizeof(Children[0]));
+ }
+}
+
+inline void RopePieceBTreeNode::Destroy() {
+ if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(this))
+ delete Leaf;
+ else
+ delete cast<RopePieceBTreeInterior>(this);
+}
+
+/// split - Split the range containing the specified offset so that we are
+/// guaranteed that there is a place to do an insertion at the specified
+/// offset. The offset is relative, so "0" is the start of the node. This
+/// returns true if the insertion could not be done in place, and returns
+/// information in 'Res' about the piece that is percolated up.
+inline bool RopePieceBTreeNode::split(unsigned Offset, InsertResult *Res) {
+ assert(Offset <= size() && "Invalid offset to split!");
+ if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(this))
+ return Leaf->split(Offset, Res);
+ return cast<RopePieceBTreeInterior>(this)->split(Offset, Res);
+}
+
+/// insert - Insert the specified ropepiece into this tree node at the
+/// specified offset. The offset is relative, so "0" is the start of the
+/// node.
+inline bool RopePieceBTreeNode::insert(unsigned Offset, const RopePiece &R,
+ InsertResult *Res) {
+ assert(Offset <= size() && "Invalid offset to insert!");
+ if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(this))
+ return Leaf->insert(Offset, R, Res);
+ return cast<RopePieceBTreeInterior>(this)->insert(Offset, R, Res);
+}
+
+/// erase - Remove NumBytes from this node at the specified offset. We are
+/// guaranteed that there is a split at Offset.
+inline void RopePieceBTreeNode::erase(unsigned Offset, unsigned NumBytes) {
+ assert(Offset+NumBytes <= size() && "Invalid offset to erase!");
+ if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(this))
+ return Leaf->erase(Offset, NumBytes);
+ return cast<RopePieceBTreeInterior>(this)->erase(Offset, NumBytes);
+}
+
+
+
+/// RewritePieceBTreeIterator - Provide read-only forward iteration.
+class RewritePieceBTreeIterator :
+ public forward_iterator<const char, ptrdiff_t> {
+ /// CurNode - The current B+Tree node that we are inspecting.
+ const RopePieceBTreeLeaf *CurNode;
+ /// CurPiece - The current RopePiece in the B+Tree node that we're inspecting.
+ const RopePiece *CurPiece;
+ /// CurChar - The current byte in the RopePiece we are pointing to.
+ unsigned CurChar;
+ friend class RewriteRope;
+public:
+ RewritePieceBTreeIterator(const RopePieceBTreeNode *N) { // begin iterator.
+ // Walk down the left side of the tree until we get to a leaf.
+ while (const RopePieceBTreeInterior *IN =
+ dyn_cast<RopePieceBTreeInterior>(N))
+ N = IN->getChild(0);
+
+ // We must have at least one leaf.
+ CurNode = cast<RopePieceBTreeLeaf>(N);
+
+ // If we found a leaf that happens to be empty, skip over it until we get to
+ // something full.
+ while (CurNode && CurNode->getNumPieces() == 0)
+ CurNode = CurNode->getNextLeafInOrder();
+
+ if (CurNode != 0)
+ CurPiece = &CurNode->getPiece(0);
+ else // Empty tree, this is an end() iterator.
+ CurPiece = 0;
+ CurChar = 0;
+ }
+ // end iterator
+ RewritePieceBTreeIterator() : CurNode(0), CurPiece(0), CurChar(0) {}
+
+ const char operator*() const {
+ return (*CurPiece)[CurChar];
+ }
+
+ bool operator==(const RewritePieceBTreeIterator &RHS) const {
+ return CurPiece == RHS.CurPiece && CurChar == RHS.CurChar;
+ }
+ bool operator!=(const RewritePieceBTreeIterator &RHS) const {
+ return !operator==(RHS);
+ }
+
+ inline RewritePieceBTreeIterator& operator++() { // Preincrement
+ if (CurChar+1 < CurPiece->size())
+ ++CurChar;
+ else if (CurPiece != &CurNode->getPiece(CurNode->getNumPieces()-1)) {
+ CurChar = 0;
+ ++CurPiece;
+ } else {
+ // Find the next non-empty leaf node.
+ do
+ CurNode = CurNode->getNextLeafInOrder();
+ while (CurNode && CurNode->getNumPieces() == 0);
+
+ if (CurNode != 0)
+ CurPiece = &CurNode->getPiece(0);
+ else // Hit end().
+ CurPiece = 0;
+ CurChar = 0;
+ }
+ return *this;
+ }
+
+ inline RewritePieceBTreeIterator operator++(int) { // Postincrement
+ RewritePieceBTreeIterator tmp = *this; ++*this; return tmp;
+ }
+};
+
+
+class RopePieceBTree {
+ RopePieceBTreeNode *Root;
+ void operator=(const RopePieceBTree &); // DO NOT IMPLEMENT
+public:
+ RopePieceBTree() {
+ Root = new RopePieceBTreeLeaf();
+ }
+ RopePieceBTree(const RopePieceBTree &RHS) {
+ assert(RHS.empty() && "Can't copy non-empty tree yet");
+ Root = new RopePieceBTreeLeaf();
+ }
+ ~RopePieceBTree() {
+ Root->Destroy();
+ }
+
+ typedef RewritePieceBTreeIterator iterator;
+ iterator begin() const { return iterator(Root); }
+ iterator end() const { return iterator(); }
+ unsigned size() const { return Root->size(); }
+ unsigned empty() const { return size() == 0; }
+
+ void clear() {
+ if (RopePieceBTreeLeaf *Leaf = dyn_cast<RopePieceBTreeLeaf>(Root))
+ Leaf->clear();
+ else {
+ Root->Destroy();
+ Root = new RopePieceBTreeLeaf();
+ }
+ }
+
+ void insert(unsigned Offset, const RopePiece &R) {
+ InsertResult Result;
+ // #1. Split at Offset.
+ if (Root->split(Offset, &Result))
+ Root = new RopePieceBTreeInterior(Result.LHS, Result.RHS);
+
+ // #2. Do the insertion.
+ if (Root->insert(Offset, R, &Result))
+ Root = new RopePieceBTreeInterior(Result.LHS, Result.RHS);
+ }
+
+ void erase(unsigned Offset, unsigned NumBytes) {
+ InsertResult Result;
+ // #1. Split at Offset.
+ if (Root->split(Offset, &Result))
+ Root = new RopePieceBTreeInterior(Result.LHS, Result.RHS);
+
+ // #2. Do the erasing.
+ Root->erase(Offset, NumBytes);
+ }
+};
+
+
+#endif // ifndef USE_ROPE_VECTOR
+
+#ifdef USE_ROPE_VECTOR
+ class RewriteRope;
template <typename CharType, typename PieceIterType>
class RewriteRopeIterator :
@@ -105,15 +789,19 @@
RewriteRopeIterator tmp = *this; ++*this; return tmp;
}
};
-
+#endif
/// RewriteRope - A powerful string class, todo generalize this.
class RewriteRope {
+#ifdef USE_ROPE_VECTOR
// FIXME: This could be significantly faster by using a balanced binary tree
// instead of a list.
std::list<RopePiece> Chunks;
unsigned CurSize;
+#else
+ RopePieceBTree Chunks;
+#endif
/// We allocate space for string data out of a buffer of size AllocChunkSize.
/// This keeps track of how much space is left.
@@ -122,9 +810,24 @@
enum { AllocChunkSize = 4080 };
public:
- RewriteRope() : CurSize(0), AllocBuffer(0), AllocOffs(AllocChunkSize) {}
- ~RewriteRope() { clear(); }
+ RewriteRope() :
+#ifdef USE_ROPE_VECTOR
+ CurSize(0),
+#endif
+ AllocBuffer(0), AllocOffs(AllocChunkSize) {}
+ RewriteRope(const RewriteRope &RHS) : Chunks(RHS.Chunks),
+#ifdef USE_ROPE_VECTOR
+ CurSize(RHS.CurSize),
+#endif
+ AllocBuffer(0), AllocOffs(AllocChunkSize) {
+ }
+
+ ~RewriteRope() {
+ // If we had an allocation buffer, drop our reference to it.
+ AllocBuffer->dropRef();
+ }
+#ifdef USE_ROPE_VECTOR
typedef RewriteRopeIterator<char, std::list<RopePiece>::iterator> iterator;
typedef RewriteRopeIterator<const char,
std::list<RopePiece>::const_iterator> const_iterator;
@@ -135,18 +838,45 @@
const_iterator end() const { return const_iterator(Chunks.end(), 0); }
unsigned size() const { return CurSize; }
+#else
+ typedef RopePieceBTree::iterator iterator;
+ typedef RopePieceBTree::iterator const_iterator;
+ iterator begin() const { return Chunks.begin(); }
+ iterator end() const { return Chunks.end(); }
+ unsigned size() const { return Chunks.size(); }
+#endif
void clear() {
Chunks.clear();
- CurSize = 0;
+#ifdef USE_ROPE_VECTOR
+ CurSize = 0;
+#endif
}
+#ifndef USE_ROPE_VECTOR
+ void assign(const char *Start, const char *End) {
+ clear();
+ Chunks.insert(0, MakeRopeString(Start, End));
+ }
+
+ void insert(unsigned Offset, const char *Start, const char *End) {
+ if (Start == End) return;
+ Chunks.insert(Offset, MakeRopeString(Start, End));
+ }
+
+ void erase(unsigned Offset, unsigned NumBytes) {
+ if (NumBytes == 0) return;
+ Chunks.erase(Offset, NumBytes);
+ }
+#endif
+
+#ifdef USE_ROPE_VECTOR
void assign(const char *Start, const char *End) {
clear();
Chunks.push_back(MakeRopeString(Start, End));
CurSize = End-Start;
}
-
+
iterator getAtOffset(unsigned Offset) {
assert(Offset <= CurSize && "Offset out of range!");
if (Offset == CurSize) return iterator(Chunks.end(), 0);
@@ -236,6 +966,7 @@
CurSize -= End.CurChar;
}
}
+#endif
private:
RopePiece MakeRopeString(const char *Start, const char *End) {
@@ -261,14 +992,25 @@
// Otherwise, this was a small request but we just don't have space for it
// Make a new chunk and share it with later allocations.
+
+ // If we had an old allocation, drop our reference to it.
+ if (AllocBuffer && --AllocBuffer->RefCount == 0)
+ delete [] (char*)AllocBuffer;
+
unsigned AllocSize = sizeof(RopeRefCountString)-1+AllocChunkSize;
AllocBuffer = reinterpret_cast<RopeRefCountString *>(new char[AllocSize]);
AllocBuffer->RefCount = 0;
memcpy(AllocBuffer->Data, Start, Len);
AllocOffs = Len;
+
+ // Start out the new allocation with a refcount of 1, since we have an
+ // internal reference to it.
+ AllocBuffer->addRef();
return RopePiece(AllocBuffer, 0, Len);
}
+#ifdef USE_ROPE_VECTOR
+
/// SplitAt - If the specified iterator position has a non-zero character
/// number, split the specified buffer up. This guarantees that the specified
/// iterator is at the start of a chunk. Return the chunk it is at the start
@@ -293,6 +1035,7 @@
// Return the old chunk, which is the suffix.
return Chunk;
}
+#endif
};
} // end namespace clang
Modified: cfe/trunk/lib/Rewrite/DeltaTree.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Rewrite/DeltaTree.cpp?rev=49635&r1=49634&r2=49635&view=diff
==============================================================================
--- cfe/trunk/lib/Rewrite/DeltaTree.cpp (original)
+++ cfe/trunk/lib/Rewrite/DeltaTree.cpp Mon Apr 14 02:17:29 2008
@@ -58,10 +58,12 @@
} // end anonymous namespace
-struct InsertResult {
- DeltaTreeNode *LHS, *RHS;
- SourceDelta Split;
-};
+namespace {
+ struct InsertResult {
+ DeltaTreeNode *LHS, *RHS;
+ SourceDelta Split;
+ };
+} // end anonymous namespace
namespace {
@@ -72,8 +74,8 @@
/// WidthFactor - This controls the number of K/V slots held in the BTree:
/// how wide it is. Each level of the BTree is guaranteed to have at least
- /// WidthFactor-1 K/V pairs (unless the whole tree is less full than that)
- /// and may have at most 2*WidthFactor-1 K/V pairs.
+ /// WidthFactor-1 K/V pairs (except the root) and may have at most
+ /// 2*WidthFactor-1 K/V pairs.
enum { WidthFactor = 8 };
/// Values - This tracks the SourceDelta's currently in this node.
Modified: cfe/trunk/lib/Rewrite/Rewriter.cpp
URL: http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/Rewrite/Rewriter.cpp?rev=49635&r1=49634&r2=49635&view=diff
==============================================================================
--- cfe/trunk/lib/Rewrite/Rewriter.cpp (original)
+++ cfe/trunk/lib/Rewrite/Rewriter.cpp Mon Apr 14 02:17:29 2008
@@ -27,8 +27,12 @@
assert(RealOffset+Size < Buffer.size() && "Invalid location");
// Remove the dead characters.
+#ifdef USE_ROPE_VECTOR
RewriteRope::iterator I = Buffer.getAtOffset(RealOffset);
Buffer.erase(I, I+Size);
+#else
+ Buffer.erase(RealOffset, Size);
+#endif
// Add a delta so that future changes are offset correctly.
AddDelta(OrigOffset, -Size);
@@ -40,23 +44,29 @@
// Nothing to insert, exit early.
if (StrLen == 0) return;
-
+
unsigned RealOffset = getMappedOffset(OrigOffset, InsertAfter);
+
+#ifdef USE_ROPE_VECTOR
assert(RealOffset <= Buffer.size() && "Invalid location");
// Insert the new characters.
Buffer.insert(Buffer.getAtOffset(RealOffset), StrData, StrData+StrLen);
+#else
+ Buffer.insert(RealOffset, StrData, StrData+StrLen);
+#endif
// Add a delta so that future changes are offset correctly.
AddDelta(OrigOffset, StrLen);
}
/// ReplaceText - This method replaces a range of characters in the input
-/// buffer with a new string. This is effectively a combined "remove/insert"
+/// buffer with a new string. This is effectively a combined "remove+insert"
/// operation.
void RewriteBuffer::ReplaceText(unsigned OrigOffset, unsigned OrigLength,
const char *NewStr, unsigned NewLength) {
unsigned RealOffset = getMappedOffset(OrigOffset, true);
+#ifdef USE_ROPE_VECTOR
assert(RealOffset+OrigLength <= Buffer.size() && "Invalid location");
// Overwrite the common piece.
@@ -76,7 +86,12 @@
RewriteRope::iterator I = Buffer.getAtOffset(RealOffset+NewLength);
Buffer.erase(I, I+(OrigLength-NewLength));
}
- AddDelta(OrigOffset, NewLength-OrigLength);
+#else
+ Buffer.erase(RealOffset, OrigLength);
+ Buffer.insert(RealOffset, NewStr, NewStr+NewLength);
+#endif
+ if (OrigLength != NewLength)
+ AddDelta(OrigOffset, NewLength-OrigLength);
}
More information about the cfe-commits
mailing list