sal/rtl/alloc_cache.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "alloc_cache.hxx"
  21 #include "alloc_impl.hxx"
  22 #include "alloc_arena.hxx"
  23 #include <rtllifecycle.h>
  24
  25 #include <cassert>
  26 #include <cstdlib>
  27 #include <string.h>
  28 #include <stdio.h>
  29
  30 /**
  31     provided for cache_type allocations, and hash_table resizing.
  32
  33     @internal
  34 */
  35 static rtl_arena_type * gp_cache_arena = nullptr;
  36
  37 namespace
  38 {
  39
  40 rtl_cache_type * rtl_cache_activate(
  41     rtl_cache_type * cache,
  42     const char *     name,
  43     size_t           objsize,
  44     size_t           objalign,
  45     int  (SAL_CALL * constructor)(void * obj, void * userarg),
  46     void (SAL_CALL * destructor) (void * obj, void * userarg),
  47     void *           userarg
  48 )
  49 {
  50     assert(cache);
  51
  52     snprintf (cache->m_name, sizeof(cache->m_name), "%s", name);
  53
  54     if (objalign == 0)
  55     {
  56         /* determine default alignment */
  57         if (objsize >= RTL_MEMORY_ALIGNMENT_8)
  58             objalign = RTL_MEMORY_ALIGNMENT_8;
  59         else
  60             objalign = RTL_MEMORY_ALIGNMENT_4;
  61     }
  62     else
  63     {
  64         /* ensure minimum alignment */
  65         if(objalign < RTL_MEMORY_ALIGNMENT_4)
  66         {
  67             objalign = RTL_MEMORY_ALIGNMENT_4;
  68         }
  69     }
  70     assert(RTL_MEMORY_ISP2(objalign));
  71
  72     cache->m_type_size = RTL_MEMORY_P2ROUNDUP(objsize, objalign);
  73
  74     cache->m_constructor = constructor;
  75     cache->m_destructor  = destructor;
  76     cache->m_userarg     = userarg;
  77
  78     return cache;
  79 }
  80
  81 } //namespace
  82
  83 rtl_cache_type * SAL_CALL rtl_cache_create(
  84     const char *     name,
  85     sal_Size         objsize,
  86     sal_Size         objalign,
  87     int  (SAL_CALL * constructor)(void * obj, void * userarg),
  88     void (SAL_CALL * destructor) (void * obj, void * userarg),
  89     void (SAL_CALL * /*reclaim*/)    (void * userarg),
  90     void *           userarg,
  91     rtl_arena_type *,
  92     int
  93 ) SAL_THROW_EXTERN_C()
  94 {
  95     rtl_cache_type * result = nullptr;
  96     sal_Size         size   = sizeof(rtl_cache_type);
  97
  98 try_alloc:
  99     result = static_cast<rtl_cache_type*>(rtl_arena_alloc (gp_cache_arena, &size));
 100     if (result)
 101     {
 102         rtl_cache_type * cache = result;
 103         memset (cache, 0, sizeof(rtl_cache_type));
 104
 105         result = rtl_cache_activate (
 106             cache,
 107             name,
 108             objsize,
 109             objalign,
 110             constructor,
 111             destructor,
 112             userarg
 113         );
 114
 115         if (!result)
 116         {
 117             /* activation failed */
 118             rtl_arena_free (gp_cache_arena, cache, size);
 119         }
 120     }
 121     else if (!gp_cache_arena)
 122     {
 123         ensureCacheSingleton();
 124         if (gp_cache_arena)
 125         {
 126             /* try again */
 127             goto try_alloc;
 128         }
 129     }
 130     return result;
 131 }
 132
 133 void SAL_CALL rtl_cache_destroy(rtl_cache_type * cache) SAL_THROW_EXTERN_C()
 134 {
 135     if (cache)
 136     {
 137         rtl_arena_free (gp_cache_arena, cache, sizeof(rtl_cache_type));
 138     }
 139 }
 140
 141 void * SAL_CALL rtl_cache_alloc(rtl_cache_type * cache) SAL_THROW_EXTERN_C()
 142 {
 143     void * obj = nullptr;
 144
 145     if (!cache)
 146         return nullptr;
 147
 148     obj = std::malloc(cache->m_type_size);
 149     if (obj && cache->m_constructor)
 150     {
 151         if (!(cache->m_constructor)(obj, cache->m_userarg))
 152         {
 153             /* construction failure */
 154             std::free(obj);
 155             obj = nullptr;
 156         }
 157     }
 158     return obj;
 159 }
 160
 161 void SAL_CALL rtl_cache_free(
 162     rtl_cache_type * cache,
 163     void *           obj
 164 ) SAL_THROW_EXTERN_C()
 165 {
 166     if (obj && cache)
 167     {
 168         if (cache->m_destructor)
 169         {
 170             /* destruct object */
 171             (cache->m_destructor)(obj, cache->m_userarg);
 172         }
 173         std::free(obj);
 174     }
 175 }
 176
 177 #if defined(SAL_UNX)
 178
 179 void SAL_CALL rtl_secureZeroMemory(void *Ptr, sal_Size Bytes) SAL_THROW_EXTERN_C()
 180 {
 181     //currently glibc doesn't implement memset_s
 182     volatile char *p = static_cast<volatile char*>(Ptr);
 183     while (Bytes--)
 184         *p++ = 0;
 185 }
 186
 187 #elif defined(_WIN32)
 188
 189 void SAL_CALL rtl_secureZeroMemory(void *Ptr, sal_Size Bytes) SAL_THROW_EXTERN_C()
 190 {
 191     RtlSecureZeroMemory(Ptr, Bytes);
 192 }
 193
 194 #endif /* SAL_UNX || _WIN32 */
 195
 196 void rtl_cache_init()
 197 {
 198     /* cache: internal arena */
 199     assert(!gp_cache_arena);
 200
 201     gp_cache_arena = rtl_arena_create (
 202         "rtl_cache_internal_arena",
 203         64,   /* quantum */
 204         0,    /* no quantum caching */
 205         nullptr, /* default source */
 206         rtl_arena_alloc,
 207         rtl_arena_free,
 208         0     /* flags */
 209     );
 210     assert(gp_cache_arena);
 211
 212     /* check 'gp_default_arena' initialization */
 213     assert(gp_default_arena);
 214 }
 215
 216 void rtl_cache_fini()
 217 {
 218     if (gp_cache_arena)
 219     {
 220         rtl_arena_destroy (gp_cache_arena);
 221         gp_cache_arena = nullptr;
 222     }
 223 }
 224
 225 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */