Remove support for pretenuring as it is not fully implemented and is currently turned on for a very…

runtime/vm/heap.h

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_HEAP_H_
 #define VM_HEAP_H_
 
 #include "platform/assert.h"
 #include "vm/allocation.h"
 #include "vm/flags.h"
@@ skipping 13 matching lines @@
 class ServiceEvent;
 class TimelineEventScope;
 class VirtualMemory;
 
 class Heap {
  public:
   enum Space {
     kNew,
     kOld,
     kCode,
-    // TODO(koda): Harmonize all old-space allocation and get rid of this.
-    kPretenured,
   };
 
   enum WeakSelector {
     kPeers = 0,
     kHashes,
     kObjectIds,
     kNumWeakSelectors
   };
 
   enum ApiCallbacks {
@@ skipping 28 matching lines @@
       case kNew:
         // Do not attempt to allocate very large objects in new space.
         if (!IsAllocatableInNewSpace(size)) {
           return AllocateOld(size, HeapPage::kData);
         }
         return AllocateNew(size);
       case kOld:
         return AllocateOld(size, HeapPage::kData);
       case kCode:
         return AllocateOld(size, HeapPage::kExecutable);
-      case kPretenured:
-        return AllocatePretenured(size);
       default:
         UNREACHABLE();
     }
     return 0;
   }
 
   // Track external data.
   void AllocateExternal(intptr_t size, Space space);
   void FreeExternal(intptr_t size, Space space);
   // Move external size from new to old space. Does not by itself trigger GC.
@@ skipping 45 matching lines @@
   // Protect access to the heap. Note: Code pages are made
   // executable/non-executable when 'read_only' is true/false, respectively.
   void WriteProtect(bool read_only);
   void WriteProtectCode(bool read_only) {
     old_space_.WriteProtectCode(read_only);
   }
 
   // Accessors for inlined allocation in generated code.
   static intptr_t TopOffset(Space space);
   static intptr_t EndOffset(Space space);
-  static Space SpaceForAllocation(intptr_t class_id);
 
   // Initialize the heap and register it with the isolate.
   static void Init(Isolate* isolate,
                    intptr_t max_new_gen_words,
                    intptr_t max_old_gen_words,
                    intptr_t max_external_words);
 
   // Verify that all pointers in the heap point to the heap.
   bool Verify(MarkExpectation mark_expectation = kForbidMarked) const;
 
@@ skipping 91 matching lines @@
 
   Isolate* isolate() const { return isolate_; }
 
   Monitor* barrier() const { return barrier_; }
   Monitor* barrier_done() const { return barrier_done_; }
 
   Monitor* finalization_tasks_lock() const { return finalization_tasks_lock_; }
   intptr_t finalization_tasks() const { return finalization_tasks_; }
   void set_finalization_tasks(intptr_t count) { finalization_tasks_ = count; }
 
-  bool ShouldPretenure(intptr_t class_id) const;
-
   void SetupExternalPage(void* pointer, uword size, bool is_executable) {
     old_space_.SetupExternalPage(pointer, size, is_executable);
   }
 
  private:
   class GCStats : public ValueObject {
    public:
     GCStats() {}
     intptr_t num_;
     Heap::Space space_;
@@ skipping 24 matching lines @@
 
   static const intptr_t kNewAllocatableSize = 256 * KB;
 
   Heap(Isolate* isolate,
        intptr_t max_new_gen_semi_words,  // Max capacity of new semi-space.
        intptr_t max_old_gen_words,
        intptr_t max_external_words);
 
   uword AllocateNew(intptr_t size);
   uword AllocateOld(intptr_t size, HeapPage::PageType type);
-  uword AllocatePretenured(intptr_t size);
 
   // Visit all pointers. Caller must ensure concurrent sweeper is not running,
   // and the visitor must not allocate.
   void VisitObjectPointers(ObjectPointerVisitor* visitor) const;
 
   // Visit all objects, including FreeListElement "objects". Caller must ensure
   // concurrent sweeper is not running, and the visitor must not allocate.
   void VisitObjects(ObjectVisitor* visitor) const;
 
   // Like Verify, but does not wait for concurrent sweeper, so caller must
   // ensure thread-safety.
   bool VerifyGC(MarkExpectation mark_expectation = kForbidMarked) const;
 
   // Helper functions for garbage collection.
   void CollectNewSpaceGarbage(
       Thread* thread, ApiCallbacks api_callbacks, GCReason reason);
   void CollectOldSpaceGarbage(
       Thread* thread, ApiCallbacks api_callbacks, GCReason reason);
 
   // GC stats collection.
   void RecordBeforeGC(Space space, GCReason reason);
   void RecordAfterGC(Space space);
   void PrintStats();
   void UpdateClassHeapStatsBeforeGC(Heap::Space space);
-  void UpdatePretenurePolicy();
   void PrintStatsToTimeline(TimelineEventScope* event);
 
   // Updates gc in progress flags.
   bool BeginNewSpaceGC(Thread* thread);
   void EndNewSpaceGC();
   bool BeginOldSpaceGC(Thread* thread);
   void EndOldSpaceGC();
 
   // If this heap is non-empty, updates start and end to the smallest range that
   // contains both the original [start, end) and the [lowest, highest) addresses
@@ skipping 19 matching lines @@
   GCStats stats_;
 
   // This heap is in read-only mode: No allocation is allowed.
   bool read_only_;
 
   // GC on the heap is in progress.
   Monitor gc_in_progress_monitor_;
   bool gc_new_space_in_progress_;
   bool gc_old_space_in_progress_;
 
-  int pretenure_policy_;
-
   friend class Become;  // VisitObjectPointers
   friend class ServiceEvent;
   friend class PageSpace;  // VerifyGC
   friend class IsolateReloadContext;  // VisitObjects
 
   DISALLOW_COPY_AND_ASSIGN(Heap);
 };
 
 
 class HeapIterationScope : public StackResource {
@@ skipping 21 matching lines @@
 // Note: During this scope, the code pages are non-executable.
 class WritableVMIsolateScope : StackResource {
  public:
   explicit WritableVMIsolateScope(Thread* thread);
   ~WritableVMIsolateScope();
 };
 
 }  // namespace dart
 
 #endif  // VM_HEAP_H_