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 : #include "monetdb_config.h"
14 : #include "opt_evaluate.h"
15 : #include "opt_aliases.h"
16 :
17 : static bool
18 23031823 : OPTallConstant(Client cntxt, MalBlkPtr mb, InstrPtr p)
19 : {
20 23031823 : int i;
21 23031823 : (void) cntxt;
22 :
23 23031823 : if (p->token != ASSIGNsymbol
24 23030558 : && getModuleId(p) != calcRef
25 22886522 : && getModuleId(p) != strRef
26 22885963 : && getModuleId(p) != mtimeRef
27 22885401 : && getModuleId(p) != mmathRef)
28 : return false;
29 146675 : if (getModuleId(p) == mmathRef && strcmp(getFunctionId(p), "rand") == 0)
30 : return false;
31 :
32 348951 : for (i = p->retc; i < p->argc; i++)
33 242315 : if (isVarConstant(mb, getArg(p, i)) == FALSE)
34 : return false;
35 213195 : for (i = 0; i < p->retc; i++) {
36 106634 : if (isaBatType(getArgType(mb, p, i)))
37 : return false;
38 106634 : if (p->unsafeProp || mb->unsafeProp)
39 : return false;
40 : }
41 : return true;
42 : }
43 :
44 : static bool
45 213 : OPTsimpleflow(MalBlkPtr mb, int pc)
46 : {
47 213 : int i, block = 0;
48 213 : bool simple = true;
49 213 : InstrPtr p;
50 :
51 2631 : for (i = pc; i < mb->stop; i++) {
52 2631 : p = getInstrPtr(mb, i);
53 2631 : if (blockStart(p))
54 228 : block++;
55 2631 : if (blockExit(p))
56 228 : block--;
57 2631 : if (blockCntrl(p))
58 178 : simple = false;
59 2631 : if (block == 0) {
60 213 : return simple;
61 : }
62 : }
63 : return false;
64 : }
65 :
66 : /* barrier blocks can only be dropped when they are fully excluded. */
67 : static str
68 375 : OPTremoveUnusedBlocks(Client cntxt, MalBlkPtr mb)
69 : {
70 : /* catch and remove constant bounded blocks */
71 375 : int i, j = 0, action = 0, block = -1, skip = 0, multipass = 1;
72 375 : InstrPtr p;
73 375 : str msg = MAL_SUCCEED;
74 :
75 753 : while (multipass--) {
76 : block = -1;
77 : skip = 0;
78 : j = 0;
79 30625 : for (i = 0; i < mb->stop; i++) {
80 30247 : p = mb->stmt[i];
81 30247 : if (blockExit(p) && block == getArg(p, 0)) {
82 317 : block = -1;
83 317 : skip = 0;
84 317 : freeInstruction(p);
85 317 : mb->stmt[i] = 0;
86 317 : continue;
87 : }
88 29930 : if (p->argc == 2 && blockStart(p) && block < 0
89 509 : && isVarConstant(mb, getArg(p, 1))
90 509 : && getArgType(mb, p, 1) == TYPE_bit) {
91 413 : if (getVarConstant(mb, getArg(p, 1)).val.btval == 0) {
92 187 : block = getArg(p, 0);
93 187 : skip++;
94 187 : action++;
95 : }
96 : // Try to remove the barrier statement itself (when true).
97 413 : if (getVarConstant(mb, getArg(p, 1)).val.btval == 1
98 213 : && OPTsimpleflow(mb, i)) {
99 130 : block = getArg(p, 0);
100 130 : skip = 0;
101 130 : action++;
102 130 : freeInstruction(p);
103 130 : mb->stmt[i] = 0;
104 130 : continue;
105 : }
106 29517 : } else if (p->argc == 2 && blockStart(p) && block >= 0 && skip == 0
107 7 : && isVarConstant(mb, getArg(p, 1))
108 7 : && getArgType(mb, p, 1) == TYPE_bit && multipass == 0)
109 29800 : multipass++;
110 29800 : if (skip) {
111 562 : freeInstruction(p);
112 562 : mb->stmt[i] = 0;
113 : } else
114 29238 : mb->stmt[j++] = p;
115 : }
116 378 : mb->stop = j;
117 1387 : for (; j < i; j++)
118 1009 : mb->stmt[j] = NULL;
119 : }
120 375 : if (action)
121 114 : msg = chkTypes(cntxt->usermodule, mb, TRUE);
122 375 : return msg;
123 : }
124 :
125 : str
126 536492 : OPTevaluateImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk,
127 : InstrPtr pci)
128 : {
129 536492 : InstrPtr p;
130 536492 : int i, k, limit, *alias = 0, barrier;
131 536492 : MalStkPtr env = NULL;
132 536492 : int actions = 0, constantblock = 0;
133 536492 : int *assigned = 0, use;
134 536492 : str msg = MAL_SUCCEED;
135 :
136 536492 : (void) stk;
137 :
138 536492 : if (mb->inlineProp)
139 : return MAL_SUCCEED;
140 :
141 536492 : assigned = (int *) GDKzalloc(sizeof(int) * mb->vtop);
142 536491 : if (assigned == NULL)
143 0 : throw(MAL, "optimizer.evaluate", SQLSTATE(HY013) MAL_MALLOC_FAIL);
144 :
145 536491 : alias = (int *) GDKzalloc(mb->vsize * sizeof(int) * 2); /* we introduce more */
146 536473 : if (alias == NULL) {
147 0 : GDKfree(assigned);
148 0 : throw(MAL, "optimizer.evaluate", SQLSTATE(HY013) MAL_MALLOC_FAIL);
149 : }
150 : // arguments are implicitly assigned by context
151 536473 : p = getInstrPtr(mb, 0);
152 537345 : for (k = p->retc; k < p->argc; k++) {
153 872 : assert(getArg(p, k) >= 0);
154 872 : assigned[getArg(p, k)]++;
155 : }
156 536473 : limit = mb->stop;
157 24829598 : for (i = 1; i < limit; i++) {
158 24293125 : p = getInstrPtr(mb, i);
159 : // The double count emerging from a barrier exit is ignored.
160 24293125 : if (!blockExit(p) || (blockExit(p) && p->retc != p->argc))
161 48838580 : for (k = 0; k < p->retc; k++)
162 24546720 : if (p->retc != p->argc || p->token != ASSIGNsymbol) {
163 24546344 : assert(getArg(p, k) >= 0);
164 24546344 : assigned[getArg(p, k)]++;
165 : }
166 : }
167 :
168 24830830 : for (i = 1; i < limit && cntxt->mode != FINISHCLIENT; i++) {
169 24294356 : p = getInstrPtr(mb, i);
170 : // to avoid management of duplicate assignments over multiple blocks
171 : // we limit ourselves to evaluation of the first assignment only.
172 24294356 : assert(getArg(p, 0) >= 0);
173 24294356 : use = assigned[getArg(p, 0)] == 1 && !(p->argc == p->retc
174 13197623 : && blockExit(p));
175 56408497 : for (k = p->retc; k < p->argc; k++)
176 32114141 : if (alias[getArg(p, k)])
177 106174 : getArg(p, k) = alias[getArg(p, k)];
178 : /* be aware that you only assign once to a variable */
179 24294356 : if (use && p->retc == 1 && getFunctionId(p)
180 23030514 : && OPTallConstant(cntxt, mb, p) && !isUnsafeFunction(p)) {
181 105759 : barrier = p->barrier;
182 105759 : p->barrier = 0;
183 105759 : if (env == NULL) {
184 27926 : env = prepareMALstack(mb, 2 * mb->vsize);
185 27924 : if (!env) {
186 0 : msg = createException(MAL, "optimizer.evaluate",
187 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
188 0 : p->barrier = barrier;
189 0 : goto wrapup;
190 : }
191 27924 : env->keepAlive = TRUE;
192 : }
193 105757 : msg = reenterMAL(cntxt, mb, i, i + 1, env);
194 105761 : p->barrier = barrier;
195 105761 : if (msg == MAL_SUCCEED) {
196 105266 : int nvar;
197 105266 : ValRecord cst;
198 :
199 105266 : actions++;
200 105266 : cst.vtype = 0;
201 105266 : if (VALcopy(&cst, &env->stk[getArg(p, 0)]) == NULL) {
202 0 : msg = createException(MAL, "optimizer.evaluate",
203 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
204 0 : goto wrapup;
205 : }
206 : /* You may not overwrite constants. They may be used by
207 : * other instructions */
208 105266 : nvar = defConstant(mb, getArgType(mb, p, 0), &cst);
209 105265 : if (nvar >= 0)
210 105265 : getArg(p, 1) = nvar;
211 105265 : if (nvar >= env->stktop) {
212 54109 : if (VALcopy(&env->stk[getArg(p, 1)],
213 54108 : &getVarConstant(mb, getArg(p, 1))) == NULL) {
214 0 : msg = createException(MAL, "optimizer.evaluate",
215 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
216 0 : goto wrapup;
217 : }
218 54109 : env->stktop = getArg(p, 1) + 1;
219 : }
220 105266 : alias[getArg(p, 0)] = getArg(p, 1);
221 105266 : p->argc = 2;
222 105266 : p->token = ASSIGNsymbol;
223 105266 : clrFunction(p);
224 105265 : p->barrier = barrier;
225 : /* freeze the type */
226 105265 : setVarFixed(mb, getArg(p, 1));
227 : } else {
228 : /* if there is an error, we should postpone message handling,
229 : as the actual error (eg. division by zero ) may not happen) */
230 495 : freeException(msg);
231 495 : msg = MAL_SUCCEED;
232 495 : mb->errors = 0;
233 : }
234 : }
235 48587912 : constantblock += blockStart(p) && OPTallConstant(cntxt, mb, p); /* default */
236 : }
237 : // produces errors in SQL when enabled
238 536474 : if (constantblock)
239 375 : msg = OPTremoveUnusedBlocks(cntxt, mb);
240 :
241 : /* Defense line against incorrect plans */
242 : /* Plan is unaffected */
243 536474 : if (!msg)
244 536474 : msg = chkTypes(cntxt->usermodule, mb, FALSE);
245 536491 : if (!msg)
246 536492 : msg = chkFlow(mb);
247 536491 : if (!msg)
248 536491 : msg = chkDeclarations(mb);
249 : /* keep all actions taken as a post block comment */
250 :
251 0 : wrapup:
252 : /* keep actions taken as a fake argument */
253 536482 : (void) pushInt(mb, pci, actions);
254 :
255 536487 : if (env) {
256 27927 : assert(env->stktop < env->stksize);
257 27927 : freeStack(env);
258 : }
259 536488 : if (assigned)
260 536488 : GDKfree(assigned);
261 536492 : if (alias)
262 536492 : GDKfree(alias);
263 536492 : return msg;
264 : }
|
