FAQ Search Today's Posts Mark Forums Read
» Video Reviews

» Linux Archive

Linux-archive is a website aiming to archive linux email lists and to make them easily accessible for linux users/developers.


» Sponsor

» Partners

» Sponsor

Go Back   Linux Archive > Redhat > Cluster Development

 
 
LinkBack Thread Tools
 
Old 12-12-2007, 12:00 AM
Bob Peterson
 
Default Run through full bitmaps quicker in gfs2_bitfit

Hi,

I eliminated the passing of an unused parameter into gfs2_bitfit called rgd.

This also changes the gfs2_bitfit code that searches for free (or used) blocks.
Before, the code was trying to check for bytes that indicated 4 blocks in
the undesired state. The problem is, it was spending more time trying to
do this than it actually was saving. This version only optimizes the case
where we're looking for free blocks, and it checks a machine word at a time.
So on 32-bit machines, it will check 32-bits (16 blocks) and on 64-bit
machines, it will check 64-bits (32 blocks) at a time. The compiler
optimizes that quite well and we save some time, especially when running
through full bitmaps (like the bitmaps allocated for the journals).

There's probably a more elegant or optimized way to do this, but I haven't
thought of it yet. I'm open to suggestions.

Regards,

Bob Peterson
Red Hat GFS

