Bug#18846682: REPLACE MALLOC+MEMSET WITH CALLOC

Use calloc() rather than malloc() + memset(..., 0, ...).
Microbenchmark shows this is faster for both glibc malloc and jemalloc.

Author: jhauglid

mysys/my_malloc.c

@@ -154,7 +154,11 @@ void *my_raw_malloc(size_t size, myf my_flags)
   if (!size)
     size=1;
 
-  point= malloc(size);
+  if (my_flags & MY_ZEROFILL)
+    point= calloc(size, 1);
+  else
+    point= malloc(size);
+
   DBUG_EXECUTE_IF("simulate_out_of_memory",
                   {
                     free(point);
@@ -179,8 +183,7 @@ void *my_raw_malloc(size_t size, myf my_flags)
     if (my_flags & MY_FAE)
       exit(1);
   }
-  else if (my_flags & MY_ZEROFILL)
-    memset(point, 0, size);
+
   DBUG_PRINT("exit",("ptr: %p", point));
   DBUG_RETURN(point);
 }

storage/innobase/fts/fts0ast.cc

@@ -50,8 +50,7 @@ fts_ast_node_create(void)
 {
 	fts_ast_node_t*	node;
 
-	node = (fts_ast_node_t*) ut_malloc(sizeof(*node));
-	memset(node, 0x0, sizeof(*node));
+	node = (fts_ast_node_t*) ut_zalloc(sizeof(*node));
 
 	return(node);
 }

storage/innobase/fts/fts0que.cc

