src/runops_cores.c

   1 /*
   2 Copyright (C) 2001-2006, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/runops_cores.c - Run Loops
   8
   9 =head1 DESCRIPTION
  10
  11 This file implements the various run loops for the interpreter. A slow
  12 one with bounds checking, tracing and (optional) profiling, and a fast
  13 one without. There's also one which uses computed C<goto>, which enables
  14 the faster dispatch of operations.
  15
  16 =head2 Functions
  17
  18 =over 4
  19
  20 =cut
  21
  22 */
  23
  24 #include "runops_cores.h"
  25 #include "parrot/embed.h"
  26 #include "trace.h"
  27 #include "interp_guts.h"
  28
  29 #ifdef HAVE_COMPUTED_GOTO
  30 #  include "parrot/oplib/core_ops_cg.h"
  31 #endif
  32
  33 /* HEADERIZER HFILE: src/runops_cores.h */
  34
  35 /* HEADERIZER BEGIN: static */
  36
  37 PARROT_WARN_UNUSED_RESULT
  38 PARROT_CAN_RETURN_NULL
  39 static opcode_t * runops_trace_core(PARROT_INTERP, ARGIN(opcode_t *pc))
  40         __attribute__nonnull__(1)
  41         __attribute__nonnull__(2);
  42
  43 /* HEADERIZER END: static */
  44
  45 /*
  46
  47 =item C<opcode_t * runops_fast_core>
  48
  49 Runs the Parrot operations starting at C<pc> until there are no more
  50 operations.
  51
  52 No bounds checking, profiling or tracing is performed.
  53
  54 =cut
  55
  56 */
  57
  58 PARROT_WARN_UNUSED_RESULT
  59 PARROT_CAN_RETURN_NULL
  60 opcode_t *
  61 runops_fast_core(PARROT_INTERP, ARGIN(opcode_t *pc))
  62 {
  63     while (pc) {
  64         DO_OP(pc, interp);
  65     }
  66     return pc;
  67 }
  68
  69 /*
  70
  71 =item C<opcode_t * runops_cgoto_core>
  72
  73 Runs the Parrot operations starting at C<pc> until there are no more
  74 operations, using the computed C<goto> core.
  75
  76 No bounds checking, profiling or tracing is performed.
  77
  78 If computed C<goto> is not available then Parrot exits with exit code 1.
  79
  80 =cut
  81
  82 */
  83
  84 PARROT_WARN_UNUSED_RESULT
  85 PARROT_CAN_RETURN_NULL
  86 opcode_t *
  87 runops_cgoto_core(PARROT_INTERP, ARGIN(opcode_t *pc))
  88 {
  89 #ifdef HAVE_COMPUTED_GOTO
  90     pc = cg_core(pc, interp);
  91     return pc;
  92 #else
  93     UNUSED(pc);
  94     PIO_eprintf(interp,
  95             "Computed goto unavailable in this configuration.\n");
  96     Parrot_exit(interp, 1);
  97 #endif
  98 }
  99
 100 #ifdef code_start
 101 #  undef code_start
 102 #endif
 103 #ifdef code_end
 104 #  undef code_end
 105 #endif
 106
 107 #define  code_start interp->code->base.data
 108 #define  code_end (interp->code->base.data + interp->code->base.size)
 109
 110 /*
 111
 112 =item C<static opcode_t * runops_trace_core>
 113
 114 Runs the Parrot operations starting at C<pc> until there are no more
 115 operations, using the tracing interpreter.
 116
 117 =cut
 118
 119 */
 120
 121 PARROT_WARN_UNUSED_RESULT
 122 PARROT_CAN_RETURN_NULL
 123 static opcode_t *
 124 runops_trace_core(PARROT_INTERP, ARGIN(opcode_t *pc))
 125 {
 126     static size_t dod, gc;
 127     Arenas * const arena_base = interp->arena_base;
 128     Interp *debugger;
 129     PMC* pio;
 130
 131     dod = arena_base->dod_runs;
 132     gc = arena_base->collect_runs;
 133     if (!interp->debugger) {
 134         PMC *pio;
 135
 136         debugger = interp->debugger =
 137             /*
 138              * using a distinct interpreter for tracing should be ok
 139              * - just in case, make it easy to switch
 140              */
 141 #if 1
 142             make_interpreter(interp, 0);
 143 #else
 144             interp;
 145 #endif
 146         debugger->lo_var_ptr = interp->lo_var_ptr;
 147         pio = PIO_STDERR(debugger);
 148         if (PIO_isatty(debugger, pio))
 149             PIO_setlinebuf(debugger, pio);
 150         else {
 151             /* this is essential (100 x faster!)  and should probably
 152              * be in init/open code */
 153             PIO_setbuf(debugger, pio, 8192);
 154         }
 155     }
 156     else
 157         debugger = interp->debugger;
 158     trace_op(interp, code_start, code_end, pc);
 159     while (pc) {
 160         if (pc < code_start || pc >= code_end) {
 161             real_exception(interp, NULL, 1,
 162                     "attempt to access code outside of current code segment");
 163         }
 164         CONTEXT(interp->ctx)->current_pc = pc;
 165
 166         DO_OP(pc, interp);
 167         trace_op(interp, code_start, code_end, pc);
 168         if (dod != arena_base->dod_runs) {
 169             dod = arena_base->dod_runs;
 170             PIO_eprintf(debugger, "       DOD\n");
 171         }
 172         if (gc != arena_base->collect_runs) {
 173             gc = arena_base->collect_runs;
 174             PIO_eprintf(debugger, "       GC\n");
 175         }
 176     }
 177     pio = PIO_STDERR(debugger);
 178     PIO_flush(debugger, pio);
 179
 180     return pc;
 181 }
 182
 183 /*
 184
 185 =item C<opcode_t * runops_slow_core>
 186
 187 Runs the Parrot operations starting at C<pc> until there are no more
 188 operations, with tracing and bounds checking enabled.
 189
 190 =cut
 191
 192 */
 193
 194 PARROT_WARN_UNUSED_RESULT
 195 PARROT_CAN_RETURN_NULL
 196 opcode_t *
 197 runops_slow_core(PARROT_INTERP, ARGIN(opcode_t *pc))
 198 {
 199
 200     if (Interp_trace_TEST(interp, PARROT_TRACE_OPS_FLAG)) {
 201         return runops_trace_core(interp, pc);
 202     }
 203     else if (interp->debugger && interp->debugger->pdb) {
 204         return Parrot_debug(interp->debugger, pc);
 205     }
 206     while (pc) {
 207         if (pc < code_start || pc >= code_end) {
 208             real_exception(interp, NULL, 1,
 209                     "attempt to access code outside of current code segment");
 210         }
 211         CONTEXT(interp->ctx)->current_pc = pc;
 212
 213         DO_OP(pc, interp);
 214     }
 215     return pc;
 216 }
 217
 218 /*
 219
 220 =item C<opcode_t * runops_gc_debug_core>
 221
 222 Runs the Parrot operations starting at C<pc> until there are no more
 223 operations, performing a full GC run before each op.  This is very slow, but
 224 it's also a very quick way to find GC problems.
 225
 226 =cut
 227
 228 */
 229
 230 PARROT_WARN_UNUSED_RESULT
 231 PARROT_CAN_RETURN_NULL
 232 opcode_t *
 233 runops_gc_debug_core(PARROT_INTERP, ARGIN(opcode_t *pc))
 234 {
 235     while (pc) {
 236         if (pc < code_start || pc >= code_end) {
 237             real_exception(interp, NULL, 1,
 238                     "attempt to access code outside of current code segment");
 239         }
 240         Parrot_do_dod_run(interp, 0);
 241         CONTEXT(interp->ctx)->current_pc = pc;
 242
 243         DO_OP(pc, interp);
 244     }
 245
 246     return pc;
 247 }
 248
 249 #undef code_start
 250 #undef code_end
 251
 252 /*
 253
 254 =item C<opcode_t * runops_profile_core>
 255
 256 Runs the Parrot operations starting at C<pc> until there are no more
 257 operations, with tracing, bounds checking and profiling enabled.
 258
 259 =cut
 260
 261 */
 262
 263 PARROT_WARN_UNUSED_RESULT
 264 PARROT_CAN_RETURN_NULL
 265 opcode_t *
 266 runops_profile_core(PARROT_INTERP, ARGIN(opcode_t *pc))
 267 {
 268     RunProfile * const profile = interp->profile;
 269
 270     const opcode_t old_op = profile->cur_op;
 271     /*
 272      * if we are reentering the runloop:
 273      * - remember old op and calc time till now
 274      */
 275     if (old_op) {
 276         profile->data[old_op].time +=
 277             Parrot_floatval_time() - profile->starttime;
 278     }
 279
 280     while (pc) {/* && pc >= code_start && pc < code_end) */
 281         opcode_t cur_op;
 282         CONTEXT(interp->ctx)->current_pc = pc;
 283         profile->cur_op = cur_op = *pc + PARROT_PROF_EXTRA;
 284         profile->data[cur_op].numcalls++;
 285         profile->starttime = Parrot_floatval_time();
 286
 287         DO_OP(pc, interp);
 288
 289         /* profile->cur_op may be different, if exception was thrown */
 290         profile->data[profile->cur_op].time +=
 291             Parrot_floatval_time() - profile->starttime;
 292     }
 293     if (old_op) {
 294         /* old opcode continues */
 295         profile->starttime = Parrot_floatval_time();
 296         profile->cur_op = old_op;
 297     }
 298     return pc;
 299 }
 300
 301 /*
 302
 303 =back
 304
 305 */
 306
 307 /*
 308  * Local variables:
 309  *   c-file-style: "parrot"
 310  * End:
 311  * vim: expandtab shiftwidth=4:
 312  */