Signed-off-by: Bob Peterson <rpeterso@redhat.com>
--
.../fs/gfs2/rgrp.c | 54 +++++++++++---------
70 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/gfs2-2.6.git.patch2/fs/gfs2/rgrp.c b/gfs2-2.6.git.patch3/fs/gfs2/rgrp.c
index e0ee195..d7ff9cf 100644
--- a/gfs2-2.6.git.patch2/fs/gfs2/rgrp.c
+++ b/gfs2-2.6.git.patch3/fs/gfs2/rgrp.c
@@ -126,41 +126,46 @@ static unsigned char gfs2_testbit(struct gfs2_rgrpd *rgd, unsigned char *buffer,
* Return: the block number (bitmap buffer scope) that was found
*/

-static u32 gfs2_bitfit(struct gfs2_rgrpd *rgd, unsigned char *buffer,
- unsigned int buflen, u32 goal,
- unsigned char old_state)
+static u32 gfs2_bitfit(unsigned char *buffer, unsigned int buflen, u32 goal,
+ unsigned char old_state)
{
- unsigned char *byte, *end, alloc;
+ unsigned char *byte;
u32 blk = goal;
- unsigned int bit;
+ unsigned int bit, bitlong;
+ unsigned long *plong, plong55;
+ static int c = 0;

byte = buffer + (goal / GFS2_NBBY);
+ plong = buffer + (goal / GFS2_NBBY);
bit = (goal % GFS2_NBBY) * GFS2_BIT_SIZE;
- end = buffer + buflen;
- alloc = (old_state == GFS2_BLKST_FREE) ? 0x55 : 0;
-
- while (byte < end) {
- /* If we're looking for a free block we can eliminate all
- bitmap settings with 0x55, which represents four data
- blocks in a row. If we're looking for a data block, we can
- eliminate 0x00 which corresponds to four free blocks. */
- if ((*byte & 0x55) == alloc) {
- blk += (8 - bit) >> 1;
-
- bit = 0;
- byte++;
-
+ bitlong = bit;
+#if BITS_PER_LONG == 32
+ plong55 = 0x55555555;
+#else
+ plong55 = 0x5555555555555555;
+#endif
+ while (byte < buffer + buflen) {
+
+ if (bitlong == 0 && old_state == 0 && *plong == plong55) {
+ plong++;
+ byte += sizeof(unsigned long);
+ blk += sizeof(unsigned long) * GFS2_NBBY;
continue;
}
-
- if (((*byte >> bit) & GFS2_BIT_MASK) == old_state)
+ if (((*byte >> bit) & GFS2_BIT_MASK) == old_state) {
+ c++;
return blk;
-
+ }
bit += GFS2_BIT_SIZE;
if (bit >= 8) {
bit = 0;
byte++;
}
+ bitlong += GFS2_BIT_SIZE;
+ if (bitlong >= sizeof(unsigned long) * 8) {
+ bitlong = 0;
+ plong++;
+ }

blk++;
}
@@ -1318,11 +1323,10 @@ static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
/* The GFS2_BLKST_UNLINKED state doesn't apply to the clone
bitmaps, so we must search the originals for that. */
if (old_state != GFS2_BLKST_UNLINKED && bi->bi_clone)
- blk = gfs2_bitfit(rgd, bi->bi_clone + bi->bi_offset,
+ blk = gfs2_bitfit(bi->bi_clone + bi->bi_offset,
bi->bi_len, goal, old_state);
else
- blk = gfs2_bitfit(rgd,
- bi->bi_bh->b_data + bi->bi_offset,
+ blk = gfs2_bitfit(bi->bi_bh->b_data + bi->bi_offset,
bi->bi_len, goal, old_state);
if (blk != BFITNOENT)
break;
 
Old 12-12-2007, 10:07 AM
Steven Whitehouse
 
Default Run through full bitmaps quicker in gfs2_bitfit

Hi,

fs/gfs2/rgrp.c: In function ‘gfs2_bitfit’:
fs/gfs2/rgrp.c:139: warning: assignment from incompatible pointer type

Please can you send me a fix for the above. Thanks,

Steve.


On Tue, 2007-12-11 at 19:00 -0600, Bob Peterson wrote:
> Hi,
>
> I eliminated the passing of an unused parameter into gfs2_bitfit called rgd.
>
> This also changes the gfs2_bitfit code that searches for free (or used) blocks.
> Before, the code was trying to check for bytes that indicated 4 blocks in
> the undesired state. The problem is, it was spending more time trying to
> do this than it actually was saving. This version only optimizes the case
> where we're looking for free blocks, and it checks a machine word at a time.
> So on 32-bit machines, it will check 32-bits (16 blocks) and on 64-bit
> machines, it will check 64-bits (32 blocks) at a time. The compiler
> optimizes that quite well and we save some time, especially when running
> through full bitmaps (like the bitmaps allocated for the journals).
>
> There's probably a more elegant or optimized way to do this, but I haven't
> thought of it yet. I'm open to suggestions.
>
> Regards,
>
> Bob Peterson
> Red Hat GFS
>
> Signed-off-by: Bob Peterson <rpeterso@redhat.com>
> --
> .../fs/gfs2/rgrp.c | 54 +++++++++++---------
> 70 files changed, 29 insertions(+), 25 deletions(-)
>
> diff --git a/gfs2-2.6.git.patch2/fs/gfs2/rgrp.c b/gfs2-2.6.git.patch3/fs/gfs2/rgrp.c
> index e0ee195..d7ff9cf 100644
> --- a/gfs2-2.6.git.patch2/fs/gfs2/rgrp.c
> +++ b/gfs2-2.6.git.patch3/fs/gfs2/rgrp.c
> @@ -126,41 +126,46 @@ static unsigned char gfs2_testbit(struct gfs2_rgrpd *rgd, unsigned char *buffer,
> * Return: the block number (bitmap buffer scope) that was found
> */
>
> -static u32 gfs2_bitfit(struct gfs2_rgrpd *rgd, unsigned char *buffer,
> - unsigned int buflen, u32 goal,
> - unsigned char old_state)
> +static u32 gfs2_bitfit(unsigned char *buffer, unsigned int buflen, u32 goal,
> + unsigned char old_state)
> {
> - unsigned char *byte, *end, alloc;
> + unsigned char *byte;
> u32 blk = goal;
> - unsigned int bit;
> + unsigned int bit, bitlong;
> + unsigned long *plong, plong55;
> + static int c = 0;
>
> byte = buffer + (goal / GFS2_NBBY);
> + plong = buffer + (goal / GFS2_NBBY);
> bit = (goal % GFS2_NBBY) * GFS2_BIT_SIZE;
> - end = buffer + buflen;
> - alloc = (old_state == GFS2_BLKST_FREE) ? 0x55 : 0;
> -
> - while (byte < end) {
> - /* If we're looking for a free block we can eliminate all
> - bitmap settings with 0x55, which represents four data
> - blocks in a row. If we're looking for a data block, we can
> - eliminate 0x00 which corresponds to four free blocks. */
> - if ((*byte & 0x55) == alloc) {
> - blk += (8 - bit) >> 1;
> -
> - bit = 0;
> - byte++;
> -
> + bitlong = bit;
> +#if BITS_PER_LONG == 32
> + plong55 = 0x55555555;
> +#else
> + plong55 = 0x5555555555555555;
> +#endif
> + while (byte < buffer + buflen) {
> +
> + if (bitlong == 0 && old_state == 0 && *plong == plong55) {
> + plong++;
> + byte += sizeof(unsigned long);
> + blk += sizeof(unsigned long) * GFS2_NBBY;
> continue;
> }
> -
> - if (((*byte >> bit) & GFS2_BIT_MASK) == old_state)
> + if (((*byte >> bit) & GFS2_BIT_MASK) == old_state) {
> + c++;
> return blk;
> -
> + }
> bit += GFS2_BIT_SIZE;
> if (bit >= 8) {
> bit = 0;
> byte++;
> }
> + bitlong += GFS2_BIT_SIZE;
> + if (bitlong >= sizeof(unsigned long) * 8) {
> + bitlong = 0;
> + plong++;
> + }
>
> blk++;
> }
> @@ -1318,11 +1323,10 @@ static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
> /* The GFS2_BLKST_UNLINKED state doesn't apply to the clone
> bitmaps, so we must search the originals for that. */
> if (old_state != GFS2_BLKST_UNLINKED && bi->bi_clone)
> - blk = gfs2_bitfit(rgd, bi->bi_clone + bi->bi_offset,
> + blk = gfs2_bitfit(bi->bi_clone + bi->bi_offset,
> bi->bi_len, goal, old_state);
> else
> - blk = gfs2_bitfit(rgd,
> - bi->bi_bh->b_data + bi->bi_offset,
> + blk = gfs2_bitfit(bi->bi_bh->b_data + bi->bi_offset,
> bi->bi_len, goal, old_state);
> if (blk != BFITNOENT)
> break;
>
>
 
Old 12-12-2007, 02:06 PM
Bob Peterson
 
Default Run through full bitmaps quicker in gfs2_bitfit

On Wed, 2007-12-12 at 11:07 +0000, Steven Whitehouse wrote:
> Hi,
>
> fs/gfs2/rgrp.c: In function ‘gfs2_bitfit’:
> fs/gfs2/rgrp.c:139: warning: assignment from incompatible pointer type
>
> Please can you send me a fix for the above. Thanks,
>
> Steve.

Hi,

Sorry about that. Here is a replacement for patch3 for the compile
error.

Note that the previous patch3 I sent also had some leftover useless
debug code in it (regarding static int c) which needed to be taken out.

Regards,

Bob Peterson
--
Signed-off-by: Bob Peterson <rpeterso@redhat.com>
--
.../fs/gfs2/rgrp.c | 49 ++++++++++----------
1 files changed, 25 insertions(+), 24 deletions(-)

diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index e0ee195..7a28339 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -126,41 +126,43 @@ static unsigned char gfs2_testbit(struct gfs2_rgrpd *rgd, unsigned char *buffer,
* Return: the block number (bitmap buffer scope) that was found
*/

-static u32 gfs2_bitfit(struct gfs2_rgrpd *rgd, unsigned char *buffer,
- unsigned int buflen, u32 goal,
- unsigned char old_state)
+static u32 gfs2_bitfit(unsigned char *buffer, unsigned int buflen, u32 goal,
+ unsigned char old_state)
{
- unsigned char *byte, *end, alloc;
+ unsigned char *byte;
u32 blk = goal;
- unsigned int bit;
+ unsigned int bit, bitlong;
+ unsigned long *plong, plong55;

byte = buffer + (goal / GFS2_NBBY);
+ plong = (unsigned long *)buffer + (goal / GFS2_NBBY);
bit = (goal % GFS2_NBBY) * GFS2_BIT_SIZE;
- end = buffer + buflen;
- alloc = (old_state == GFS2_BLKST_FREE) ? 0x55 : 0;
-
- while (byte < end) {
- /* If we're looking for a free block we can eliminate all
- bitmap settings with 0x55, which represents four data
- blocks in a row. If we're looking for a data block, we can
- eliminate 0x00 which corresponds to four free blocks. */
- if ((*byte & 0x55) == alloc) {
- blk += (8 - bit) >> 1;
-
- bit = 0;
- byte++;
-
+ bitlong = bit;
+#if BITS_PER_LONG == 32
+ plong55 = 0x55555555;
+#else
+ plong55 = 0x5555555555555555;
+#endif
+ while (byte < buffer + buflen) {
+
+ if (bitlong == 0 && old_state == 0 && *plong == plong55) {
+ plong++;
+ byte += sizeof(unsigned long);
+ blk += sizeof(unsigned long) * GFS2_NBBY;
continue;
}
-
if (((*byte >> bit) & GFS2_BIT_MASK) == old_state)
return blk;
-
bit += GFS2_BIT_SIZE;
if (bit >= 8) {
bit = 0;
byte++;
}
+ bitlong += GFS2_BIT_SIZE;
+ if (bitlong >= sizeof(unsigned long) * 8) {
+ bitlong = 0;
+ plong++;
+ }

blk++;
}
@@ -1318,11 +1320,10 @@ static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
/* The GFS2_BLKST_UNLINKED state doesn't apply to the clone
bitmaps, so we must search the originals for that. */
if (old_state != GFS2_BLKST_UNLINKED && bi->bi_clone)
- blk = gfs2_bitfit(rgd, bi->bi_clone + bi->bi_offset,
+ blk = gfs2_bitfit(bi->bi_clone + bi->bi_offset,
bi->bi_len, goal, old_state);
else
- blk = gfs2_bitfit(rgd,
- bi->bi_bh->b_data + bi->bi_offset,
+ blk = gfs2_bitfit(bi->bi_bh->b_data + bi->bi_offset,
bi->bi_len, goal, old_state);
if (blk != BFITNOENT)
break;
 
Old 01-21-2008, 08:21 AM
 
Default Run through full bitmaps quicker in gfs2_bitfit

From: Bob Peterson <rpeterso@redhat.com>

I eliminated the passing of an unused parameter into gfs2_bitfit called rgd.

This also changes the gfs2_bitfit code that searches for free (or used) blocks.
Before, the code was trying to check for bytes that indicated 4 blocks in
the undesired state. The problem is, it was spending more time trying to
do this than it actually was saving. This version only optimizes the case
where we're looking for free blocks, and it checks a machine word at a time.
So on 32-bit machines, it will check 32-bits (16 blocks) and on 64-bit
machines, it will check 64-bits (32 blocks) at a time. The compiler
optimizes that quite well and we save some time, especially when running
through full bitmaps (like the bitmaps allocated for the journals).

There's probably a more elegant or optimized way to do this, but I haven't
thought of it yet. I'm open to suggestions.

Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>

diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index e0ee195..d7ff9cf 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -126,41 +126,46 @@ static unsigned char gfs2_testbit(struct gfs2_rgrpd *rgd, unsigned char *buffer,
* Return: the block number (bitmap buffer scope) that was found
*/

-static u32 gfs2_bitfit(struct gfs2_rgrpd *rgd, unsigned char *buffer,
- unsigned int buflen, u32 goal,
- unsigned char old_state)
+static u32 gfs2_bitfit(unsigned char *buffer, unsigned int buflen, u32 goal,
+ unsigned char old_state)
{
- unsigned char *byte, *end, alloc;
+ unsigned char *byte;
u32 blk = goal;
- unsigned int bit;
+ unsigned int bit, bitlong;
+ unsigned long *plong, plong55;
+ static int c = 0;

byte = buffer + (goal / GFS2_NBBY);
+ plong = buffer + (goal / GFS2_NBBY);
bit = (goal % GFS2_NBBY) * GFS2_BIT_SIZE;
- end = buffer + buflen;
- alloc = (old_state == GFS2_BLKST_FREE) ? 0x55 : 0;
-
- while (byte < end) {
- /* If we're looking for a free block we can eliminate all
- bitmap settings with 0x55, which represents four data
- blocks in a row. If we're looking for a data block, we can
- eliminate 0x00 which corresponds to four free blocks. */
- if ((*byte & 0x55) == alloc) {
- blk += (8 - bit) >> 1;
-
- bit = 0;
- byte++;
-
+ bitlong = bit;
+#if BITS_PER_LONG == 32
+ plong55 = 0x55555555;
+#else
+ plong55 = 0x5555555555555555;
+#endif
+ while (byte < buffer + buflen) {
+
+ if (bitlong == 0 && old_state == 0 && *plong == plong55) {
+ plong++;
+ byte += sizeof(unsigned long);
+ blk += sizeof(unsigned long) * GFS2_NBBY;
continue;
}
-
- if (((*byte >> bit) & GFS2_BIT_MASK) == old_state)
+ if (((*byte >> bit) & GFS2_BIT_MASK) == old_state) {
+ c++;
return blk;
-
+ }
bit += GFS2_BIT_SIZE;
if (bit >= 8) {
bit = 0;
byte++;
}
+ bitlong += GFS2_BIT_SIZE;
+ if (bitlong >= sizeof(unsigned long) * 8) {
+ bitlong = 0;
+ plong++;
+ }

blk++;
}
@@ -1318,11 +1323,10 @@ static u32 rgblk_search(struct gfs2_rgrpd *rgd, u32 goal,
/* The GFS2_BLKST_UNLINKED state doesn't apply to the clone
bitmaps, so we must search the originals for that. */
if (old_state != GFS2_BLKST_UNLINKED && bi->bi_clone)
- blk = gfs2_bitfit(rgd, bi->bi_clone + bi->bi_offset,
+ blk = gfs2_bitfit(bi->bi_clone + bi->bi_offset,
bi->bi_len, goal, old_state);
else
- blk = gfs2_bitfit(rgd,
- bi->bi_bh->b_data + bi->bi_offset,
+ blk = gfs2_bitfit(bi->bi_bh->b_data + bi->bi_offset,
bi->bi_len, goal, old_state);
if (blk != BFITNOENT)
break;
--
1.5.1.2
 

Thread Tools




All times are GMT. The time now is 07:44 AM.

VBulletin, Copyright ©2000 - 2014, Jelsoft Enterprises Ltd.
Content Relevant URLs by vBSEO ©2007, Crawlability, Inc.
Copyright 2007 - 2008, www.linux-archive.org