Skip to contentSkip to conversation

hugetlb strict commit accounting

PATCH In review Chen, Kenneth W 2 participants 8 messages Mar 9, 2006

Subsystems (2)
lore
Share & tools
lore
#0 lore raw

PATCH 1/1 hugetlb strict commit accounting

Here is a competing implementation of hugetlb strict commit accounting. A back port of what was done about two years ago by Andy Whitcroft, Ray Bryant, and myself.

Essentially for the same purpose of this patch currently sit in -mm:

http://kernel.org/pub/linux/kernel/people/akpm/patches/2.6/2.6.16-rc5/2.6.16-rc5-mm3/broken-out/hugepage-strict-page-reservation-for
-hugepage-inodes.patch

Except it is BETTER and more robust :-) because:

(1) it does arbitrary variable length and arbitrary variable offset
(2) doesn't need to perform linear traverse of page cache

It is more flexible that it will handle any arbitrary mmap offset versus the one in -mm that always reserve entire hugetlb file size. I've heard numerous complains from application developers that hugetlb is difficult to use in current state of affair. Having another peculiar behavior like "reservation would only work if mmap offset is zero" adds another horrendous factor.

Posted here for -mm consideration.

 fs/hugetlbfs/inode.c    |  188 ++++++++++++++++++++++++++++++++++++++----------
 include/linux/hugetlb.h |    1 
 mm/hugetlb.c            |    3 
 3 files changed, 156 insertions(+), 36 deletions(-)
fs/hugetlbfs/inode.c renamed from fs/hugetlbfs/inode.c.orig +152 -36
@@ -56,48 +56,160 @@ static void huge_pagevec_release(struct 
 	pagevec_reinit(pvec);
 }
 
