1611 } 1612 return result; 1613 } 1614 1615 void os::initialize_initial_active_processor_count() { 1616 assert(_initial_active_processor_count == 0, "Initial active processor count already set."); 1617 _initial_active_processor_count = active_processor_count(); 1618 log_debug(os)("Initial active processor count set to %d" , _initial_active_processor_count); 1619 } 1620 1621 void os::SuspendedThreadTask::run() { 1622 assert(Threads_lock->owned_by_self() || (_thread == VMThread::vm_thread()), "must have threads lock to call this"); 1623 internal_do_task(); 1624 _done = true; 1625 } 1626 1627 bool os::create_stack_guard_pages(char* addr, size_t bytes) { 1628 return os::pd_create_stack_guard_pages(addr, bytes); 1629 } 1630 1631 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) { 1632 char* result = pd_reserve_memory(bytes, addr, alignment_hint); 1633 if (result != NULL) { 1634 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); 1635 } 1636 1637 return result; 1638 } 1639 1640 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint, 1641 MEMFLAGS flags) { 1642 char* result = pd_reserve_memory(bytes, addr, alignment_hint); 1643 if (result != NULL) { 1644 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); 1645 MemTracker::record_virtual_memory_type((address)result, flags); 1646 } 1647 1648 return result; 1649 } 1650 1651 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) { 1652 char* result = pd_attempt_reserve_memory_at(bytes, addr); 1653 if (result != NULL) { 1654 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); 1655 } 1656 return result; 1657 } 1658 1659 void os::split_reserved_memory(char *base, size_t size, 1660 size_t split, bool realloc) { 1661 pd_split_reserved_memory(base, size, split, realloc); 1662 } 1663 1664 bool os::commit_memory(char* addr, size_t bytes, bool executable) { 1665 bool res = pd_commit_memory(addr, bytes, executable); 1666 if (res) { 1667 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC); 1668 } 1669 return res; 1670 } 1671 1672 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, 1673 bool executable) { 1674 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable); 1675 if (res) { | 1611 } 1612 return result; 1613 } 1614 1615 void os::initialize_initial_active_processor_count() { 1616 assert(_initial_active_processor_count == 0, "Initial active processor count already set."); 1617 _initial_active_processor_count = active_processor_count(); 1618 log_debug(os)("Initial active processor count set to %d" , _initial_active_processor_count); 1619 } 1620 1621 void os::SuspendedThreadTask::run() { 1622 assert(Threads_lock->owned_by_self() || (_thread == VMThread::vm_thread()), "must have threads lock to call this"); 1623 internal_do_task(); 1624 _done = true; 1625 } 1626 1627 bool os::create_stack_guard_pages(char* addr, size_t bytes) { 1628 return os::pd_create_stack_guard_pages(addr, bytes); 1629 } 1630 1631 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint, int file_desc) { 1632 1633 char* result = NULL; 1634 1635 if (file_desc != -1) { 1636 // Do your own memory mapping instead of doing 1637 // pd_reserve_memory() followed by replace_existing_mapping_with_dax_file_mapping(), because AIX might use SHM 1638 result = os::map_memory_to_dax_file(addr, bytes, file_desc); 1639 if (result != NULL) { 1640 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, CALLER_PC); 1641 } 1642 } 1643 else { 1644 result = pd_reserve_memory(bytes, addr, alignment_hint); 1645 if (result != NULL) { 1646 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); 1647 } 1648 } 1649 1650 return result; 1651 } 1652 1653 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint, 1654 MEMFLAGS flags) { 1655 char* result = pd_reserve_memory(bytes, addr, alignment_hint); 1656 if (result != NULL) { 1657 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC); 1658 MemTracker::record_virtual_memory_type((address)result, flags); 1659 } 1660 1661 return result; 1662 } 1663 1664 void os::split_reserved_memory(char *base, size_t size, 1665 size_t split, bool realloc) { 1666 pd_split_reserved_memory(base, size, split, realloc); 1667 } 1668 1669 bool os::commit_memory(char* addr, size_t bytes, bool executable) { 1670 bool res = pd_commit_memory(addr, bytes, executable); 1671 if (res) { 1672 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC); 1673 } 1674 return res; 1675 } 1676 1677 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint, 1678 bool executable) { 1679 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable); 1680 if (res) { |