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) {
|