void * worker_routine (void *param)
{
worker_param_t *wp = (worker_param_t*) param;
rect_t r;
mascheraSegnaliThread ();
output (OUTPUT_WORKER, maschera_globale, "[W-%d] init\n",wp->wid);
crea_file_con_wid (wp->wid);
output (OUTPUT_WORKER, maschera_globale, "[W-%d] creato il file \"wator_worker_%d\"\n",wp->wid,wp->wid);
do
{
r = try_dequeue ( wp->shared_queue );
output (OUTPUT_WORKER, maschera_globale, "[W-%d] rettangolo ottenuto: %d %d\n",wp->wid, r.i, r.j);
//finché devono ancora essere inseriti rettangoli nella coda...
while ( !bcmp ( &r, &RECT_EMPTY, sizeof(r) ) )
{
//...mi addormento sull'apposita variabile condizione
pthread_cond_wait ( &wp->shared_queue->condVuoto, &wp->shared_queue->mutexq );
pthread_mutex_unlock (&wp->shared_queue->mutexq);
r = try_dequeue ( wp->shared_queue );
output (OUTPUT_WORKER, maschera_globale, "[W-%d] rettangolo ottenuto: %d %d\n",wp->wid, r.i, r.j);
}
if ( bcmp ( &r, &RECT_FINISH, sizeof(r) ) )
{
ottieniRettangoloInMutuaEsclusione (wp->ws, r);
elabora (wp->pw, r);
output (OUTPUT_WORKER, maschera_globale, "[W-%d] elaborato (%d,%d)\n",wp->wid,r.i/wp->ws->dimSottomatrice,r.j/wp->ws->dimSottomatrice);
rilasciaRettangolo (wp->ws,r);
collector_sync_decrement (wp->cs);
}
} while ( bcmp ( &r, &RECT_FINISH, sizeof(r) ) );
output (OUTPUT_WORKER, maschera_globale, "[W-%d] Gently exiting...\n", wp->wid);
return NULL;
}
// Helper function for removing a message from the head of the queue
OsStatus OsMsgQShared::doReceive(OsMsg*& rpMsg, const OsTime& rTimeout)
{
OsStatus ret;
if (!rTimeout.isInfinite())
{
int expireFromNow = rTimeout.cvtToMsecs();
if (try_dequeue(rpMsg, expireFromNow))
ret = OS_SUCCESS;
else
ret = OS_WAIT_TIMEOUT;
}
else
{
dequeue(rpMsg);
ret = OS_SUCCESS;
}
system_tap_queue_dequeue(mName.data(), 0, _queue.size());
return ret;
}
void consumer(struct queue* q) //@: thread_run_joinable
//@ requires thread_run_pre(consumer)(q, ?info);
//@ ensures thread_run_post(consumer)(q, info);
{
//@ open thread_run_pre(consumer)(q, info);
int x;
while(true)
//@ invariant [1/2]queue(q, queue_inv) &*& integer(&x, _);
{
/*@
predicate_family_instance try_dequeue_pre(try_dequeue_lemma)() = true;
predicate_family_instance try_dequeue_post(try_dequeue_lemma)(bool success, int v) = ! success || le(0, v);
lemma void try_dequeue_lemma()
requires try_dequeue_pre(try_dequeue_lemma)() &*& queue_inv(?vs);
ensures try_dequeue_post(try_dequeue_lemma)(vs != nil, ?res) &*& vs != nil ? res == head(vs) &*& queue_inv(tail(vs)) : queue_inv(vs);
{
open try_dequeue_pre(try_dequeue_lemma)();
open queue_inv(vs);
if(vs == nil) {
close queue_inv(nil);
close try_dequeue_post(try_dequeue_lemma)(false, 0);
} else {
switch(vs) { case nil: case cons(h, t): }
close queue_inv(tail(vs));
close try_dequeue_post(try_dequeue_lemma)(true, head(vs));
}
}
@*/
//@ produce_lemma_function_pointer_chunk(try_dequeue_lemma) : queue_try_dequeue(queue_inv)() { call();};
//@ close try_dequeue_pre(try_dequeue_lemma)();
bool dequeued = try_dequeue(q, &x);
//@ open try_dequeue_post(try_dequeue_lemma)(_, _);
if(dequeued) {
assert 0 <= x;
}
}
}
//! Attempts to dequeue a log record ready for processing from the queue, does not block if the queue is empty
bool try_dequeue_ready(record_view& rec)
{
return try_dequeue(rec);
}
