3cd2094396
access to a vm_page. It is basically an atomically accessed thread ID field
in the vm_page structure, which is explicitly set by macros marking the
critical sections. As a first positive effect I had to review quite a bit of
code and found several issues.
* Added several TODOs and comments. Some harmless ones, but also a few
troublesome ones in vm.cpp regarding page unmapping.
* file_cache: PrecacheIO::Prepare()/read_into_cache: Removed superfluous
vm_page_allocate_page() return value checks. It cannot fail anymore.
* Removed the heavily contended "pages" lock. We use different policies now:
- sModifiedTemporaryPages is accessed atomically.
- sPageDeficitLock and sFreePageCondition are protected by a new mutex.
- The page queues have individual locks (mutexes).
- Renamed set_page_state_nolock() to set_page_state(). Unless the caller says
otherwise, it does now lock the affected pages queues itself. Also changed
the return value to void -- we panic() anyway.
* set_page_state(): Add free/clear pages to the beginning of their respective
queues as this is more cache-friendly.
* Pages with the states PAGE_STATE_WIRED or PAGE_STATE_UNUSED are no longer
in any queue. They were in the "active" queue, but there's no good reason
to have them there. In case we decide to let the page daemon work the queues
(like FreeBSD) they would just be in the way.
* Pulled the common part of vm_page_allocate_page_run[_no_base]() into a helper
function. Also fixed a bug I introduced previously: The functions must not
vm_page_unreserve_pages() on success, since they remove the pages from the
free/clear queue without decrementing sUnreservedFreePages.
* vm_page_set_state(): Changed return type to void. The function cannot really
fail and no-one was checking it anyway.
* vm_page_free(), vm_page_set_state(): Added assertion: The page must not be
free/clear before. This is implied by the policy that no-one is allowed to
access free/clear pages without holding the respective queue's lock, which is
not the case at this point. This found the bug fixed in r34912.
* vm_page_requeue(): Added general assertions. panic() when requeuing of
free/clear pages is requested. Same reason as above.
* vm_clone_area(), B_FULL_LOCK case: Don't map busy pages. The implementation is
still not correct, though.
My usual -j8 Haiku build test runs another 10% faster, now. The total kernel
time drops about 18%. As hoped the new locks have only a fraction of the old
"pages" lock contention. Other locks lead the "most wanted list" now.
git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@34933 a95241bf-73f2-0310-859d-f6bbb57e9c96
64 lines
2.0 KiB
C
64 lines
2.0 KiB
C
/*
|
|
* Copyright 2002-2009, Axel Dörfler, axeld@pinc-software.de.
|
|
* Distributed under the terms of the MIT License.
|
|
*
|
|
* Copyright 2001-2002, Travis Geiselbrecht. All rights reserved.
|
|
* Distributed under the terms of the NewOS License.
|
|
*/
|
|
#ifndef _KERNEL_VM_VM_PAGE_H
|
|
#define _KERNEL_VM_VM_PAGE_H
|
|
|
|
|
|
#include <vm/vm.h>
|
|
|
|
|
|
struct kernel_args;
|
|
|
|
extern int32 gMappedPagesCount;
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
void vm_page_init_num_pages(struct kernel_args *args);
|
|
status_t vm_page_init(struct kernel_args *args);
|
|
status_t vm_page_init_post_area(struct kernel_args *args);
|
|
status_t vm_page_init_post_thread(struct kernel_args *args);
|
|
|
|
status_t vm_mark_page_inuse(addr_t page);
|
|
status_t vm_mark_page_range_inuse(addr_t startPage, addr_t length);
|
|
void vm_page_free(struct VMCache *cache, struct vm_page *page);
|
|
void vm_page_set_state(struct vm_page *page, int state);
|
|
void vm_page_requeue(struct vm_page *page, bool tail);
|
|
|
|
// get some data about the number of pages in the system
|
|
size_t vm_page_num_pages(void);
|
|
size_t vm_page_num_free_pages(void);
|
|
size_t vm_page_num_available_pages(void);
|
|
size_t vm_page_num_unused_pages(void);
|
|
void vm_page_get_stats(system_info *info);
|
|
|
|
status_t vm_page_write_modified_page_range(struct VMCache *cache,
|
|
uint32 firstPage, uint32 endPage);
|
|
status_t vm_page_write_modified_pages(struct VMCache *cache);
|
|
void vm_page_schedule_write_page(struct vm_page *page);
|
|
void vm_page_schedule_write_page_range(struct VMCache *cache,
|
|
uint32 firstPage, uint32 endPage);
|
|
|
|
void vm_page_unreserve_pages(uint32 count);
|
|
void vm_page_reserve_pages(uint32 count);
|
|
bool vm_page_try_reserve_pages(uint32 count);
|
|
|
|
struct vm_page *vm_page_allocate_page(int pageState);
|
|
struct vm_page *vm_page_allocate_page_run(int state, addr_t base,
|
|
addr_t length);
|
|
struct vm_page *vm_page_allocate_page_run_no_base(int state, addr_t count);
|
|
struct vm_page *vm_page_at_index(int32 index);
|
|
struct vm_page *vm_lookup_page(addr_t pageNumber);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* _KERNEL_VM_VM_PAGE_H */
|