Allow UNIV_SYNC_DEBUG to be disabled while UNIV_DEBUG is enabled

3 files changed, 62 insertions, 69 deletions

diff --git a/innobase/sync/sync0arr.c b/innobase/sync/sync0arr.c
index 06e9fdcd63d..dbfac6ac086 100644
--- a/innobase/sync/sync0arr.c
+++ b/innobase/sync/sync0arr.c
@@ -100,6 +100,7 @@ struct sync_array_struct {
 					since creation of the array */
 };
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 This function is called only in the debug version. Detects a deadlock
 of one or more threads because of waits of semaphores. */
@@ -113,6 +114,7 @@ sync_array_detect_deadlock(
 	sync_cell_t*	start,	/* in: cell where recursive search started */
 	sync_cell_t*	cell,	/* in: cell to search */
 	ulint		depth);	/* in: recursion depth */
+#endif /* UNIV_SYNC_DEBUG */
 
 /*********************************************************************
 Gets the nth cell in array. */
@@ -464,12 +466,17 @@ sync_array_cell_print(
 		mutex = cell->old_wait_mutex;
 
 		buf += sprintf(buf,
-		"Mutex at %lx created file %s line %lu, lock var %lu\n",
-			(ulint)mutex, mutex->cfile_name, mutex->cline,
-							mutex->lock_word);
-		buf += sprintf(buf,
-		"Last time reserved in file %s line %lu, waiters flag %lu\n",
-			mutex->file_name, mutex->line, mutex->waiters);
+			"Mutex at %p created file %s line %lu, lock var %lu\n"
+#ifdef UNIV_SYNC_DEBUG
+			"Last time reserved in file %s line %lu, "
+#endif /* UNIV_SYNC_DEBUG */
+			"waiters flag %lu\n",
+			mutex, mutex->cfile_name, mutex->cline,
+			mutex->lock_word,
+#ifdef UNIV_SYNC_DEBUG
+			mutex->file_name, mutex->line,
+#endif /* UNIV_SYNC_DEBUG */
+			mutex->waiters);
 
 	} else if (type == RW_LOCK_EX || type == RW_LOCK_SHARED) {
 
@@ -518,6 +525,7 @@ sync_array_cell_print(
 	}
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Looks for a cell with the given thread id. */
 static
@@ -689,7 +697,6 @@ sync_array_detect_deadlock(
 				sync_array_cell_print(buf, cell);
 				printf("rw-lock %lx %s ", (ulint) lock, buf);
 				rw_lock_debug_print(debug);
-
 				return(TRUE);
 			}
 		}
