Changeset 26375

Timestamp:

07/10/08 15:50:34 (4 months ago)

Author:

bonefish

Message:

* Replaced the low_resource() "bool wait" parameter by a flags +

timeout pair. Timeouts are a good idea given that it's not really
clear how long the low resource handlers might take.

* Added timeout parameter to vm_try_reserve_memory(). That's how long

the function loops and keeps nagging the low resource manager.

* Also track the amount of memory needed by threads waiting in

vm_try_resource_memory(). vm_available_not_needed_memory() returns the
difference of available and needed memory.

* The VMAnonymous*Cache implementations use a 1s timeout for reserving

memory in Commit() now. Over-committing areas still require immediate
reservations, though.

This might already remedy the main problem of #2046. 1s could be a
little too short for freeing the 270 MB jam needs, though.

Location:

haiku/branches/developer/bonefish/vm

Files:

• headers/private/kernel/low_resource_manager.h (modified) (1 diff)
• headers/private/kernel/vm.h (modified) (1 diff)
• headers/private/kernel/vm_priv.h (modified) (1 diff)
• src/system/kernel/low_resource_manager.cpp (modified) (4 diffs)
• src/system/kernel/vm/VMAnonymousCache.cpp (modified) (2 diffs)
• src/system/kernel/vm/VMAnonymousNoSwapCache.cpp (modified) (2 diffs)
• src/system/kernel/vm/vm.cpp (modified) (5 diffs)
• src/system/kernel/vm/vm_page.cpp (modified) (1 diff)

haiku/branches/developer/bonefish/vm/headers/private/kernel/low_resource_manager.h

@@ -38 +38 @@
 status_t low_resource_manager_init_post_thread(void);
 int32 low_resource_state(uint32 resources);
-void low_resource(uint32 resource, uint64 requirements, bool wait);
+void low_resource(uint32 resource, uint64 requirements, uint32 flags,
+        uint32 timeout);
 
 // these calls might get public some day

haiku/branches/developer/bonefish/vm/headers/private/kernel/vm.h

@@ -89 +89 @@
 
 off_t vm_available_memory(void);
+off_t vm_available_not_needed_memory(void);
 
 // user syscalls

haiku/branches/developer/bonefish/vm/headers/private/kernel/vm_priv.h

@@ -49 +49 @@
         bool isUser, addr_t *newip);
 void vm_unreserve_memory(size_t bytes);
-status_t vm_try_reserve_memory(size_t bytes);
+status_t vm_try_reserve_memory(size_t bytes, bigtime_t timeout);
 void vm_schedule_page_scanner(uint32 target);
 status_t vm_daemon_init(void);

haiku/branches/developer/bonefish/vm/src/system/kernel/low_resource_manager.cpp

@@ -147 +147 @@
 
         // free memory state
-        off_t freeMemory = vm_available_memory();
+        off_t freeMemory = vm_available_not_needed_memory();
 
         if (freeMemory < sCriticalMemoryLimit) {
@@ -195 +195 @@
                 TRACE(("low_resource_manager: state = %ld, %ld free pages, %lld free "
                         "memory, %lu free semaphores\n", state, vm_page_num_free_pages(),
-                        vm_available_memory(), sem_max_sems() - sem_used_sems()));
+                        vm_available_not_needed_memory(),
+                        sem_max_sems() - sem_used_sems()));
 
                 if (state < B_LOW_RESOURCE_NOTE)
@@ -243 +244 @@
 
 
-/*!     Notifies the low resource manager that a resource is lacking. If \a wait
-        is \c true, the function will wait until the low resource manager has
-        finished its next iteration of calling low resource handlers.
+/*!     Notifies the low resource manager that a resource is lacking. If \a flags
+        and \a timeout specify a timeout, the function will wait until the low
+        resource manager has finished its next iteration of calling low resource
+        handlers, or until the timeout occurs (whichever happens first).
 */
 void
-low_resource(uint32 resource, uint64 requirements, bool wait)
+low_resource(uint32 resource, uint64 requirements, uint32 flags, uint32 timeout)
 {
         // TODO: take requirements into account
@@ -264 +266 @@
         release_sem(sLowResourceWaitSem);
 
-        if (wait)
-                sLowResourceWaiterCondition.Wait();
+        if ((flags & B_RELATIVE_TIMEOUT) == 0 || timeout > 0)
+                sLowResourceWaiterCondition.Wait(flags, timeout);
 }
 

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/VMAnonymousCache.cpp

