Mercurial > hg > graal-jvmci-8
diff src/share/vm/memory/binaryTreeDictionary.hpp @ 6028:f69a5d43dc19
7164144: Fix variable naming style in freeBlockDictionary.* and binaryTreeDictionary*
Summary: Fix naming style to be consistent with the predominant hotspot style.
Reviewed-by: ysr, brutisso
author | jmasa |
---|---|
date | Wed, 25 Apr 2012 09:55:55 -0700 |
parents | 9f059abe8cf2 |
children | a297b0e14605 |
line wrap: on
line diff
--- a/src/share/vm/memory/binaryTreeDictionary.hpp Thu Mar 29 19:46:24 2012 -0700 +++ b/src/share/vm/memory/binaryTreeDictionary.hpp Wed Apr 25 09:55:55 2012 -0700 @@ -70,22 +70,22 @@ // Accessors for links in tree. - void setLeft(TreeList<Chunk>* tl) { + void set_left(TreeList<Chunk>* tl) { _left = tl; if (tl != NULL) - tl->setParent(this); + tl->set_parent(this); } - void setRight(TreeList<Chunk>* tl) { + void set_right(TreeList<Chunk>* tl) { _right = tl; if (tl != NULL) - tl->setParent(this); + tl->set_parent(this); } - void setParent(TreeList<Chunk>* tl) { _parent = tl; } + void set_parent(TreeList<Chunk>* tl) { _parent = tl; } void clearLeft() { _left = NULL; } - void clearRight() { _right = NULL; } - void clearParent() { _parent = NULL; } - void initialize() { clearLeft(); clearRight(), clearParent(); } + void clear_right() { _right = NULL; } + void clear_parent() { _parent = NULL; } + void initialize() { clearLeft(); clear_right(), clear_parent(); } // For constructing a TreeList from a Tree chunk or // address and size. @@ -104,16 +104,16 @@ // use with caution! TreeChunk<Chunk>* largest_address(); - // removeChunkReplaceIfNeeded() removes the given "tc" from the TreeList. + // remove_chunk_replace_if_needed() removes the given "tc" from the TreeList. // If "tc" is the first chunk in the list, it is also the - // TreeList that is the node in the tree. removeChunkReplaceIfNeeded() + // TreeList that is the node in the tree. remove_chunk_replace_if_needed() // returns the possibly replaced TreeList* for the node in // the tree. It also updates the parent of the original // node to point to the new node. - TreeList<Chunk>* removeChunkReplaceIfNeeded(TreeChunk<Chunk>* tc); + TreeList<Chunk>* remove_chunk_replace_if_needed(TreeChunk<Chunk>* tc); // See FreeList. - void returnChunkAtHead(TreeChunk<Chunk>* tc); - void returnChunkAtTail(TreeChunk<Chunk>* tc); + void return_chunk_at_head(TreeChunk<Chunk>* tc); + void return_chunk_at_tail(TreeChunk<Chunk>* tc); }; // A TreeChunk is a subclass of a Chunk that additionally @@ -151,7 +151,7 @@ size_t size() const volatile { return Chunk::size(); } // debugging - void verifyTreeChunkList() const; + void verify_tree_chunk_list() const; }; @@ -159,19 +159,19 @@ class BinaryTreeDictionary: public FreeBlockDictionary<Chunk> { friend class VMStructs; bool _splay; - size_t _totalSize; - size_t _totalFreeBlocks; + size_t _total_size; + size_t _total_free_blocks; TreeList<Chunk>* _root; bool _adaptive_freelists; // private accessors bool splay() const { return _splay; } void set_splay(bool v) { _splay = v; } - void set_totalSize(size_t v) { _totalSize = v; } - virtual void inc_totalSize(size_t v); - virtual void dec_totalSize(size_t v); - size_t totalFreeBlocks() const { return _totalFreeBlocks; } - void set_totalFreeBlocks(size_t v) { _totalFreeBlocks = v; } + void set_total_size(size_t v) { _total_size = v; } + virtual void inc_total_size(size_t v); + virtual void dec_total_size(size_t v); + size_t total_free_blocks() const { return _total_free_blocks; } + void set_total_free_blocks(size_t v) { _total_free_blocks = v; } TreeList<Chunk>* root() const { return _root; } void set_root(TreeList<Chunk>* v) { _root = v; } bool adaptive_freelists() { return _adaptive_freelists; } @@ -186,46 +186,46 @@ // return it. If the chunk // is the last chunk of that size, remove the node for that size // from the tree. - TreeChunk<Chunk>* getChunkFromTree(size_t size, enum FreeBlockDictionary<Chunk>::Dither dither, bool splay); + TreeChunk<Chunk>* get_chunk_from_tree(size_t size, enum FreeBlockDictionary<Chunk>::Dither dither, bool splay); // Return a list of the specified size or NULL from the tree. // The list is not removed from the tree. - TreeList<Chunk>* findList (size_t size) const; + TreeList<Chunk>* find_list (size_t size) const; // Remove this chunk from the tree. If the removal results // in an empty list in the tree, remove the empty list. - TreeChunk<Chunk>* removeChunkFromTree(TreeChunk<Chunk>* tc); + TreeChunk<Chunk>* remove_chunk_from_tree(TreeChunk<Chunk>* tc); // Remove the node in the trees starting at tl that has the // minimum value and return it. Repair the tree as needed. - TreeList<Chunk>* removeTreeMinimum(TreeList<Chunk>* tl); - void semiSplayStep(TreeList<Chunk>* tl); + TreeList<Chunk>* remove_tree_minimum(TreeList<Chunk>* tl); + void semi_splay_step(TreeList<Chunk>* tl); // Add this free chunk to the tree. - void insertChunkInTree(Chunk* freeChunk); + void insert_chunk_in_tree(Chunk* freeChunk); public: static const size_t min_tree_chunk_size = sizeof(TreeChunk<Chunk>)/HeapWordSize; - void verifyTree() const; + void verify_tree() const; // verify that the given chunk is in the tree. - bool verifyChunkInFreeLists(Chunk* tc) const; + bool verify_chunk_in_free_list(Chunk* tc) const; private: - void verifyTreeHelper(TreeList<Chunk>* tl) const; - static size_t verifyPrevFreePtrs(TreeList<Chunk>* tl); + void verify_tree_helper(TreeList<Chunk>* tl) const; + static size_t verify_prev_free_ptrs(TreeList<Chunk>* tl); // Returns the total number of chunks in the list. - size_t totalListLength(TreeList<Chunk>* tl) const; + size_t total_list_length(TreeList<Chunk>* tl) const; // Returns the total number of words in the chunks in the tree // starting at "tl". - size_t totalSizeInTree(TreeList<Chunk>* tl) const; + size_t total_size_in_tree(TreeList<Chunk>* tl) const; // Returns the sum of the square of the size of each block // in the tree starting at "tl". double sum_of_squared_block_sizes(TreeList<Chunk>* const tl) const; // Returns the total number of free blocks in the tree starting // at "tl". - size_t totalFreeBlocksInTree(TreeList<Chunk>* tl) const; - size_t numFreeBlocks() const; + size_t total_free_blocks_in_tree(TreeList<Chunk>* tl) const; + size_t num_free_blocks() const; size_t treeHeight() const; - size_t treeHeightHelper(TreeList<Chunk>* tl) const; - size_t totalNodesInTree(TreeList<Chunk>* tl) const; - size_t totalNodesHelper(TreeList<Chunk>* tl) const; + size_t tree_height_helper(TreeList<Chunk>* tl) const; + size_t total_nodes_in_tree(TreeList<Chunk>* tl) const; + size_t total_nodes_helper(TreeList<Chunk>* tl) const; public: // Constructor @@ -233,7 +233,7 @@ BinaryTreeDictionary(MemRegion mr, bool adaptive_freelists, bool splay = false); // Public accessors - size_t totalSize() const { return _totalSize; } + size_t total_size() const { return _total_size; } // Reset the dictionary to the initial conditions with // a single free chunk. @@ -245,37 +245,37 @@ // Return a chunk of size "size" or greater from // the tree. // want a better dynamic splay strategy for the future. - Chunk* getChunk(size_t size, enum FreeBlockDictionary<Chunk>::Dither dither) { + Chunk* get_chunk(size_t size, enum FreeBlockDictionary<Chunk>::Dither dither) { FreeBlockDictionary<Chunk>::verify_par_locked(); - Chunk* res = getChunkFromTree(size, dither, splay()); - assert(res == NULL || res->isFree(), + Chunk* res = get_chunk_from_tree(size, dither, splay()); + assert(res == NULL || res->is_free(), "Should be returning a free chunk"); return res; } - void returnChunk(Chunk* chunk) { + void return_chunk(Chunk* chunk) { FreeBlockDictionary<Chunk>::verify_par_locked(); - insertChunkInTree(chunk); + insert_chunk_in_tree(chunk); } - void removeChunk(Chunk* chunk) { + void remove_chunk(Chunk* chunk) { FreeBlockDictionary<Chunk>::verify_par_locked(); - removeChunkFromTree((TreeChunk<Chunk>*)chunk); - assert(chunk->isFree(), "Should still be a free chunk"); + remove_chunk_from_tree((TreeChunk<Chunk>*)chunk); + assert(chunk->is_free(), "Should still be a free chunk"); } - size_t maxChunkSize() const; - size_t totalChunkSize(debug_only(const Mutex* lock)) const { + size_t max_chunk_size() const; + size_t total_chunk_size(debug_only(const Mutex* lock)) const { debug_only( if (lock != NULL && lock->owned_by_self()) { - assert(totalSizeInTree(root()) == totalSize(), - "_totalSize inconsistency"); + assert(total_size_in_tree(root()) == total_size(), + "_total_size inconsistency"); } ) - return totalSize(); + return total_size(); } - size_t minSize() const { + size_t min_size() const { return min_tree_chunk_size; } @@ -288,40 +288,40 @@ // Find the list with size "size" in the binary tree and update // the statistics in the list according to "split" (chunk was // split or coalesce) and "birth" (chunk was added or removed). - void dictCensusUpdate(size_t size, bool split, bool birth); + void dict_census_udpate(size_t size, bool split, bool birth); // Return true if the dictionary is overpopulated (more chunks of // this size than desired) for size "size". - bool coalDictOverPopulated(size_t size); + bool coal_dict_over_populated(size_t size); // Methods called at the beginning of a sweep to prepare the // statistics for the sweep. - void beginSweepDictCensus(double coalSurplusPercent, + void begin_sweep_dict_census(double coalSurplusPercent, float inter_sweep_current, float inter_sweep_estimate, float intra_sweep_estimate); // Methods called after the end of a sweep to modify the // statistics for the sweep. - void endSweepDictCensus(double splitSurplusPercent); + void end_sweep_dict_census(double splitSurplusPercent); // Return the largest free chunk in the tree. - Chunk* findLargestDict() const; + Chunk* find_largest_dict() const; // Accessors for statistics - void setTreeSurplus(double splitSurplusPercent); - void setTreeHints(void); + void set_tree_surplus(double splitSurplusPercent); + void set_tree_hints(void); // Reset statistics for all the lists in the tree. - void clearTreeCensus(void); + void clear_tree_census(void); // Print the statistcis for all the lists in the tree. Also may // print out summaries. - void printDictCensus(void) const; + void print_dict_census(void) const; void print_free_lists(outputStream* st) const; - // For debugging. Returns the sum of the _returnedBytes for + // For debugging. Returns the sum of the _returned_bytes for // all lists in the tree. - size_t sumDictReturnedBytes() PRODUCT_RETURN0; - // Sets the _returnedBytes for all the lists in the tree to zero. - void initializeDictReturnedBytes() PRODUCT_RETURN; + size_t sum_dict_returned_bytes() PRODUCT_RETURN0; + // Sets the _returned_bytes for all the lists in the tree to zero. + void initialize_dict_returned_bytes() PRODUCT_RETURN; // For debugging. Return the total number of chunks in the dictionary. - size_t totalCount() PRODUCT_RETURN0; + size_t total_count() PRODUCT_RETURN0; - void reportStatistics() const; + void report_statistics() const; void verify() const; };