Bug#21866029 HEAP ENGINE WASTES CPU RE-CALCULATING HASH VALUES

Tor Didriksen · Tor Didriksen · commit 1e139ad40235 · 2015-09-21T10:34:20.000+02:00
Problem: my_hash_sort_simple consumes lots of CPU
Solution: cache computed hash values
diff --git a/storage/heap/_check.c b/storage/heap/_check.c
@@ -1,5 +1,4 @@
-/* Copyright (c) 2000, 2002-2007 MySQL AB
-   Use is subject to license terms
+/* Copyright (c) 2000, 2015, Oracle and/or its affiliates. All rights reserved.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -111,18 +110,15 @@ static int check_one_key(HP_KEYDEF *keydef, uint keynr, ulong records,
   for (i=found=max_links=seek=0 ; i < records ; i++)
   {
     hash_info=hp_find_hash(&keydef->block,i);
-    if (hp_mask(hp_rec_hashnr(keydef, hash_info->ptr_to_rec),
-		blength,records) == i)
+    if (hp_mask(hash_info->hash, blength,records) == i)
     {
       found++;
       seek++;
       links=1;
       while ((hash_info=hash_info->next_key) && found < records + 1)
       {
 	seek+= ++links;
-	if ((rec_link = hp_mask(hp_rec_hashnr(keydef, hash_info->ptr_to_rec),
-			        blength, records))
-	    != i)
+	if (i != (rec_link= hp_mask(hash_info->hash, blength, records)))
 	{
 	  DBUG_PRINT("error",
                      ("Record in wrong link: Link %lu  Record: 0x%lx  Record-link %lu",
diff --git a/storage/heap/ha_heap.cc b/storage/heap/ha_heap.cc
@@ -680,7 +680,7 @@ heap_prepare_hp_create_info(TABLE *table_arg, bool internal_table,
     case HA_KEY_ALG_UNDEF:
     case HA_KEY_ALG_HASH:
       keydef[key].algorithm= HA_KEY_ALG_HASH;
-      mem_per_row+= sizeof(char*) * 2; // = sizeof(HASH_INFO)
+      mem_per_row+= sizeof(HASH_INFO);
       break;
     case HA_KEY_ALG_BTREE:
       keydef[key].algorithm= HA_KEY_ALG_BTREE;
diff --git a/storage/heap/heapdef.h b/storage/heap/heapdef.h
@@ -51,6 +51,7 @@ typedef struct st_hp_hash_info
 {
   struct st_hp_hash_info *next_key;
   uchar *ptr_to_rec;
+  ulong hash;                           /* Cached key hash value. */
 } HASH_INFO;
 
 typedef struct {
diff --git a/storage/heap/hp_delete.c b/storage/heap/hp_delete.c
@@ -149,8 +149,7 @@ int hp_delete_key(HP_INFO *info, HP_KEYDEF *keyinfo,
   else if (pos->next_key)
   {
     empty=pos->next_key;
-    pos->ptr_to_rec=empty->ptr_to_rec;
-    pos->next_key=empty->next_key;
+    *pos= *empty;
   }
   else
     keyinfo->hash_buckets--;
@@ -159,7 +158,7 @@ int hp_delete_key(HP_INFO *info, HP_KEYDEF *keyinfo,
     DBUG_RETURN (0);
 
   /* Move the last key (lastpos) */
-  lastpos_hashnr = hp_rec_hashnr(keyinfo, lastpos->ptr_to_rec);
+  lastpos_hashnr= lastpos->hash;
   /* pos is where lastpos should be */
   pos=hp_find_hash(&keyinfo->block, hp_mask(lastpos_hashnr, share->blength,
 					    share->records));
@@ -168,7 +167,7 @@ int hp_delete_key(HP_INFO *info, HP_KEYDEF *keyinfo,
     empty[0]=lastpos[0];
     DBUG_RETURN(0);
   }
-  pos_hashnr = hp_rec_hashnr(keyinfo, pos->ptr_to_rec);
+  pos_hashnr= pos->hash;
   /* pos3 is where the pos should be */
   pos3= hp_find_hash(&keyinfo->block,
 		     hp_mask(pos_hashnr, share->blength, share->records));
diff --git a/storage/heap/hp_test2.c b/storage/heap/hp_test2.c
@@ -64,7 +64,7 @@ int main(int argc, char *argv[])
   get_options(argc,argv);
 
   memset(&hp_create_info, 0, sizeof(hp_create_info));
-  hp_create_info.max_table_size= 1024L*1024L;
+  hp_create_info.max_table_size= 1024L * 1024L * 2;
   hp_create_info.keys= keys;
   hp_create_info.keydef= keyinfo;
   hp_create_info.reclength= reclength;
diff --git a/storage/heap/hp_write.c b/storage/heap/hp_write.c
@@ -166,6 +166,24 @@ static uchar *next_free_record_pos(HP_SHARE *info)
 }
 
 
+/**
+  Populate HASH_INFO structure.
+  
+  @param key           Pointer to a HASH_INFO key to be populated
+  @param next_key      HASH_INFO next_key value
+  @param ptr_to_rec    HASH_INFO ptr_to_rec value
+  @param hash          HASH_INFO hash value
+*/
+
+static inline void set_hash_key(HASH_INFO *key, HASH_INFO *next_key,
+                                uchar *ptr_to_rec, ulong hash)
+{
+  key->next_key= next_key;
+  key->ptr_to_rec= ptr_to_rec;
+  key->hash= hash;
+}
+
+
 /*
   Write a hash-key to the hash-index
   SYNOPSIS
@@ -198,6 +216,7 @@ int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo,
   int flag;
   ulong halfbuff,hashnr,first_index;
   uchar *ptr_to_rec= NULL, *ptr_to_rec2= NULL;
+  ulong hash1= 0, hash2= 0;
   HASH_INFO *empty, *gpos= NULL, *gpos2= NULL, *pos;
   DBUG_ENTER("hp_write_key");
 
@@ -227,7 +246,7 @@ int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo,
   {
     do
     {
-      hashnr = hp_rec_hashnr(keyinfo, pos->ptr_to_rec);
+      hashnr= pos->hash;
       if (flag == 0)
       {
         /* 
@@ -279,13 +298,13 @@ int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo,
 	  if (!(flag & LOWUSED))
 	  {
 	    /* Change link of previous lower-list key */
-	    gpos->ptr_to_rec=ptr_to_rec;
-	    gpos->next_key=pos;
+            set_hash_key(gpos, pos, ptr_to_rec, hash1);
 	    flag= (flag & HIGHFIND) | (LOWFIND | LOWUSED);
 	  }
 	  gpos=pos;
 	  ptr_to_rec=pos->ptr_to_rec;
 	}