-/*
- * huge_pages_needed tries to determine the number of new huge pages that
- * will be required to fully populate this VMA.  This will be equal to
- * the size of the VMA in huge pages minus the number of huge pages
- * (covered by this VMA) that are found in the page cache.
- *
- * Result is in bytes to be compatible with is_hugepage_mem_enough()
- */
-static unsigned long
-huge_pages_needed(struct address_space *mapping, struct vm_area_struct *vma)
+struct file_region {
+	struct list_head link;
+	int from;
+	int to;
+};
+
+static int region_add(struct list_head *head, int f, int t)
 {
-	int i;
-	struct pagevec pvec;
-	unsigned long start = vma->vm_start;
-	unsigned long end = vma->vm_end;
-	unsigned long hugepages = (end - start) >> HPAGE_SHIFT;
-	pgoff_t next = vma->vm_pgoff >> (HPAGE_SHIFT - PAGE_SHIFT);
-	pgoff_t endpg = next + hugepages;
+	struct file_region *rg;
+	struct file_region *nrg;
+	struct file_region *trg;
+
+	/* Locate the region we are either in or before. */
+	list_for_each_entry(rg, head, link)
+		if (f <= rg->to)
+			break;
 
-	pagevec_init(&pvec, 0);
-	while (next < endpg) {
-		if (!pagevec_lookup(&pvec, mapping, next, PAGEVEC_SIZE))
+	/* Round our left edge to the current segment if it encloses us. */
+	if (f > rg->from)
+		f = rg->from;
+
+	/* Check for and consume any regions we now overlap with. */
+	nrg = rg;
+	list_for_each_entry_safe(rg, trg, rg->link.prev, link) {
+		if (&rg->link == head)
 			break;
-		for (i = 0; i < pagevec_count(&pvec); i++) {
-			struct page *page = pvec.pages[i];
-			if (page->index > next)
-				next = page->index;
-			if (page->index >= endpg)
-				break;
-			next++;
-			hugepages--;
+		if (rg->from > t)
+			break;
+
+		/* If this area reaches higher then extend our area to
+		 * include it completely.  If this is not the first area
+		 * which we intend to reuse, free it. */
+		if (rg->to > t)
+			t = rg->to;
+		if (rg != nrg) {
+			list_del(&rg->link);
+			kfree(rg);
 		}
-		huge_pagevec_release(&pvec);
 	}
-	return hugepages << HPAGE_SHIFT;
+	nrg->from = f;
+	nrg->to = t;
+	return 0;
+}
+
+static int region_chg(struct list_head *head, int f, int t)
+{
+	struct file_region *rg;
+	struct file_region *nrg;
+	loff_t chg = 0;
+
+	/* Locate the region we are before or in. */
+	list_for_each_entry(rg, head, link)
+		if (f <= rg->to)
+			break;
+
+	/* If we are below the current region then a new region is required.
+	 * Subtle, allocate a new region at the position but make it zero
+	 * size such that we can guarentee to record the reservation. */
+	if (&rg->link == head || t < rg->from) {
+		nrg = kmalloc(sizeof(*nrg), GFP_KERNEL);
+		if (nrg == 0)
+			return -ENOMEM;
+		nrg->from = f;
+		nrg->to   = f;
+		INIT_LIST_HEAD(&nrg->link);
+		list_add(&nrg->link, rg->link.prev);
+
+		return t - f;
+	}
+
+	/* Round our left edge to the current segment if it encloses us. */
+	if (f > rg->from)
+		f = rg->from;
+	chg = t - f;
+
+	/* Check for and consume any regions we now overlap with. */
+	list_for_each_entry(rg, rg->link.prev, link) {
+		if (&rg->link == head)
+			break;
+		if (rg->from > t)
+			return chg;
+
+		/* We overlap with this area, if it extends futher than
+		 * us then we must extend ourselves.  Account for its
+		 * existing reservation. */
+		if (rg->to > t) {
+			chg += rg->to - t;
+			t = rg->to;
+		}
+		chg -= rg->to - rg->from;
+	}
+	return chg;
+}
+
+static int region_truncate(struct list_head *head, int end)
+{
+	struct file_region *rg;
+	struct file_region *trg;
+	int chg = 0;
+
+	/* Locate the region we are either in or before. */
+	list_for_each_entry(rg, head, link)
+		if (end <= rg->to)
+			break;
+	if (&rg->link == head)
+		return 0;
+
+	/* If we are in the middle of a region then adjust it. */
+	if (end > rg->from) {
+		chg = rg->to - end;
+		rg->to = end;
+		rg = list_entry(rg->link.next, typeof(*rg), link);
+	}
+
+	/* Drop any remaining regions. */
+	list_for_each_entry_safe(rg, trg, rg->link.prev, link) {
+		if (&rg->link == head)
+			break;
+		chg += rg->to - rg->from;
+		list_del(&rg->link);
+		kfree(rg);
+	}
+	return chg;
+}
+
+#define VMACCTPG(x) ((x) >> (HPAGE_SHIFT - PAGE_SHIFT))
+int hugetlb_acct_memory(long delta)
+{
+	atomic_add(delta, &resv_huge_pages);
+	if (delta > 0 && atomic_read(&resv_huge_pages) >
+			VMACCTPG(hugetlb_total_pages())) {
+		atomic_add(-delta, &resv_huge_pages);
+		return -ENOMEM;
+	}
+	return 0;
+}
+
+static int hugetlb_reserve_pages(struct inode *inode, int from, int to)
+{
+	int ret, chg;
+
+	chg = region_chg(&inode->i_mapping->private_list, from, to);
+	if (chg < 0)
+		return chg;
+	ret = hugetlb_acct_memory(chg);
+	if (ret < 0)
+		return ret;
+	region_add(&inode->i_mapping->private_list, from, to);
+	return 0;
 }
 
 static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct inode *inode = file->f_dentry->d_inode;
-	struct address_space *mapping = inode->i_mapping;
-	unsigned long bytes;
 	loff_t len, vma_len;
 	int ret;
 
@@ -113,10 +225,6 @@ static int hugetlbfs_file_mmap(struct fi
 	if (vma->vm_end - vma->vm_start < HPAGE_SIZE)
 		return -EINVAL;
 
-	bytes = huge_pages_needed(mapping, vma);
-	if (!is_hugepage_mem_enough(bytes))
-		return -ENOMEM;
-
 	vma_len = (loff_t)(vma->vm_end - vma->vm_start);
 
 	mutex_lock(&inode->i_mutex);
@@ -129,6 +237,11 @@ static int hugetlbfs_file_mmap(struct fi
 	if (!(vma->vm_flags & VM_WRITE) && len > inode->i_size)
 		goto out;
 
+	if (vma->vm_flags & VM_MAYSHARE)
+		if (hugetlb_reserve_pages(inode, VMACCTPG(vma->vm_pgoff),
+			VMACCTPG(vma->vm_pgoff + (vma_len >> PAGE_SHIFT))))
+			goto out;
+
 	ret = 0;
 	hugetlb_prefault_arch_hook(vma->vm_mm);
 	if (inode->i_size < len)
@@ -258,6 +371,8 @@ static void truncate_hugepages(struct ad
 		huge_pagevec_release(&pvec);
 	}
 	BUG_ON(!lstart && mapping->nrpages);
+	i = region_truncate(&mapping->private_list, start);
+	hugetlb_acct_memory(-i);
 }
 
 static void hugetlbfs_delete_inode(struct inode *inode)
@@ -401,6 +516,7 @@ static struct inode *hugetlbfs_get_inode
 		inode->i_mapping->a_ops = &hugetlbfs_aops;
 		inode->i_mapping->backing_dev_info =&hugetlbfs_backing_dev_info;
 		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+		INIT_LIST_HEAD(&inode->i_mapping->private_list);
 		info = HUGETLBFS_I(inode);
 		mpol_shared_policy_init(&info->policy, MPOL_DEFAULT, NULL);
 		switch (mode & S_IFMT) {
include/linux/hugetlb.h renamed from include/linux/hugetlb.h.orig +1 -0
@@ -30,6 +30,7 @@ int hugetlb_fault(struct mm_struct *mm, 
 extern unsigned long max_huge_pages;
 extern const unsigned long hugetlb_zero, hugetlb_infinity;
 extern int sysctl_hugetlb_shm_group;
+extern atomic_t resv_huge_pages;
 
 /* arch callbacks */
 
mm/hugetlb.c renamed from mm/hugetlb.c.orig +3 -0
@@ -21,6 +21,7 @@
 
 const unsigned long hugetlb_zero = 0, hugetlb_infinity = ~0UL;
 static unsigned long nr_huge_pages, free_huge_pages;
+atomic_t resv_huge_pages;
 unsigned long max_huge_pages;
 static struct list_head hugepage_freelists[MAX_NUMNODES];
 static unsigned int nr_huge_pages_node[MAX_NUMNODES];
@@ -225,9 +226,11 @@ int hugetlb_report_meminfo(char *buf)
 	return sprintf(buf,
 			"HugePages_Total: %5lu\n"
 			"HugePages_Free:  %5lu\n"
+			"HugePages_Resv:  %5u\n"
 			"Hugepagesize:    %5lu kB\n",
 			nr_huge_pages,
 			free_huge_pages,
+			atomic_read(&resv_huge_pages),
 			HPAGE_SIZE/1024);
 }
 

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>

#1 lore raw
Quoted 14 lines · Kenneth W

Here is a competing implementation of hugetlb strict commit accounting. A back port of what was done about two years ago by Andy Whitcroft, Ray Bryant, and myself.

Essentially for the same purpose of this patch currently sit in -mm:

http://kernel.org/pub/linux/kernel/people/akpm/patches/2.6/2.6.16-rc5/2.6.16-rc5-mm3/broken-out/hugepage-strict-page-reservation-for
-hugepage-inodes.patch

Except it is BETTER and more robust :-) because:

(1) it does arbitrary variable length and arbitrary variable offset
(2) doesn't need to perform linear traverse of page cache

Quoted 6 lines

It is more flexible that it will handle any arbitrary mmap offset versus the one in -mm that always reserve entire hugetlb file size. I've heard numerous complains from application developers that hugetlb is difficult to use in current state of affair. Having another peculiar behavior like "reservation would only work if mmap offset is zero" adds another horrendous factor.

Um... as far as I can tell, this patch doesn't actually reserve anything. There are no changes to the fault handler ot alloc_huge_page(), so there's nothing to stop PRIVATE mappings dipping into the supposedly reserved pool.

More comments below.

Quoted 107 lines
 fs/hugetlbfs/inode.c    |  188 ++++++++++++++++++++++++++++++++++++++----------
 include/linux/hugetlb.h |    1 
 mm/hugetlb.c            |    3 
 3 files changed, 156 insertions(+), 36 deletions(-)
fs/hugetlbfs/inode.c renamed from fs/hugetlbfs/inode.c.orig +61 -30
@@ -56,48 +56,160 @@ static void huge_pagevec_release(struct 
 	pagevec_reinit(pvec);
 }
 
-/*
- * huge_pages_needed tries to determine the number of new huge pages that
- * will be required to fully populate this VMA.  This will be equal to
- * the size of the VMA in huge pages minus the number of huge pages
- * (covered by this VMA) that are found in the page cache.
- *
- * Result is in bytes to be compatible with is_hugepage_mem_enough()
- */
-static unsigned long
-huge_pages_needed(struct address_space *mapping, struct vm_area_struct *vma)
+struct file_region {
+	struct list_head link;
+	int from;
+	int to;
+};
+
+static int region_add(struct list_head *head, int f, int t)
 {
-	int i;
-	struct pagevec pvec;
-	unsigned long start = vma->vm_start;
-	unsigned long end = vma->vm_end;
-	unsigned long hugepages = (end - start) >> HPAGE_SHIFT;
-	pgoff_t next = vma->vm_pgoff >> (HPAGE_SHIFT - PAGE_SHIFT);
-	pgoff_t endpg = next + hugepages;
+	struct file_region *rg;
+	struct file_region *nrg;
+	struct file_region *trg;
+
+	/* Locate the region we are either in or before. */
+	list_for_each_entry(rg, head, link)
+		if (f <= rg->to)
+			break;
 
-	pagevec_init(&pvec, 0);
-	while (next < endpg) {
-		if (!pagevec_lookup(&pvec, mapping, next, PAGEVEC_SIZE))
+	/* Round our left edge to the current segment if it encloses us. */
+	if (f > rg->from)
+		f = rg->from;
+
+	/* Check for and consume any regions we now overlap with. */
+	nrg = rg;
+	list_for_each_entry_safe(rg, trg, rg->link.prev, link) {
+		if (&rg->link == head)
 			break;
-		for (i = 0; i < pagevec_count(&pvec); i++) {
-			struct page *page = pvec.pages[i];
-			if (page->index > next)
-				next = page->index;
-			if (page->index >= endpg)
-				break;
-			next++;
-			hugepages--;
+		if (rg->from > t)
+			break;
+
+		/* If this area reaches higher then extend our area to
+		 * include it completely.  If this is not the first area
+		 * which we intend to reuse, free it. */
+		if (rg->to > t)
+			t = rg->to;
+		if (rg != nrg) {
+			list_del(&rg->link);
+			kfree(rg);
 		}
-		huge_pagevec_release(&pvec);
 	}
-	return hugepages << HPAGE_SHIFT;
+	nrg->from = f;
+	nrg->to = t;
+	return 0;
+}
+
+static int region_chg(struct list_head *head, int f, int t)
+{
+	struct file_region *rg;
+	struct file_region *nrg;
+	loff_t chg = 0;
+
+	/* Locate the region we are before or in. */
+	list_for_each_entry(rg, head, link)
+		if (f <= rg->to)
+			break;
+
+	/* If we are below the current region then a new region is required.
+	 * Subtle, allocate a new region at the position but make it zero
+	 * size such that we can guarentee to record the reservation. */
+	if (&rg->link == head || t < rg->from) {
+		nrg = kmalloc(sizeof(*nrg), GFP_KERNEL);
+		if (nrg == 0)
+			return -ENOMEM;
+		nrg->from = f;
+		nrg->to   = f;
+		INIT_LIST_HEAD(&nrg->link);
+		list_add(&nrg->link, rg->link.prev);

fs/hugetlbfs/inode.c static void huge_pagevec_release(struct · line 134

Quoted 10 lines
fs/hugetlbfs/inode.c renamed from fs/hugetlbfs/inode.c.orig +10 -0
+
+		return t - f;
+	}
+
+	/* Round our left edge to the current segment if it encloses us. */
+	if (f > rg->from)
+		f = rg->from;
+	chg = t - f;
+
+	/* Check for and consume any regions we now overlap with. */

Looks like we have this test code duplicated from region_add(). Any way to avoid that?

Quoted 50 lines
fs/hugetlbfs/inode.c renamed from fs/hugetlbfs/inode.c.orig +50 -0
+	list_for_each_entry(rg, rg->link.prev, link) {
+		if (&rg->link == head)
+			break;
+		if (rg->from > t)
+			return chg;
+
+		/* We overlap with this area, if it extends futher than
+		 * us then we must extend ourselves.  Account for its
+		 * existing reservation. */
+		if (rg->to > t) {
+			chg += rg->to - t;
+			t = rg->to;
+		}
+		chg -= rg->to - rg->from;
+	}
+	return chg;
+}
+
+static int region_truncate(struct list_head *head, int end)
+{
+	struct file_region *rg;
+	struct file_region *trg;
+	int chg = 0;
+
+	/* Locate the region we are either in or before. */
+	list_for_each_entry(rg, head, link)
+		if (end <= rg->to)
+			break;
+	if (&rg->link == head)
+		return 0;
+
+	/* If we are in the middle of a region then adjust it. */
+	if (end > rg->from) {
+		chg = rg->to - end;
+		rg->to = end;
+		rg = list_entry(rg->link.next, typeof(*rg), link);
+	}
+
+	/* Drop any remaining regions. */
+	list_for_each_entry_safe(rg, trg, rg->link.prev, link) {
+		if (&rg->link == head)
+			break;
+		chg += rg->to - rg->from;
+		list_del(&rg->link);
+		kfree(rg);
+	}
+	return chg;
+}
+
+#define VMACCTPG(x) ((x) >> (HPAGE_SHIFT - PAGE_SHIFT))

fs/hugetlbfs/inode.c static void huge_pagevec_release(struct · line 194

Quoted 10 lines
fs/hugetlbfs/inode.c renamed from fs/hugetlbfs/inode.c.orig +10 -0
+int hugetlb_acct_memory(long delta)
+{
+	atomic_add(delta, &resv_huge_pages);
+	if (delta > 0 && atomic_read(&resv_huge_pages) >
+			VMACCTPG(hugetlb_total_pages())) {
+		atomic_add(-delta, &resv_huge_pages);
+		return -ENOMEM;
+	}
+	return 0;
+}

This looks a bit like a case of "let's make it an atomic_t to sprinkle it with magic atomicity dust" without thinking about what operations are and need to be atomic. I think resv_huge_pages should be an ordinary int, but protected by a lock (exactly which lock is not immediately obvious).

fs/hugetlbfs/inode.c static void huge_pagevec_release(struct · line 200

Quoted 5 lines
fs/hugetlbfs/inode.c renamed from fs/hugetlbfs/inode.c.orig +5 -0
+static int hugetlb_reserve_pages(struct inode *inode, int from, int to)
+{
+	int ret, chg;
+
+	chg = region_chg(&inode->i_mapping->private_list, from, to);

What is the list of regions (mapping->private_list) protected by? mmap_sem (the only thing I can think of off hand that's already taken) doesn't cut it, because the mapping can be accessed by multiple mms.

Quoted 78 lines
fs/hugetlbfs/inode.c renamed from fs/hugetlbfs/inode.c.orig +15 -6
+	if (chg < 0)
+		return chg;
+	ret = hugetlb_acct_memory(chg);
+	if (ret < 0)
+		return ret;
+	region_add(&inode->i_mapping->private_list, from, to);
+	return 0;
 }
 
 static int hugetlbfs_file_mmap(struct file *file, struct vm_area_struct *vma)
 {
 	struct inode *inode = file->f_dentry->d_inode;
-	struct address_space *mapping = inode->i_mapping;
-	unsigned long bytes;
 	loff_t len, vma_len;
 	int ret;
 
@@ -113,10 +225,6 @@ static int hugetlbfs_file_mmap(struct fi
 	if (vma->vm_end - vma->vm_start < HPAGE_SIZE)
 		return -EINVAL;
 
-	bytes = huge_pages_needed(mapping, vma);
-	if (!is_hugepage_mem_enough(bytes))
-		return -ENOMEM;
-
 	vma_len = (loff_t)(vma->vm_end - vma->vm_start);
 
 	mutex_lock(&inode->i_mutex);
@@ -129,6 +237,11 @@ static int hugetlbfs_file_mmap(struct fi
 	if (!(vma->vm_flags & VM_WRITE) && len > inode->i_size)
 		goto out;
 
+	if (vma->vm_flags & VM_MAYSHARE)
+		if (hugetlb_reserve_pages(inode, VMACCTPG(vma->vm_pgoff),
+			VMACCTPG(vma->vm_pgoff + (vma_len >> PAGE_SHIFT))))
+			goto out;
+
 	ret = 0;
 	hugetlb_prefault_arch_hook(vma->vm_mm);
 	if (inode->i_size < len)
@@ -258,6 +371,8 @@ static void truncate_hugepages(struct ad
 		huge_pagevec_release(&pvec);
 	}
 	BUG_ON(!lstart && mapping->nrpages);
+	i = region_truncate(&mapping->private_list, start);
+	hugetlb_acct_memory(-i);
 }
 
 static void hugetlbfs_delete_inode(struct inode *inode)
@@ -401,6 +516,7 @@ static struct inode *hugetlbfs_get_inode
 		inode->i_mapping->a_ops = &hugetlbfs_aops;
 		inode->i_mapping->backing_dev_info =&hugetlbfs_backing_dev_info;
 		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
+		INIT_LIST_HEAD(&inode->i_mapping->private_list);
 		info = HUGETLBFS_I(inode);
 		mpol_shared_policy_init(&info->policy, MPOL_DEFAULT, NULL);
 		switch (mode & S_IFMT) {
include/linux/hugetlb.h renamed from include/linux/hugetlb.h.orig +1 -0
@@ -30,6 +30,7 @@ int hugetlb_fault(struct mm_struct *mm, 
 extern unsigned long max_huge_pages;
 extern const unsigned long hugetlb_zero, hugetlb_infinity;
 extern int sysctl_hugetlb_shm_group;
+extern atomic_t resv_huge_pages;
 
 /* arch callbacks */
 
mm/hugetlb.c renamed from mm/hugetlb.c.orig +1 -0
@@ -21,6 +21,7 @@
 
 const unsigned long hugetlb_zero = 0, hugetlb_infinity = ~0UL;
 static unsigned long nr_huge_pages, free_huge_pages;
+atomic_t resv_huge_pages;
 unsigned long max_huge_pages;
 static struct list_head hugepage_freelists[MAX_NUMNODES];
 static unsigned int nr_huge_pages_node[MAX_NUMNODES];

mm/hugetlb.c int hugetlb_report_meminfo(char *buf) · line 235

Quoted 10 lines
mm/hugetlb.c renamed from mm/hugetlb.c.orig +2 -0
@@ -225,9 +226,11 @@ int hugetlb_report_meminfo(char *buf)
 	return sprintf(buf,
 			"HugePages_Total: %5lu\n"
 			"HugePages_Free:  %5lu\n"
+			"HugePages_Resv:  %5u\n"
 			"Hugepagesize:    %5lu kB\n",
 			nr_huge_pages,
 			free_huge_pages,
+			atomic_read(&resv_huge_pages),
 			HPAGE_SIZE/1024);
 }

Again, there are no changes to the fault handler. Including the promised changes which would mean my instantiation serialization path isn't necessary ;-).

Signature · 10 lines
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to [email protected].  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
#2 lore raw

David Gibson wrote on Thursday, March 09, 2006 3:27 AM

Quoted 4 lines

Um... as far as I can tell, this patch doesn't actually reserve anything. There are no changes to the fault handler ot alloc_huge_page(), so there's nothing to stop PRIVATE mappings dipping into the supposedly reserved pool.

Well, the reservation is already done at mmap time for shared mapping. Why does kernel need to do anything at fault time? Doing it at fault time is an indication of weakness (or brokenness) - you already promised at mmap time that there will be a page available for faulting. Why check them again at fault time?

I don't think your implementation handles PRIVATE mapping either, Isn't it? Private mapping doesn't enter into the page cache hanging of address_space pointer, so either way, it is busted.

Quoted 5 lines

This looks a bit like a case of "let's make it an atomic_t to sprinkle it with magic atomicity dust" without thinking about what operations are and need to be atomic. I think resv_huge_pages should be an ordinary int, but protected by a lock (exactly which lock is not immediately obvious).

Yeah, I agree. It crossed my mind whether I should fix that or post a fairly straightforward back port. I decided to do the latter and I got bitten :-( That is in the pipeline if people agree that this variable reservation system is a better one.

Quoted 3 lines

What is the list of regions (mapping->private_list) protected by? mmap_sem (the only thing I can think of off hand that's already taken) doesn't cut it, because the mapping can be accessed by multiple mms.

I think it is the inode->i_mutex.

- Ken

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>

#3 lore raw
Quoted 11 lines · Kenneth W

David Gibson wrote on Thursday, March 09, 2006 3:27 AM

Quoted 4 lines

Um... as far as I can tell, this patch doesn't actually reserve anything. There are no changes to the fault handler ot alloc_huge_page(), so there's nothing to stop PRIVATE mappings dipping into the supposedly reserved pool.

Well, the reservation is already done at mmap time for shared mapping. Why does kernel need to do anything at fault time? Doing it at fault time is an indication of weakness (or brokenness) - you already promised at mmap time that there will be a page available for faulting. Why check them again at fault time?

You can't know (or bound) at mmap() time how many pages a PRIVATE mapping will take (because of fork()). So unless you have a test at fault time (essentialy deciding whether to draw from "reserved" and "unreserved" hugepage pool) a supposedly reserved SHARED mapping will OOM later if there have been enough COW faults to use up all the hugepages before it's instantiated.

Quoted 3 lines

I don't think your implementation handles PRIVATE mapping either, Isn't it? Private mapping doesn't enter into the page cache hanging of address_space pointer, so either way, it is busted.

Depends what you mean by "handle". With my patch PRIVATE mappings are never reserved or guaranteed (I couldn't think of any set of sane semantics for it), *but* they will never eat into the pool reserved for SHARED mappings. With yours, they can, so:

	p = mmap(SHARED)
	/* Lots of COW faults elsewhere */
	*p = x;

Will result in an OOM Kill on the last line.

Quoted 12 lines
Quoted 5 lines

This looks a bit like a case of "let's make it an atomic_t to sprinkle it with magic atomicity dust" without thinking about what operations are and need to be atomic. I think resv_huge_pages should be an ordinary int, but protected by a lock (exactly which lock is not immediately obvious).

Yeah, I agree. It crossed my mind whether I should fix that or post a fairly straightforward back port. I decided to do the latter and I got bitten :-( That is in the pipeline if people agree that this variable reservation system is a better one.

Quoted 5 lines
Quoted 3 lines

What is the list of regions (mapping->private_list) protected by? mmap_sem (the only thing I can think of off hand that's already taken) doesn't cut it, because the mapping can be accessed by multiple mms.

I think it is the inode->i_mutex.

Ok, you should double check that's taken in all the right places, but it sounds plausible.

Signature · 10 lines
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to [email protected].  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
#4 lore raw

David Gibson wrote on Thursday, March 09, 2006 4:07 AM

Quoted 6 lines
Quoted 5 lines

Well, the reservation is already done at mmap time for shared mapping. Why does kernel need to do anything at fault time? Doing it at fault time is an indication of weakness (or brokenness) - you already promised at mmap time that there will be a page available for faulting. Why check them again at fault time?

Quoted 6 lines

You can't know (or bound) at mmap() time how many pages a PRIVATE mapping will take (because of fork()). So unless you have a test at fault time (essentialy deciding whether to draw from "reserved" and "unreserved" hugepage pool) a supposedly reserved SHARED mapping will OOM later if there have been enough COW faults to use up all the hugepages before it's instantiated.

I see. But that is easy to fix. I just need to do exactly the same thing as what you did to alloc_huge_page. I will then need to change definition of 'reservation' to needs-in-the future (also an easy thing to change).

The real question or discussion I want to bring up is whether kernel should do it's own accounting or relying on traversing the page cache. My opinion is that kernel should do it's own accounting because it is
simpler: you just need to do that at mmap and ftruncate time.

- Ken

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>

#5 lore raw
Quoted 14 lines · Kenneth W

David Gibson wrote on Thursday, March 09, 2006 4:07 AM

Quoted 6 lines
Quoted 5 lines

Well, the reservation is already done at mmap time for shared mapping. Why does kernel need to do anything at fault time? Doing it at fault time is an indication of weakness (or brokenness) - you already promised at mmap time that there will be a page available for faulting. Why check them again at fault time?

Quoted 6 lines

You can't know (or bound) at mmap() time how many pages a PRIVATE mapping will take (because of fork()). So unless you have a test at fault time (essentialy deciding whether to draw from "reserved" and "unreserved" hugepage pool) a supposedly reserved SHARED mapping will OOM later if there have been enough COW faults to use up all the hugepages before it's instantiated.

Quoted 4 lines

I see. But that is easy to fix. I just need to do exactly the same thing as what you did to alloc_huge_page. I will then need to change definition of 'reservation' to needs-in-the future (also an easy thing to change).

Well.. except that then you *do* need to traverse the page cache on truncate(), just like I do. Note that in my latest revision, hugetlb_extend_reservation() no longer walks the radix tree, only hugetlb_truncate_reservation() does (extend *does* still take the tree_lock, an oversight which I will send a patch for tomorrow).

(Oh, and you'll need to walk the reserved range list in alloc_huge_page(), rather than one comparison like I have. Although in practice I imagine there will never be more than one entry on the list, so I guess that doesn't really matter)

Quoted 4 lines

The real question or discussion I want to bring up is whether kernel should do it's own accounting or relying on traversing the page cache. My opinion is that kernel should do it's own accounting because it is
simpler: you just need to do that at mmap and ftruncate time.

And as we've seen above, a little bit at fault time. Which would be exactly the same three places that my patch adds accounting. I'm quite willing to be convinced your patch is the better approach, but this isn't an argument for it.

Incidentally, I've just realised that removing the dodgy heuristic and allowing unconstrained overcommit for PRIVATE mappings (which both our patches do) is potentially problematic. In particular it means my hugepage malloc() implementation will always OOM rather than fallback to normal pages :( (I believe currently it will usually fall back, and only OOM if you get unlucky with the timing).

Signature · 10 lines
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to [email protected].  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
#6 lore raw
In reply to 'David Gibson'

David Gibson wrote on Thursday, March 09, 2006 3:27 AM

Quoted 3 lines

Again, there are no changes to the fault handler. Including the promised changes which would mean my instantiation serialization path isn't necessary ;-).

This is the major portion that I omitted in the first patch and is the real kicker that fulfills the promise of guaranteed available hugetlb page for shared mapping.

You can shower me all over on the lock protection :-) yes, this is not perfect and was the reason I did not post it earlier, but I want to give you the concept on how I envision this route would work.

Again PRIVATE mapping is busted, you can't count them from inode. You would have to count them via mm_struct (I think).

- Ken

Note: definition of "reservation" in earlier patch is total hugetlb pages needed for that file, including the one that is already faulted in. Maybe that throw you off a bit because I'm guessing your definition is "needed in the future" and probably you are looking for a decrement of the counter in the fault path?

mm/hugetlb.c renamed from mm/hugetlb.c.orig +2 -0
@@ -196,6 +196,8 @@ static unsigned long set_max_huge_pages(
 		enqueue_huge_page(page);
 		spin_unlock(&hugetlb_lock);
 	}
+	if (count < atomic_read(&resv_huge_pages))
+		count = atomic_read(&resv_huge_pages);
 	if (count >= nr_huge_pages)
 		return nr_huge_pages;
 

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>

#7 lore raw
Quoted 9 lines · Kenneth W

David Gibson wrote on Thursday, March 09, 2006 3:27 AM

Quoted 3 lines

Again, there are no changes to the fault handler. Including the promised changes which would mean my instantiation serialization path isn't necessary ;-).

This is the major portion that I omitted in the first patch and is the real kicker that fulfills the promise of guaranteed available hugetlb page for shared mapping.

Quoted 6 lines

You can shower me all over on the lock protection :-) yes, this is not perfect and was the reason I did not post it earlier, but I want to give you the concept on how I envision this route would work.

Again PRIVATE mapping is busted, you can't count them from inode. You would have to count them via mm_struct (I think).

I don't think there's any sane way to reserve for PRIVATE mappings. To do it strictly you'd have to reaccount the whole block on every fork(), and that would mean that any process using >0.5 of the system's hugepages could never fork(), even if the child was just going to exec().

Given that, it's simplest just to allow free overcommit for PRIVATE mappings. *But* you can ensure that PRIVATE allocations (i.e. COW faults) don't mess with any previously reserved SHARED mappings.

Quoted 5 lines

Note: definition of "reservation" in earlier patch is total hugetlb pages needed for that file, including the one that is already faulted in. Maybe that throw you off a bit because I'm guessing your definition is "needed in the future" and probably you are looking for a decrement of the counter in the fault path?

No, I realised that distinction.

Signature · 10 lines
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

--
To unsubscribe, send a message with 'unsubscribe linux-mm' in
the body to [email protected].  For more info on Linux MM,
see: http://www.linux-mm.org/ .
Don't email: <a href=mailto:"[email protected]"> [email protected] </a>