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      477408 : OPTmatpackImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk,
      22             :                                                  InstrPtr pci)
      23             : {
      24      477408 :         int v, i, j, limit, slimit;
      25      477408 :         InstrPtr p, q;
      26      477408 :         int actions = 0;
      27      477408 :         InstrPtr *old = NULL;
      28      477408 :         str msg = MAL_SUCCEED;
      29             : 
      30      477408 :         if (isOptimizerUsed(mb, pci, mergetableRef) <= 0) {
      31       31959 :                 goto wrapup;
      32             :         }
      33             : 
      34             :         (void) cntxt;
      35             :         (void) stk;                                     /* to fool compilers */
      36    20143022 :         for (i = 1; i < mb->stop; i++)
      37    19726196 :                 if (getModuleId(getInstrPtr(mb, i)) == matRef
      38       31933 :                         && getFunctionId(getInstrPtr(mb, i)) == packRef
      39       30942 :                         && isaBatType(getArgType(mb, getInstrPtr(mb, i), 1)))
      40             :                         break;
      41      445450 :         if (i == mb->stop)
      42      416826 :                 goto wrapup;
      43             : 
      44       28624 :         old = mb->stmt;
      45       28624 :         limit = mb->stop;
      46       28624 :         slimit = mb->ssize;
      47       28624 :         if (newMalBlkStmt(mb, mb->stop) < 0)
      48           0 :                 throw(MAL, "optimizer.matpack", SQLSTATE(HY013) MAL_MALLOC_FAIL);
      49             : 
      50     7244769 :         for (i = 0; mb->errors == NULL && i < limit; i++) {
      51     7216145 :                 p = old[i];
      52     7216145 :                 if (getModuleId(p) == matRef && getFunctionId(p) == packRef
      53      169403 :                         && isaBatType(getArgType(mb, p, 1))) {
      54      167310 :                         q = newInstruction(0, matRef, packIncrementRef);
      55      167310 :                         if (q == NULL) {
      56           0 :                                 msg = createException(MAL, "optimizer.matpack",
      57             :                                                                           SQLSTATE(HY013) MAL_MALLOC_FAIL);
      58           0 :                                 break;
      59             :                         }
      60      167310 :                         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      167310 :                         q = pushArgument(mb, q, getArg(p, 1));
      67      167310 :                         v = getArg(q, 0);
      68      167310 :                         q = pushInt(mb, q, p->argc - p->retc);
      69      167310 :                         pushInstruction(mb, q);
      70      167310 :                         typeChecker(cntxt->usermodule, mb, q, mb->stop - 1, TRUE);
      71             : 
      72     1447861 :                         for (j = 2; j < p->argc; j++) {
      73     1113241 :                                 q = newInstruction(0, matRef, packIncrementRef);
      74     1113241 :                                 if (q == NULL) {
      75           0 :                                         msg = createException(MAL, "optimizer.matpack",
      76             :                                                                                   SQLSTATE(HY013) MAL_MALLOC_FAIL);
      77           0 :                                         break;
      78             :                                 }
      79     1113241 :                                 q = pushArgument(mb, q, v);
      80     1113241 :                                 q = pushArgument(mb, q, getArg(p, j));
      81     1113241 :                                 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     1113241 :                                 v = getArg(q, 0);
      88     1113241 :                                 pushInstruction(mb, q);
      89     1113241 :                                 typeChecker(cntxt->usermodule, mb, q, mb->stop - 1, TRUE);
      90             :                         }
      91           0 :                         if (msg)
      92             :                                 break;
      93      167310 :                         getArg(q, 0) = getArg(p, 0);
      94      167310 :                         freeInstruction(p);
      95      167310 :                         actions++;
      96      167310 :                         continue;
      97             :                 }
      98     7048835 :                 pushInstruction(mb, p);
      99     7048835 :                 old[i] = NULL;
     100             :         }
     101    20654783 :         for (; i < slimit; i++)
     102    20626159 :                 if (old[i])
     103           0 :                         pushInstruction(mb, old[i]);
     104       28624 :         GDKfree(old);
     105             : 
     106             :         /* Defense line against incorrect plans */
     107       28624 :         if (msg == MAL_SUCCEED && actions > 0) {
     108       28624 :                 msg = chkTypes(cntxt->usermodule, mb, FALSE);
     109       28624 :                 if (!msg)
     110       28624 :                         msg = chkFlow(mb);
     111       28624 :                 if (!msg)
     112       28624 :                         msg = chkDeclarations(mb);
     113             :         }
     114           0 :   wrapup:
     115             :         /* keep actions taken as a fake argument */
     116      477409 :         (void) pushInt(mb, pci, actions);
     117      477409 :         return msg;
     118             : }