← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/os/os0proc.c

  • Committer: Monty Taylor
  • Date: 2008-10-16 09:12:23 UTC
  • mto: (511.1.6 codestyle)
  • mto: This revision was merged to the branch mainline in revision 521.
  • Revision ID: monty@inaugust.com-20081016091223-17ngih0qu9vssjs3
We pass -Wunused-macros now!

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/os/os0proc.c
1
 
/*****************************************************************************
2
 
 
3
 
Copyright (c) 1995, 2009, Innobase Oy. All Rights Reserved.
4
 
 
5
 
This program is free software; you can redistribute it and/or modify it under
6
 
the terms of the GNU General Public License as published by the Free Software
7
 
Foundation; version 2 of the License.
8
 
 
9
 
This program is distributed in the hope that it will be useful, but WITHOUT
10
 
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11
 
FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
12
 
 
13
 
You should have received a copy of the GNU General Public License along with
14
 
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
15
 
Place, Suite 330, Boston, MA 02111-1307 USA
16
 
 
17
 
*****************************************************************************/
18
 
 
19
 
/**************************************************//**
20
 
@file os/os0proc.c
21
 
The interface to the operating system
22
 
process control primitives
23
 
 
24
 
Created 9/30/1995 Heikki Tuuri
25
 
*******************************************************/
26
 
 
27
 
#include "os0proc.h"
28
 
#ifdef UNIV_NONINL
29
 
#include "os0proc.ic"
30
 
#endif
31
 
 
32
 
#include "ut0mem.h"
33
 
#include "ut0byte.h"
34
 
#include <errno.h>
35
 
#include <unistd.h>
36
 
 
37
 
/* FreeBSD for example has only MAP_ANON, Linux has MAP_ANONYMOUS and
38
 
MAP_ANON but MAP_ANON is marked as deprecated */
39
 
#if defined(MAP_ANONYMOUS)
40
 
#define OS_MAP_ANON     MAP_ANONYMOUS
41
 
#elif defined(MAP_ANON)
42
 
#define OS_MAP_ANON     MAP_ANON
43
 
#endif
44
 
 
45
 
UNIV_INTERN ibool os_use_large_pages;
46
 
/* Large page size. This may be a boot-time option on some platforms */
47
 
UNIV_INTERN ulint os_large_page_size;
48
 
 
49
 
/****************************************************************//**
50
 
Converts the current process id to a number. It is not guaranteed that the
51
 
number is unique. In Linux returns the 'process number' of the current
52
 
thread. That number is the same as one sees in 'top', for example. In Linux
53
 
the thread id is not the same as one sees in 'top'.
54
 
@return process id as a number */
55
 
UNIV_INTERN
56
 
ulint
57
 
os_proc_get_number(void)
58
 
/*====================*/
59
 
{
60
 
#ifdef __WIN__
61
 
        return((ulint)GetCurrentProcessId());
62
 
#else
63
 
        return((ulint)getpid());
64
 
#endif
65
 
}
66
 
 
67
 
/****************************************************************//**
68
 
Allocates large pages memory.
69
 
@return allocated memory */
70
 
UNIV_INTERN
71
 
void*
72
 
os_mem_alloc_large(
73
 
/*===============*/
74
 
        ulint*  n)                      /*!< in/out: number of bytes */
75
 
