1657 }
1658 return result;
1659 }
1660
1661 void os::initialize_initial_active_processor_count() {
1662 assert(_initial_active_processor_count == 0, "Initial active processor count already set.");
1663 _initial_active_processor_count = active_processor_count();
1664 log_debug(os)("Initial active processor count set to %d" , _initial_active_processor_count);
1665 }
1666
1667 void os::SuspendedThreadTask::run() {
1668 assert(Threads_lock->owned_by_self() || (_thread == VMThread::vm_thread()), "must have threads lock to call this");
1669 internal_do_task();
1670 _done = true;
1671 }
1672
1673 bool os::create_stack_guard_pages(char* addr, size_t bytes) {
1674 return os::pd_create_stack_guard_pages(addr, bytes);
1675 }
1676
1677 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint) {
1678 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1679 if (result != NULL) {
1680 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1681 }
1682
1683 return result;
1684 }
1685
1686 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint,
1687 MEMFLAGS flags) {
1688 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1689 if (result != NULL) {
1690 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1691 MemTracker::record_virtual_memory_type((address)result, flags);
1692 }
1693
1694 return result;
1695 }
1696
1697 char* os::attempt_reserve_memory_at(size_t bytes, char* addr) {
1698 char* result = pd_attempt_reserve_memory_at(bytes, addr);
1699 if (result != NULL) {
1700 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1701 }
1702 return result;
1703 }
1704
1705 void os::split_reserved_memory(char *base, size_t size,
1706 size_t split, bool realloc) {
1707 pd_split_reserved_memory(base, size, split, realloc);
1708 }
1709
1710 bool os::commit_memory(char* addr, size_t bytes, bool executable) {
1711 bool res = pd_commit_memory(addr, bytes, executable);
1712 if (res) {
1713 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC);
1714 }
1715 return res;
1716 }
1717
1718 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
1719 bool executable) {
1720 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable);
|
1657 }
1658 return result;
1659 }
1660
1661 void os::initialize_initial_active_processor_count() {
1662 assert(_initial_active_processor_count == 0, "Initial active processor count already set.");
1663 _initial_active_processor_count = active_processor_count();
1664 log_debug(os)("Initial active processor count set to %d" , _initial_active_processor_count);
1665 }
1666
1667 void os::SuspendedThreadTask::run() {
1668 assert(Threads_lock->owned_by_self() || (_thread == VMThread::vm_thread()), "must have threads lock to call this");
1669 internal_do_task();
1670 _done = true;
1671 }
1672
1673 bool os::create_stack_guard_pages(char* addr, size_t bytes) {
1674 return os::pd_create_stack_guard_pages(addr, bytes);
1675 }
1676
1677 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint, int file_desc) {
1678 char* result = NULL;
1679
1680 if (file_desc != -1) {
1681 // Could have called pd_reserve_memory() followed by replace_existing_mapping_with_file_mapping(),
1682 // but AIX may use SHM in which case its more trouble to detach the segment and remap memory to the file.
1683 result = os::map_memory_to_file(addr, bytes, file_desc);
1684 if (result != NULL) {
1685 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, CALLER_PC);
1686 }
1687 } else {
1688 result = pd_reserve_memory(bytes, addr, alignment_hint);
1689 if (result != NULL) {
1690 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1691 }
1692 }
1693
1694 return result;
1695 }
1696
1697 char* os::reserve_memory(size_t bytes, char* addr, size_t alignment_hint,
1698 MEMFLAGS flags) {
1699 char* result = pd_reserve_memory(bytes, addr, alignment_hint);
1700 if (result != NULL) {
1701 MemTracker::record_virtual_memory_reserve((address)result, bytes, CALLER_PC);
1702 MemTracker::record_virtual_memory_type((address)result, flags);
1703 }
1704
1705 return result;
1706 }
1707
1708 char* os::attempt_reserve_memory_at(size_t bytes, char* addr, int file_desc) {
1709 char* result = NULL;
1710 if (file_desc != -1) {
1711 result = pd_attempt_reserve_memory_at(bytes, addr, file_desc);
1712 if (result != NULL) {
1713 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, CALLER_PC);
1714 }
1715 } else {
1716 result = pd_attempt_reserve_memory_at(bytes, addr);
1717 if (result != NULL) {
1718 MemTracker::record_virtual_memory_reserve_and_commit((address)result, bytes, CALLER_PC);
1719 }
1720 }
1721 return result;
1722 }
1723
1724 void os::split_reserved_memory(char *base, size_t size,
1725 size_t split, bool realloc) {
1726 pd_split_reserved_memory(base, size, split, realloc);
1727 }
1728
1729 bool os::commit_memory(char* addr, size_t bytes, bool executable) {
1730 bool res = pd_commit_memory(addr, bytes, executable);
1731 if (res) {
1732 MemTracker::record_virtual_memory_commit((address)addr, bytes, CALLER_PC);
1733 }
1734 return res;
1735 }
1736
1737 bool os::commit_memory(char* addr, size_t size, size_t alignment_hint,
1738 bool executable) {
1739 bool res = os::pd_commit_memory(addr, size, alignment_hint, executable);
|