@@ -142 +142 @@
         if (size > committed_size) {
                 // try to commit
-                if (vm_try_reserve_memory(size - committed_size) != B_OK)
+                if (vm_try_reserve_memory(size - committed_size, 1000000) != B_OK)
                         return B_NO_MEMORY;
         } else {
@@ -268 +268 @@
                 if (fPrecommittedPages == 0) {
                         // try to commit additional memory
-                        if (vm_try_reserve_memory(B_PAGE_SIZE) != B_OK)
+                        if (vm_try_reserve_memory(B_PAGE_SIZE, 0) != B_OK)
                                 return B_NO_MEMORY;
 

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/VMAnonymousNoSwapCache.cpp

@@ -76 +76 @@
         if (size > committed_size) {
                 // try to commit
-                if (vm_try_reserve_memory(size - committed_size) != B_OK)
+                if (vm_try_reserve_memory(size - committed_size, 1000000) != B_OK)
                         return B_NO_MEMORY;
         } else {
@@ -137 +137 @@
                 if (fPrecommittedPages == 0) {
                         // try to commit additional memory
-                        if (vm_try_reserve_memory(B_PAGE_SIZE) != B_OK)
+                        if (vm_try_reserve_memory(B_PAGE_SIZE, 0) != B_OK)
                                 return B_NO_MEMORY;
 

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm.cpp

@@ -21 +21 @@
 #include <AutoDeleter.h>
 
+#include <arch/cpu.h>
+#include <arch/vm.h>
+#include <boot/elf.h>
+#include <boot/stage2.h>
+#include <condition_variable.h>
+#include <console.h>
+#include <debug.h>
+#include <file_cache.h>
 #include <fs/fd.h>
-#include <vm_address_space.h>
-#include <vm_priv.h>
-#include <vm_page.h>
-#include <vm_cache.h>
-#include <file_cache.h>
 #include <heap.h>
-#include <condition_variable.h>
-#include <debug.h>
-#include <console.h>
 #include <int.h>
+#include <lock.h>
+#include <low_resource_manager.h>
 #include <smp.h>
-#include <lock.h>
 #include <thread.h>
 #include <team.h>
 #include <util/AutoLock.h>
 #include <util/khash.h>
-
-#include <boot/stage2.h>
-#include <boot/elf.h>
-
-#include <arch/cpu.h>
-#include <arch/vm.h>
+#include <vm_address_space.h>
+#include <vm_cache.h>
+#include <vm_page.h>
+#include <vm_priv.h>
 
 
@@ -194 +193 @@
 
 static off_t sAvailableMemory;
+static off_t sNeededMemory;
 static mutex sAvailableMemoryLock = MUTEX_INITIALIZER("available memory lock");
 
@@ -4614 +4614 @@
 vm_available_memory(void)
 {
+        MutexLocker locker(sAvailableMemoryLock);
         return sAvailableMemory;
+}
+
+
+off_t
+vm_available_not_needed_memory(void)
+{
+        MutexLocker locker(sAvailableMemoryLock);
+        return sAvailableMemory - sNeededMemory;
 }
 
@@ -4637 +4646 @@
 
 status_t
-vm_try_reserve_memory(size_t amount)
-{
-        status_t status;
-        mutex_lock(&sAvailableMemoryLock);
+vm_try_reserve_memory(size_t amount, bigtime_t timeout)
+{
+        MutexLocker locker(sAvailableMemoryLock);
 
         //dprintf("try to reserve %lu bytes, %Lu left\n", amount, sAvailableMemory);
@@ -4646 +4654 @@
         if (sAvailableMemory >= amount) {
                 sAvailableMemory -= amount;
-                status = B_OK;
-        } else
-                status = B_NO_MEMORY;
-
-        mutex_unlock(&sAvailableMemoryLock);
-        return status;
+                return B_OK;
+        }
+
+        if (timeout <= 0)
+                return B_NO_MEMORY;
+
+        // turn timeout into an absolute timeout
+        timeout += system_time();
+
+        // loop until we've got the memory or the timeout occurs
+        do {
+                sNeededMemory += amount;
+
+                // call the low resource manager
+                locker.Unlock();
+                low_resource(B_KERNEL_RESOURCE_MEMORY, sNeededMemory - sAvailableMemory,
+                        B_ABSOLUTE_TIMEOUT, timeout);
+                locker.Lock();
+
+                sNeededMemory -= amount;
+
+                if (sAvailableMemory >= amount) {
+                        sAvailableMemory -= amount;
+                        return B_OK;
+                }
+        } while (timeout > system_time());
+
+        return B_NO_MEMORY;
 }
 

haiku/branches/developer/bonefish/vm/src/system/kernel/vm/vm_page.cpp

@@ -1253 +1253 @@
                 locker.Unlock();
 
-                low_resource(B_KERNEL_RESOURCE_PAGES, count, false);
+                low_resource(B_KERNEL_RESOURCE_PAGES, count, B_RELATIVE_TIMEOUT, 0);
                 //snooze(50000);
                         // sleep for 50ms