sc/source/core/tool/formulagroup.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
  10 #include <config_features.h>
  11
  12 #include "formulagroup.hxx"
  13 #include "formulagroupcl.hxx"
  14 #include "document.hxx"
  15 #include "formulacell.hxx"
  16 #include "tokenarray.hxx"
  17 #include "compiler.hxx"
  18 #include "interpre.hxx"
  19 #include "scmatrix.hxx"
  20 #include "globalnames.hxx"
  21
  22 #include <formula/vectortoken.hxx>
  23 #include <officecfg/Office/Common.hxx>
  24 #if HAVE_FEATURE_OPENCL
  25 #include <opencl/platforminfo.hxx>
  26 #endif
  27 #include <rtl/bootstrap.hxx>
  28
  29 #include <cstdio>
  30 #include <unordered_map>
  31 #include <vector>
  32
  33 #if HAVE_FEATURE_OPENCL
  34 #include <opencl/openclwrapper.hxx>
  35 #endif
  36
  37 namespace sc {
  38
  39 FormulaGroupEntry::FormulaGroupEntry( ScFormulaCell** pCells, size_t nRow, size_t nLength ) :
  40     mpCells(pCells), mnRow(nRow), mnLength(nLength), mbShared(true) {}
  41
  42 FormulaGroupEntry::FormulaGroupEntry( ScFormulaCell* pCell, size_t nRow ) :
  43     mpCell(pCell), mnRow(nRow), mnLength(0), mbShared(false) {}
  44
  45 size_t FormulaGroupContext::ColKey::Hash::operator ()( const FormulaGroupContext::ColKey& rKey ) const
  46 {
  47     return rKey.mnTab * MAXCOLCOUNT + rKey.mnCol;
  48 }
  49
  50 FormulaGroupContext::ColKey::ColKey( SCTAB nTab, SCCOL nCol ) : mnTab(nTab), mnCol(nCol) {}
  51
  52 bool FormulaGroupContext::ColKey::operator== ( const ColKey& r ) const
  53 {
  54     return mnTab == r.mnTab && mnCol == r.mnCol;
  55 }
  56
  57 bool FormulaGroupContext::ColKey::operator!= ( const ColKey& r ) const
  58 {
  59     return !operator==(r);
  60 }
  61
  62 FormulaGroupContext::ColArray::ColArray( NumArrayType* pNumArray, StrArrayType* pStrArray ) :
  63     mpNumArray(pNumArray), mpStrArray(pStrArray), mnSize(0)
  64 {
  65     if (mpNumArray)
  66         mnSize = mpNumArray->size();
  67     else if (mpStrArray)
  68         mnSize = mpStrArray->size();
  69 }
  70
  71 FormulaGroupContext::ColArray* FormulaGroupContext::getCachedColArray( SCTAB nTab, SCCOL nCol, size_t nSize )
  72 {
  73     ColArraysType::iterator itColArray = maColArrays.find(ColKey(nTab, nCol));
  74     if (itColArray == maColArrays.end())
  75         // Not cached for this column.
  76         return NULL;
  77
  78     ColArray& rCached = itColArray->second;
  79     if (nSize > rCached.mnSize)
  80         // Cached data array is not long enough for the requested range.
  81         return NULL;
  82
  83     return &rCached;
  84 }
  85
  86 FormulaGroupContext::ColArray* FormulaGroupContext::setCachedColArray(
  87     SCTAB nTab, SCCOL nCol, NumArrayType* pNumArray, StrArrayType* pStrArray )
  88 {
  89     ColArraysType::iterator it = maColArrays.find(ColKey(nTab, nCol));
  90     if (it == maColArrays.end())
  91     {
  92         std::pair<ColArraysType::iterator,bool> r =
  93             maColArrays.insert(
  94                 ColArraysType::value_type(ColKey(nTab, nCol), ColArray(pNumArray, pStrArray)));
  95
  96         if (!r.second)
  97             // Somehow the insertion failed.
  98             return NULL;
  99
 100         return &r.first->second;
 101     }
 102
 103     // Prior array exists for this column. Overwrite it.
 104     ColArray& rArray = it->second;
 105     rArray = ColArray(pNumArray, pStrArray);
 106     return &rArray;
 107 }
 108
 109 void FormulaGroupContext::ensureStrArray( ColArray& rColArray, size_t nArrayLen )
 110 {
 111     if (rColArray.mpStrArray)
 112         return;
 113
 114     maStrArrays.push_back(
 115         new sc::FormulaGroupContext::StrArrayType(nArrayLen, NULL));
 116     rColArray.mpStrArray = &maStrArrays.back();
 117 }
 118
 119 void FormulaGroupContext::ensureNumArray( ColArray& rColArray, size_t nArrayLen )
 120 {
 121     if (rColArray.mpNumArray)
 122         return;
 123
 124     double fNan;
 125     rtl::math::setNan(&fNan);
 126
 127     maNumArrays.push_back(
 128         new sc::FormulaGroupContext::NumArrayType(nArrayLen, fNan));
 129     rColArray.mpNumArray = &maNumArrays.back();
 130 }
 131
 132 FormulaGroupContext::FormulaGroupContext()
 133 {
 134 }
 135
 136 FormulaGroupContext::~FormulaGroupContext()
 137 {
 138 }
 139
 140 namespace {
 141
 142 /**
 143  * Input double array consists of segments of NaN's and normal values.
 144  * Insert only the normal values into the matrix while skipping the NaN's.
 145  */
 146 void fillMatrix( ScMatrix& rMat, size_t nCol, const double* pNums, size_t nLen )
 147 {
 148     const double* pNum = pNums;
 149     const double* pNumEnd = pNum + nLen;
 150     const double* pNumHead = NULL;
 151     for (; pNum != pNumEnd; ++pNum)
 152     {
 153         if (!rtl::math::isNan(*pNum))
 154         {
 155             if (!pNumHead)
 156                 // Store the first non-NaN position.
 157                 pNumHead = pNum;
 158
 159             continue;
 160         }
 161
 162         if (pNumHead)
 163         {
 164             // Flush this non-NaN segment to the matrix.
 165             rMat.PutDouble(pNumHead, pNum - pNumHead, nCol, pNumHead - pNums);
 166             pNumHead = NULL;
 167         }
 168     }
 169
 170     if (pNumHead)
 171     {
 172         // Flush last non-NaN segment to the matrix.
 173         rMat.PutDouble(pNumHead, pNum - pNumHead, nCol, pNumHead - pNums);
 174     }
 175 }
 176
 177 void flushStrSegment(
 178     ScMatrix& rMat, size_t nCol, rtl_uString** pHead, rtl_uString** pCur, rtl_uString** pTop )
 179 {
 180     size_t nOffset = pHead - pTop;
 181     std::vector<svl::SharedString> aStrs;
 182     aStrs.reserve(pCur - pHead);
 183     for (; pHead != pCur; ++pHead)
 184         aStrs.push_back(svl::SharedString(*pHead, *pHead));
 185
 186     rMat.PutString(&aStrs[0], aStrs.size(), nCol, nOffset);
 187 }
 188
 189 void fillMatrix( ScMatrix& rMat, size_t nCol, rtl_uString** pStrs, size_t nLen )
 190 {
 191     rtl_uString** p = pStrs;
 192     rtl_uString** pEnd = p + nLen;
 193     rtl_uString** pHead = NULL;
 194     for (; p != pEnd; ++p)
 195     {
 196         if (*p)
 197         {
 198             if (!pHead)
 199                 // Store the first non-empty string position.
 200                 pHead = p;
 201
 202             continue;
 203         }
 204
 205         if (pHead)
 206         {
 207             // Flush this non-empty segment to the matrix.
 208             flushStrSegment(rMat, nCol, pHead, p, pStrs);
 209             pHead = NULL;
 210         }
 211     }
 212
 213     if (pHead)
 214     {
 215         // Flush last non-empty segment to the matrix.
 216         flushStrSegment(rMat, nCol, pHead, p, pStrs);
 217     }
 218 }
 219
 220 void fillMatrix( ScMatrix& rMat, size_t nCol, const double* pNums, rtl_uString** pStrs, size_t nLen )
 221 {
 222     if (!pStrs)
 223     {
 224         fillMatrix(rMat, nCol, pNums, nLen);
 225         return;
 226     }
 227
 228     const double* pNum = pNums;
 229     const double* pNumHead = NULL;
 230     rtl_uString** pStr = pStrs;
 231     rtl_uString** pStrEnd = pStr + nLen;
 232     rtl_uString** pStrHead = NULL;
 233
 234     for (; pStr != pStrEnd; ++pStr, ++pNum)
 235     {
 236         if (*pStr)
 237         {
 238             // String cell exists.
 239
 240             if (pNumHead)
 241             {
 242                 // Flush this numeric segment to the matrix.
 243                 rMat.PutDouble(pNumHead, pNum - pNumHead, nCol, pNumHead - pNums);
 244                 pNumHead = NULL;
 245             }
 246
 247             if (!pStrHead)
 248                 // Store the first non-empty string position.
 249                 pStrHead = pStr;
 250
 251             continue;
 252         }
 253
 254         // No string cell. Check the numeric cell value.
 255
 256         if (pStrHead)
 257         {
 258             // Flush this non-empty string segment to the matrix.
 259             flushStrSegment(rMat, nCol, pStrHead, pStr, pStrs);
 260             pStrHead = NULL;
 261         }
 262
 263         if (!rtl::math::isNan(*pNum))
 264         {
 265             // Numeric cell exists.
 266             if (!pNumHead)
 267                 // Store the first non-NaN position.
 268                 pNumHead = pNum;
 269
 270             continue;
 271         }
 272
 273         // Empty cell. No action required.
 274     }
 275
 276     if (pStrHead)
 277     {
 278         // Flush the last non-empty segment to the matrix.
 279         flushStrSegment(rMat, nCol, pStrHead, pStr, pStrs);
 280     }
 281     else if (pNumHead)
 282     {
 283         // Flush the last numeric segment to the matrix.
 284         rMat.PutDouble(pNumHead, pNum - pNumHead, nCol, pNumHead - pNums);
 285     }
 286 }
 287
 288 }
 289
 290 CompiledFormula::CompiledFormula() {}
 291
 292 CompiledFormula::~CompiledFormula() {}
 293
 294 FormulaGroupInterpreterSoftware::FormulaGroupInterpreterSoftware() : FormulaGroupInterpreter()
 295 {
 296 }
 297
 298 ScMatrixRef FormulaGroupInterpreterSoftware::inverseMatrix(const ScMatrix& /*rMat*/)
 299 {
 300     return ScMatrixRef();
 301 }
 302
 303 CompiledFormula* FormulaGroupInterpreterSoftware::createCompiledFormula(
 304     ScFormulaCellGroup& /*rGroup*/, ScTokenArray& /*rCode*/ )
 305 {
 306     return NULL;
 307 }
 308
 309 bool FormulaGroupInterpreterSoftware::interpret(ScDocument& rDoc, const ScAddress& rTopPos,
 310                                                 ScFormulaCellGroupRef& xGroup,
 311                                                 ScTokenArray& rCode)
 312 {
 313     typedef std::unordered_map<const formula::FormulaToken*, formula::FormulaTokenRef> CachedTokensType;
 314
 315     // Decompose the group into individual cells and calculate them individually.
 316
 317     // The caller must ensure that the top position is the start position of
 318     // the group.
 319
 320     ScAddress aTmpPos = rTopPos;
 321     std::vector<formula::FormulaTokenRef> aResults;
 322     aResults.reserve(xGroup->mnLength);
 323     CachedTokensType aCachedTokens;
 324
 325     double fNan;
 326     rtl::math::setNan(&fNan);
 327
 328     for (SCROW i = 0; i < xGroup->mnLength; ++i, aTmpPos.IncRow())
 329     {
 330         ScTokenArray aCode2;
 331         for (const formula::FormulaToken* p = rCode.First(); p; p = rCode.Next())
 332         {
 333             CachedTokensType::iterator it = aCachedTokens.find(p);
 334             if (it != aCachedTokens.end())
 335             {
 336                 // This token is cached. Use the cached one.
 337                 aCode2.AddToken(*it->second);
 338                 continue;
 339             }
 340
 341             switch (p->GetType())
 342             {
 343                 case formula::svSingleVectorRef:
 344                 {
 345                     const formula::SingleVectorRefToken* p2 = static_cast<const formula::SingleVectorRefToken*>(p);
 346                     const formula::VectorRefArray& rArray = p2->GetArray();
 347
 348                     rtl_uString* pStr = NULL;
 349                     double fVal = fNan;
 350                     if (static_cast<size_t>(i) < p2->GetArrayLength())
 351                     {
 352                         if (rArray.mpStringArray)
 353                             // See if the cell is of string type.
 354                             pStr = rArray.mpStringArray[i];
 355
 356                         if (!pStr && rArray.mpNumericArray)
 357                             fVal = rArray.mpNumericArray[i];
 358                     }
 359
 360                     if (pStr)
 361                     {
 362                         // This is a string cell.
 363                         svl::SharedStringPool& rPool = rDoc.GetSharedStringPool();
 364                         aCode2.AddString(rPool.intern(OUString(pStr)));
 365                     }
 366                     else if (rtl::math::isNan(fVal))
 367                         // Value of NaN represents an empty cell.
 368                         aCode2.AddToken(ScEmptyCellToken(false, false));
 369                     else
 370                         // Numeric cell.
 371                         aCode2.AddDouble(fVal);
 372                 }
 373                 break;
 374                 case formula::svDoubleVectorRef:
 375                 {
 376                     const formula::DoubleVectorRefToken* p2 = static_cast<const formula::DoubleVectorRefToken*>(p);
 377                     const std::vector<formula::VectorRefArray>& rArrays = p2->GetArrays();
 378                     size_t nColSize = rArrays.size();
 379                     size_t nRowStart = p2->IsStartFixed() ? 0 : i;
 380                     size_t nRowEnd = p2->GetRefRowSize() - 1;
 381                     if (!p2->IsEndFixed())
 382                         nRowEnd += i;
 383                     size_t nRowSize = nRowEnd - nRowStart + 1;
 384                     ScMatrixRef pMat(new ScMatrix(nColSize, nRowSize));
 385
 386                     size_t nDataRowEnd = p2->GetArrayLength() - 1;
 387                     if (nRowStart > nDataRowEnd)
 388                         // Referenced rows are all empty.
 389                         nRowSize = 0;
 390                     else if (nRowEnd > nDataRowEnd)
 391                         // Data array is shorter than the row size of the reference. Truncate it to the data.
 392                         nRowSize -= nRowEnd - nDataRowEnd;
 393
 394                     for (size_t nCol = 0; nCol < nColSize; ++nCol)
 395                     {
 396                         const formula::VectorRefArray& rArray = rArrays[nCol];
 397                         if (rArray.mpStringArray)
 398                         {
 399                             if (rArray.mpNumericArray)
 400                             {
 401                                 // Mixture of string and numeric values.
 402                                 const double* pNums = rArray.mpNumericArray;
 403                                 pNums += nRowStart;
 404                                 rtl_uString** pStrs = rArray.mpStringArray;
 405                                 pStrs += nRowStart;
 406                                 fillMatrix(*pMat, nCol, pNums, pStrs, nRowSize);
 407                             }
 408                             else
 409                             {
 410                                 // String cells only.
 411                                 rtl_uString** pStrs = rArray.mpStringArray;
 412                                 pStrs += nRowStart;
 413                                 fillMatrix(*pMat, nCol, pStrs, nRowSize);
 414                             }
 415                         }
 416                         else if (rArray.mpNumericArray)
 417                         {
 418                             // Numeric cells only.
 419                             const double* pNums = rArray.mpNumericArray;
 420                             pNums += nRowStart;
 421                             fillMatrix(*pMat, nCol, pNums, nRowSize);
 422                         }
 423                     }
 424
 425                     if (p2->IsStartFixed() && p2->IsEndFixed())
 426                     {
 427                         // Cached the converted token for absolute range referene.
 428                         ScComplexRefData aRef;
 429                         ScRange aRefRange = rTopPos;
 430                         aRefRange.aEnd.SetRow(rTopPos.Row() + nRowEnd);
 431                         aRef.InitRange(aRefRange);
 432                         formula::FormulaTokenRef xTok(new ScMatrixRangeToken(pMat, aRef));
 433                         aCachedTokens.insert(CachedTokensType::value_type(p, xTok));
 434                         aCode2.AddToken(*xTok);
 435                     }
 436                     else
 437                     {
 438                         ScMatrixToken aTok(pMat);
 439                         aCode2.AddToken(aTok);
 440                     }
 441                 }
 442                 break;
 443                 default:
 444                     aCode2.AddToken(*p);
 445             }
 446         }
 447
 448         ScFormulaCell* pDest = rDoc.GetFormulaCell(aTmpPos);
 449         if (!pDest)
 450             return false;
 451
 452         ScCompiler aComp(&rDoc, aTmpPos, aCode2);
 453         aComp.CompileTokenArray();
 454         ScInterpreter aInterpreter(pDest, &rDoc, aTmpPos, aCode2);
 455         aInterpreter.Interpret();
 456         aResults.push_back(aInterpreter.GetResultToken());
 457     } // for loop end (xGroup->mnLength)
 458
 459     if (!aResults.empty())
 460         rDoc.SetFormulaResults(rTopPos, &aResults[0], aResults.size());
 461
 462     return true;
 463 }
 464
 465 FormulaGroupInterpreter *FormulaGroupInterpreter::msInstance = NULL;
 466
 467 void FormulaGroupInterpreter::MergeCalcConfig(const ScDocument& rDoc)
 468 {
 469     maCalcConfig = ScInterpreter::GetGlobalConfig();
 470     maCalcConfig.MergeDocumentSpecific(rDoc.GetCalcConfig());
 471 }
 472
 473 /// load and/or configure the correct formula group interpreter
 474 FormulaGroupInterpreter *FormulaGroupInterpreter::getStatic()
 475 {
 476     if ( !msInstance )
 477     {
 478 #if HAVE_FEATURE_OPENCL
 479         const ScCalcConfig& rConfig = ScInterpreter::GetGlobalConfig();
 480         if (officecfg::Office::Common::Misc::UseOpenCL::get())
 481             switchOpenCLDevice(rConfig.maOpenCLDevice, rConfig.mbOpenCLAutoSelect, false);
 482 #endif
 483         static bool bAllowSoftwareInterpreter = (getenv("SC_ALLOW_BROKEN_SOFTWARE_INTERPRETER") != NULL);
 484
 485         if ( !msInstance && bAllowSoftwareInterpreter ) // software fallback
 486         {
 487             SAL_INFO("sc.formulagroup", "Create S/W interpreter");
 488             msInstance = new sc::FormulaGroupInterpreterSoftware();
 489         }
 490     }
 491
 492     return msInstance;
 493 }
 494
 495 #if HAVE_FEATURE_OPENCL
 496 void FormulaGroupInterpreter::fillOpenCLInfo(std::vector<OpenCLPlatformInfo>& rPlatforms)
 497 {
 498     const std::vector<OpenCLPlatformInfo>& rPlatformsFromWrapper =
 499         ::opencl::fillOpenCLInfo();
 500
 501     rPlatforms.assign(rPlatformsFromWrapper.begin(), rPlatformsFromWrapper.end());
 502 }
 503
 504 bool FormulaGroupInterpreter::switchOpenCLDevice(const OUString& rDeviceId, bool bAutoSelect, bool bForceEvaluation)
 505 {
 506     bool bOpenCLEnabled = officecfg::Office::Common::Misc::UseOpenCL::get();
 507     static bool bAllowSoftwareInterpreter = (getenv("SC_ALLOW_BROKEN_SOFTWARE_INTERPRETER") != NULL);
 508     if (!bOpenCLEnabled || (bAllowSoftwareInterpreter && rDeviceId == OPENCL_SOFTWARE_DEVICE_CONFIG_NAME))
 509     {
 510         if(msInstance)
 511         {
 512             // if we already have a software interpreter don't delete it
 513             if(dynamic_cast<sc::FormulaGroupInterpreterSoftware*>(msInstance))
 514                 return true;
 515
 516             delete msInstance;
 517         }
 518
 519         msInstance = new sc::FormulaGroupInterpreterSoftware();
 520         return true;
 521     }
 522     bool bSuccess = ::opencl::switchOpenCLDevice(&rDeviceId, bAutoSelect, bForceEvaluation);
 523     if(!bSuccess)
 524         return false;
 525
 526     delete msInstance;
 527     msInstance = NULL;
 528
 529     if ( officecfg::Office::Common::Misc::UseOpenCL::get() )
 530     {
 531         msInstance = new sc::opencl::FormulaGroupInterpreterOpenCL();
 532         return msInstance != NULL;
 533     }
 534
 535     return false;
 536 }
 537
 538 void FormulaGroupInterpreter::getOpenCLDeviceInfo(sal_Int32& rDeviceId, sal_Int32& rPlatformId)
 539 {
 540     rDeviceId = -1;
 541     rPlatformId = -1;
 542     bool bOpenCLEnabled = officecfg::Office::Common::Misc::UseOpenCL::get();
 543     if(!bOpenCLEnabled)
 544         return;
 545
 546     size_t aDeviceId = static_cast<size_t>(-1);
 547     size_t aPlatformId = static_cast<size_t>(-1);
 548
 549     ::opencl::getOpenCLDeviceInfo(aDeviceId, aPlatformId);
 550     rDeviceId = aDeviceId;
 551     rPlatformId = aPlatformId;
 552 }
 553
 554 void FormulaGroupInterpreter::enableOpenCL_UnitTestsOnly()
 555 {
 556     std::shared_ptr<comphelper::ConfigurationChanges> batch(comphelper::ConfigurationChanges::create());
 557     officecfg::Office::Common::Misc::UseOpenCL::set(true, batch);
 558     batch->commit();
 559
 560     ScCalcConfig aConfig = ScInterpreter::GetGlobalConfig();
 561
 562     aConfig.mbOpenCLSubsetOnly = false;
 563     aConfig.mnOpenCLMinimumFormulaGroupSize = 2;
 564
 565     ScInterpreter::SetGlobalConfig(aConfig);
 566 }
 567
 568 #endif
 569
 570 } // namespace sc
 571
 572 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */