src/pmc/schedulermessage.pmc

   1 /*
   2 Copyright (C) 2001-2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/schedulermessage.pmc - The concurrency scheduler
   8
   9 =head1 DESCRIPTION
  10
  11 Implements a message passed between concurrency schedulers.
  12
  13 =head2 Vtable Functions
  14
  15 =over 4
  16
  17 =cut
  18
  19 */
  20
  21 #include "parrot/scheduler_private.h"
  22
  23 /* HEADERIZER HFILE: none */
  24 /* HEADERIZER BEGIN: static */
  25 /* HEADERIZER END: static */
  26
  27 pmclass SchedulerMessage auto_attrs {
  28     ATTR INTVAL  id;        /* The message's ID. */
  29     ATTR STRING *type;      /* The message's type. */
  30     ATTR PMC    *data;      /* Additional data for the message. */
  31
  32 /*
  33
  34 =item C<void init()>
  35
  36 Initialize a concurrency scheduler message object.
  37
  38 =cut
  39
  40 */
  41
  42     VTABLE void init() {
  43         Parrot_SchedulerMessage_attributes * const core_struct
  44             = (Parrot_SchedulerMessage_attributes *) PMC_data(SELF);
  45
  46         /* Set flags for custom GC mark. */
  47         PObj_custom_mark_SET(SELF);
  48
  49         /* Set up the core struct. */
  50         core_struct->id          = 0;
  51         core_struct->type        = CONST_STRING(INTERP, "");
  52         core_struct->data        = PMCNULL;
  53     }
  54
  55 /*
  56
  57 =item C<void init_pmc(PMC *data)>
  58
  59 Initializes a new SchedulerMessage with a C<Hash> PMC with any or all of the
  60 keys:
  61
  62 =over 4
  63
  64 =item C<id>
  65
  66 An C<Integer> representing the unique identifier for this scheduler message.
  67
  68 =item C<type>
  69
  70 A C<String> representing the unique type for this scheduler message.
  71
  72 =item C<data>
  73
  74 An C<PMC> representing the data passed in this scheduler message.
  75
  76 =back
  77
  78 =cut
  79
  80 */
  81
  82     VTABLE void init_pmc(PMC *data) {
  83         PMC                     *elem;
  84         Parrot_SchedulerMessage_attributes *core_struct;
  85
  86         if (! VTABLE_isa(INTERP, data, CONST_STRING(INTERP, "Hash")))
  87             Parrot_ex_throw_from_c_args(INTERP, NULL, EXCEPTION_INVALID_OPERATION,
  88                 "message initializer must be a Hash");
  89
  90         SELF.init();
  91         core_struct = PARROT_SCHEDULERMESSAGE(SELF);
  92
  93         elem = VTABLE_get_pmc_keyed_str(INTERP, data, CONST_STRING(INTERP, "id"));
  94         if (! PMC_IS_NULL(elem))
  95             core_struct->id = VTABLE_get_integer(INTERP, elem);
  96
  97         elem = VTABLE_get_pmc_keyed_str(INTERP, data, CONST_STRING(INTERP, "type"));
  98         if (! PMC_IS_NULL(elem))
  99             core_struct->type = VTABLE_get_string(INTERP, elem);
 100
 101         elem = VTABLE_get_pmc_keyed_str(INTERP, data, CONST_STRING(INTERP, "data"));
 102         if (! PMC_IS_NULL(elem))
 103             core_struct->data = elem;
 104     }
 105
 106 /*
 107
 108 =item C<INTVAL get_integer()>
 109
 110 Retrieve the message ID.
 111
 112 =cut
 113
 114 */
 115
 116     VTABLE INTVAL get_integer() {
 117         const Parrot_SchedulerMessage_attributes * const
 118             core_struct = PARROT_SCHEDULERMESSAGE(SELF);
 119         UNUSED(INTERP);
 120
 121         return core_struct->id;
 122     }
 123
 124 /*
 125
 126 =item C<void set_integer_native(INTVAL value)>
 127
 128 Set the message ID.
 129
 130 =cut
 131
 132 */
 133
 134     VTABLE void set_integer_native(INTVAL value) {
 135         Parrot_SchedulerMessage_attributes * const core_struct = PARROT_SCHEDULERMESSAGE(SELF);
 136         UNUSED(INTERP);
 137         core_struct->id = value;
 138     }
 139
 140
 141 /*
 142
 143 =item C<STRING * get_string()>
 144
 145 Retrieve the message type.
 146
 147 =cut
 148
 149 */
 150
 151     STRING *  get_string() {
 152         const Parrot_SchedulerMessage_attributes * const core_struct =
 153             PARROT_SCHEDULERMESSAGE(SELF);
 154         UNUSED(INTERP);
 155         return core_struct->type;
 156     }
 157
 158 /*
 159
 160 =item C<void set_string_native(STRING *value)>
 161
 162 Set the message type.
 163
 164 =cut
 165
 166 */
 167
 168     VTABLE void set_string_native(STRING *value) {
 169         Parrot_SchedulerMessage_attributes * const core_struct = PARROT_SCHEDULERMESSAGE(SELF);
 170         UNUSED(INTERP);
 171         core_struct->type = value;
 172     }
 173
 174
 175 /*
 176
 177 =item C<PMC *share_ro()>
 178
 179 Set this PMC as shared.
 180
 181 =cut
 182
 183 */
 184
 185     VTABLE PMC *share_ro() {
 186         PMC *shared_self;
 187         Parrot_SchedulerMessage_attributes *shared_struct;
 188
 189         if (PObj_is_PMC_shared_TEST(SELF))
 190             return SELF;
 191
 192         shared_self         = pt_shared_fixup(INTERP, SELF);
 193         shared_struct       = PARROT_SCHEDULERMESSAGE(shared_self);
 194         shared_struct->data = pt_shared_fixup(INTERP, shared_struct->data);
 195
 196         return shared_self;
 197     }
 198
 199 /*
 200
 201 =item C<void mark()>
 202
 203 Mark any referenced strings and PMCs.
 204
 205 =cut
 206
 207 */
 208     VTABLE void mark() {
 209         if (PARROT_SCHEDULERMESSAGE(SELF)) {
 210             Parrot_SchedulerMessage_attributes * const core_struct =
 211                 PARROT_SCHEDULERMESSAGE(SELF);
 212
 213             Parrot_gc_mark_STRING_alive(INTERP, core_struct->type);
 214             Parrot_gc_mark_PMC_alive(INTERP, core_struct->data);
 215         }
 216     }
 217
 218 /*
 219
 220 =item C<void visit(PMC *info)>
 221
 222 This is used by freeze/thaw to visit the contents of the scheduler message.
 223
 224 C<*info> is the visit info, (see F<include/parrot/pmc_freeze.h>).
 225
 226 =cut
 227
 228 */
 229
 230     VTABLE void visit(PMC *info) {
 231         /* visit message data */
 232         VISIT_PMC(INTERP, info, PARROT_SCHEDULERMESSAGE(SELF)->data);
 233     }
 234
 235 /*
 236
 237 =item C<void freeze(PMC *info)>
 238
 239 Used to archive the scheduler message.
 240
 241 =cut
 242
 243 */
 244
 245     VTABLE void freeze(PMC *info) {
 246         Parrot_SchedulerMessage_attributes * const core_struct =
 247             PARROT_SCHEDULERMESSAGE(SELF);
 248
 249         /* 1) freeze message id */
 250         VTABLE_push_integer(INTERP, info, core_struct->id);
 251
 252         /* 2) freeze message type */
 253         VTABLE_push_string(INTERP, info, core_struct->type);
 254     }
 255
 256 /*
 257
 258 =item C<void thaw(PMC *info)>
 259
 260 Used to unarchive the scheduler message.
 261
 262 =cut
 263
 264 */
 265
 266     VTABLE void thaw(PMC *info) {
 267         /* 1. thaw message id */
 268         const INTVAL id = VTABLE_shift_integer(INTERP, info);
 269
 270         /* 2. thaw message type */
 271         STRING * const type = VTABLE_shift_string(INTERP, info);
 272
 273         /* Allocate the message's core data struct and set custom flags. */
 274         SELF.init();
 275
 276         /* Set the message's id to the frozen id */
 277         PARROT_SCHEDULERMESSAGE(SELF)->id = id;
 278
 279         /* Set the message's type to the frozen type */
 280         PARROT_SCHEDULERMESSAGE(SELF)->type = type;
 281     }
 282
 283 }
 284
 285 /*
 286
 287 =back
 288
 289 =head1 SEE ALSO
 290
 291 F<docs/pdds/pdd25_concurrency.pod>.
 292
 293 =cut
 294
 295 */
 296
 297 /*
 298  * Local variables:
 299  *   c-file-style: "parrot"
 300  * End:
 301  * vim: expandtab shiftwidth=4:
 302  */