< prev index next >

src/share/vm/oops/array.hpp

Print this page




  47     _length = length;
  48   }
  49 
  50  private:
  51   // Turn off copy constructor and assignment operator.
  52   Array(const Array<T>&);
  53   void operator=(const Array<T>&);
  54 
  55   void* operator new(size_t size, ClassLoaderData* loader_data, int length, bool read_only, TRAPS) throw() {
  56     size_t word_size = Array::size(length);
  57     return (void*) Metaspace::allocate(loader_data, word_size, read_only,
  58                                        MetaspaceObj::array_type(sizeof(T)), THREAD);
  59   }
  60 
  61   static size_t byte_sizeof(int length) { return sizeof(Array<T>) + MAX2(length - 1, 0) * sizeof(T); }
  62 
  63   // WhiteBox API helper.
  64   // Can't distinguish between array of length 0 and length 1,
  65   // will always return 0 in those cases.
  66   static int bytes_to_length(size_t bytes)       {
  67     assert(is_size_aligned(bytes, BytesPerWord), "Must be, for now");
  68 
  69     if (sizeof(Array<T>) >= bytes) {
  70       return 0;
  71     }
  72 
  73     size_t left = bytes - sizeof(Array<T>);
  74     assert(is_size_aligned(left, sizeof(T)), "Must be");
  75 
  76     size_t elements = left / sizeof(T);
  77     assert(elements <= (size_t)INT_MAX, "number of elements " SIZE_FORMAT "doesn't fit into an int.", elements);
  78 
  79     int length = (int)elements;
  80 
  81     assert((size_t)size(length) * BytesPerWord == (size_t)bytes,
  82            "Expected: " SIZE_FORMAT " got: " SIZE_FORMAT,
  83            bytes, (size_t)size(length) * BytesPerWord);
  84 
  85     return length;
  86   }
  87 
  88   explicit Array(int length) : _length(length) {
  89     assert(length >= 0, "illegal length");
  90   }
  91 
  92   Array(int length, T init) : _length(length) {
  93     assert(length >= 0, "illegal length");
  94     for (int i = 0; i < length; i++) {


 105 
 106   int index_of(const T& x) const {
 107     int i = length();
 108     while (i-- > 0 && _data[i] != x) ;
 109 
 110     return i;
 111   }
 112 
 113   // sort the array.
 114   bool contains(const T& x) const      { return index_of(x) >= 0; }
 115 
 116   T    at(int i) const                 { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); return _data[i]; }
 117   void at_put(const int i, const T& x) { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); _data[i] = x; }
 118   T*   adr_at(const int i)             { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); return &_data[i]; }
 119   int  find(const T& x)                { return index_of(x); }
 120 
 121   T at_acquire(const int which)              { return OrderAccess::load_acquire(adr_at(which)); }
 122   void release_at_put(int which, T contents) { OrderAccess::release_store(adr_at(which), contents); }
 123 
 124   static int size(int length) {
 125     size_t bytes = align_size_up(byte_sizeof(length), BytesPerWord);
 126     size_t words = bytes / BytesPerWord;
 127 
 128     assert(words <= INT_MAX, "Overflow: " SIZE_FORMAT, words);
 129 
 130     return (int)words;
 131   }
 132 
 133   int size() {
 134     return size(_length);
 135   }
 136 
 137   static int length_offset_in_bytes() { return (int) (offset_of(Array<T>, _length)); }
 138   // Note, this offset don't have to be wordSize aligned.
 139   static int base_offset_in_bytes() { return (int) (offset_of(Array<T>, _data)); };
 140 
 141   // FIXME: How to handle this?
 142   void print_value_on(outputStream* st) const {
 143     st->print("Array<T>(" INTPTR_FORMAT ")", p2i(this));
 144   }
 145 


  47     _length = length;
  48   }
  49 
  50  private:
  51   // Turn off copy constructor and assignment operator.
  52   Array(const Array<T>&);
  53   void operator=(const Array<T>&);
  54 
  55   void* operator new(size_t size, ClassLoaderData* loader_data, int length, bool read_only, TRAPS) throw() {
  56     size_t word_size = Array::size(length);
  57     return (void*) Metaspace::allocate(loader_data, word_size, read_only,
  58                                        MetaspaceObj::array_type(sizeof(T)), THREAD);
  59   }
  60 
  61   static size_t byte_sizeof(int length) { return sizeof(Array<T>) + MAX2(length - 1, 0) * sizeof(T); }
  62 
  63   // WhiteBox API helper.
  64   // Can't distinguish between array of length 0 and length 1,
  65   // will always return 0 in those cases.
  66   static int bytes_to_length(size_t bytes)       {
  67     assert(is_aligned(bytes, BytesPerWord), "Must be, for now");
  68 
  69     if (sizeof(Array<T>) >= bytes) {
  70       return 0;
  71     }
  72 
  73     size_t left = bytes - sizeof(Array<T>);
  74     assert(is_aligned(left, sizeof(T)), "Must be");
  75 
  76     size_t elements = left / sizeof(T);
  77     assert(elements <= (size_t)INT_MAX, "number of elements " SIZE_FORMAT "doesn't fit into an int.", elements);
  78 
  79     int length = (int)elements;
  80 
  81     assert((size_t)size(length) * BytesPerWord == (size_t)bytes,
  82            "Expected: " SIZE_FORMAT " got: " SIZE_FORMAT,
  83            bytes, (size_t)size(length) * BytesPerWord);
  84 
  85     return length;
  86   }
  87 
  88   explicit Array(int length) : _length(length) {
  89     assert(length >= 0, "illegal length");
  90   }
  91 
  92   Array(int length, T init) : _length(length) {
  93     assert(length >= 0, "illegal length");
  94     for (int i = 0; i < length; i++) {


 105 
 106   int index_of(const T& x) const {
 107     int i = length();
 108     while (i-- > 0 && _data[i] != x) ;
 109 
 110     return i;
 111   }
 112 
 113   // sort the array.
 114   bool contains(const T& x) const      { return index_of(x) >= 0; }
 115 
 116   T    at(int i) const                 { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); return _data[i]; }
 117   void at_put(const int i, const T& x) { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); _data[i] = x; }
 118   T*   adr_at(const int i)             { assert(i >= 0 && i< _length, "oob: 0 <= %d < %d", i, _length); return &_data[i]; }
 119   int  find(const T& x)                { return index_of(x); }
 120 
 121   T at_acquire(const int which)              { return OrderAccess::load_acquire(adr_at(which)); }
 122   void release_at_put(int which, T contents) { OrderAccess::release_store(adr_at(which), contents); }
 123 
 124   static int size(int length) {
 125     size_t bytes = align_up(byte_sizeof(length), BytesPerWord);
 126     size_t words = bytes / BytesPerWord;
 127 
 128     assert(words <= INT_MAX, "Overflow: " SIZE_FORMAT, words);
 129 
 130     return (int)words;
 131   }
 132 
 133   int size() {
 134     return size(_length);
 135   }
 136 
 137   static int length_offset_in_bytes() { return (int) (offset_of(Array<T>, _length)); }
 138   // Note, this offset don't have to be wordSize aligned.
 139   static int base_offset_in_bytes() { return (int) (offset_of(Array<T>, _data)); };
 140 
 141   // FIXME: How to handle this?
 142   void print_value_on(outputStream* st) const {
 143     st->print("Array<T>(" INTPTR_FORMAT ")", p2i(this));
 144   }
 145 
< prev index next >