{
76
 
        void*   ptr;
77
 
        ulint   size;
78
 
#if defined HAVE_LARGE_PAGES && defined UNIV_LINUX
79
 
        int shmid;
80
 
        struct shmid_ds buf;
81
 
 
82
 
        if (!os_use_large_pages || !os_large_page_size) {
83
 
                goto skip;
84
 
        }
85
 
 
86
 
        /* Align block size to os_large_page_size */
87
 
        ut_ad(ut_is_2pow(os_large_page_size));
88
 
        size = ut_2pow_round(*n + (os_large_page_size - 1),
89
 
                             os_large_page_size);
90
 
 
91
 
        shmid = shmget(IPC_PRIVATE, (size_t)size, SHM_HUGETLB | SHM_R | SHM_W);
92
 
        if (shmid < 0) {
93
 
                fprintf(stderr, "InnoDB: HugeTLB: Warning: Failed to allocate"
94
 
                        " %lu bytes. errno %d\n", size, errno);
95
 
                ptr = NULL;
96
 
        } else {
97
 
                ptr = shmat(shmid, NULL, 0);
98
 
                if (ptr == (void *)-1) {
99
 
                        fprintf(stderr, "InnoDB: HugeTLB: Warning: Failed to"
100
 
                                " attach shared memory segment, errno %d\n",
101
 
                                errno);
102
 
                }
103
 
 
104
 
                /* Remove the shared memory segment so that it will be
105
 
                automatically freed after memory is detached or
106
 
                process exits */
107
 
                shmctl(shmid, IPC_RMID, &buf);
108
 
        }
109
 
 
110
 
        if (ptr) {
111
 
                *n = size;
112
 
                os_fast_mutex_lock(&ut_list_mutex);
113
 
                ut_total_allocated_memory += size;
114
 
                os_fast_mutex_unlock(&ut_list_mutex);
115
 
# ifdef UNIV_SET_MEM_TO_ZERO
116
 
                memset(ptr, '\0', size);
117
 
# endif
118
 
                UNIV_MEM_ALLOC(ptr, size);
119
 
                return(ptr);
120
 
        }
121
 
 
122
 
        fprintf(stderr, "InnoDB HugeTLB: Warning: Using conventional"
123
 
                " memory pool\n");
124
 
skip:
125
 
#endif /* HAVE_LARGE_PAGES && UNIV_LINUX */
126
 
 
127
 
#ifdef __WIN__
128
 
        SYSTEM_INFO     system_info;
129
 
        GetSystemInfo(&system_info);
130
 
 
131
 
        /* Align block size to system page size */
132
 
        ut_ad(ut_is_2pow(system_info.dwPageSize));
133
 
        /* system_info.dwPageSize is only 32-bit. Casting to ulint is required
134
 
        on 64-bit Windows. */
135
 
        size = *n = ut_2pow_round(*n + (system_info.dwPageSize - 1),
136
 
                                  (ulint) system_info.dwPageSize);
137
 
        ptr = VirtualAlloc(NULL, size, MEM_COMMIT | MEM_RESERVE,
138
 
                           PAGE_READWRITE);
139
 
        if (!ptr) {
140
 
                fprintf(stderr, "InnoDB: VirtualAlloc(%lu bytes) failed;"
141
 
                        " Windows error %lu\n",
142
 
                        (ulong) size, (ulong) GetLastError());
143
 
        } else {
144
 
                os_fast_mutex_lock(&ut_list_mutex);
145
 
                ut_total_allocated_memory += size;
146
 
                os_fast_mutex_unlock(&ut_list_mutex);
147
 
                UNIV_MEM_ALLOC(ptr, size);
148
 
        }
149
 
#elif defined __NETWARE__ || !defined OS_MAP_ANON
150
 
        size = *n;
151
 
        ptr = ut_malloc_low(size, TRUE, FALSE);
152
 
#else
153
 
# ifdef HAVE_GETPAGESIZE
154
 
        size = getpagesize();
155
 
# else
156
 
        size = UNIV_PAGE_SIZE;
157
 
# endif
158
 
        /* Align block size to system page size */
159
 
        ut_ad(ut_is_2pow(size));
160
 
        size = *n = ut_2pow_round(*n + (size - 1), size);
161
 
        ptr = mmap(NULL, size, PROT_READ | PROT_WRITE,
162
 
                   MAP_PRIVATE | OS_MAP_ANON, -1, 0);
163
 
        if (UNIV_UNLIKELY(ptr == (void*) -1)) {
164
 
                fprintf(stderr, "InnoDB: mmap(%lu bytes) failed;"
165
 
                        " errno %lu\n",
166
 
                        (ulong) size, (ulong) errno);
167
 
                ptr = NULL;
168
 
        } else {
169
 
                os_fast_mutex_lock(&ut_list_mutex);
170
 
                ut_total_allocated_memory += size;
171
 
                os_fast_mutex_unlock(&ut_list_mutex);
172
 
                UNIV_MEM_ALLOC(ptr, size);
173
 
        }
174
 
#endif
175
 
        return(ptr);
176
 
}
177
 
 
178
 
/****************************************************************//**
179
 
Frees large pages memory. */
180
 
UNIV_INTERN
181
 
void
182
 
os_mem_free_large(
183
 
/*==============*/
184
 
        void    *ptr,                   /*!< in: pointer returned by
185
 
                                        os_mem_alloc_large() */
186
 
        ulint   size)                   /*!< in: size returned by
187
 
                                        os_mem_alloc_large() */
188
 
{
189
 
        os_fast_mutex_lock(&ut_list_mutex);
190
 
        ut_a(ut_total_allocated_memory >= size);
191
 
        os_fast_mutex_unlock(&ut_list_mutex);
192
 
 
193
 
#if defined HAVE_LARGE_PAGES && defined UNIV_LINUX
194
 
        if (os_use_large_pages && os_large_page_size && !shmdt(ptr)) {
195
 
                os_fast_mutex_lock(&ut_list_mutex);
196
 
                ut_a(ut_total_allocated_memory >= size);
197
 
                ut_total_allocated_memory -= size;
198
 
                os_fast_mutex_unlock(&ut_list_mutex);
199
 
                UNIV_MEM_FREE(ptr, size);
200
 
                return;
201
 
        }
202
 
#endif /* HAVE_LARGE_PAGES && UNIV_LINUX */
203
 
#ifdef __WIN__
204
 
        /* When RELEASE memory, the size parameter must be 0.
205
 
        Do not use MEM_RELEASE with MEM_DECOMMIT. */
206
 
        if (!VirtualFree(ptr, 0, MEM_RELEASE)) {
207
 
                fprintf(stderr, "InnoDB: VirtualFree(%p, %lu) failed;"
208
 
                        " Windows error %lu\n",
209
 
                        ptr, (ulong) size, (ulong) GetLastError());
210
 
        } else {
211
 
                os_fast_mutex_lock(&ut_list_mutex);
212
 
                ut_a(ut_total_allocated_memory >= size);
213
 
                ut_total_allocated_memory -= size;
214
 
                os_fast_mutex_unlock(&ut_list_mutex);
215
 
                UNIV_MEM_FREE(ptr, size);
216
 
        }
217
 
#elif defined __NETWARE__ || !defined OS_MAP_ANON
218
 
        ut_free(ptr);
219
 
#else
220
 
        if (munmap(ptr, size)) {
221
 
                fprintf(stderr, "InnoDB: munmap(%p, %lu) failed;"
222
 
                        " errno %lu\n",
223
 
                        ptr, (ulong) size, (ulong) errno);
224
 
        } else {
225
 
                os_fast_mutex_lock(&ut_list_mutex);
226
 
                ut_a(ut_total_allocated_memory >= size);
227
 
                ut_total_allocated_memory -= size;
228
 
                os_fast_mutex_unlock(&ut_list_mutex);
229
 
                UNIV_MEM_FREE(ptr, size);
230
 
        }
231
 
#endif
232
 
}