cleanup: os_thread_sleep() -> std::this_thread::sleep_for()

std version has an advantage of a more convenient units implementation from
std::chrono. Now it's no need to multipy/divide to bring anything to
micro seconds.

Author: kevgs

cmake/os/WindowsCache.cmake

@@ -317,7 +317,6 @@ SET(HAVE_BZLIB2_DECOMPRESS CACHE INTERNAL "")
 SET(HAVE_BZLIB2_H CACHE INTERNAL "")
 SET(HAVE_SNAPPY_H CACHE INTERNAL "")
 SET(HAVE_SCHED_GETCPU CACHE INTERNAL "")
-SET(HAVE_NANOSLEEP CACHE INTERNAL "")
 SET(HAVE_PTHREAD_THREADID_NP CACHE INTERNAL "")
 SET(HAVE_SYS_GETTID CACHE INTERNAL "")
 SET(HAVE_INTEGER_PTHREAD_SELF CACHE INTERNAL "")

extra/mariabackup/backup_copy.cc

@@ -970,7 +970,7 @@ run_data_threads(datadir_iter_t *it, os_thread_func_t func, uint n)
 
 	/* Wait for threads to exit */
 	while (1) {
-		os_thread_sleep(100000);
+		std::this_thread::sleep_for(std::chrono::milliseconds(100));
 		pthread_mutex_lock(&count_mutex);
 		if (count == 0) {
 			pthread_mutex_unlock(&count_mutex);

extra/mariabackup/backup_mysql.cc

@@ -791,7 +791,7 @@ wait_for_no_updates(MYSQL *connection, uint timeout, uint threshold)
 		if (!have_queries_to_wait_for(connection, threshold)) {
 			return(true);
 		}
-		os_thread_sleep(1000000);
+		std::this_thread::sleep_for(std::chrono::seconds(1));
 	}
 
 	msg("Unable to obtain lock. Please try again later.");
@@ -963,8 +963,9 @@ unlock_all(MYSQL *connection)
 	if (opt_debug_sleep_before_unlock) {
 		msg("Debug sleep for %u seconds",
 		       opt_debug_sleep_before_unlock);
-		os_thread_sleep(opt_debug_sleep_before_unlock * 1000);
-	}
+                std::this_thread::sleep_for(
+                    std::chrono::milliseconds(opt_debug_sleep_before_unlock));
+        }
 
 	msg("Executing BACKUP STAGE END");
 	xb_mysql_query(connection, "BACKUP STAGE END", false);
@@ -1042,7 +1043,7 @@ wait_for_safe_slave(MYSQL *connection)
 		       "remaining)...", sleep_time, n_attempts);
 
 		xb_mysql_query(connection, "START SLAVE SQL_THREAD", false);
-		os_thread_sleep(sleep_time * 1000000);
+		std::this_thread::sleep_for(std::chrono::seconds(sleep_time));
 		xb_mysql_query(connection, "STOP SLAVE SQL_THREAD", false);
 
 		open_temp_tables = get_open_temp_tables(connection);

extra/mariabackup/fil_cur.cc

@@ -457,7 +457,8 @@ xb_fil_cur_result_t xb_fil_cur_read(xb_fil_cur_t*	cursor,
 				msg(cursor->thread_n, "Database page corruption detected at page "
 				    UINT32PF ", retrying...",
 				    page_no);
-				os_thread_sleep(100000);
+				std::this_thread::sleep_for(
+					std::chrono::milliseconds(100));
 				goto read_retry;
 			}
 		}

extra/mariabackup/xtrabackup.cc

@@ -3561,7 +3561,8 @@ static dberr_t xb_assign_undo_space_start()
 	/* TRX_SYS page can't be compressed or encrypted. */
 	if (buf_page_is_corrupted(false, page, fsp_flags)) {
 		if (n_retries--) {
-			os_thread_sleep(1000);
+			std::this_thread::sleep_for(
+				std::chrono::milliseconds(1));
 			goto retry;
 		} else {
 			msg("mariabackup: TRX_SYS page corrupted.\n");
@@ -4085,7 +4086,7 @@ static void stop_backup_threads(bool running)
     {
       putc('.', stderr);
       fflush(stderr);
-      os_thread_sleep(200000); /*0.2 sec*/
+      std::this_thread::sleep_for(std::chrono::milliseconds(200));
     }
     putc('\n', stderr);
     mysql_cond_destroy(&log_copying_stop);
@@ -4471,7 +4472,7 @@ static bool xtrabackup_backup_func()
 
 	/* Wait for threads to exit */
 	while (1) {
-		os_thread_sleep(1000000);
+		std::this_thread::sleep_for(std::chrono::seconds(1));
 		pthread_mutex_lock(&count_mutex);
 		bool stop = count == 0;
 		pthread_mutex_unlock(&count_mutex);

storage/innobase/buf/buf0buf.cc

@@ -310,8 +310,7 @@ void page_hash_latch::write_lock_wait()
   while (!write_lock_poll());
 }
 
-/** Value in microseconds */
-constexpr int WAIT_FOR_READ= 100;
+constexpr std::chrono::microseconds WAIT_FOR_READ(100);
 constexpr int WAIT_FOR_WRITE= 100;
 /** Number of attempts made to read in a page in the buffer pool */
 constexpr ulint	BUF_PAGE_READ_MAX_RETRIES= 100;
@@ -1810,7 +1809,8 @@ inline void buf_pool_t::resize()
 	if (should_retry_withdraw) {
 		ib::info() << "Will retry to withdraw " << retry_interval
 			<< " seconds later.";
-		os_thread_sleep(retry_interval * 1000000);
+		std::this_thread::sleep_for(
+			std::chrono::seconds(retry_interval));
 
 		if (retry_interval > 5) {
 			retry_interval = 10;
@@ -1831,7 +1831,9 @@ inline void buf_pool_t::resize()
 			should_wait = false;
 			DBUG_EXECUTE_IF(
 				"ib_buf_pool_resize_wait_before_resize",
-				should_wait = true; os_thread_sleep(10000););
+				should_wait = true;
+				std::this_thread::sleep_for(
+					std::chrono::milliseconds(10)););
 		}
 	}
 #endif /* !DBUG_OFF */
@@ -2375,7 +2377,7 @@ buf_page_t* buf_page_get_zip(const page_id_t page_id, ulint zip_size)
   if (must_read)
     /* Let us wait until the read operation completes */
     while (bpage->io_fix() == BUF_IO_READ)
-      os_thread_sleep(WAIT_FOR_READ);
+      std::this_thread::sleep_for(WAIT_FOR_READ);
 
   return bpage;
 }
