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, 2025 MonetDB Foundation;
       9             :  * Copyright August 2008 - 2023 MonetDB B.V.;
      10             :  * Copyright 1997 - July 2008 CWI.
      11             :  */
      12             : 
      13             : /* (c) Martin Kersten
      14             :  */
      15             : #include "monetdb_config.h"
      16             : #include "opt_deadcode.h"
      17             : 
      18             : str
      19     1692540 : OPTdeadcodeImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk,
      20             :                                                   InstrPtr pci)
      21             : {
      22     1692540 :         int i, k, se, limit, slimit;
      23     1692540 :         InstrPtr p = 0, *old = NULL;
      24     1692540 :         int actions = 0;
      25     1692540 :         int *varused = 0;
      26     1692540 :         str msg = MAL_SUCCEED;
      27             : 
      28     1692540 :         (void) cntxt;
      29     1692540 :         (void) stk;                                     /* to fool compilers */
      30             : 
      31     1692540 :         if (mb->inlineProp)
      32           0 :                 goto wrapup;
      33             : 
      34     1692540 :         varused = GDKzalloc(mb->vtop * sizeof(int));
      35     1693490 :         if (varused == NULL)
      36           0 :                 goto wrapup;
      37             : 
      38     1693490 :         old = mb->stmt;
      39     1693490 :         limit = mb->stop;
      40     1693490 :         slimit = mb->ssize;
      41     1693490 :         if (newMalBlkStmt(mb, mb->ssize) < 0) {
      42           0 :                 GDKfree(varused);
      43           0 :                 throw(MAL, "optimizer.deadcode", SQLSTATE(HY013) MAL_MALLOC_FAIL);
      44             :         }
      45             :         //mnstr_printf(cntxt->fdout,"deadcode limit %d ssize %d vtop %d vsize %d\n", limit, (int)(mb->ssize), mb->vtop, (int)(mb->vsize));
      46             : 
      47             :         // Calculate the instructions in which a variable is used.
      48             :         // Variables can be used multiple times in an instruction.
      49    91870251 :         for (i = 1; i < limit; i++) {
      50    90176700 :                 p = old[i];
      51   358884477 :                 for (k = p->retc; k < p->argc; k++)
      52   268707777 :                         varused[getArg(p, k)]++;
      53    90176700 :                 if (blockCntrl(p))
      54       25212 :                         for (k = 0; k < p->retc; k++)
      55       18438 :                                 varused[getArg(p, k)]++;
      56             :         }
      57             : 
      58             :         // Consolidate the actual need for variables
      59    95319023 :         for (i = limit; i >= 0; i--) {
      60    93625704 :                 p = old[i];
      61    93625704 :                 if (p == 0)
      62     1692626 :                         continue;                       //left behind by others?
      63             : 
      64    91933078 :                 if (getModuleId(p) == batRef && isUpdateInstruction(p) && !p->barrier) {
      65             :                         /* bat.append and friends are intermediates that need not be retained
      66             :                          * unless they are not used outside of an update */
      67      857382 :                         if (varused[getArg(p, 1)] > 1)
      68        4617 :                                 varused[getArg(p, 0)]++;        // force keeping it
      69    91075726 :                 } else if (hasSideEffects(mb, p, FALSE) || !isLinearFlow(p)
      70    35295728 :                                    || (p->retc == 1 && mb->unsafeProp)
      71    35238027 :                                    || p->barrier /* ==side-effect */ ) {
      72    55837237 :                         varused[getArg(p, 0)]++;        // force keeping it
      73    55837237 :                         continue;
      74             :                 }
      75             :                 // The results should be used somewhere
      76    36095609 :                 se = 0;
      77    73940104 :                 for (k = 0; k < p->retc; k++)
      78    37844495 :                         se += varused[getArg(p, k)] > 0;
      79             : 
      80             :                 // Reduce input variable count when garbage is detected
      81    36095609 :                 if (se == 0)
      82    92642433 :                         for (k = p->retc; k < p->argc; k++)
      83    82705853 :                                 varused[getArg(p, k)]--;
      84             :         }
      85             : 
      86             :         // Now we can simply copy the instructions and discard useless ones.
      87     1693319 :         pushInstruction(mb, old[0]);
      88    45988328 :         for (i = 1; i < limit; i++) {
      89    44295102 :                 if ((p = old[i]) != NULL) {
      90    44294144 :                         if (p->token == ENDsymbol) {
      91     1693315 :                                 pushInstruction(mb, p);
      92             :                                 // Also copy the optimizer trace information
      93    47654865 :                                 for (i++; i < limit; i++)
      94    45961537 :                                         if (old[i])
      95    45961537 :                                                 pushInstruction(mb, old[i]);
      96             :                                 break;
      97             :                         }
      98             :                         // Is the instruction still relevant?
      99             :                         se = 0;
     100    88971194 :                         for (k = 0; k < p->retc; k++)
     101    46370365 :                                 se += varused[getArg(p, k)] > 0;
     102             : 
     103    42600829 :                         if (se)
     104    34357567 :                                 pushInstruction(mb, p);
     105             :                         else {
     106     8243262 :                                 freeInstruction(p);
     107     8243442 :                                 actions++;
     108             :                         }
     109             :                 }
     110             :         }
     111             :         /* save the free instructions records for later */
     112   381384230 :         for (; i < slimit; i++)
     113   379690743 :                 if (old[i]) {
     114           0 :                         pushInstruction(mb, old[i]);
     115             :                 }
     116             :         /* Defense line against incorrect plans */
     117             :         /* we don't create or change existing structures */
     118             :         // no type change msg = chkTypes(cntxt->usermodule, mb, FALSE);
     119     1693487 :         if (actions > 0) {
     120      578727 :                 msg = chkFlow(mb);
     121      578719 :                 if (!msg)
     122      578719 :                         msg = chkDeclarations(mb);
     123             :         }
     124     1114760 :   wrapup:
     125             :         /* keep actions taken as a fake argument */
     126     1693436 :         (void) pushInt(mb, pci, actions);
     127             : 
     128     1693115 :         if (old)
     129     1693115 :                 GDKfree(old);
     130     1693517 :         if (varused)
     131     1693517 :                 GDKfree(varused);
     132             :         return msg;
     133             : }