72 assert(ValueArrayFlatten, "Flatten array not allowed");
73 assert(ValueKlass::cast(element_klass())->is_atomic() || (!ValueArrayAtomicAccess), "Atomic by-default");
74
75 ClassLoaderData* loader_data = element_klass->class_loader_data();
76 int size = ArrayKlass::static_size(ValueArrayKlass::header_size());
77 ValueArrayKlass* vak = new (loader_data, size, THREAD) ValueArrayKlass(element_klass, name);
78 if (vak == NULL) {
79 return NULL;
80 }
81 loader_data->add_class(vak);
82 complete_create_array_klass(vak, vak->super(), CHECK_NULL);
83 return vak;
84 }
85
86 ValueArrayKlass* ValueArrayKlass::allocate_klass(KlassHandle element_klass, TRAPS) {
87 Symbol* name = ArrayKlass::create_element_klass_array_name(element_klass, CHECK_NULL);
88 return allocate_klass(element_klass, name, THREAD);
89 }
90
91 // Oops allocation...
92 valueArrayOop ValueArrayKlass::allocate_array(int length,
93 bool do_zero,
94 TRAPS) {
95 CMH("this is virtually identical in all arrayKlasses, refactor")
96 if (length < 0) {
97 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
98 }
99 if (length > max_elements()) {
100 report_java_out_of_memory("Requested array size exceeds VM limit");
101 JvmtiExport::post_array_size_exhausted();
102 THROW_OOP_0(Universe::out_of_memory_error_array_size());
103 }
104
105 size_t size = valueArrayOopDesc::object_size(layout_helper(), length);
106 KlassHandle h_k(THREAD, this);
107 valueArrayOop array;
108 CollectedHeap* ch = Universe::heap();
109 if (do_zero) {
110 array = (valueArrayOop)CollectedHeap::array_allocate(h_k, (int)size, length, CHECK_NULL);
111 } else {
112 array = (valueArrayOop)CollectedHeap::array_allocate_nozero(h_k, (int)size, length, CHECK_NULL);
113 }
114 return array;
115 }
116
117
118 oop ValueArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
119 // For valueArrays this is only called for the last dimension
120 assert(rank == 1, "just checking");
121 int length = *last_size;
122 return allocate_array(length, true, THREAD);
123 }
124
125 jint ValueArrayKlass::array_layout_helper(ValueKlass* vk) {
126 BasicType etype = T_VALUETYPE;
127 int atag = _lh_array_tag_type_value;
128 int esize = upper_log2(vk->raw_value_byte_size());
129 int hsize = arrayOopDesc::base_offset_in_bytes(etype);
130
131 int lh = (atag << _lh_array_tag_shift)
132 | (1 << _lh_valuetype_bit)
133 | (hsize << _lh_header_size_shift)
134 | ((int)etype << _lh_element_type_shift)
135 | (esize);
136
137 #ifdef DEBUG
138 assert(lh < (int)_lh_neutral_value, "must look like an array layout");
139 assert(layout_helper_is_array(lh), "correct kind");
140 assert(layout_helper_is_valueArray(lh), "correct kind");
141 assert(layout_helper_header_size(lh) == hsize, "correct decode");
142 assert(layout_helper_element_type(lh) == etype, "correct decode");
143 assert(layout_helper_is_typeArray(lh), "correct kind");
144 assert(1 << layout_helper_log2_element_size(lh) == esize, "correct decode");
145 #endif
146 return lh;
147 }
148
149 int ValueArrayKlass::oop_size(oop obj) const {
150 assert(obj->is_valueArray(),"must be a value array");
151 valueArrayOop array = valueArrayOop(obj);
152 return array->object_size();
153 }
154
155 jint ValueArrayKlass::max_elements() const {
243 assert(!is_objArray_klass(), "Unimplemented");
244
245 st->print("Value Type Array: ");
246 Klass::print_on(st);
247
248 st->print(" - element klass: ");
249 element_klass()->print_value_on(st);
250 st->cr();
251
252 int elem_size = element_byte_size();
253 st->print(" - element size %i ", elem_size);
254 st->print("aligned layout size %i", 1 << layout_helper_log2_element_size(layout_helper()));
255 st->cr();
256 #endif //PRODUCT
257 }
258
259 #ifndef PRODUCT
260 void ValueArrayKlass::oop_print_on(oop obj, outputStream* st) {
261 ArrayKlass::oop_print_on(obj, st);
262 valueArrayOop va = valueArrayOop(obj);
263 int print_len = MIN2((intx) va->length(), MaxElementPrintSize);
264 for(int index = 0; index < print_len; index++) {
265 st->print(" - %3d : ", index);
266 CMH("CMH: helper method for valueOop/valorind printing")
267 st->print(" CMH: helper method for valueOop/valorind printing");
268 st->cr();
269 }
270 int remaining = va->length() - print_len;
271 if (remaining > 0) {
272 st->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
273 }
274 }
275 #endif //PRODUCT
276
|
72 assert(ValueArrayFlatten, "Flatten array not allowed");
73 assert(ValueKlass::cast(element_klass())->is_atomic() || (!ValueArrayAtomicAccess), "Atomic by-default");
74
75 ClassLoaderData* loader_data = element_klass->class_loader_data();
76 int size = ArrayKlass::static_size(ValueArrayKlass::header_size());
77 ValueArrayKlass* vak = new (loader_data, size, THREAD) ValueArrayKlass(element_klass, name);
78 if (vak == NULL) {
79 return NULL;
80 }
81 loader_data->add_class(vak);
82 complete_create_array_klass(vak, vak->super(), CHECK_NULL);
83 return vak;
84 }
85
86 ValueArrayKlass* ValueArrayKlass::allocate_klass(KlassHandle element_klass, TRAPS) {
87 Symbol* name = ArrayKlass::create_element_klass_array_name(element_klass, CHECK_NULL);
88 return allocate_klass(element_klass, name, THREAD);
89 }
90
91 // Oops allocation...
92 oop ValueArrayKlass::allocate(int length, bool do_zero, TRAPS) {
93 CMH("this is virtually identical in all arrayKlasses, refactor")
94 if (length < 0) {
95 THROW_0(vmSymbols::java_lang_NegativeArraySizeException());
96 }
97 if (length > max_elements()) {
98 report_java_out_of_memory("Requested array size exceeds VM limit");
99 JvmtiExport::post_array_size_exhausted();
100 THROW_OOP_0(Universe::out_of_memory_error_array_size());
101 }
102
103 size_t size = valueArrayOopDesc::object_size(layout_helper(), length);
104 KlassHandle h_k(THREAD, this);
105 if (do_zero) {
106 return CollectedHeap::array_allocate(h_k, (int)size, length, CHECK_NULL);
107 } else {
108 return CollectedHeap::array_allocate_nozero(h_k, (int)size, length, CHECK_NULL);
109 }
110 }
111
112
113 oop ValueArrayKlass::multi_allocate(int rank, jint* last_size, TRAPS) {
114 // For valueArrays this is only called for the last dimension
115 assert(rank == 1, "just checking");
116 int length = *last_size;
117 return allocate(length, true, THREAD);
118 }
119
120 jint ValueArrayKlass::array_layout_helper(ValueKlass* vk) {
121 BasicType etype = T_VALUETYPE;
122 int atag = _lh_array_tag_type_value;
123 int esize = upper_log2(vk->raw_value_byte_size());
124 int hsize = arrayOopDesc::base_offset_in_bytes(etype);
125
126 int lh = (atag << _lh_array_tag_shift)
127 | (1 << _lh_valuetype_bit)
128 | (hsize << _lh_header_size_shift)
129 | ((int)etype << _lh_element_type_shift)
130 | ((esize) << _lh_log2_element_size_shift);
131
132 #ifdef DEBUG
133 assert(lh < (int)_lh_neutral_value, "must look like an array layout");
134 assert(layout_helper_is_array(lh), "correct kind");
135 assert(layout_helper_is_valueArray(lh), "correct kind");
136 assert(layout_helper_header_size(lh) == hsize, "correct decode");
137 assert(layout_helper_element_type(lh) == etype, "correct decode");
138 assert(layout_helper_is_typeArray(lh), "correct kind");
139 assert(1 << layout_helper_log2_element_size(lh) == esize, "correct decode");
140 #endif
141 return lh;
142 }
143
144 int ValueArrayKlass::oop_size(oop obj) const {
145 assert(obj->is_valueArray(),"must be a value array");
146 valueArrayOop array = valueArrayOop(obj);
147 return array->object_size();
148 }
149
150 jint ValueArrayKlass::max_elements() const {
238 assert(!is_objArray_klass(), "Unimplemented");
239
240 st->print("Value Type Array: ");
241 Klass::print_on(st);
242
243 st->print(" - element klass: ");
244 element_klass()->print_value_on(st);
245 st->cr();
246
247 int elem_size = element_byte_size();
248 st->print(" - element size %i ", elem_size);
249 st->print("aligned layout size %i", 1 << layout_helper_log2_element_size(layout_helper()));
250 st->cr();
251 #endif //PRODUCT
252 }
253
254 #ifndef PRODUCT
255 void ValueArrayKlass::oop_print_on(oop obj, outputStream* st) {
256 ArrayKlass::oop_print_on(obj, st);
257 valueArrayOop va = valueArrayOop(obj);
258 ValueKlass* vk = element_klass();
259 int print_len = MIN2((intx) va->length(), MaxElementPrintSize);
260 for(int index = 0; index < print_len; index++) {
261 st->print_cr(" - %d : ", index);
262 oop obj = (oop) ((uintptr_t)va->value_at_addr(index, layout_helper()) - vk->first_field_offset());
263 FieldPrinter print_field(st, obj);
264 vk->do_nonstatic_fields(&print_field);
265 st->cr();
266 }
267 int remaining = va->length() - print_len;
268 if (remaining > 0) {
269 st->print_cr(" - <%d more elements, increase MaxElementPrintSize to print>", remaining);
270 }
271 }
272 #endif //PRODUCT
273
|