Speed up of several procedures that rely on ERS, _mreallocz ('z'ero)

Made Possible Thanks to the Woonderful Haruna! <3
Commit also fixes an inconsistency in the ERS, where it'd start with clear memory but would use garbage upon resizing, also implements a new ERS option that clears entries as soon as pass by ers_free, so that they'll be all shinny for when ers_alloc reuses them.

Signed-off-by: shennetsind <ind@henn.et>

6 files changed, 52 insertions, 8 deletions

diff --git a/src/common/HPM.c b/src/common/HPM.c
index 8e41e5838..426fac94a 100644
--- a/src/common/HPM.c
+++ b/src/common/HPM.c
@@ -533,6 +533,9 @@ void* HPM_calloc(size_t num, size_t size, const char *file, int line, const char
 void* HPM_realloc(void *p, size_t size, const char *file, int line, const char *func) {
 	return iMalloc->realloc(p,size,HPM_file2ptr(file),line,func);
 }
+void* HPM_reallocz(void *p, size_t size, const char *file, int line, const char *func) {
+	return iMalloc->reallocz(p,size,HPM_file2ptr(file),line,func);
+}
 char* HPM_astrdup(const char *p, const char *file, int line, const char *func) {
 	return iMalloc->astrdup(p,HPM_file2ptr(file),line,func);
 }
@@ -705,6 +708,7 @@ void hpm_init(void) {
 	HPMiMalloc->malloc = HPM_mmalloc;
 	HPMiMalloc->calloc = HPM_calloc;
 	HPMiMalloc->realloc = HPM_realloc;
+	HPMiMalloc->reallocz = HPM_reallocz;
 	HPMiMalloc->astrdup = HPM_astrdup;
 
 	sscanf(HPM_VERSION, "%u.%u", &HPM->version[0], &HPM->version[1]);
diff --git a/src/common/db.c b/src/common/db.c
index ba3fef97b..efe7ca8b2 100644
--- a/src/common/db.c
+++ b/src/common/db.c
@@ -2446,7 +2446,7 @@ DBMap* db_alloc(const char *file, const char *func, int line, DBType type, DBOpt
 	db->free_lock = 0;
 	/* Other */
 	snprintf(ers_name, 50, "db_alloc:nodes:%s:%s:%d",func,file,line);
-	db->nodes = ers_new(sizeof(struct dbn),ers_name,ERS_OPT_WAIT|ERS_OPT_FREE_NAME);
+	db->nodes = ers_new(sizeof(struct dbn),ers_name,ERS_OPT_WAIT|ERS_OPT_FREE_NAME|ERS_OPT_CLEAN);
 	db->cmp = DB->default_cmp(type);
 	db->hash = DB->default_hash(type);
 	db->release = DB->default_release(type, options);
@@ -2609,8 +2609,8 @@ void* db_data2ptr(DBData *data)
  * @see #db_final(void)
  */
 void db_init(void) {
-	db_iterator_ers = ers_new(sizeof(struct DBIterator_impl),"db.c::db_iterator_ers",ERS_OPT_NONE);
-	db_alloc_ers = ers_new(sizeof(struct DBMap_impl),"db.c::db_alloc_ers",ERS_OPT_NONE);
+	db_iterator_ers = ers_new(sizeof(struct DBIterator_impl),"db.c::db_iterator_ers",ERS_OPT_CLEAN);
+	db_alloc_ers = ers_new(sizeof(struct DBMap_impl),"db.c::db_alloc_ers",ERS_OPT_CLEAN);
 	ers_chunk_size(db_alloc_ers, 50);
 	DB_COUNTSTAT(db_init);
 }
diff --git a/src/common/ers.c b/src/common/ers.c
index 22269a51f..a7dad49ab 100644
--- a/src/common/ers.c
+++ b/src/common/ers.c
@@ -40,6 +40,7 @@
  * @see common#ers.h                                                         *
 \*****************************************************************************/
 #include <stdlib.h>
+#include <string.h>
 
 #include "../common/cbasetypes.h"
 #include "../common/malloc.h" // CREATE, RECREATE, aMalloc, aFree
@@ -238,6 +239,9 @@ static void ers_obj_free_entry(ERS self, void *entry)
 		return;
 	}
 
+	if( instance->Options & ERS_OPT_CLEAN )
+		memset((unsigned char*)reuse + sizeof(struct ers_list), 0, instance->Cache->ObjectSize - sizeof(struct ers_list));
+	
 	reuse->Next = instance->Cache->ReuseList;
 	instance->Cache->ReuseList = reuse;
 	instance->Count--;
diff --git a/src/common/ers.h b/src/common/ers.h
index 4ff2a6230..e63711b81 100644
--- a/src/common/ers.h
+++ b/src/common/ers.h
@@ -71,10 +71,11 @@
 #endif /* not ERS_ALIGN_ENTRY */
 
 enum ERSOptions {
-	ERS_OPT_NONE		= 0x0,
-	ERS_OPT_CLEAR		= 0x1,/* silently clears any entries left in the manager upon destruction */
-	ERS_OPT_WAIT		= 0x2,/* wait for entries to come in order to list! */
-	ERS_OPT_FREE_NAME	= 0x4,/* name is dynamic memory, and should be freed */
+	ERS_OPT_NONE        = 0x0,
+	ERS_OPT_CLEAR       = 0x1,/* silently clears any entries left in the manager upon destruction */
+	ERS_OPT_WAIT        = 0x2,/* wait for entries to come in order to list! */
+	ERS_OPT_FREE_NAME   = 0x4,/* name is dynamic memory, and should be freed */
+	ERS_OPT_CLEAN       = 0x8,/* clears used memory upon ers_free so that its all new to be reused on the next alloc */
 };
 
 /**
diff --git a/src/common/malloc.c b/src/common/malloc.c
index 23e28a65f..875b87a15 100644
--- a/src/common/malloc.c
+++ b/src/common/malloc.c
@@ -369,6 +369,37 @@ void* _mrealloc(void *memblock, size_t size, const char *file, int line, const c
 	}
 }
 
+/* a _mrealloc clone with the difference it 'z'eroes the newly created memory */
+void* _mreallocz(void *memblock, size_t size, const char *file, int line, const char *func ) {
+	size_t old_size;
+	void *p = NULL;
+	
+	if(memblock == NULL) {
+		p = iMalloc->malloc(size,file,line,func);
+		memset(p,0,size);
+		return p;
+	}
+	
+	old_size = ((struct unit_head *)((char *)memblock - sizeof(struct unit_head) + sizeof(long)))->size;
+	if( old_size == 0 ) {
+		old_size = ((struct unit_head_large *)((char *)memblock - sizeof(struct unit_head_large) + sizeof(long)))->size;
+	}
+	if(old_size > size) {
+		// Size reduction - return> as it is (negligence)
+		return memblock;
+	}  else {
+		// Size Large
+		p = iMalloc->malloc(size,file,line,func);
+		if(p != NULL) {
+			memcpy(p,memblock,old_size);
+			memset(p+old_size,0,size-old_size);
+		}
+		iMalloc->free(memblock,file,line,func);
+		return p;
+	}
+}
+
+
 char* _mstrdup(const char *p, const char *file, int line, const char *func )
 {
 	if(p == NULL) {
@@ -822,12 +853,14 @@ void malloc_defaults(void) {
 	iMalloc->malloc  =	 _mmalloc;
 	iMalloc->calloc  =	 _mcalloc;
 	iMalloc->realloc =	 _mrealloc;
+	iMalloc->reallocz=	 _mreallocz;
 	iMalloc->astrdup =	 _mstrdup;
 	iMalloc->free    =	 _mfree;
 #else
 	iMalloc->malloc  =	aMalloc_;
 	iMalloc->calloc  =	aCalloc_;
 	iMalloc->realloc =	aRealloc_;
+	iMalloc->reallocz=	aRealloc_;/* not using memory manager huhum o.o perhaps we could still do something about */
 	iMalloc->astrdup =	aStrdup_;
 	iMalloc->free    =	aFree_;
 #endif
diff --git a/src/common/malloc.h b/src/common/malloc.h
index cd0ef238b..19b5213bb 100644
--- a/src/common/malloc.h
+++ b/src/common/malloc.h
@@ -33,6 +33,7 @@
 #	define aMalloc(n)    (iMalloc->malloc((n),ALC_MARK))
 #	define aCalloc(m,n)  (iMalloc->calloc((m),(n),ALC_MARK))
 #	define aRealloc(p,n) (iMalloc->realloc((p),(n),ALC_MARK))
+#	define aReallocz(p,n) (iMalloc->reallocz((p),(n),ALC_MARK))
 #	define aStrdup(p)    (iMalloc->astrdup((p),ALC_MARK))
 #	define aFree(p)      (iMalloc->free((p),ALC_MARK))
 
@@ -54,7 +55,7 @@
 ////////////// Others //////////////////////////
 // should be merged with any of above later
 #define CREATE(result, type, number) ((result) = (type *) aCalloc((number), sizeof(type)))
-#define RECREATE(result, type, number) ((result) = (type *) aRealloc((result), sizeof(type) * (number)))
+#define RECREATE(result, type, number) ((result) = (type *) aReallocz((result), sizeof(type) * (number)))
 
 ////////////////////////////////////////////////
 
@@ -73,6 +74,7 @@ struct malloc_interface {
 	void* (*malloc	)(size_t size, const char *file, int line, const char *func);
 	void* (*calloc	)(size_t num, size_t size, const char *file, int line, const char *func);
 	void* (*realloc	)(void *p, size_t size, const char *file, int line, const char *func);
+	void* (*reallocz)(void *p, size_t size, const char *file, int line, const char *func);
 	char* (*astrdup	)(const char *p, const char *file, int line, const char *func);
 	void  (*free	)(void *p, const char *file, int line, const char *func);
 	/* */