// Function to process event list once per frame.
// First advances event times, then processes each event with the appropriate
// handler depending on the type of event.
void Events::handleEvents(long msec) {
long delta_time;
int result;
// Advance event times
processEventTime(msec);
// Process each event in list
for (EventList::iterator eventi = _eventList.begin(); eventi != _eventList.end(); ++eventi) {
Event *event_p = &eventi->front();
// Call the appropriate event handler for the specific event type
switch (event_p->type) {
case kEvTOneshot:
result = handleOneShot(event_p);
break;
case kEvTContinuous:
result = handleContinuous(event_p);
break;
case kEvTInterval:
result = handleInterval(event_p);
break;
case kEvTImmediate:
result = handleImmediate(event_p);
break;
default:
result = kEvStInvalidCode;
warning("Invalid event code encountered");
break;
}
// Process the event appropriately based on result code from
// handler
if ((result == kEvStDelete) || (result == kEvStInvalidCode)) {
// If there is no event chain, delete the base event.
if (eventi->size() < 2) {
eventi = _eventList.reverse_erase(eventi);
} else {
// If there is an event chain present, move the next event
// in the chain up, adjust it by the previous delta time,
// and reprocess the event
delta_time = event_p->time;
eventi->pop_front();
event_p = &eventi->front();
event_p->time += delta_time;
--eventi;
}
} else if (result == kEvStBreak) {
break;
}
}
}
std::vector <PassElement *> *ImmediateSelection::entry (PassElement *pe, Description *desc) const
{
Logging::log (0, "Starting Operand Immediate", NULL);
//Prepare result
std::vector <PassElement *> *res = new std::vector <PassElement *> ();
//Push in the vector our original one
res->push_back (pe);
//Ok, get the original kernel
Kernel *orig = pe->getKernel ();
//If we have work
if (orig != NULL)
{
handleImmediate (res, orig, orig);
}
Logging::log (0, "Stopping Operand Immediate", NULL);
(void) desc;
return res;
}
// Function to process event list once per frame.
// First advances event times, then processes each event with the appropriate
// handler depending on the type of event.
int Events::handleEvents(long msec) {
Event *event_p;
long delta_time;
int result;
// Advance event times
processEventTime(msec);
// Process each event in list
for (EventList::iterator eventi = _eventList.begin(); eventi != _eventList.end(); ++eventi) {
event_p = (Event *)eventi.operator->();
// Call the appropriate event handler for the specific event type
switch (event_p->type) {
case kEvTOneshot:
result = handleOneShot(event_p);
break;
case kEvTContinuous:
result = handleContinuous(event_p);
break;
case kEvTInterval:
result = handleInterval(event_p);
break;
case kEvTImmediate:
result = handleImmediate(event_p);
break;
default:
result = kEvStInvalidCode;
warning("Invalid event code encountered");
break;
}
// Process the event appropriately based on result code from
// handler
if ((result == kEvStDelete) || (result == kEvStInvalidCode)) {
// If there is no event chain, delete the base event.
if (event_p->chain == NULL) {
eventi = _eventList.eraseAndPrev(eventi);
} else {
// If there is an event chain present, move the next event
// in the chain up, adjust it by the previous delta time,
// and reprocess the event
delta_time = event_p->time;
Event *from_chain = event_p->chain;
memcpy(event_p, from_chain, sizeof(*event_p));
free(from_chain);
event_p->time += delta_time;
--eventi;
}
} else if (result == kEvStBreak) {
break;
}
}
return SUCCESS;
}
void ImmediateSelection::handleImmediate (std::vector <PassElement *> *pool, const Kernel *outer, Kernel *kernel, unsigned int start) const
{
//Paranoid
assert (pool != NULL);
//Paranoid
if (kernel == NULL || kernel->getNbrStatements () <= start)
{
return;
}
//How many statements do we have?
unsigned int nbr = kernel->getNbrStatements ();
//For each statement from start to the end
for (unsigned int i = start; i < nbr; i++)
{
//Get instruction
Statement *s_interest = kernel->getModifiableStatement (i);
//Paranoid
assert (s_interest != NULL);
//We only care about instructions
Instruction *interest = dynamic_cast<Instruction *> (s_interest);
if (interest != NULL)
{
//Update the immediate operand depending on the beforeUnroll member
bool test = false;
//Test says if we are interested in it or not
if (beforeUnroll == true)
{
test = (interest->getImmediateAfter () == false);
}
else
{
test = interest->getImmediateAfter ();
}
if (test == true)
{
unsigned int nbOp = interest->getNbrOperands();
for (unsigned int j = 0; j < nbOp; j++)
{
//Get operand
Operand *s_op = interest->getModifiableOperand (j);
//we only care about immediate operand
ImmediateOperand *immediateOp = dynamic_cast<ImmediateOperand *> (s_op);
if (immediateOp != NULL)
{
std::string slink = "";
slink = interest->getLinked ();
//Handle the linked instruction
if (slink != "")
{
const Instruction *linked = findOurLinked (outer, interest->getLinked ());
//Now, we can update the immediate operand
updateImmediateOperand (linked, immediateOp);
}
long value = immediateOp->getValImmediate(),
min = immediateOp->getMinImmediate(),
max = immediateOp->getMaxImmediate();
long progress = immediateOp->getProgressImmediate();
if ((min > max) || (progress <= 0))
{
Logging::log (2, "Error: Wrong parameters from the immediate operand", NULL);
return;
}
//If we have no value, we actually have a range
if (value == -1)
{
//It's min + progress because min is handled later
for (int k = min + progress; k <= max; k += progress)
{
//Ok then we create a new PassElement
//Create a new kernel
Kernel *outer_copy = dynamic_cast<Kernel*> (outer->copy ());
//Paranoid
assert (outer_copy != NULL);
//Now find our Kernel
Kernel *copy = dynamic_cast<Kernel*> (outer_copy->findOrigin (kernel));
//Paranoid
assert (copy != NULL);
//Ok now create the copy of the instruction we care about
Instruction *inst = dynamic_cast<Instruction*> (interest->copy ());
//Paranoid
assert (inst != NULL);
//Update the operand
immediateOp->setValImmediate (k);
//We create a copy of the operand we care about
ImmediateOperand *op = dynamic_cast<ImmediateOperand *> (immediateOp->copy ());
//Choose my value
op->setValImmediate (k);
//Now we update the operand of the instruction
inst->setOperand (j, op);
//Replace instruction with my new instruction
copy->replaceStatement (inst, i);
//Finally create the new PassElement
PassElement *newElement = new PassElement ();
newElement->setKernel (outer_copy);
//Add to newElements
pool->push_back (newElement);
//Now we call the handleImmediate with a new start index
handleImmediate (pool, outer_copy, outer_copy);
}
//Min is the first immediate value, we said we'd handle it ;-)
immediateOp->setValImmediate (min);
}
}
}
}
}
else
{
//If it's a kernel we have to start over
Kernel *inner = dynamic_cast<Kernel *> (s_interest);
if (inner != NULL)
{
//Actually, just update what we're doing
handleImmediate (pool, outer, inner);
}
}
}
}
