LISATek

1. LISATek LISATek pour concevoir des processeurs

2. Plan de la présentation • Caractéristique • Le codage du modèle • Pipeline • Synthèse • Génération de documentation • Modèle déjà existant • Conclusion • Référence LisaTek

3. Caractéristique publicitaire • Environnement de développement intégré pour le design de processeur et la création d'outils de développement de logiciel (tools chains). • Aucune expertise en conception de processeur n’est requise. • Diminue en nombre de mois le temps de conception de processeur. LisaTek

4. Caractéristique publicitaire • Élimine des années de travail pour la création d'outils de développement de programme – même pour des processeurs non crée avec LISATek • Garantie la compatibilité du simulateur d'instruction, des outils de création de programme et du RTL. [C'est dû au fait que tout est dérivé de la même source] LisaTek

5. Caractéristique publicitaire • L'environnement de développement des programmes permet le développement des programmes avant la disponibilité du silicone. LisaTek

6. Vue globale

7. Autres caractéristique • Précis à l'instruction ou au cycle • Débuggeur inclus. • Profileur inclus. • Aide à la conception des instructions, des ressources et du compilateur. • Peut générer l'assembleur, le linker, le HDL (VHDL ou Vérilog) synthétisable (avec certaine restriction), le compilateur C, PSP (Package Support Processor) et la documentation du jet d’instruction. • Langage du modèle semblable au C. LisaTek

8. Le codage du modèle • On définit les Ressources globales RESOURCE{ ...} • On définit les opérations (instructions, opérandes) OPERATION{ ...} • Les opérations main et reset sont nécessaire pour générer le simulateur. LisaTek

9. La section RESOURCE RESOURCE{ BUS char common_bus{ ADDRTYPE(unsigned long); BLOCKSIZE(8,8); }; MEMORY_MAP{ BUS(common_bus), RANGE(0x0000, 0x0fff) -> prog_mem[(31..0)]; BUS(common_bus), RANGE(0x1000, 0x1fff) -> data_mem[(31..0)]; } RAM char prog_mem{ SIZE(0x1000); BLOCKSIZE(8,8); FLAGS(R|X); // Obligatoire par défaut pas X };

10. La section RESOURCE RAM char data_mem{ SIZE(0x1000); BLOCKSIZE(8,8); FLAGS(R|W); }; PROGRAM_COUNTER int PC; REGISTER short R[0..15]; REGISTER unsigned short IR; CONTROL_REGISTER short ST; bit[17] MUL_IN[0..1]; long cycle, instruction_counter; }

11. L’opération main • Est l’opération qui sera activée à chaque cycle. • C’est elle qui doit activer les autres opérations nécessaires. Donc, elle appellera d’autres opérations. LisaTek

12. L’opération main OPERATION main { DECLARE { INSTANCE decode; } BEHAVIOR { char tmp1, tmp2; common_bus.read(PC+1, &tmp1); common_bus.read(PC, &tmp2); IR = (((unsigned char)tmp1) << 8) | ((unsigned char) tmp2); decode(); PC += 2; }} LisaTek

13. L’opération reset • Sers à mettre les ressources du processeur à des valeurs par défaut. • Sers à initialiser le processeur au démarrage. • Sert lors d’une réinitialisions du processeur. • Cette opération contient qu’une partie comportementale (behavior). LisaTek

14. L’opération reset OPERATION reset { BEHAVIOR { for (int i = 0 ; i < 16 ; i++) { R[i] = 0; } IR = 0; ST = 0; MUL_IN[0] = MUL_IN[1] = 0; cycle = instruction_counter = 0; PC = LISA_PROGRAM_COUNTER; } } LisaTek

15. LISA_PROGRAM_COUNTER LISA_PROGRAM_COUNTER est une variable spécifique de LISA qui contient l’adresse de début du programme qui roule sur le processeur. C’est défini à partir du fichier ELF/COFF quand le programme est chargé. LisaTek

16. L’opération decode OPERATION decode { DECLARE { GROUP instruction = { NOP }; } CODING AT (PC) { IR == instruction } SYNTAX { instruction } BEHAVIOR {instruction(); } } LisaTek

17. L’opération NOP OPERATION NOP { CODING { 0b0[16] } SYNTAX { "NOP" }// NOP BEHAVIOR { printf("Nothing to do\n"); } } LisaTek

18. L’opération ADD OPERATION ADD { DECLARE { GROUP src1, src2, dst = { reg16 }; } CODING { 0b0011 dst src1 src2 } SYNTAX { "ADD" ~" " dst "," src1 "," src2 } //ADD R[1],R[2],R[3] BEHAVIOR { dst = src1 + src2; } } LisaTek

19. reg16 OPERATION reg16 { DECLARE { LABEL index; }//LABEL variable local CODING { index=0bx[4] } SYNTAX { "R[" ~index=#U ~"]" } // R[4], index est un caractère EXPRESSION { R[index] } //index est un entier } LisaTek

20. Stockage de données OPERATION STR { DECLARE { GROUP address = { addr8 }; GROUP addr_mode = { direct_addressing || indirect_addressing }; INSTANCE reg16, load_addr; } CODING { 0b101 addr_mode address reg16 } SYNTAX { "STR" ~" " reg16 "," address } BEHAVIOR { load_addr(); char tmp1, tmp2; tmp1 = (reg16 >> 8) & 0x00fff; tmp2 = reg16 & 0x00ff; common_bus.write(AR+1, &tmp1); common_bus.write(AR, &tmp2); } } LisaTek

21. Contrôle de flot de donnée OPERATION load_addr { DECLARE { REFERENCE addr_mode, address; } SWITCH (addr_mode) { CASE direct_addressing: { BEHAVIOR { AR = ((R[0] << 8) | address); } }CASE indirect_addressing: { BEHAVIOR { AR = address; } } } } LisaTek

22. Contrôle de flot de donnée OPERATION addr8 { DECLARE { LABEL addr; REFERENCE addr_mode; INSTANCE reg16;} SWITCH (addr_mode) { CASE direct_addressing: { CODING { addr=0bx[8] } SYNTAX { "@" ~SYMBOL("0x" addr=#X) } EXPRESSION { addr } } CASE indirect_addressing: { CODING { reg16 0bx[4] } SYNTAX { reg16 } EXPRESSION { reg16 } } } } LisaTek

23. Les ressources des pipelines • Ajout de la ressource dans RESOURCE • PIPELINE pipe = { FD; AG; EX }; • Ajout des codes dans le main: • PIPELINE(pipe).execute(); • PIPELINE(pipe).shift(); • Ajout de la section ACTIVATION dans les opérations • ACTIVATION { decode } LisaTek

24. Pipeline opération • PIPELINE(pipe).execute(); • PIPELINE(pipe).shift(); • PIPELINE(pipe).flush(); • PIPELINE(pipe).stall(cycles); //default 0 LisaTek

25. L’opération main d’une pipeline OPERATION main { DECLARE { INSTANCE decode; } BEHAVIOR { char tmp1, tmp2; common_bus.read(PC+1, &tmp1); common_bus.read(PC, &tmp2); IR = (((unsigned char)tmp1) << 8) | ((unsigned char) tmp2); PIPELINE(pipe).execute(); PIPELINE(pipe).shift(); cycle += 1; } ACTIVATION { decode } } LisaTek

26. Les opérations d’une pipeline OPERATION decode IN pipe.FD { DECLARE { GROUP instruction = { insn_memory_access || insn_no_memory_access };} CODING AT (PC) { IR == instruction } SYNTAX { instruction } BEHAVIOR { PC += 2; instruction_counter += 1; } ACTIVATION { instruction } } LisaTek

27. Registre de pipeline LisaTek

28. Registre de pipeline • Évite les conflits de données. • RESOURCE{ … PIPELINE_REGISTER IN pipe { unsigned short instr; short pc; }; … } LisaTek

29. Registre de pipeline • PIPELINE_REGISTER(pipe_ident, stage1 / stage2 ).element • PIPELINE_REGISTER(pipe_ident, stage1 / stage2 ).execute() • PIPELINE_REGISTER(pipe_ident, stage1 / stage2 ).flush() • PIPELINE_REGISTER(pipe_ident, stage1 / stage2 ).shift() • PIPELINE_REGISTER(pipe_ident, stage1 / stage2 ).stall() • PIPELINE_REGISTER(pipe_ident, stage1 / stage2 ).stalled() LisaTek

30. Synthèse • UNIT • Les opérations assignées à une unité doivent être activées par d’autres opérations. • Toutes les opérations dans l’unité doivent être dans le même étage du pipeline. • USES • Les interconnections de/a des ressources qui ne sont pas dans l’étage courant du pipeline doivent être spécifier par le mot clé USES. • Le mot-clé USES n’est pas requis si on active l’analyse comportementale dans la configuration. • Elle est nécessaire seulement si l’opération a une section BEHAVIOR. • REGISTER • Pour agir comme un Flip-Flop utiliser le mot clé TClocked. LisaTek

31. Synthèse • UNIT UNIT Fetch {fetch;}; UNIT AddressGeneration {load_address;}; UNIT LoadStoreBranches {LDL,LDH,LDR,STR,BC,B,BDS;}; UNIT Arithmetic {MUL,ADD, reset_branch_flag;}; • USES BEHAVIOR USES ( READ src1, src2; WRITE dst; ) { dst = src1 + src2; } • REGISTER REGISTER TClocked<short> R[0..15]; LisaTek

32. Synthèse • BEHAVIOR • Une règle importante de LISATek 2.0 pour la génération de HDL est que les appelles de fonction de pipeline comme flushes et stalls doivent être appelé de la section ACTIVATION. Les fonctions de pipeline appelé dans la section BEHAVIOR sont ignoré pour la génération du code HDL. • Comme l’instruction load_addr est assigné a une unité, l’appel dans l’instruction insn_memory_access doit être remplacer par une activation. LisaTek

33. Synthèse • BEHAVIOR OPERATION insn_memory_access IN pipe.AG { // ... BEHAVIOR { // load_addr(); } ACTIVATION { insn, load_addr } }  LisaTek

34. Génération de documentation • Si crée un processeur VLIW il faut utiliser le mots clé INSTRUCTION a la place des opérations qui on dans leur hiérarchie des instructions. S’il n’est pas présent, le simulateur va utiliser la racine. • Permet de documenter les instructions et les opérandes • La section DOCUMENTATION peut être mise dans un IF-THEN-ELSE, SWITCH-CASE ou OPERATION LisaTek

35. Génération de documentation • Format utilisé pour décrire une instruction. • DOCUMENTATION ( “ InstructionName ” ) { commentaire } • Format utilisé pour décrire une opérandes. • DOCUMENTATION { commentaire sur une ligne} LisaTek

36. LisaTek

37. Les modèles déjà existants • Il y a plusieurs modèles déjà fournis, dont tous ceux des tutoriels. • Il y a des processeurs RISC à 4 étages qui sont synthétisables et dont on peut générer le compilateur C • Il y a des VLIW • Il y a une FFT • Il y a des modèles incomplets pour partir un processeur RISC, VLIW ou RISC avec des instructions de tailles différence (8 et 16 bits) LisaTek

38. Conclusion • LISATek semble est un produit qui rend plus facile la création d’un processeur pour quelqu’un qui n’est pas expérimenter. • LISATek simplifie la création d’outils de développement de logiciel. • Un non expert peut créer un processeur. Mais pour avoir une bonne performance en vitesse à la synthèse, je pense qu’il doit bien comprendre le fonctionnement et les implémentations possibles. LisaTek

39. Référence • www.coware.com • LISA 2.0 Language Tutorial : The QSIP Architecture (HTML) • LISA Language Reference Manual • INFINEONSUCCESS.pdf • LISATEKSTMSUCCESSFINAL.PDF LisaTek