/*! Creates a copy of the component message */
gcs_comp_msg_t*
gcs_comp_msg_copy (const gcs_comp_msg_t* comp)
{
size_t size = gcs_comp_msg_size(comp);
gcs_comp_msg_t* ret = gu_malloc (size);
if (ret) memcpy (ret, comp, size);
return ret;
}
static inline dummy_msg_t*
dummy_msg_create (gcs_msg_type_t const type,
size_t const len,
long const sender,
const void* const buf)
{
dummy_msg_t *msg = NULL;
if ((msg = gu_malloc (sizeof(dummy_msg_t) + len)))
{
memcpy (msg->buf, buf, len);
msg->len = len;
msg->type = type;
msg->sender_idx = sender;
}
return msg;
}
/* Creates FIFO object. Since it practically consists of array of (void*),
* the length can be chosen arbitrarily high - to minimize the risk
* of overflow situation.
*/
gcs_fifo_lite_t* gcs_fifo_lite_create (size_t length, size_t item_size)
{
gcs_fifo_lite_t* ret = NULL;
uint64_t l = 1;
/* check limits */
if (length < 1 || item_size < 1)
return NULL;
/* Find real length. It must be power of 2*/
while (l < length) l = l << 1;
if (l * item_size > (uint64_t)GU_LONG_MAX) {
gu_error ("Resulting FIFO size %lld exceeds signed limit: %lld",
(long long)(l*item_size), (long long)GU_LONG_MAX);
return NULL;
}
ret = GU_CALLOC (1, gcs_fifo_lite_t);
if (ret) {
ret->length = l;
ret->item_size = item_size;
ret->mask = ret->length - 1;
ret->closed = true;
ret->queue = gu_malloc (ret->length * item_size);
if (ret->queue) {
gu_mutex_init (&ret->lock, NULL);
gu_cond_init (&ret->put_cond, NULL);
gu_cond_init (&ret->get_cond, NULL);
/* everything else must be initialized to 0 by calloc */
}
else {
gu_free (ret);
ret = NULL;
}
}
return ret;
}
gcs_sm_t*
gcs_sm_create (long len, long n)
{
if ((len < 2 /* 2 is minimum */) || (len & (len - 1))) {
gu_error ("Monitor length parameter is not a power of 2: %ld", len);
return NULL;
}
if (n < 1) {
gu_error ("Invalid monitor concurrency parameter: %ld", n);
return NULL;
}
size_t sm_size = sizeof(gcs_sm_t) +
len * sizeof(((gcs_sm_t*)(0))->wait_q[0]);
gcs_sm_t* sm = static_cast<gcs_sm_t*>(gu_malloc(sm_size));
if (sm) {
sm_init_stats (&sm->stats);
gu_mutex_init (&sm->lock, NULL);
#ifdef GCS_SM_GRAB_RELEASE
gu_cond_init (&sm->cond, NULL);
sm->cond_wait = 0;
#endif /* GCS_SM_GRAB_RELEASE */
sm->wait_q_len = len;
sm->wait_q_mask = sm->wait_q_len - 1;
sm->wait_q_head = 1;
sm->wait_q_tail = 0;
sm->users = 0;
sm->entered = 0;
sm->ret = 0;
#ifdef GCS_SM_CONCURRENCY
sm->cc = n; // concurrency param.
#endif /* GCS_SM_CONCURRENCY */
sm->pause = false;
memset (sm->wait_q, 0, sm->wait_q_len * sizeof(sm->wait_q[0]));
}
return sm;
}
static PgfAbsFun*
pgf_read_absfun(PgfReader* rdr, PgfAbstr* abstr, PgfAbsFun* absfun)
{
size_t len = pgf_read_len(rdr);
PgfExprFun *efun =
gu_new_flex_variant(PGF_EXPR_FUN,
PgfExprFun,
fun, len+1,
&absfun->ep.expr, rdr->opool);
gu_in_bytes(rdr->in, (uint8_t*)efun->fun, len, rdr->err);
efun->fun[len] = 0;
absfun->name = efun->fun;
gu_return_on_exn(rdr->err, NULL);
absfun->type = pgf_read_type_(rdr);
gu_return_on_exn(rdr->err, NULL);
absfun->arity = pgf_read_int(rdr);
uint8_t tag = pgf_read_tag(rdr);
gu_return_on_exn(rdr->err, NULL);
switch (tag) {
case 0:
absfun->defns = NULL;
if (absfun->arity == 0) {
absfun->closure.code = abstr->eval_gates->evaluate_value;
absfun->closure.con = &absfun->closure.code;
} else {
absfun->closure.code = NULL;
}
break;
case 1: {
size_t length = pgf_read_len(rdr);
gu_return_on_exn(rdr->err, NULL);
absfun->defns = gu_new_seq(PgfEquation*, length, rdr->opool);
PgfEquation** data = gu_seq_data(absfun->defns);
for (size_t i = 0; i < length; i++) {
size_t n_patts = pgf_read_len(rdr);
gu_return_on_exn(rdr->err, NULL);
PgfEquation *equ =
gu_malloc(rdr->opool,
sizeof(PgfEquation)+sizeof(PgfPatt)*n_patts);
equ->n_patts = n_patts;
for (size_t j = 0; j < n_patts; j++) {
equ->patts[j] = pgf_read_patt(rdr);
gu_return_on_exn(rdr->err, NULL);
}
equ->body = pgf_read_expr_(rdr);
gu_return_on_exn(rdr->err, NULL);
data[i] = equ;
}
// pgf_jit_function(rdr, abstr, absfun);
break;
}
default:
pgf_read_tag_error(rdr);
break;
}
absfun->ep.prob = - log(pgf_read_double(rdr));
return absfun;
}