+	hash1= pos->hash;
       }
       else
       {
@@ -303,13 +322,13 @@ int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo,
 	  if (!(flag & HIGHUSED))
 	  {
 	    /* Change link of previous upper-list key and save */
-	    gpos2->ptr_to_rec=ptr_to_rec2;
-	    gpos2->next_key=pos;
+	    set_hash_key(gpos2, pos, ptr_to_rec2, hash2);
 	    flag= (flag & LOWFIND) | (HIGHFIND | HIGHUSED);
 	  }
 	  gpos2=pos;
 	  ptr_to_rec2=pos->ptr_to_rec;
 	}
+	hash2= pos->hash;
       }
     }
     while ((pos=pos->next_key));
@@ -325,42 +344,36 @@ int hp_write_key(HP_INFO *info, HP_KEYDEF *keyinfo,
 
     if ((flag & (LOWFIND | LOWUSED)) == LOWFIND)
     {
-      gpos->ptr_to_rec=ptr_to_rec;
-      gpos->next_key=0;
+      set_hash_key(gpos, NULL, ptr_to_rec, hash1);
     }
     if ((flag & (HIGHFIND | HIGHUSED)) == HIGHFIND)
     {
-      gpos2->ptr_to_rec=ptr_to_rec2;
-      gpos2->next_key=0;
+      set_hash_key(gpos2, NULL, ptr_to_rec2, hash2);
     }
   }
   /* Check if we are at the empty position */
