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 : /*
14 : * Author M. Kersten
15 : * The MAL Interpreter
16 : */
17 : #include "monetdb_config.h"
18 : #include "mal_runtime.h"
19 : #include "mal_interpreter.h"
20 : #include "mal_resource.h"
21 : #include "mal_listing.h"
22 : #include "mal_type.h"
23 : #include "mal_private.h"
24 : #include "mal_internal.h"
25 : #include "mal_function.h"
26 :
27 : static lng qptimeout = 0; /* how often we print still running queries (usec) */
28 :
29 : void
30 0 : setqptimeout(lng usecs)
31 : {
32 0 : qptimeout = usecs;
33 0 : }
34 :
35 : inline ptr
36 33774331 : getArgReference(MalStkPtr stk, InstrPtr pci, int k)
37 : {
38 : /* the C standard says: "A pointer to a union object, suitably
39 : * converted, points to each of its members (or if a member is a
40 : * bit-field, then to the unit in which it resides), and vice
41 : * versa." */
42 33774331 : return (ptr) &stk->stk[pci->argv[k]].val;
43 : }
44 :
45 : static str
46 31127465 : malCommandCall(MalStkPtr stk, InstrPtr pci)
47 : {
48 31127465 : str ret = MAL_SUCCEED;
49 :
50 31127465 : switch (pci->argc) {
51 0 : case 0:
52 0 : ret = (*(str (*) (void)) pci->fcn)();
53 0 : break;
54 10312 : case 1:
55 10312 : ret = (*(str (*) (void *)) pci->fcn)(
56 : getArgReference(stk, pci, 0));
57 10312 : break;
58 153366 : case 2:
59 153366 : ret = (*(str (*) (void *, void *)) pci->fcn)(
60 : getArgReference(stk, pci, 0),
61 : getArgReference(stk, pci, 1));
62 153366 : break;
63 29159747 : case 3:
64 29159747 : ret = (*(str (*) (void *, void *, void *)) pci->fcn)(
65 : getArgReference(stk, pci, 0),
66 : getArgReference(stk, pci, 1),
67 : getArgReference(stk, pci, 2));
68 29159747 : break;
69 608948 : case 4:
70 608948 : ret = (*(str (*) (void *, void *, void *, void *)) pci-> fcn)(
71 : getArgReference(stk, pci, 0),
72 : getArgReference(stk, pci, 1),
73 : getArgReference(stk, pci, 2),
74 : getArgReference(stk, pci, 3));
75 608948 : break;
76 747890 : case 5:
77 747890 : ret = (*(str (*) (void *, void *, void *, void *, void *)) pci->fcn)(
78 : getArgReference(stk, pci, 0),
79 : getArgReference(stk, pci, 1),
80 : getArgReference(stk, pci, 2),
81 : getArgReference(stk, pci, 3),
82 : getArgReference(stk, pci, 4));
83 747890 : break;
84 3987 : case 6:
85 3987 : ret = (*(str (*) (void *, void *, void *, void *, void *,
86 3987 : void *)) pci->fcn)(
87 : getArgReference(stk, pci, 0),
88 : getArgReference(stk, pci, 1),
89 : getArgReference(stk, pci, 2),
90 : getArgReference(stk, pci, 3),
91 : getArgReference(stk, pci, 4),
92 : getArgReference(stk, pci, 5));
93 3987 : break;
94 97441 : case 7:
95 97441 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
96 97441 : void *)) pci->fcn)(
97 : getArgReference(stk, pci, 0),
98 : getArgReference(stk, pci, 1),
99 : getArgReference(stk, pci, 2),
100 : getArgReference(stk, pci, 3),
101 : getArgReference(stk, pci, 4),
102 : getArgReference(stk, pci, 5),
103 : getArgReference(stk, pci, 6));
104 97441 : break;
105 329605 : case 8:
106 329605 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
107 329605 : void *, void *)) pci->fcn)(
108 : getArgReference(stk, pci, 0),
109 : getArgReference(stk, pci, 1),
110 : getArgReference(stk, pci, 2),
111 : getArgReference(stk, pci, 3),
112 : getArgReference(stk, pci, 4),
113 : getArgReference(stk, pci, 5),
114 : getArgReference(stk, pci, 6),
115 : getArgReference(stk, pci, 7));
116 329605 : break;
117 15990 : case 9:
118 15990 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
119 15990 : void *, void *, void *)) pci->fcn)(
120 : getArgReference(stk, pci, 0),
121 : getArgReference(stk, pci, 1),
122 : getArgReference(stk, pci, 2),
123 : getArgReference(stk, pci, 3),
124 : getArgReference(stk, pci, 4),
125 : getArgReference(stk, pci, 5),
126 : getArgReference(stk, pci, 6),
127 : getArgReference(stk, pci, 7),
128 : getArgReference(stk, pci, 8));
129 15990 : break;
130 37 : case 10:
131 37 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
132 37 : void *, void *, void *, void *)) pci->fcn)(
133 : getArgReference(stk, pci, 0),
134 : getArgReference(stk, pci, 1),
135 : getArgReference(stk, pci, 2),
136 : getArgReference(stk, pci, 3),
137 : getArgReference(stk, pci, 4),
138 : getArgReference(stk, pci, 5),
139 : getArgReference(stk, pci, 6),
140 : getArgReference(stk, pci, 7),
141 : getArgReference(stk, pci, 8),
142 : getArgReference(stk, pci, 9));
143 37 : break;
144 40 : case 11:
145 40 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
146 40 : void *, void *, void *, void *, void *)) pci->fcn)(
147 : getArgReference(stk, pci, 0),
148 : getArgReference(stk, pci, 1),
149 : getArgReference(stk, pci, 2),
150 : getArgReference(stk, pci, 3),
151 : getArgReference(stk, pci, 4),
152 : getArgReference(stk, pci, 5),
153 : getArgReference(stk, pci, 6),
154 : getArgReference(stk, pci, 7),
155 : getArgReference(stk, pci, 8),
156 : getArgReference(stk, pci, 9),
157 : getArgReference(stk, pci, 10));
158 40 : break;
159 102 : case 12:
160 102 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
161 : void *, void *, void *, void *, void *,
162 102 : void *)) pci->fcn)(
163 : getArgReference(stk, pci, 0),
164 : getArgReference(stk, pci, 1),
165 : getArgReference(stk, pci, 2),
166 : getArgReference(stk, pci, 3),
167 : getArgReference(stk, pci, 4),
168 : getArgReference(stk, pci, 5),
169 : getArgReference(stk, pci, 6),
170 : getArgReference(stk, pci, 7),
171 : getArgReference(stk, pci, 8),
172 : getArgReference(stk, pci, 9),
173 : getArgReference(stk, pci, 10),
174 : getArgReference(stk, pci, 11));
175 102 : break;
176 0 : case 13:
177 0 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
178 : void *, void *, void *, void *, void *, void *,
179 0 : void *)) pci->fcn)(
180 : getArgReference(stk, pci, 0),
181 : getArgReference(stk, pci, 1),
182 : getArgReference(stk, pci, 2),
183 : getArgReference(stk, pci, 3),
184 : getArgReference(stk, pci, 4),
185 : getArgReference(stk, pci, 5),
186 : getArgReference(stk, pci, 6),
187 : getArgReference(stk, pci, 7),
188 : getArgReference(stk, pci, 8),
189 : getArgReference(stk, pci, 9),
190 : getArgReference(stk, pci, 10),
191 : getArgReference(stk, pci, 11),
192 : getArgReference(stk, pci, 12));
193 0 : break;
194 0 : case 14:
195 0 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
196 : void *, void *, void *, void *, void *, void *,
197 0 : void *, void *)) pci->fcn)(
198 : getArgReference(stk, pci, 0),
199 : getArgReference(stk, pci, 1),
200 : getArgReference(stk, pci, 2),
201 : getArgReference(stk, pci, 3),
202 : getArgReference(stk, pci, 4),
203 : getArgReference(stk, pci, 5),
204 : getArgReference(stk, pci, 6),
205 : getArgReference(stk, pci, 7),
206 : getArgReference(stk, pci, 8),
207 : getArgReference(stk, pci, 9),
208 : getArgReference(stk, pci, 10),
209 : getArgReference(stk, pci, 11),
210 : getArgReference(stk, pci, 12),
211 : getArgReference(stk, pci, 13));
212 0 : break;
213 0 : case 15:
214 0 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
215 : void *, void *, void *, void *, void *, void *,
216 0 : void *, void *, void *)) pci->fcn)(
217 : getArgReference(stk, pci, 0),
218 : getArgReference(stk, pci, 1),
219 : getArgReference(stk, pci, 2),
220 : getArgReference(stk, pci, 3),
221 : getArgReference(stk, pci, 4),
222 : getArgReference(stk, pci, 5),
223 : getArgReference(stk, pci, 6),
224 : getArgReference(stk, pci, 7),
225 : getArgReference(stk, pci, 8),
226 : getArgReference(stk, pci, 9),
227 : getArgReference(stk, pci, 10),
228 : getArgReference(stk, pci, 11),
229 : getArgReference(stk, pci, 12),
230 : getArgReference(stk, pci, 13),
231 : getArgReference(stk, pci, 14));
232 0 : break;
233 0 : case 16:
234 0 : ret = (* (str (*) (void *, void *, void *, void *, void *, void *,
235 : void *, void *, void *, void *, void *, void *,
236 0 : void *, void *, void *, void *)) pci->fcn)(
237 : getArgReference(stk, pci, 0),
238 : getArgReference(stk, pci, 1),
239 : getArgReference(stk, pci, 2),
240 : getArgReference(stk, pci, 3),
241 : getArgReference(stk, pci, 4),
242 : getArgReference(stk, pci, 5),
243 : getArgReference(stk, pci, 6),
244 : getArgReference(stk, pci, 7),
245 : getArgReference(stk, pci, 8),
246 : getArgReference(stk, pci, 9),
247 : getArgReference(stk, pci, 10),
248 : getArgReference(stk, pci, 11),
249 : getArgReference(stk, pci, 12),
250 : getArgReference(stk, pci, 13),
251 : getArgReference(stk, pci, 14),
252 : getArgReference(stk, pci, 15));
253 0 : break;
254 0 : default:
255 0 : throw(MAL, "mal.interpreter", "too many arguments for command call");
256 : }
257 : return ret;
258 : }
259 :
260 : /*
261 : * Copy the constant values onto the stack frame
262 : */
263 : #define initStack(S, R) \
264 : do { \
265 : for (int i = (S); i < mb->vtop; i++) { \
266 : lhs = &stk->stk[i]; \
267 : if (isVarConstant(mb, i) > 0) { \
268 : if (!isVarDisabled(mb, i)) { \
269 : rhs = &getVarConstant(mb, i); \
270 : if(VALcopy(lhs, rhs) == NULL) \
271 : R = 0; \
272 : } \
273 : } else { \
274 : lhs->vtype = getVarGDKType(mb, i); \
275 : lhs->val.pval = 0; \
276 : lhs->len = 0; \
277 : lhs->bat = isaBatType(getVarType(mb, i)); \
278 : } \
279 : } \
280 : } while (0)
281 :
282 : static inline bool
283 7798238 : isNotUsedIn(InstrPtr p, int start, int a)
284 : {
285 19573301 : for (int k = start; k < p->argc; k++)
286 11785703 : if (getArg(p, k) == a)
287 : return false;
288 : return true;
289 : }
290 :
291 : MalStkPtr
292 811601 : prepareMALstack(MalBlkPtr mb, int size)
293 : {
294 811601 : MalStkPtr stk = NULL;
295 811601 : int res = 1;
296 811601 : ValPtr lhs, rhs;
297 :
298 811601 : stk = newGlobalStack(size);
299 811601 : if (!stk)
300 : return NULL;
301 811601 : stk->stktop = mb->vtop;
302 811601 : stk->blk = mb;
303 811601 : stk->memory = 0;
304 173717365 : initStack(0, res);
305 811599 : if (!res) {
306 0 : freeStack(stk);
307 0 : return NULL;
308 : }
309 : return stk;
310 : }
311 :
312 : str
313 622437 : runMAL(Client cntxt, MalBlkPtr mb, MalBlkPtr mbcaller, MalStkPtr env)
314 : {
315 622437 : MalStkPtr stk = NULL;
316 622437 : ValPtr lhs, rhs;
317 622437 : str ret;
318 622437 : (void) mbcaller;
319 :
320 : /* Prepare a new interpreter call. This involves two steps, (1)
321 : * allocate the minimum amount of stack space needed, some slack
322 : * resources are included to permit code optimizers to add a few
323 : * variables at run time, (2) copying the arguments into the new
324 : * stack frame.
325 : *
326 : * The env stackframe is set when a MAL function is called
327 : * recursively. Alternatively, there is no caller but a stk to be
328 : * re-used for interpretation. We assume here that it aligns with
329 : * the variable table of the routine being called.
330 : *
331 : * allocate space for value stack the global stack should be large
332 : * enough
333 : */
334 622437 : cntxt->lastcmd = time(0);
335 622437 : ATOMIC_SET(&cntxt->lastprint, GDKusec());
336 622437 : if (env != NULL) {
337 9980 : int res = 1;
338 9980 : stk = env;
339 9980 : if (mb != stk->blk)
340 0 : throw(MAL, "mal.interpreter", "misalignment of symbols");
341 9980 : if (mb->vtop > stk->stksize)
342 0 : throw(MAL, "mal.interpreter", "stack too small");
343 26175 : initStack(env->stkbot, res);
344 9980 : if (!res)
345 0 : throw(MAL, "mal.interpreter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
346 : } else {
347 612457 : stk = prepareMALstack(mb, mb->vsize);
348 612457 : if (stk == 0)
349 0 : throw(MAL, "mal.interpreter", MAL_STACK_FAIL);
350 612457 : stk->blk = mb;
351 : /*safeguardStack */
352 612457 : if (env) {
353 : stk->stkdepth = stk->stksize + env->stkdepth;
354 : stk->calldepth = env->calldepth + 1;
355 : stk->up = env;
356 : if (stk->calldepth > 256)
357 : throw(MAL, "mal.interpreter", MAL_CALLDEPTH_FAIL);
358 : }
359 : /*
360 : * An optimization is to copy all constant variables used in
361 : * functions immediately onto the value stack. Then we do not
362 : * have to check for their location later on any more. At some
363 : * point, the effect is optimal, if at least several constants
364 : * are referenced in a function (a gain on tst400a of 20% has
365 : * been observed due the small size of the function).
366 : */
367 : }
368 622437 : ret = runMALsequence(cntxt, mb, 1, 0, stk, env, 0);
369 :
370 622436 : if (!stk->keepAlive && garbageControl(getInstrPtr(mb, 0)))
371 612457 : garbageCollector(cntxt, mb, stk, env != stk);
372 622430 : if (stk && stk != env)
373 612451 : freeStack(stk);
374 622434 : if (ret == MAL_SUCCEED) {
375 604692 : switch (cntxt->qryctx.endtime) {
376 0 : case QRY_TIMEOUT:
377 0 : throw(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_TIMEOUT);
378 0 : case QRY_INTERRUPT:
379 0 : throw(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_INTERRUPT);
380 : default:
381 : break;
382 : }
383 : }
384 : return ret;
385 : }
386 :
387 : /* Single instruction
388 : * It is possible to re-enter the interpreter at a specific place.
389 : * This is used in the area where we need to support co-routines.
390 : *
391 : * A special case for MAL interpretation is to execute just one instruction.
392 : * This is typically used by optimizers and schedulers that need part of the
393 : * answer to direct their actions. Or, a dataflow scheduler could step in
394 : * to enforce a completely different execution order.
395 : */
396 : str
397 105921 : reenterMAL(Client cntxt, MalBlkPtr mb, int startpc, int stoppc, MalStkPtr stk)
398 : {
399 105921 : str ret;
400 105921 : int keepAlive;
401 :
402 105921 : if (stk == NULL)
403 0 : throw(MAL, "mal.interpreter", MAL_STACK_FAIL);
404 105921 : keepAlive = stk->keepAlive;
405 105921 : ret = runMALsequence(cntxt, mb, startpc, stoppc, stk, 0, 0);
406 :
407 105919 : if (keepAlive == 0 && garbageControl(getInstrPtr(mb, 0)))
408 0 : garbageCollector(cntxt, mb, stk, stk != 0);
409 : return ret;
410 : }
411 :
412 : /*
413 : * Front ends may benefit from a more direct call to any of the MAL
414 : * procedural abstractions. The argument list points to the arguments
415 : * for the block to be executed. An old stack frame may be re-used,
416 : * but it is then up to the caller to ensure it is properly
417 : * initialized.
418 : * The call does not return values, they are ignored.
419 : */
420 : str
421 0 : callMAL(Client cntxt, MalBlkPtr mb, MalStkPtr *env, ValPtr argv[])
422 : {
423 0 : MalStkPtr stk = NULL;
424 0 : str ret = MAL_SUCCEED;
425 0 : ValPtr lhs;
426 0 : InstrPtr pci = getInstrPtr(mb, 0);
427 :
428 0 : cntxt->lastcmd = time(0);
429 :
430 0 : switch (pci->token) {
431 0 : case FUNCTIONsymbol:
432 : case FCNcall:
433 : /*
434 : * Prepare the stack frame for this operation. Copy all the arguments
435 : * in place. We assume that the caller has supplied pointers for
436 : * all arguments and return values.
437 : */
438 0 : if (*env == NULL) {
439 0 : stk = prepareMALstack(mb, mb->vsize);
440 0 : if (stk == NULL)
441 0 : throw(MAL, "mal.interpreter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
442 0 : stk->up = 0;
443 0 : *env = stk;
444 : } else {
445 : ValPtr lhs, rhs;
446 : int res = 1;
447 :
448 0 : stk = *env;
449 0 : initStack(0, res);
450 0 : if (!res)
451 0 : throw(MAL, "mal.interpreter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
452 : }
453 0 : assert(stk);
454 0 : for (int i = pci->retc; i < pci->argc; i++) {
455 0 : lhs = &stk->stk[pci->argv[i]];
456 0 : if (VALcopy(lhs, argv[i]) == NULL)
457 0 : throw(MAL, "mal.interpreter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
458 0 : if (lhs->bat)
459 0 : BBPretain(lhs->val.bval);
460 : }
461 0 : ret = runMALsequence(cntxt, mb, 1, 0, stk, 0, 0);
462 0 : break;
463 0 : case PATcall:
464 : case CMDcall:
465 : default:
466 0 : throw(MAL, "mal.interpreter", RUNTIME_UNKNOWN_INSTRUCTION);
467 : }
468 0 : if (stk)
469 0 : garbageCollector(cntxt, mb, stk, TRUE);
470 0 : if (ret == MAL_SUCCEED) {
471 0 : switch (cntxt->qryctx.endtime) {
472 0 : case QRY_TIMEOUT:
473 0 : throw(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_TIMEOUT);
474 0 : case QRY_INTERRUPT:
475 0 : throw(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_INTERRUPT);
476 : default:
477 : break;
478 : }
479 : }
480 : return ret;
481 : }
482 :
483 : /*
484 : * The core of the interpreter is presented next. It takes the context
485 : * information and starts the interpretation at the designated
486 : * instruction. Note that the stack frame is aligned and initialized
487 : * in the enclosing routine. When we start executing the first
488 : * instruction, we take the wall-clock time for resource management.
489 : */
490 : str
491 9730655 : runMALsequence(Client cntxt, MalBlkPtr mb, int startpc,
492 : int stoppc, MalStkPtr stk, MalStkPtr env, InstrPtr pcicaller)
493 : {
494 9730655 : ValPtr lhs, rhs, v;
495 9730655 : InstrPtr pci = 0;
496 9730655 : int exceptionVar;
497 9730655 : str ret = MAL_SUCCEED, localGDKerrbuf = GDKerrbuf;
498 9731938 : ValRecord backups[16];
499 9731938 : ValPtr backup;
500 9731938 : int garbages[16], *garbage;
501 9731938 : int stkpc = 0;
502 9731938 : RuntimeProfileRecord runtimeProfile, runtimeProfileFunction;
503 9731938 : lng lastcheck = 0;
504 9731938 : bool startedProfileQueue = false;
505 : #define CHECKINTERVAL 1000 /* how often do we check for client disconnect */
506 9731938 : runtimeProfile.ticks = runtimeProfileFunction.ticks = 0;
507 :
508 9731938 : if (stk == NULL)
509 0 : throw(MAL, "mal.interpreter", MAL_STACK_FAIL);
510 :
511 : /* prepare extended backup and garbage structures */
512 9731938 : if (startpc + 1 == stoppc) {
513 8938406 : pci = getInstrPtr(mb, startpc);
514 8938406 : if (pci->argc > 16) {
515 68617 : backup = GDKmalloc(pci->argc * sizeof(ValRecord));
516 68605 : garbage = (int *) GDKzalloc(pci->argc * sizeof(int));
517 68607 : if (backup == NULL || garbage == NULL) {
518 0 : GDKfree(backup);
519 0 : GDKfree(garbage);
520 0 : throw(MAL, "mal.interpreter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
521 : }
522 : } else {
523 8869789 : backup = backups;
524 8869789 : garbage = garbages;
525 8869789 : memset(garbages, 0, sizeof(garbages));
526 : }
527 793532 : } else if (mb->maxarg > 16) {
528 113246 : backup = GDKmalloc(mb->maxarg * sizeof(ValRecord));
529 113246 : garbage = (int *) GDKzalloc(mb->maxarg * sizeof(int));
530 113246 : if (backup == NULL || garbage == NULL) {
531 0 : GDKfree(backup);
532 0 : GDKfree(garbage);
533 0 : throw(MAL, "mal.interpreter", SQLSTATE(HY013) MAL_MALLOC_FAIL);
534 : }
535 : } else {
536 680286 : backup = backups;
537 680286 : garbage = garbages;
538 680286 : memset(garbages, 0, sizeof(garbages));
539 : }
540 :
541 : /* also produce event record for start of function */
542 9731928 : if (startpc == 1 && startpc < mb->stop) {
543 793540 : startedProfileQueue = true;
544 793540 : runtimeProfileInit(cntxt, mb, stk);
545 793541 : runtimeProfileBegin(cntxt, mb, stk, getInstrPtr(mb, 0),
546 : &runtimeProfileFunction);
547 793541 : if (cntxt->sessiontimeout
548 264781 : && cntxt->qryctx.starttime - cntxt->session >
549 : cntxt->sessiontimeout) {
550 0 : runtimeProfileFinish(cntxt, mb, stk);
551 0 : if (backup != backups)
552 0 : GDKfree(backup);
553 0 : if (garbage != garbages)
554 0 : GDKfree(garbage);
555 0 : throw(MAL, "mal.interpreter",
556 : SQLSTATE(HYT00) RUNTIME_SESSION_TIMEOUT);
557 : }
558 : }
559 9731929 : stkpc = startpc;
560 9731929 : exceptionVar = -1;
561 :
562 71983880 : while (stkpc < mb->stop && stkpc != stoppc) {
563 : // incomplete block being executed, requires at least signature and end statement
564 62257874 : MT_thread_setalgorithm(NULL);
565 62255105 : pci = getInstrPtr(mb, stkpc);
566 62255105 : if (cntxt->mode == FINISHCLIENT) {
567 1 : stkpc = stoppc;
568 1 : if (ret == MAL_SUCCEED)
569 1 : ret = createException(MAL, "mal.interpreter",
570 : "prematurely stopped client");
571 : break;
572 : }
573 :
574 62255104 : freeException(ret);
575 62258352 : ret = MAL_SUCCEED;
576 :
577 62258352 : if (stk->status) {
578 : /* pause procedure from SYSMON */
579 1 : if (stk->status == 'p') {
580 0 : while (stk->status == 'p')
581 0 : MT_sleep_ms(50);
582 0 : continue;
583 : }
584 : /* stop procedure from SYSMON */
585 1 : if (stk->status == 'q') {
586 1 : stkpc = mb->stop;
587 1 : ret = createException(MAL, "mal.interpreter",
588 : "Query with tag " OIDFMT
589 : " received stop signal", mb->tag);
590 1 : break;
591 : }
592 : }
593 : //Ensure we spread system resources over multiple users as well.
594 62258351 : runtimeProfileBegin(cntxt, mb, stk, pci, &runtimeProfile);
595 62254345 : if (runtimeProfile.ticks > lastcheck + CHECKINTERVAL) {
596 9845119 : if (cntxt->fdin && TIMEOUT_TEST(&cntxt->qryctx)) {
597 4 : if (cntxt->qryctx.endtime != QRY_INTERRUPT && cntxt->qryctx.endtime != QRY_TIMEOUT)
598 0 : cntxt->mode = FINISHCLIENT;
599 4 : switch (cntxt->qryctx.endtime) {
600 4 : case QRY_TIMEOUT:
601 4 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_TIMEOUT);
602 4 : break;
603 0 : case QRY_INTERRUPT:
604 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_INTERRUPT);
605 0 : break;
606 0 : default:
607 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) "Client disconnected");
608 0 : cntxt->mode = FINISHCLIENT;
609 0 : break;
610 : }
611 : break;
612 : }
613 9845794 : lastcheck = runtimeProfile.ticks;
614 : }
615 :
616 62255020 : if (qptimeout > 0) {
617 0 : lng t = GDKusec();
618 0 : ATOMIC_BASE_TYPE lp = ATOMIC_GET(&cntxt->lastprint);
619 0 : if ((lng) lp + qptimeout < t) {
620 : /* if still the same, replace lastprint with current
621 : * time and print the query */
622 0 : if (ATOMIC_CAS(&cntxt->lastprint, &lp, t)) {
623 0 : const char *q = cntxt->query ? cntxt->query : NULL;
624 0 : TRC_INFO(MAL_SERVER,
625 : "%s: query already running " LLFMT "s: %.200s\n",
626 : cntxt->mythread ? cntxt->mythread : "?",
627 : (lng) (time(0) - cntxt->lastcmd), q ? q : "");
628 : }
629 : }
630 : }
631 :
632 : /* The interpreter loop
633 : * The interpreter is geared towards execution a MAL
634 : * procedure together with all its descendant
635 : * invocations. As such, it provides the MAL abstract
636 : * machine processor.
637 : *
638 : * The value-stack frame of the surrounding scope is
639 : * needed to resolve binding values. Getting (putting) a
640 : * value from (into) a surrounding scope should be guarded
641 : * with the exclusive access lock. This situation is
642 : * encapsulated by a bind() function call, whose
643 : * parameters contain the access mode required.
644 : *
645 : * The formal procedure arguments are assumed to always
646 : * occupy the first elements in the value stack.
647 : *
648 : * Before we execute an instruction the variables to be
649 : * garbage collected are identified. In the post-execution
650 : * phase they are removed.
651 : */
652 124819842 : for (int i = 0; i < pci->retc; i++)
653 62564822 : backup[i] = stk->stk[getArg(pci, i)];
654 :
655 62255020 : if (garbageControl(pci)) {
656 132369589 : for (int i = 0; i < pci->argc; i++) {
657 102476193 : int a = getArg(pci, i);
658 :
659 102476193 : if (stk->stk[a].bat && getEndScope(mb, a) == stkpc
660 15596476 : && isNotUsedIn(pci, i + 1, a))
661 7788080 : garbage[i] = a;
662 : else
663 94688113 : garbage[i] = -1;
664 : }
665 : }
666 :
667 62255020 : switch (pci->token) {
668 7112404 : case ASSIGNsymbol:
669 : /* Assignment command
670 : * The assignment statement copies values around on
671 : * the stack frame, including multiple assignments.
672 : *
673 : * Pushing constants/initial values onto the stack is
674 : * a separate operation. It takes the constant value
675 : * discovered at compile time and stored in the symbol
676 : * table and moves it to the stackframe location. This
677 : * activity is made part of the start-up procedure.
678 : *
679 : * The before after calls should be reconsidered here,
680 : * because their. They seem superfluous and the way
681 : * they are used will cause errors in multi-assignment
682 : * statements.
683 : */
684 14124841 : for (int k = 0, i = pci->retc; k < pci->retc && i < pci->argc;
685 7012437 : i++, k++) {
686 7012309 : lhs = &stk->stk[pci->argv[k]];
687 7012309 : assert(lhs->bat == isaBatType(getArgType(mb, pci, k)));
688 7012309 : rhs = &stk->stk[pci->argv[i]];
689 7012309 : assert(rhs->bat == isaBatType(getArgType(mb, pci, i)));
690 7012309 : if (VALcopy(lhs, rhs) == NULL) {
691 0 : ret = createException(MAL, "mal.interpreter",
692 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
693 0 : break;
694 7012437 : } else if (lhs->bat && !is_bat_nil(lhs->val.bval))
695 7156 : BBPretain(lhs->val.bval);
696 : }
697 : break;
698 23234488 : case PATcall:
699 23234488 : if (pci->fcn == NULL) {
700 0 : ret = createException(MAL, "mal.interpreter",
701 : "address of pattern %s.%s missing",
702 : pci->modname, pci->fcnname);
703 : } else {
704 23234488 : TRC_DEBUG(ALGO, "calling %s.%s\n",
705 : pci->modname ? pci->modname : "<null>",
706 : pci->fcnname ? pci->fcnname : "<null>");
707 23234488 : ret = (*(str (*) (Client, MalBlkPtr, MalStkPtr, InstrPtr)) pci->
708 : fcn) (cntxt, mb, stk, pci);
709 : #ifndef NDEBUG
710 23233861 : if (ret == MAL_SUCCEED) {
711 : /* check that the types of actual results match
712 : * expected results */
713 46999935 : for (int i = 0; i < pci->retc; i++) {
714 23785502 : int a = getArg(pci, i);
715 23785502 : int t = getArgType(mb, pci, i);
716 :
717 23785502 : if (isaBatType(t)) {
718 4477249 : bat bid = stk->stk[a].val.bval;
719 4477249 : BAT *_b;
720 4477249 : t = getBatType(t);
721 4477249 : assert(stk->stk[a].bat);
722 12922202 : assert(is_bat_nil(bid) ||
723 : t == TYPE_any ||
724 : ((_b = BBP_desc(bid)) != NULL &&
725 : ATOMtype(_b->ttype) == ATOMtype(t)));
726 : } else {
727 19308253 : assert(t == stk->stk[a].vtype);
728 : }
729 : }
730 : }
731 : #endif
732 : }
733 : break;
734 31126285 : case CMDcall:
735 31126285 : TRC_DEBUG(ALGO, "calling %s.%s\n",
736 : pci->modname ? pci->modname : "<null>",
737 : pci->fcnname ? pci->fcnname : "<null>");
738 31126285 : ret = malCommandCall(stk, pci);
739 : #ifndef NDEBUG
740 31126504 : if (ret == MAL_SUCCEED) {
741 : /* check that the types of actual results match
742 : * expected results */
743 62588837 : for (int i = 0; i < pci->retc; i++) {
744 31463425 : int a = getArg(pci, i);
745 31463425 : int t = getArgType(mb, pci, i);
746 :
747 31463425 : if (isaBatType(t)) {
748 : //bat bid = stk->stk[a].val.bval;
749 17538763 : t = getBatType(t);
750 17538763 : assert(stk->stk[a].bat);
751 : //assert( !is_bat_nil(bid));
752 17538763 : assert(t != TYPE_any);
753 : //assert( ATOMtype(BBP_desc(bid)->ttype) == ATOMtype(t));
754 : } else {
755 13924662 : assert(t == stk->stk[a].vtype);
756 : }
757 : }
758 : }
759 : #endif
760 : break;
761 171053 : case FCNcall: {
762 : /*
763 : * MAL function calls are relatively expensive,
764 : * because they have to assemble a new stack frame and
765 : * do housekeeping, such as garbagecollection of all
766 : * non-returned values.
767 : */
768 171053 : MalStkPtr nstk;
769 171053 : InstrPtr q;
770 171053 : int ii, arg;
771 :
772 171053 : nstk = prepareMALstack(pci->blk, pci->blk->vsize);
773 171053 : if (nstk == 0) {
774 0 : ret = createException(MAL, "mal.interpreter", MAL_STACK_FAIL);
775 0 : break;
776 : }
777 171053 : nstk->pcup = stkpc;
778 :
779 : /*safeguardStack */
780 171053 : nstk->stkdepth = nstk->stksize + stk->stkdepth;
781 171053 : nstk->calldepth = stk->calldepth + 1;
782 171053 : nstk->up = stk;
783 171053 : if (nstk->calldepth > 256) {
784 1 : ret = createException(MAL, "mal.interpreter",
785 : MAL_CALLDEPTH_FAIL);
786 1 : GDKfree(nstk);
787 1 : break;
788 : }
789 171052 : if ((unsigned) nstk->stkdepth >
790 46472 : THREAD_STACK_SIZE / sizeof(mb->var[0]) / 4 && THRhighwater()) {
791 : /* we are running low on stack space */
792 0 : ret = createException(MAL, "mal.interpreter", MAL_STACK_FAIL);
793 0 : GDKfree(nstk);
794 0 : break;
795 : }
796 :
797 : /* copy arguments onto destination stack */
798 171052 : q = getInstrPtr(pci->blk, 0);
799 171052 : arg = q->retc;
800 864842 : for (ii = pci->retc; ii < pci->argc; ii++, arg++) {
801 693790 : lhs = &nstk->stk[q->argv[arg]];
802 693790 : rhs = &stk->stk[pci->argv[ii]];
803 693790 : if (VALcopy(lhs, rhs) == NULL) {
804 0 : GDKfree(nstk);
805 0 : ret = createException(MAL, "mal.interpreter",
806 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
807 0 : break;
808 693790 : } else if (lhs->bat)
809 18 : BBPretain(lhs->val.bval);
810 : }
811 171052 : if (ret == MAL_SUCCEED && ii == pci->argc) {
812 171052 : ret = runMALsequence(cntxt, pci->blk, 1, pci->blk->stop, nstk,
813 : stk, pci);
814 171052 : garbageCollector(cntxt, pci->blk, nstk, 0);
815 171052 : arg = q->retc;
816 864842 : for (ii = pci->retc; ii < pci->argc; ii++, arg++) {
817 693790 : lhs = &nstk->stk[q->argv[arg]];
818 693790 : if (lhs->bat)
819 0 : BBPrelease(lhs->val.bval);
820 : }
821 171052 : GDKfree(nstk);
822 : }
823 : break;
824 : }
825 : case REMsymbol:
826 : break;
827 610692 : case ENDsymbol:
828 610692 : runtimeProfileExit(cntxt, mb, stk, pci, &runtimeProfile);
829 610693 : runtimeProfileExit(cntxt, mb, stk, getInstrPtr(mb, 0),
830 : &runtimeProfileFunction);
831 610695 : if (pcicaller && garbageControl(getInstrPtr(mb, 0)))
832 5997 : garbageCollector(cntxt, mb, stk, TRUE);
833 610695 : if (cntxt->qryctx.endtime == QRY_TIMEOUT) {
834 0 : freeException(ret); /* overrule exception */
835 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_TIMEOUT);
836 0 : break;
837 610695 : } else if (cntxt->qryctx.endtime == QRY_INTERRUPT) {
838 0 : freeException(ret); /* overrule exception */
839 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_INTERRUPT);
840 0 : break;
841 : }
842 610695 : stkpc = mb->stop; // force end of loop
843 610695 : continue;
844 0 : default: {
845 0 : str w;
846 0 : if (pci->token < 0) {
847 : /* temporary NOOP instruction */
848 : break;
849 : }
850 0 : w = instruction2str(mb, 0, pci, FALSE);
851 0 : if (w) {
852 0 : ret = createException(MAL, "interpreter", "unknown operation:%s",
853 : w);
854 0 : GDKfree(w);
855 : } else {
856 0 : ret = createException(MAL, "interpreter",
857 : "failed instruction2str");
858 : }
859 : // runtimeProfileBegin already sets the time in the instruction
860 0 : if (cntxt->qryctx.endtime == QRY_TIMEOUT) {
861 0 : freeException(ret); /* overrule exception */
862 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_TIMEOUT);
863 0 : break;
864 0 : } else if (cntxt->qryctx.endtime == QRY_INTERRUPT) {
865 0 : freeException(ret); /* overrule exception */
866 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_INTERRUPT);
867 0 : break;
868 : }
869 :
870 0 : stkpc = mb->stop;
871 0 : continue;
872 : }
873 : }
874 :
875 : /* monitoring information should reflect the input arguments,
876 : which may be removed by garbage collection */
877 : /* BEWARE, the SQL engine or MAL function could zap the block, leaving garbage behind in pci */
878 : /* this hack means we loose a closing event */
879 61644048 : if (mb->stop <= 1)
880 0 : continue;
881 61644048 : runtimeProfileExit(cntxt, mb, stk, pci, &runtimeProfile);
882 : /* when we find a timeout situation, then the result is already known
883 : * and assigned, the backup version is not removed*/
884 61644139 : if (ret == MAL_SUCCEED) {
885 124186612 : for (int i = 0; i < pci->retc; i++) {
886 62563895 : lhs = &backup[i];
887 62563895 : if (lhs->bat) {
888 22051264 : BBPrelease(lhs->val.bval);
889 40512631 : } else if (ATOMextern(lhs->vtype) &&
890 3941228 : lhs->val.pval &&
891 291258 : lhs->val.pval != ATOMnilptr(lhs->vtype) &&
892 291258 : lhs->val.pval != stk->stk[getArg(pci, i)].val.pval)
893 288888 : GDKfree(lhs->val.pval);
894 : }
895 61622717 : if (ATOMIC_GET(&GDKdebug) & CHECKMASK && exceptionVar < 0) {
896 : BAT *b;
897 :
898 68798979 : for (int i = 0; i < pci->retc; i++) {
899 34866638 : if (garbage[i] == -1
900 32909115 : && stk->stk[getArg(pci, i)].bat
901 7395373 : && !is_bat_nil(stk->stk[getArg(pci, i)].val.bval)) {
902 7336692 : assert(stk->stk[getArg(pci, i)].val.bval > 0);
903 7336692 : b = BATdescriptor(stk->stk[getArg(pci, i)].val.bval);
904 7337998 : if (b == NULL) {
905 0 : if (ret == MAL_SUCCEED)
906 0 : ret = createException(MAL, "mal.propertyCheck",
907 : SQLSTATE(HY002)
908 : RUNTIME_OBJECT_MISSING);
909 0 : continue;
910 : }
911 7337998 : BATassertProps(b);
912 7335401 : BBPunfix(b->batCacheid);
913 : }
914 : }
915 : }
916 :
917 : /* general garbage collection */
918 61623885 : if (ret == MAL_SUCCEED && garbageControl(pci)) {
919 132483461 : for (int i = 0; i < pci->argc; i++) {
920 102607975 : int a = getArg(pci, i);
921 :
922 102607975 : if (isaBatType(getArgType(mb, pci, i))) {
923 51436161 : bat bid = stk->stk[a].val.bval;
924 :
925 51436161 : if (garbage[i] >= 0) {
926 7785899 : bid = stk->stk[garbage[i]].val.bval;
927 7785899 : if (!is_bat_nil(bid)) {
928 7289833 : stk->stk[garbage[i]].val.bval = bat_nil;
929 7289833 : BBPcold(bid);
930 7284973 : BBPrelease(bid);
931 : }
932 : }
933 : }
934 : }
935 : }
936 : }
937 :
938 : /* Exception handling */
939 61641256 : if (localGDKerrbuf && localGDKerrbuf[0]) {
940 2 : if (ret == MAL_SUCCEED)
941 2 : ret = createException(MAL, "mal.interpreter", GDK_EXCEPTION);
942 : // TODO take properly care of the GDK exception
943 2 : localGDKerrbuf[0] = 0;
944 : }
945 :
946 61641256 : if (ret != MAL_SUCCEED) {
947 19034 : str msg = 0;
948 :
949 : /* Detect any exception received from the implementation. */
950 : /* The first identifier is an optional exception name */
951 19034 : if (strstr(ret, "!skip-to-end")) {
952 0 : freeException(ret);
953 0 : ret = MAL_SUCCEED;
954 0 : stkpc = mb->stop;
955 0 : continue;
956 : }
957 : /*
958 : * Exceptions are caught based on their name, which is part of the
959 : * exception message. The ANYexception variable catches all.
960 : */
961 19034 : exceptionVar = -1;
962 19034 : msg = strchr(ret, ':');
963 19034 : if (msg) {
964 19034 : exceptionVar = findVariableLength(mb, ret, (int) (msg - ret));
965 : }
966 19034 : if (exceptionVar == -1)
967 19032 : exceptionVar = findVariableLength(mb, "ANYexception", 12);
968 :
969 : /* unknown exceptions lead to propagation */
970 19032 : if (exceptionVar == -1) {
971 19016 : if (cntxt->qryctx.endtime == QRY_TIMEOUT) {
972 3 : freeException(ret); /* overrule exception */
973 3 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_TIMEOUT);
974 19013 : } else if (cntxt->qryctx.endtime == QRY_INTERRUPT) {
975 0 : freeException(ret); /* overrule exception */
976 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_INTERRUPT);
977 : }
978 19016 : stkpc = mb->stop;
979 19016 : continue;
980 : }
981 : /* assure correct variable type */
982 18 : if (getVarType(mb, exceptionVar) == TYPE_str) {
983 : /* watch out for concurrent access */
984 18 : MT_lock_set(&mal_contextLock);
985 18 : v = &stk->stk[exceptionVar];
986 18 : if (v->val.sval)
987 5 : freeException(v->val.sval); /* old exception */
988 18 : VALset(v, TYPE_str, ret);
989 18 : ret = MAL_SUCCEED;
990 18 : MT_lock_unset(&mal_contextLock);
991 : } else {
992 0 : mnstr_printf(cntxt->fdout, "%s", ret);
993 0 : freeException(ret);
994 0 : ret = MAL_SUCCEED;
995 : }
996 : /* position yourself at the catch instruction for further decisions */
997 : /* skipToCatch(exceptionVar,@2,@3) */
998 : /* skip to catch block or end */
999 201 : for (; stkpc < mb->stop; stkpc++) {
1000 201 : InstrPtr l = getInstrPtr(mb, stkpc);
1001 201 : if (l->barrier == CATCHsymbol) {
1002 : int j;
1003 18 : for (j = 0; j < l->retc; j++)
1004 18 : if (getArg(l, j) == exceptionVar)
1005 : break;
1006 0 : else if (getArgName(mb, l, j) && strcmp(getArgName(mb, l, j), "ANYexception") == 0)
1007 : break;
1008 18 : if (j < l->retc)
1009 : break;
1010 : }
1011 : }
1012 18 : if (stkpc == mb->stop) {
1013 0 : if (cntxt->qryctx.endtime == QRY_TIMEOUT) {
1014 0 : freeException(ret); /* overrule exception */
1015 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_TIMEOUT);
1016 0 : stkpc = mb->stop;
1017 0 : } else if (cntxt->qryctx.endtime == QRY_INTERRUPT) {
1018 0 : freeException(ret); /* overrule exception */
1019 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_INTERRUPT);
1020 0 : stkpc = mb->stop;
1021 : }
1022 0 : continue;
1023 : }
1024 18 : pci = getInstrPtr(mb, stkpc);
1025 : }
1026 :
1027 : /*
1028 : * After the expression has been evaluated we should check for
1029 : * a possible change in the control flow.
1030 : */
1031 61622240 : switch (pci->barrier) {
1032 2733704 : case BARRIERsymbol:
1033 2733704 : v = &stk->stk[getDestVar(pci)];
1034 : /* skip to end of barrier, depends on the type */
1035 2733704 : switch (v->vtype) {
1036 2731264 : case TYPE_bit:
1037 2731264 : if (v->val.btval == FALSE || is_bit_nil(v->val.btval))
1038 2628825 : stkpc = pci->jump;
1039 : break;
1040 0 : case TYPE_bte:
1041 0 : if (is_bte_nil(v->val.btval))
1042 0 : stkpc = pci->jump;
1043 : break;
1044 2416 : case TYPE_oid:
1045 2416 : if (is_oid_nil(v->val.oval))
1046 2195 : stkpc = pci->jump;
1047 : break;
1048 0 : case TYPE_sht:
1049 0 : if (is_sht_nil(v->val.shval))
1050 0 : stkpc = pci->jump;
1051 : break;
1052 9 : case TYPE_int:
1053 9 : if (is_int_nil(v->val.ival))
1054 0 : stkpc = pci->jump;
1055 : break;
1056 14 : case TYPE_lng:
1057 14 : if (is_lng_nil(v->val.lval))
1058 0 : stkpc = pci->jump;
1059 : break;
1060 : #ifdef HAVE_HGE
1061 0 : case TYPE_hge:
1062 0 : if (is_hge_nil(v->val.hval))
1063 0 : stkpc = pci->jump;
1064 : break;
1065 : #endif
1066 1 : case TYPE_flt:
1067 1 : if (is_flt_nil(v->val.fval))
1068 0 : stkpc = pci->jump;
1069 : break;
1070 0 : case TYPE_dbl:
1071 0 : if (is_dbl_nil(v->val.dval))
1072 0 : stkpc = pci->jump;
1073 : break;
1074 0 : case TYPE_str:
1075 0 : if (strNil(v->val.sval))
1076 0 : stkpc = pci->jump;
1077 : break;
1078 0 : default: {
1079 0 : char name[IDLENGTH];
1080 0 : ret = createException(MAL, "mal.interpreter",
1081 : "%s: Unknown barrier type",
1082 : getVarNameIntoBuffer(mb,
1083 : getDestVar
1084 : (pci), name));
1085 : }
1086 : }
1087 2733704 : stkpc++;
1088 2733704 : break;
1089 13305252 : case LEAVEsymbol:
1090 : case REDOsymbol:
1091 13305252 : v = &stk->stk[getDestVar(pci)];
1092 : /* skip to end of barrier, depending on the type */
1093 13305252 : switch (v->vtype) {
1094 1907 : case TYPE_bit:
1095 1907 : if (v->val.btval == TRUE)
1096 854 : stkpc = pci->jump;
1097 : else
1098 1053 : stkpc++;
1099 : break;
1100 0 : case TYPE_str:
1101 0 : if (!strNil(v->val.sval))
1102 0 : stkpc = pci->jump;
1103 : else
1104 0 : stkpc++;
1105 : break;
1106 92971 : case TYPE_oid:
1107 92971 : if (!is_oid_nil(v->val.oval))
1108 92756 : stkpc = pci->jump;
1109 : else
1110 215 : stkpc++;
1111 : break;
1112 0 : case TYPE_sht:
1113 0 : if (!is_sht_nil(v->val.shval))
1114 0 : stkpc = pci->jump;
1115 : else
1116 0 : stkpc++;
1117 : break;
1118 119 : case TYPE_int:
1119 119 : if (!is_int_nil(v->val.ival))
1120 114 : stkpc = pci->jump;
1121 : else
1122 5 : stkpc++;
1123 : break;
1124 0 : case TYPE_bte:
1125 0 : if (!is_bte_nil(v->val.btval))
1126 0 : stkpc = pci->jump;
1127 : else
1128 0 : stkpc++;
1129 : break;
1130 13210253 : case TYPE_lng:
1131 13210253 : if (!is_lng_nil(v->val.lval))
1132 13210239 : stkpc = pci->jump;
1133 : else
1134 14 : stkpc++;
1135 : break;
1136 : #ifdef HAVE_HGE
1137 0 : case TYPE_hge:
1138 0 : if (!is_hge_nil(v->val.hval))
1139 0 : stkpc = pci->jump;
1140 : else
1141 0 : stkpc++;
1142 : break;
1143 : #endif
1144 2 : case TYPE_flt:
1145 2 : if (!is_flt_nil(v->val.fval))
1146 1 : stkpc = pci->jump;
1147 : else
1148 1 : stkpc++;
1149 : break;
1150 0 : case TYPE_dbl:
1151 0 : if (!is_dbl_nil(v->val.dval))
1152 0 : stkpc = pci->jump;
1153 : else
1154 0 : stkpc++;
1155 : break;
1156 : default:
1157 : break;
1158 : }
1159 : break;
1160 41 : case CATCHsymbol:
1161 : /* catch blocks are skipped unless
1162 : searched for explicitly */
1163 41 : if (exceptionVar < 0) {
1164 20 : stkpc = pci->jump;
1165 20 : break;
1166 : }
1167 21 : exceptionVar = -1;
1168 21 : stkpc++;
1169 21 : break;
1170 102572 : case EXITsymbol:
1171 102572 : if (getDestVar(pci) == exceptionVar)
1172 0 : exceptionVar = -1;
1173 102572 : stkpc++;
1174 102572 : break;
1175 17 : case RAISEsymbol:
1176 17 : exceptionVar = getDestVar(pci);
1177 : //freeException(ret);
1178 17 : ret = MAL_SUCCEED;
1179 17 : if (getVarType(mb, getDestVar(pci)) == TYPE_str) {
1180 15 : char nme[256];
1181 15 : snprintf(nme, 256, "%s.%s[%d]", getModuleId(getInstrPtr(mb, 0)),
1182 15 : getFunctionId(getInstrPtr(mb, 0)), stkpc);
1183 15 : ret = createException(MAL, nme, "%s",
1184 15 : stk->stk[getDestVar(pci)].val.sval);
1185 : }
1186 : /* skipToCatch(exceptionVar, @2, stk) */
1187 : /* skip to catch block or end */
1188 396 : for (; stkpc < mb->stop; stkpc++) {
1189 382 : InstrPtr l = getInstrPtr(mb, stkpc);
1190 382 : if (l->barrier == CATCHsymbol) {
1191 : int j;
1192 3 : for (j = 0; j < l->retc; j++)
1193 3 : if (getArg(l, j) == exceptionVar)
1194 : break;
1195 0 : else if (getArgName(mb, l, j) && strcmp(getArgName(mb, l, j), "ANYexception") == 0)
1196 : break;
1197 3 : if (j < l->retc)
1198 : break;
1199 : }
1200 : }
1201 17 : if (stkpc == mb->stop) {
1202 14 : runtimeProfileExit(cntxt, mb, stk, pci, &runtimeProfile);
1203 14 : runtimeProfileExit(cntxt, mb, stk, getInstrPtr(mb, 0),
1204 : &runtimeProfileFunction);
1205 14 : break;
1206 : }
1207 : break;
1208 164805 : case RETURNsymbol:
1209 : /* a fake multi-assignment */
1210 164805 : if (env != NULL && pcicaller != NULL) {
1211 : InstrPtr pp = pci;
1212 332106 : pci = pcicaller;
1213 332106 : for (int i = 0; i < pci->retc; i++) {
1214 167303 : rhs = &stk->stk[pp->argv[i]];
1215 167303 : lhs = &env->stk[pci->argv[i]];
1216 167303 : if (VALcopy(lhs, rhs) == NULL) {
1217 0 : ret = createException(MAL, "mal.interpreter",
1218 : SQLSTATE(HY013) MAL_MALLOC_FAIL);
1219 0 : break;
1220 167303 : } else if (lhs->bat)
1221 2965 : BBPretain(lhs->val.bval);
1222 : }
1223 164803 : if (garbageControl(getInstrPtr(mb, 0)))
1224 164764 : garbageCollector(cntxt, mb, stk, TRUE);
1225 : /* reset the clock */
1226 164803 : runtimeProfileExit(cntxt, mb, stk, pp, &runtimeProfile);
1227 164803 : runtimeProfileExit(cntxt, mb, stk, getInstrPtr(mb, 0),
1228 : &runtimeProfileFunction);
1229 : }
1230 164805 : stkpc = mb->stop;
1231 164805 : continue;
1232 45315849 : default:
1233 45315849 : stkpc++;
1234 : }
1235 61457435 : if (cntxt->qryctx.endtime == QRY_TIMEOUT) {
1236 0 : if (ret == MAL_SUCCEED)
1237 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_TIMEOUT);
1238 0 : stkpc = mb->stop;
1239 61457435 : } else if (cntxt->qryctx.endtime == QRY_INTERRUPT) {
1240 0 : if (ret == MAL_SUCCEED)
1241 0 : ret = createException(MAL, "mal.interpreter", SQLSTATE(HYT00) RUNTIME_QRY_INTERRUPT);
1242 0 : stkpc = mb->stop;
1243 : }
1244 : }
1245 :
1246 : /* if we could not find the exception variable, cascade a new one */
1247 : /* don't add 'exception not caught' extra message for MAL sequences besides main function calls */
1248 9726012 : if (exceptionVar >= 0 && (ret == MAL_SUCCEED || !pcicaller)) {
1249 1 : char nme[256];
1250 1 : snprintf(nme, 256, "%s.%s[%d]", getModuleId(getInstrPtr(mb, 0)),
1251 1 : getFunctionId(getInstrPtr(mb, 0)), stkpc);
1252 1 : if (ret != MAL_SUCCEED) {
1253 0 : str new, n;
1254 0 : n = createException(MAL, nme, "exception not caught");
1255 0 : if (n) {
1256 0 : new = GDKmalloc(strlen(ret) + strlen(n) + 16);
1257 0 : if (new) {
1258 0 : char *p = stpcpy(new, ret);
1259 0 : if (p[-1] != '\n')
1260 0 : *p++ = '\n';
1261 0 : *p++ = '!';
1262 0 : p = stpcpy(p, n);
1263 0 : freeException(n);
1264 0 : freeException(ret);
1265 0 : ret = new;
1266 : } else {
1267 0 : freeException(ret);
1268 0 : ret = n;
1269 : }
1270 : }
1271 : } else {
1272 1 : ret = createException(MAL, nme, "Exception not caught");
1273 : }
1274 : }
1275 9726012 : if (startedProfileQueue)
1276 793540 : runtimeProfileFinish(cntxt, mb, stk);
1277 9726013 : if (backup != backups)
1278 181830 : GDKfree(backup);
1279 9725337 : if (garbage != garbages)
1280 181848 : GDKfree(garbage);
1281 : return ret;
1282 : }
1283 :
1284 :
1285 : /*
1286 : * MAL API
1287 : * The linkage between MAL interpreter and compiled C-routines
1288 : * is kept as simple as possible.
1289 : * Basically we distinguish four kinds of calling conventions:
1290 : * CMDcall, FCNcall and PATcall.
1291 : * The FCNcall indicates calling a MAL procedure, which leads
1292 : * to a recursive call to the interpreter.
1293 : *
1294 : * CMDcall initiates calling a linked function, passing pointers
1295 : * to the parameters and result variable, i.e. f(ptr a0,..., ptr aN)
1296 : * The function returns a MAL-SUCCEED upon success and a pointer
1297 : * to an exception string upon failure.
1298 : * Failure leads to raise-ing an exception in the interpreter loop,
1299 : * by either looking up the relevant exception message in the module
1300 : * administration or construction of a standard string.
1301 : *
1302 : * The PATcall initiates a call which contains the MAL context,
1303 : * i.e. f(MalBlkPtr mb, MalStkPtr stk, InstrPtr pci)
1304 : * The mb provides access to the code definitions. It is primarilly
1305 : * used by routines intended to manipulate the code base itself, such
1306 : * as the optimizers. The Mal stack frame pointer provides access
1307 : * to the values maintained. The arguments passed are offsets
1308 : * into the stack frame rather than pointers to the actual value.
1309 : *
1310 : * BAT parameters require some care. Ideally, a BAT should not be kept
1311 : * around long. This would mean that each time we access a BAT it has to be
1312 : * pinned in memory and upon leaving the function, it is unpinned.
1313 : * This degrades performance significantly.
1314 : * After the parameters are fixed, we can safely free the destination
1315 : * variable and re-initialize it to nil.
1316 : *
1317 : */
1318 :
1319 : /*
1320 : * The type dispatching table in getArgReference can be removed if we
1321 : * determine at compile time the address offset within a ValRecord.
1322 : * We leave this optimization for the future, it leads to about 10%
1323 : * improvement (100ms for 1M calls).
1324 : *
1325 : * Flow of control statements
1326 : * Each assignment (function call) may be part of the initialization
1327 : * of a barrier- block. In that case we have to test the
1328 : * outcome of the operation and possibly skip the block altogether.
1329 : * The latter is implemented as a linear scan for the corresponding
1330 : * labeled statemtent. This might be optimized later.
1331 : *
1332 : * You can skip to a catch block by searching for the corresponding 'lab'
1333 : * The return value should be set to pass the error automatically upon
1334 : * reaching end of function block.
1335 : */
1336 :
1337 : /*
1338 : * Each time we enter a barrier block, we could keep its position in the
1339 : * interpreter stack frame. It forms the starting point to issue a redo.
1340 : * Unfortunately, this does not easily work in the presence of optimizers, which
1341 : * may change the order/block structure. Therefore, we simple have to search
1342 : * the beginning or ensure that during chkProgram the barrier/redo/leave/catch
1343 : * jumps are re-established.
1344 : *
1345 : * Exception handling
1346 : * Calling a built-in or user-defined routine may lead to an error or a
1347 : * cached status message to be dealt with in MAL.
1348 : * To improve error handling in MAL, an exception handling
1349 : * scheme based on @sc{catch}-@sc{exit} blocks. The @sc{catch}
1350 : * statement identifies a (string-valued) variable, which carries the
1351 : * exception message from
1352 : * the originally failed routine or @sc{raise} exception assignment.
1353 : * During normal processing @sc{catch}-@sc{exit} blocks are simply skipped.
1354 : * Upon receiving an exception status from a function call, we set the
1355 : * exception variable and skip to the first associated @sc{catch}-@sc{exit}
1356 : * block.
1357 : * MAL interpretation then continues until it reaches the end of the block.
1358 : * If no exception variable was defined, we should abandon the function
1359 : * altogether searching for a catch block at a higher layer.
1360 : *
1361 : * For the time being we have ignored cascaded/stacked exceptions.
1362 : * The policy is to pass the first recognized exception to a context
1363 : * in which it can be handled.
1364 : *
1365 : * Exceptions raised within a linked-in function requires some care.
1366 : * First, the called procedure does not know anything about the MAL
1367 : * interpreter context. Thus, we need to return all relevant information
1368 : * upon leaving the linked library routine.
1369 : *
1370 : * Second, exceptional cases can be handled deeply in the recursion, where they
1371 : * may also be handled, i.e. by issuing an GDKerror message. The upper layers
1372 : * merely receive a negative integer value to indicate occurrence of an
1373 : * error somewhere in the calling sequence.
1374 : * We then have to also look into GDKerrbuf to see if there was
1375 : * an error raised deeply inside the system.
1376 : *
1377 : * The policy is to require all C-functions to return a string-pointer.
1378 : * Upon a successful call, it is a NULL string. Otherwise it contains an
1379 : * encoding of the exceptional state encountered. This message
1380 : * starts with the exception identifier, followed by contextual details.
1381 : */
1382 :
1383 : /*
1384 : * Garbage collection
1385 : * Garbage collection is relatively straightforward, because most values are
1386 : * retained on the stackframe of an interpreter call. However, two storage
1387 : * types and possibly user-defined type garbage collector definitions
1388 : * require attention: BATs and strings.
1389 : *
1390 : * A key issue is to deal with temporary BATs in an efficient way.
1391 : * References to bats in the buffer pool may cause dangling references
1392 : * at the language level. This appears as soons as your share
1393 : * a reference and delete the BAT from one angle. If not careful, the
1394 : * dangling pointer may subsequently be associated with another BAT
1395 : *
1396 : * All string values are private to the VALrecord, which means they
1397 : * have to be freed explicitly before a MAL function returns.
1398 : * The first step is to always safe the destination variable
1399 : * before a function call is made.
1400 : */
1401 : void
1402 279318878 : garbageElement(Client cntxt, ValPtr v)
1403 : {
1404 279318878 : (void) cntxt;
1405 279318878 : if (v->bat) {
1406 : /*
1407 : * All operations are responsible to properly set the
1408 : * reference count of the BATs being produced or destroyed.
1409 : * The libraries should not leave the
1410 : * physical reference count being set. This is only
1411 : * allowed during the execution of a GDK operation.
1412 : * All references should be logical.
1413 : */
1414 15658565 : bat bid = v->val.bval;
1415 : /* printf("garbage collecting: %d lrefs=%d refs=%d\n",
1416 : bid, BBP_lrefs(bid),BBP_refs(bid)); */
1417 15658565 : v->val.bval = bat_nil;
1418 15658565 : v->bat = false;
1419 15658565 : if (is_bat_nil(bid))
1420 : return;
1421 319787 : BBPcold(bid);
1422 319792 : BBPrelease(bid);
1423 263660313 : } else if (ATOMstorage(v->vtype) == TYPE_str) {
1424 59200950 : GDKfree(v->val.sval);
1425 59200909 : v->val.sval = NULL;
1426 59200909 : v->len = 0;
1427 204459363 : } else if (0 < v->vtype && v->vtype < MAXATOMS && ATOMextern(v->vtype)) {
1428 2638 : GDKfree(v->val.pval);
1429 2638 : v->val.pval = 0;
1430 2638 : v->len = 0;
1431 : }
1432 : }
1433 :
1434 : /*
1435 : * Before we return from the interpreter, we should free all
1436 : * dynamically allocated objects and adjust the BAT reference counts.
1437 : * Early experience shows that for small stack frames the overhead
1438 : * is about 200 ms for a 1M function call loop (tst400e). This means that
1439 : * for the time being we do not introduce more complex garbage
1440 : * administration code.
1441 : *
1442 : * Also note that for top-level stack frames (no environment available),
1443 : * we should retain the value stack because it acts as a global variables.
1444 : * This situation is indicated by the 'global' in the stack frame.
1445 : * Upon termination of the session, the stack should be cleared.
1446 : * Beware that variables may be know polymorphic, their actual
1447 : * type should be saved for variables that reside on a global
1448 : * stack frame.
1449 : */
1450 : void
1451 991849 : garbageCollector(Client cntxt, MalBlkPtr mb, MalStkPtr stk, int flag)
1452 : {
1453 991849 : assert(mb->vtop <= mb->vsize);
1454 991849 : assert(stk->stktop <= stk->stksize);
1455 : (void) flag;
1456 : (void) mb;
1457 : (void) cntxt;
1458 280293479 : for (int k = 0; k < stk->stktop; k++) {
1459 : // if (isVarCleanup(mb, k) ){
1460 279301635 : ValPtr v = &stk->stk[k];
1461 279301635 : garbageElement(cntxt, v);
1462 279301630 : *v = (ValRecord) {
1463 : .vtype = TYPE_int,
1464 : .val.ival = int_nil,
1465 : .bat = false,
1466 : };
1467 : // }
1468 : }
1469 991844 : }
|
