Mercurial > hg > graal-jvmci-8
annotate src/share/vm/memory/filemap.cpp @ 1994:6cd6d394f280
7001033: assert(gch->gc_cause() == GCCause::_scavenge_alot || !gch->incremental_collection_failed())
7002546: regression on SpecJbb2005 on 7b118 comparing to 7b117 on small heaps
Summary: Relaxed assertion checking related to incremental_collection_failed flag to allow for ExplicitGCInvokesConcurrent behaviour where we do not want a failing scavenge to bail to a stop-world collection. Parameterized incremental_collection_will_fail() so we can selectively use, or not use, as appropriate, the statistical prediction at specific use sites. This essentially reverts the scavenge bail-out logic to what it was prior to some recent changes that had inadvertently started using the statistical prediction which can be noisy in the presence of bursty loads. Added some associated verbose non-product debugging messages.
Reviewed-by: johnc, tonyp
| author | ysr |
|---|---|
| date | Tue, 07 Dec 2010 21:55:53 -0800 |
| parents | f95d63e2154a |
| children | 828eafbd85cc |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 1972 | 2 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. |
| 0 | 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 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
605
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
605
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
605
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/classLoader.hpp" | |
| 27 #include "classfile/symbolTable.hpp" | |
| 28 #include "memory/filemap.hpp" | |
| 29 #include "runtime/arguments.hpp" | |
| 30 #include "runtime/java.hpp" | |
| 31 #include "runtime/os.hpp" | |
| 32 #include "utilities/defaultStream.hpp" | |
| 33 #ifdef TARGET_OS_FAMILY_linux | |
| 34 # include "hpi_linux.hpp" | |
| 35 #endif | |
| 36 #ifdef TARGET_OS_FAMILY_solaris | |
| 37 # include "hpi_solaris.hpp" | |
| 38 #endif | |
| 39 #ifdef TARGET_OS_FAMILY_windows | |
| 40 # include "hpi_windows.hpp" | |
| 41 #endif | |
| 42 | |
| 0 | 43 # include <sys/stat.h> |
| 44 # include <errno.h> | |
| 45 | |
| 46 #ifndef O_BINARY // if defined (Win32) use binary files. | |
| 47 #define O_BINARY 0 // otherwise do nothing. | |
| 48 #endif | |
| 49 | |
| 50 | |
| 51 extern address JVM_FunctionAtStart(); | |
| 52 extern address JVM_FunctionAtEnd(); | |
| 53 | |
| 605 | 54 // Complain and stop. All error conditions occurring during the writing of |
| 0 | 55 // an archive file should stop the process. Unrecoverable errors during |
| 56 // the reading of the archive file should stop the process. | |
| 57 | |
| 58 static void fail(const char *msg, va_list ap) { | |
| 59 // This occurs very early during initialization: tty is not initialized. | |
| 60 jio_fprintf(defaultStream::error_stream(), | |
| 605 | 61 "An error has occurred while processing the" |
| 0 | 62 " shared archive file.\n"); |
| 63 jio_vfprintf(defaultStream::error_stream(), msg, ap); | |
| 64 jio_fprintf(defaultStream::error_stream(), "\n"); | |
| 65 vm_exit_during_initialization("Unable to use shared archive.", NULL); | |
| 66 } | |
| 67 | |
| 68 | |
| 69 void FileMapInfo::fail_stop(const char *msg, ...) { | |
| 70 va_list ap; | |
| 71 va_start(ap, msg); | |
| 72 fail(msg, ap); // Never returns. | |
| 73 va_end(ap); // for completeness. | |
| 74 } | |
| 75 | |
| 76 | |
| 77 // Complain and continue. Recoverable errors during the reading of the | |
| 78 // archive file may continue (with sharing disabled). | |
| 79 // | |
| 80 // If we continue, then disable shared spaces and close the file. | |
| 81 | |
| 82 void FileMapInfo::fail_continue(const char *msg, ...) { | |
| 83 va_list ap; | |
| 84 va_start(ap, msg); | |
| 85 if (RequireSharedSpaces) { | |
| 86 fail(msg, ap); | |
| 87 } | |
| 88 va_end(ap); | |
| 89 UseSharedSpaces = false; | |
| 90 close(); | |
| 91 } | |
| 92 | |
| 93 | |
| 94 // Fill in the fileMapInfo structure with data about this VM instance. | |
| 95 | |
| 96 void FileMapInfo::populate_header(size_t alignment) { | |
| 97 _header._magic = 0xf00baba2; | |
| 98 _header._version = _current_version; | |
| 99 _header._alignment = alignment; | |
| 100 | |
| 101 // The following fields are for sanity checks for whether this archive | |
| 102 // will function correctly with this JVM and the bootclasspath it's | |
| 103 // invoked with. | |
| 104 | |
| 105 // JVM version string ... changes on each build. | |
| 106 const char *vm_version = VM_Version::internal_vm_info_string(); | |
| 107 if (strlen(vm_version) < (JVM_IDENT_MAX-1)) { | |
| 108 strcpy(_header._jvm_ident, vm_version); | |
| 109 } else { | |
| 110 fail_stop("JVM Ident field for shared archive is too long" | |
| 111 " - truncated to <%s>", _header._jvm_ident); | |
| 112 } | |
| 113 | |
| 114 // Build checks on classpath and jar files | |
| 115 _header._num_jars = 0; | |
| 116 ClassPathEntry *cpe = ClassLoader::classpath_entry(0); | |
| 117 for ( ; cpe != NULL; cpe = cpe->next()) { | |
| 118 | |
| 119 if (cpe->is_jar_file()) { | |
| 120 if (_header._num_jars >= JVM_SHARED_JARS_MAX) { | |
| 121 fail_stop("Too many jar files to share.", NULL); | |
| 122 } | |
| 123 | |
| 124 // Jar file - record timestamp and file size. | |
| 125 struct stat st; | |
| 126 const char *path = cpe->name(); | |
| 127 if (os::stat(path, &st) != 0) { | |
| 128 // If we can't access a jar file in the boot path, then we can't | |
| 129 // make assumptions about where classes get loaded from. | |
| 130 fail_stop("Unable to open jar file %s.", path); | |
| 131 } | |
| 132 _header._jar[_header._num_jars]._timestamp = st.st_mtime; | |
| 133 _header._jar[_header._num_jars]._filesize = st.st_size; | |
| 134 _header._num_jars++; | |
| 135 } else { | |
| 136 | |
| 137 // If directories appear in boot classpath, they must be empty to | |
| 138 // avoid having to verify each individual class file. | |
| 139 const char* name = ((ClassPathDirEntry*)cpe)->name(); | |
| 140 if (!os::dir_is_empty(name)) { | |
| 141 fail_stop("Boot classpath directory %s is not empty.", name); | |
| 142 } | |
| 143 } | |
| 144 } | |
| 145 } | |
| 146 | |
| 147 | |
| 148 // Read the FileMapInfo information from the file. | |
| 149 | |
| 150 bool FileMapInfo::init_from_file(int fd) { | |
| 151 | |
| 152 size_t n = read(fd, &_header, sizeof(struct FileMapHeader)); | |
| 153 if (n != sizeof(struct FileMapHeader)) { | |
| 154 fail_continue("Unable to read the file header."); | |
| 155 return false; | |
| 156 } | |
| 157 if (_header._version != current_version()) { | |
| 158 fail_continue("The shared archive file has the wrong version."); | |
| 159 return false; | |
| 160 } | |
| 161 _file_offset = (long)n; | |
| 162 return true; | |
| 163 } | |
| 164 | |
| 165 | |
| 166 // Read the FileMapInfo information from the file. | |
| 167 bool FileMapInfo::open_for_read() { | |
| 168 _full_path = Arguments::GetSharedArchivePath(); | |
| 169 int fd = open(_full_path, O_RDONLY | O_BINARY, 0); | |
| 170 if (fd < 0) { | |
| 171 if (errno == ENOENT) { | |
| 172 // Not locating the shared archive is ok. | |
| 173 fail_continue("Specified shared archive not found."); | |
| 174 } else { | |
| 175 fail_continue("Failed to open shared archive file (%s).", | |
| 176 strerror(errno)); | |
| 177 } | |
| 178 return false; | |
| 179 } | |
| 180 | |
| 181 _fd = fd; | |
| 182 _file_open = true; | |
| 183 return true; | |
| 184 } | |
| 185 | |
| 186 | |
| 187 // Write the FileMapInfo information to the file. | |
| 188 | |
| 189 void FileMapInfo::open_for_write() { | |
| 190 _full_path = Arguments::GetSharedArchivePath(); | |
| 191 if (PrintSharedSpaces) { | |
| 192 tty->print_cr("Dumping shared data to file: "); | |
| 193 tty->print_cr(" %s", _full_path); | |
| 194 } | |
| 195 | |
| 196 // Remove the existing file in case another process has it open. | |
| 197 remove(_full_path); | |
| 198 int fd = open(_full_path, O_RDWR | O_CREAT | O_TRUNC | O_BINARY, 0444); | |
| 199 if (fd < 0) { | |
| 200 fail_stop("Unable to create shared archive file %s.", _full_path); | |
| 201 } | |
| 202 _fd = fd; | |
| 203 _file_offset = 0; | |
| 204 _file_open = true; | |
| 205 } | |
| 206 | |
| 207 | |
| 208 // Write the header to the file, seek to the next allocation boundary. | |
| 209 | |
| 210 void FileMapInfo::write_header() { | |
| 211 write_bytes_aligned(&_header, sizeof(FileMapHeader)); | |
| 212 } | |
| 213 | |
| 214 | |
| 215 // Dump shared spaces to file. | |
| 216 | |
| 217 void FileMapInfo::write_space(int i, CompactibleSpace* space, bool read_only) { | |
| 218 align_file_position(); | |
| 219 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[i]; | |
| 220 write_region(i, (char*)space->bottom(), space->used(), | |
| 221 space->capacity(), read_only, false); | |
| 222 } | |
| 223 | |
| 224 | |
| 225 // Dump region to file. | |
| 226 | |
| 227 void FileMapInfo::write_region(int region, char* base, size_t size, | |
| 228 size_t capacity, bool read_only, | |
| 229 bool allow_exec) { | |
| 230 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[region]; | |
| 231 | |
| 232 if (_file_open) { | |
| 233 guarantee(si->_file_offset == _file_offset, "file offset mismatch."); | |
| 234 if (PrintSharedSpaces) { | |
| 235 tty->print_cr("Shared file region %d: 0x%x bytes, addr 0x%x," | |
| 236 " file offset 0x%x", region, size, base, _file_offset); | |
| 237 } | |
| 238 } else { | |
| 239 si->_file_offset = _file_offset; | |
| 240 } | |
| 241 si->_base = base; | |
| 242 si->_used = size; | |
| 243 si->_capacity = capacity; | |
| 244 si->_read_only = read_only; | |
| 245 si->_allow_exec = allow_exec; | |
| 246 write_bytes_aligned(base, (int)size); | |
| 247 } | |
| 248 | |
| 249 | |
| 250 // Dump bytes to file -- at the current file position. | |
| 251 | |
| 252 void FileMapInfo::write_bytes(const void* buffer, int nbytes) { | |
| 253 if (_file_open) { | |
| 254 int n = ::write(_fd, buffer, nbytes); | |
| 255 if (n != nbytes) { | |
| 256 // It is dangerous to leave the corrupted shared archive file around, | |
| 257 // close and remove the file. See bug 6372906. | |
| 258 close(); | |
| 259 remove(_full_path); | |
| 260 fail_stop("Unable to write to shared archive file.", NULL); | |
| 261 } | |
| 262 } | |
| 263 _file_offset += nbytes; | |
| 264 } | |
| 265 | |
| 266 | |
| 267 // Align file position to an allocation unit boundary. | |
| 268 | |
| 269 void FileMapInfo::align_file_position() { | |
| 270 long new_file_offset = align_size_up(_file_offset, os::vm_allocation_granularity()); | |
| 271 if (new_file_offset != _file_offset) { | |
| 272 _file_offset = new_file_offset; | |
| 273 if (_file_open) { | |
| 274 // Seek one byte back from the target and write a byte to insure | |
| 275 // that the written file is the correct length. | |
| 276 _file_offset -= 1; | |
| 277 if (lseek(_fd, _file_offset, SEEK_SET) < 0) { | |
| 278 fail_stop("Unable to seek.", NULL); | |
| 279 } | |
| 280 char zero = 0; | |
| 281 write_bytes(&zero, 1); | |
| 282 } | |
| 283 } | |
| 284 } | |
| 285 | |
| 286 | |
| 287 // Dump bytes to file -- at the current file position. | |
| 288 | |
| 289 void FileMapInfo::write_bytes_aligned(const void* buffer, int nbytes) { | |
| 290 align_file_position(); | |
| 291 write_bytes(buffer, nbytes); | |
| 292 align_file_position(); | |
| 293 } | |
| 294 | |
| 295 | |
| 296 // Close the shared archive file. This does NOT unmap mapped regions. | |
| 297 | |
| 298 void FileMapInfo::close() { | |
| 299 if (_file_open) { | |
| 300 if (::close(_fd) < 0) { | |
| 301 fail_stop("Unable to close the shared archive file."); | |
| 302 } | |
| 303 _file_open = false; | |
| 304 _fd = -1; | |
| 305 } | |
| 306 } | |
| 307 | |
| 308 | |
| 309 // Memory map a shared space from the archive file. | |
| 310 | |
| 311 bool FileMapInfo::map_space(int i, ReservedSpace rs, ContiguousSpace* space) { | |
| 312 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[i]; | |
| 313 if (space != NULL) { | |
| 314 if (si->_base != (char*)space->bottom() || | |
| 315 si->_capacity != space->capacity()) { | |
| 316 fail_continue("Shared space base address does not match."); | |
| 317 return false; | |
| 318 } | |
| 319 } | |
| 320 bool result = (map_region(i, rs) != NULL); | |
| 321 if (space != NULL && result) { | |
| 322 space->set_top((HeapWord*)(si->_base + si->_used)); | |
| 323 space->set_saved_mark(); | |
| 324 } | |
| 325 return result; | |
| 326 } | |
| 327 | |
| 328 | |
| 329 // JVM/TI RedefineClasses() support: | |
| 330 // Remap the shared readonly space to shared readwrite, private. | |
| 331 bool FileMapInfo::remap_shared_readonly_as_readwrite() { | |
| 332 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[0]; | |
| 333 if (!si->_read_only) { | |
| 334 // the space is already readwrite so we are done | |
| 335 return true; | |
| 336 } | |
| 337 size_t used = si->_used; | |
| 338 size_t size = align_size_up(used, os::vm_allocation_granularity()); | |
| 339 if (!open_for_read()) { | |
| 340 return false; | |
| 341 } | |
| 342 char *base = os::remap_memory(_fd, _full_path, si->_file_offset, | |
| 343 si->_base, size, false /* !read_only */, | |
| 344 si->_allow_exec); | |
| 345 close(); | |
| 346 if (base == NULL) { | |
| 347 fail_continue("Unable to remap shared readonly space (errno=%d).", errno); | |
| 348 return false; | |
| 349 } | |
| 350 if (base != si->_base) { | |
| 351 fail_continue("Unable to remap shared readonly space at required address."); | |
| 352 return false; | |
| 353 } | |
| 354 si->_read_only = false; | |
| 355 return true; | |
| 356 } | |
| 357 | |
| 358 | |
| 359 // Memory map a region in the address space. | |
| 360 | |
| 361 char* FileMapInfo::map_region(int i, ReservedSpace rs) { | |
| 362 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[i]; | |
| 363 size_t used = si->_used; | |
| 364 size_t size = align_size_up(used, os::vm_allocation_granularity()); | |
| 365 | |
| 366 ReservedSpace mapped_rs = rs.first_part(size, true, true); | |
| 367 ReservedSpace unmapped_rs = rs.last_part(size); | |
| 368 mapped_rs.release(); | |
| 369 | |
| 370 return map_region(i, true); | |
| 371 } | |
| 372 | |
| 373 | |
| 374 // Memory map a region in the address space. | |
| 375 | |
| 376 char* FileMapInfo::map_region(int i, bool address_must_match) { | |
| 377 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[i]; | |
| 378 size_t used = si->_used; | |
| 379 size_t size = align_size_up(used, os::vm_allocation_granularity()); | |
| 380 char *requested_addr = 0; | |
| 381 if (address_must_match) { | |
| 382 requested_addr = si->_base; | |
| 383 } | |
| 384 char *base = os::map_memory(_fd, _full_path, si->_file_offset, | |
| 385 requested_addr, size, si->_read_only, | |
| 386 si->_allow_exec); | |
| 387 if (base == NULL) { | |
| 388 fail_continue("Unable to map shared space."); | |
| 389 return NULL; | |
| 390 } | |
| 391 if (address_must_match) { | |
| 392 if (base != si->_base) { | |
| 393 fail_continue("Unable to map shared space at required address."); | |
| 394 return NULL; | |
| 395 } | |
| 396 } else { | |
| 397 si->_base = base; // save mapped address for unmapping. | |
| 398 } | |
| 399 return base; | |
| 400 } | |
| 401 | |
| 402 | |
| 403 // Unmap a memory region in the address space. | |
| 404 | |
| 405 void FileMapInfo::unmap_region(int i) { | |
| 406 struct FileMapInfo::FileMapHeader::space_info* si = &_header._space[i]; | |
| 407 size_t used = si->_used; | |
| 408 size_t size = align_size_up(used, os::vm_allocation_granularity()); | |
| 409 if (!os::unmap_memory(si->_base, size)) { | |
| 410 fail_stop("Unable to unmap shared space."); | |
| 411 } | |
| 412 } | |
| 413 | |
| 414 | |
| 415 void FileMapInfo::assert_mark(bool check) { | |
| 416 if (!check) { | |
| 417 fail_stop("Mark mismatch while restoring from shared file.", NULL); | |
| 418 } | |
| 419 } | |
| 420 | |
| 421 | |
| 422 FileMapInfo* FileMapInfo::_current_info = NULL; | |
| 423 | |
| 424 | |
| 425 // Open the shared archive file, read and validate the header | |
| 426 // information (version, boot classpath, etc.). If initialization | |
| 427 // fails, shared spaces are disabled and the file is closed. [See | |
| 428 // fail_continue.] | |
| 429 | |
| 430 | |
| 431 bool FileMapInfo::initialize() { | |
| 432 assert(UseSharedSpaces, "UseSharedSpaces expected."); | |
| 433 | |
| 434 if (JvmtiExport::can_modify_any_class() || JvmtiExport::can_walk_any_space()) { | |
| 435 fail_continue("Tool agent requires sharing to be disabled."); | |
| 436 return false; | |
| 437 } | |
| 438 | |
| 439 if (!open_for_read()) { | |
| 440 return false; | |
| 441 } | |
| 442 | |
| 443 init_from_file(_fd); | |
| 444 if (!validate()) { | |
| 445 return false; | |
| 446 } | |
| 447 | |
| 448 SharedReadOnlySize = _header._space[0]._capacity; | |
| 449 SharedReadWriteSize = _header._space[1]._capacity; | |
| 450 SharedMiscDataSize = _header._space[2]._capacity; | |
| 451 SharedMiscCodeSize = _header._space[3]._capacity; | |
| 452 return true; | |
| 453 } | |
| 454 | |
| 455 | |
| 456 bool FileMapInfo::validate() { | |
| 457 if (_header._version != current_version()) { | |
| 458 fail_continue("The shared archive file is the wrong version."); | |
| 459 return false; | |
| 460 } | |
| 461 if (_header._magic != (int)0xf00baba2) { | |
| 462 fail_continue("The shared archive file has a bad magic number."); | |
| 463 return false; | |
| 464 } | |
| 465 if (strncmp(_header._jvm_ident, VM_Version::internal_vm_info_string(), | |
| 466 JVM_IDENT_MAX-1) != 0) { | |
| 467 fail_continue("The shared archive file was created by a different" | |
| 468 " version or build of HotSpot."); | |
| 469 return false; | |
| 470 } | |
| 471 | |
| 472 // Cannot verify interpreter yet, as it can only be created after the GC | |
| 473 // heap has been initialized. | |
| 474 | |
| 475 if (_header._num_jars >= JVM_SHARED_JARS_MAX) { | |
| 476 fail_continue("Too many jar files to share."); | |
| 477 return false; | |
| 478 } | |
| 479 | |
| 480 // Build checks on classpath and jar files | |
| 481 int num_jars_now = 0; | |
| 482 ClassPathEntry *cpe = ClassLoader::classpath_entry(0); | |
| 483 for ( ; cpe != NULL; cpe = cpe->next()) { | |
| 484 | |
| 485 if (cpe->is_jar_file()) { | |
| 486 if (num_jars_now < _header._num_jars) { | |
| 487 | |
| 488 // Jar file - verify timestamp and file size. | |
| 489 struct stat st; | |
| 490 const char *path = cpe->name(); | |
| 491 if (os::stat(path, &st) != 0) { | |
| 492 fail_continue("Unable to open jar file %s.", path); | |
| 493 return false; | |
| 494 } | |
| 495 if (_header._jar[num_jars_now]._timestamp != st.st_mtime || | |
| 496 _header._jar[num_jars_now]._filesize != st.st_size) { | |
| 497 fail_continue("A jar file is not the one used while building" | |
| 498 " the shared archive file."); | |
| 499 return false; | |
| 500 } | |
| 501 } | |
| 502 ++num_jars_now; | |
| 503 } else { | |
| 504 | |
| 505 // If directories appear in boot classpath, they must be empty to | |
| 506 // avoid having to verify each individual class file. | |
| 507 const char* name = ((ClassPathDirEntry*)cpe)->name(); | |
| 508 if (!os::dir_is_empty(name)) { | |
| 509 fail_continue("Boot classpath directory %s is not empty.", name); | |
| 510 return false; | |
| 511 } | |
| 512 } | |
| 513 } | |
| 514 if (num_jars_now < _header._num_jars) { | |
| 515 fail_continue("The number of jar files in the boot classpath is" | |
| 516 " less than the number the shared archive was created with."); | |
| 517 return false; | |
| 518 } | |
| 519 | |
| 520 return true; | |
| 521 } | |
| 522 | |
| 523 // The following method is provided to see whether a given pointer | |
| 524 // falls in the mapped shared space. | |
| 525 // Param: | |
| 526 // p, The given pointer | |
| 527 // Return: | |
| 528 // True if the p is within the mapped shared space, otherwise, false. | |
| 529 bool FileMapInfo::is_in_shared_space(const void* p) { | |
| 530 for (int i = 0; i < CompactingPermGenGen::n_regions; i++) { | |
| 531 if (p >= _header._space[i]._base && | |
| 532 p < _header._space[i]._base + _header._space[i]._used) { | |
| 533 return true; | |
| 534 } | |
| 535 } | |
| 536 | |
| 537 return false; | |
| 538 } |