src/pmc_freeze.c

   1 /*
   2 Copyright (C) 2001-2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc_freeze.c - Freeze and thaw functionality
   8
   9 =head1 DESCRIPTION
  10
  11 Thawing PMCs uses a list with (maximum) size of the amount of PMCs to
  12 keep track of retrieved PMCs.
  13
  14 PMCs freeze and thaw their own information through their vtables.
  15
  16 To avoid recursion, the whole functionality is driven by
  17 C<< pmc->vtable->visit >>, which is called for the first PMC initially.
  18 Container PMCs call a "todo-callback" for all contained PMCs. The
  19 individual action vtable (freeze/thaw) is then called for all todo-PMCs.
  20
  21 =cut
  22
  23 */
  24
  25 #include "parrot/parrot.h"
  26 #include "pmc/pmc_callcontext.h"
  27 #include "pmc_freeze.str"
  28
  29 /* when thawing a string longer then this size, we first do a GC run and then
  30  * block GC - the system can't give us more headers */
  31
  32 #define THAW_BLOCK_GC_SIZE 100000
  33
  34 /* HEADERIZER HFILE: include/parrot/pmc_freeze.h */
  35
  36 /*
  37
  38 =head2 Public Interface
  39
  40 =over 4
  41
  42 =item C<STRING* Parrot_freeze(PARROT_INTERP, PMC *pmc)>
  43
  44 Freeze using either method.
  45
  46 =cut
  47
  48 */
  49
  50 PARROT_EXPORT
  51 PARROT_WARN_UNUSED_RESULT
  52 PARROT_CANNOT_RETURN_NULL
  53 STRING*
  54 Parrot_freeze(PARROT_INTERP, ARGIN(PMC *pmc))
  55 {
  56     ASSERT_ARGS(Parrot_freeze)
  57     PMC * const image = Parrot_pmc_new(interp, enum_class_ImageIO);
  58     VTABLE_set_pmc(interp, image, pmc);
  59     return VTABLE_get_string(interp, image);
  60 }
  61
  62
  63 /*
  64
  65 =item C<opcode_t * Parrot_freeze_pbc(PARROT_INTERP, PMC *pmc, const
  66 PackFile_ConstTable *pf, opcode_t *cursor)>
  67
  68 Freezes a PMC to a PackFile.
  69
  70 =cut
  71
  72 */
  73
  74 PARROT_EXPORT
  75 PARROT_WARN_UNUSED_RESULT
  76 PARROT_CAN_RETURN_NULL
  77 opcode_t *
  78 Parrot_freeze_pbc(PARROT_INTERP, ARGIN(PMC *pmc), ARGIN(const PackFile_ConstTable *pf),
  79     ARGIN(opcode_t *cursor))
  80 {
  81     ASSERT_ARGS(Parrot_freeze_pbc)
  82     PMC    *visitor;
  83     STRING *image;
  84     DECL_CONST_CAST;
  85
  86     visitor  = Parrot_pmc_new(interp, enum_class_ImageIO);
  87     VTABLE_set_pointer(interp, visitor,
  88         PARROT_const_cast(void *, (const void *)pf));
  89     VTABLE_set_pmc(interp, visitor, pmc);
  90
  91     image  = VTABLE_get_string(interp, visitor);
  92     cursor = PF_store_buf(cursor, image);
  93
  94     return cursor;
  95 }
  96
  97
  98 /*
  99
 100 =item C<UINTVAL Parrot_freeze_size(PARROT_INTERP, PMC *pmc)>
 101
 102 Gets the size of an image to be frozen without allocating a large buffer.
 103
 104 =cut
 105
 106 */
 107
 108 PARROT_EXPORT
 109 PARROT_WARN_UNUSED_RESULT
 110 UINTVAL
 111 Parrot_freeze_size(PARROT_INTERP, ARGIN(PMC *pmc))
 112 {
 113     ASSERT_ARGS(Parrot_freeze_size)
 114     PMC    *pmc_result;
 115     PMC    * const visitor = Parrot_pmc_new(interp, enum_class_ImageIOSize);
 116     VTABLE_set_pmc(interp, visitor, pmc);
 117     pmc_result = VTABLE_get_pmc(interp, visitor);
 118
 119     return VTABLE_get_integer(interp, pmc_result);
 120 }
 121
 122
 123 /*
 124
 125 =item C<UINTVAL Parrot_freeze_pbc_size(PARROT_INTERP, PMC *pmc, const
 126 PackFile_ConstTable *pf)>
 127
 128 Gets the size of an image if it were created using C<Parrot_freeze_pbc>.
 129
 130 =cut
 131
 132 */
 133
 134 PARROT_EXPORT
 135 PARROT_WARN_UNUSED_RESULT
 136 UINTVAL
 137 Parrot_freeze_pbc_size(PARROT_INTERP, ARGIN(PMC *pmc), ARGIN(const PackFile_ConstTable *pf))
 138 {
 139     ASSERT_ARGS(Parrot_freeze_pbc_size)
 140     PMC *pf_pmc = Parrot_pmc_new(interp, enum_class_UnManagedStruct);
 141     PMC *visitor, *pmc_result;
 142     DECL_CONST_CAST;
 143
 144     VTABLE_set_pointer(interp, pf_pmc,
 145         PARROT_const_cast(void *, (const void *)pf));
 146
 147     visitor = Parrot_pmc_new_init(interp, enum_class_ImageIOSize, pf_pmc);
 148     VTABLE_set_pmc(interp, visitor, pmc);
 149
 150     pmc_result = VTABLE_get_pmc(interp, visitor);
 151     return VTABLE_get_integer(interp, pmc_result);
 152 }
 153
 154
 155 /*
 156
 157 =item C<PMC * Parrot_freeze_strings(PARROT_INTERP, PMC *pmc)>
 158
 159 Gets the strings of a PMC to be frozen.
 160
 161 =cut
 162
 163 */
 164
 165 PARROT_EXPORT
 166 PARROT_WARN_UNUSED_RESULT
 167 PARROT_CANNOT_RETURN_NULL
 168 PMC *
 169 Parrot_freeze_strings(PARROT_INTERP, ARGIN(PMC *pmc))
 170 {
 171     ASSERT_ARGS(Parrot_freeze_strings)
 172     PMC * const visitor = Parrot_pmc_new(interp, enum_class_ImageIOStrings);
 173     VTABLE_set_pmc(interp, visitor, pmc);
 174     return VTABLE_get_pmc(interp, visitor);
 175 }
 176
 177
 178 /*
 179
 180 =item C<PMC * Parrot_thaw(PARROT_INTERP, STRING *image)>
 181
 182 Thaws a PMC.  Called from the C<thaw> opcode.
 183
 184 For now it seems cheaper to use a list for remembering contained aggregates. We
 185 could of course decide dynamically, which strategy to use: given a big image,
 186 the first thawed item is a small aggregate. This implies it probably contains
 187 more nested containers, for which another approach could be a win.
 188
 189 =cut
 190
 191 */
 192
 193 PARROT_EXPORT
 194 PARROT_WARN_UNUSED_RESULT
 195 PARROT_CANNOT_RETURN_NULL
 196 PMC *
 197 Parrot_thaw(PARROT_INTERP, ARGIN(STRING *image))
 198 {
 199     ASSERT_ARGS(Parrot_thaw)
 200
 201     PMC        *result;
 202     PMC * const info     = Parrot_pmc_new(interp, enum_class_ImageIO);
 203     int         gc_block = 0;
 204
 205     /*
 206      * if we are thawing a lot of PMCs, it's cheaper to do
 207      * a GC run first and then block GC - the limit should be
 208      * chosen so that no more then one GC run would be triggered
 209      *
 210      * XXX
 211      *
 212      * md5_3.pir shows a segfault during thawing the config hash
 213      * info->thaw_ptr becomes invalid - seems that the hash got
 214      * collected under us.
 215      */
 216     if (1 || (Parrot_str_byte_length(interp, image) > THAW_BLOCK_GC_SIZE)) {
 217         Parrot_block_GC_mark(interp);
 218         Parrot_block_GC_sweep(interp);
 219         gc_block = 1;
 220     }
 221
 222     VTABLE_set_string_native(interp, info, image);
 223     result = VTABLE_get_pmc(interp, info);
 224
 225     if (gc_block) {
 226         Parrot_unblock_GC_mark(interp);
 227         Parrot_unblock_GC_sweep(interp);
 228     }
 229
 230     return result;
 231 }
 232
 233
 234 /*
 235
 236 =item C<PMC* Parrot_thaw_pbc(PARROT_INTERP, PackFile_ConstTable *ct, const
 237 opcode_t **cursor)>
 238
 239 Thaw a pmc frozen by Parrot_freeze_pbc.
 240
 241 =cut
 242
 243 */
 244
 245 PARROT_EXPORT
 246 PARROT_WARN_UNUSED_RESULT
 247 PARROT_CAN_RETURN_NULL
 248 PMC*
 249 Parrot_thaw_pbc(PARROT_INTERP, ARGIN(PackFile_ConstTable *ct), ARGMOD(const opcode_t **cursor))
 250 {
 251     ASSERT_ARGS(Parrot_thaw_pbc)
 252     PackFile * const pf = ct->base.pf;
 253     STRING *image       = PF_fetch_buf(interp, pf, cursor);
 254     PMC *info           = Parrot_pmc_new(interp, enum_class_ImageIO);
 255     VTABLE_set_pointer(interp, info, ct);
 256     VTABLE_set_string_native(interp, info, image);
 257     return VTABLE_get_pmc(interp, info);
 258 }
 259
 260
 261 /*
 262
 263 =item C<PMC* Parrot_thaw_constants(PARROT_INTERP, STRING *image)>
 264
 265 This does nothing different from Parrot_thaw at the moment.
 266
 267 =cut
 268
 269 */
 270
 271 PARROT_EXPORT
 272 PARROT_WARN_UNUSED_RESULT
 273 PARROT_CANNOT_RETURN_NULL
 274 PMC*
 275 Parrot_thaw_constants(PARROT_INTERP, ARGIN(STRING *image))
 276 {
 277     ASSERT_ARGS(Parrot_thaw_constants)
 278     return Parrot_thaw(interp, image);
 279 }
 280
 281
 282 /*
 283
 284 =item C<PMC* Parrot_clone(PARROT_INTERP, PMC *pmc)>
 285
 286 There are for sure shortcuts to clone faster, e.g. always thaw the image
 287 immediately or use a special callback.  For now we just thaw a frozen PMC.
 288
 289 =cut
 290
 291 */
 292
 293 PARROT_EXPORT
 294 PARROT_WARN_UNUSED_RESULT
 295 PARROT_CAN_RETURN_NULL
 296 PMC*
 297 Parrot_clone(PARROT_INTERP, ARGIN(PMC *pmc))
 298 {
 299     ASSERT_ARGS(Parrot_clone)
 300     return VTABLE_clone(interp, pmc);
 301 }
 302
 303
 304 /*
 305
 306 =item C<void Parrot_visit_loop_visit(PARROT_INTERP, PMC *info)>
 307
 308 Iterate a visitor PMC visiting each encountered target PMC.
 309
 310 =cut
 311
 312 */
 313
 314 void
 315 Parrot_visit_loop_visit(PARROT_INTERP, ARGIN(PMC *info))
 316 {
 317     ASSERT_ARGS(Parrot_visit_loop_visit)
 318
 319     PMC * const  todo   = VTABLE_get_iter(interp, info);
 320     const INTVAL action = VTABLE_get_integer(interp, info);
 321     INTVAL       i;
 322
 323     /* can't cache upper limit, visit may append items */
 324     for (i = 0; i < VTABLE_elements(interp, todo); ++i) {
 325         PMC * const current = VTABLE_get_pmc_keyed_int(interp, todo, i);
 326         if (PMC_IS_NULL(current))
 327             Parrot_ex_throw_from_c_args(interp, NULL,
 328                     EXCEPTION_MALFORMED_PACKFILE,
 329                     "NULL current PMC at %d in visit_loop_todo_list - %s",
 330                     (int) i,
 331                     action == VISIT_FREEZE_NORMAL ? "feeze" : "thaw");
 332
 333         PARROT_ASSERT(current->vtable);
 334
 335         if (action == VISIT_FREEZE_NORMAL)
 336             VTABLE_freeze(interp, current, info);
 337         else
 338             VTABLE_thaw(interp, current, info);
 339
 340         VTABLE_visit(interp, current, info);
 341
 342         VISIT_PMC(interp, info, PMC_metadata(current));
 343     }
 344 }
 345
 346
 347 /*
 348
 349 =item C<void Parrot_visit_loop_thawfinish(PARROT_INTERP, PMC *info)>
 350
 351 Iterates a visitor PMC, thawfinishing each encountered target PMC.
 352
 353 =cut
 354
 355 */
 356
 357 void
 358 Parrot_visit_loop_thawfinish(PARROT_INTERP, ARGIN(PMC *info))
 359 {
 360     ASSERT_ARGS(Parrot_visit_loop_thawfinish)
 361
 362     /* call thawfinish for each processed PMC */
 363     /*
 364      * Thaw in reverse order. We have to fully thaw younger PMCs
 365      * before use them in older.
 366      *
 367      * XXX There are no younger or older pmcs in a directed graph
 368      *     that allows cycles. Any code that requires a specific
 369      *      order here is likely broken.
 370      */
 371
 372     PMC * const  todo = VTABLE_get_iter(interp, info);
 373     const INTVAL n    = VTABLE_elements(interp, todo);
 374     int          i;
 375
 376     for (i = n - 1; i >= 0; --i) {
 377         PMC *current = VTABLE_get_pmc_keyed_int(interp, todo, i);
 378         if (!PMC_IS_NULL(current))
 379             VTABLE_thawfinish(interp, current, info);
 380     }
 381 }
 382
 383
 384 /*
 385
 386 =back
 387
 388 =head1 TODO
 389
 390 The seen-hash version for freezing might go away sometime.
 391
 392 =head1 SEE ALSO
 393
 394 Lot of discussion on p6i and F<docs/dev/pmc_freeze.pod>.
 395
 396 =cut
 397
 398 */
 399
 400
 401 /*
 402  * Local variables:
 403  *   c-file-style: "parrot"
 404  * End:
 405  * vim: expandtab shiftwidth=4:
 406  */