Traduzione automatica di un middleware su ZigBee Andrea Brazzarola vr043510 15 luglio 2008.
11
Traduzione automatica di un middleware su ZigBee Andrea Brazzarola vr043510 15 luglio 2008
-
Upload
assunta-grossi -
Category
Documents
-
view
213 -
download
0
Transcript of Traduzione automatica di un middleware su ZigBee Andrea Brazzarola vr043510 15 luglio 2008.
Traduzione automatica di un
middleware su ZigBee
Andrea Brazzarola
vr043510
15 luglio 2008
Introduzione
Lo sviluppo di una applicazione per reti di sensori
comporta un elevato sforzo di progettazione a causa
delle limitate risorse disponibili e delle forti limitazioni
date dallo standard ZigBee/IEEE 802.15.4
Lo scopo di questo progetto è quello di fornire un tool
per il mapping automatico dell'applicazione SystemC
sullo Z-Stack di Texas Instrument, lasciando allo
sviluppatore libertà di progetto.
Traduzione automatica su
ZigBee
Tre concetti fondamentali:
Conversione dal linguaggio SystemC a C;
Implementazione dei servizi ZigBee OOM;
Modifica dell'applicazione per rispettare le specifiche
dello Z-Stack.
Traduzione automatica su
ZigBee
Creazione della macchina a
stati finiti
Nella slide precedente si può notare che il corpo principale
dell'applicazione ZigBee è dato dalla trasformazione del
codice in una FSM, ciò è stato fatto per evitare il rischio di
deadlock sulle invocazioni remote.
La creazione di una FSM implica la suddivisione del
codice in stati e quindi l'implementazione di un algoritmo
che riconosca nel codice dell'applicazione AME i punti nel
quale creare un nuovo stato.
Creazione della macchina a
stati finiti
Un nuovo stato deve essere creato quando si incontra
un'operazione potenzialmente bloccante, come una
chiamata a servizio o un operazione di register/lookup di
un nodo. Esiste anche il problema che se la chiamata si
trova annidata in un blocco iterativo o condizionale, questi
non possone essere interrotti e poi ripresi. Quindi c'è
bisogno di dividere in stati anche questi blocchi.
Creazione della macchina a
stati finiti
La trasformazione inizia con la visita di ogni funzione e
procedura, per ognuna di queste viene effettuato il parsing
delle sue istruzioni attraverso il metodo parseCode() e nel
caso venga trovata una chiamata bloccante verrà creato
un nuovo stato; Allo stesso modo, se vengono trovati
blocchi iterativi o condizionali verrà creato uno stato ma, in
questo caso, si andrà ad analizzare ricorsivamente il
codice al loro interno utilizzando il metodo parseIf() o il
metodo parseWhile(), mentre i blocchi di istruzioni
sequenziali verranno copiati nello stato corrente.
codeToFsm(){
newState = create_newFSM_state();
parseCode(AMECode->INSTRUCTIONS, newState)
for each(state) addStatement(“return”);
}
parse_Code(instr, newState){
for each (instr) {
if(instr.type == CASE_STATEMENT){
newState = create_new_FSM_state();
parse_if(caseObjects, newState)
}else if(instr.type == WHILE_STATEMENT){
newState = create_new_FSM_state();
parse_while(whileObject, newState)
}else if(instr.type == PCALL_STATEMENT){
newState = create_new_FSM_state();
newState ->AddInstruction_to_FSM_state(instr);
newState ->AddStatement(“step=step+1”);
}else if(instr.type == ASSIGN_STATEMENT){
if(instr.type == FCALL_STATEMENT){
newState = create_new_FSM_state();
newState -> addInstruction_to_FSM_state(instr);
newState -> addStatement(“step=step+1”);
}else newState -> addInstruction_to_FSM_state(instr);
}else newState -> addInstruction_to_FSM_state(instr);
}
}
parse_if(caseObjects, newState){
for each (caseObjects) {
newCaseObject = create_CaseObject();
parseCode(caseObject->INSTRUCTIONS, newCaseObject);
newCaseObject -> setCondition(caseObject->CONDITION)
newCaseObject -> addStatement(“step=step+1”);
newCaseObject -> addStatement(“else{step=counter}”);
newState -> addStatement(newCaseObject);
}
}
parse_while(whileObject, newState){newCaseObject = create_CaseObject();
parseCode(whileObject->INSTRUCTIONS, newCaseObject);
newCaseObject -> setCondition(whileObject->CONDITION)
newCaseObject -> addStatement(“else{step=counter}”);
newState -> addStatement(newCaseObject);
}
create_new_FSM_state(){newState = newState();newState -> addStatement(“if (step==[counter]){}”);counter++;return newState;
}
Creazione della macchina a
stati finiti
Il codice necessario per la costruzione della FSM è situato
nei file: CodeToFsm.cpp e CodeToFsm.h
Esso è stato implementato in modo da poter modificare un
albero HIF ridefinendo il metodo VisitStateObject() di
guideVisitor.
Ecco come viene trasformato un blocco while:
while (COND){ if (step == n){
\\Codice if (COND) {
} \\Codice
}else step++
}
FINE
