1 /*
   2  * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #include "precompiled.hpp"
  26 #include "ci/ciEnv.hpp"
  27 #include "ci/ciInstance.hpp"
  28 #include "ci/ciMetadata.hpp"
  29 #include "code/oopRecorder.hpp"
  30 #include "memory/allocation.inline.hpp"
  31 #include "oops/oop.inline.hpp"
  32 
  33 #ifdef ASSERT
  34 template <class T> int ValueRecorder<T>::_find_index_calls = 0;
  35 template <class T> int ValueRecorder<T>::_hit_indexes      = 0;
  36 template <class T> int ValueRecorder<T>::_missed_indexes   = 0;
  37 #endif //ASSERT
  38 
  39 
  40 template <class T> ValueRecorder<T>::ValueRecorder(Arena* arena) {
  41   _handles  = NULL;
  42   _indexes  = NULL;
  43   _arena    = arena;
  44   _complete = false;
  45 }
  46 
  47 template <class T> template <class X>  ValueRecorder<T>::IndexCache<X>::IndexCache() {
  48   assert(first_index > 0, "initial zero state of cache must be invalid index");
  49   Copy::zero_to_bytes(&_cache[0], sizeof(_cache));
  50 }
  51 
  52 template <class T> int ValueRecorder<T>::size() {
  53   _complete = true;
  54   if (_handles == NULL)  return 0;
  55   return _handles->length() * sizeof(T);
  56 }
  57 
  58 template <class T> void ValueRecorder<T>::copy_values_to(nmethod* nm) {
  59   assert(_complete, "must be frozen");
  60   maybe_initialize();  // get non-null handles, even if we have no oops
  61   nm->copy_values(_handles);
  62 }
  63 
  64 template <class T> void ValueRecorder<T>::maybe_initialize() {
  65   if (_handles == NULL) {
  66     if (_arena != NULL) {
  67       _handles  = new(_arena) GrowableArray<T>(_arena, 10, 0, 0);
  68       _no_finds = new(_arena) GrowableArray<int>(    _arena, 10, 0, 0);
  69     } else {
  70       _handles  = new GrowableArray<T>(10, 0, 0);
  71       _no_finds = new GrowableArray<int>(    10, 0, 0);
  72     }
  73   }
  74 }
  75 
  76 
  77 template <class T> T ValueRecorder<T>::at(int index) {
  78   // there is always a NULL virtually present as first object
  79   if (index == null_index)  return NULL;
  80   return _handles->at(index - first_index);
  81 }
  82 
  83 
  84 template <class T> int ValueRecorder<T>::add_handle(T h, bool make_findable) {
  85   assert(!_complete, "cannot allocate more elements after size query");
  86   maybe_initialize();
  87   // indexing uses 1 as an origin--0 means null
  88   int index = _handles->length() + first_index;
  89   _handles->append(h);
  90 
  91   // Support correct operation of find_index().
  92   assert(!(make_findable && !is_real(h)), "nulls are not findable");
  93   if (make_findable) {
  94     // This index may be returned from find_index().
  95     if (_indexes != NULL) {
  96       int* cloc = _indexes->cache_location(h);
  97       _indexes->set_cache_location_index(cloc, index);
  98     } else if (index == index_cache_threshold && _arena != NULL) {
  99       _indexes = new(_arena) IndexCache<T>();
 100       for (int i = 0; i < _handles->length(); i++) {
 101         // Load the cache with pre-existing elements.
 102         int index0 = i + first_index;
 103         if (_no_finds->contains(index0))  continue;
 104         int* cloc = _indexes->cache_location(_handles->at(i));
 105         _indexes->set_cache_location_index(cloc, index0);
 106       }
 107     }
 108   } else if (is_real(h)) {
 109     // Remember that this index is not to be returned from find_index().
 110     // This case is rare, because most or all uses of allocate_index pass
 111     // an argument of NULL or Universe::non_oop_word.
 112     // Thus, the expected length of _no_finds is zero.
 113     _no_finds->append(index);
 114   }
 115 
 116   return index;
 117 }
 118 
 119 
 120 template <class T> int ValueRecorder<T>::maybe_find_index(T h) {
 121   debug_only(_find_index_calls++);
 122   assert(!_complete, "cannot allocate more elements after size query");
 123   maybe_initialize();
 124   if (h == NULL)  return null_index;
 125   assert(is_real(h), "must be valid");
 126   int* cloc = (_indexes == NULL)? NULL: _indexes->cache_location(h);
 127   if (cloc != NULL) {
 128     int cindex = _indexes->cache_location_index(cloc);
 129     if (cindex == 0) {
 130       return -1;   // We know this handle is completely new.
 131     }
 132     if (cindex >= first_index && _handles->at(cindex - first_index) == h) {
 133       debug_only(_hit_indexes++);
 134       return cindex;
 135     }
 136     if (!_indexes->cache_location_collision(cloc)) {
 137       return -1;   // We know the current cache occupant is unique to that cloc.
 138     }
 139   }
 140 
 141   // Not found in cache, due to a cache collision.  (Or, no cache at all.)
 142   // Do a linear search, most recent to oldest.
 143   for (int i = _handles->length() - 1; i >= 0; i--) {
 144     if (_handles->at(i) == h) {
 145       int findex = i + first_index;
 146       if (_no_finds->contains(findex))  continue;  // oops; skip this one
 147       if (cloc != NULL) {
 148         _indexes->set_cache_location_index(cloc, findex);
 149       }
 150       debug_only(_missed_indexes++);
 151       return findex;
 152     }
 153   }
 154   return -1;
 155 }
 156 
 157 // Explicitly instantiate these types
 158 template class ValueRecorder<Metadata*>;
 159 template class ValueRecorder<jobject>;
 160 
 161 oop ObjectLookup::ObjectEntry::oop_value() const { return JNIHandles::resolve(_value); }
 162 
 163 ObjectLookup::ObjectLookup(): _gc_count(Universe::heap()->total_collections()), _values(4) {}
 164 
 165 void ObjectLookup::maybe_resort() {
 166   // The values are kept sorted by address which may be invalidated
 167   // after a GC, so resort if a GC has occurred since last time.
 168   if (_gc_count != Universe::heap()->total_collections()) {
 169     _gc_count = Universe::heap()->total_collections();
 170     _values.sort(sort_by_address);
 171   }
 172 }
 173 
 174 int ObjectLookup::sort_by_address(oop a, oop b) {
 175   if (b > a) return 1;
 176   if (a > b) return -1;
 177   return 0;
 178 }
 179 
 180 int ObjectLookup::sort_by_address(ObjectEntry* a, ObjectEntry* b) {
 181   return sort_by_address(a->oop_value(), b->oop_value());
 182 }
 183 
 184 int ObjectLookup::sort_oop_by_address(oop const& a, ObjectEntry const& b) {
 185   return sort_by_address(a, b.oop_value());
 186 }
 187   
 188 int ObjectLookup::find_index(jobject handle, OopRecorder* oop_recorder) {
 189   if (handle == NULL) {
 190     return 0;
 191   }
 192   oop object = JNIHandles::resolve(handle);
 193   maybe_resort();
 194   bool found;
 195   int location = _values.find_sorted<oop, sort_oop_by_address>(object, found);
 196   if (!found) {
 197     jobject handle = JNIHandles::make_local(object);
 198     ObjectEntry r(handle, oop_recorder->allocate_oop_index(handle));
 199     _values.insert_before(location, r);
 200     return r.index();
 201   }
 202   return _values.at(location).index();
 203 }
 204