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             : #include "monetdb_config.h"
      14             : #include "mal_instruction.h"
      15             : #include "opt_aliases.h"
      16             : 
      17             : /* an alias is recognized by a simple assignment */
      18             : #define OPTisAlias(X) (X->argc == 2 && X->token == ASSIGNsymbol && X->barrier == 0 )
      19             : 
      20             : str
      21     1494585 : OPTaliasesImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
      22             : {
      23     1494585 :         int i, j, k = 1, limit, actions = 0;
      24     1494585 :         int *alias = 0;
      25     1494585 :         str msg = MAL_SUCCEED;
      26     1494585 :         InstrPtr p;
      27             : 
      28     1494585 :         (void) stk;
      29     1494585 :         (void) cntxt;
      30             : 
      31     1494585 :         limit = mb->stop;
      32    50018726 :         for (i = 1; i < limit; i++) {
      33    49058971 :                 p = getInstrPtr(mb, i);
      34    49058971 :                 if (OPTisAlias(p))
      35             :                         break;
      36             :         }
      37     1494585 :         if (i == limit) {
      38             :                 // we didn't found a simple assignment that warrants a rewrite
      39      959742 :                 goto wrapup;
      40             :         }
      41      534843 :         k = i;
      42      534843 :         if (i < limit) {
      43      534843 :                 alias = GDKzalloc(sizeof(int) * mb->vtop);
      44      534862 :                 if (alias == NULL)
      45           0 :                         throw(MAL, "optimizer.aliases", SQLSTATE(HY013) MAL_MALLOC_FAIL);
      46      534862 :                 setVariableScope(mb);
      47    52779005 :                 for (j = 1; j < mb->vtop; j++)
      48    51709402 :                         alias[j] = j;
      49             :         }
      50    29632330 :         for (; i < limit; i++) {
      51    29097440 :                 p = getInstrPtr(mb, i);
      52    29097440 :                 mb->stmt[k++] = p;
      53    29097440 :                 if (OPTisAlias(p) && getLastUpdate(mb, getArg(p, 0)) == i
      54     3348261 :                         && getBeginScope(mb, getArg(p, 0)) == i
      55     3346804 :                         && getLastUpdate(mb, getArg(p, 1)) <= i) {
      56     3346383 :                         alias[getArg(p, 0)] = alias[getArg(p, 1)];
      57     3346383 :                         freeInstruction(p);
      58     3346532 :                         actions++;
      59     3346532 :                         k--;
      60     3346532 :                         mb->stmt[k] = 0;
      61             :                 } else {
      62    90017792 :                         for (int i = 0; i < p->argc; i++)
      63    64266735 :                                 getArg(p, i) = alias[getArg(p, i)];
      64             :                 }
      65             :         }
      66             : 
      67     3880979 :         for (i = k; i < limit; i++)
      68     3346089 :                 mb->stmt[i] = NULL;
      69             : 
      70      534890 :         mb->stop = k;
      71      534890 :         GDKfree(alias);
      72             : 
      73             :         /* Defense line against incorrect plans */
      74             :         /* Plan is unaffected */
      75             :         // msg = chkTypes(cntxt->usermodule, mb, FALSE);
      76             :         // if ( msg == MAL_SUCCEED)
      77             :         //      msg = chkFlow(mb);
      78             :         // if ( msg == MAL_SUCCEED)
      79             :         //      msg = chkDeclarations(mb);
      80     1494605 :   wrapup:
      81             :         /* keep actions taken as a fake argument */
      82     1494605 :         (void) pushInt(mb, pci, actions);
      83     1494605 :         return msg;
      84             : }