void sync_sched::do_swrite()
{
readreq_t * pw = (readreq_t*)request->data;
schannel_t *chan = pw->chan;
if(debug_driver)
fprintf(stderr,"[sync: svc_write] Request to write on channel %p\n",chan);
if(chan==NULL)goto svc_write_none;
svc_write_next:
{
fthread_t *reader= chan->pop_reader();
if(reader == 0) goto svc_write_none; // no readers
if(reader->cc == 0) goto svc_write_next; // killed
readreq_t * pr = (readreq_t*)reader->get_svc()->data;
if(debug_driver)
fprintf(stderr,"[sync: svc_write] Writer @%p=%p, read into %p\n",
pw->variable,*(void**)pw->variable, pr->variable);
*(void**)pr->variable = *(void**)pw->variable;
push_new (reader);
return;
}
svc_write_none:
if(debug_driver)
fprintf(stderr,"[sync: svc_write] No readers on channel %p: BLOCKING\n",chan);
chan->push_writer(ft);
forget_current();
return;
}
void sync_sched::do_spawn_detached()
{
fthread_t *ftx = *(fthread_t**)request->data;
if(debug_driver)
fprintf(stderr,"[sync: svc_spawn_detached] Spawn fthread %p\n",ftx);
push_new(ftx);
}
static int __smq_writeback_work(struct smq_policy *mq, dm_oblock_t *oblock,
dm_cblock_t *cblock, bool critical_only)
{
struct entry *e = NULL;
bool target_met = clean_target_met(mq, critical_only);
if (critical_only)
/*
* Always try and keep the bottom level clean.
*/
e = pop_old(mq, &mq->dirty, target_met ? 1u : mq->dirty.nr_levels);
else
e = pop_old(mq, &mq->dirty, mq->dirty.nr_levels);
if (!e)
return -ENODATA;
*oblock = e->oblock;
*cblock = infer_cblock(mq, e);
e->dirty = false;
push_new(mq, e);
return 0;
}
static void insert_in_cache(struct smq_policy *mq, dm_oblock_t oblock,
struct policy_locker *locker,
struct policy_result *result, enum promote_result pr)
{
int r;
struct entry *e;
if (allocator_empty(&mq->cache_alloc)) {
result->op = POLICY_REPLACE;
r = demote_cblock(mq, locker, &result->old_oblock);
if (r) {
result->op = POLICY_MISS;
return;
}
} else
result->op = POLICY_NEW;
e = alloc_entry(&mq->cache_alloc);
BUG_ON(!e);
e->oblock = oblock;
if (pr == PROMOTE_TEMPORARY)
push(mq, e);
else
push_new(mq, e);
result->cblock = infer_cblock(mq, e);
}
static GLboolean push_gen (slang_assembly_file *file, slang_assembly_type type, GLfloat literal,
GLuint label, GLuint size)
{
slang_assembly *assem;
if (!push_new (file))
return GL_FALSE;
assem = &file->code[file->count - 1];
assem->type = type;
assem->literal = literal;
assem->param[0] = label;
assem->param[1] = size;
return GL_TRUE;
}
void sync_sched::external_multi_swrite (schannel_t *chan, void *data)
{
if(chan==NULL) return;
svc_multi_write_next:
fthread_t *reader= chan->pop_reader();
if(reader == 0) return; // no readers left
if(reader->cc == 0) goto svc_multi_write_next; // killed
{
readreq_t * pr = (readreq_t*)reader->get_svc()->data;
if(debug_driver)
fprintf(stderr,"[sync: svc_multi_write] Write data %p, read into %p\n",
data, pr->variable);
*(void**)pr->variable = data;
push_new(reader);
}
goto svc_multi_write_next;
}
GLboolean _slang_assemble_function (slang_assemble_ctx *A, slang_function *fun)
{
GLuint param_size, local_size;
GLuint skip, cleanup;
fun->address = A->file->count;
if (fun->body == NULL)
{
/* jump to the actual function body - we do not know it, so add the instruction
* to fixup table */
fun->fixups.table = (GLuint *) slang_alloc_realloc (fun->fixups.table,
fun->fixups.count * sizeof (GLuint), (fun->fixups.count + 1) * sizeof (GLuint));
if (fun->fixups.table == NULL)
return GL_FALSE;
fun->fixups.table[fun->fixups.count] = fun->address;
fun->fixups.count++;
if (!PUSH (A->file, slang_asm_jump))
return GL_FALSE;
return GL_TRUE;
}
else
{
GLuint i;
/* resolve all fixup table entries and delete it */
for (i = 0; i < fun->fixups.count; i++)
A->file->code[fun->fixups.table[i]].param[0] = fun->address;
slang_fixup_table_free (&fun->fixups);
}
/* At this point traverse function formal parameters and code to calculate
* total memory size to be allocated on the stack.
* During this process the variables will be assigned local addresses to
* reference them in the code.
* No storage optimizations are performed so exclusive scopes are not detected and shared. */
/* calculate return value size */
param_size = 0;
if (fun->header.type.specifier.type != slang_spec_void)
if (!sizeof_variable (A, &fun->header.type.specifier, slang_qual_none, 0, ¶m_size))
return GL_FALSE;
A->local.ret_size = param_size;
/* calculate formal parameter list size */
if (!sizeof_variables (A, fun->parameters, 0, fun->param_count, ¶m_size))
return GL_FALSE;
/* calculate local variables size - take into account the four-byte return address and
* temporaries for various tasks (4 for addr and 16 for swizzle temporaries).
* these include variables from the formal parameter scope and from the code */
A->local.addr_tmp = param_size + 4;
A->local.swizzle_tmp = param_size + 4 + 4;
local_size = param_size + 4 + 4 + 16;
if (!sizeof_variables (A, fun->parameters, fun->param_count, fun->parameters->num_variables,
&local_size))
return GL_FALSE;
if (!collect_locals (A, fun->body, &local_size))
return GL_FALSE;
/* allocate local variable storage */
if (!PLAB (A->file, slang_asm_local_alloc, local_size - param_size - 4))
return GL_FALSE;
/* mark a new frame for function variable storage */
if (!PLAB (A->file, slang_asm_enter, local_size))
return GL_FALSE;
/* jump directly to the actual code */
skip = A->file->count;
if (!push_new (A->file))
return GL_FALSE;
A->file->code[skip].type = slang_asm_jump;
/* all "return" statements will be directed here */
A->flow.function_end = A->file->count;
cleanup = A->file->count;
if (!push_new (A->file))
return GL_FALSE;
A->file->code[cleanup].type = slang_asm_jump;
/* execute the function body */
A->file->code[skip].param[0] = A->file->count;
if (!_slang_assemble_operation (A, fun->body, /*slang_ref_freelance*/slang_ref_forbid))
return GL_FALSE;
/* this is the end of the function - restore the old function frame */
A->file->code[cleanup].param[0] = A->file->count;
if (!PUSH (A->file, slang_asm_leave))
return GL_FALSE;
/* free local variable storage */
if (!PLAB (A->file, slang_asm_local_free, local_size - param_size - 4))
return GL_FALSE;
/* return from the function */
if (!PUSH (A->file, slang_asm_return))
return GL_FALSE;
return GL_TRUE;
}
