sc/inc/interpretercontext.hxx

   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
  10 #pragma once
  11
  12 #include <array>
  13 #include <memory>
  14 #include <random>
  15 #include <vector>
  16 #include <i18nlangtag/lang.h>
  17 #include <svl/numformat.hxx>
  18 #include "types.hxx"
  19
  20 namespace formula
  21 {
  22 class FormulaTypedDoubleToken;
  23 }
  24
  25 #define TOKEN_CACHE_SIZE 8
  26
  27 class ScDocument;
  28 class SvNumberFormatter;
  29 struct ScLookupCacheMap;
  30 class ScInterpreter;
  31 enum class SvNumFormatType : sal_Int16;
  32
  33 // SetNumberFormat() is not thread-safe, so calls to it need to be delayed to the main thread.
  34 struct DelayedSetNumberFormat
  35 {
  36     SCCOL mCol;
  37     SCROW mRow;
  38     sal_uInt32 mnNumberFormat;
  39 };
  40
  41 class ScInterpreterContextPool;
  42
  43 struct ScInterpreterContext
  44 {
  45     const ScDocument* mpDoc;
  46     size_t mnTokenCachePos;
  47     std::vector<formula::FormulaTypedDoubleToken*> maTokens;
  48     std::vector<DelayedSetNumberFormat> maDelayedSetNumberFormat;
  49     std::unique_ptr<ScLookupCacheMap> mxScLookupCache; // cache for lookups like VLOOKUP and MATCH
  50     // Allocation cache for "aConditions" array in ScInterpreter::IterateParameterIfs()
  51     // This is populated/used only when formula-group threading is enabled.
  52     std::vector<sal_uInt8> maConditions;
  53     std::mt19937 aRNG;
  54     ScInterpreter* pInterpreter;
  55
  56     ScInterpreterContext(const ScDocument& rDoc, SvNumberFormatter* pFormatter);
  57
  58     ScInterpreterContext() = delete;
  59
  60     ~ScInterpreterContext();
  61
  62     SvNumberFormatter* GetFormatTable() const
  63     {
  64         if (mpFormatter == nullptr)
  65             const_cast<ScInterpreterContext*>(this)->initFormatTable();
  66         return mpFormatter;
  67     }
  68
  69     SvNumFormatType GetNumberFormatType(sal_uInt32 nFIndex) const;
  70
  71     sal_uInt32 GetFormatForLanguageIfBuiltIn(sal_uInt32 nFormat, LanguageType eLnge) const;
  72
  73 private:
  74     friend class ScInterpreterContextPool;
  75     void ResetTokens();
  76     void SetDocAndFormatter(const ScDocument& rDoc, SvNumberFormatter* pFormatter);
  77     void Cleanup();
  78     void ClearLookupCache(const ScDocument* pDoc);
  79     void initFormatTable();
  80     SvNumberFormatter* mpFormatter;
  81
  82     // Some temp caches of the 4 most recent results from NumberFormatting
  83     // lookups.
  84     struct NFBuiltIn
  85     {
  86         sal_uInt64 nKey;
  87         sal_uInt32 nFormat;
  88         NFBuiltIn()
  89             : nKey(SAL_MAX_UINT64)
  90             , nFormat(SAL_MAX_UINT32)
  91         {
  92         }
  93     };
  94     // from format+lang to builtin format
  95     mutable std::array<NFBuiltIn, 4> maNFBuiltInCache;
  96     struct NFType
  97     {
  98         sal_uInt32 nKey;
  99         SvNumFormatType eType;
 100         NFType()
 101             : nKey(SAL_MAX_UINT32)
 102             , eType(SvNumFormatType::ALL)
 103         {
 104         }
 105     };
 106     // from format index to type
 107     mutable std::array<NFType, 4> maNFTypeCache;
 108 };
 109
 110 class ScThreadedInterpreterContextGetterGuard;
 111 class ScInterpreterContextGetterGuard;
 112
 113 class ScInterpreterContextPool
 114 {
 115     friend class ScThreadedInterpreterContextGetterGuard;
 116     friend class ScInterpreterContextGetterGuard;
 117
 118     std::vector<std::unique_ptr<ScInterpreterContext>> maPool;
 119     size_t mnNextFree;
 120     bool mbThreaded;
 121
 122     ScInterpreterContextPool(bool bThreaded)
 123         : mnNextFree(0)
 124         , mbThreaded(bThreaded)
 125     {
 126     }
 127
 128     ~ScInterpreterContextPool() {}
 129
 130     static ScInterpreterContextPool aThreadedInterpreterPool;
 131     static ScInterpreterContextPool aNonThreadedInterpreterPool;
 132
 133     // API for threaded case
 134
 135     // Ensures nNumThreads elements in pool.
 136     void Init(size_t nNumThreads, const ScDocument& rDoc, SvNumberFormatter* pFormatter);
 137
 138     // Returns ScInterpreterContext* for thread index nThreadIdx
 139     ScInterpreterContext* GetInterpreterContextForThreadIdx(size_t nThreadIdx) const;
 140
 141     // API for non-threaded
 142
 143     // Ensures there is one unused element in the pool.
 144     void Init(const ScDocument& rDoc, SvNumberFormatter* pFormatter);
 145
 146     // Returns ScInterpreterContext* for non-threaded use.
 147     ScInterpreterContext* GetInterpreterContext() const;
 148
 149     // Common API for threaded/non-threaded
 150
 151     // Cleans up the contexts prepared by call to immediately previous Init() and
 152     // marks them all as unused.
 153     void ReturnToPool();
 154
 155 public:
 156     // Only to be used to clear lookup cache in all pool elements
 157     static void ClearLookupCaches(const ScDocument* pDoc);
 158 };
 159
 160 class ScThreadedInterpreterContextGetterGuard
 161 {
 162     ScInterpreterContextPool& rPool;
 163
 164 public:
 165     ScThreadedInterpreterContextGetterGuard(size_t nNumThreads, const ScDocument& rDoc,
 166                                             SvNumberFormatter* pFormatter);
 167     ~ScThreadedInterpreterContextGetterGuard();
 168
 169     // Returns ScInterpreterContext* for thread index nThreadIdx
 170     ScInterpreterContext* GetInterpreterContextForThreadIdx(size_t nThreadIdx) const;
 171 };
 172
 173 class ScInterpreterContextGetterGuard
 174 {
 175     ScInterpreterContextPool& rPool;
 176 #if !defined NDEBUG
 177     size_t nContextIdx;
 178 #endif
 179
 180 public:
 181     ScInterpreterContextGetterGuard(const ScDocument& rDoc, SvNumberFormatter* pFormatter);
 182     ~ScInterpreterContextGetterGuard();
 183
 184     // Returns ScInterpreterContext* for non-threaded use.
 185     ScInterpreterContext* GetInterpreterContext() const;
 186 };
 187
 188 /* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */