| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| #include "rtl/alloc.h" | |
| #include "alloc_impl.h" | |
| #ifndef INCLUDED_STRING_H | |
| #include <string.h> | |
| #define INCLUDED_STRING_H | |
| #endif | |
| #if !defined(FORCE_SYSALLOC) | |
| /* ================================================================= * | |
| * | |
| * custom allocator includes. | |
| * | |
| * ================================================================= */ | |
| #ifndef INCLUDED_STDIO_H | |
| #include <stdio.h> | |
| #define INCLUDED_STDIO_H | |
| #endif | |
| #include "internal/once.h" | |
| #include "sal/macros.h" | |
| #include "osl/diagnose.h" | |
| /* ================================================================= * | |
| * | |
| * custom allocator internals. | |
| * | |
| * ================================================================= */ | |
| static const sal_Size g_alloc_sizes[] = | |
| { | |
| /* powers of 2**(1/4) */ | |
| 4 * 4, 6 * 4, | |
| 4 * 8, 5 * 8, 6 * 8, 7 * 8, | |
| 4 * 16, 5 * 16, 6 * 16, 7 * 16, | |
| 4 * 32, 5 * 32, 6 * 32, 7 * 32, | |
| 4 * 64, 5 * 64, 6 * 64, 7 * 64, | |
| 4 * 128, 5 * 128, 6 * 128, 7 * 128, | |
| 4 * 256, 5 * 256, 6 * 256, 7 * 256, | |
| 4 * 512, 5 * 512, 6 * 512, 7 * 512, | |
| 4 * 1024, 5 * 1024, 6 * 1024, 7 * 1024, | |
| 4 * 2048, 5 * 2048, 6 * 2048, 7 * 2048, | |
| 4 * 4096 | |
| }; | |
| #define RTL_MEMORY_CACHED_LIMIT 4 * 4096 | |
| #define RTL_MEMORY_CACHED_SIZES (sizeof(g_alloc_sizes) / sizeof(g_alloc_sizes[0])) | |
| static rtl_cache_type * g_alloc_caches[RTL_MEMORY_CACHED_SIZES] = | |
| { | |
| 0, | |
| }; | |
| #ifdef NEED_ALIGN16 | |
| #define RTL_MEMALIGN 16 | |
| #define RTL_MEMALIGN_SHIFT 4 | |
| #else | |
| #define RTL_MEMALIGN 8 | |
| #define RTL_MEMALIGN_SHIFT 3 | |
| #endif | |
| static rtl_cache_type * g_alloc_table[RTL_MEMORY_CACHED_LIMIT >> RTL_MEMALIGN_SHIFT] = | |
| { | |
| 0, | |
| }; | |
| static rtl_arena_type * gp_alloc_arena = NULL; | |
| /* ================================================================= * | |
| * | |
| * custom allocator initialization / finalization. | |
| * | |
| * ================================================================= */ | |
| static void | |
| rtl_memory_once_init (void) | |
| { | |
| { | |
| /* global memory arena */ | |
| OSL_ASSERT(gp_alloc_arena == NULL); | |
| gp_alloc_arena = rtl_arena_create ( | |
| "rtl_alloc_arena", | |
| 2048, /* quantum */ | |
| 0, /* w/o quantum caching */ | |
| 0, /* default source */ | |
| rtl_arena_alloc, | |
| rtl_arena_free, | |
| 0 /* flags */ | |
| ); | |
| OSL_ASSERT(gp_alloc_arena != NULL); | |
| } | |
| { | |
| sal_Size size; | |
| int i, n = RTL_MEMORY_CACHED_SIZES; | |
| for (i = 0; i < n; i++) | |
| { | |
| char name[RTL_CACHE_NAME_LENGTH + 1]; | |
| (void) snprintf (name, sizeof(name), "rtl_alloc_%lu", g_alloc_sizes[i]); | |
| g_alloc_caches[i] = rtl_cache_create (name, g_alloc_sizes[i], 0, NULL, NULL, NULL, NULL, NULL, 0); | |
| } | |
| size = RTL_MEMALIGN; | |
| for (i = 0; i < n; i++) | |
| { | |
| while (size <= g_alloc_sizes[i]) | |
| { | |
| g_alloc_table[(size - 1) >> RTL_MEMALIGN_SHIFT] = g_alloc_caches[i]; | |
| size += RTL_MEMALIGN; | |
| } | |
| } | |
| } | |
| } | |
| static int | |
| rtl_memory_init (void) | |
| { | |
| static sal_once_type g_once = SAL_ONCE_INIT; | |
| SAL_ONCE(&g_once, rtl_memory_once_init); | |
| return (gp_alloc_arena != NULL); | |
| } | |
| /* ================================================================= */ | |
| /* | |
| Issue http://udk.openoffice.org/issues/show_bug.cgi?id=92388 | |
| Mac OS X does not seem to support "__cxa__atexit", thus leading | |
| to the situation that "__attribute__((destructor))__" functions | |
| (in particular "rtl_{memory|cache|arena}_fini") become called | |
| _before_ global C++ object d'tors. | |
| Delegated the call to "rtl_memory_fini()" into a dummy C++ object, | |
| see alloc_fini.cxx . | |
| */ | |
| #if defined(__GNUC__) && !defined(MACOSX) | |
| static void rtl_memory_fini (void) __attribute__((destructor)); | |
| #elif defined(__SUNPRO_C) || defined(__SUNPRO_CC) | |
| #pragma fini(rtl_memory_fini) | |
| static void rtl_memory_fini (void); | |
| #endif /* __GNUC__ || __SUNPRO_C */ | |
| void | |
| rtl_memory_fini (void) | |
| { | |
| int i, n; | |
| /* clear g_alloc_table */ | |
| memset (g_alloc_table, 0, sizeof(g_alloc_table)); | |
| /* cleanup g_alloc_caches */ | |
| for (i = 0, n = RTL_MEMORY_CACHED_SIZES; i < n; i++) | |
| { | |
| if (g_alloc_caches[i] != NULL) | |
| { | |
| rtl_cache_destroy (g_alloc_caches[i]); | |
| g_alloc_caches[i] = NULL; | |
| } | |
| } | |
| /* cleanup gp_alloc_arena */ | |
| if (gp_alloc_arena != NULL) | |
| { | |
| rtl_arena_destroy (gp_alloc_arena); | |
| gp_alloc_arena = NULL; | |
| } | |
| } | |
| /* ================================================================= * | |
| * | |
| * custom allocator implementation. | |
| * | |
| * ================================================================= */ | |
| void * | |
| SAL_CALL rtl_allocateMemory (sal_Size n) SAL_THROW_EXTERN_C() | |
| { | |
| void * p = 0; | |
| if (n > 0) | |
| { | |
| char * addr; | |
| sal_Size size = RTL_MEMORY_ALIGN(n + RTL_MEMALIGN, RTL_MEMALIGN); | |
| OSL_ASSERT(RTL_MEMALIGN >= sizeof(sal_Size)); | |
| if (n >= SAL_MAX_SIZE - (RTL_MEMALIGN + RTL_MEMALIGN - 1)) | |
| { | |
| /* requested size too large for roundup alignment */ | |
| return 0; | |
| } | |
| try_alloc: | |
| if (size <= RTL_MEMORY_CACHED_LIMIT) | |
| addr = (char*)rtl_cache_alloc(g_alloc_table[(size - 1) >> RTL_MEMALIGN_SHIFT]); | |
| else | |
| addr = (char*)rtl_arena_alloc (gp_alloc_arena, &size); | |
| if (addr != 0) | |
| { | |
| ((sal_Size*)(addr))[0] = size; | |
| p = addr + RTL_MEMALIGN; | |
| } | |
| else if (gp_alloc_arena == 0) | |
| { | |
| if (rtl_memory_init()) | |
| { | |
| /* try again */ | |
| goto try_alloc; | |
| } | |
| } | |
| } | |
| return (p); | |
| } | |
| /* ================================================================= */ | |
| void SAL_CALL rtl_freeMemory (void * p) SAL_THROW_EXTERN_C() | |
| { | |
| if (p != 0) | |
| { | |
| char * addr = (char*)(p) - RTL_MEMALIGN; | |
| sal_Size size = ((sal_Size*)(addr))[0]; | |
| if (size <= RTL_MEMORY_CACHED_LIMIT) | |
| rtl_cache_free(g_alloc_table[(size - 1) >> RTL_MEMALIGN_SHIFT], addr); | |
| else | |
| rtl_arena_free (gp_alloc_arena, addr, size); | |
| } | |
| } | |
| /* ================================================================= */ | |
| void * SAL_CALL rtl_reallocateMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C() | |
| { | |
| if (n > 0) | |
| { | |
| if (p != 0) | |
| { | |
| void * p_old = p; | |
| sal_Size n_old = ((sal_Size*)( (char*)(p) - RTL_MEMALIGN ))[0] - RTL_MEMALIGN; | |
| p = rtl_allocateMemory (n); | |
| if (p != 0) | |
| { | |
| memcpy (p, p_old, SAL_MIN(n, n_old)); | |
| rtl_freeMemory (p_old); | |
| } | |
| } | |
| else | |
| { | |
| p = rtl_allocateMemory (n); | |
| } | |
| } | |
| else if (p != 0) | |
| { | |
| rtl_freeMemory (p), p = 0; | |
| } | |
| return (p); | |
| } | |
| #else /* FORCE_SYSALLOC */ | |
| /* ================================================================= * | |
| * | |
| * system allocator includes. | |
| * | |
| * ================================================================= */ | |
| #ifndef INCLUDED_STDLIB_H | |
| #include <stdlib.h> | |
| #define INCLUDED_STDLIB_H | |
| #endif | |
| /* ================================================================= * | |
| * | |
| * system allocator implementation. | |
| * | |
| * ================================================================= */ | |
| void * SAL_CALL rtl_allocateMemory (sal_Size n) | |
| { | |
| return malloc (n); | |
| } | |
| /* ================================================================= */ | |
| void SAL_CALL rtl_freeMemory (void * p) | |
| { | |
| free (p); | |
| } | |
| /* ================================================================= */ | |
| void * SAL_CALL rtl_reallocateMemory (void * p, sal_Size n) | |
| { | |
| return realloc (p, n); | |
| } | |
| /* ================================================================= */ | |
| void | |
| rtl_memory_fini (void) | |
| { | |
| /* nothing to do */ | |
| } | |
| #endif /* FORCE_SYSALLOC */ | |
| /* ================================================================= * | |
| * | |
| * rtl_(allocate|free)ZeroMemory() implementation. | |
| * | |
| * ================================================================= */ | |
| void * SAL_CALL rtl_allocateZeroMemory (sal_Size n) SAL_THROW_EXTERN_C() | |
| { | |
| void * p = rtl_allocateMemory (n); | |
| if (p != 0) | |
| memset (p, 0, n); | |
| return (p); | |
| } | |
| /* ================================================================= */ | |
| void SAL_CALL rtl_freeZeroMemory (void * p, sal_Size n) SAL_THROW_EXTERN_C() | |
| { | |
| if (p != 0) | |
| { | |
| memset (p, 0, n); | |
| rtl_freeMemory (p); | |
| } | |
| } | |
| /* ================================================================= */ |