Line data    Source code

       1             : /*
       2             :  * SPDX-License-Identifier: MPL-2.0
       3             :  *
       4             :  * This Source Code Form is subject to the terms of the Mozilla Public
       5             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       6             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       7             :  *
       8             :  * Copyright 2024 MonetDB Foundation;
       9             :  * Copyright August 2008 - 2023 MonetDB B.V.;
      10             :  * Copyright 1997 - July 2008 CWI.
      11             :  */
      12             : 
      13             : /*
      14             :  * This simple module unrolls the mat.pack into an incremental sequence.
      15             :  * This could speedup parallel processing and releases resources faster.
      16             :  */
      17             : #include "monetdb_config.h"
      18             : #include "opt_matpack.h"
      19             : 
      20             : str
      21      483985 : OPTmatpackImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk,
      22             :                                                  InstrPtr pci)
      23             : {
      24      483985 :         int v, i, j, limit, slimit;
      25      483985 :         InstrPtr p, q;
      26      483985 :         int actions = 0;
      27      483985 :         InstrPtr *old = NULL;
      28      483985 :         str msg = MAL_SUCCEED;
      29             : 
      30      483985 :         if (isOptimizerUsed(mb, pci, mergetableRef) <= 0) {
      31       32000 :                 goto wrapup;
      32             :         }
      33             : 
      34             :         (void) cntxt;
      35             :         (void) stk;                                     /* to fool compilers */
      36    19089193 :         for (i = 1; i < mb->stop; i++)
      37    18668155 :                 if (getModuleId(getInstrPtr(mb, i)) == matRef
      38       46095 :                         && getFunctionId(getInstrPtr(mb, i)) == packRef
      39       33322 :                         && isaBatType(getArgType(mb, getInstrPtr(mb, i), 1)))
      40             :                         break;
      41      451986 :         if (i == mb->stop)
      42      421038 :                 goto wrapup;
      43             : 
      44       30948 :         old = mb->stmt;
      45       30948 :         limit = mb->stop;
      46       30948 :         slimit = mb->ssize;
      47       30948 :         if (newMalBlkStmt(mb, mb->stop) < 0)
      48           0 :                 throw(MAL, "optimizer.matpack", SQLSTATE(HY013) MAL_MALLOC_FAIL);
      49             : 
      50     5774245 :         for (i = 0; mb->errors == NULL && i < limit; i++) {
      51     5743297 :                 p = old[i];
      52     5743297 :                 if (getModuleId(p) == matRef && getFunctionId(p) == packRef
      53      157713 :                         && isaBatType(getArgType(mb, p, 1))) {
      54      155577 :                         q = newInstruction(0, matRef, packIncrementRef);
      55      155577 :                         if (q == NULL) {
      56           0 :                                 msg = createException(MAL, "optimizer.matpack",
      57             :                                                                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
      58           0 :                                 break;
      59             :                         }
      60      155577 :                         if (setDestVar(q, newTmpVariable(mb, getArgType(mb, p, 1))) < 0) {
      61           0 :                                 freeInstruction(q);
      62           0 :                                 msg = createException(MAL, "optimizer.matpack",
      63             :                                                                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
      64           0 :                                 break;
      65             :                         }
      66      155577 :                         q = pushArgument(mb, q, getArg(p, 1));
      67      155577 :                         v = getArg(q, 0);
      68      155577 :                         q = pushInt(mb, q, p->argc - p->retc);
      69      155577 :                         pushInstruction(mb, q);
      70      155577 :                         typeChecker(cntxt->usermodule, mb, q, mb->stop - 1, TRUE);
      71             : 
      72      772329 :                         for (j = 2; j < p->argc; j++) {
      73      461175 :                                 q = newInstruction(0, matRef, packIncrementRef);
      74      461175 :                                 if (q == NULL) {
      75           0 :                                         msg = createException(MAL, "optimizer.matpack",
      76             :                                                                                   SQLSTATE(HY013) MAL_MALLOC_FAIL);
      77           0 :                                         break;
      78             :                                 }
      79      461175 :                                 q = pushArgument(mb, q, v);
      80      461175 :                                 q = pushArgument(mb, q, getArg(p, j));
      81      461175 :                                 if (setDestVar(q, newTmpVariable(mb, getVarType(mb, v))) < 0) {
      82           0 :                                         freeInstruction(q);
      83           0 :                                         msg = createException(MAL, "optimizer.matpack",
      84             :                                                                                   SQLSTATE(HY013) MAL_MALLOC_FAIL);
      85           0 :                                         break;
      86             :                                 }
      87      461175 :                                 v = getArg(q, 0);
      88      461175 :                                 pushInstruction(mb, q);
      89      461175 :                                 typeChecker(cntxt->usermodule, mb, q, mb->stop - 1, TRUE);
      90             :                         }
      91           0 :                         if (msg)
      92             :                                 break;
      93      155577 :                         getArg(q, 0) = getArg(p, 0);
      94      155577 :                         freeInstruction(p);
      95      155577 :                         actions++;
      96      155577 :                         continue;
      97             :                 }
      98     5587720 :                 pushInstruction(mb, p);
      99     5587720 :                 old[i] = NULL;
     100             :         }
     101    15257635 :         for (; i < slimit; i++)
     102    15226687 :                 if (old[i])
     103           0 :                         pushInstruction(mb, old[i]);
     104       30948 :         GDKfree(old);
     105             : 
     106             :         /* Defense line against incorrect plans */
     107       30948 :         if (msg == MAL_SUCCEED && actions > 0) {
     108       30948 :                 msg = chkTypes(cntxt->usermodule, mb, FALSE);
     109       30948 :                 if (!msg)
     110       30948 :                         msg = chkFlow(mb);
     111       30948 :                 if (!msg)
     112       30948 :                         msg = chkDeclarations(mb);
     113             :         }
     114           0 :   wrapup:
     115             :         /* keep actions taken as a fake argument */
     116      483986 :         (void) pushInt(mb, pci, actions);
     117      483986 :         return msg;
     118             : }