@@ -739,6 +746,7 @@ sync_array_detect_deadlock(
 	return(TRUE); 	/* Execution never reaches this line: for compiler
 			fooling only */
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Determines if we can wake up the thread waiting for a sempahore. */
diff --git a/innobase/sync/sync0rw.c b/innobase/sync/sync0rw.c
index fd52d5aac2e..86924c437c7 100644
--- a/innobase/sync/sync0rw.c
+++ b/innobase/sync/sync0rw.c
@@ -31,6 +31,7 @@ ulint	rw_x_exit_count		= 0;
 rw_lock_list_t	rw_lock_list;
 mutex_t		rw_lock_list_mutex;
 
+#ifdef UNIV_SYNC_DEBUG
 /* The global mutex which protects debug info lists of all rw-locks.
 To modify the debug info list of an rw-lock, this mutex has to be
 acquired in addition to the mutex protecting the lock. */
@@ -76,6 +77,7 @@ rw_lock_debug_free(
 {
 	mem_free(info);
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Creates, or rather, initializes an rw-lock object in a specified memory
@@ -107,10 +109,12 @@ rw_lock_create_func(
 
 	lock->writer_is_wait_ex = FALSE;
 
+#ifdef UNIV_SYNC_DEBUG
 	UT_LIST_INIT(lock->debug_list);
 
-	lock->magic_n = RW_LOCK_MAGIC_N;
 	lock->level = SYNC_LEVEL_NONE;
+#endif /* UNIV_SYNC_DEBUG */
+	lock->magic_n = RW_LOCK_MAGIC_N;
 	
 	lock->cfile_name = cfile_name;
 	lock->cline = cline;
@@ -307,8 +311,9 @@ rw_lock_x_lock_low(
 	char*		file_name,/* in: file name where lock requested */
 	ulint		line)	/* in: line where requested */
 {
+#ifdef UNIV_SYNC_DEBUG
 	ut_ad(mutex_own(rw_lock_get_mutex(lock)));
-
+#endif /* UNIV_SYNC_DEBUG */
 	if (rw_lock_get_writer(lock) == RW_LOCK_NOT_LOCKED) {
 
 		if (rw_lock_get_reader_count(lock) == 0) {
@@ -516,6 +521,7 @@ lock_loop:
         goto lock_loop;
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Acquires the debug mutex. We cannot use the mutex defined in sync0sync,
 because the debug mutex is also acquired in sync0arr while holding the OS
@@ -641,6 +647,7 @@ rw_lock_remove_debug_info(
 
 	ut_error;
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Sets the rw-lock latching level field. */
@@ -654,6 +661,7 @@ rw_lock_set_level(
 	lock->level = level;
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Checks if the thread has locked the rw-lock in the specified mode, with
 the pass value == 0. */
@@ -671,9 +679,6 @@ rw_lock_own(
 	ut_ad(lock);
 	ut_ad(rw_lock_validate(lock));
 
-#ifndef UNIV_SYNC_DEBUG
-	ut_error;
-#endif	
 	mutex_enter(&(lock->mutex));
 
 	info = UT_LIST_GET_FIRST(lock->debug_list);
@@ -696,6 +701,7 @@ rw_lock_own(
 
 	return(FALSE);
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Checks if somebody has locked the rw-lock in the specified mode. */
@@ -732,6 +738,7 @@ rw_lock_is_locked(
 	return(ret);
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /*******************************************************************
 Prints debug info of currently locked rw-locks. */
 
@@ -739,8 +746,6 @@ void
 rw_lock_list_print_info(void)
 /*=========================*/
 {
-#ifndef UNIV_SYNC_DEBUG
-#else
 	rw_lock_t*	lock;
 	ulint		count		= 0;
 	rw_lock_debug_t* info;
@@ -784,7 +789,6 @@ rw_lock_list_print_info(void)
 
 	printf("Total number of rw-locks %ld\n", count);
 	mutex_exit(&rw_lock_list_mutex);
-#endif
 }
 
 /*******************************************************************
@@ -795,11 +799,6 @@ rw_lock_print(
 /*==========*/
 	rw_lock_t*	lock __attribute__((unused)))	/* in: rw-lock */
 {
-#ifndef UNIV_SYNC_DEBUG
-	printf(
-	   "Sorry, cannot give rw-lock info in non-debug version!\n");
-#else
-	ulint		count		= 0;
 	rw_lock_debug_t* info;
 	
 	printf("-------------\n");
@@ -822,7 +821,6 @@ rw_lock_print(
 			info = UT_LIST_GET_NEXT(list, info);
 		}
 	}
-#endif
 }
 
 /*************************************************************************
@@ -862,12 +860,6 @@ ulint
 rw_lock_n_locked(void)
 /*==================*/
 {
-#ifndef UNIV_SYNC_DEBUG
-	printf(
-	   "Sorry, cannot give rw-lock info in non-debug version!\n");
-	ut_error;
-	return(0);
-#else
 	rw_lock_t*	lock;
 	ulint		count		= 0;
 	
@@ -890,5 +882,5 @@ rw_lock_n_locked(void)
 	mutex_exit(&rw_lock_list_mutex);
 
 	return(count);
-#endif
 }
+#endif /* UNIV_SYNC_DEBUG */
diff --git a/innobase/sync/sync0sync.c b/innobase/sync/sync0sync.c
index 178511b8996..4f5d27bcc7c 100644
--- a/innobase/sync/sync0sync.c
+++ b/innobase/sync/sync0sync.c
@@ -188,8 +188,10 @@ mutex_create_func(
 #endif
 	mutex_set_waiters(mutex, 0);
 	mutex->magic_n = MUTEX_MAGIC_N;
+#ifdef UNIV_SYNC_DEBUG
 	mutex->line = 0;
 	mutex->file_name = (char *) "not yet reserved";
+#endif /* UNIV_SYNC_DEBUG */
 	mutex->level = SYNC_LEVEL_NONE;
 	mutex->cfile_name = cfile_name;
 	mutex->cline = cline;
@@ -253,9 +255,11 @@ mutex_enter_nowait(
 /*===============*/
 					/* out: 0 if succeed, 1 if not */
 	mutex_t*	mutex,		/* in: pointer to mutex */
-	char*	   	file_name, 	/* in: file name where mutex
+	char*	   	file_name __attribute__((unused)),
+					/* in: file name where mutex
 					requested */
-	ulint	   	line)		/* in: line where requested */
+	ulint	   	line __attribute__((unused)))
+					/* in: line where requested */
 {
 	ut_ad(mutex_validate(mutex));
 
@@ -264,9 +268,6 @@ mutex_enter_nowait(
 #ifdef UNIV_SYNC_DEBUG
 		mutex_set_debug_info(mutex, file_name, line);
 #endif
-		
-		mutex->file_name = file_name;
-		mutex->line = line;
 
 		return(0);	/* Succeeded! */
 	}
@@ -366,9 +367,6 @@ spin_loop:
 		mutex_set_debug_info(mutex, file_name, line);
 #endif
 
-		mutex->file_name = file_name;
-		mutex->line = line;
-
                 return;
    	}
 
@@ -413,9 +411,6 @@ spin_loop:
 		mutex_set_debug_info(mutex, file_name, line);
 #endif
 
-		mutex->file_name = file_name;
-		mutex->line = line;
-
 		if (srv_print_latch_waits) {
 			printf(
 			"Thread %lu spin wait succeeds at 2: mutex at %lx\n",
@@ -465,6 +460,7 @@ mutex_signal_object(
 	sync_array_signal_object(sync_primary_wait_array, mutex);
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Sets the debug information for a reserved mutex. */
 
@@ -502,7 +498,8 @@ mutex_get_debug_info(
 	*file_name = mutex->file_name;
 	*line	   = mutex->line;
 	*thread_id = mutex->thread_id;
-}	
+}
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Sets the mutex latching level field. */
@@ -516,6 +513,7 @@ mutex_set_level(
 	mutex->level = level;
 }
 
+#ifdef UNIV_SYNC_DEBUG
 /**********************************************************************
 Checks that the current thread owns the mutex. Works only in the debug
 version. */
@@ -548,8 +546,6 @@ void
 mutex_list_print_info(void)
 /*=======================*/
 {
-#ifndef UNIV_SYNC_DEBUG
-#else
 	mutex_t*	mutex;
 	char*		file_name;
 	ulint		line;
@@ -582,7 +578,6 @@ mutex_list_print_info(void)
 	printf("Total number of mutexes %ld\n", count);
 	
 	mutex_exit(&mutex_list_mutex);
-#endif
 }
 
 /**********************************************************************
@@ -592,12 +587,6 @@ ulint
 mutex_n_reserved(void)
 /*==================*/
 {
-#ifndef UNIV_SYNC_DEBUG
-	printf("Sorry, cannot give mutex info in non-debug version!\n");
-	ut_error;
-
-	return(0);
-#else
 	mutex_t*	mutex;
 	ulint		count		= 0;
 
@@ -620,7 +609,6 @@ mutex_n_reserved(void)
 
 	return(count - 1); /* Subtract one, because this function itself
 			   was holding one mutex (mutex_list_mutex) */
-#endif
 }
 
 /**********************************************************************
@@ -631,19 +619,9 @@ ibool
 sync_all_freed(void)
 /*================*/
 {
-#ifdef UNIV_SYNC_DEBUG
-	if (mutex_n_reserved() + rw_lock_n_locked() == 0) {
-
-		return(TRUE);
-	} else {
-		return(FALSE);
-	}	
-#else
-	ut_error;
-
-	return(FALSE);
-#endif
+	return(mutex_n_reserved() + rw_lock_n_locked() == 0);
 }
+#endif /* UNIV_SYNC_DEBUG */
 
 /**********************************************************************
 Gets the value in the nth slot in the thread level arrays. */
@@ -740,9 +718,6 @@ sync_thread_levels_g(
 				thread */
 	ulint		limit)	/* in: level limit */
 {
-	char*		file_name;
-	ulint		line;
-	os_thread_id_t	thread_id;
 	sync_level_t*	slot;
 	rw_lock_t*	lock;
 	mutex_t*	mutex;
@@ -767,18 +742,28 @@ sync_thread_levels_g(
 						mutex->cline);
 
 					if (mutex_get_lock_word(mutex) != 0) {
+#ifdef UNIV_SYNC_DEBUG
+						char*		file_name;
+						ulint		line;
+						os_thread_id_t	thread_id;
 
 		    				mutex_get_debug_info(mutex,
 						&file_name, &line, &thread_id);
 
-	printf("InnoDB: Locked mutex: addr %lx thread %ld file %s line %ld\n",
-		    	(ulint)mutex, os_thread_pf(thread_id),
-						file_name, line);
+						fprintf(stderr,
+		"InnoDB: Locked mutex: addr %p thread %ld file %s line %ld\n",
+		mutex, os_thread_pf(thread_id), file_name, line);
+#else /* UNIV_SYNC_DEBUG */
+						fprintf(stderr,
+		"InnoDB: Locked mutex: addr %p\n", mutex);
+#endif /* UNIV_SYNC_DEBUG */
 					} else {
-						printf("Not locked\n");
+						fputs("Not locked\n", stderr);
 					}	
 				} else {
+#ifdef UNIV_SYNC_DEBUG
 					rw_lock_print(lock);
+#endif /* UNIV_SYNC_DEBUG */
 				}
 								
 				return(FALSE);
@@ -918,7 +903,9 @@ sync_thread_add_level(
 
 	if ((latch == (void*)&sync_thread_mutex)
 	    || (latch == (void*)&mutex_list_mutex)
+#ifdef UNIV_SYNC_DEBUG
 	    || (latch == (void*)&rw_lock_debug_mutex)
+#endif /* UNIV_SYNC_DEBUG */
 	    || (latch == (void*)&rw_lock_list_mutex)) {
 
 		return;
@@ -1098,7 +1085,9 @@ sync_thread_reset_level(
 
 	if ((latch == (void*)&sync_thread_mutex)
 	    || (latch == (void*)&mutex_list_mutex)
+#ifdef UNIV_SYNC_DEBUG
 	    || (latch == (void*)&rw_lock_debug_mutex)
+#endif /* UNIV_SYNC_DEBUG */
 	    || (latch == (void*)&rw_lock_list_mutex)) {
 
 		return(FALSE);
@@ -1184,11 +1173,13 @@ sync_init(void)
         mutex_create(&rw_lock_list_mutex);
         mutex_set_level(&rw_lock_list_mutex, SYNC_NO_ORDER_CHECK);
 
+#ifdef UNIV_SYNC_DEBUG
         mutex_create(&rw_lock_debug_mutex);
         mutex_set_level(&rw_lock_debug_mutex, SYNC_NO_ORDER_CHECK);
 
 	rw_lock_debug_event = os_event_create(NULL);
 	rw_lock_debug_waiters = FALSE;
+#endif /* UNIV_SYNC_DEBUG */
 }
 
 /**********************************************************************
@@ -1250,9 +1241,11 @@ sync_print(
 	char*	buf,		/* in/out: buffer where to print */
 	char*	buf_end)	/* in: buffer end */
 {
+#ifdef UNIV_SYNC_DEBUG
 	mutex_list_print_info();
 
 	rw_lock_list_print_info();
+#endif /* UNIV_SYNC_DEBUG */
 
 	sync_array_print_info(buf, buf_end, sync_primary_wait_array);