@@ -2763,7 +2765,8 @@ buf_page_get_low(
 			Avoid returning reference to this page.
 			Instead wait for the flush action to complete. */
 			fix_block->unfix();
-			os_thread_sleep(WAIT_FOR_WRITE);
+			std::this_thread::sleep_for(
+				std::chrono::microseconds(WAIT_FOR_WRITE));
 			goto loop;
 		}
 
@@ -2814,7 +2817,7 @@ buf_page_get_low(
 
 			/* The block is buffer-fixed or I/O-fixed.
 			Try again later. */
-			os_thread_sleep(WAIT_FOR_READ);
+			std::this_thread::sleep_for(WAIT_FOR_READ);
 
 			goto loop;
 		}

storage/innobase/buf/buf0dump.cc

@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2011, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2017, 2020, MariaDB Corporation.
+Copyright (c) 2017, 2021, MariaDB Corporation.
 
 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
@@ -472,7 +472,8 @@ buf_load_throttle_if_needed(
 	ut_time_ms() that often may turn out to be too expensive. */
 
 	if (elapsed_time < 1000 /* 1 sec (1000 milli secs) */) {
-		os_thread_sleep((1000 - elapsed_time) * 1000 /* micro secs */);
+		std::this_thread::sleep_for(
+			std::chrono::milliseconds(1000 - elapsed_time));
 	}
 
 	*last_check_time = ut_time_ms();

storage/innobase/buf/buf0flu.cc

@@ -2219,7 +2219,7 @@ static os_thread_ret_t DECLARE_THREAD(buf_flush_page_cleaner)(void*)
 #ifdef UNIV_DEBUG
     while (innodb_page_cleaner_disabled_debug && !buf_flush_sync_lsn &&
            srv_shutdown_state == SRV_SHUTDOWN_NONE)
-      os_thread_sleep(100000);
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));
 #endif /* UNIV_DEBUG */
 
 #ifndef DBUG_OFF

storage/innobase/buf/buf0rea.cc

@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 1995, 2017, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2015, 2020, MariaDB Corporation.
+Copyright (c) 2015, 2021, MariaDB Corporation.
 
 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
@@ -748,7 +748,8 @@ void buf_read_recv_pages(ulint space_id, const uint32_t* page_nos, ulint n)
 		}
 
 		for (ulint count = 0; buf_pool.n_pend_reads >= limit; ) {
-			os_thread_sleep(10000);
+			std::this_thread::sleep_for(
+				std::chrono::milliseconds(10));
 
 			if (!(++count % 1000)) {
 

storage/innobase/dict/dict0stats.cc

@@ -1,7 +1,7 @@
 /*****************************************************************************
 
 Copyright (c) 2009, 2019, Oracle and/or its affiliates. All Rights Reserved.
-Copyright (c) 2015, 2020, MariaDB Corporation.
+Copyright (c) 2015, 2021, MariaDB Corporation.
 
 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
@@ -37,6 +37,7 @@ Created Jan 06, 2010 Vasil Dimov
 #include <algorithm>
 #include <map>
 #include <vector>
+#include <thread>
 
 /* Sampling algorithm description @{
 
@@ -3775,7 +3776,8 @@ dict_stats_rename_table(
 
 		if (ret != DB_SUCCESS) {
 			dict_sys_unlock();
-			os_thread_sleep(200000 /* 0.2 sec */);
+			std::this_thread::sleep_for(
+				std::chrono::milliseconds(200));
 			dict_sys_lock();
 		}
 	} while ((ret == DB_DEADLOCK
@@ -3828,7 +3830,8 @@ dict_stats_rename_table(
 
 		if (ret != DB_SUCCESS) {
 			dict_sys_unlock();
-			os_thread_sleep(200000 /* 0.2 sec */);
+			std::this_thread::sleep_for(
+				std::chrono::milliseconds(200));
 			dict_sys_lock();
 		}
 	} while ((ret == DB_DEADLOCK