-
-  pos=hp_find_hash(&keyinfo->block, hp_mask(hp_rec_hashnr(keyinfo, record),
-					 share->blength, share->records + 1));
+  hash1= hp_rec_hashnr(keyinfo, record);
+  pos= hp_find_hash(&keyinfo->block, hp_mask(hash1, share->blength,
+                                             share->records + 1));
   if (pos == empty)
   {
-    pos->ptr_to_rec=recpos;
-    pos->next_key=0;
+    set_hash_key(pos, NULL, recpos, hash1);
     keyinfo->hash_buckets++;
   }
   else
   {
     /* Check if more records in same hash-nr family */
     empty[0]=pos[0];
-    gpos=hp_find_hash(&keyinfo->block,
-		      hp_mask(hp_rec_hashnr(keyinfo, pos->ptr_to_rec),
-			      share->blength, share->records + 1));
+    gpos= hp_find_hash(&keyinfo->block, hp_mask(pos->hash, share->blength,
+                                                share->records + 1));
     if (pos == gpos)
     {
-      pos->ptr_to_rec=recpos;
-      pos->next_key=empty;
+      set_hash_key(pos, empty, recpos, hash1);
     }
     else
     {
+      set_hash_key(pos, NULL, recpos, hash1);
       keyinfo->hash_buckets++;
-      pos->ptr_to_rec=recpos;
-      pos->next_key=0;
       hp_movelink(pos, gpos, empty);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,7 @@ typedef struct st_hp_hash_info`
`51`	`51`	`{`
`52`	`52`	`struct st_hp_hash_info *next_key;`
`53`	`53`	`uchar *ptr_to_rec;`
	`54`	`+ ulong hash; /* Cached key hash value. */`
`54`	`55`	`} HASH_INFO;`
`55`	`56`
`56`	`57`	`typedef struct {`
Original file line number	Diff line number	Diff line change
`@@ -166,6 +166,24 @@ static uchar next_free_record_pos(HP_SHARE info)`
`166`	`166`	`}`
`167`	`167`
`168`	`168`
	`169`	`+/**`
	`170`	`+ Populate HASH_INFO structure.`
	`171`	`+`
	`172`	`+ @param key Pointer to a HASH_INFO key to be populated`
	`173`	`+ @param next_key HASH_INFO next_key value`
	`174`	`+ @param ptr_to_rec HASH_INFO ptr_to_rec value`
	`175`	`+ @param hash HASH_INFO hash value`
	`176`	`+*/`
	`177`	`+`
	`178`	`+static inline void set_hash_key(HASH_INFO key, HASH_INFO next_key,`
	`179`	`+ uchar *ptr_to_rec, ulong hash)`
	`180`	`+{`
	`181`	`+ key->next_key= next_key;`
	`182`	`+ key->ptr_to_rec= ptr_to_rec;`
	`183`	`+ key->hash= hash;`
	`184`	`+}`
	`185`	`+`
	`186`	`+`
`169`	`187`	`/*`
`170`	`188`	`Write a hash-key to the hash-index`
`171`	`189`	`SYNOPSIS`
`@@ -198,6 +216,7 @@ int hp_write_key(HP_INFO info, HP_KEYDEF keyinfo,`
`198`	`216`	`int flag;`
`199`	`217`	`ulong halfbuff,hashnr,first_index;`
`200`	`218`	`uchar ptr_to_rec= NULL, ptr_to_rec2= NULL;`
	`219`	`+ ulong hash1= 0, hash2= 0;`
`201`	`220`	`HASH_INFO empty, gpos= NULL, gpos2= NULL, pos;`
`202`	`221`	`DBUG_ENTER("hp_write_key");`
`203`	`222`
`@@ -227,7 +246,7 @@ int hp_write_key(HP_INFO info, HP_KEYDEF keyinfo,`
`227`	`246`	`{`
`228`	`247`	`do`
`229`	`248`	`{`
`230`		`- hashnr = hp_rec_hashnr(keyinfo, pos->ptr_to_rec);`
	`249`	`+ hashnr= pos->hash;`
`231`	`250`	`if (flag == 0)`
`232`	`251`	`{`
`233`	`252`	`/*`
`@@ -279,13 +298,13 @@ int hp_write_key(HP_INFO info, HP_KEYDEF keyinfo,`
`279`	`298`	`if (!(flag & LOWUSED))`
`280`	`299`	`{`
`281`	`300`	`/* Change link of previous lower-list key */`
`282`		`- gpos->ptr_to_rec=ptr_to_rec;`
`283`		`- gpos->next_key=pos;`
	`301`	`+ set_hash_key(gpos, pos, ptr_to_rec, hash1);`
`284`	`302`	`flag= (flag & HIGHFIND) \| (LOWFIND \| LOWUSED);`
`285`	`303`	`}`
`286`	`304`	`gpos=pos;`
`287`	`305`	`ptr_to_rec=pos->ptr_to_rec;`
`288`	`306`	`}`
	`307`	`+ hash1= pos->hash;`
`289`	`308`	`}`
`290`	`309`	`else`
`291`	`310`	`{`
`@@ -303,13 +322,13 @@ int hp_write_key(HP_INFO info, HP_KEYDEF keyinfo,`
`303`	`322`	`if (!(flag & HIGHUSED))`
`304`	`323`	`{`
`305`	`324`	`/* Change link of previous upper-list key and save */`
`306`		`- gpos2->ptr_to_rec=ptr_to_rec2;`
`307`		`- gpos2->next_key=pos;`
	`325`	`+ set_hash_key(gpos2, pos, ptr_to_rec2, hash2);`
`308`	`326`	`flag= (flag & LOWFIND) \| (HIGHFIND \| HIGHUSED);`
`309`	`327`	`}`
`310`	`328`	`gpos2=pos;`
`311`	`329`	`ptr_to_rec2=pos->ptr_to_rec;`
`312`	`330`	`}`
	`331`	`+ hash2= pos->hash;`
`313`	`332`	`}`
`314`	`333`	`}`
`315`	`334`	`while ((pos=pos->next_key));`
`@@ -325,42 +344,36 @@ int hp_write_key(HP_INFO info, HP_KEYDEF keyinfo,`
`325`	`344`
`326`	`345`	`if ((flag & (LOWFIND \| LOWUSED)) == LOWFIND)`
`327`	`346`	`{`
`328`		`- gpos->ptr_to_rec=ptr_to_rec;`
`329`		`- gpos->next_key=0;`
	`347`	`+ set_hash_key(gpos, NULL, ptr_to_rec, hash1);`
`330`	`348`	`}`
`331`	`349`	`if ((flag & (HIGHFIND \| HIGHUSED)) == HIGHFIND)`
`332`	`350`	`{`
`333`		`- gpos2->ptr_to_rec=ptr_to_rec2;`
`334`		`- gpos2->next_key=0;`
	`351`	`+ set_hash_key(gpos2, NULL, ptr_to_rec2, hash2);`
`335`	`352`	`}`
`336`	`353`	`}`
`337`	`354`	`/* Check if we are at the empty position */`
`338`		`-`
`339`		`- pos=hp_find_hash(&keyinfo->block, hp_mask(hp_rec_hashnr(keyinfo, record),`
`340`		`- share->blength, share->records + 1));`
	`355`	`+ hash1= hp_rec_hashnr(keyinfo, record);`
	`356`	`+ pos= hp_find_hash(&keyinfo->block, hp_mask(hash1, share->blength,`
	`357`	`+ share->records + 1));`
`341`	`358`	`if (pos == empty)`
`342`	`359`	`{`
`343`		`- pos->ptr_to_rec=recpos;`
`344`		`- pos->next_key=0;`
	`360`	`+ set_hash_key(pos, NULL, recpos, hash1);`
`345`	`361`	`keyinfo->hash_buckets++;`
`346`	`362`	`}`
`347`	`363`	`else`
`348`	`364`	`{`
`349`	`365`	`/* Check if more records in same hash-nr family */`
`350`	`366`	`empty[0]=pos[0];`
`351`		`- gpos=hp_find_hash(&keyinfo->block,`
`352`		`- hp_mask(hp_rec_hashnr(keyinfo, pos->ptr_to_rec),`
`353`		`- share->blength, share->records + 1));`
	`367`	`+ gpos= hp_find_hash(&keyinfo->block, hp_mask(pos->hash, share->blength,`
	`368`	`+ share->records + 1));`
`354`	`369`	`if (pos == gpos)`
`355`	`370`	`{`
`356`		`- pos->ptr_to_rec=recpos;`
`357`		`- pos->next_key=empty;`
	`371`	`+ set_hash_key(pos, empty, recpos, hash1);`
`358`	`372`	`}`
`359`	`373`	`else`
`360`	`374`	`{`
	`375`	`+ set_hash_key(pos, NULL, recpos, hash1);`
`361`	`376`	`keyinfo->hash_buckets++;`
`362`		`- pos->ptr_to_rec=recpos;`
`363`		`- pos->next_key=0;`
`364`	`377`	`hp_movelink(pos, gpos, empty);`
`365`	`378`	`}`
`366`	`379`