src/pmc/schedulermessage.pmc

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