vcl/source/graphic/Manager.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 <graphic/Manager.hxx>
  21 #include <impgraph.hxx>
  22 #include <sal/log.hxx>
  23
  24 #include <officecfg/Office/Common.hxx>
  25 #include <unotools/configmgr.hxx>
  26
  27 using namespace css;
  28
  29 namespace vcl
  30 {
  31 namespace graphic
  32 {
  33 namespace
  34 {
  35 void setupConfigurationValuesIfPossible(sal_Int64& rMemoryLimit,
  36                                         std::chrono::seconds& rAllowedIdleTime)
  37 {
  38     if (utl::ConfigManager::IsFuzzing())
  39         return;
  40
  41     try
  42     {
  43         using officecfg::Office::Common::Cache;
  44
  45         rMemoryLimit = Cache::GraphicManager::GraphicMemoryLimit::get();
  46         rAllowedIdleTime
  47             = std::chrono::seconds(Cache::GraphicManager::GraphicAllowedIdleTime::get());
  48     }
  49     catch (...)
  50     {
  51     }
  52 }
  53 }
  54
  55 Manager& Manager::get()
  56 {
  57     static std::unique_ptr<Manager> gStaticManager(new Manager);
  58     return *gStaticManager;
  59 }
  60
  61 Manager::Manager()
  62     : mnAllowedIdleTime(10)
  63     , mnMemoryLimit(300000000)
  64     , mnUsedSize(0)
  65     , maSwapOutTimer("graphic::Manager maSwapOutTimer")
  66 {
  67     setupConfigurationValuesIfPossible(mnMemoryLimit, mnAllowedIdleTime);
  68
  69     maSwapOutTimer.SetInvokeHandler(LINK(this, Manager, SwapOutTimerHandler));
  70     maSwapOutTimer.SetTimeout(10000);
  71     maSwapOutTimer.SetDebugName("graphic::Manager maSwapOutTimer");
  72     maSwapOutTimer.Start();
  73 }
  74
  75 void Manager::reduceGraphicMemory()
  76 {
  77     std::scoped_lock<std::recursive_mutex> aGuard(maMutex);
  78
  79     for (ImpGraphic* pEachImpGraphic : m_pImpGraphicList)
  80     {
  81         if (mnUsedSize < mnMemoryLimit * 0.7)
  82             return;
  83
  84         sal_Int64 nCurrentGraphicSize = getGraphicSizeBytes(pEachImpGraphic);
  85         if (!pEachImpGraphic->ImplIsSwapOut() && nCurrentGraphicSize > 1000000)
  86         {
  87             if (!pEachImpGraphic->mpContext)
  88             {
  89                 auto aCurrent = std::chrono::high_resolution_clock::now();
  90                 auto aDeltaTime = aCurrent - pEachImpGraphic->maLastUsed;
  91                 auto aSeconds = std::chrono::duration_cast<std::chrono::seconds>(aDeltaTime);
  92
  93                 if (aSeconds > mnAllowedIdleTime)
  94                     pEachImpGraphic->ImplSwapOut();
  95             }
  96         }
  97     }
  98 }
  99
 100 sal_Int64 Manager::getGraphicSizeBytes(const ImpGraphic* pImpGraphic)
 101 {
 102     if (!pImpGraphic->isAvailable())
 103         return 0;
 104     return pImpGraphic->ImplGetSizeBytes();
 105 }
 106
 107 IMPL_LINK(Manager, SwapOutTimerHandler, Timer*, pTimer, void)
 108 {
 109     std::scoped_lock<std::recursive_mutex> aGuard(maMutex);
 110
 111     pTimer->Stop();
 112     reduceGraphicMemory();
 113     pTimer->Start();
 114 }
 115
 116 void Manager::registerGraphic(const std::shared_ptr<ImpGraphic>& pImpGraphic,
 117                               OUString const& /*rsContext*/)
 118 {
 119     std::scoped_lock<std::recursive_mutex> aGuard(maMutex);
 120
 121     // make some space first
 122     if (mnUsedSize > mnMemoryLimit)
 123         reduceGraphicMemory();
 124
 125     // Insert and update the used size (bytes)
 126     mnUsedSize += getGraphicSizeBytes(pImpGraphic.get());
 127     m_pImpGraphicList.insert(pImpGraphic.get());
 128
 129     // calculate size of the graphic set
 130     sal_Int64 calculatedSize = 0;
 131     for (ImpGraphic* pEachImpGraphic : m_pImpGraphicList)
 132     {
 133         if (!pEachImpGraphic->ImplIsSwapOut())
 134         {
 135             calculatedSize += getGraphicSizeBytes(pEachImpGraphic);
 136         }
 137     }
 138
 139     if (calculatedSize != mnUsedSize)
 140     {
 141         SAL_INFO_IF(calculatedSize != mnUsedSize, "vcl.gdi",
 142                     "Calculated size mismatch. Variable size is '"
 143                         << mnUsedSize << "' but calculated size is '" << calculatedSize << "'");
 144         mnUsedSize = calculatedSize;
 145     }
 146 }
 147
 148 void Manager::unregisterGraphic(ImpGraphic* pImpGraphic)
 149 {
 150     std::scoped_lock<std::recursive_mutex> aGuard(maMutex);
 151
 152     mnUsedSize -= getGraphicSizeBytes(pImpGraphic);
 153     m_pImpGraphicList.erase(pImpGraphic);
 154 }
 155
 156 std::shared_ptr<ImpGraphic> Manager::copy(std::shared_ptr<ImpGraphic> const& rImpGraphicPtr)
 157 {
 158     auto pReturn = std::make_shared<ImpGraphic>(*rImpGraphicPtr);
 159     registerGraphic(pReturn, "Copy");
 160     return pReturn;
 161 }
 162
 163 std::shared_ptr<ImpGraphic> Manager::newInstance()
 164 {
 165     auto pReturn = std::make_shared<ImpGraphic>();
 166     registerGraphic(pReturn, "Empty");
 167     return pReturn;
 168 }
 169
 170 std::shared_ptr<ImpGraphic> Manager::newInstance(const Bitmap& rBitmap)
 171 {
 172     auto pReturn = std::make_shared<ImpGraphic>(rBitmap);
 173     registerGraphic(pReturn, "Bitmap");
 174     return pReturn;
 175 }
 176
 177 std::shared_ptr<ImpGraphic> Manager::newInstance(const BitmapEx& rBitmapEx)
 178 {
 179     auto pReturn = std::make_shared<ImpGraphic>(rBitmapEx);
 180     registerGraphic(pReturn, "BitmapEx");
 181     return pReturn;
 182 }
 183
 184 std::shared_ptr<ImpGraphic> Manager::newInstance(const Animation& rAnimation)
 185 {
 186     auto pReturn = std::make_shared<ImpGraphic>(rAnimation);
 187     registerGraphic(pReturn, "Animation");
 188     return pReturn;
 189 }
 190
 191 std::shared_ptr<ImpGraphic> Manager::newInstance(const VectorGraphicDataPtr& rVectorGraphicDataPtr)
 192 {
 193     auto pReturn = std::make_shared<ImpGraphic>(rVectorGraphicDataPtr);
 194     registerGraphic(pReturn, "VectorGraphic");
 195     return pReturn;
 196 }
 197
 198 std::shared_ptr<ImpGraphic> Manager::newInstance(const GDIMetaFile& rMetaFile)
 199 {
 200     auto pReturn = std::make_shared<ImpGraphic>(rMetaFile);
 201     registerGraphic(pReturn, "Metafile");
 202     return pReturn;
 203 }
 204
 205 std::shared_ptr<ImpGraphic> Manager::newInstance(const GraphicExternalLink& rGraphicLink)
 206 {
 207     auto pReturn = std::make_shared<ImpGraphic>(rGraphicLink);
 208     registerGraphic(pReturn, "GraphicExternalLink");
 209     return pReturn;
 210 }
 211
 212 void Manager::swappedIn(const ImpGraphic* pImpGraphic)
 213 {
 214     std::scoped_lock<std::recursive_mutex> aGuard(maMutex);
 215
 216     mnUsedSize += getGraphicSizeBytes(pImpGraphic);
 217 }
 218
 219 void Manager::swappedOut(const ImpGraphic* pImpGraphic)
 220 {
 221     std::scoped_lock<std::recursive_mutex> aGuard(maMutex);
 222
 223     mnUsedSize -= getGraphicSizeBytes(pImpGraphic);
 224 }
 225
 226 void Manager::changeExisting(const ImpGraphic* pImpGraphic, sal_Int64 nOldSizeBytes)
 227 {
 228     std::scoped_lock<std::recursive_mutex> aGuard(maMutex);
 229
 230     mnUsedSize -= nOldSizeBytes;
 231     mnUsedSize += getGraphicSizeBytes(pImpGraphic);
 232 }
 233 }
 234 } // end vcl::graphic
 235
 236 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */