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 "opt_multiplex.h"
15 : #include "manifold.h"
16 : #include "mal_interpreter.h"
17 :
18 : /*
19 : * The generic solution to the multiplex operators is to translate
20 : * them to a MAL loop.
21 : * The call optimizer.multiplex(MOD,FCN,A1,...An) introduces the following code
22 : * structure:
23 : *
24 : * resB:= bat.new(restype, A1);
25 : * barrier (h,t1):= iterator.new(A1);
26 : * t2:= algebra.fetch(A2,h)
27 : * ...
28 : * cr:= MOD.FCN(t1,...,tn);
29 : * bat.append(resB,cr);
30 : * redo (h,t):= iterator.next(A1);
31 : * end h;
32 : *
33 : * The algorithm consists of two phases: phase one deals with
34 : * collecting the relevant information, phase two is the actual
35 : * code construction.
36 : */
37 : static str
38 4173 : OPTexpandMultiplex(Client cntxt, MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
39 : {
40 4173 : int i = 2, iter = 0;
41 4173 : int hvar, tvar;
42 4173 : const char *mod, *fcn;
43 4173 : int *alias, *resB;
44 4173 : InstrPtr q;
45 4173 : int tt;
46 4173 : int bat = (getModuleId(pci) == batmalRef);
47 :
48 4173 : (void) cntxt;
49 4173 : (void) stk;
50 8379 : for (i = 0; i < pci->retc; i++) {
51 4206 : tt = getBatType(getArgType(mb, pci, i));
52 4206 : if (tt == TYPE_any)
53 0 : throw(MAL, "optimizer.multiplex",
54 : SQLSTATE(HY002) "Target tail type is missing");
55 4206 : if (isAnyExpression(getArgType(mb, pci, i)))
56 0 : throw(MAL, "optimizer.multiplex",
57 : SQLSTATE(HY002) "Target type is missing");
58 : }
59 4173 : int plus_one = getArgType(mb, pci, pci->retc) == TYPE_lng ? 1 : 0;
60 4173 : mod = VALget(&getVar(mb, getArg(pci, pci->retc + plus_one))->value);
61 4173 : mod = putName(mod);
62 4173 : fcn = VALget(&getVar(mb, getArg(pci, pci->retc + 1 + plus_one))->value);
63 4173 : fcn = putName(fcn);
64 4173 : if (mod == NULL || fcn == NULL)
65 0 : throw(MAL, "optimizer.multiplex", SQLSTATE(HY013) MAL_MALLOC_FAIL);
66 :
67 : #ifndef NDEBUG
68 : TRC_WARNING_IF(MAL_OPTIMIZER) {
69 4173 : char *ps = instruction2str(mb, stk, pci, LIST_MAL_DEBUG);
70 4173 : TRC_WARNING_ENDIF(MAL_OPTIMIZER,
71 : "To speedup %s.%s a bulk operator implementation is needed%s%s\n",
72 : mod, fcn, ps ? " for " : "", ps ? ps : "");
73 4173 : GDKfree(ps);
74 : }
75 : #endif
76 :
77 4173 : if (plus_one) {
78 0 : q = newFcnCallArgs(mb, batRef, putName("densebat"), 2);
79 0 : if (q == NULL) {
80 0 : throw(MAL, "optimizer.multiplex", SQLSTATE(HY013) MAL_MALLOC_FAIL);
81 : }
82 0 : q = pushArgument(mb, q, getArg(pci, pci->retc));
83 0 : pushInstruction(mb, q);
84 0 : iter = getArg(q, 0);
85 : } else /* search the iterator bat */
86 4195 : for (i = pci->retc + 2; i < pci->argc; i++)
87 4195 : if (isaBatType(getArgType(mb, pci, i))) {
88 : iter = getArg(pci, i);
89 : break;
90 : }
91 4173 : if (i == pci->argc)
92 0 : throw(MAL, "optimizer.multiplex",
93 : SQLSTATE(HY002) "Iterator BAT type is missing");
94 :
95 : /*
96 : * Beware, the operator constant (arg=1) is passed along as well,
97 : * because in the end we issue a recursive function call that should
98 : * find the actual arguments at the proper place of the callee.
99 : */
100 :
101 4173 : alias = (int *) GDKmalloc(sizeof(int) * pci->maxarg);
102 4173 : resB = (int *) GDKmalloc(sizeof(int) * pci->retc);
103 4173 : if (alias == NULL || resB == NULL) {
104 0 : goto nomem;
105 : }
106 :
107 : /* resB := new(refBat) */
108 8379 : for (i = 0; i < pci->retc; i++) {
109 4206 : q = newFcnCallArgs(mb, batRef, newRef, 3);
110 4206 : if (q == NULL) {
111 0 : goto nomem;
112 : }
113 4206 : resB[i] = getArg(q, 0);
114 :
115 4206 : tt = getBatType(getArgType(mb, pci, i));
116 :
117 4206 : setVarType(mb, getArg(q, 0), newBatType(tt));
118 4206 : q = pushType(mb, q, tt);
119 4206 : q = pushArgument(mb, q, iter);
120 4206 : pushInstruction(mb, q);
121 4206 : assert(q->argc == 3);
122 : }
123 :
124 : /* barrier (h,r) := iterator.new(refBat); */
125 4173 : q = newFcnCall(mb, iteratorRef, newRef);
126 4173 : if (q == NULL) {
127 0 : goto nomem;
128 : }
129 4173 : q->barrier = BARRIERsymbol;
130 4173 : hvar = newTmpVariable(mb, TYPE_any);
131 4173 : getArg(q, 0) = hvar;
132 4173 : tvar = newTmpVariable(mb, TYPE_any);
133 4173 : q = pushReturn(mb, q, tvar);
134 4173 : q = pushArgument(mb, q, iter);
135 4173 : pushInstruction(mb, q);
136 :
137 : /* $1:= algebra.fetch(Ai,h) or constant */
138 12493 : for (i = pci->retc + 2 + plus_one; i < pci->argc; i++) {
139 8320 : if (getArg(pci, i) != iter &&isaBatType(getArgType(mb, pci, i))) {
140 3925 : q = newFcnCall(mb, algebraRef, "fetch");
141 3925 : if (q == NULL) {
142 0 : goto nomem;
143 : }
144 3925 : alias[i] = newTmpVariable(mb, getBatType(getArgType(mb, pci, i)));
145 3925 : getArg(q, 0) = alias[i];
146 3925 : q = pushArgument(mb, q, getArg(pci, i));
147 3925 : q = pushArgument(mb, q, hvar);
148 3925 : pushInstruction(mb, q);
149 : }
150 : }
151 :
152 : /* cr:= mod.CMD($1,...,$n); */
153 4173 : q = newFcnCallArgs(mb, mod, fcn, pci->argc - 2 - plus_one);
154 4173 : if (q == NULL) {
155 0 : goto nomem;
156 : }
157 8379 : for (i = 0; i < pci->retc; i++) {
158 4206 : int nvar = 0;
159 4206 : if (bat) {
160 42 : tt = getBatType(getArgType(mb, pci, i));
161 42 : nvar = newTmpVariable(mb, newBatType(tt));
162 : } else {
163 4164 : nvar = newTmpVariable(mb, TYPE_any);
164 : }
165 4206 : if (i)
166 33 : q = pushReturn(mb, q, nvar);
167 : else
168 4173 : getArg(q, 0) = nvar;
169 : }
170 :
171 12493 : for (i = pci->retc + 2 + plus_one; i < pci->argc; i++) {
172 8320 : if (getArg(pci, i) == iter) {
173 4176 : q = pushArgument(mb, q, tvar);
174 4144 : } else if (isaBatType(getArgType(mb, pci, i))) {
175 3925 : q = pushArgument(mb, q, alias[i]);
176 : } else {
177 219 : q = pushArgument(mb, q, getArg(pci, i));
178 : }
179 : }
180 4173 : pushInstruction(mb, q);
181 :
182 12552 : for (i = 0; i < pci->retc; i++) {
183 4206 : InstrPtr a = newFcnCall(mb, batRef, appendRef);
184 4206 : if (a == NULL) {
185 0 : goto nomem;
186 : }
187 4206 : a = pushArgument(mb, a, resB[i]);
188 4206 : a = pushArgument(mb, a, getArg(q, i));
189 4206 : getArg(a, 0) = resB[i];
190 4206 : pushInstruction(mb, a);
191 : }
192 :
193 : /* redo (h,r):= iterator.next(refBat); */
194 4173 : q = newFcnCall(mb, iteratorRef, nextRef);
195 4173 : if (q == NULL) {
196 0 : goto nomem;
197 : }
198 4173 : q->barrier = REDOsymbol;
199 4173 : getArg(q, 0) = hvar;
200 4173 : q = pushReturn(mb, q, tvar);
201 4173 : q = pushArgument(mb, q, iter);
202 4173 : pushInstruction(mb, q);
203 :
204 4173 : q = newAssignment(mb);
205 4173 : if (q == NULL) {
206 0 : goto nomem;
207 : }
208 4173 : q->barrier = EXITsymbol;
209 4173 : getArg(q, 0) = hvar;
210 4173 : q = pushReturn(mb, q, tvar);
211 4173 : pushInstruction(mb, q);
212 :
213 12552 : for (i = 0; i < pci->retc; i++) {
214 4206 : q = newAssignment(mb);
215 4206 : if (q == NULL) {
216 0 : goto nomem;
217 : }
218 4206 : getArg(q, 0) = getArg(pci, i);
219 4206 : q = pushArgument(mb, q, resB[i]);
220 4206 : pushInstruction(mb, q);
221 : }
222 4173 : GDKfree(alias);
223 4173 : GDKfree(resB);
224 4173 : return MAL_SUCCEED;
225 :
226 0 : nomem:
227 0 : GDKfree(alias);
228 0 : GDKfree(resB);
229 0 : throw(MAL, "optimizer.multiplex", SQLSTATE(HY013) MAL_MALLOC_FAIL);
230 : }
231 :
232 : /*
233 : * The multiplexSimple is called by the MAL scenario. It bypasses
234 : * the optimizer infrastructure, to avoid excessive space allocation
235 : * and interpretation overhead.
236 : */
237 : str
238 7 : OPTmultiplexSimple(Client cntxt, MalBlkPtr mb)
239 : {
240 7 : int i, doit = 0;
241 7 : InstrPtr p;
242 7 : str msg = MAL_SUCCEED;
243 :
244 7 : if (mb)
245 1289 : for (i = 0; i < mb->stop; i++) {
246 1282 : p = getInstrPtr(mb, i);
247 1282 : if (isMultiplex(p)) {
248 0 : p->typeresolved = false;
249 0 : doit++;
250 : }
251 : }
252 7 : if (doit) {
253 0 : msg = OPTmultiplexImplementation(cntxt, mb, 0, 0);
254 0 : if (!msg)
255 0 : msg = chkTypes(cntxt->usermodule, mb, TRUE);
256 0 : if (!msg)
257 0 : msg = chkFlow(mb);
258 0 : if (!msg)
259 0 : msg = chkDeclarations(mb);
260 : }
261 7 : return msg;
262 : }
263 :
264 : str
265 455075 : OPTmultiplexImplementation(Client cntxt, MalBlkPtr mb, MalStkPtr stk,
266 : InstrPtr pci)
267 : {
268 455075 : InstrPtr *old = 0, p;
269 455075 : int i, limit, slimit, actions = 0;
270 455075 : str msg = MAL_SUCCEED;
271 :
272 455075 : (void) stk;
273 28476623 : for (i = 0; i < mb->stop; i++) {
274 28022433 : p = getInstrPtr(mb, i);
275 28022433 : if (isMultiplex(p)) {
276 : break;
277 : }
278 : }
279 455122 : if (i == mb->stop) {
280 454190 : goto wrapup;
281 : }
282 :
283 932 : old = mb->stmt;
284 932 : limit = mb->stop;
285 932 : slimit = mb->ssize;
286 932 : if (newMalBlkStmt(mb, mb->ssize) < 0)
287 0 : throw(MAL, "optimizer.multiplex", SQLSTATE(HY013) MAL_MALLOC_FAIL);
288 :
289 320321 : for (i = 0; i < limit; i++) {
290 319389 : p = old[i];
291 319389 : if (msg == MAL_SUCCEED && isMultiplex(p)) {
292 4941 : if (MANIFOLDtypecheck(cntxt, mb, p, 0) != NULL) {
293 768 : setFunctionId(p, manifoldRef);
294 768 : p->typeresolved = false;
295 768 : pushInstruction(mb, p);
296 768 : actions++;
297 768 : continue;
298 : }
299 4173 : msg = OPTexpandMultiplex(cntxt, mb, stk, p);
300 4173 : if (msg == MAL_SUCCEED) {
301 4173 : freeInstruction(p);
302 4173 : old[i] = 0;
303 4173 : actions++;
304 4173 : continue;
305 : }
306 :
307 0 : pushInstruction(mb, p);
308 0 : actions++;
309 314448 : } else if (old[i])
310 314448 : pushInstruction(mb, p);
311 : }
312 104455 : for (; i < slimit; i++)
313 103523 : if (old[i])
314 0 : pushInstruction(mb, old[i]);
315 932 : GDKfree(old);
316 :
317 : /* Defense line against incorrect plans */
318 932 : if (msg == MAL_SUCCEED && actions > 0) {
319 932 : msg = chkTypes(cntxt->usermodule, mb, FALSE);
320 932 : if (!msg)
321 932 : msg = chkFlow(mb);
322 932 : if (!msg)
323 932 : msg = chkDeclarations(mb);
324 : }
325 0 : wrapup:
326 : /* keep actions taken as a fake argument */
327 455122 : (void) pushInt(mb, pci, actions);
328 :
329 455122 : return msg;
330 : }
|
