< prev index next >

src/share/vm/gc/shared/cardTableModRefBS.hpp

Print this page




 222                                size_t& lowest_non_clean_chunk_size);
 223 
 224   // Returns the number of chunks necessary to cover "mr".
 225   size_t chunks_to_cover(MemRegion mr) {
 226     return (size_t)(addr_to_chunk_index(mr.last()) -
 227                     addr_to_chunk_index(mr.start()) + 1);
 228   }
 229 
 230   // Returns the index of the chunk in a stride which
 231   // covers the given address.
 232   uintptr_t addr_to_chunk_index(const void* addr) {
 233     uintptr_t card = (uintptr_t) byte_for(addr);
 234     return card / ParGCCardsPerStrideChunk;
 235   }
 236 
 237   // Apply cl, which must either itself apply dcto_cl or be dcto_cl,
 238   // to the cards in the stride (of n_strides) within the given space.
 239   void process_stride(Space* sp,
 240                       MemRegion used,
 241                       jint stride, int n_strides,
 242                       bool parallel,
 243                       OopsInGenClosure* cl,
 244                       CardTableRS* ct,
 245                       jbyte** lowest_non_clean,
 246                       uintptr_t lowest_non_clean_base_chunk_index,
 247                       size_t lowest_non_clean_chunk_size);
 248 
 249   // Makes sure that chunk boundaries are handled appropriately, by
 250   // adjusting the min_done of dcto_cl, and by using a special card-table
 251   // value to indicate how min_done should be set.
 252   void process_chunk_boundaries(Space* sp,
 253                                 DirtyCardToOopClosure* dcto_cl,
 254                                 MemRegion chunk_mr,
 255                                 MemRegion used,
 256                                 jbyte** lowest_non_clean,
 257                                 uintptr_t lowest_non_clean_base_chunk_index,
 258                                 size_t    lowest_non_clean_chunk_size);
 259 
 260 public:
 261   // Constants
 262   enum SomePublicConstants {




 222                                size_t& lowest_non_clean_chunk_size);
 223 
 224   // Returns the number of chunks necessary to cover "mr".
 225   size_t chunks_to_cover(MemRegion mr) {
 226     return (size_t)(addr_to_chunk_index(mr.last()) -
 227                     addr_to_chunk_index(mr.start()) + 1);
 228   }
 229 
 230   // Returns the index of the chunk in a stride which
 231   // covers the given address.
 232   uintptr_t addr_to_chunk_index(const void* addr) {
 233     uintptr_t card = (uintptr_t) byte_for(addr);
 234     return card / ParGCCardsPerStrideChunk;
 235   }
 236 
 237   // Apply cl, which must either itself apply dcto_cl or be dcto_cl,
 238   // to the cards in the stride (of n_strides) within the given space.
 239   void process_stride(Space* sp,
 240                       MemRegion used,
 241                       jint stride, int n_strides,

 242                       OopsInGenClosure* cl,
 243                       CardTableRS* ct,
 244                       jbyte** lowest_non_clean,
 245                       uintptr_t lowest_non_clean_base_chunk_index,
 246                       size_t lowest_non_clean_chunk_size);
 247 
 248   // Makes sure that chunk boundaries are handled appropriately, by
 249   // adjusting the min_done of dcto_cl, and by using a special card-table
 250   // value to indicate how min_done should be set.
 251   void process_chunk_boundaries(Space* sp,
 252                                 DirtyCardToOopClosure* dcto_cl,
 253                                 MemRegion chunk_mr,
 254                                 MemRegion used,
 255                                 jbyte** lowest_non_clean,
 256                                 uintptr_t lowest_non_clean_base_chunk_index,
 257                                 size_t    lowest_non_clean_chunk_size);
 258 
 259 public:
 260   // Constants
 261   enum SomePublicConstants {


< prev index next >