3387   int err = errno;
3388 
3389   // Remove shmid. If shmat() is successful, the actual shared memory segment
3390   // will be deleted when it's detached by shmdt() or when the process
3391   // terminates. If shmat() is not successful this will remove the shared
3392   // segment immediately.
3393   shmctl(shmid, IPC_RMID, NULL);
3394 
3395   if (retAddr == (char *) -1) {
3396     if (warn_on_failure) {
3397       jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err);
3398       warning(msg);
3399     }
3400     return NULL;
3401   }
3402   if ((retAddr != NULL) && UseNUMAInterleaving) {
3403     numa_make_global(retAddr, size);
3404   }
3405 
3406   // The memory is committed
3407   address pc = CALLER_PC;
3408   MemTracker::record_virtual_memory_reserve((address)retAddr, size, pc);
3409   MemTracker::record_virtual_memory_commit((address)retAddr, size, pc);
3410 
3411   return retAddr;
3412 }
3413 
3414 bool os::release_memory_special(char* base, size_t bytes) {

3415   // detaching the SHM segment will also delete it, see reserve_memory_special()
3416   int rslt = shmdt(base);
3417   if (rslt == 0) {
3418     MemTracker::record_virtual_memory_uncommit((address)base, bytes);
3419     MemTracker::record_virtual_memory_release((address)base, bytes);
3420     return true;
3421   } else {

3422    return false;
3423   }
3424 }
3425 
3426 size_t os::large_page_size() {
3427   return _large_page_size;
3428 }
3429 
3430 // MPSS allows application to commit large page memory on demand; with ISM
3431 // the entire memory region must be allocated as shared memory.
3432 bool os::can_commit_large_page_memory() {
3433   return UseISM ? false : true;
3434 }
3435 
3436 bool os::can_execute_large_page_memory() {
3437   return UseISM ? false : true;
3438 }
3439 
3440 static int os_sleep(jlong millis, bool interruptible) {
3441   const jlong limit = INT_MAX;

3387   int err = errno;
3388 
3389   // Remove shmid. If shmat() is successful, the actual shared memory segment
3390   // will be deleted when it's detached by shmdt() or when the process
3391   // terminates. If shmat() is not successful this will remove the shared
3392   // segment immediately.
3393   shmctl(shmid, IPC_RMID, NULL);
3394 
3395   if (retAddr == (char *) -1) {
3396     if (warn_on_failure) {
3397       jio_snprintf(msg, sizeof(msg), "Failed to attach shared memory (errno = %d).", err);
3398       warning(msg);
3399     }
3400     return NULL;
3401   }
3402   if ((retAddr != NULL) && UseNUMAInterleaving) {
3403     numa_make_global(retAddr, size);
3404   }
3405 
3406   // The memory is committed
3407   MemTracker::record_virtual_memory_reserve_and_commit((address)retAddr, size, mtNone, CURRENT_PC);


3408 
3409   return retAddr;
3410 }
3411 
3412 bool os::release_memory_special(char* base, size_t bytes) {
3413   MemTracker::Tracker tkr = MemTracker::get_virtual_memory_release_tracker();
3414   // detaching the SHM segment will also delete it, see reserve_memory_special()
3415   int rslt = shmdt(base);
3416   if (rslt == 0) {
3417     tkr.record((address)base, bytes);

3418     return true;
3419   } else {
3420     tkr.discard();
3421     return false;
3422   }
3423 }
3424 
3425 size_t os::large_page_size() {
3426   return _large_page_size;
3427 }
3428 
3429 // MPSS allows application to commit large page memory on demand; with ISM
3430 // the entire memory region must be allocated as shared memory.
3431 bool os::can_commit_large_page_memory() {
3432   return UseISM ? false : true;
3433 }
3434 
3435 bool os::can_execute_large_page_memory() {
3436   return UseISM ? false : true;
3437 }
3438 
3439 static int os_sleep(jlong millis, bool interruptible) {
3440   const jlong limit = INT_MAX;