src/share/vm/memory/heap.cpp

*** 169,185 ****
    _next_segment = 0;
    mark_segmap_as_free(0, _number_of_committed_segments);
  }
  
  
! void* CodeHeap::allocate(size_t instance_size, bool is_critical) {
    size_t number_of_segments = size_to_segments(instance_size + header_size());
    assert(segments_to_size(number_of_segments) >= sizeof(FreeBlock), "not enough room for FreeList");
  
    // First check if we can satisfy request from freelist
    NOT_PRODUCT(verify());
!   HeapBlock* block = search_freelist(number_of_segments, is_critical);
    NOT_PRODUCT(verify());
  
    if (block != NULL) {
      assert(block->length() >= number_of_segments && block->length() < number_of_segments + CodeCacheMinBlockLength, "sanity check");
      assert(!block->free(), "must be marked free");
--- 169,185 ----
    _next_segment = 0;
    mark_segmap_as_free(0, _number_of_committed_segments);
  }
  
  
! void* CodeHeap::allocate(size_t instance_size) {
    size_t number_of_segments = size_to_segments(instance_size + header_size());
    assert(segments_to_size(number_of_segments) >= sizeof(FreeBlock), "not enough room for FreeList");
  
    // First check if we can satisfy request from freelist
    NOT_PRODUCT(verify());
!   HeapBlock* block = search_freelist(number_of_segments);
    NOT_PRODUCT(verify());
  
    if (block != NULL) {
      assert(block->length() >= number_of_segments && block->length() < number_of_segments + CodeCacheMinBlockLength, "sanity check");
      assert(!block->free(), "must be marked free");
*** 189,207 ****
    }
  
    // Ensure minimum size for allocation to the heap.
    number_of_segments = MAX2((int)CodeCacheMinBlockLength, (int)number_of_segments);
  
-   if (!is_critical) {
-     // Make sure the allocation fits in the unallocated heap without using
-     // the CodeCacheMimimumFreeSpace that is reserved for critical allocations.
-     if (segments_to_size(number_of_segments) > (heap_unallocated_capacity() - CodeCacheMinimumFreeSpace)) {
-       // Fail allocation
-       return NULL;
-     }
-   }
- 
    if (_next_segment + number_of_segments <= _number_of_committed_segments) {
      mark_segmap_as_used(_next_segment, _next_segment + number_of_segments);
      HeapBlock* b =  block_at(_next_segment);
      b->initialize(number_of_segments);
      _next_segment += number_of_segments;
--- 189,198 ----
*** 425,452 ****
  
  /**
   * Search freelist for an entry on the list with the best fit.
   * @return NULL, if no one was found
   */
! FreeBlock* CodeHeap::search_freelist(size_t length, bool is_critical) {
    FreeBlock* found_block = NULL;
    FreeBlock* found_prev  = NULL;
    size_t     found_length = 0;
  
    FreeBlock* prev = NULL;
    FreeBlock* cur = _freelist;
-   const size_t critical_boundary = (size_t)high_boundary() - CodeCacheMinimumFreeSpace;
  
    // Search for first block that fits
    while(cur != NULL) {
      if (cur->length() >= length) {
-       // Non critical allocations are not allowed to use the last part of the code heap.
-       // Make sure the end of the allocation doesn't cross into the last part of the code heap.
-       if (!is_critical && (((size_t)cur + length) > critical_boundary)) {
-         // The freelist is sorted by address - if one fails, all consecutive will also fail.
-         break;
-       }
        // Remember block, its previous element, and its length
        found_block = cur;
        found_prev  = prev;
        found_length = found_block->length();
  
--- 416,436 ----
  
  /**
   * Search freelist for an entry on the list with the best fit.
   * @return NULL, if no one was found
   */
! FreeBlock* CodeHeap::search_freelist(size_t length) {
    FreeBlock* found_block = NULL;
    FreeBlock* found_prev  = NULL;
    size_t     found_length = 0;
  
    FreeBlock* prev = NULL;
    FreeBlock* cur = _freelist;
  
    // Search for first block that fits
    while(cur != NULL) {
      if (cur->length() >= length) {
        // Remember block, its previous element, and its length
        found_block = cur;
        found_prev  = prev;
        found_length = found_block->length();