Brevet FR2843200A1 — publié le 20040206

PROCEDE ET SYSTEME DE RECONNAISSANCE AUTOMATIQUE DE CONFIGURATIONS DE SIMULATIONS D'UN CIRCUIT INTEGRE L'invention concerne un procédé et un système de reconnaissance automatique de configurations de simulation pour la vérification fonctionnelle des circuits intégrés ASIC par des tests de simulation. Plus particulièrement, l'invention concerne un procédé de reconnaissance automatique de configurations de simulation et un système permettant de mettre en #uvre le procédé. Avec l'accroissement de la complexité des systèmes matériels (hardware), il faut pouvoir traiter des configurations de systèmes rassemblant de plus en plus de modèles écrits en langage de description du matériel, par exemple de type HDL (les langages VHDL et Verilog étant les plus utilisés), et en langages de haut niveau, par exemple de type HLL (tels que C ou C++), ces langages décrivant, d'une part, les éléments constitutifs du matériel et, d'autre part, les modèles constitutifs de l'environnement de simulation. Dans la suite de la description, nous appellerons "configuration de simulation" ou "configuration" un ensemble de modèles logiciels d'éléments dits "composants" constituant un modèle global de simulation, les composants étant connectés entre eux, soit directement, soit par l'intermédiaire de blocs intermédiaires. L'invention est utile dans la vérification de la conception des ASICs par simulation de leur fonctionnement, par exemple, dans un environnement identique à ou très proche de leur utilisation finale, le procédé de reconnaissance automatique de configurations permettant à des tests d'identifier les composants d'une configuration. Dans le cas d'un ASIC contenant beaucoup d'éléments et étant connecté à plusieurs circuits externes, il est difficile de prévoir à l'avance toutes les configurations utiles et d'établir les relations entre les ensembles de configurations associant différentes propriétés de configuration, et les ensembles de test qui leur sont applicables. De ce fait, on renonce souvent à l'utilisation de certaines variantes de configurations facilitant le debug, ces variantes pouvant ne concerner qu'une partie des composants afin de simuler une partie seulement de l'ASIC ou de son environnement. Pour couvrir l'ensemble des variantes d'une configuration de simulation, il est nécessaire de disposer d'une grande quantité de variantes de tests propres à chaque configuration. Cette situation est une source potentielle d'erreurs car chaque modification et correction d'un test doit être répertoriée et vérifiée dans chaque variante du test. Le but de la présente invention vise donc à limiter les inconvénients de mise au point des programmes de test en fonction des configurations de simulation disponibles. Ce but est atteint par un procédé de reconnaissance automatique de configurations de simulation disponibles de circuits intégrés en projet comprenant au moins deux composants reliés entre eux directement ou indirectement, pour la vérification fonctionnelle desdits circuits par des tests de simulation, caractérisé en ce qu'il comprend : - une étape de saisie de configuration de simulation par un premier gestionnaire, appelé "gestionnaire serveur" associé au simulateur, pendant l'initialisation du programme simulateur, et pendant que sont alors appelés tous les constructeurs d'instances HLL (C++) de composants présents dans le modèle global de simulation courant, chacun de ces constructeurs enregistrant sa présence en transmettant ses propres paramètres (label, type, chemin HDL ...) au gestionnaire serveur qui construit la table des instances des composants, - une étape d'envoi d'une requête par un deuxième gestionnaire, appelé "gestionnaire client" vers le gestionnaire serveur pour savoir si les composants attendus dans une configuration par le gestionnaire client sont présents et quels sont leurs positions (indiquées par les labels) et leurs types, - une étape d'envoi d'une réponse par le gestionnaire serveur au gestionnaire client, après consultation de la table des instances des composants, la réponse contenant les instances des composants présents et/ou une notification d'erreur en cas d'absence d'un ou plusieurs composants attendus, et de mémorisation de la réponse dans au moins une table de mémorisation des modèles de configuration par le gestionnaire client, - une étape de comparaison, par le gestionnaire client , de la réponse avec les exigences du test, suivie d'une étape d'inhibition, d'activation et/ou de modification de certaines parties du test par le gestionnaire client pour adapter le test à la configuration ou signalisation d'erreur si cela s'avère impossible . Selon une autre particularité, les configurations de simulation sont générées à partir des données de génération de configurations, avant l'utilisation du procédé selon l'invention. Selon une autre particularité, la génération des configurations est réalisée par un opérateur humain. Selon une autre particularité, la génération des configurations est réalisée par un générateur automatique de configurations. Selon une autre particularité, l'étape d'envoi d'une requête est suivie d'une étape de traduction de ladite requête, par une interface programmatique, en langage compréhensible par le premier gestionnaire, et en ce que l'étape d'envoi d'une réponse est suivie d'une étape de traduction de ladite réponse, par l'interface programmatique, en langage compréhensible par le deuxième gestionnaire. Selon une autre particularité, le procédé de reconnaissance automatique de configurations fonctionne dans une architecture clientserveur, le premier gestionnaire étant situé sur le serveur et le deuxième gestionnaire sur le client. Un autre but de l'invention est de proposer un système permettant de mettre en #uvre le procédé selon l'invention. Ce but est atteint par un système de reconnaissance de configurations de simulation disponibles de circuits intégrés en projet, caractérisé en ce qu'il comprend un premier gestionnaire muni de moyens pour formuler et/ou analyser un message, de moyens de mémorisation, et de moyens pour remplir et consulter au moins une table dite table des d'instances des composants présents dans chaque configuration, et en ce qu'il comprend un deuxième gestionnaire muni de moyens pour formuler un message et/ou une requête, de moyens pour analyser un message, et de moyens pour remplir et consulter au moins une table de mémorisation des modèles de configuration. Selon une autre particularité, le deuxième gestionnaire est muni de moyens pour inhiber, activer et/ou modifier certaines parties du test pour adapter le test en fonction de la réponse. L'invention sera mieux comprise à l'aide de la description suivante d'un mode préféré de mise en #uvre du procédé de l'invention, en référence aux dessins annexés, sur lesquels : - la figure 1 représente, sous forme très schématique, un exemple de modèle global de simulation ; - la figure 2 représente un diagramme illustrant les différentes composantes du système de reconnaissance automatique et les étapes de mise en #uvre de ces composantes dans le procédé de l'invention ; - les figures 3a à 3c représentent différents stades de modélisation d'un circuit à l'aide d'un modèle mixte de type HDL (VERILOG ou VHDL) et de type HLL (C++) ; - les figures 4a à 4c représentent différentes configurations du modèle global de simulation correspondant à l'architecture représentée sur la figure 1. Un modèle global de simulation est typiquement composé d'un ou plusieurs modèles de circuits intégrés testés (DUT) entourés de modèles qui créent un environnement de test et vérification. Ces modèles créent des stimuli complexes et reçoivent des réponses complexes du modèle testé. Ces composants peuvent être des transactors (XACTORS) - des modèles possédant généralement une interface programmatique (API) permettant un pilotage par des tests externes au modèle, ces tests étant écrits généralement en langage de haut niveau (HLL). L'environnement de vérification peut contenir aussi des composants dits Bloc de Monitoring (MONITOR) et des composants dits Bloc de Vérification (VERIFIER). Ces composants n'interviennent pas directement dans l'échange de signaux entre les autres constituants du modèle global de simulation mais servent à les observer et à les interpréter. Les Blocs de Monitoring (MONITOR) servent de support d'analyse pour les tests, ils possèdent des interfaces programmatiques (API) pour signaler des événements observés sur les signaux de modèle global. Les Blocs de Vérification (VERIFIER) sont des composants qui possèdent une spécification de référence de fonctionnement de modèle testé et, en observant les signaux du modèle global de simulation, sont capables de vérifier le bon fonctionnement du modèle. La figure 1 représente un exemple d'architecture d'un système comprenant un circuit intégré en développement, constitué d'un processeur (1) (CPU) communicant par une passerelle (4) (BRIDGE) avec une mémoire système (2) (MEMORY) et des entrées sorties (3) (1/0). Les figures 4a, 4b et 4c représentent trois modèles globaux de simulation de l'architecture de la figure 1, à des stades successifs d'un projet, les figures 4a et 4ab étant des exemples d'étapes intermédiaires d'évolution vers le modèle de la figure 4c, qui peut représenter un modèle global final. Chaque modèle global de simulation est généré par un utilisateur du système de reconnaissance automatique, manuellement ou par un générateur automatique de configurations, dit configurateur (17, figure 2), permettant de générer une configuration arbitraire à partir d'au moins un fichier comprenant les conditions de génération de la configuration (18). Le configurateur (17) est, par exemple, celui décrit dans la demande de brevet "Système et procédé d'établissement automatique d'un modèle global de simulation d'une architecture" déposée par la requérante ce même jour. Dans le mode de réalisation de la figure 2, les conditions de génération de la configuration (18) sont réparties sous forme de trois fichiers comprenant respectivement une description de l'architecture du modèle global de simulation (FDARCH), une description synthétique de la configuration à générer (FCONF) et une description des interfaces de type HDL des composants (BFSHDL). L'utilisateur du système selon l'invention génère, manuellement ou à l'aide du configurateur (17), deux fichiers MGHDL (33) et MGHLL (32) qui vont servir de fichiers source pour la simulation. Le fichier MGHDL (33) instancie les parties HDL du modèle et décrit la connexion, en langage de type HDL, des composants entre eux, et le fichier MGHLL (32), contient des instances, écrites en langage de type HLL, comportant les caractéristiques de chaque composant. Le système de reconnaissance automatique de configurations de simulation selon l'invention permet aux tests de vérifier leur adéquation à la configuration au cours de la simulation, et de s'adapter en fonction de la configuration, afin de ne pas avoir à écrire un test par variante de configuration. Le modèle global représenté sur la figure 4b, auquel peut par exemple aboutir le configurateur, est constitué d'un composant processeur CPU de type XACTOR relié par une interface de type "fbus~p" à un bloc intermédiaire (fbus~xchg) (101) ayant une interface de type différent. Un autre bloc intermédiaire (fbus~xchg) (102) relie le premier bloc intermédiaire (101) à un composant de type passerelle (BRIDGE) de type DUT~CORE qui communique, d'une part avec un modèle majoritairement en langage de type HDL d'une mémoire (MEMORY) de type DUT, d'autre part avec un modèle majoritairement en langage de type HDL d'une entrée/sortie (1/0) de type DUT et enfin avec un bloc système (SYS~BRIDGE) de type DUT. Chaque type de Composant peut être décrit à plusieurs niveaux de détails (fonctionnel, comportemental, portes, etc...) en langage de type HDL, tel que VERILOG ou VHDL, ou en langage de haut niveau (HLL), tel que C ou C++, complété d'une interface de type HDL. Plusieurs niveaux de descriptions peuvent coexister pour décrire des fonctionnalités similaires et avoir des interfaces de type HDL similaires mais pas forcément identiques. Certaines descriptions peuvent avoir plus de fonctionnalités, et les interfaces de type HDL peuvent contenir des jeux de signaux complètement différents. Chaque instance d'un composant dans ce schéma obtient des paramètres d'identification du composant, à savoir au moins un nom ou label, qui identifie la position du composant (par exemple CPU~0, BRIDGE 0, CMEM~0), un type (par exemple DUT, VERIFIER, XACTOR, MONITOR) et un chemin HDL, correspondant au nom hiérarchique du composant dans le modèle global de simulation. Un exemple de définition des paramètres d'identification d'un composant est donné dans l'annexe 1. Les composants sont décrits, comme représenté sur les figures 3a à 3c, à la fois en langage de type HDL et en langage de type HLL. Dans le cas d'un composant décrit complètement en langage de type HDL (figure 3a), la partie de type HLL est réduite à une instance qui permet de signaler sa présence dans la configuration au cours de la simulation et qui fournit les chemins d'accès aux ressources de type HDL du composant. Dans le cas où un composant de type HDL n'a pas besoin d'être identifié par le test, la présence de la partie HLL est facultative, ce qui permet une simplification du modèle global de simulation. Pour les composants décrits en langage de type HLL (figure 3c), c'est la partie de type HDL qui est réduite au strict minimum, et qui est limitée à la description des signaux et registres d'interface. Tous les niveaux intermédiaires entre ces deux extrémités sont possibles et naturellement exploités dans le contexte de processus de développement des circuits ASIC. La partie de type HLL des composants est construite par un constructeur d'instance. C'est cette partie qui comprend les paramètres d'identification du composant (nom, type, chemin HDL, etc...). Un exemple d'instance d'identification d'un composant, écrite en C++, est donné dans l'annexe 4. La figure 2 illustre le principe du procédé de reconnaissance automatique de configurations de simulation selon l'invention. Le fonctionnement du procédé de reconnaissance automatique de configurations sera décrit, de façon non limitative, dans une architecture client-serveur, comme représenté sur la figure 2. Le procédé de reconnaissance automatique de configurations fonctionne également sur une machine unique ou dans une architecture multiclients-multiserveurs, distribuée sur plusieurs machines, chaque machine comprenant au moins un serveur ou un client de l'architecture. L'utilisation d'une architecture clientserveur est particulièrement utile dans le cas où la mémoire de la machine constituant le serveur n'est pas suffisante pour réaliser le procédé. Le modèle global de simulation est constitué de fichiers sources HDL et HLL (marqués respectivement MGHDL et MGHLL) et de toutes les bibliothèques de composants HDL (71) et modules de librairies HLL (72) auxquels ils font respectivement référence. Les deux parties du modèle global sont ensuite compilées pour donner les fichiers objet HDL (51) et fichiers objet HLL (52) utilisés par le simulateur. Les fichiers objets HLL sont intégrés au simulateur édition des liens (linking) en utilisant une API standardisé (exemple PLI pour VERILOG) et les fichiers objet HDL seront utilisés directement par le simulateur pour créer les modèles des composants. Le serveur (13) comprend un gestionnaire, dit ServerRegistry (14), qui comprend au moins une table m~plnstanceMap (15) mémorisant des informations sur l'instance. Le client (10) comprend également un gestionnaire, dit ClientRegistry (11), comprenant au moins une table m~serverConfigMap (12) dans laquelle sont mémorisées, au début du procédé de reconnaissance de configurations les informations sur les instances des composants présentes dans le modèle simulé Au début de chaque simulation les constructeurs des instances d'objets sont appelés. Chaque constructeur appelle une procédure spéciale dite Register de la classe ServerRegistry (annexe 3) en lui transmettant les informations sur l'instance, ces informations sont mémorisées (16) dans la table m~plnstanceMap (15). Le procédé selon l'invention permet au client de vérifier l'adéquation de chaque test de simulation fourni par le client avec la configuration à laquelle le test est associé. Pour ce faire, le client (10) envoie une requête faisant partie de la classe QueryReq par l'intermédiaire du gestionnaire du client ClientRegistry (11) au gestionnaire du serveur ServerRegistry (14). Une interface programmatique API CONF, présente sur le serveur (13), permet de traduire la requête en langage compréhensible par le gestionnaire du serveur ServerRegistry (14). La requête QueryReq permet au client (10) de s'informer sur la présence d'un composant dans la configuration et sur son type. Le client (10) demande par exemple si tel type de composant est présent dans telle ou telle configuration, et, si oui, où il est. Le client (10) peut aussi lancer une requête pour s'informer sur la présence et le type de tous les éléments compris dans une ou plusieurs configurations, sur un ou plusieurs serveurs, en spécifiant comme paramètres (annexe 1, classe QueryReq) INSTANCE~ANY, TYPE~ANY et SERVER~ANY respectivement. Le gestionnaire du serveur ServerRegistry (14) cherche dans la table m~plnstanceMap (15) et envoie une réponse au gestionnaire du client ClientRegistry (11) par l'intermédiaire de l'API CONF, formulée par la classe QueryRsp. Un exemple de classe ServerRegistry du gestionnaire du serveur est donné en annexe 3. Si le gestionnaire du serveur ServerRegistry (14) trouve le type de composant cherché, il le notifie dans la réponse en précisant, en fonction de ce qui lui est demandé dans la requête, les informations comprises dans la requête associée à chaque composant. La réponse contient par exemple le nom (label), le type du composant, son chemin HDL, le nom de la configuration et le nom du serveur sur lequel il est simulé. Dans le cas où le composant recherché n'est pas présent dans la configuration, la réponse contient une notification d'erreur (INSTANCE~NONE, TYPE~NONE). Le gestionnaire du client ClientRegistry (11) mémorise alors la réponse dans la table m~serverConfigMap (12) formant un cache de la table du gestionnaire serveur. Un exemple de cette procédure est donné en annexe 2. Dans le cas d'une simulation muti-serveur la table du gestionnaire client contient la somme de contenu des tables de tous les serveurs utilisés. Dans ce cas le test utilise le nom du serveur associé à chaque composant pour adresser les stimuli vers le serveur adéquat. Si les composants et leur type correspondent aux attentes du test, le test s'auto-adapte à la configuration en inhibant, activant et/ou modifiant certaines parties du test selon la présence ou non des composants et leur type particulier. Ceci permet de pouvoir utiliser le même test pour des configurations différentes. Le client (10) peut alors exécuter le test de simulation sur le serveur (13) par l'intermédiaire d'une interface programmatique API SIM, qui traduit le test en stimuli. L'annexe 5 illustre la définition des classes clientes permettant l'accès à l'API SIM correspondant à l'architecture représentée sur la figure 1. Si la configuration ne correspond pas aux besoins du test une erreur est signalée. Un exemple de test correspondant à l'architecture représentée sur la figure 1 est donné en annexe 6. Ce test ne peut s'exécuter correctement que si les composants suivants sont présents: CPU~0 d'un type arbitraire, CMEM~0 et/ou CIO~0 de type arbitraire et BRIDGE 0 de type DUT~CORE. Pour CPU~0 de type DUT un traitement spécifique est appliqué - appel de procédures self test() et reset(). Dans la boucle principale du test les accès mémoire et entrée-sortie sont exécutés de manière conditionnelle selon la présence des composants CMEM~0 et CIO~0. Le test de l'annexe 6 correspond à la configuration de la figure 4b ou ses variantes. Les fichiers MGHLL et MGHDL correspondants, générés par le système configurateur automatique (17) sont donnés dans les annexes 7 et 8 respectivement. On conçoit que la présente invention peut être mise en #uvre selon d'autres formes spécifiques, sans sortir de son domaine d'application tel que revendiqué. Par conséquent, la présente description détaillée doit être considérée comme étant une simple illustration d'un cas particulier dans le cadre de l'invention et peut donc être modifiée sans sortir du domaine défini par les revendications jointes. ANNEXE 1 /*++************************************************** * * Copyright (c) 2000 BULL - Worldwide Information Systems * All rights reserved * * Module name : registry.hpp * Author Andrzej Wozniak * *##****************-*-************'*'********************/ #ifndef HPP~REGISTRY~HPP #define HPP REGISTRY HPP ////////////////////// #include #include #include ////////////////////// class LabelClass { public : enum InstLabel { CPU~0 = 0x0010, CPU~1 = 0x0011, // BRIDGE~0 = Ox0020, BRIDGE~1 = Ox0021, CMEM~0 = Ox0030, CMEM~1 = Ox0031, CIO~0 = Ox0040, CIO~1 = Ox0041, CPU~0~BRIDGE~0 = Ox2010, BRIDGE~0~CPU~0 = 0x1020, CPU~1~BRIDGE~1 = Ox2111, BRIDGE~1~CPU~1 = 0x1121, - - ~ INSTANCE~ANY = Oxffff, INSTANCE~NONE = 0x0000 }; ////// class TypeClass { public : enum InstType { DUT = 0x0001, DUT~CORE = Ox0002, XACTOR = Ox0004, MONITOR = Ox0008, VERIFIER = Ox0010, FBUS~XCHG = Ox0020, // TYPE~ANY = Oxffff, TYPE~NONE = 0x0000 }; }; ////// class Registry : public LabelClass, public TypeClass { public : typedef long unsigned int Handle~t; public : static const string SERVER~ANY; static const int MAX~CLIENT~NB = 16; static const int MAX~SERVER~NB = 8; public : //// typedef long long unsigned int CombinedID~t; }; //// class QueryReq : publicRegistry { public : QueryReq(const string& serverName = SERVER~ANY, int clientNum = 0, InstLabel instanceLabel = INSTANCE~ANY, InstType instanceType = TYPE~ANY); public : string m~serverName; int m~clientNum; InstLabel m~instanceLabel; InstType m~instanceType; }; class QueryRsp : public Registry { public : QueryRsp(long unsigned int iihandle = 0, const string& serverName = SERVER~ANY, InstLabel instanceLabel = INSTANCE~ANY, InstType instanceType = TYPE~ANY, const string& instanceName = string(""), const string& instanceVerilogPath = string("")); public : long unsigned int m handle; string m~serverName; InstLabel m~instanceLabel; InstType m~instanceType; string m~instanceName; string m~instanceVerilogPath; string m~fullInstanceName; }; class QueryError{ public : const string m~err; QueryRsp m~qrsp; QueryError(const string& err, const QueryRsp& qrsp): m~err(err), m~qrsp (qrsp) } }; //// ostream& operator (ostream& str, const QueryReq& qrq); istream& operator (istream& str, QueryReq& qrq); ostream& operator (ostream& str, const QueryRsp& qrsp); istream& operator (istream& str, QueryRsp& qrsp); typedef int Status; #endif /* HPP REGISTRY HPP */ ANNEXE 2 /*++************************************************** * * Copyright (c) 2000 BULL - Worldwide Information Systems * All rights reserved * * Module name : client~registry.hpp * Author Andrzej Wozniak * *##***************************'*'************************/ #ifndef HPP~CLIENT~REGISTRY~HPP #define HPP CLIENT REGISTRY HPP #include #include "registry.hpp" #include "client~component.hpp" class ClientRegistry : public Registry { public : typedef map QueryMap~Type; public : static Status QueryServerConfig(); static const QueryRsp& QueryServer(InstLabel iid, InstType ict) ; static const QueryMap~Type& getQueryMap(); static QueryRsp& QueryComponent(InstLabel iid, InstType ict); private: static QueryMap~Type m serverConfigMap; static QueryMap~Type::iterator m~it; public : static int getServerNumber(); static int getClientOwnNum(); static string& getConfigName(); }; #endif /* HPP CLIENT REGISTRY HPP */ ANNEXE 3 1*++************************************************** * * Copyright (c) 2000 BULL - Worldwide Information Systems * All rights reserved * * Module name : server~registry.hpp * Author Andrzej Wozniak * *--**************************************************1 #ifndef HPP~SERVER~REGISTRY~HPP #define HPP SERVER REGISTRY HPP #include "registry.hpp" #include "component.hpp" #include class ServerRegistry : public Registry { public : static Status Register(ComponentIdent* p~comp); static ComponentIdent* getInstance(InstLabel ilabel, InstType itype); static const ComponentIdent* c~getInstance(InstLabel ilabel, InstType itype); public: static Status QueryServer(); private: typedef map Map~t; static Map~t* m pInstanceMap; static int m~clientNumber; static const string m~serverName; static const string m~configName; public : static const string& getServerName(); static const string& getConfigName(); static int getServerNumber(); static int getClientNumber(); public : // } ; // ServerRegistry class #endif /* HPP SERVER REGISTRY HPP */ ANNEXE 4 * Copyright (c) 2000 BULL - Worldwide Information Systems All rights reserved * Module name : Component.hpp * Author Andrzej Wozniak *~~*****************************************************/ #ifndef HPP~COMPONENT~HPP #define HPP~COMPONENT~HPP #include #include "registry.hpp" class ComponentIdent . public Registry public : ComponentIdent(InstLabel ilabel, InstType itype, const string iname, const string hdlpath); virtual #ComponentIdent(); public : InstLabel m~ilabel; InstType m~itype; string m~iname; string m~hdlpath; #endif /* HPP~COMPONENT~HPP */ ANNEXE 5 /*++************************************************** * Copyright (c) 2000 BULL - Worldwide Information Systems * All rights reserved * * Module name : client~component.hpp * Author : Andrzej Wozniak * *--**************************************************/ #ifndef HPP~CLIENT~COMPONENT~HPP #define HPP CLIENT COMPONENT HPP class ClientComponent { protected : ClientComponent(); public : static ClientComponent* create(QueryRsp qrsp); public : virtual int mem~write(unsigned long long addr, unsigned long long data); virtual int mem~read~compare(unsigned long long addr, unsigned long long data); virtual int io~write(unsigned long long addr, unsigned long long data); virtual int io~read~compare(unsigned long long addr, unsigned long long data); virtual int self~test(); virtual int reset(); virtual int cache~clear(); virtual int cache~flush(); virtual int get~err~nbr(); }; int PrintError(const string msg); #endif /* HPP~CLIENT~COMPONENT~HPP */ ANNEXE 6 1*++***************************************************** * Copyright (c) 2000 BULL - Worldwide Information Systems * All rights reserved * * Module name : example~test.cpp * Author Andrzej Wozniak * *--*****************************************************1 #include "client~registry.hpp" int Test (int argc, char* argv[]){ ///////////// CONFIGURE SECTION ///////////// ClientRegistry::QueryServerConfig(); QueryRsp &qrs~cpu~0 ClientRegistry: QueryComponent(LabelClass::CPU~O,TypeClass::TY PE~ANY); QueryRsp &qrs~mem~0 = ClientRegistry: QueryComponent(LabelClass::CMEM~O,TypeClass::T YPE~ANY); QueryRsp &qrs~cio~0 = ClientRegistry: QueryComponent(LabelClass::CIO~O,TypeClass::TY PE~ANY); QueryRsp &qrs~bridge~0 = ClientRegistry: QueryComponent(LabelClass::BRIDGE~0, TypeClass: :DUT~CORE); int err~status = 0; if(qrs~cpu~O.m~instanceLabel == LabelClass::INSTANCE~NONE){ PrintError("Component CPU~0 is missing\n"); ++err status; } if(qrs~mem~O.m~instanceLabel LabelClass::INSTANCE~ANY && qrs~cio~O.m~instanceLabel == LabelClass::INSTANCE~ANY){ PrintError("Components MEM~0 and CIO~0 are both missing\n"); ++err status; } if(qrs~bridge~O.m~instanceType != TypeClass::DUT~CORE){ PrintError("Component BRIDGE~0 of type DUT~CORE is missing\n"); ++err status; } if (err~status) PrintError("aborting test\n"); return -1; } //////// constructing client components ClientComponent* cpu~0= ClientComponent::create(qrs~cpu~0); ClientComponent* mem~0= ClientComponent::create(qrs~mem~0); ClientComponent* cio~0= ClientComponent::create(qrs-cio-0); ClientComponent* bridge~0 = ClientComponent ::create(qrs~bridge~0); /////// const int MAX~CYCLES = 4096; const unsigned long long mem~base = Ox8123456787665500ULL; const unsigned long long cio~base = OxFFFFFFFFFABCDlOOULL; if(qrs~cpu~O.m~instanceType TypeClass::DUT){ cpu~0->self~test(); cpu~0->reset(); } bridge~0->cache~clear(); for(int ii ; ii mem~write(mem~base+8*ii, Oxa5a5a5a5a5a50000ULL+ii); } if(qrs~cio~0.m~instanceLabel ! = LabelClass::INSTANCE~ANY){ cpu~0->io~write(cio~base+4*ii, Oxc3c3c3c3c3c30000ULL+ii); bridge~0->cache~flush(); for(int ii ; ii mem~read~compare(mem~base+8*ii, Oxa5a5a5a5a5a50000ULL+ii); } if(qrs~cio~O.m~instanceLabel != LabelClass::INSTANCE~ANY){ cpu~0->io~read~compare(cio~base+4*ii, Oxc3c3c3c3c3c30000ULL+ii); return cpu~0->get~err~nbr() + mem~0->get~err~nbr() + cio~0- >get~err~nbr() + bridge~0->get~err~nbr(); } ANNEXE 7 /////////////////////////////////////// FILE GENERATED by A. W. PERL SCRIPT FROM patent/sim/configs/pat03.cfg file FOR server /////////////////////////////////////// #include "server~registry.hpp" #include "server~components.hpp" ///////////// const string ServerRegistry::m~serverName = "SERVER"; const string ServerRegistry::m~configName = "pat03"; const int ServerRegistry::m~serverNumber = 1; Status InstantiateConfiguration(){ static Fbus~hwif CPU~0~XACTOR~FBUS~p (LabelClass::CPU~0, TypeClass::FBUS~type, string("top.CPU~0~XACTOR~FBUS~p")); static Cio~Dut CIO-0 (LabelClass::CIO~0, TypeClass::DUT, string ("top.CIO~0")); static Cmem~Dut CMEM~0 (LabelClass::CMEM~0, TypeClass::DUT, string("top.CMEM~0")); static Bridge~Dut BRIDGE~0 (LabelClass::BRIDGE~0, TypeClass::DUT~CORE, string("top.BRIDGE~0")); static CPU~Xactor CPU~0~XACTOR (LabelClass::CPU~0, TypeClass::XACTOR, &CPU~0~XACTOR~FBUS~p); static CPU~Monitor CPU~0~MONITOR (LabelClass::CPU~0, TypeClass::MONITOR, &CPU~0~XACTOR~FBUS~p); static Fbus~Xchg BRIDGE~0~CPU~0~FBUS~XCHG (LabelClass::BRIDGE~0-CPU~0, TypeClass::FBUS~XCHG, string("top.BRIDGE~0~CPU~0~FBUS~XCHG")); static Fbus~Xchg CPU~0~BRIDGE~0~FBUS~XCHG (LabelClass::CPU~0~BRIDGE~0, TypeClass::FBUS~XCHG, string("top.CPU~0~BRIDGE~0~FBUS~XCHG")); return Success; } ///////////// // END ///////////// ANNEXE 8 //////////////////////////////////////////////////////////// FILE "config~server~pat03~top.v" GENERATED by A. W. PERL SCRIP FROM "patent/sim/configs/pat03.cfg" file //////////////////////////////////////////////////////////// ////// 'timescale 100ps module top (); wire POWER~GOOD; wire RESET; wire CLK~33MHz; wire CLK 66MHz; Clock SysClock( .sys~POWER~GOOD (POWER~GOOD) .sys~RESET (RESET), .sys~CLK (CLK~33MHz), .sys~CLK~2X (CLK~66MHz) ); //////////////////////////////// ///// Wire Déclaration Section //////////////////////////////// // wire CLK~33MHz; // output(l) // wire CLK~66MHz; // input(3) output(l) // wire POWER~GOOD; // input(3) output(l) // wire RESET ; // input(3) output(l) wire [3:0] Wl~00~inXXack; // input(1) output(l) wire [63:0] Wl~00~inXXadr~dat; // input(1) output(1) wire [3:0] Wl~00~inXXreq; // input(l) output(l) wire [3:0] Wl~00~outXXack; // input(1) output(1) wire [63:0] Wl~00~outXXadr~dat; // input(1) output(1) wire [3:0] W1~00~outXXreq; // input(1) output (1) wire [3:0] W~00~XXack; // inout(2) wire [63:0] W~00~XXadr~dat; // inout(2) wire [3:0] W~00~XXreq; // inout(2) wire [31:0] W~00~YYadr; // input(l) output (1) wire [2:0] W~00~YYctrl; // input(1) output (1) wire [63:0] W~00~YYdata; // inout(2) wire [1:0] W~00~ZZack; // input(1) output (1) wire [15:0] W~00~ZZdata; inout(2) wire [1:0]W~00~ZZreq; // input(1) output(l) //////////////////////////////// wire W~00~clk~2xn; // input(l) output(1) wire W~00~clk~2xp; // input(l) output(1) wire W~00~clkn; // input(l) output(1) wire W~00~clkp; // input(l) output(l) wire [3:0] W~00~inXXack; // input(1) output(l) wire [63:0] W~00~inXXadr~dat; // input(l) output (1) wire [3:0] W~00~inXXreq; // input(1) output (1) wire [3:0]W~00~outXXack; // input(1) output(1) wire [63:0] W~00~outXXadr~dat; // input(l) output (1) wire [3:0] W~00~outXXreq; // input(1) output(1) wire W~00~powergood; // input(1) output (1) wire W~00~reset; // input(1) output (1) //////////////////////////////// ///// Module Instancies Section //////////////////////////////// //// BRIDGE~0~CPU~0~FBUS~XCHG -> IND~CON -> FBUS~xchg //////////// fbus~xchg BRIDGE~0~CPU~0~FBUS~XCHG ( .XXadr~dat (W~00~XXadr~dat), . XXreq (W~00~XXreq), . XXack (W~00~XXack), .inXXadr~dat (W1~00~outXXadr~dat), .outXXadr~dat (W1~00~inXXadr~dat), . inXXreq (Wl~00~outXXreq), . outXXreq (Wl~00~inXXreq), . inXXack (Wl~00~outXXack), . outXXack (W1~00-inXXack)); //// CMEM~0 -> DUT -> CMEMD cmem CMEM~0 ( . YYadr (W~00~YYadr), . YYdata (W~00~YYdata), .YYctrl (W~00~YYctrl), .clk (CLK~66MHz), . reset (RESET), . powergood (POWER~GOOD)); //// CIO~0 -> DUT -> CIOD cio CIO~0 ( . ZZdata (W~00~ZZdata), . ZZreq (W~00~ZZreq), . ZZack (W~00~ZZack), . clk (CLK~66MHz), . reset (RESET), . powergood (POWER~GOOD)); //// BRIDGE~0 -> DUT~CORE -> BRD bridge~core BRIDGE~0 ( .inXXadr~dat (Wl~00~inXXadr~dat), .outXXadr~dat (Wl~00~outXXadr~dat), . inXXreq (Wl~00~inXXreq), . outXXreq (Wl~00~outXXreq) , . inXXack (W1~00~inXXack), . outXXack (Wl~00~outXXack), . YYadr (W~00~YYadr), . YYdata (W~00~YYdata), .YYctrl (W~00~YYctrl), . ZZdata (W~00~ZZdata), . ZZreq (W~00~ZZreq), . ZZack (W~00~ZZack), .clk~2xp (W~00~clk~2xp), .clk~2xn (W~00~clk~2xn), .clkp (W~00~clkp), . clkn (W~00~clkn), . reset (W~00~reset), . powergood (W~00~powergood)); //// CPU~0-BRIDGE~0~FBUS~XCHG -> IND~CON -> FBUS~xchg //////////// - ~ fbus~xchg CPU~0~BRIDGE~0~FBUS~XCHG ( .XXadr~dat (W~00~XXadr~dat), . XXreq (W~00~XXreq), . XXack (W~00~XXack), .inXXadr~dat (W~00~outXXadr~dat), .outXXadr~dat (W~00~inXXadr~dat), . inXXreq (W~00~outXXreq), . outXXreq (W~00~inXXreq), . inXXack (W~00~outXXack), . outXXack (W~00~inXXack)); //// CPU~0 -> XACTOR-> FBUS~p //////////// fbus~p CPU~0~XACTOR~FBUS~p ( .inXXadr~dat (W~00~inXXadr~dat), .outXXadr~dat (W~00~outXXadr~dat), . inXXreq (W~00~inXXreq), . outXXreq (W~00~outXXreq), . inXXack (W~00~inXXack), . outXXack (W~00~outXXack), .clk (CLK~66MHz), . reset (RESET), . powergood (POWER~GOOD) ) ; //// BRIDGE~0~sys -> SYS~CON -> BRIDGE~sys //////////// sys~bridge #(0, 32'h00000007) BRIDGE~0~sys ( .clk~2xp (W~00~clk~2xp), .clk~2xn (W~00~clk~2xn), . clkp (W~00~clkp), . clkn (W~00~clkn), . reset (W~00~reset), . powergood (W~00~powergood), .sys~CLK~2X (CLK~66MHz), .sys~CLK (CLK~33MHz), .sys~RESET (RESET), .sys-POWER-GOOD (POWER~GOOD)); endmodule ///////////// // END ///////////// REVENDICATIONS 1. Procédé de reconnaissance automatique de configurations de simulation disponibles de circuits intégrés en projet comprenant au moins deux composants reliés entre eux directement ou indirectement, pour la vérification fonctionnelle desdits circuits par des tests de simulation, caractérisé en ce qu'il comprend : - une étape de saisie de configuration de simulation par un premier gestionnaire, appelé "gestionnaire serveur" (14) associé au simulateur, pendant l'initialisation du programme simulateur, et pendant que sont alors appelés tous les constructeurs d'instances HLL (C++) de composants présents dans le modèle global de simulation courant, chacun de ces constructeurs enregistrant (35) sa présence en transmettant ses propres paramètres (label, type, chemin HDL...) au gestionnaire serveur qui construit la table des instances des composants, - une étape d'envoi d'une requête par un deuxième gestionnaire, appelé "gestionnaire client" (11) vers le gestionnaire serveur (14) pour savoir si les composants attendus dans une configuration par le gestionnaire client (11) sont présents et quelles sont leurs positions (indiquées par les labels) et leurs types, - une étape d'envoi d'une réponse par le gestionnaire serveur (14) au gestionnaire client (11), après consultation de la table des instances des composants, la réponse contenant les instances des composants présents et/ou une notification d'erreur en cas d'absence d'un ou plusieurs composants attendus, et de mémorisation de la réponse dans au moins une table de mémorisation des modèles de configuration (12) par le gestionnaire client, - une étape de comparaison, par le gestionnaire client (11), de la réponse avec les exigences du test, suivie d'une étape d'inhibition, d'activation et/ou de modification de certaines parties du test par le gestionnaire client (11) pour adapter le test à la configuration ou signalisation d'erreur si cela s'avère impossible. 2. Procédé de reconnaissance automatique de configurations selon la revendication 1, caractérisé en ce que les configurations de simulation sont générées à partir des données de génération de configurations (MGHLL, MGHDL), avant l'utilisation du procédé selon l'invention. 3. Procédé de reconnaissance automatique de configurations selon la revendication 2, caractérisé en ce que la génération des configurations de simulation est réalisée par un opérateur. 4. Procédé de reconnaissance automatique de configurations selon la revendication 2, caractérisé en ce que la génération des configurations de simulation est réalisée par un générateur automatique de configurations (17). 5. Procédé de reconnaissance automatique de configurations selon une des revendications 1 à 4, caractérisé en ce que l'étape d'envoi d'une requête est suivie d'une étape de traduction de ladite requête, par une interface programmatique (API CONF), en langage compréhensible par le premier gestionnaire (14), et en ce que l'étape d'envoi d'une réponse est suivie d'une étape de traduction de ladite réponse, par l'interface programmatique (API CONF), en langage compréhensible par le deuxième gestionnaire (11). 6. Procédé de reconnaissance automatique de configurations selon une des revendications 1 à 5, caractérisé en ce qu'il fonctionne dans une architecture client-serveur, le premier gestionnaire (11) étant situé sur le serveur (10) et le deuxième gestionnaire (14) sur le client (13). 7. Système de reconnaissance automatique de configurations de simulation disponibles de circuits intégrés en projet pour mettre en oeuvre le procédé selon l'invention, caractérisé en ce qu'il comprend un premier gestionnaire (14) muni de moyens pour formuler et/ou analyser un message, de moyens de mémorisation, et de moyens pour remplir et consulter au moins une table dite table des instances des composants (15) présents dans chaque configuration, et en ce qu'il comprend un deuxième gestionnaire (11) muni de moyens pour formuler un message et/ou une requête, de moyens pour analyser un message, et de moyens pour remplir et consulter au moins une table de mémorisation des modèles de configuration (12). 8. Système de reconnaissance automatique de configurations selon la revendication 7, caractérisé en ce que le deuxième gestionnaire (11) est muni de moyens pour inhiber, activer et/ou modifier certaines parties du test pour adapter le test en fonction de la réponse.