******************************************************************** ******** INSTRUCTION ********** ******** Utlilisable dans les processeurs et dans ********** ******** certaines partie du noyau de ZOOM (ZOOM KER) ********** ******************************************************************** ************************** USERS MANUAL ************************** ******************************************************************** remises a jour 14/08/1998, 15/02/2000(Al1) ******************************************************************** ********************** L'IMPRESSION FACILE ********************* ******************************************************************** ==> Z_Pr : Var_List; Z_Pr : var1,var2,(var3(i),i=1,n); génère print *,'** var1,var2,(var3(i),i=1,n)' print *,var1,var2,(var3(i),i=1,n) ==> Z2_Pr : Var_List; Z2_Pr : a,b,j,(a(i),i=1,4); génère print *,' a =',a,' b =',b,' j =',j,' (a(i),i=1,4) =',(a(i),i=1,4) *** attention pour les boucles Fortran implicites : Z2_PR : (d(i),i=1,2),a,b,c; ne marche pas, erreur de compil. Z2_PR : a,b,c,(d(i),i=1,2); marche. Futura: Z_Pad : idem, les memes avec sorties console; Z_Pr_Error_Cl(LCL/TR):'BlaBla',varlist; donee la blabla precede de **PROCERROR, et ajoute le CL/TR ID si /not,ZPRINT(LCL/TR) (le premier element de la liste DOIT etre un char string). symboles utiles : SV_CL_ID(LSV) genere "MESH- 1/Face- 2" en print* ou dans Z_Pr; ex : Z_Pr/Matrix D on Cl:/:SV_CL_ID(LSV); (Futura) ******************************************************************** ******************** PREMISSES D'UN P.D.L. ********************* ******************* Processor Design Language ******************** ******************************************************************** ******* Langages dédié à l'écriture des processeurs ******** ************************** USERS MANUAL ************************** ******************************************************************** VERIFICATION EFFECTUEES PAR LES INSTRUCTIONS ============================================ On verifie systematiquement que les banks instancies qui sont en argument des instructions sont bien de la classe voulue (permet de diagnostiquer des inversions d'argument ou autre). On controle les indices lors des acces aux vecteurs et aux matrices, sauf si l'utilisateur precise 'inhibit check array;' au debut de son processeur. META LANGAGE ============ Soit: Vct : Nom d'un vecteur (ETA,GAMMA,FI,OMEGA,FIZ) Mx : Nom de matrice (ABt, Ct, D) Alors la numerotation des composantes des matrices et de vecteurs suit la logique suivante : Vct : Numerotation "naturelle". Vct_SV : Numerotation dans le CPLUG Vct_TV : Numerotation dans le TPLUG Mx_SV : Un des indices correspond a une numerotation "naturelle", l'autre a une numerotation dans le CPLUG Mx_TV : Un des indices correspond a une numerotation "naturelle", l'autre a une numerotation dans le TPLUG Les arguments associes au GRASP de ces vecteurs et matrices suit egalement cette logique : LTR : Numerotation "naturelle" pour le transfert LCL : Numerotation "naturelle" pour la cellule LTV (ou LTV2) : Numerotation dans le TPLUG LSV : Numerotation dans le CPLUG Par exemple , GRASP ARRAY MX_SV(LSV,LTR) for ... ^ ^ | |--- 2 eme indice (numero de ligne) dans l'ordre | naturel du transfert |---- 1 er indice (numero de colonne) dans l'ordre du CPLUG ============================================== INSTRUCTIONS POUR LES PROCESSSEURS DE CELLULES ============================================== 1) Instructions attachees a la cellule elle même ------------------------------------------------ arguments communs a ces instructions: ------------------------------------- LCL : bank instancié attaché a la cellule a) IMPRESSIONS: --------------- ===> Print_CL_ID(LCL); Imprime les informations judicieuses suivantes concernant la cellule : **FROM: RND1, CL: PARO- 1 OF CLASS: CND1 | | | | Nom de la routine Nom et Numero Nom du Proceseur d'ou est effectuée de la cellule de cellule l'impression ===> Print_Class_CL(LCL); Imprime le nom du proceeseur de cellule. Exemple : CLASS: CND1 ===> Pour des impressions personnalisées CL_ID(LCL) est remplacé par une chaine de 4 caracteres suivi d'un entier, correspondants au Nom et Numéro de la cellule exemple : print *,'user define print ',CL_ID(LCL); donne user define print PARO 1 b) Accès aux variables reservées --------------------------------- ===> grasp array eta,gamma (LCL); Cette instruction (en général au début des points d'entrées C... et R...) permet ensuite d'accéder directement au vecteur ETA des variables d'état et au vecteur GAMMA. Variables FORTRAN réservées utiles : LO_ETA, LO_GAMMA : adresses des banks ETA et GAMMA ===> Set_signed_ABt(LCL); Cette instruction precise a la navette ZOOM que la cellule gere elle-meme la convention de signe des transferts. Les signes de ABt ne sont pas modifie par la navette. ------------------------------------------- 2 ) Instructions attachées à une connexion ------------------------------------------- arguments communs à ces instructions: ------------------------------------- LCX : bank instancie attaché à cette connexion LCL : bank instancie attaché à la cellule LTV : bank instancie attaché au T-Plug du transfert connecté Ces instructions se situent naturellement dans l'environement suivant : from CL(LCL) < skip thru SV(LSV) < skip thru CX(LCX) < From TV(LTV); .... Print_TV_TR_ID(LTV); grasp array FI_TV (LTV); grasp array ABt_TV (LCL,LTV) for (LCX); ... > > > a) IMPRESSIONS: --------------- ===> Print_TV_TR_ID(LTV); Imprime de l'information permettant de reconnaître le transfert connecté. Exemple : ** CONNECTED-TR OF CLASS: TGENE1 (1ST CONNECTED CELL: CAPA- 1) | | | Nom du processeur Nom et numero de la premiere de transfert cellule connectée a ce transfert b) Accès aux variables reservées --------------------------------- ===> grasp array FI_TV (LTV); Cette instruction permet d'accéder aux variables de transfert connectées au T-Plug (LTV), dans la numérotation du T-Plug : ..... = FI_TV(ITV) avec ITV : numéro d'ordre dans le T-Plug de la variable de transfert L'écriture dans FI_TV est interdite. ===> grasp array ABt_TV (LCL,LTV) for (LCX); Cette instruction permet d'accéder à la partie de la matrice ABt rattachée à un T-Plug de la façon suivante: ABt_TV( ICL, ITV) = ... ; avec ICL : numéro de la composante de la variables de cellule ITV : numéro d'ordre dans le T-Plug de la variable de transfert 3) création d'une cellule (IEntry) ------------------------------------ ===> Zinit_Entry {Proc_Name} ( Types(2) = ..., Nb_St_Var = .... ); " { } voulant dire optionel " avec Proc_name : nom du processeur (optionel). La présence de ce nom peut améliorer la visibilité. On vérifie que ce nom est bien celui du processeur. * Ce que ca fait: - Création du point d'entrée I - Création bank CL(LCL), avec le nom du processeur CALL OCLN(NAME,(LCL).Types(1)); - Pour tout ce qui est entre parenthèses ( Types(2) = ..., Nb_St_Var = .... ); ca génère : (LCL).Types(2) = ...; (LCL).Nb_St_Var = .... ; - Cree le bank ETA et le link a LCL - Nom de variable réservé : LCL : adresse du bank CL LETA : adresse du bank ET * Ce que ca ne fait pas : toucher au CD Bank. L'utilisateur doit typiquement faire quelque chose du genre : Lift LCD of class CD under (2,0); "Link CDesc" @LCL@CL@CD@=LCD; * Création avec argument(s) <=> Create Cell, type = XXX arg1, arg2, arg3 (nbre optionnel) on retrouve ces arguments dans les FTN var JZSIG, KZSIG(1), KZSIG(2) 4) Parameter_Entry (PEntry) ---------------------------- ===> Parameter_Entry ; Doit être tout seul, tout à la fin des processeur, en dehors de tous blocks (en particulier de from CL(LCL)< ), juste avant le END: ============================================== INSTRUCTIONS POUR LES PROCESSEURS DE TRANSFERT ============================================== 1 ) Instructions attachées au transfert lui même ------------------------------------------------ arguments communs a ces instructions: ------------------------------------- LTR : bank instancié attaché au transfert a) IMPRESSIONS: --------------- ===> Print_TR_ID(LTR); Imprime de l'information permettant de reconnaître le transfert exemple : **FROM: SCD1 ,TR OF CLASS: TCD1 (1ST CONNECTED CELL: CAPA- 1) | | | | Nom de la routine Nom du processeur Nom et numéro de la première d'ou est effectuée de transfert cellule connectée a ce transfert l'impression ===> Print_Class_TR(LTR); Imprime le nom du proceeseur de transfert. Exemple : CLASS: TCD1 b) Accès aux variables reservées --------------------------------- ===> grasp array fi,omega (LTR); Cette instruction (en général au début des points d'entrées T... et S...) permet ensuite d'accéder directement au vecteur FI des variables de transfert et au vecteur OMEGA. Variables FORTRAN réservées utiles : LO_FI, LO_OMEGA : adresses des banks FI et OMEGA ------------------------------------------- 2 ) Instructions attachees a une connexion ------------------------------------------- arguments communs a ces instructions: ------------------------------------- LCX : bank instancié attaché à cette connexion LSV : bank instancié attaché au C-Plug de la cellule connectée LTR : bank instancié attaché au transfert Ces instructions se situent naturellement dans l'environnement suivant : from TR(LTR) < skip thru TV(LTV) < NCX= ...; read thru CX(LCX) (J=1,NCX) < get SV(LSV); Print_SV_CL_ID(LSV); .... grasp array ETA_SV (LSV); ... grasp array Ct_SV (LSV,LTR) for (LCX); ... > > > a) IMPRESSIONS: --------------- ===> Print_SV_CL_ID(LSV); Imprime de l'information permettant de reconnaître la cellule connectée. Exemple : ** CONNECTED-CL: CAPA- 1 OF CLASS: CND1 = TYPE: 10104 | | | | Nom et Numero Nom du Proceseur Types(2) de la cellule de cellule b) Accès aux variables reservées --------------------------------- ===> grasp array ETA_SV (LSV); Cette instruction permet d'accéder aux variables d'état connectées au C-Plug (LSV), dans la numérotation du C-Plug : ..... = ETA_SV(ISV) avec ISV : numéro d'ordre dans le C-Plug de la variable d'état L'ecriture dans ETA_SV est interdite. Variables FORTRAN réservées utiles : LO_CL_SV, LO_ETA_SV : adresses des banks CL et ETA ==> grasp array Ct_SV (LSV,LTR) for (LCX); Cette instruction permet d'accéder à la partie de la matrice Ct rattachée à un C-Plug de la façon suivante: Ct_SV( ISV, ITR) = ... ; avec ISV : numéro d'ordre dans le C-Plug de la variable d'état ITR : numéro de la composante de la variables de transfert Variables FORTRAN reservees utiles : LO_CT : adresses du bank CT 3) création d'un transfer (yEntry) ------------------------------------ ===> Zinit_Entry {Proc_name} " { } voulant dire optionel " ( Types(2) = ..., Nb_Tr_Var = ..., Nb_Extr = ..., Nb_Fluxes = .... ); avec Proc_name : nom du processeur (optionnel). La présence de ce nom peut améliorer la visibilité. On vérifie que ce nom est bien celui du processeur. * Ce que ca fait: - Création du point d'entrée Y - Création bank TR(LTR), avec le nom du processeur (CALL OTRN(...,(LTR).Types(1)); - Pour tout ce qui est entre parenthese ( Types(2) = ..., Nb_Fluxes = .... ); ca genere : (LTR).Types(2) = ...; (LTR).Nb_Fluxes = ....; - Cre le bank Fi et le link a LTR - Nom de variable reserve : LTR : adresse du bank TR LFIZ : adresse du bank FI ( LFI ne serait pas mieux !!!????....) * Ce que ca ne fait pas : toucher au TD Bank. L'utilisateur doit typiquement faire quelque chose du genre : Lift LTD of class TD under (2,0); "Link TDesc" @LTR@TR@TD@=LTD; * Création avec argument(s) <=> Create TR, type = XXX arg1, arg2, arg3 (nbre optionnel) on retrouve ces arguments dans les FTN var JZTAU, KZTAU(1), KZTAU(2) 4) Parameter_Entry (QEntry) ---------------------------- ===> Parameter_Entry ; Doit être tout seul, tout à la fin des processeurs, en dehors de tout block (en particulier de from TR(LTR)< ), juste avant le END: 5 ) Instructions utilisees pour les matrices D ---------------------------------------------- arguments communs a ces instructions: ------------------------------------- LTR : bank instancié attaché au "transfert origine" LTV2 : bank instancié attaché au T-Plug du "transfert connecte" LCX2 : bank instancié attaché à la connexion Cellule - "Transfert connecte" LCX : bank instancié attaché à la connexion "Transfert origine" - Cellule LCL : bank instancié attaché à la cellule par laquelle passe la connexion entre ces deux transferts Chaine de la connexion : LTR -- LTV -- LCX -- LCL -- LCX2 -- LTV2 ^ ^ ^ | | |--- "Connected Transfer" | |--- "Connecting Cell" |--- "Origin Transfer" Ces instructions se situent naturellement dans l'environnement suivant : from TR(LTR) "Transfert origine" < skip thru TV(LTV) < NCX=(LTV).Nb_Cx_CX; read thru CX(LCX) (J=1,NCX) < ! Matrice D from CL(LCL) "ce FROM est indispensable; un GET ne suffit pas" "Cellule connectee" < skip thru CX(LCX2) < get TV(LTV2); "Transfert connecte" if ( (LTV2).Nb_Tr_Var.eq.0 ) to next LCX2; grasp array FIZ_TV (LTV2); ... = .... *FIZ_TV(..) ...; grasp array D_TV (LTV2,LTR) for (LCX2,LCL,LCX); D_TV(1,1) = ....; D_TV(.. , ..) = ....; > > ! Fin matrice D > > > a) IMPRESSIONS: --------------- ===> Print_TV_TR_ID(LTV2); b) Accès aux variables reservées --------------------------------- ===> grasp array D_TV (LTV2,LTR) for (LCX2,LCL,LCX); Cette instruction effectue les opérations suivante : = Si le bank associé à la matrice D n'existe pas, elle le crée et elle positionne le mot d'état de la cellule précisant que celle-ci possède une matrice D (call sbit1( ...) ) = Si la matrice D a été compactée, elle la decompacte = Elle permet d'accéder à la partie de la matrice D rattachée à un Transfert connecté au Transfert via une cellule connectante la façon suivante: D_TV( ITV, ITR) = ... ; avec ITV : numéro d'ordre dans le T-Plug de la variable du transfert connecté ITR : numéro de la composante de la variables du transfert origine Variables FORTRAN réservées utiles : LO_D_TV : adresses du bank D LO_TR2_D, LO_IC2_D : adresses du "Connected Transfer" et du IC associé à la connexion celulle - transfert connecte LO_IC_D : adresse du IC associée à la connexion transfert origine - celulle ===> grasp array FIZ_TV (LTV2); ===> grasp array OMEGA_TV(LTV2); Accès direct au vecteur Fiz et Omega du transfert connecté dans la numérotation du T-Plug. L'écriture dans FIZ_TV est interdite. ===> copy array fi in fiz (LTR); Copie le vecteur FI dans FIZ. Cette instruction définit un tableau FIZ. Si un grasp array FI... n'a pas été fait, on le génère. Variables FORTRAN réservées utiles : LO_FIZ : adresses du bank FIZ ===> copy array FIZ in FI (LTR); ===> grasp array FIZ (LTR); 1 ******************************************************************** ************************* A. L. L. I. S. ************************* ******* (ADA Like Language Implementation Specification) ******** ******************************************************************** ************************** USERS MANUAL ************************** ******************************************************************** ===== PROCEDURE ================== Appel d'une procedure : ===> execute Procedure_name; Déclaration de la procédure (à la fin,en dehors du "zero-level FROM bloc") ===> procedure Procedure_Name < ..... ..... > A l'intérieur de la procédure, on peut sortir à l'aide de l'instruction : ===> RETURN_FROM_PROCEDURE ; .execute sera remplacé par un GOTO Fortran pointant sur l'instruction de déclaration de la procédure STEADY. Ainsi, la procédure se trouve située en dehors de tout Bank bloc<>, et donc, toutes les variables d'adresse devront être calculées avant l'execute. from,read thru, skip thru et get sont interdites. ***** DIAGNOSTICS ET ERREURS : Toute tentative d' utiliser les instructions ZBM de chaînage provoque le message d' erreur: '** ALLIS ERROR ** ZBM INSTRUCTION FORBIDDEN IN NON AT-PROCEDURE' Voire egalement ***** DIAGNOSTICS ET ERREURS communs aux PROCEDURE et aux AT-PROCEDURE ===== AT- PROCEDURE ===================== Appel de la procédure ===> at LBank execute Procedure_Name; Déclaration de la procédure (à la fin,en dehors du "zero-level FROM bloc") ===> procedure Procedure_Name at LBank_Loc < from Cl_Bk(LBank_Loc) < ..... ..... > > De l'intérieur de la procédure on peut sortir à l'aide de l'instruction : ===> RETURN_FROM_PROCEDURE ; AT-PROCEDURE : Procédure permettant de définir (en son fort intérieur) une première origine des chaînages de bank, et donc d'accéder ensuite à d'autre bank via des GET, DES FROM .... ***** DIAGNOSTICS ET ERREURS : Une at-procedure exige de déclarer un from <> bloc qui sera 0-level.L' adresse de l' origine est purement symbolique et sera remplacée par une variable locale (cf l'instruction ALLIS: LOCAL_VARIABLE), sans qu' il soit nécessaire de la déclarer LOCALE. L absence de from<> déclenche un message d' erreur : '** ALLIS ERROR ** AT-PROC SHOULD CONTAIN A 0-LEVEL FROM< ' ***** DIAGNOSTICS ET ERREURS communs aux PROCEDURE et aux AT-PROCEDURE : La demande d'execution d'une procédure ou d'une at-procédure non définie provoque un message d' erreur : '** ALLIS ERROR ** PROCEDURE XXXXX IS UNDEFINED' La définition d'une procédure sans demande d'exécution associée génère le message: '** ALLIS WARNING ** PROCEDURE XXXXX IS UNUSED' Une at-procédure, comme une procédure, doit être déclarée entre le >; zero-level from et la carte END; . DECLARATION DE VARIABLES LOCALES ================================ LOCAL_VARIABLES: (R_DROIT,ATTENDS-TOI,I_ES-TU?) ; . Remplace dans le texte subsequent ces trois variables par un nom unique reprenant la meme initiale ( pour type implicite FORTRAN), comme par exemple: R_DROIT --> R10016 ATTENDS-TOI --> A10017 I_ES-TU? --> I10018 . (La déclaration se fait n' importe où, et la substitution reste valide jusqu'à la carte END;) ===== CASE ================= Ensemble d'instructions pour émuler le ADA CASE instruction: ------------------------------------------------------------ TYPE mach_in OF (truc_1,truc_2,truc_3); . Instruction de declaration, declaree avant toute instruction FORTRAN executable. ... mach_in := truc_3; . Instanciation de la variable mach_in (il va sans dire que le signe = va aussi). ... CASE mach_in IS < WHEN truc_1 <... > WHEN truc_3 < execute ... ; > WHEN_OTHERS < print*' error' > > . Permet de manipuler la variable symbolique mach_in en lui donnant des valeurs symboliques truc_1 etc . . Analogue à l' instruction IF..ELSEIF..ELSEIF..ENDIF; . WHEN_OTHERS termine obligatoirement le CASE ... IS bloc. . Pour les inconditionnels du FORTRAN, elles sont remplacées par I10011 et incrémentées dans l' ordre de la liste: et donc truc_3=truc_2 +1=truc_1 +2 (ne pas en abuser). . De même, : truc_1=mach_in +1 ... 1 ******************************************************************** ***************** DECLARATION LOCALE D'UN BANK ***************** ******************************************************************** ******* Utilisé en particulier pour déclarer les banks ******* ******* TD et CD des processeurs de Transfert et de Cellule ******* ******************************************************************** ************************** USERS MANUAL ************************** ******************************************************************** La déclaration locale d'un BANK permet d'accéder à celui-ci comme si il avait été déclaré dans le précompilateur: - Après avoir fait un GET ou un FROM du bank, on accède à une variable du bank par (LBank).Var_Name. - Si des liens ont été définis, on y accède de façon habituelle (@L..@..@..@). - Pour créer le bank on utilise l'instruction LIFT ... Avant la déclaration du bank, l'instruction IMPLICIT ACCES TO BANK bk_name(LBk) permet ensuite à l'utilisateur, après avoir instancié l'adresse LBk, d'accéder directement à une variable sans préciser le bank auquel elle appartient, c.a.d. d'ecrire Var_Name au lieu de (LBank).Var_Name Plusieurs banks peuvent être définis simultanément. Après la déclaration d'une (ou d'une suite de) variable ou de liens, il faut donc préciser la classe auquelle elle appartient. (VAR .... IN CLASS Bk_name; ) On distingue dans la déclaration 3 type de variables: - LOCAL_VAR : ces variables sont directement rangées dans la zone données du bank - LINK_VAR : seule l'adresse de ces variables sont rangées dans ce bank; les valeurs elles memes sont rangées dans un autre bank. - VAR : Vu de l'utilisateur, équivalent actuellement à LOCAL_VAR qu'il vaut mieux préférer pour'heure. (En fait VAR est oriente PDL, who is not yet implemented) Chaque variable peut avoir 0, 1 ou 2 dimensions. La dimension d'une variable peut être composée de nombres entiers, de paramètres FORTRAN ou d'autre variables (placées entre crochets) de ce MEME bank. La dimension d'une variable ne peut en aucun cas contenir une variable FORTRAN. Par défaut le type d'une variable (entier ou réel) suit l'incontournable règle du FORTRAN (entier de I a N, réel autrement). Mais le type peut être imposé lors de la déclaration de la variable ( ... : INTEGER, ... :REAL, ... :CHARACTER_4) Le rangement des variables dans la bank suit l'ordre de leur déclaration. Lorsqu'une variable est dimensionnée, on peut la sous-structurer en sous-tableaux avec l'instruction ARRAY Ar_Name_1 IN ARRAY Ar_Name_2 Contrôle d'indices des variables dimensionnées : Actuellement, quand on accède de facon standard ZBM à une variable dimensionnée par l'instruction (Lbank).Var_Name(indice) , aucun controle d'indice n'est effectué ( Fameux adage du programmeur Fortran inconnu : "Je veux pouvoir faire ce que je veux, donc je dois pouvoir faire n'importe quoi" ). De même quand on accède à l'adresse d'une variable par @(Lbank.Class_Name).Var_Name(indice) . Par contre, lorsque l'on décide d'accéder de façon implicite à un bank, on admet que les taches les plus stupides puissent être effectuées par la machine et non pas par l'utilisateur (point de vue subversif, s'il en est). Par défaut, un contrôle d'indice sera donc effectué sur les variables dimensionnées, sauf si l'utilisateur demande le contraire par l'instruction INHIBIT CHECK ARRAY; ************************************* Futura feature *************************** - VAR_LINKED Version du mercredi 26/02/1997 ---------------------------------------------------------------------------(Al1) Declaration : ------------ var_linked name , name1(2) , name2(2,3) , name3([klen]}, :xxx in class XX; Rq : on a l'air de s'orienter plutot vers "array_linked" plutot que "var_linked" qui voudra s'exprimer a ce sujet ? Liaison ------- Link namxx[] to ... standard Utilisation : -------------- Ces variables pointent chacune sur un tableau different pour Futura : seuls les tableaux 1D sont liables, comme Eta_SV, DFi_TV etc ou les variables d'un foreign TD/CD Pour preciser la composante # i du tableau linke' : name(i), name1(i/n), name2(i/n,m) Verifications internes generees : -------------------------------- a la var_linked(n,m) est associee une local var(n,m) de nom ODIM_namexx(,) qui est remplie au moment du link xxx to xxx avec la dimension du tableau, ou du TEF vecteur (Eta_SV etc) La verification est alors standard : i compris entre 1 et ODIM_name(,). ATTENTION : les liens etant effectues en general dans les S/R_Entry, il faut que le tableau originel - s'il est de dimension asssociee a une variable, ai bien ete defini. ************************************************************************************* Remarques d'utilisation avec pointé sur des plugs. (Al1, Avril 2000) ************************************************************************************* Ces liens pointant sur un tableau amenent a une contradiction possible avec les plug. En effet le seul tableau Zebra est le bank Tr (ou Eta); les plug donnant une liste non necessairement ordonnee de ses composantes. Exemple : on a un TV de liste 7,12,17,22. link name to Fi_TV(1); a pour consequence de faire pointer sur Tr(7) mais alors name(2) pointera sur Tr(8) ! la solution est alors name((LTV.TV).Cx_Tr_Nb(2)-(LTV.TV).Cx_Tr_Nb(1)+1) etc On peut aussi preferer dans ce cas declarer un name(4) comme link_var et faire : Pour eviter les erreurs, Zoom signale un LINK WARNING lorsqu'on effectue un lien de type array_linked sur un plug de liste non naturelle. ************************************************************************************* DEBUT ET FIN DE DECLARATION DU BANK ===================================== arguments communs a ces instructions : Bank : Variable correspondant a l'adresse du bank Class_Name : Nom de la classe auquel appartiend le Bank ==> IMPLICIT ACCES TO BANK Class_Name(Bank); Cette instruction permet a l'utilisateur d'acceder directement aux variables du bank: on ecrira par ex. X = Y au lieu de (Bank).X = (Bank).Y .Elle doit etre situee avant le debut de la declaration de la classe. Avant d'utiliser les variables de ce Bank, il est indispensable (sous peine de plantage) de definir l'adresse de ce bank avec les instructions GET .., FROM .., .. Cette adresse doit etre instanciee pour l'ensemble des points d'entree le cas echeant. Un meme nom de variable ne peut etre defini dans plusieurs banks a acces implicite. De meme un meme nom ne peut etre utilise pour une variable FORTRAN et une variable dans un bank a acces implicite. ==> DECLARE CLASS Class_Name [,Class_Name_2...]; Debut de la declaration de la classe Class_Name[ ,ou de la liste de classe] . Toute declaration de classe doit etre termine avant la premiere instruction FTN executable (lors de la declaration, on genere en effet des instruction FORTRAN PARAMETER (....=....) ). ===> END DECLARE CLASS Class_Name[,Class_Name_2...]; Fin de la declaration de la classe Class_Name[ ,ou de la liste de classe] . DECLARATION DES VARIABLES ============================= ARGUMENT COMMUNS AUX DECLARATIONS DE VARIABLES: Var_Name : Nom de variable. Doit etre compose uniquement de caracteres alphanumerique ou du caractere souligne. Pas de restriction sur la longueur. Class_Name : Nom de classe dans lauqlle la variable est definies type : type de la variable Les types autorises sont INTEGER , REAL (et bientot CHARACTER_4, DOUBLE) Si le type n'est pas defini, on prend la convention FORTRAN : entier pour les variables dont la premiere lettre est de I a N, reel sinon. nbcol, nblin : nombre de colonnes, nombre de lignes. Ces dimensions peuvent etre des expressions contenant des nombres entiers, des PARAMETER FORTRAN, une autre variable (deja definie) du meme bank; dans ce cas, cette variable doit etre entre crochet. Mais cela ne peut pas etre une variable FORTRAN. Lorsqu'une variable est utilisee dans une dimension, il est vivement conseille: - que cette variable soit definie au prealable - que cette variable soit une VAR ou une LOCAL_VAR Avant de créer le bank par l'instruction LIFT il faut que l'ensemble des variables utilisées dans une dimension soient instanciées par l'instruction SET : SET .Var_Name for Class_name = Valeur; Après le LIFT, les variables instanciees par l'instruction SET auront la valeur definie par cette instanciation. *** attention, si le symbole Var_name ne sert pas à dimensionner une autre variable, *** on ne peut leur donner une valeur qu'en explicitant : *** (LTD).Var_name = valeur ADRESSES DES VARIABLES On peut acceder a l'adresse d'une variable Var_Name du bank Bk_Name de la classe Class_Name par @(Bk_Name . Class_Name).Var_Name et pour les variables dimensionnees: @(Bk_Name . Class_Name).Var_Name(Ncol,Nligne) ===> LOCAL_VAR Var_name{( nbcol{,nblin} ) } {,Var_name_2....} {:type} IN CLASS Class_Name; Definit une variable (ou une liste de variables) dans la zone donnee du bank. ===> LINK_VAR Var_name{( nbcol{,nblin} ) } {,Var_name_2....} {:type} IN CLASS Class_Name; Definit un lien de reference (ou un tableau de liens pour les variables dimensionnees) qui contient la (ou les) adresse ou est rangee la variable. Cette adresse, ou l'ensemble des adresses pour les variables dimensionnees, doivent etre initialisees par l'utilisateur a l'aide des instrucions link Var_Name_1 to Var_Name_2; ou directement via les adresses @(Bank . Class_name).Var_name = .......; Pour les variables dimensionnees: @(Bank . Class_name).Var_name(Ncol,Nligne) = .......; ===> VAR Var_name{( nbcol{,nblin} ) } {,Var_name_2....} {:type} IN CLASS Class_Name; Definit un espace memoire dans la zone donnee du bank, definit un lien qui contient l'adresse ou est rangee la variable. A l'initialisation (apres un LIFT), ce pointeur est initialise au debut de l'espace memoire dans la zone donnee du bank precedemment defini. Ce pointeur peut etre modifie par (aussi bien pour les variables non dimensionnees que pour celle qui le sont) : @(Bank . Class_name).Var_name = Nouvelle_adresse ; Il faut que l'utilisateur verifie que cette Nouvelle_adresse pointe sur une zone de donnees correspondant aux dimensions et au type de la variable INITIALISATION DU LIEN D'UNE LINK_VAR ======================================= ===> link Var1 to Reserved_Var(n); Pour faire "pointer" une link_var du CD ou TD bank du processeur ou l'on est sur une variable "reservee" (apres avoir fait un Grasp Array de cette variable) avec Var1 : nom de la link_var "locale" Reserved_Var : Eta_SV , Fi_TV , Fiz_TV n : indice dans la Reserved_Var ==> link Var_Name_1 to Var_Name_2 of (LProc); Pour faire "pointer" une link_var du CD ou TD bank du processeur ou l'on est sur une variable declare dans un CD ou TD bank d'un autre processeur. avec Var_Name_1 : nom de la link_var "locale" Var_Name_2 : nom de la var ou local_var "externe" LProc: Adresse permettant d'acceder a cette variable "externe" ( LProc = LSV ou LCL ou LTV ou LTR ). Ne doit en aucun correspondre au processeur ou l'on est : ce pauvre FORTRAN n'etant pas reentrant, "results may be hazardous" ==> link Var_Name_1 to Var_Name_2; Pour faire "pointer" une link_var du CD ou TD bank du processeur ou l'on est sur une variable de ce meme processeur. avec Var_Name_1 : nom de la link_var "locale" Var_Name_2 : nom de la var ou local_var "locale" LECTURE D'UNE VARIABLE D'UN AUTRE OBJET ========================================= ==> set X = [Var2]{:type} of (LProc); " {...} veut dire optionel " Pour lire une variable declaree dans un CD ou TD bank d'un autre objet et la ranger dans une variable Fortran (ou une variable declare dans le CD ou TD bank locale, si on a fait un IMPLICIT ACCESS ...) avec X : nom de la variable Fortran (ou d'une variable declaree dans le CD ou TD bank local, si on a fait un IMPLICIT ACCESS ...) Var2 : nom de la var , local_var ou link_var "externe" type : I ou R ; type de la var, local_var ou link_var "externe". Si le type n'est pas specifie, on prend le type FORTRAN par defaut (entier de I a N, reel sinon) de la variable externe Var2. Diagnostique d'erreur si le type (precise ou par defaut) ne correspond pas au type de Var2 tel qu'il a ete precise lors de sa declaration. LProc: Adresse permettant d'acceder a cette variable "externe" ( LProc = LSV ou LCL ou LTV ou LTR ) DECLARATION DES LIENS ======================= ARGUMENT DES DECLARATIONS DES LIENS Lk_Name : Nom de lien. Doit etre compose uniquement de caracteres alphanumerique ou du caractere souligne. Pas de restriction sur la longueur. Class_Name : Nom de classe dans lauqlle la variable est definies dim : Dimension du tableau de liens. Cette dimension peut etre une expression contenant des nombres entiers, des PARAMETER FORTRAN mais ni une autre variable du bank ni une variable FORTRAN. ===> SLINK Lk_Name[(dim)] [,Lk_Name_2....] IN CLASS Class_Name; Definit un lien de structure (ou un tableau de lien), de taille fixe. ===> RLINK Lk_Name[(dim)] [,Lk_Name_2....] IN CLASS Class_Name; Definit un lien de reference (ou un tableau de lien), de taille fixe. !!!!! attention !!!!! Pour l'instant, il ne faut surtout pas definir un RLINK apres avoir definit des LINK_VAR dont la dimension depend d'une variable du bank; plantage assure. PROTECTION DES VARIABLES , CONTROLE DES INDICES DE TABLEAUX ============================================================== ===> CHECK ARRAY (OP1=YES_NO[,OP2=YES_NO])[ARRAY1[,ARRAY2,..]]; OP1, OP2 : Operation a 'checker' (RD ou WR) YES_NO : (Y ou N ou X) ARRAY1, ARRAY2 : Noms des tableaux -Si on precise une seule operation, le controle des indices pour l'autre operation n'est pas modifiee. -Si on ne precise pas de nom de tableau, la directive s'applique a l'ensemble des tableaux. -Cette directive peut etre situee n'importe ou. Elle s'applique a la suite du texte. Elle peut etre situee a plusieur endroit : le controle des indices ne sera pas le meme dans tout le programme. - Par defaut on controle l'ecriture et la lecture pour tous les tableaux CHECK ARRAY (WR=Y,RD=N); - Si YES_NO vaut X, on prend la valeur precedent le dernier CHECK ARRAY. Ceci permet de modifier locale le controle des tableaux, puis de remettre les conditions de controle comme avant (voir par exemple la macro Z_Pr ) ===> INHIBIT CHECK ARRAY; - Plus aucun controle sur les indices (ni a la creation, ni a la lecture, ni a l'ecriture) n'est effetue et ne peut etre effectue pour tous les tableaux creer a partir de cette directive. Les directives CHECK n'ont aucun effet. - Le code genere est beaucoup plus 'leger' (- Cette directive modifie les macros definissant les operations de lecture/ecriture et l'operation de controle des dimensions initiales, macros appelees lors de la creation d'un tableau) !!!! Antonio Rodrigues pretend avoir obtenu des resultats differents !!!! avec et sans cette instruction => PRUDENCE donc ===> WRITE INHIBIT ARRAY AR1[,AR2....]; AR1,AR2 : Nom de tableaux - Interdit l'ecriture pour les tableaux dont le nom est specifie, non encore crees. Aucun effet sur les tableau deja existant. 1 ******************************************************************** ***************** Z.B.M. (ZOOM Bank Manager ) ****************** ******************************************************************** ***** Chainage des banks, définition de l'origine du chainage, ***** ***** création des bank, accès aux variables des bank, .... ***** ******************************************************************** ************************** USERS MANUAL ************************** ******************************************************************** DEFINTION DES CHAINAGES DE BANK =============================== ===> local_valid_chains:[~CL~SV~CX~TV~TR~], ou ...~CX(.)~.. [~CX~IC~], [~etc~FM*~IN~etc~], end_chains; . Declaration des chaines de graphes orientes de gauche a droite. . Permet de referencer tout bank (ex TV) ayant une origine a sa gauche dans une chaine de la liste ( ex CL,SV ou CX). . La premiere chaine de la liste permettant le chainage sera retenue. . La presence de * signifie adressage indirect (reserve pour la classe FM) . Une seule declaration de liste est autorisee par subroutine. . La presence de CX(.) est requise pour la commande READ THRU. Dans ce cas il est inutile de repeter la chaine sans CX(.). ***** DIAGNOSTICS ET ERREURS : Toute tentative de declarer plus d' une liste sera sanctionnee par le message d' erreur: '** ZBM ERROR ** ONLY ONE CHAIN LIST BLOC ALLOWED PER SUBROUTINE' DEFINTION DE LA PREMIERE ORIGINE DES CHAINAGES DE BANK (zero-level FROM ) ========================================================================== On doit, avant toute reference a un bank definir une premiere origine des chainages au debut de chaque routine : - pour un processeur de cellule, on definit comme premiere origine la classe CL. Si LCL est l'adresse du bank de la cellule, on fera : ===> from CL(LCL) < ...... > - pour un processeur de transfert, on definit comme premiere origine la classe TR. Si LTR est l'adresse du bank de la cellule, on fera : ===> from TR(LTR) < ...... > DEFINTION LOCALE DE L'ORIGINE D'UN CHAINAGE DE BANK =================================================== ===> from Cl_Bk(LBank) < .......... ..... exit from LBank; .......... > Arguments : Cl_Bk : Bank Class name LBank : Bank addresse Cette instruction : - instancie le bank LBank de la class Cl_Bk a partir de l'origine courante des chainages. - definit Cl_Bk(LBank) comme etant la nouvelle origine des chainages. - exit from LBank; provoque la sortie de ce block MORTRAN. BOUCLE SUR TOUS LES BANKS D'UNE CLASSE AVEC REDEFINTION ======================================================= DE L'ORIGINE DES CHAINAGES DE BANK ================================== - Cas generale -------------- ===> skip thru Cl_Bk(LBank) < ..... ..... to next LBank; ..... exit from LBank; > Arguments : Cl_Bk, LBank. Cette instruction : - instancie le bank LBank de la class Cl_Bk a partir de l'origine courante des chainages. - definit Cl_Bk(LBank) comme etant la nouvelle origine des chainages. - exit from LBank; provoque la sortie de ce block MORTRAN. - to next LBank ou la fin de block MORTRAN (>) provoque le bouclage sur LTV jusqu a ce que l'on ai parcouru tous les banks de cette classe. -(Cette instruction est utilisable lorsque les banks sont chaines a la suite l'un de l'autre) - Cas particulier ----------------- Cas rencontre lorsque l'on veut parcourir les connections sous un T-Plug (c.a.d. un TV) ===> NCX = (LTV).Nb_Cx_CX; "Nombre de connexion de ce T-Plug" read thru CX(LCX) (J=1,NCX) < ..... ..... to next LCX; .... exit from LCX; > Arguments : CX : nom de la classe du bank LCX: adresse du bank J : indice de boucle NCX: nombre de connexions sur lesquelles s'effectue la boucle Cette instruction : - instancie le bank LCX de la class CX a partir de l'origine courante des chainages. - definit CX(LCX) comme etant la nouvelle origine des chainages. - exit from LCX; provoque la sortie de ce block MORTRAN. - to next LCX ou la fin de block MORTRAN (>) provoque le bouclage sur LCX jusqu a ce que l'on ai parcouru NCX fois la boucle. - Exige de declarer ~CX(.)~ dans le bloc LOCAL_VALID_CHAINS(voir cette commande). -(Cette instruction doit etre utilisee lorsque les banks doivent etre addresses via un tableau de link , ce qui est les cas des CX sous les TV (cf TV Bank)). INSTANCIATION D'UN BANK, SANS MODIFICATION DE L'ORIGINE DES CHAINAGES ===================================================================== ===> get Cl_Bk(LBank); Arguments : Cl_Bk : Bank Class name LBank : Bank addresse . Instancie le bank LBank a partir de l' origine courante des chainages. . Tolere tout alteration de LBank. ***** PAS DE DIAGNOSTIC . ACCES AUX VARIABLES D'UN BANK INSTANCIE ======================================= Apres avoir instancié un bank LBank (par les instructions from, get, skip thru ou read thru ), on peut accéder à toutes les variables de ce bank (voir liste plus loin) par : ===> (Lbank).Var_Name ou (Lbank).Var_Name(..) pour les variables dimensionnées. Actuellement pas de contrôle d'indice pour l'accès aux variables dimensionnées. L'instruction ===> Point_On(LBank) permet d'accéder à une variable non plus par (Lbank).Var_Name, mais par ===> ..Var_Name Arguments : LBank : Bank addresse Var_Name : nom de variable CREATION D'UN BANK ================== ===> Lift Lbank of class Cl_Bk under (L_Up, -N_Lk); Arguments : Cl_Bk : Bank Class name LBank : Bank addresse L_Up : Adresse du bank de reference auquel ser attache l'objet cree N_Lk : si = 0, on cree le bank en next de L_Up si <>0, on cree le bank sous L_up, rattache au lien numero N_Lk Cette instruction : - cree le bank - genere un get Cl_Bk(LBank) et un Point_On(LBank) Certaines grandeurs necessaires a la creation du bank, si elle ne sont definient par PRECOMP ou par une declaration locale de classe, doivent être instanciées par l'instruction ===> Set .Var_name for Cl_Bk = Valeur; arguments : Var_Name, Cl_Bk, Valeur 1 ******************************************************************** ***************** Z.B.M. (ZOOM Bank Manager ) ****************** ******************************************************************** ***** Boucles courtes pour les processeurs (Dev from Sept 94) ***** ******************************************************************** ************************** USERS MANUAL ************************** ******************************************************************** ====================================== = Amélioration de la boucle standard : ====================================== read thru CX(LCX) (JCx=1,*) < génère : READ THRU CX(LCX)(JCx=1,0_(#U6#S6$L#C.TV).Nb_Cx_CX)< ( cad qu elle récupère l'adresse du TV supérieur ); [ATTENTION : cela lui interdit d'être sous un Get TV(LTV); car alors, le TV n'est pas dans le stack 6 => faire plutot un From TV(LTV);] ================================= = Ecriture compactee de boucles : ================================= Skip thru CX(LCX) (JOCx=1,*)/.CL(LCL)/SV(LSV2)/CX(LCX2.ne.LCX)/ .TV(LTV2)/.TR(LTR2) < IF (LTR2).Types(2).EQ. 01 01 02 "TCdM" < >"End TCdM" > "close Skip thru CX/../TR2" génère les boucles standard Skip et Read thru; Attention : !!! effectue les tests pour skiper les T_Probes ( (LTV).Nb_Tr_Var=0 ). (au contraire du skip thru standard qui prend tout !!!/.XX(LXX) genere un FROM XX(LXX)< ---- CX(LCX2.ne.LCX) : skip en cas d'égalité (test uniquement sur banks CX). *** adresse de la boucle CX locale. (LCX supposée définie précédemment); pour ces formes, la première adresse est l'adresse de boucle (of course) Aucun test sur les CPlugs; Autres possibilités : .../TProbe(LTV)/ : ne prend que les T_Probes; .../All_TV(LTV)/ : prend tout; CX(LCX2.eq.LCX) : skip en cas de non égalité; signification du /. : génère un get, (=> ne prend donc que le premier Bk) skip si (LTV).Nb_Tr_Var=0: suivit d' un from; pour CX( )/.TV( )< : skip to next CX si T_Probe; (avec son pendant /.TProbe( ) of course); Formes équivalentes : TPlug == TV; CPlug == SV; TPlug_Tprobe == All_TV; Rq : On peut toujours utiliser la forme CX(LCX) (JCx=1,NCX), ou NCX a été définie précédemment. ******************************************************************** ************************** FUTURA adds *************************** **********************************************(Al1 mardi 21/01/1997) Les additions suivantes sont utiles pour sélectionner les C-Plug qui sont identifiés par (LSV).C_Plug_Nm, (LSV).C_Plug_Nb [ex: Face-1] ATTENTION : Case sensitive !!! (même forme que dans Znit) ... /SV(LSV.eq.*-*)/ pas d'effet [* stands for any] ... /SV(LSV.eq.Face-*)/ ... /SV(LSV).eq.*-1/ ... /SV(LSV.eq.*-1,2,3,4)/ ... /SV(LSV.eq.Face-1,2,3,4)/ ... /SV(LSV.ne.Face-*)/ ... /SV(LSV.ne.Face-1,2,3,4)/ == .NOT.(LSV.eq.Face-1,2,3,4) idem avec la forme : /.SV(LSV) commentaire : on reprend ainsi la forme logique du traitement des listes IF< IF i.eq.1,2,3,4 == IF i.eq.1 ou 2 ou 3 ou 4 IF i.ne.1,2,3,4 == IF i .eq. ni 1, ni 2 , ni 3, ni 4 => ici ni Face-1, ni Face-2, etc ; exemple (pas forcément à suivre) SKIP THRU TV(LTV.ne.LTV2)/CX(LCX.ne.LCX2) (JCX=1,*)/.SV(LSV.ne.Face-3,4,5)/ .CL(LCL.ne.LCL2)/SV(LSV2.eq.Bulk-*)/CX(LCX3.ne.LCX)/ .TPROBE(LTV3.ne.LTV) < ;continue; to next LTV; to next LCX; to next LCX3; >; ******************************************************************************************** ********** Futura : Connections directes TRansfert a TRansfert ***************************** *********************************************************Al1 : 14/08/1998 ****************** les : SKIP THRU TV(LTV)/CX(LCX) < ne retiennent que les TV connectés à une cellule au moins et les CX non connectés directement à un transfert (via l'objet (*) de la famille). All_TV prend tous les TV (T_probes y compris), All_CX tous les CX. On pourra alors utiliser les expressions : IF (TV_to_TR(LTV)) then; IF (CX_to_TR(LCX)) then; pour les branchements; TV_to_TR invoque l'expression logique : JBIT(IQ(LTV),IODITR).eq.1 CX_to_TR invoque l'expression logique : JBIT(IQ(LCX),IODITR).eq.1 Pour suivre les connections jusqu'à un transfert, on utilise alors : SKIP THRU Cx_to_TR(LCX)/TV(LTV2)/.TR(LTR2)< qui est equivalente à : SKIP THRU Cx(LCX) < IF (JOBIT(IQ(LCX),IODITR).eq.0) To Next LCX; SKIP THRU SV(LSV)/CX(LCX2.ne.LCX)/TV(LTV2)/.TR(LTR2)< Dans tous les cas, on définit une matrice D particulière : grasp array D_TV (LTV2,LTR) for (LCX2,*,LCX); dans le cas des SKIP THRU explicites ou alors : grasp array D_TV (LTV2,LTR) for (*,*,LCX); dans le cas des SKIP THRU rapides; Rq : ces dernières macros rapides marchent aussi dans les cas standards ou on ne ferait pas reconnaissance de la Cellule médiate. exemples complet de boucle de connection directe : SKIP THRU Cx_to_TR(LCX)/TV(LTV2)/.TR(LTR2) < grasp array D_TV (LTV2,LTR) for (*,*,LCX); D_TV(i,j)= ...; >; Avec boucles explicites : SKIP THRU CX(LCX) < IF (Cx_to_TR) < SKIP THRU SV(LSV)/CX(LCX2.ne.LCX)/TV(LTV2)/.TR(LTR2) < grasp array D_TV (LTV2,LTR) for (LCX2,*,LCX); ;;; on remarque que l'objet * de connexion directe des TR ne comporte qu'un SV. >; >ELSE < " connection aux cellules " ;;; >; (l'intérêt réside dans le fait que la Cellule connectée ne verra pas ces CX)