mirror of
https://github.com/MariaDB/server.git
synced 2025-01-18 04:53:01 +01:00
355 lines
8.6 KiB
C++
355 lines
8.6 KiB
C++
/*****************************************************************************
|
|
|
|
Copyright (c) 1995, 2013, 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, Suite 500, Boston, MA 02110-1335 USA
|
|
|
|
*****************************************************************************/
|
|
|
|
/**************************************************//**
|
|
@file os/os0thread.cc
|
|
The interface to the operating system thread control primitives
|
|
|
|
Created 9/8/1995 Heikki Tuuri
|
|
*******************************************************/
|
|
|
|
#include "os0thread.h"
|
|
#ifdef UNIV_NONINL
|
|
#include "os0thread.ic"
|
|
#endif
|
|
|
|
#ifdef __WIN__
|
|
#include <windows.h>
|
|
#elif UNIV_LINUX
|
|
#include <sys/time.h>
|
|
#include <sys/resource.h>
|
|
#include <unistd.h>
|
|
#include <sys/syscall.h>
|
|
#include <sys/types.h>
|
|
#endif
|
|
|
|
#ifndef UNIV_HOTBACKUP
|
|
#include "srv0srv.h"
|
|
#include "os0sync.h"
|
|
|
|
/***************************************************************//**
|
|
Compares two thread ids for equality.
|
|
@return TRUE if equal */
|
|
UNIV_INTERN
|
|
ibool
|
|
os_thread_eq(
|
|
/*=========*/
|
|
os_thread_id_t a, /*!< in: OS thread or thread id */
|
|
os_thread_id_t b) /*!< in: OS thread or thread id */
|
|
{
|
|
#ifdef __WIN__
|
|
if (a == b) {
|
|
return(TRUE);
|
|
}
|
|
|
|
return(FALSE);
|
|
#else
|
|
if (pthread_equal(a, b)) {
|
|
return(TRUE);
|
|
}
|
|
|
|
return(FALSE);
|
|
#endif
|
|
}
|
|
|
|
/****************************************************************//**
|
|
Converts an OS thread id to a ulint. It is NOT guaranteed that the ulint is
|
|
unique for the thread though!
|
|
@return thread identifier as a number */
|
|
UNIV_INTERN
|
|
ulint
|
|
os_thread_pf(
|
|
/*=========*/
|
|
os_thread_id_t a) /*!< in: OS thread identifier */
|
|
{
|
|
#ifdef UNIV_HPUX10
|
|
/* In HP-UX-10.20 a pthread_t is a struct of 3 fields: field1, field2,
|
|
field3. We do not know if field1 determines the thread uniquely. */
|
|
|
|
return((ulint)(a.field1));
|
|
#else
|
|
return((ulint) a);
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************//**
|
|
Returns the thread identifier of current thread. Currently the thread
|
|
identifier in Unix is the thread handle itself. Note that in HP-UX
|
|
pthread_t is a struct of 3 fields.
|
|
@return current thread identifier */
|
|
UNIV_INTERN
|
|
os_thread_id_t
|
|
os_thread_get_curr_id(void)
|
|
/*=======================*/
|
|
{
|
|
#ifdef __WIN__
|
|
return(GetCurrentThreadId());
|
|
#else
|
|
return(pthread_self());
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************//**
|
|
Returns the system-specific thread identifier of current thread. On Linux,
|
|
returns tid. On other systems currently returns os_thread_get_curr_id().
|
|
|
|
@return current thread identifier */
|
|
UNIV_INTERN
|
|
os_tid_t
|
|
os_thread_get_tid(void)
|
|
/*===================*/
|
|
{
|
|
#ifdef UNIV_LINUX
|
|
return((os_tid_t)syscall(SYS_gettid));
|
|
#else
|
|
return(os_thread_get_curr_id());
|
|
#endif
|
|
}
|
|
|
|
|
|
/****************************************************************//**
|
|
Creates a new thread of execution. The execution starts from
|
|
the function given. The start function takes a void* parameter
|
|
and returns an ulint.
|
|
@return handle to the thread */
|
|
UNIV_INTERN
|
|
os_thread_t
|
|
os_thread_create_func(
|
|
/*==================*/
|
|
os_thread_func_t func, /*!< in: pointer to function
|
|
from which to start */
|
|
void* arg, /*!< in: argument to start
|
|
function */
|
|
os_thread_id_t* thread_id) /*!< out: id of the created
|
|
thread, or NULL */
|
|
{
|
|
/* the new thread should look recent changes up here so far. */
|
|
os_wmb;
|
|
|
|
#ifdef __WIN__
|
|
os_thread_t thread;
|
|
DWORD win_thread_id;
|
|
|
|
os_atomic_increment_ulint(&os_thread_count, 1);
|
|
|
|
thread = CreateThread(NULL, /* no security attributes */
|
|
0, /* default size stack */
|
|
func,
|
|
arg,
|
|
0, /* thread runs immediately */
|
|
&win_thread_id);
|
|
|
|
if (thread_id) {
|
|
*thread_id = win_thread_id;
|
|
}
|
|
|
|
return((os_thread_t)thread);
|
|
#else
|
|
int ret;
|
|
os_thread_t pthread;
|
|
pthread_attr_t attr;
|
|
|
|
#ifndef UNIV_HPUX10
|
|
pthread_attr_init(&attr);
|
|
#endif
|
|
|
|
#ifdef UNIV_AIX
|
|
/* We must make sure a thread stack is at least 32 kB, otherwise
|
|
InnoDB might crash; we do not know if the default stack size on
|
|
AIX is always big enough. An empirical test on AIX-4.3 suggested
|
|
the size was 96 kB, though. */
|
|
|
|
ret = pthread_attr_setstacksize(&attr,
|
|
(size_t)(PTHREAD_STACK_MIN
|
|
+ 32 * 1024));
|
|
if (ret) {
|
|
fprintf(stderr,
|
|
"InnoDB: Error: pthread_attr_setstacksize"
|
|
" returned %d\n", ret);
|
|
exit(1);
|
|
}
|
|
#endif
|
|
ulint new_count = os_atomic_increment_ulint(&os_thread_count, 1);
|
|
ut_a(new_count <= OS_THREAD_MAX_N);
|
|
|
|
#ifdef UNIV_HPUX10
|
|
ret = pthread_create(&pthread, pthread_attr_default, func, arg);
|
|
#else
|
|
ret = pthread_create(&pthread, &attr, func, arg);
|
|
#endif
|
|
if (ret) {
|
|
fprintf(stderr,
|
|
"InnoDB: Error: pthread_create returned %d\n", ret);
|
|
exit(1);
|
|
}
|
|
|
|
#ifndef UNIV_HPUX10
|
|
pthread_attr_destroy(&attr);
|
|
#endif
|
|
|
|
if (thread_id) {
|
|
*thread_id = pthread;
|
|
}
|
|
|
|
return(pthread);
|
|
#endif
|
|
}
|
|
|
|
/**
|
|
Waits until the specified thread completes and joins it. Its return value is
|
|
ignored.
|
|
|
|
@param thread thread to join */
|
|
UNIV_INTERN
|
|
void
|
|
os_thread_join(
|
|
os_thread_t thread)
|
|
{
|
|
/*This function is currently only used to workaround glibc bug
|
|
described in http://bugs.mysql.com/bug.php?id=82886
|
|
|
|
On Windows, no workarounds are necessary, all threads
|
|
are "detached" upon thread exit (handle is closed), so we do
|
|
nothing.
|
|
*/
|
|
#ifndef _WIN32
|
|
int ret MY_ATTRIBUTE((unused)) = pthread_join(thread, NULL);
|
|
|
|
/* Waiting on already-quit threads is allowed */
|
|
ut_ad(ret == 0 || ret == ESRCH);
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************//**
|
|
Exits the current thread. */
|
|
UNIV_INTERN
|
|
void
|
|
os_thread_exit(
|
|
/*===========*/
|
|
void* exit_value, /*!< in: exit value; in Windows this void*
|
|
is cast as a DWORD */
|
|
bool detach) /*!< in: if true, the thread will be detached
|
|
right before exiting. If false, another thread
|
|
is responsible for joining this thread. */
|
|
{
|
|
#ifdef UNIV_DEBUG_THREAD_CREATION
|
|
fprintf(stderr, "Thread exits, id %lu\n",
|
|
os_thread_pf(os_thread_get_curr_id()));
|
|
#endif
|
|
|
|
#ifdef UNIV_PFS_THREAD
|
|
pfs_delete_thread();
|
|
#endif
|
|
|
|
os_atomic_decrement_ulint(&os_thread_count, 1);
|
|
|
|
#ifdef __WIN__
|
|
ExitThread((DWORD) exit_value);
|
|
#else
|
|
if (detach)
|
|
pthread_detach(pthread_self());
|
|
pthread_exit(exit_value);
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************//**
|
|
Advises the os to give up remainder of the thread's time slice. */
|
|
UNIV_INTERN
|
|
void
|
|
os_thread_yield(void)
|
|
/*=================*/
|
|
{
|
|
#if defined(__WIN__)
|
|
SwitchToThread();
|
|
#elif (defined(HAVE_SCHED_YIELD) && defined(HAVE_SCHED_H))
|
|
sched_yield();
|
|
#elif defined(HAVE_PTHREAD_YIELD_ZERO_ARG)
|
|
pthread_yield();
|
|
#elif defined(HAVE_PTHREAD_YIELD_ONE_ARG)
|
|
pthread_yield(0);
|
|
#else
|
|
os_thread_sleep(0);
|
|
#endif
|
|
}
|
|
#endif /* !UNIV_HOTBACKUP */
|
|
|
|
/*****************************************************************//**
|
|
The thread sleeps at least the time given in microseconds. */
|
|
UNIV_INTERN
|
|
void
|
|
os_thread_sleep(
|
|
/*============*/
|
|
ulint tm) /*!< in: time in microseconds */
|
|
{
|
|
#ifdef __WIN__
|
|
Sleep((DWORD) tm / 1000);
|
|
#else
|
|
struct timeval t;
|
|
|
|
t.tv_sec = tm / 1000000;
|
|
t.tv_usec = tm % 1000000;
|
|
|
|
select(0, NULL, NULL, NULL, &t);
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************//**
|
|
Set relative scheduling priority for a given thread on Linux. Currently a
|
|
no-op on other systems.
|
|
|
|
@return An actual thread priority after the update */
|
|
UNIV_INTERN
|
|
ulint
|
|
os_thread_set_priority(
|
|
/*===================*/
|
|
os_tid_t thread_id, /*!< in: thread id */
|
|
ulint relative_priority) /*!< in: system-specific
|
|
priority value */
|
|
{
|
|
#ifdef UNIV_LINUX
|
|
lint thread_nice = 19 - relative_priority;
|
|
if (setpriority(PRIO_PROCESS, thread_id, thread_nice) == -1) {
|
|
ib_logf(IB_LOG_LEVEL_WARN,
|
|
"Setting thread %lu nice to %ld failed, "
|
|
"current nice %d, errno %d",
|
|
os_thread_pf(thread_id), thread_nice,
|
|
getpriority(PRIO_PROCESS, thread_id), errno);
|
|
}
|
|
return(19 - getpriority(PRIO_PROCESS, thread_id));
|
|
#else
|
|
return(relative_priority);
|
|
#endif
|
|
}
|
|
|
|
/*****************************************************************//**
|
|
Get priority for a given thread on Linux. Currently a
|
|
no-op on other systems.
|
|
|
|
@return An actual thread priority */
|
|
UNIV_INTERN
|
|
ulint
|
|
os_thread_get_priority(
|
|
/*===================*/
|
|
os_tid_t thread_id) /*!< in: thread id */
|
|
{
|
|
#ifdef UNIV_LINUX
|
|
return (getpriority(PRIO_PROCESS, thread_id));
|
|
#else
|
|
return (0);
|
|
#endif
|
|
}
|