@@ -3675,9 +3675,7 @@ fts_query_prepare_result(
 	bool			result_is_null = false;
 
 	if (result == NULL) {
-		result = static_cast<fts_result_t*>(ut_malloc(sizeof(*result)));
-
-		memset(result, 0x0, sizeof(*result));
+		result = static_cast<fts_result_t*>(ut_zalloc(sizeof(*result)));
 
 		result->rankings_by_id = rbt_create(
 			sizeof(fts_ranking_t), fts_ranking_doc_id_cmp);
@@ -3781,8 +3779,7 @@ fts_query_get_result(
 		result = fts_query_prepare_result(query, result);
 	} else {
 		/* Create an empty result instance. */
-		result = static_cast<fts_result_t*>(ut_malloc(sizeof(*result)));
-		memset(result, 0, sizeof(*result));
+		result = static_cast<fts_result_t*>(ut_zalloc(sizeof(*result)));
 	}
 
 	return(result);
@@ -4185,8 +4182,7 @@ fts_query(
 	} else {
 		/* still return an empty result set */
 		*result = static_cast<fts_result_t*>(
-			ut_malloc(sizeof(**result)));
-		memset(*result, 0, sizeof(**result));
+			ut_zalloc(sizeof(**result)));
 	}
 
 	ut_free(lc_query_str);

storage/innobase/gis/gis0sea.cc

@@ -905,8 +905,7 @@ rtr_create_rtr_info(
 	index = index ? index : cursor->index;
 	ut_ad(index);
 
-	rtr_info = static_cast<rtr_info_t*>(ut_malloc(sizeof(*rtr_info)));
-	memset(rtr_info, 0, sizeof(*rtr_info));
+	rtr_info = static_cast<rtr_info_t*>(ut_zalloc(sizeof(*rtr_info)));
 
 	rtr_info->allocated = true;
 	rtr_info->cursor = cursor;

storage/innobase/include/buf0buf.ic

@@ -778,8 +778,8 @@ buf_page_alloc_descriptor(void)
 {
 	buf_page_t*	bpage;
 
-	bpage = (buf_page_t*) ut_malloc(sizeof *bpage);
-	ut_d(memset(bpage, 0, sizeof *bpage));
+	bpage = (buf_page_t*) ut_zalloc(sizeof *bpage);
+	ut_ad(bpage);
 	UNIV_MEM_ALLOC(bpage, sizeof *bpage);
 
 	return(bpage);

storage/innobase/log/log0recv.cc

@@ -3509,8 +3509,7 @@ recv_reset_log_files_for_backup(
 	*/
 	ut_a(log_dir_len + strlen(ib_logfile_basename) + 11  < sizeof(name));
 
-	buf = ut_malloc(LOG_FILE_HDR_SIZE + OS_FILE_LOG_BLOCK_SIZE);
-	memset(buf, '\0', LOG_FILE_HDR_SIZE + OS_FILE_LOG_BLOCK_SIZE);
+	buf = ut_zalloc(LOG_FILE_HDR_SIZE + OS_FILE_LOG_BLOCK_SIZE);
 
 	for (i = 0; i < n_log_files; i++) {
 

storage/innobase/os/os0file.cc

@@ -3663,8 +3663,7 @@ os_aio_array_create(
 	ut_a(n > 0);
 	ut_a(n_segments > 0);
 
-	array = static_cast<os_aio_array_t*>(ut_malloc(sizeof(*array)));
-	memset(array, 0x0, sizeof(*array));
+	array = static_cast<os_aio_array_t*>(ut_zalloc(sizeof(*array)));
 
 	mutex_create("os_aio_mutex", &array->mutex);
 
@@ -3677,9 +3676,8 @@ os_aio_array_create(
 	array->n_segments = n_segments;
 
 	array->slots = static_cast<os_aio_slot_t*>(
-		ut_malloc(n * sizeof(*array->slots)));
+		ut_zalloc(n * sizeof(*array->slots)));
 
-	memset(array->slots, 0x0, sizeof(n * sizeof(*array->slots)));
 #ifdef _WIN32
 	array->handles = static_cast<HANDLE*>(ut_malloc(n * sizeof(HANDLE)));
 #endif /* _WIN32 */
@@ -3715,9 +3713,8 @@ os_aio_array_create(
 
 	/* Initialize the event array. One event per slot. */
 	io_event = static_cast<struct io_event*>(
-		ut_malloc(n * sizeof(*io_event)));
+		ut_zalloc(n * sizeof(*io_event)));
 
-	memset(io_event, 0x0, sizeof(*io_event) * n);
 	array->aio_events = io_event;
 
 skip_native_aio:

storage/innobase/ut/ut0bh.cc

@@ -46,8 +46,7 @@ ib_bh_create(
 
 	sz = sizeof(*ib_bh) + (sizeof_elem * max_elems);
 
-	ib_bh = (ib_bh_t*) ut_malloc(sz);
-	memset(ib_bh, 0x0, sz);
+	ib_bh = (ib_bh_t*) ut_zalloc(sz);
 
 	ib_bh->compare = compare;
 	ib_bh->max_elems = max_elems;

storage/innobase/ut/ut0mem.cc

@@ -88,7 +88,31 @@ void*
 ut_zalloc(
 	ulint	size)
 {
-	return(memset(ut_malloc(size), 0, size));
+	void*	ptr = calloc(size, 1);
+
+	for (int retry = 1; ; retry++) {
+		if (ptr != NULL) {
+			return(ptr);
+		}
+		if (retry > max_attempts) {
+			break;
+		}
+
+		/* Sleep for a second and retry the allocation;
+		maybe this is just a temporary shortage of memory */
+
+		os_thread_sleep(1000000);
+
+		ptr = calloc(size, 1);
+	}
+
+	ib_logf(IB_LOG_LEVEL_FATAL,
+		"Cannot allocate " ULINTPF " bytes of memory after %d"
+		" tries over %d seconds. OS error: %d-%s. %s",
+		size, max_attempts, max_attempts,
+		errno, strerror(errno), OUT_OF_MEMORY_MSG);
+
+	return(NULL);
 }
 
 /**********************************************************************//**

storage/innobase/ut/ut0rbt.cc

@@ -799,22 +799,19 @@ rbt_create(
 	ib_rbt_t*	tree;
 	ib_rbt_node_t*	node;
 
-	tree = (ib_rbt_t*) ut_malloc(sizeof(*tree));
-	memset(tree, 0, sizeof(*tree));
+	tree = (ib_rbt_t*) ut_zalloc(sizeof(*tree));
 
 	tree->sizeof_value = sizeof_value;
 
 	/* Create the sentinel (NIL) node. */
-	node = tree->nil = (ib_rbt_node_t*) ut_malloc(sizeof(*node));
-	memset(node, 0, sizeof(*node));
+	node = tree->nil = (ib_rbt_node_t*) ut_zalloc(sizeof(*node));
 
 	node->color = IB_RBT_BLACK;
 	node->parent = node->left = node->right = node;
 
 	/* Create the "fake" root, the real root node will be the
 	left child of this node. */
-	node = tree->root = (ib_rbt_node_t*) ut_malloc(sizeof(*node));
-	memset(node, 0, sizeof(*node));
+	node = tree->root = (ib_rbt_node_t*) ut_zalloc(sizeof(*node));
 
 	node->color = IB_RBT_BLACK;
 	node->parent = node->left = node->right = tree->nil;

unittest/gunit/CMakeLists.txt

@@ -232,6 +232,7 @@ SET(TESTS
   bounds_checked_array
   bitmap
   byteorder
+  calloc
   cost_estimate
   dbug
   decimal

unittest/gunit/calloc-t.cc

@@ -0,0 +1,96 @@
+/* Copyright (c) 2014, 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
+   the Free Software Foundation; version 2 of the License.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA */
+
+// First include (the generated) my_config.h, to get correct platform defines.
+#include "my_config.h"
+#include <gtest/gtest.h>
+
+#include <stdlib.h>
+#include <string.h>
+
+namespace calloc_unittest {
+
+/*
+  Set num_iterations to a reasonable value (e.g. 200000), build release
+  and run with 'calloc-t --disable-tap-output' to see the time taken.
+*/
+#if !defined(DBUG_OFF)
+// There is no point in benchmarking anything in debug mode.
+static int num_iterations= 2;
+#else
+// Set this so that each test case takes a few seconds.
+// And set it back to a small value before pushing!!
+static int num_iterations= 2000;
+#endif
+
+
+class CallocTest : public ::testing::Test
+{
+protected:
+  CallocTest() { };
+
+  void malloc_test(int count);
+  void calloc_test(int count);
+};
+
+
+void CallocTest::malloc_test(int count)
+{
+  for (int i= 1; i <= count; i++)
+  {
+    size_t size= i * 10;
+    void *rawmem1= malloc(size);
+    memset(rawmem1, 0, size);
+    void *rawmem2= malloc(size);
+    memset(rawmem2, 0, size);
+    // We need to prevent the optimizer from removing the whole loop.
+    EXPECT_FALSE(memcmp(rawmem1, rawmem2, 1));
+    free(rawmem1);
+    free(rawmem2);
+  }
+}
+
+
+void CallocTest::calloc_test(int count)
+{
+  for (int i= 1; i <= count; i++)
+  {
+    size_t size= i * 10;
+    void *rawmem1= calloc(size, 1);
+    void *rawmem2= calloc(size, 1);
+    // We need to prevent the optimizer from removing the whole loop.
+    EXPECT_FALSE(memcmp(rawmem1, rawmem2, 1));
+    free(rawmem1);
+    free(rawmem2);
+  }
+}
+
+
+TEST_F(CallocTest, WarmupTest)
+{
+  calloc_test(num_iterations);
+}
+
+TEST_F(CallocTest, MallocTest)
+{
+  malloc_test(num_iterations);
+}
+
+TEST_F(CallocTest, CallocTest)
+{
+  calloc_test(num_iterations);
+}
+
+}