equal
deleted
inserted
replaced
156 if (extra_base == NULL) { |
156 if (extra_base == NULL) { |
157 return NULL; |
157 return NULL; |
158 } |
158 } |
159 |
159 |
160 // Do manual alignment |
160 // Do manual alignment |
161 char* aligned_base = align_ptr_up(extra_base, alignment); |
161 char* aligned_base = align_up(extra_base, alignment); |
162 |
162 |
163 // [ | | ] |
163 // [ | | ] |
164 // ^ extra_base |
164 // ^ extra_base |
165 // ^ extra_base + begin_offset == aligned_base |
165 // ^ extra_base + begin_offset == aligned_base |
166 // extra_base + begin_offset + size ^ |
166 // extra_base + begin_offset + size ^ |
320 } else { |
320 } else { |
321 // perform the binary search. |
321 // perform the binary search. |
322 julong lower_limit = min_allocation_size; |
322 julong lower_limit = min_allocation_size; |
323 while ((upper_limit - lower_limit) > min_allocation_size) { |
323 while ((upper_limit - lower_limit) > min_allocation_size) { |
324 julong temp_limit = ((upper_limit - lower_limit) / 2) + lower_limit; |
324 julong temp_limit = ((upper_limit - lower_limit) / 2) + lower_limit; |
325 temp_limit = align_size_down_(temp_limit, min_allocation_size); |
325 temp_limit = align_down_(temp_limit, min_allocation_size); |
326 if (is_allocatable(temp_limit)) { |
326 if (is_allocatable(temp_limit)) { |
327 lower_limit = temp_limit; |
327 lower_limit = temp_limit; |
328 } else { |
328 } else { |
329 upper_limit = temp_limit; |
329 upper_limit = temp_limit; |
330 } |
330 } |
1178 |
1178 |
1179 _java_thread_min_stack_allowed = _java_thread_min_stack_allowed + |
1179 _java_thread_min_stack_allowed = _java_thread_min_stack_allowed + |
1180 JavaThread::stack_guard_zone_size() + |
1180 JavaThread::stack_guard_zone_size() + |
1181 JavaThread::stack_shadow_zone_size(); |
1181 JavaThread::stack_shadow_zone_size(); |
1182 |
1182 |
1183 _java_thread_min_stack_allowed = align_size_up(_java_thread_min_stack_allowed, vm_page_size()); |
1183 _java_thread_min_stack_allowed = align_up(_java_thread_min_stack_allowed, vm_page_size()); |
1184 _java_thread_min_stack_allowed = MAX2(_java_thread_min_stack_allowed, os_min_stack_allowed); |
1184 _java_thread_min_stack_allowed = MAX2(_java_thread_min_stack_allowed, os_min_stack_allowed); |
1185 |
1185 |
1186 size_t stack_size_in_bytes = ThreadStackSize * K; |
1186 size_t stack_size_in_bytes = ThreadStackSize * K; |
1187 if (stack_size_in_bytes != 0 && |
1187 if (stack_size_in_bytes != 0 && |
1188 stack_size_in_bytes < _java_thread_min_stack_allowed) { |
1188 stack_size_in_bytes < _java_thread_min_stack_allowed) { |
1202 // Reminder: a compiler thread is a Java thread. |
1202 // Reminder: a compiler thread is a Java thread. |
1203 _compiler_thread_min_stack_allowed = _compiler_thread_min_stack_allowed + |
1203 _compiler_thread_min_stack_allowed = _compiler_thread_min_stack_allowed + |
1204 JavaThread::stack_guard_zone_size() + |
1204 JavaThread::stack_guard_zone_size() + |
1205 JavaThread::stack_shadow_zone_size(); |
1205 JavaThread::stack_shadow_zone_size(); |
1206 |
1206 |
1207 _compiler_thread_min_stack_allowed = align_size_up(_compiler_thread_min_stack_allowed, vm_page_size()); |
1207 _compiler_thread_min_stack_allowed = align_up(_compiler_thread_min_stack_allowed, vm_page_size()); |
1208 _compiler_thread_min_stack_allowed = MAX2(_compiler_thread_min_stack_allowed, os_min_stack_allowed); |
1208 _compiler_thread_min_stack_allowed = MAX2(_compiler_thread_min_stack_allowed, os_min_stack_allowed); |
1209 |
1209 |
1210 stack_size_in_bytes = CompilerThreadStackSize * K; |
1210 stack_size_in_bytes = CompilerThreadStackSize * K; |
1211 if (stack_size_in_bytes != 0 && |
1211 if (stack_size_in_bytes != 0 && |
1212 stack_size_in_bytes < _compiler_thread_min_stack_allowed) { |
1212 stack_size_in_bytes < _compiler_thread_min_stack_allowed) { |
1214 "Specify at least " SIZE_FORMAT "k", |
1214 "Specify at least " SIZE_FORMAT "k", |
1215 _compiler_thread_min_stack_allowed / K); |
1215 _compiler_thread_min_stack_allowed / K); |
1216 return JNI_ERR; |
1216 return JNI_ERR; |
1217 } |
1217 } |
1218 |
1218 |
1219 _vm_internal_thread_min_stack_allowed = align_size_up(_vm_internal_thread_min_stack_allowed, vm_page_size()); |
1219 _vm_internal_thread_min_stack_allowed = align_up(_vm_internal_thread_min_stack_allowed, vm_page_size()); |
1220 _vm_internal_thread_min_stack_allowed = MAX2(_vm_internal_thread_min_stack_allowed, os_min_stack_allowed); |
1220 _vm_internal_thread_min_stack_allowed = MAX2(_vm_internal_thread_min_stack_allowed, os_min_stack_allowed); |
1221 |
1221 |
1222 stack_size_in_bytes = VMThreadStackSize * K; |
1222 stack_size_in_bytes = VMThreadStackSize * K; |
1223 if (stack_size_in_bytes != 0 && |
1223 if (stack_size_in_bytes != 0 && |
1224 stack_size_in_bytes < _vm_internal_thread_min_stack_allowed) { |
1224 stack_size_in_bytes < _vm_internal_thread_min_stack_allowed) { |
1274 } |
1274 } |
1275 |
1275 |
1276 // pthread_attr_setstacksize() may require that the size be rounded up to the OS page size. |
1276 // pthread_attr_setstacksize() may require that the size be rounded up to the OS page size. |
1277 // Be careful not to round up to 0. Align down in that case. |
1277 // Be careful not to round up to 0. Align down in that case. |
1278 if (stack_size <= SIZE_MAX - vm_page_size()) { |
1278 if (stack_size <= SIZE_MAX - vm_page_size()) { |
1279 stack_size = align_size_up(stack_size, vm_page_size()); |
1279 stack_size = align_up(stack_size, vm_page_size()); |
1280 } else { |
1280 } else { |
1281 stack_size = align_size_down(stack_size, vm_page_size()); |
1281 stack_size = align_down(stack_size, vm_page_size()); |
1282 } |
1282 } |
1283 |
1283 |
1284 return stack_size; |
1284 return stack_size; |
1285 } |
1285 } |
1286 |
1286 |