[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[PATCH] gnumach: vm: zone_gc: Got rid of useless function
|
From: |
Maksym Planeta |
|
Subject: |
[PATCH] gnumach: vm: zone_gc: Got rid of useless function |
|
Date: |
Mon, 18 Apr 2011 00:13:14 +0300 |
When zone_gc starts collecting free memory, first it form a list
(zone_free_page_list) of free
pages and then by the end of function it frees this list.
Patch makes releasing of free pages on spot. So this list isn't
needed and one for loop becomes less.
There was a risk of deadlocking when kmem_free is called, but
investigating of code and test didn't reveal the deadlock.
Signed-off-by: Maksym Planeta <mcsim.planeta@gmail.com>
---
kern/zalloc.c | 95 +++++++++++++++++++++++----------------------------------
1 files changed, 38 insertions(+), 57 deletions(-)
diff --git a/kern/zalloc.c b/kern/zalloc.c
index a95c7f6..762b60b 100644
--- a/kern/zalloc.c
+++ b/kern/zalloc.c
@@ -579,7 +579,6 @@ void zfree(zone_t zone, vm_offset_t elem)
* zone_page_init - initializes in_free_list and alloc_count
* zone_page_alloc - increments alloc_count
* zone_page_dealloc - decrements alloc_count
- * zone_add_free_page_list - adds the page to the free list
*
* Two counts are maintained for each page, the in_free_list count and
* alloc_count. The alloc_count is how many zone elements have been
@@ -595,8 +594,7 @@ void zfree(zone_t zone, vm_offset_t elem)
* gets and frees of zone elements will call zone_page_in_use and
* zone_page_free which modify the in_free_list count. When the zones
* garbage collector runs it will walk through a zones free element list,
- * remove the elements that reside on collectable pages, and use
- * zone_add_free_page_list to create a list of pages to be collected.
+ * remove the elements that reside on collectable pages.
*/
void zone_page_in_use(addr, size)
@@ -696,30 +694,6 @@ vm_size_t size;
unlock_zone_page_table();
}
-void
-zone_add_free_page_list(free_list, addr, size)
- struct zone_page_table_entry **free_list;
- vm_offset_t addr;
- vm_size_t size;
-{
- int i, j;
- if ((addr < zone_map_min_address) ||
- (addr+size > zone_map_max_address)) return;
- i = atop(addr-zone_map_min_address);
- j = atop((addr+size-1) - zone_map_min_address);
- lock_zone_page_table();
- for (; i <= j; i++) {
- if (zone_page_table[i].alloc_count == 0) {
- zone_page_table[i].next = *free_list;
- *free_list = &zone_page_table[i];
- zone_page_table[i].alloc_count = ZONE_PAGE_UNUSED;
- zone_page_table[i].in_free_list = 0;
- }
- }
- unlock_zone_page_table();
-}
-
-
/* This is used for walking through a zone's free element list.
*/
struct zone_free_entry {
@@ -740,16 +714,12 @@ static void zone_gc(void)
zone_t z;
int i;
register spl_t s;
- struct zone_page_table_entry *freep;
- struct zone_page_table_entry *zone_free_page_list;
simple_lock(&all_zones_lock);
max_zones = num_zones;
z = first_zone;
simple_unlock(&all_zones_lock);
- zone_free_page_list = (struct zone_page_table_entry *) 0;
-
for (i = 0; i < max_zones; i++) {
struct zone_free_entry * last;
struct zone_free_entry * elt;
@@ -786,14 +756,45 @@ static void zone_gc(void)
z->cur_size -= z->elem_size;
zone_page_in_use((vm_offset_t)elt, z->elem_size);
zone_page_dealloc((vm_offset_t)elt, z->elem_size);
- if (zone_page(elt)->alloc_count == 0 ||
- zone_page(elt+(z->elem_size-1))->alloc_count==0) {
- zone_add_free_page_list(
- &zone_free_page_list,
- (vm_offset_t)elt, z->elem_size);
+ if ((zone_page(elt)->alloc_count == 0 ||
+
zone_page(elt+(z->elem_size-1))->alloc_count==0)
+ && ((vm_offset_t)elt <
zone_map_min_address ||
+ (vm_offset_t)elt + z->elem_size
+ > zone_map_max_address)) {
+ vm_offset_t free_addr;
+ int i, j;
+ i =
atop((vm_offset_t)elt-zone_map_min_address);
+ j = atop(((vm_offset_t)elt +
z->elem_size - 1)
+ -
zone_map_min_address);
+ for (; i<= j; i++) {
+ lock_zone_page_table();
+ if
(zone_page_table[i].alloc_count == 0) {
+ free_addr =
zone_map_min_address +
+ PAGE_SIZE *
(&zone_page_table[i] -
+
zone_page_table);
+
zone_page_table[i].alloc_count = ZONE_PAGE_UNUSED;
+
zone_page_table[i].in_free_list = 0;
+
+ /* Hack Hack */
+ /* Needed to make
vm_map_delete's vm_map_clip_end
+ * always be able to
get an element without having
+ * to call zget_space
and hang because zone_map is
+ * already locked by
vm_map_delete */
+
+ /* zone for kernel
entry structures */
+ extern zone_t
vm_map_kentry_zone;
+ vm_offset_t entry1 =
zalloc(vm_map_kentry_zone),
+ entry2 =
zalloc(vm_map_kentry_zone);
+
zfree(vm_map_kentry_zone, entry1);
+
zfree(vm_map_kentry_zone, entry2);
+
/*unlock_zone_page_table();*/
+
+ kmem_free(zone_map,
free_addr, PAGE_SIZE);
+ }
+ unlock_zone_page_table();
+ }
}
-
if (elt == last) {
elt = elt->next;
z->free_elements =(vm_offset_t)elt;
@@ -822,26 +823,6 @@ static void zone_gc(void)
z = z->next_zone;
simple_unlock(&all_zones_lock);
}
-
- for (freep = zone_free_page_list; freep != 0; freep = freep->next) {
- vm_offset_t free_addr;
-
- free_addr = zone_map_min_address +
- PAGE_SIZE * (freep - zone_page_table);
-
- /* Hack Hack */
- /* Needed to make vm_map_delete's vm_map_clip_end always be
- * able to get an element without having to call zget_space and
- * hang because zone_map is already locked by vm_map_delete */
-
- extern zone_t vm_map_kentry_zone; /* zone for
kernel entry structures */
- vm_offset_t entry1 = zalloc(vm_map_kentry_zone),
- entry2 = zalloc(vm_map_kentry_zone);
- zfree(vm_map_kentry_zone, entry1);
- zfree(vm_map_kentry_zone, entry2);
-
- kmem_free(zone_map, free_addr, PAGE_SIZE);
- }
}
boolean_t zone_gc_allowed = TRUE;
--
1.7.2.3
- [PATCH] gnumach: vm: zone_gc: Got rid of useless function,
Maksym Planeta <=