radeon: use vmalloc instead of kmalloc
Subsystems (2)
PATCH 1/1 radeon: use vmalloc instead of kmalloc
We don't need to allocated contiguous pages in cs codepath so use vmalloc instead.
--- drivers/gpu/drm/radeon/radeon_cs.c | 20 ++++++++++---------- 1 files changed, 10 insertions(+), 10 deletions(-)
drivers/gpu/drm/radeon/radeon_cs.c +10 -10
@@ -45,11 +45,11 @@ int radeon_cs_parser_relocs(struct radeon_cs_parser *p) chunk = &p->chunks[p->chunk_relocs_idx];/* FIXME: we assume that each relocs use 4 dwords */ p->nrelocs = chunk->length_dw /4 ; - p->relocs_ptr =kcalloc (p->nrelocs,sizeof (void *),GFP_KERNEL ); + p->relocs_ptr =vmalloc (p->nrelocs *sizeof (void *));if (p->relocs_ptr ==NULL ) {return -ENOMEM ; } - p->relocs =kcalloc (p->nrelocs,sizeof (struct radeon_cs_reloc ),GFP_KERNEL ); + p->relocs =vmalloc (p->nrelocs *sizeof (struct radeon_cs_reloc ));if (p->relocs ==NULL ) {return -ENOMEM ; }
@@ -103,7 +103,7 @@ int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data) p->idx =0 ; p->chunk_ib_idx =-1 ; p->chunk_relocs_idx =-1 ; - p->chunks_array =kcalloc (cs->num_chunks,sizeof (uint64_t ),GFP_KERNEL ); + p->chunks_array =vmalloc (cs->num_chunks *sizeof (uint64_t ));if (p->chunks_array ==NULL ) {return -ENOMEM ; }
@@ -113,7 +113,7 @@ int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data)return -EFAULT ; } p->nchunks = cs->num_chunks; - p->chunks =kcalloc (p->nchunks,sizeof (struct radeon_cs_chunk ),GFP_KERNEL ); + p->chunks =vmalloc (p->nchunks *sizeof (struct radeon_cs_chunk ));if (p->chunks ==NULL ) {return -ENOMEM ; }
@@ -139,7 +139,7 @@ int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data) p->chunks[i].kdata =NULL ; size = p->chunks[i].length_dw *sizeof (uint32_t ); - p->chunks[i].kdata =kzalloc (size,GFP_KERNEL ); + p->chunks[i].kdata =vmalloc (size);if (p->chunks[i].kdata ==NULL ) {return -ENOMEM ; }
@@ -179,13 +179,13 @@ static void radeon_cs_parser_fini(struct radeon_cs_parser *parser, int error)mutex_unlock (&parser->rdev->ddev->struct_mutex); } } -kfree (parser->relocs); -kfree (parser->relocs_ptr); +vfree (parser->relocs); +vfree (parser->relocs_ptr);for (i =0 ; i < parser->nchunks; i++) { -kfree (parser->chunks[i].kdata); +vfree (parser->chunks[i].kdata); } -kfree (parser->chunks); -kfree (parser->chunks_array); +vfree (parser->chunks); +vfree (parser->chunks_array);radeon_ib_free (parser->rdev, &parser->ib); }
Signature · 1 line
1.6.2.2
Quoted 2 lines · Jerome Glisse
We don't need to allocated contiguous pages in cs codepath so use vmalloc instead.
Best would be to not require >PAGE_SIZE allocations at all of course. But barring that, it would be great to have something like:
ptr = kmalloc(size, GFP_KERNEL | __GFP_NOWARN);
if (!ptr)
ptr = vmalloc(size);Also, how long do these allocations live? vmalloc space can be quite limited (i386) and it can fragment too.
Quoted 69 lines
Signed-off-by Jerome Glisse <[email protected]>--- drivers/gpu/drm/radeon/radeon_cs.c | 20 ++++++++++---------- 1 files changed, 10 insertions(+), 10 deletions(-)drivers/gpu/drm/radeon/radeon_cs.c +10
-10@@ -45,11 +45,11 @@ int radeon_cs_parser_relocs(struct radeon_cs_parser *p) chunk = &p->chunks[p->chunk_relocs_idx];/* FIXME: we assume that each relocs use 4 dwords */ p->nrelocs = chunk->length_dw /4 ; - p->relocs_ptr =kcalloc (p->nrelocs,sizeof (void *),GFP_KERNEL ); + p->relocs_ptr =vmalloc (p->nrelocs *sizeof (void *));if (p->relocs_ptr ==NULL ) {return -ENOMEM ; } - p->relocs =kcalloc (p->nrelocs,sizeof (struct radeon_cs_reloc ),GFP_KERNEL ); + p->relocs =vmalloc (p->nrelocs *sizeof (struct radeon_cs_reloc ));if (p->relocs ==NULL ) {return -ENOMEM ; }@@ -103,7 +103,7 @@ int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data) p->idx =0 ; p->chunk_ib_idx =-1 ; p->chunk_relocs_idx =-1 ; - p->chunks_array =kcalloc (cs->num_chunks,sizeof (uint64_t ),GFP_KERNEL ); + p->chunks_array =vmalloc (cs->num_chunks *sizeof (uint64_t ));if (p->chunks_array ==NULL ) {return -ENOMEM ; }@@ -113,7 +113,7 @@ int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data)return -EFAULT ; } p->nchunks = cs->num_chunks; - p->chunks =kcalloc (p->nchunks,sizeof (struct radeon_cs_chunk ),GFP_KERNEL ); + p->chunks =vmalloc (p->nchunks *sizeof (struct radeon_cs_chunk ));if (p->chunks ==NULL ) {return -ENOMEM ; }@@ -139,7 +139,7 @@ int radeon_cs_parser_init(struct radeon_cs_parser *p, void *data) p->chunks[i].kdata =NULL ; size = p->chunks[i].length_dw *sizeof (uint32_t ); - p->chunks[i].kdata =kzalloc (size,GFP_KERNEL ); + p->chunks[i].kdata =vmalloc (size);if (p->chunks[i].kdata ==NULL ) {return -ENOMEM ; }@@ -179,13 +179,13 @@ static void radeon_cs_parser_fini(struct radeon_cs_parser *parser, int error)mutex_unlock (&parser->rdev->ddev->struct_mutex); } } -kfree (parser->relocs); -kfree (parser->relocs_ptr); +vfree (parser->relocs); +vfree (parser->relocs_ptr);for (i =0 ; i < parser->nchunks; i++) { -kfree (parser->chunks[i].kdata); +vfree (parser->chunks[i].kdata); } -kfree (parser->chunks); -kfree (parser->chunks_array); +vfree (parser->chunks); +vfree (parser->chunks_array);radeon_ib_free (parser->rdev, &parser->ib); }
Dave Airlie
maintainerQuoted 5 lines · Peter Zijlstra
Quoted 2 lines · Jerome Glisse
We don't need to allocated contiguous pages in cs codepath so use vmalloc instead.
Best would be to not require >PAGE_SIZE allocations at all of course.
It gets messy when you have copy from user and spinlocks, it would be nice to just parse the userspace PAGE_SIZE at a time, but it would mean dropping a lock we probably need to hold.
Quoted 5 lines
But barring that, it would be great to have something like:
ptr =
kmalloc(size, GFP_KERNEL | __GFP_NOWARN);
if (!ptr)
ptr = vmalloc(size);
we have a drm_calloc_large workaround already for the Intel driver which also need this.
Quoted 3 lines
Also, how long do these allocations live? vmalloc space can be quite limited (i386) and it can fragment too.
Only an ioctl lifetime so they aren't that bad. We however do have some vmaps that might be quite large, mainly the fbcon framebuffer (up to 8MB in some cases)
Dave.
Quoted 20 lines · Dave Airlie
Quoted 5 lines · Peter Zijlstra
Quoted 2 lines · Jerome Glisse
We don't need to allocated contiguous pages in cs codepath so use vmalloc instead.
Best would be to not require >PAGE_SIZE allocations at all of course.
It gets messy when you have copy from user and spinlocks, it would be nice to just parse the userspace
PAGE_SIZEat a time, but it would mean dropping a lock we probably need to hold.Quoted 5 lines
But barring that, it would be great to have something like:
ptr =
kmalloc(size, GFP_KERNEL | __GFP_NOWARN);
if (!ptr)
ptr = vmalloc(size);we have a
drm_calloc_largeworkaround already for the Intel driver which also need this.Quoted 1 line
Quoted 8 lines
Quoted 2 lines
Also, how long do these allocations live? vmalloc space can be quite limited (i386) and it can fragment too.
Only an ioctl lifetime so they aren't that bad. We however do have some vmaps that might be quite large, mainly the fbcon framebuffer (up to 8MB in some cases)
Dave.
I will rework cs parsing a bit see with what i can come up with. Forget this patch, i will get back with a new one.
Jerome
Quoted 10 lines · Dave Airlie
Quoted 5 lines · Peter Zijlstra
Quoted 2 lines · Jerome Glisse
We don't need to allocated contiguous pages in cs codepath so use vmalloc instead.
Best would be to not require >PAGE_SIZE allocations at all of course.
It gets messy when you have copy from user and spinlocks, it would be nice to just parse the userspace
PAGE_SIZEat a time, but it would mean dropping a lock we probably need to hold.
Can't you play tricks with refcounts?
Dave Airlie skrev:
Quoted 17 lines · Peter Zijlstra
Quoted 8 lines · Jerome Glisse
Quoted 4 lines
We don't need to allocated contiguous pages in cs codepath so use vmalloc instead.
Best would be to not require >PAGE_SIZE allocations at all of course.
It gets messy when you have copy from user and spinlocks, it would be nice to just parse the userspace
PAGE_SIZEat a time, but it would mean dropping a lock we probably need to hold.Quoted 2 lines
But barring that, it would be great to have something like:
Quoted 8 lines
Quoted 4 lines
ptr =
kmalloc(size, GFP_KERNEL | __GFP_NOWARN);
if (!ptr)
ptr = vmalloc(size);we have a
drm_calloc_largeworkaround already for the Intel driver which also need this.
One problem with multiple vmallocs per command submission is performance. Judging from previous work, drivers that are doing this tend to get very cpu-hungry. Since Radeon is only allowing a single process into the command submission path at once, what about pre-allocating a single larger vmalloced buffer at first command submission and take care to flush user-space before the submitted command stream gets too big.
Quoted 8 lines
Quoted 3 lines
Also, how long do these allocations live? vmalloc space can be quite limited (i386) and it can fragment too.
Only an ioctl lifetime so they aren't that bad. We however do have some vmaps that might be quite large, mainly the fbcon framebuffer (up to 8MB in some cases)
That one would be ioremapped, not vmapped right? Not that it matters because it's using vmalloc space anyway, but it wouldn't be worse than a traditionally ioremapped framebuffer.
Thomas
Quoted 13 lines
Dave.
------------------------------------------------------------------------------
Are you an open source citizen? Join us for the Open Source Bridge conference! Portland, OR, June 17-19. Two days of sessions, one day of unconference: $250. Need another reason to go? 24-hour hacker lounge. Register today!
http://ad.doubleclick.net/clk;215844324;13503038;v?http://opensourcebridge.org
--
_______________________________________________
Dri-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/dri-devel