Dynamicaly allocate SG table from the pages
Subsystems (6)
v5 cover Dynamicaly allocate SG table from the pages
From: Leon Romanovsky <[email protected]>
Changelog:
v5:
* Use sg_init_table to allocate table and avoid changes is __sg_alloc_table
* Fix offset issue
v4: https://lore.kernel.org/lkml/[email protected]
* Fixed formatting in first patch.
* Added fix (clear tmp_netnts) in first patch to fix i915 failure.
* Added test patches
v3: https://lore.kernel.org/linux-rdma/[email protected]/
* Squashed Christopher's suggestion to avoid introduced new API, but extend existing one.
v2: https://lore.kernel.org/linux-rdma/[email protected]
* Fixed indentations and comments
* Deleted sg_alloc_next()
* Squashed lib/scatterlist patches into one
v1: https://lore.kernel.org/lkml/[email protected]
* Changed _sg_chain to be __sg_chain
* Added dependency on ARCH_NO_SG_CHAIN
* Removed struct sg_append
v0:
* https://lore.kernel.org/lkml/[email protected]
--------------------------------------------------------------------------
From Maor:
This series extends __sg_alloc_table_from_pages to allow chaining of new pages to already initialized SG table.
This allows for the drivers to utilize the optimization of merging contiguous pages without a need to pre allocate all the pages and hold them in a very large temporary buffer prior to the call to SG table initialization.
The second patch changes the Infiniband driver to use the new API. It removes duplicate functionality from the code and benefits the optimization of allocating dynamic SG table from pages.
In huge pages system of 2MB page size, without this change, the SG table would contain x512 SG entries.
E.g. for 100GB memory registration:
Number of entries Size
Before 26214400 600.0MB
After 51200 1.2MB
Thanks
Maor Gottlieb (2):
lib/scatterlist: Add support in dynamic allocation of SG table from
pages
RDMA/umem: Move to allocate SG table from pages
Tvrtko Ursulin (2):
tools/testing/scatterlist: Rejuvenate bit-rotten test tools/testing/scatterlist: Show errors in human readable form
drivers/gpu/drm/i915/gem/i915_gem_userptr.c | 12 +- drivers/gpu/drm/vmwgfx/vmwgfx_ttm_buffer.c | 15 ++- drivers/infiniband/core/umem.c | 94 ++------------- include/linux/scatterlist.h | 38 +++--- lib/scatterlist.c | 125 ++++++++++++++++---- tools/testing/scatterlist/Makefile | 3 +- tools/testing/scatterlist/linux/mm.h | 35 ++++++ tools/testing/scatterlist/main.c | 53 ++++++--- 8 files changed, 225 insertions(+), 150 deletions(-)
--
2.26.2
PATCH v5 1/4 lib/scatterlist: Add support in dynamic allocation of SG table from pages
From: Maor Gottlieb <[email protected]>
Extend __sg_alloc_table_from_pages to support dynamic allocation of SG table from pages. It should be used by drivers that can't supply all the pages at one time.
This function returns the last populated SGE in the table. Users should pass it as an argument to the function from the second call and forward. As before, nents will be equal to the number of populated SGEs (chunks).
With this new extension, drivers can benefit the optimization of merging contiguous pages without a need to allocate all pages in advance and hold them in a large buffer.
E.g. with the Infiniband driver that allocates a single page for hold the pages. For 1TB memory registration, the temporary buffer would consume only 4KB, instead of 2GB.
--- drivers/gpu/drm/i915/gem/i915_gem_userptr.c | 12 +- drivers/gpu/drm/vmwgfx/vmwgfx_ttm_buffer.c | 15 ++- include/linux/scatterlist.h | 38 +++--- lib/scatterlist.c | 125 ++++++++++++++++---- tools/testing/scatterlist/main.c | 9 +- 5 files changed, 142 insertions(+), 57 deletions(-)
drivers/gpu/drm/i915/gem/i915_gem_userptr.c +6 -6
@@ -403,6 +403,7 @@ __i915_gem_userptr_alloc_pages(struct drm_i915_gem_object *obj,unsigned int max_segment =i915_sg_segment_size ();struct sg_table *st;unsigned int sg_page_sizes; +struct scatterlist *sg;int ret; st =kmalloc (sizeof (*st),GFP_KERNEL );
@@ -410,13 +411,12 @@ __i915_gem_userptr_alloc_pages(struct drm_i915_gem_object *obj,return ERR_PTR (-ENOMEM ); alloc_table: - ret =__sg_alloc_table_from_pages (st, pvec, num_pages, -0 , num_pages <<PAGE_SHIFT , - max_segment, -GFP_KERNEL ); -if (ret) { + sg =__sg_alloc_table_from_pages (st, pvec, num_pages,0 , + num_pages <<PAGE_SHIFT , max_segment, +NULL ,0 ,GFP_KERNEL ); +if (IS_ERR (sg)) {kfree (st); -return ERR_PTR (ret); +return ERR_CAST (sg); } ret =i915_gem_gtt_prepare_pages (obj, st);
drivers/gpu/drm/vmwgfx/vmwgfx_ttm_buffer.c +9 -6
@@ -419,6 +419,7 @@ static int vmw_ttm_map_dma(struct vmw_ttm_tt *vmw_tt)int ret =0 ;static size_t sgl_size;static size_t sgt_size; +struct scatterlist *sg;if (vmw_tt->mapped)return 0 ;
@@ -441,13 +442,15 @@ static int vmw_ttm_map_dma(struct vmw_ttm_tt *vmw_tt)if (unlikely (ret !=0 ))return ret; - ret =__sg_alloc_table_from_pages - (&vmw_tt->sgt, vsgt->pages, vsgt->num_pages,0 , - (unsigned long ) vsgt->num_pages <<PAGE_SHIFT , -dma_get_max_seg_size (dev_priv->dev->dev), -GFP_KERNEL ); -if (unlikely (ret !=0 )) + sg =__sg_alloc_table_from_pages (&vmw_tt->sgt, vsgt->pages, + vsgt->num_pages,0 , + (unsigned long ) vsgt->num_pages <<PAGE_SHIFT , +dma_get_max_seg_size (dev_priv->dev->dev), +NULL ,0 ,GFP_KERNEL ); +if (IS_ERR (sg)) { + ret =PTR_ERR (sg); goto out_sg_alloc_fail; + }if (vsgt->num_pages > vmw_tt->sgt.nents) { uint64_t over_alloc =
include/linux/scatterlist.h +22 -16
@@ -165,6 +165,22 @@ static inline void sg_set_buf(struct scatterlist *sg, const void *buf,#define for_each_sgtable_dma_sg (sgt, sg, i) \ for_each_sg((sgt)->sgl, sg, (sgt)->nents, i) +static inline void __sg_chain (struct scatterlist *chain_sg, +struct scatterlist *sgl) +{ +/* +* offset and length are unused for chain entry. Clear them. +*/ + chain_sg->offset =0 ; + chain_sg->length =0 ; + +/* +* Set lowest bit to indicate a link pointer, and make sure to clear +* the termination bit if it happens to be set. +*/ + chain_sg->page_link = ((unsigned long ) sgl |SG_CHAIN ) & ~SG_END ; +} +/** * sg_chain - Chain two sglists together * @prv: First scatterlist
@@ -178,18 +194,7 @@ static inline void sg_set_buf(struct scatterlist *sg, const void *buf,static inline void sg_chain (struct scatterlist *prv,unsigned int prv_nents,struct scatterlist *sgl) { -/* -* offset and length are unused for chain entry. Clear them. -*/ - prv[prv_nents -1 ].offset =0 ; - prv[prv_nents -1 ].length =0 ; - -/* -* Set lowest bit to indicate a link pointer, and make sure to clear -* the termination bit if it happens to be set. -*/ - prv[prv_nents -1 ].page_link = ((unsigned long ) sgl |SG_CHAIN ) - & ~SG_END ; +__sg_chain (&prv[prv_nents -1 ], sgl); }/**
@@ -286,10 +291,11 @@ void sg_free_table(struct sg_table *);int __sg_alloc_table (struct sg_table *,unsigned int ,unsigned int ,struct scatterlist *,unsigned int ,gfp_t ,sg_alloc_fn *);int sg_alloc_table (struct sg_table *,unsigned int ,gfp_t ); -int __sg_alloc_table_from_pages (struct sg_table *sgt,struct page **pages, -unsigned int n_pages,unsigned int offset, -unsigned long size,unsigned int max_segment, -gfp_t gfp_mask); +struct scatterlist *__sg_alloc_table_from_pages (struct sg_table *sgt, +struct page **pages,unsigned int n_pages,unsigned int offset, +unsigned long size,unsigned int max_segment, +struct scatterlist *prv,unsigned int left_pages, +gfp_t gfp_mask);int sg_alloc_table_from_pages (struct sg_table *sgt,struct page **pages,unsigned int n_pages,unsigned int offset,unsigned long size,gfp_t gfp_mask);
lib/scatterlist.c +101 -24
172 lines not on this page · raw message
tools/testing/scatterlist/main.c +4 -5
@@ -55,14 +55,13 @@ int main(void)for (i =0 , test = tests; test->expected_segments; test++, i++) {struct page *pages[MAX_PAGES ];struct sg_table st; -int ret; +struct scatterlist *sg;set_pages (pages, test->pfn, test->num_pages); - ret =__sg_alloc_table_from_pages (&st, pages, test->num_pages, -0 , test->size, test->max_seg, -GFP_KERNEL ); -assert (ret == test->alloc_ret); + sg =__sg_alloc_table_from_pages (&st, pages, test->num_pages,0 , + test->size, test->max_seg,NULL ,0 ,GFP_KERNEL ); +assert (PTR_ERR_OR_ZERO (sg) == test->alloc_ret);if (test->alloc_ret)continue ;
--
2.26.2
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v5 2/4 tools/testing/scatterlist: Rejuvenate bit-rotten test
In reply to Leon RomanovskyFrom: Tvrtko Ursulin <[email protected]>
A couple small tweaks are needed to make the test build and run on current kernels.
--- tools/testing/scatterlist/Makefile | 3 ++- tools/testing/scatterlist/linux/mm.h | 35 ++++++++++++++++++++++++++++ 2 files changed, 37 insertions(+), 1 deletion(-)
tools/testing/scatterlist/Makefile +2 -1
@@ -14,7 +14,7 @@ targets: include $(TARGETS) main: $(OFILES) clean: - $(RM) $(TARGETS) $(OFILES) scatterlist.c linux/scatterlist.h linux/highmem.h linux/kmemleak.h asm/io.h + $(RM) $(TARGETS) $(OFILES) scatterlist.c linux/scatterlist.h linux/highmem.h linux/kmemleak.h linux/slab.h asm/io.h @rmdir asm scatterlist.c: ../../../lib/scatterlist.c
@@ -28,4 +28,5 @@ include: ../../../include/linux/scatterlist.h @touch asm/io.h @touch linux/highmem.h @touch linux/kmemleak.h + @touch linux/slab.h @cp $< linux/scatterlist.h
tools/testing/scatterlist/linux/mm.h +35 -0
@@ -114,6 +114,12 @@ static inline void *kmalloc(unsigned int size, unsigned int flags)return malloc (size); } +static inline void * +kmalloc_array (unsigned int n,unsigned int size,unsigned int flags) +{ +return malloc (n * size); +} +#define kfree (x) free(x)#define kmemleak_alloc (a, b, c, d)
@@ -122,4 +128,33 @@ static inline void *kmalloc(unsigned int size, unsigned int flags)#define PageSlab (p) (0)#define flush_kernel_dcache_page (p) +#define MAX_ERRNO 4095 + +#define IS_ERR_VALUE (x) unlikely((unsigned long)(void *)(x) >= (unsigned long)-MAX_ERRNO) + +static inline void *__must_check ERR_PTR (long error) +{ +return (void *) error; +} + +static inline long __must_check PTR_ERR (__force const void *ptr) +{ +return (long ) ptr; +} + +static inline bool __must_check IS_ERR (__force const void *ptr) +{ +return IS_ERR_VALUE ((unsigned long )ptr); +} + +static inline int __must_check PTR_ERR_OR_ZERO (__force const void *ptr) +{ +if (IS_ERR (ptr)) +return PTR_ERR (ptr); +else +return 0 ; +} + +#define IS_ENABLED (x) (0) +#endif
--
2.26.2
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
PATCH v5 3/4 tools/testing/scatterlist: Show errors in human readable form
In reply to Leon RomanovskyFrom: Tvrtko Ursulin <[email protected]>
Instead of just asserting dump some more useful info about what the test saw versus what it expected to see.
--- tools/testing/scatterlist/main.c | 44 ++++++++++++++++++++++++-------- 1 file changed, 34 insertions(+), 10 deletions(-)
tools/testing/scatterlist/main.c +34 -10
@@ -5,6 +5,15 @@#define MAX_PAGES (64) +struct test { +int alloc_ret; +unsigned num_pages; +unsigned *pfn; +unsigned size; +unsigned int max_seg; +unsigned int expected_segments; +}; +static void set_pages (struct page **pages,const unsigned *array,unsigned num) {unsigned int i;
@@ -17,17 +26,32 @@ static void set_pages(struct page **pages, const unsigned *array, unsigned num)#define pfn (...) (unsigned []){ __VA_ARGS__ } +static void fail (struct test *test,struct sg_table *st,const char *cond) +{ +unsigned int i; + +fprintf (stderr,"Failed on '%s'!\n\n" , cond); + +printf ("size = %u, max segment = %u, expected nents = %u\nst->nents = %u, st->orig_nents= %u\n" , + test->size, test->max_seg, test->expected_segments, st->nents, + st->orig_nents); + +printf ("%u input PFNs:" , test->num_pages); +for (i =0 ; i < test->num_pages; i++) +printf (" %x" , test->pfn[i]); +printf ("\n" ); + +exit (1 ); +} + +#define VALIDATE (cond, st, test) \ + if (!(cond)) \ + fail((test), (st), #cond); +int main (void ) {const unsigned int sgmax =SCATTERLIST_MAX_SEGMENT ; -struct test { -int alloc_ret; -unsigned num_pages; -unsigned *pfn; -unsigned size; -unsigned int max_seg; -unsigned int expected_segments; - } *test, tests[] = { +struct test *test, tests[] = { { -EINVAL ,1 ,pfn (0 ),PAGE_SIZE ,PAGE_SIZE +1 ,1 }, { -EINVAL ,1 ,pfn (0 ),PAGE_SIZE ,0 ,1 }, { -EINVAL ,1 ,pfn (0 ),PAGE_SIZE , sgmax +1 ,1 },
@@ -66,8 +90,8 @@ int main(void)if (test->alloc_ret)continue ; -assert (st.nents == test->expected_segments); -assert (st.orig_nents == test->expected_segments); +VALIDATE (st.nents == test->expected_segments, &st, test); +VALIDATE (st.orig_nents == test->expected_segments, &st, test);sg_free_table (&st); }
--
2.26.2
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
PATCH v5 4/4 RDMA/umem: Move to allocate SG table from pages
In reply to Leon RomanovskyFrom: Maor Gottlieb <[email protected]>
Remove the implementation of ib_umem_add_sg_table and instead call to __sg_alloc_table_from_pages which already has the logic to merge contiguous pages.
Besides that it removes duplicated functionality, it reduces the memory consumption of the SG table significantly. Prior to this patch, the SG table was allocated in advance regardless consideration of contiguous pages.
In huge pages system of 2MB page size, without this change, the SG table would contain x512 SG entries.
E.g. for 100GB memory registration:
Number of entries Size
Before 26214400 600.0MB
After 51200 1.2MB
--- drivers/infiniband/core/umem.c | 94 +++++----------------------------- 1 file changed, 12 insertions(+), 82 deletions(-)
drivers/infiniband/core/umem.c +12 -82
@@ -61,73 +61,6 @@ static void __ib_umem_release(struct ib_device *dev, struct ib_umem *umem, int dsg_free_table (&umem->sg_head); } -/* ib_umem_add_sg_table - Add N contiguous pages to scatter table -* -* sg: current scatterlist entry -* page_list: array of npage struct page pointers -* npages: number of pages in page_list -* max_seg_sz: maximum segment size in bytes -* nents: [out] number of entries in the scatterlist -* -* Return new end of scatterlist -*/ -static struct scatterlist *ib_umem_add_sg_table (struct scatterlist *sg, -struct page **page_list, -unsigned long npages, -unsigned int max_seg_sz, -int *nents) -{ -unsigned long first_pfn; -unsigned long i =0 ; -bool update_cur_sg = false; -bool first = !sg_page (sg); - -/* Check if new page_list is contiguous with end of previous page_list. -* sg->length here is a multiple of PAGE_SIZE and sg->offset is 0. -*/ -if (!first && (page_to_pfn (sg_page (sg)) + (sg->length >>PAGE_SHIFT ) == -page_to_pfn (page_list[0 ]))) - update_cur_sg = true; - -while (i != npages) { -unsigned long len; -struct page *first_page = page_list[i]; - - first_pfn =page_to_pfn (first_page); - -/* Compute the number of contiguous pages we have starting -* at i -*/ -for (len =0 ; i != npages && - first_pfn + len ==page_to_pfn (page_list[i]) && - len < (max_seg_sz >>PAGE_SHIFT ); - len++) - i++; - -/* Squash N contiguous pages from page_list into current sge */ -if (update_cur_sg) { -if ((max_seg_sz - sg->length) >= (len <<PAGE_SHIFT )) { -sg_set_page (sg,sg_page (sg), - sg->length + (len <<PAGE_SHIFT ), -0 ); - update_cur_sg = false; -continue ; - } - update_cur_sg = false; - } - -/* Squash N contiguous pages into next sge or first sge */ -if (!first) - sg =sg_next (sg); - - (*nents)++; -sg_set_page (sg, first_page, len <<PAGE_SHIFT ,0 ); - first = false; - } - -return sg; -} -/** * ib_umem_find_best_pgsz - Find best HW page size to use for this MR *
@@ -217,7 +150,7 @@ struct ib_umem *ib_umem_get(struct ib_device *device, unsigned long addr,struct mm_struct *mm;unsigned long npages;int ret; -struct scatterlist *sg; +struct scatterlist *sg =NULL ;unsigned int gup_flags =FOLL_WRITE ;/*
@@ -272,15 +205,9 @@ struct ib_umem *ib_umem_get(struct ib_device *device, unsigned long addr, cur_base = addr &PAGE_MASK ; - ret =sg_alloc_table (&umem->sg_head, npages,GFP_KERNEL ); -if (ret) - goto vma; -if (!umem->writable) gup_flags |=FOLL_FORCE ; - sg = umem->sg_head.sgl; -while (npages) {cond_resched (); ret = pin_user_pages_fast(cur_base,
@@ -292,15 +219,19 @@ struct ib_umem *ib_umem_get(struct ib_device *device, unsigned long addr, goto umem_release; cur_base += ret *PAGE_SIZE ; - npages -= ret; - - sg =ib_umem_add_sg_table (sg, page_list, ret, -dma_get_max_seg_size (device->dma_device), - &umem->sg_nents); + npages -= ret; + sg =__sg_alloc_table_from_pages ( + &umem->sg_head, page_list, ret,0 , ret <<PAGE_SHIFT , +dma_get_max_seg_size (device->dma_device), sg, npages, +GFP_KERNEL ); + umem->sg_nents = umem->sg_head.nents; +if (IS_ERR (sg)) { +unpin_user_pages_dirty_lock (page_list, ret,0 ); + ret =PTR_ERR (sg); + goto umem_release; + } } -sg_mark_end (sg); -if (access &IB_ACCESS_RELAXED_ORDERING ) dma_attr |=DMA_ATTR_WEAK_ORDERING ;
@@ -318,7 +249,6 @@ struct ib_umem *ib_umem_get(struct ib_device *device, unsigned long addr, umem_release:__ib_umem_release (device, umem,0 ); -vma:atomic64_sub (ib_umem_num_pages (umem), &mm->pinned_vm); out:free_page ((unsigned long ) page_list);
--
2.26.2
_______________________________________________
dri-devel mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/dri-devel
Patchwork
CI[Intel-gfx] ✗ Fi.CI.BUILD: failure for Dynamicaly allocate SG table from the pages (rev3)
In reply to Leon Romanovsky== Series Details ==
== Series Details ==
Series: Dynamicaly allocate SG table from the pages (rev3)
URL : https://patchwork.freedesktop.org/series/81962/
State : failure
== Summary ==
Applying: This series extends __sg_alloc_table_from_pages to allow chaining of
error: sha1 information is lacking or useless (tools/testing/scatterlist/main.c).
error: could not build fake ancestor
hint: Use 'git am --show-current-patch=diff' to see the failed patch
Patch failed at 0001 This series extends __sg_alloc_table_from_pages to allow chaining of When you have resolved this problem, run "git am --continue".
If you prefer to skip this patch, run "git am --skip" instead.
To restore the original branch and stop patching, run "git am --abort".
_______________________________________________
Intel-gfx mailing list
[email protected]
https://lists.freedesktop.org/mailman/listinfo/intel-gfx
Jason Gunthorpe
maintainerQuoted 21 lines · Leon Romanovsky
This series extends
__sg_alloc_table_from_pagesto allow chaining of new pages to already initialized SG table.This allows for the drivers to utilize the optimization of merging contiguous pages without a need to pre allocate all the pages and hold them in a very large temporary buffer prior to the call to SG table initialization.
The second patch changes the Infiniband driver to use the new API. It removes duplicate functionality from the code and benefits the optimization of allocating dynamic SG table from pages.
In huge pages system of 2MB page size, without this change, the SG table would contain x512 SG entries.
E.g. for 100GB memory registration:Number of entries Size
Before 26214400 600.0MB
After 51200 1.2MBThanks
Quoted 8 lines
Maor Gottlieb (2):
lib/scatterlist: Add support in dynamic allocation of SG table from
pages
RDMA/umem: Move to allocate SG table from pagesTvrtko Ursulin (2):
tools/testing/scatterlist: Rejuvenate bit-rotten testtools/testing/scatterlist: Show errors in human readable form
This looks OK, I'm going to send it into linux-next on the hmm tree for awhile to see if anything gets broken. If there is more remarks/tags/etc please continue
Thanks,
Jason
Quoted 27 lines · Jason Gunthorpe
Quoted 26 lines · Leon Romanovsky
This series extends
__sg_alloc_table_from_pagesto allow chaining of new pages to already initialized SG table.This allows for the drivers to utilize the optimization of merging contiguous pages without a need to pre allocate all the pages and hold them in a very large temporary buffer prior to the call to SG table initialization.
The second patch changes the Infiniband driver to use the new API. It removes duplicate functionality from the code and benefits the optimization of allocating dynamic SG table from pages.
In huge pages system of 2MB page size, without this change, the SG table would contain x512 SG entries.
E.g. for 100GB memory registration:Number of entries Size
Before 26214400 600.0MB
After 51200 1.2MBThanks
Maor Gottlieb (2):
lib/scatterlist: Add support in dynamic allocation of SG table from
pages
RDMA/umem: Move to allocate SG table from pages
Quoted 7 lines
Quoted 3 lines
Tvrtko Ursulin (2):
tools/testing/scatterlist: Rejuvenate bit-rotten testtools/testing/scatterlist: Show errors in human readable formThis looks OK, I'm going to send it into linux-next on the hmm tree for awhile to see if anything gets broken. If there is more remarks/tags/etc please continue
An idea that just crossed my mind: A pin_user_pages_sgt might be useful for both rdma and drm, since this would avoid the possible huge interim struct pages array for thp pages. Or anything else that could be coalesced down into a single sg entry.
Not sure it's worth it, but would at least give a slightly neater interface I think.
-Daniel
Signature · 7 lines
Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch _______________________________________________ dri-devel mailing list [email protected] https://lists.freedesktop.org/mailman/listinfo/dri-devel
Quoted 36 lines · Daniel Vetter
Quoted 27 lines · Jason Gunthorpe
Quoted 26 lines · Leon Romanovsky
This series extends
__sg_alloc_table_from_pagesto allow chaining of new pages to already initialized SG table.This allows for the drivers to utilize the optimization of merging contiguous pages without a need to pre allocate all the pages and hold them in a very large temporary buffer prior to the call to SG table initialization.
The second patch changes the Infiniband driver to use the new API. It removes duplicate functionality from the code and benefits the optimization of allocating dynamic SG table from pages.
In huge pages system of 2MB page size, without this change, the SG table would contain x512 SG entries.
E.g. for 100GB memory registration:Number of entries Size
Before 26214400 600.0MB
After 51200 1.2MBThanks
Maor Gottlieb (2):
lib/scatterlist: Add support in dynamic allocation of SG table from
pages
RDMA/umem: Move to allocate SG table from pagesQuoted 7 lines
Quoted 3 lines
Tvrtko Ursulin (2):
tools/testing/scatterlist: Rejuvenate bit-rotten testtools/testing/scatterlist: Show errors in human readable formThis looks OK, I'm going to send it into linux-next on the hmm tree for awhile to see if anything gets broken. If there is more remarks/tags/etc please continue
Quoted 7 lines
An idea that just crossed my mind: A
pin_user_pages_sgtmight be useful for both rdma and drm, since this would avoid the possible huge interim struct pages array for thp pages. Or anything else that could be coalesced down into a single sg entry.Not sure it's worth it, but would at least give a slightly neater interface I think.
We've talked about it. Christoph wants to see this area move to a biovec interface instead of sgl, but it might still be worthwhile to have an interm step at least as an API consolidation.
Avoiding the page list would be complicated as we'd somehow have to code share the page table iterator scheme.
Jason
Quoted 42 lines · Jason Gunthorpe
Quoted 41 lines · Daniel Vetter
Quoted 27 lines · Jason Gunthorpe
Quoted 26 lines · Leon Romanovsky
This series extends
__sg_alloc_table_from_pagesto allow chaining of new pages to already initialized SG table.This allows for the drivers to utilize the optimization of merging contiguous pages without a need to pre allocate all the pages and hold them in a very large temporary buffer prior to the call to SG table initialization.
The second patch changes the Infiniband driver to use the new API. It removes duplicate functionality from the code and benefits the optimization of allocating dynamic SG table from pages.
In huge pages system of 2MB page size, without this change, the SG table would contain x512 SG entries.
E.g. for 100GB memory registration:Number of entries Size
Before 26214400 600.0MB
After 51200 1.2MBThanks
Maor Gottlieb (2):
lib/scatterlist: Add support in dynamic allocation of SG table from
pages
RDMA/umem: Move to allocate SG table from pagesQuoted 7 lines
Quoted 3 lines
Tvrtko Ursulin (2):
tools/testing/scatterlist: Rejuvenate bit-rotten testtools/testing/scatterlist: Show errors in human readable formThis looks OK, I'm going to send it into linux-next on the hmm tree for awhile to see if anything gets broken. If there is more remarks/tags/etc please continue
An idea that just crossed my mind: A
pin_user_pages_sgtmight be useful for both rdma and drm, since this would avoid the possible huge interim struct pages array for thp pages. Or anything else that could be coalesced down into a single sg entry.
Quoted 6 lines
Quoted 2 lines
Not sure it's worth it, but would at least give a slightly neater interface I think.
We've talked about it. Christoph wants to see this area move to a biovec interface instead of sgl, but it might still be worthwhile to have an interm step at least as an API consolidation.
Hm but then we'd need a new struct for the mapped side of things (which would still be what you get from dma-buf). That would be quite a bit of work to roll out everywhere, and sgt isn't such a huge misfit for passing buffer object mappings and system memory backing storage around, and hence what we (very slowly) converging drivers/gpu towards over the past 10 years or so.
And moving the dma_map step out of dma-buf doesn't work, because some of the use-cases we have is for very special iommus which are managed by the gpu driver directly. Stuff that e.g. rotates/retiles/compresses on the fly, and is accessible by other (gfx related like video code, camera, ..) devices. Not something I expect to ever be relevant for rdma since this exist mostly on some small soc, but it's a thing. Without that dma-buf could hand out biovec for struct_page backed stuff, or some pfn_vec for the p2p stuff.
Anyway was just an idea, I guess we'll have to live with some impedance mismatch since rolling out the one an only iovec structure which suits everyone is I think impossible :-)
Quoted 2 lines
Avoiding the page list would be complicated as we'd somehow have to code share the page table iterator scheme.
We're (slowly) getting towards thp for vram mappings and everything so I guess for drivers/gpu we might make that happen. But yeah it'd be not so pretty I think.
-Daniel
Signature · 3 lines
Daniel Vetter Software Engineer, Intel Corporation http://blog.ffwll.ch