test/hotspot/gtest/code/test_dependencyContext.cpp

*** 26,50 ****
  #include "code/dependencyContext.hpp"
  #include "unittest.hpp"
  
  class TestDependencyContext {
   public:
    nmethod* _nmethods[3];
  
!   intptr_t _dependency_context;
  
    DependencyContext dependencies() {
!     DependencyContext depContext(&_dependency_context);
      return depContext;
    }
  
!   TestDependencyContext() : _dependency_context(DependencyContext::EMPTY) {
      CodeCache_lock->lock_without_safepoint_check();
  
!     _nmethods[0] = reinterpret_cast<nmethod*>(0x8 * 0);
!     _nmethods[1] = reinterpret_cast<nmethod*>(0x8 * 1);
!     _nmethods[2] = reinterpret_cast<nmethod*>(0x8 * 2);
  
      dependencies().add_dependent_nmethod(_nmethods[2]);
      dependencies().add_dependent_nmethod(_nmethods[1]);
      dependencies().add_dependent_nmethod(_nmethods[0]);
    }
--- 26,59 ----
  #include "code/dependencyContext.hpp"
  #include "unittest.hpp"
  
  class TestDependencyContext {
   public:
+   char* _buffer[sizeof(nmethod) * 3];
    nmethod* _nmethods[3];
  
!   nmethodBucket* volatile _dependency_context;
!   volatile uint64_t _last_cleanup;
  
    DependencyContext dependencies() {
!     DependencyContext depContext(&_dependency_context, &_last_cleanup);
      return depContext;
    }
  
!   TestDependencyContext()
!     : _dependency_context(NULL),
!       _last_cleanup(0) {
      CodeCache_lock->lock_without_safepoint_check();
  
!     memset(_buffer, 0, sizeof(nmethod) * 3);
!     _nmethods[0] = reinterpret_cast<nmethod*>(_buffer) + 0;
!     _nmethods[1] = reinterpret_cast<nmethod*>(_buffer) + 1;
!     _nmethods[2] = reinterpret_cast<nmethod*>(_buffer) + 2;
! 
!     _nmethods[0]->clear_unloading_state();
!     _nmethods[1]->clear_unloading_state();
!     _nmethods[2]->clear_unloading_state();
  
      dependencies().add_dependent_nmethod(_nmethods[2]);
      dependencies().add_dependent_nmethod(_nmethods[1]);
      dependencies().add_dependent_nmethod(_nmethods[0]);
    }
***************
*** 52,109 ****
    ~TestDependencyContext() {
      wipe();
      CodeCache_lock->unlock();
    }
  
-   static bool has_stale_entries(DependencyContext ctx) {
-     return ctx.has_stale_entries();
-   }
- 
- #ifndef PRODUCT
-   static bool find_stale_entries(DependencyContext ctx) {
-     return ctx.find_stale_entries();
-   }
- #endif
- 
    void wipe() {
!     DependencyContext ctx(&_dependency_context);
      nmethodBucket* b = ctx.dependencies();
      ctx.set_dependencies(NULL);
-     ctx.set_has_stale_entries(false);
      while (b != NULL) {
        nmethodBucket* next = b->next();
        delete b;
        b = next;
      }
    }
  };
  
! static void test_remove_dependent_nmethod(int id, bool delete_immediately) {
    TestDependencyContext c;
    DependencyContext depContext = c.dependencies();
-   NOT_PRODUCT(ASSERT_FALSE(TestDependencyContext::find_stale_entries(depContext)));
-   ASSERT_FALSE(TestDependencyContext::has_stale_entries(depContext));
  
    nmethod* nm = c._nmethods[id];
!   depContext.remove_dependent_nmethod(nm, delete_immediately);
! 
!   if (!delete_immediately) {
!     NOT_PRODUCT(ASSERT_TRUE(TestDependencyContext::find_stale_entries(depContext)));
!     ASSERT_TRUE(TestDependencyContext::has_stale_entries(depContext));
!     NOT_PRODUCT(ASSERT_TRUE(depContext.is_dependent_nmethod(nm)));
!     depContext.expunge_stale_entries();
!   }
  
-   NOT_PRODUCT(ASSERT_FALSE(TestDependencyContext::find_stale_entries(depContext)));
-   ASSERT_FALSE(TestDependencyContext::has_stale_entries(depContext));
    NOT_PRODUCT(ASSERT_FALSE(depContext.is_dependent_nmethod(nm)));
  }
  
  TEST_VM(code, dependency_context) {
!   test_remove_dependent_nmethod(0, false);
!   test_remove_dependent_nmethod(1, false);
!   test_remove_dependent_nmethod(2, false);
! 
!   test_remove_dependent_nmethod(0, true);
!   test_remove_dependent_nmethod(1, true);
!   test_remove_dependent_nmethod(2, true);
  }
--- 61,92 ----
    ~TestDependencyContext() {
      wipe();
      CodeCache_lock->unlock();
    }
  
    void wipe() {
!     DependencyContext ctx(&_dependency_context, &_last_cleanup);
      nmethodBucket* b = ctx.dependencies();
      ctx.set_dependencies(NULL);
      while (b != NULL) {
        nmethodBucket* next = b->next();
        delete b;
        b = next;
      }
    }
  };
  
! static void test_remove_dependent_nmethod(int id) {
    TestDependencyContext c;
    DependencyContext depContext = c.dependencies();
  
    nmethod* nm = c._nmethods[id];
!   depContext.remove_dependent_nmethod(nm);
  
    NOT_PRODUCT(ASSERT_FALSE(depContext.is_dependent_nmethod(nm)));
  }
  
  TEST_VM(code, dependency_context) {
!   test_remove_dependent_nmethod(0);
!   test_remove_dependent_nmethod(1);
!   test_remove_dependent_nmethod(2);
  }