FR2673015A1 - Analyse visuelle multidimentionnelle. - Google Patents

Abstract

L'invention concerne un procédé pour l'analyse graphique d'informations de réseaux de circuit, utilisant une pluralité d'indices visuels, il comporte les étapes suivantes: (a) Sélection d'un indice visuel représentatif de l'information d'état du circuit choisie. (b) Tri des informations de réseaux de circuit et affectation d'un point de départ à une position physique particulière. (c) Détermination d'une fenêtre de temps intéressante et affichage des indices visuels en effectuant une corrélation du temps et des informations de réseaux de circuit. Application à l'analyse de conception de logique et de simulateurs de circuit.

Description

La présente invention concerne, de manière

générale, des perfectionnements de l'analyse de con-

ception de logiques et de simulateurs de circuit et, plus particulièrement, une technique qui utilise des techniques de visualisation multidimensionnelle pour analyser et afficher de manière plus efficace de

grands volumes de données.

On utilise de la logique rapide et des si-

mulateurs de circuit largement dans l'industrie de l'informatique pour assister la conception de systèmes

complexes Les simulateurs à grande performance en-

gendrent des quantités énormes de données ce qui rend

impraticable la mémorisation de l'information.

Pour localiser des problèmes de manière ef-

ficace, l'information doit être visualisée pour le

concepteur lorsqu'elle est engendrée Mais la tech-

nologie courante ne permet seulement que de présenter l'information sous forme de formes d'ondes, tableaux ou en comparaison à des valeurs connues en vue de détecter des problèmes Une technique connue d'analyse de l'information sur un canal d'ordinateur est décrite dans le brevet américain 4 773 003 Ce brevet détecte un événement de ligne de signaux pré-sélectionné et

affiche l'information sur un affichage à deux dimen-

sions en vue d'une analyse manuelle ultérieure.

Les concepteurs de circuit à très haut ni-

veau d'intégration ont des difficultés quand ils cherchent à déverminer des conceptions lorsque l'on

affiche une grande quantité d'informations sans di-

rection ou information résumée Par exemple il est très difficile pour un concepteur d'analyser l'effet de la réalimentation sur toutes les macros Il est

souvent très difficile de suivre la source d'un pro-

blème jusqu'à sa cause Un arbre précédent de réseau pour le problème qui vient d'être décrit peut être très grand et relativement profond L'arbre croit également rapidement pour obscurcir encore plus la

source du problème.

Les affichages de formes d'ondes de type

connu fournissent une aide au concepteur dans l'ana-

lyse de réseaux Cependant, ils se focalisent sim-

plement sur un aspect du problème à un instant donné et n'ont aucune capacité de corrélation de fonctions multiples afin de déchiffrer la source commune du problème. Des programmes de formes d'ondes sont offerts par de nombreux vendeurs d'association de

conception d'ingéniérie (Engineering Design Associa-

tion); c'est le cas en particulier du simulateur LSIM du ZYCAD, d'IKOS et de Mentor Une approche standard décrit l'information sur des formes d'ondes à deux

dimensions pour chaque réseau en fonction du temps.

Les représentations graphiques sont affichées sur un

dispositif graphique en vue d'une interrogation ma-

nuelle ultérieure On trace jusqu'à cinquante réseaux en direction verticale alors que le temps est décrit à partir d'une origine zéro du côté le plus à gauche La

Figure 1 représente un exemple d'un affichage de ré-

seaux de la technique antérieure Pour déverminer de nombreux réseaux et visualiser de manière globale l'information de simulation, une nouvelle approche est nécessaire. L'invention est constituée par un ordinateur et un appareil de visualisation graphique destinés au traitement de grandes quantités d'informations et à

l'affichage graphique de ces informations Le traite-

ment par logiciel de l'information et l'affichage

graphique de l'information traitée attirent l'atten-

tion sur des zones suspectes en employant des couleurs et des techniques d'ombrage pour attirer rapidement

l'attention de l'utilisateur sur des zones à problème.

D'autres caractéristiques et avantages de

l'invention ressortiront de la description qui suit

d'un exemple préféré de réalisation de l'invention,

faite en se référant aux dessins ci-annexés sur les-

quels: la Fig 1 représente un exemple de la technique connue d'un affichage de formes d'ondes de réseaux.

la Fig 2 A est une illustration d'un af-

fichage de plusieurs réseaux conformément à la pré-

sente invention.

la Fig 2 B est un agrandissement d'un affichage de formes d'ondes d'un réseau faisant partie d'un affichage de plusieurs réseaux conformément à la

présente invention.

la Fig 3 est un organigramme représentant la logique destinée à mettre en oeuvre un affichage de

plusieurs réseaux conformément à la présente inven-

tion. la Fig 4 A décrit un affichage de tous les

réseaux conformément à la présente invention.

la Fig 4 B décrit un affichage de tous les réseaux à l'instant (T) conformément à la présente invention. la Fig 4 C décrit un affichage de tous les réseaux à un instant (T) conformément à la présente

invention.

la Fig 5 illustre une représentation tri-

dimentionnelle d'un affichage de tous les réseaux con-

formément à la présente invention.

la Fig 6 est un organigramme montrant la logique utilisée pour mettre en oeuvre un affichage de

tous les réseaux conformément à la présente invention.

la Fig 7 A est un schéma de réalisation du

concept physique d'un semiconducteur.

la Fig 7 B est un affichage de tous les

réseaux du semiconducteur décrit à la Fig 7 A confor-

mément à la présente invention.

la Fig 8 est un affichage de tous les réseaux de l'horloge avec des relations spatiales

conformément à la présente invention.

la Fig 9 est un affichage de tous les ré-

seaux de deux caractéristiques conformément à la pré-

sente invention.

la Fig 10 est un affichage de tous les réseaux de deux caractéristiques avec une sélection différente de la compression de l'espace de temps

conformément à la présente invention.

la Fig 11 est un affichage de tous les réseaux pour tous les changements du temps en temps réel avec une densité de couleur et une relation en x,

y conformément à la présente invention.

la Fig 12 est un schéma-bloc du matériel

conforme à la présente invention.

Si l'on part du simple affichage de réseau multiple à deux dimensions qui est représenté à la

Fig 1, une simple étape initiale entraîne la com-

pression des tracés verticaux jusqu'à ce que tous les tracés soient comprimés Ensuite, la transition de

l'état le plus bas à l'état le plus haut sera repré-

sentée sous la forme d'une variation de couleur de ligne et non d'une déviation verticale d'une forme d'onde polygonale Au fur et à mesure que des états de

réseau sont tracés sur un écran, le facteur de limita-

tion est constitué par le nombre de lignes de balayage sur l'affichage La limite est obtenue lorsque les états logiques sont représentés par un seul pixel ou une seule ligne de pixels et sont codés en utilisant

la couleur comme facteur de différenciation.

La forme d'onde du réseau d'horloge de la

Fig 1, le réseau 10 nécessite cent pixels pour re-

présenter la transition d'état logique En employant la technique qui vient d'être décrite, la transition de montée et de descente du réseau 20 de la Fig 1 est représentée sur la Fig 2 au moyen de différence de couleur sur une ligne de balayage horizontal Deux pixels verts sont représentatifs de l'état bas ensuite

quatre pixels rouges sont utilisés pour l'état indé-

fini et quatre pixels bleus pour l'état haut Les pi-

xels verts sont représentés sur la Fig 2 par des zones rectangulaires blanches alors que les pixels rouges sont représentés par de légères ombres de gris et les pixels bleus sont représentés par des zones

noires sur la Fig 2.

Sur la Fig 2 le temps est tracé sur l'axe des X alors que chaque ligne de l'axe des Y est un

réseau séparé Ainsi par exemple, en 30 on a repré-

senté une transition du niveau logique haut au niveau logique indéfini par le fait que la zone noire-se

change en gris.

Sur la Fig 2 chaque réseau occupe une seule ligne de balayage Ainsi un groupe de réseaux peut

être visible en tant que zone rouge 40 sur l'affi-

chage. L'affichage qui en résulte comporte des taches de couleur qui changent de la gauche vers la droite au fur et mesure que la simulation se réalise

dans le temps.

En permettant à l'utilisateur de choisir l'ordre vertical de l'affichage de réseaux, par exemple réseau précédent, réseau suivant ou distance

du port d'entrée ou du port de sortie, on crée diffé-

rentes images pour améliorer le processus de visua-

lisation. Si l'on se réfère à la Fig 2, un réseau de sortie apparaît près du bas 20 Le réseau de sortie 20 est indéfini au temps zéro 25 mais il devient défini au temps quatre 27 Le réseau représente un problème typique de réalimentation d'un microprocesseur ou un appel d'une adresse invalide L'utilisateur note que le réseau devient indéfini au temps cinq 30 mais la

cause n'est pas apparente si l'on se base sur l'af-

fichage de la Fig 1 Lorsque l'on utilise des tech-

niques de l'art antérieur, telles que les formes d'ondes représentées sur la Fig 1, l'utilisateur devra sélectionner le réseau de sortie spécifique et commencer ensuite à suivre en arrière à travers de nombreuses fenêtres et réseaux Sur la Fig 2, la capacité de visualiser beaucoup plus de réseaux

fournit une vue intelligible d'une pluralité de ré-

seaux et la capacité de localiser la source d'une

erreur rapidement et précisément.

De nombreuses routines de tracé de lignes sont disponibles actuellement pour mettre en oeuvre les appels de tracé de lignes de l'invention Des

progiciels tels que le Graphics Programmer's Hie-

rarchical Interactive Graphic System (Gra Phigs) ou le

IBM 3277 Graphics Attachment PRQ décrit dans la pu-

blication de chez IBM SH 20-2137 fournissent le type de supports graphiques nécessaires pour mettre en oeuvre l'invention Les progiciels graphiques sont conçus

pour travailler sur de nombreux processeurs et appa-

reils de visualisation de type classique tels que le T

PC/RT IBM avec son affichage graphique à haute réso-

lution correspondant ou le contrôleur IBM 5085 relié à

une unité principale System/370 pour commander un af-

fichage IBM 5080 comme représenté sur la Fig 12.

La logique destinée à la mise en oeuvre de l'invention est représentée sur la Fig 3 Dans le

bloc de fonction 100 on détermine le mappage du ré-

seau L'information concernant la couleur ou l'inten-

sité de chaque état électrique et le nombre maximal de réseaux à afficher dans l'image de trame est définie de manière préalable par l'utilisateur en liaison avec le bloc de fonction 110 Ensuite les emplacements de réseaux sont alloués par des voisins les plus proches au niveau logique ou physique dans le bloc de fonction

120 L'utilisateur doit ensuite sélectionner le sous-

ensemble de réseaux qui peut être affiché sur le dis-

positif d'affichage dans le bloc de fonction 130.

La fenêtre de temps intéressante est choisie

ensuite dans le bloc de fonction 140 Après, on cal-

cule le nombre d'étapes temporelles dans le bloc de fonction 150 et on calcule la variation (delta) de mouvement dans la direction horizontale pour chaque

étape dans le bloc de fonction 160.

On utilise une boucle pour traiter chaque simulation de donnée de réseau lorsque le temps s'écoule en commençant au bloc de fonction 170 dans lequel l'affichage est réinitialisé pour la coordonnée horizontale particulière (x) Le bloc de fonction 180 réinitialise le pointeur de données de sous-ensemble au début du côté gauche de l'affichage et le bloc de fonction 190 incrémente l'affichage à l'emplacement vertical (y) suivant en vue d'afficher l'état de réseau suivant Le réseau est incrémenté dans le bloc de fonction 200 pour obtenir l'information suivante de

simulation de réseau.

Ensuite on introduit une boucle intérieure

au niveau du bloc de fonction 210 pour traiter l'in-

formation de transition de réseau Le bloc de fonction 210 incrémente par l'intermédiaire de l'information de transition jusqu'à ce que le réseau soit complet comme cela est testé dans le bloc de décision 250 Un test de transition dans les données de réseau est réalisé dans le bloc de décision 230 et l'information est tracée en 240 si l'on a détecté une transition dans le

bloc de décision 230.

A la suite de l'étape de traçage au bloc de

fonction 240 ou de la détection d'une absence de tran-

sition au bloc de décision 230, la commande retourne

au bloc de décision 250 pour déterminer si le traite-

ment du réseau est terminé Si cela n'est pas le cas, la commande retourne à la boucle intérieure au bloc de fonction 210 afin de continuer à traiter l'information

de réseau S'il est terminé, alors la commande re-

tourne au bloc de fonction 170 pour incrémenter au

niveau du réseau suivant Le traitement continue jus-

qu'à ce que l'information soit stoppée ou que le

processus soit interrompu.

L'affichage de plusieurs réseaux permet à un concepteur d'avoir une vue sur des grandes macros de puce qui fournissent un résumé de son comportement en regardant une image graphique Bien que l'affichage de plusieurs réseaux qui vient d'être-décrit soit une aide, beaucoup de conceptions de systèmes dépassent mille réseaux Ainsi un utilisateur devrait feuilleter

des dizaines ou des centaines d'affichages de plu-

sieurs réseaux pour essayer d'obtenir une vue générale ou pour trouver des conditions d'exception Ceci est impraticable. Pour voir une vue globale du système, les

réseaux doivent être représentés par un volume tri-

dimensionnel dans l'espace et dans le temps sur l'af-

fichage graphique Le volume tri-dimensionnel dessine le réseau sous forme d'une ligne dans un réseau à trois dimensions avec des changements de couleur pour

les transitions d'état.

Dans certaines des figures suivantes, la ligne qui représente un état de réseau est représentée par un grand cylindre dont le rayon est une fonction du nombre de réseaux que l'on voudrait afficher à un

instant juste comme dans l'affichage de plusieurs ré-

seaux o les lignes ont une largeur qui est fonction du nombre de réseaux à afficher Un exemple est celui de la figure 4 A qui décrit l'affichage de tous les réseaux pour l'exemple précédent L'affichage peut être présenté de manière panoramique par la face de réseau du cube à un instant T 400 Il faut noter qu'à l'instant (T) le dernier réseau qui a commencé à un état indéfini atteint un état défini au sommet 420 du

cône 430.

La face ou le plan à l'instant T est appelé "tous les réseaux" à un instant T dans le cube de tous

les réseaux pour tous les instants tel qu'il est re-

présenté à la figure 4 B par la référence 450 Ensuite, au lieu de dessiner le cube entier, la vue provenant de la face droite peut être dessinée comme étant

l'état de tous les réseaux à l'instant T comme repré-

senté à la figure 4 C La taille de tous les réseaux jusqu'à l'instant (T) peut être augmentée pour remplir

l'affichage graphique, le contour du cube étant main-

tenu dans toutes les figures pour obtenir la référence

visuelle 401.

Le plan de tous les réseaux à l'instant (T) *-o fournit un point de départ pour réaliser une analyse ultérieure en utilisant des outils conventionnels tels que l'affichage de formes d'ondes pour analyser le

sous-ensemble spécifique d'information La caracté-

ristique de différenciation déterminante est que cette

technique fournit à l'utilisateur un affichage du sys-

tème entier En se basant sur l'affichage du sytème, l'utilisateur peut s'intéresser à une zone de problème

et isoler rapidement ce problème.

On va maintenant essayer de montrer comment un utilisateur pourrait visualiser les séries de tous

les réseaux à des instants s'incrémentant avec recou-

vrement et obtenir une impression visuelle telle que représentée sur la Fig 11 Par exemple, on suppose que le concepteur voudrait explorer les états "actifs" ou "à haut niveau de puissance" et qu'un réseau débute la réaction de chaîne comme représenté par le sommet

du cône 460 sur la Fig 4.

Si l'on regarde les suivants de ce réseau, on peut imaginer que le cône des successeurs 470 pourrait changer complètement pour passer à un état de haut niveau de puissance Si l'on regarde l'affichage de tous les réseaux à un instant quelconque tel que T, comme représenté sur le Fig 4 C, un cercle 460 est

affiché en tant que tranche de 470.

Si l'on illumine chaque affichage de tous les réseaux à l'instant t (n), lorsque N augmente dans

le temps, l'un après l'autre, ou si l'on fait un trai-

tement de moyenne de l'ensemble de tous les réseaux,

la visualisation des images par le spectateur va réa-

liser une moyenne de l'ensemble des réseaux, le centre

460 apparaîtra en rouge 1110, mais la bordure exté-

rieure apparaîtra seulement en rouge pour un seul degré de temps 1120 Ainsi, l'image résultante aura moins de couleur dans la zone extérieure du fait d'un affichage d'une durée de un/dixième En outre, la couleur rouge s'accroîtra en intensité comme si l'attention était attirée sur le centre 1110 La zone la plus chaude du circuit passera clairement par la zone rouge Les cercles solides 1130 et 1140 re-

présentent des réseaux qui ne changent jamais d'état.

Pour mettre en oeuvre l'affichage de tous les réseaux à tout instant, on utilise un logiciel de mappage à

trois dimensions tel que le support fourni sous Ma-

thematica, qui est décrit dans "Mathematic, A System For Doing Mathematics By Computer", Stephen Wolfram,

1988, ISBN 0-201019334-5.

La logique pour l'affichage de tous les ré-

seaux est très similaire à la logique utilisée pour

l'affichage de plusieurs réseaux Les lignes sont tra-

cées dans l'espace à trois dimensions au lieu de l'es-

pace à deux dimensions et l'utilisateur choisit un

point de vue pour faciliter une perspective correcte.

Un point clé de ce procédé est la sélection de la couleur appropriée ou de la non couleur pour faciliter des vues à travers l'objet à trois dimensions Par

exemple, si l'on est intéressé par les réseaux indé-

finis ou les réseaux qui n'ont jamais de transition,

ils doivent être les seuls réseaux dessinés pour évi-

ter un encombrement de l'objet Il peut également être utile de faire passer les données de transition à une routine d'ombrage de surface à trois dimensions et/ou

de dessiner l'objet 3 D sous forme d'une image stéréo-

graphique pour aider lors du processus de visuali-

sation.

La Fig 5 montre seulement des états non définis de réseaux et des états non changeants de tous

les réseaux Les réseaux qui sont indéfinis sont re-

présentés par les cônes référencés 300, 333 et 340.

Lorsque le temps augmente de la gauche vers la droite, les réseaux qui étaient non définis deviennent définis au sommet du cône référencé 301 Les cylindres 310 et 320 représentent des réseaux qui n'ont jamais changé d'état et les cônes qui augmentent en taille de la gauche vers la droite 330 et 340 représentent des réseaux qui sont en train de devenir indéfinis lorsque

le temps augmente.

L'invention peut également identifier des points chauds de puissance, un manque d'activité de réseau et un bruit de circuit pour une couche physique d'une puce Tous les réseaux à l'instant T décrivent de manière graphique la fonction intéressante, dans ce cas des points chauds de puissance au-dessus de chacun des réseaux intéressants Le point clé de cette analyse est la création d'un mappage de la puce physique dans un mappage d'espace "tous les réseaux" qui permet au concepteur de trouver facilement des

endroits à problème sur la puce.

Il n'y a plus besoin de traitement préalable

pour l'analyse de l'activité du réseau, pour la puis-

sance ou le courant du réseau, le mappage en couleur peut être différent Par exemple, un état logique zéro pourrait être à un état de puissance supérieur ou à un

état logique un et ainsi on pourrait choisir la cou-

leur rouge pour le circuit spécifique se trouvant à

l'état zéro.

Pour l'analyse de la commutation de la va-

riation (delta) de courant, les instants de transition du réseau peuvent être accentués par des changements de couleur Les résultats peuvent être affichés en commençant à l'instant zéro et en affichant chaque plan à des étapes de temps croissantes La vitesse des variations d'affichage est également réglable pour réaliser une opération de moyenne sur les couleurs et

obtenir une sensation globale de l'état de la machine.

Par exemple, si les réseaux d'une zone spécifiques

sont généralement à l'état de niveau élevé de puis-

sance, la couleur intégrée de cette zone peut être rouge Les états de réseau peuvent être soumis à une opération de moyenne, de manière automatique ou au fur et à mesure que les réseaux sont tracés sur l'écran, mais il est bien meilleur de permettre à l'utilisateur de surveiller l'affichage pour les exceptions et de

traiter l'information visuelle de manière dynamique.

La Fig 6 représente de manière détaillée la

logique associée au traitement de tous les réseaux.

Cette logique est identique à l'affichage de plusieurs

réseaux, à l'exception de la boucle additionnelle des-

tinée à remplir la zone tri-dimensionnelle dans les blocs de fonction 430 et 440 Les réseaux sont classés préalablement dans le bloc de fonction 320 de telle manière que le point de départ (x, y) du réseau soit une fonction linéaire de l'emplacement du circuit de pilotage primaire (cx, cy) se trouvant sur la puce ou sur le dessin de la plaque L'étape d'initialisation nécessite également que l'utilisateur sélectionne une perspective pour visualiser l'affichage tri-dimensionnel et décide si un affichage statique est plus efficace ou répétitif lorsque l'on visualise tous les réseaux à l'instant t (n) lorsque N croit

avec le temps.

Si ceci est nécessaire, la fonction du temps (t) est représentative d'un petit sous-ensemble de temps pour afficher tous les réseaux à l'instant t En outre, le point de départ X, Y, t peut être remis à

zéro pour superposer des affichages de tous les ré-

seaux au lieu de les étaler dans un espace 3 D Ceci facilite le traitement dynamique de l'opération de

moyenne de l'état du réseau.

Pour un exemple de circuit électrique, l'affichage de tous les réseaux réalisera les étapes suivantes: 1) Sélection de la couleur ou de l'intensité

pour représenter chaque étape électrique.

2) Sélection des états qui nécessitent la transparence. 3) Sélection de la fenêtre de l'utilisateur

(X, Y, z) dans un espace tri-dimensionnel.

4) Décision quant au nombre maximal de ré-

seaux à afficher.

) Allocation aux réseaux d'une position

physique et assignation des points de départ X, Y, 0.

6) Création d'un ensemble de points phy-

siques si nécessaire.

7) Sélection d'un sous-ensemble de points

qui va s'adapter sur l'affichage.

* 8) Détermination de la fenêtre de temps

intéressante.

9) Choix du taux du temps par rapport à la

trame spatiale.

) Calcul du nombre d'étapes de temps et de

delta T par intervalle de temps.

11) Obtenir pour chaque donnée de réseau le résultat d'affichage a Index pour le nouveau point de départ

X, Y, O représentant le point de départ du réseau.

b Réinitialisation du compteur de

décalage d'état de réseau ou du pointeur de transi-

tion. c Faire pour des transitions de réseau:

1) Incrémenter le pointeur de ré-

seau pour obtenir l'ensemble suivant de données de si-

mulation de réseau.

2) Réaliser un test de transition

dans les données de réseau et modifier la couleur.

3) Tracer la valeur de segment de

ligne pour la dernière transition dans l'espace tri-

dimensionnel. 4) Tracer le volume si il existe une compression ou une expansion de temps dans l'espce tri-dimensionnel. ) Sortir de la bouche si l'on a atteint la limite des données ou de la fenêtre de temps.

d Fin de traitement (transition de ré-

seau).

12) Fin de traitement (données de réseau).

Une solution alternative possible pour amé-

liorer la visualisation utilise une technique pour afficher un ensemble de segments de ligne pour chaque réseau L'affichage consiste en une zone polygonale qui représente l'état du réseau à l'instant T et la forme représente tous les points physiques se trouvant dans un réseau spécifique sur une puce, une carte ou une plaque Ensuite, une amélioration supplémentaire fournit une compression de temps si bien que le plan de tous les réseaux à l'instant T devient le plan de

tous les réseaux aux instants t (n) à t (m).

Par exemple, supposons que la forme de la zone soit un rectangle, supposons en outre que ce rectangle représente 16 étapes de temps, le temps étant balayé sur le rectangle en affichant les 16 étapes de temps et formant un réseau de couleurs

représentant la fenêtre de temps L'affichage résul-

tant des états de simulation de la puce effectue une corrélation entre l'image de contraste de la tension du faisceau d'électrons sur la puce physique en fonctionnement avec le taux de rafraîchissement de

l'affichage de trame.

La Fig 7 A représente un volume délimité par une frontière 700 comprenant un sous-volume référencé 702 Le dessin de la puce physique est représenté sur la Fig 7 B sous la référence 710 Le mappage à partir de l'emplacement x, y des pilotes de réseau sur la puce physique est indiqué par 720, 721, 722 Il est clair que les réseaux se trouvant dans la macro 701 sont les seuls réseaux de la puce qui commencent à l'état indéfini 730 et deviennent définis à un instant

un peu ultérieur 740.

Etant donné l'emplacement x, y, z de ce point dans le volume spatial du réseau graphique 700, on peut localiser le point xl 741, yl 742 sur la puce, ainsi le réseau était le dernier réseau à revenir à un état défini En outre, cet événement s'est révélé de

manière claire à l'instant 743.

Les trois figures ombrées 8, 9 et 10 repré-

sentent les lignes d'état de réseau sous la forme de cylindres pour mettre en valeur le réseau et le rendre clairement distingable Le réseau unique représenté est une forme d'onde d'horloge et le réseau est défini

et oscille à chaque instant.

La Fig 8 montre une zone délimitée par une frontière 800 qui est un espace de tout le réseau Le

volume contient un sous-volume référencé 802 et repré-

sentant un réseau unique Ce réseau est représenté par 16 cylindres avec du blanc et du noir alternés lorsque le réseau change son état logique dans le temps La forme choisie s'adapte à la forme d'un réseau se trouvant sur une puce (forme S) La période de temps allant de t O à t 8 augmente d'une seconde A l'instant

t 8, le réseau est à l'état logique zéro et est repré-

senté tout blanc. Du fait que la forme de l'affichage du ré-

seau représente la forme du dessin physique, l'utili-

sateur peut voir la totalité du volume physique et l'état logique du réseau Les Fig 9 et 10 mettent en valeur une autre caractéristique La forme choisie est

adaptée à la forme d'un réseau sur une puce (rec-

tangle) et le taux d'horloge du réseau est adapté à la

sélection de la description du temps En permettant à

l'utilisateur de commander cette compression ou cette

expansion du temps dans l'affichage spatial, l'uti-

lisateur peut rechercher des réseaux qui l'aident à comprendre la manière dont le système fonctionne Dans la Fig 9, au lieu d'avoir les plans représentant une période de temps comme dans la Fig 8, le temps peut être comprimé ou représenté comme étant balayé sur l'image.

De nouveau un volume délimité par une fron-

tière 900 pour tous les réseaux contient également un sous-volume indiqué sous la référence 902 et représentatif d'un réseau unique représenté avec 16 pixels La trame du temps est représentée avec la référence de temps 903 Le dernier point du temps est 910 Une sélection différente de la compression

spatiale du temps est utilisée pour créer la Fig 10.

On peut noter les différences d'apparences et les différents réseaux à partir du côté 1010 et de la vue

terminale 1020.

On fournit ci-après un mode de réalisation de l'invention qui a été développé par l'inventeur pour analyser et déverminer des puces de la technique

à très haut degré d'intégration (VLSI), afin de cla-

rifier la-logique détaillée de la présente invention.

Cette logique est présentée par l'intermédiaire d'un listage d'un code source en Pascal couramment utilisé

par IBM.

1 8 2673015

SA 9-89-070

CONST /* MULTI-DIMENSIONAL ANALYSIS DISPLAY CODE */

ALVL = 2; * ACTIVE LEVEL COLOR *)

ILVL = 4; (* NON-ACTIVE LEVEL COLOR *)

ULVL = 1; (* UNDEFINED LEVEL COLOR *)

DLVL = 3; (*DELAY LEVEL COLOR*)

(*

0 = WHITE

1 = RED

2 = GREEN

3 = YELLOW

4 = BLUE

= MAGENTA

6 = CYAN

7 = WHITE

*)

%page

(* *)

(* ROUTINE NAME: PREP_NETS *)

(* *)

(*ROUTINE TYPE: PROCEDURE *)

(* *)

(* FUNCTION: THIS PROCEDURE INITIALIZES DISPLAY PARAMETERS IN THE *)

(* EDIT RECORDS OF NETS IN THE VIEWED LIST *)

(*PARAMETERS: *)

(* 1) VCNTNUMBER OF NETS TO PROCESS *)

(*RETURNS: NONE *)

PROCEDURE PREP_NETS (CONST VCNT: INTEGER);

VAR

I,R: INTEGER;

LP: PEDIT_REC;

BEGIN (* begin PREPNETS *)

LP:= HEADPTR;

FOR I:= 1 TO VCNT DO (* SCAN THE NET LIST *)

BEGIN

REPEAT

LP:= LP-> CHAIN_FORWARD;

UNTIL (NET_VIEW IN LP-> NET_FLAGS); (* UNTIL VIEWED NET *)

SLOT( I):= LP; (* SAVE NET POINTER *)

R:= 1;

(* GROUP REGISTERS TOGETHER FOR DISPLAY

-j

SA 9-89-070

IF REG_DEF IN LP-> NET_FLAGS

THEN BEGIN

REPEAT (* SCAN FOR END OF REGISTER *)

LP:= LP-> CHAIN_FORWARD;

R: R + 1; (* INCREMENT REGISTER COUNT *)

UNTIL REGDEF IN LP-> NETFLAGS;

IF REG_REV IN LP-> NET_FLAGS (* IF REVERSED REGISTER *)

THEN SLOT( I):= LP; (* THEN UPDATE NET POINTER*)

END; (* END IF THEN A REGISTER *)

WITH SLOT( I)-> DO

BEGIN

REGCNT:= R; (* SAVE REGISTER LENGTH *)

IF (LENGTH (NETNAME_PTR-> NAM) > DNAME_LENGTH) AND

(NOT NM_LEN_SET)

THEN DNAME_LENGTH:= LENGTH (NETNAME_PTR-> NAM); END;

END; %PAGE

(* INITALIZE DISPLAY PARAMETERS *)

SLOT( VCNT+ 1):= TAILPTR; (* FLAG END OF VIEW LIST *)

YINCW:= 4;

MAXWAVE:= PLOTHEIGHT DIV 4;

IF DISPLAY_WAVE

THEN PLOTSTART:= 2 * XCHARSIZE

ELSE PLOT_START:= (FUNCTION_LEN + DNAME_LENGTH + 8) *

XCHARSIZE;

PLOTLENGTH:= XMAX PLOTSTART;

IF QPARM ='D'

THEN RETURN;

(* INITALIZE WINDOW CONTENTS *)

WRITESTR (BUFFER S,DNAME_LENGTH:-2);

R:= FSWRITEW ( 213,$REP,BUFFER);

if CYCLEMARK (* if cycle marks on*) then BUFFER S:= 'ON' (* then set field on *)

SA 9-89-070

else BUFFER S:='OFF'; (* else set field

R:= FSWRITEW ( 209,$REP,BUFFER);

if VIEWLEFT (* if view first 3: then BUFFER S:= 'FIRST' (* then set fie else BUFFER S:= 'LAST'; (* else set field

R:= FSWRITEW ( 212,$REP,BUFFER);

IF DISPLAYWAVE

then BUFFER S:= 'Drawing Waveforms ' else BUFFER S:= 'Drawing Character Display ';

R:= FSWRITEW ( 200,$REP,BUFFER);

SET_WINDOWS (SON); (* TURN C

END; (* end PREP NETS to off*) 2 chars eld first d last *) *) *)

)N DISPLAY WINDOWS *) S *)

%page

(* *)

(* ROUTINE NAME: TIME)

(* ROUTINE TYPE: FUNCTION)

(* FUNCTION: THIS PROCEDURE WILL CALCULATE THE TIME DEPENDING ON

(* THE DISPLAY/DATA MODE.

(*

(* PARAMETERS:

(* 1) CYCLE CYCLE NUMBER

(* 2) LEVEL LEVEL NUMBER

(*

(* RETURNS:

(* 1) CONVERTED TIME VALUE

(* ) )

FUNCTION TIME (CONST CYCLE,LEVEL: INTEGER): INTEGER;

ENTRY;

(* FIND THE TIME OF THE CURRENT CYCLE/LEVEL *)

BEGIN (* BEGIN TIME *)

IF MODE = DEBUG (* IF DEBUG MODE *)

THEN TIME:= ((CYCLE START_CYCLE) * LEVELCYCLE) +

LEVEL START_LEVEL

ELSE TIME:= CYCLE START_CYCLE; (* ELSE STROBE MODE

)

SA 9-89-070

(* END TIME

(* ROUTINE NAME: BACKSCALE

(* ROUTINE TYPE: PROCEDURE

(* ROUTINE TYPE: PROCEDURE

(* ) )

(* FUNCTION: THIS PROCEDURE WILL CALCULATE THE CYCLE AND LEVEL

)

(* NUMBERS FROM THE GIVEN TIME *)

(* PARAMETERS:)

(* 1) T TIME VALUE TO BE BACK-SCALED *)

( *)

(* RETURNS:

(* 1) CYCLE CYCLE NUMBER

(* 2) LEVEL LEVEL NUMBER

(, *)

PROCEDURE BACK_SCALE (CONST T: INTEGER;

CONST FLDNM: FSFLDE;

VAR CYCLE: INTEGER;

VAR LEVEL: INTEGER); ENTRY;

VAR

R: INTEGER;

(* SCALE THE CURRENT TIME BACK TO CYCLE AND LEVEL NUMBERS

BEGIN (* begin BACKSCALE *) IF MODE = $DEBUG (* if debug mode THEN BEGIN (* then scale cycle/level *)

R:= T + START_LEVEL -1;

CYCLE:= R DIV LEVELCYCLE + STARTCYCLE;

LEVEL:= R MOD LEVEL_CYCLE + 1;

END (* end if then *) ELSE BEGIN (* else strobe mode*)

CYCLE:= T + START_CYCLE;

LEVEL:= STROBE_VALUE;

END; %page

(* *)

) )

SA 9-89-070

END;

IF (FLDNM = 0) OR

(QPARM = 'D')

THEN RETURN;

WRITESTR (BUFFER S,CYCLE:-5);

R:= FSWRITEW (FLDNM,$REP,BUFFER);

WRITESTR (BUFFER S,LEVEL:-5);

R:= FSWRITEW (FLDNM+ 1,$REP,BUFFER);

END; (* end BACK__SCALE *) %page

(* ROUTINE NAME: READ_DATA *)

(* *)

(* ROUTINE TYPE: FUNCTION *)

(* *)

(* FUNCTION: THIS PROCEDURE WILL READ THE LSM DATA FOR A GIVEN)

(* TIME SLOT INTO AN ARRAY FOR QUICK REFERENCE *)

(* *)

(* PARAMETERS:)

(* 1) T THE TIME NUMBER OF THE DATA REQUIRED *)

(*RETURNS: NONE *)

(*)

PROCEDURE READDATA (CONST T: INTEGER); ENTRY;

VAR

I,RECNO: INTEGER;

HWPOINTER: INTEGER;

(* CALCULATE THE RECORD AND WORD POINTER *)

(************"***"*******'****'*"**"**'*'***''****'*******)

BEGIN (*BEGIN READ_DATA *

IF T = WAVE_TIME THEN RETURN; (* IF RECORD IS CURRENT *)

WAVE_TIME: T; (* SAVE THE TIME NUMBER*)

HW _POINTER:= ((T * DATASIZE) MOD 128) + 1;

RECNO:= ((T * DATA_SIZE) DIV 128) + 2;

SA 9-89-070

IF RECNO ^= WAVERECNO (* IF NEW RECORD NEEDED *)

THEN BEGIN (*THEN: *)

WAVERECNO:= RECNO; (* SAVE NEW RECORD NUMBER *)

SEEK (LSMDOUT,WAVE_RECNO); (* SEEK TO GIVEN RECORD *)

GET (LSMDOUT); (* READ THE RECORD *)

END;

(* READ IN THE REQUIRED RECORD(S) *)

(****************************************f******************************

FOR I:= 1 TO DATA_SIZE DO (* READ THE LSM DATA *)

BEGIN

WAVEFORM RECDATA( I):= LSMDOUT-> RECDATA( HW_POINTER);

HW_ POINTER:= HWPOINTER + 1;

* IF HW_POINTER > 128 (* IF NEXT RECORD REQUIRED *)

THEN BEGIN (*THEN READ NEXT RECORD *)

HWPOINTER:= 1;

WAVERECNO:= WAVERECNO + 1;

GET (LSMDOUT);

END;

END;

END; (* END READ_DATA *)

%page

(* *)

(* ROUTINE NAME: NETVALUE *)

(* ROUTINE TYPE: FUNCTION *)

3 O (*FUNCTION: THIS PROCEDURE WILL FIND THE CURRENT NET'S VALUE *)

(*PARAMETERS: *)

(* 1) PTR POINTER TO EDITOR RECORD *)

(* *)

(*RETURNS: *)

(* 1) CHARACTER REPRESENTING VALUE OF NET AT CURRENT TIME *)

function NETVALUE (const PTR: PEDIT_REC): CHAR; ENTRY; VAR

SA 9-89-070

LSMW: INTEGER;

LSMBIT: INTEGER;

(* FIND THE VALUE OF THE NET AT THE GIVEN TIME *)

begin (* BEGIN NETVALUE *)

IF (NET_GAP IN PTR-> NETFLAGS) (* IF GAP RECORD *)

THEN NETVALUE:= ' '

ELSE BEGIN

LSMW:= PTR-> IAX;

LSMBIT:= 14 ( 2 * (LSMW MOD 8)); (* calculate bit shift *) LSMW:= (LSMW DIV 8) + I; (* calculate word index *)

LSMW:= (WAVEFORM RECDATA( LSMW) >> LSMBIT) AND '0003 'X;

IF ((LSMW AND '0001 'X) ^= 0) OR(* IF UNDEFINED OR *)

(PTR-> NETNAME_PTR-> NAM( 1) -= '-') (* ACTIVE LEVEL PLUS *)

THEN NETVALUE:= LSMCHAR( LSMW)

ELSE NETVALUE:= LSMCHAR( LSMW && 2);

END; end; (* END NETVALUE *) %page

(* ROUTINE NAME: REGVALUE *)

(* *)

(* ROUTINE TYPE: FUNCTION *)

(* FUNCTION: THIS PROCEDURE WILL FIND THE CURRENT NET'S VALUE AS *)

(* EITHER A SINGLE NET OR AS A REGISTER *)

(* *)

(* PARAMETERS: *)

(* 1) PTR POINTER TO EDITOR RECORD *)

(*RETURNS: *)

(* 1) STRING OF CHAR(S) REPRESENTING THE VALUE *)

function REGVALUE (const PTR: PEDITREC): STRING( 255); ENTRY;

TYPE

SA 9-89-070

HEXCHARS = ARRAY ( -1 15) OF STRING( 1);

CONST

MINU 51 =-1;

HEX =HEXCHARS(*,1,'2,3,4,5,6,7,

VAR

I,REG: INTEGER;

COUNT: INTEGER;

LP:PEDIT_REC;

TSTR: STRING( 255);

NETCHAR: CHAR;

begin (* BEGIN REGVALUE *)

(* FIND VALUE OF A REGISTER AT THE GIVEN SLOT *)

IF NOT (REGDEF IN PTR-> NET_FLAGS) (* IF NET IS SINGLE VALUE *)

THEN REGVALUE:= STR (NETVALUE (PTR))

ELSE WITH PTR-> DO

BEGIN

TSTR:="; (* CLEAR RESULT STRING *)

COUNT:= REGCNT;

LP:= PTR;

IF (ANLGREG IN NETFLAGS) OR (* IF ANALOG REGISTER *)

(REG_TYP IN NET_FLAGS) (* OR A HEX REGISTER *)

(* FIND VALUE OF A HEX REGISTER *)

3 0 (**********************************************************************)

THEN BEGIN (* THEN SCAN THE REGISTER *)

WAVE_VAL:= O;

IF NOT (REG_TYP IN NET_FLAGS) (* IF UNSIGNED REGISTER *)

THEN BEGIN

COUNT:= COUNT 1; (* DON'T SCAN GAP RECORD*)

IF (REG_REV IN NETFLAGS) (* POINT TO 1ST DATA BIT *)

THEN LP:= LP-> CHAINBACKWARD

ELSE LP:= LP-> CHAIN_FORWARD;

END;

REPEAT (* THEN SCAN THE REGISTER *)

REG:= O; (* START HEX DIGIT AS O *)

SA 9-89-070

WAVEVAL:= WAVEVAL "< 4;

I:= 1 << ((COUNT 1) MOD 4); (* RELEVANT BIT OF DIGIT*)

REPEAT (* FORM HEX DIGIT *)

NETCHAR:= NETVALUE (LP);

IF NETCHAR = 'i'

THEN BEGIN

REG:= REG j I; (* VALUE WAS + *) WAVE_VAL:= WAVE_VAL j I; END

ELSE IF (NETCHAR ^= '0 ') AND

(NETCHAR -=' ')

THEN REG:= -1; (* VALUE WAS UNDEFINED *)

I:= I >> 1; (* POSITION FOR NEXT BIT *)

IF (REG_REV IN NET_FLAGS) (* POINT TO NEXT LINE *)

THEN LP:= LP-> CHAINBACKWARD

ELSE LP:= LP-> CHAIN_FORWARD;

COUNT:= COUNT I;

UNTIL (I = 0); (* UNTIL HEX DIGIT END *)

TSTR:= TSTR Ij HEX( REG); (* ACCUMULATE HEX STRING *)

UNTIL COUNT = O; (* UNTIL REGISTER END*)

IF (ANLG_REG IN NET_FLAGS) AND

(REGTYP IN NET_FLAGS) AND

((WAVE_VAL << ( 32 REGCNT)) < 0)

THEN WAVE_VAL:= (MINU 51 << REGCNT) + WAVE_VAL;

END

(* FIND VALUE OF A BINARY REGISTER *)

ELSE REPEAT (* else scan binary reg *) TSTR:= TSTR Il STR (NETVALUE (LP));

IF (REG_REV IN LP-> NET_FLAGS) (* POINT TO NEXT LINE *)

THEN LP:= LP-> CHAINBACKWARD

ELSE LP:= LP-> CHAIN_FORWARD;

COUNT:= COUNT 1;

UNTIL COUNT = O; (* UNTIL REGISTER END *)

REGVALUE:= TSTR;

END; end; (* end REGVALUE *)

%PAGE

(t*t*t***tt*tt**t**ttt***tttt*tt titt)

SA 9-89-070

(* *)

(* ROUTINE NAME: SET_PLOTLENGTH *)

(* ROUTINE TYPE: PROCEDURE *)

(* *)

(* FUNCTION: THIS PROCEDURE WILL ESTABLISH THE DEFAULT PLOT *

(* LENGTH SUCH THAT THE MINIMUM NUMBER OF ( 80 % FULL) *)

(* SCREENS WILL BE DRAWN *)

(*,)

(* PARAMETERS: NONE *)

(* RETURNS: *)

(* 1) DTWI DEFAULT PLOT WIDTH FOR WAVEFORMS (GLOBAL VARIABLE)

)

(* 2) DTCI DEFAULT PLOT WIDTH FOR CHARACTERS (GLOBAL VARIABLE)

) procedure SET_PLOT_LENGTH; VAR

R,MINPLEN: INTEGER; (* MIN DEFAULT PLOT LENGTH *)

BEGIN (* BEGIN SET_PLOT_LENGTH *)

MIN_PLEN:= ( 4 * PLOT_LENGTH) DIV 5;

R:= (MAXTIME + PLOT_LENGTH 1) DIV PLOT_LENGTH;

REPEAT

DTWI:= (MAX_TIME + R -1) DIV R;

XINC:= PLOT_LENGTH DIV DTWI;

3 0 IF (XINC * DTWI) > MINPLEN

THEN LEAVE;

R:= R + 1;

UNTIL FALSE;

R:= PLOTLENGTH DIV XCHARSIZE;

R:= (MAXTIME + R -1) DIV R;

REPEAT

DTCI:= (MAXTIME + R -1) DIV R;

XINC:= PLOT_LENGTH DIV DTCI;

IF (XINC * DTCI) > MIN PLEN

THEN RETURN;

SA 9-89-070

R:=R + 1;

UNTIL FALSE;

END; (* END SET_PLOT_LENGTH *)

%page

(*ROUTINE NAME: READ LSMHEADER *)

(*ROUTINE TYPE: FUNCTION *)

(*FUNCTION: THIS PROCEDURE WILL READ THE HEADER OF THE LSM

(* OUTPUT FILE AND SET VARIOUS GLOBAL VARIABLES *)

(*

(* PARAMETERS:

(* 1 THE USER'S TEST NAME

(* 2 THE FILE MODE OF THE USER DISK

(

(* RETURNS: NONE

(,

PROCEDURE READ_LSM_HEADER;

*) ) )

ENTRY;

VAR

R: INTEGER;

(* READ THE LSM DATA COLLECTION FILE AND BUILD INTERNAL WORK FILE

*) C*

BEGIN (*

DEFINE_OUTPUT_FILE;

IF RCODE > O THEN RETURN;

NEWOUTPUT:= TRUE;

WAVERECNO:= 1;

WAVETIME:= -1;

WITH LSMDOUT-> DO

BEGIN (*

LEVELCYCLE:= HDLPCY;

STARTCYCLE:= HDBCYC;

ENDCYCLE:= HDECYC;

STARTLEVEL:= HDBLVL;

BEGIN READ_LSM_HEADER *)

(* INITIAL Re CORD NUMBER *)

(* INITIALIZE ARRAY TIME *)

(* MAKE RECORD ADDRESSABLE *)

EXTRACT DATA *)

(* GET LEVELS/CYCLE

(* GET START CYCLE *)

(* GET END CYCLE *)

(* GET START LEVEL *)

*)

SA 9-89-070

ENDLEVEL:= HDELVL; (* GET END LEVEL *)

NANOSLEVEL:= HDNPLV; (* GET NANOSECONDS / LEVEL *)

STROBE_VALUE:= HDSLVL; (* GET STROBE LEVEL *)

IF HDUND O ^= CHR('00 'X) (* IF CHARACTER DEFINED *)

THEN LSMCHAR( 1):= HDUND O(* THEN USE FOR DISPLAY *)

ELSE LSMCHAR( I):= '*'; (* ELSE DEFAULT CHARACTER *)

IF HDUND 1 ^= CHR('00 'X) (* IF CHARACTER DEFINED *)

THEN LSMCHAR( 3):= HDUND 1 (* THEN USE FOR DISPLAY *)

ELSE LSMCHAR( 3):= '?'; (* ELSE DEFAULT CHARACTER *)

IF QPARM -= 'D'

THEN BEGIN

BUFFER S:= STR (LSMCHAR( I));

R:= FSWRITEW ( 214,$REP,BUFFER);

BUFFER S:= STR (LSMCHAR( 3));

R:= FSWRITEW ( 215,$REP,BUFFER);

END; %PAGE

TIME__BIAS:= (START_CYCLE 1) * LEVELCYCLE; (* BIAS FOR STB *)

CASE HDTYPE OF

Il: IF MODE ^= $COMPARE

THEN SUPERROR ( 90,NIL);

12: IF MODE '= $STROBE

THEN SUPERROR ( 90,NIL)

ELSE BEGIN

START_LEVEL:= STROBE_VALUE;

ENDLEVEL:= STROBE_VALUE;

END;

13: IF MODE ^= $DEBUG

THEN SUPERROR ( 90,NIL)

ELSE BEGIN

TIME_BIAS:= TIME_BIAS + STARTLEVEL I;

IF QPARM ^= 'D

THEN BEGIN

WRITESTR (BUFFER S,'START LEVEL (,

START__LEVEL:5,') ==>');

R:= FSWRITEW ( 219,$REP,BUFFER);

WRITESTR (BUFFER S,'END LEVEL (',

END_LEVEL:5,') ==>');

R:= FSWRITEW ( 221,$REP,BUFFER);

END;

END;

SA 9-89-070

OTHERWISE SUPERROR ( 90,NIL);

END;

IF HDWCNT = O THEN SUPERROR ( 92,NIL);

IF RCODE > O THEN RETURN;

IF MODE -= $COMPARE

THEN OUTPUT_EXISTS:= TRUE;

DATA_SIZE:= (HDVCNT + 7) DIV 8;

END;

IF QPARM '= 'D'

*THEN BEGIN

WRITESTR (BUFFER S,'START CYCLE (',START__CYCLE:5,') ==>');

R:= FSWRITEW ( 218,$REP,BUFFER);

WRITESTR (BUFFER S,'END CYCLE (',END CYCLE:5,') ==>');

R:= FSWRITEW ( 220,$REP,BUFFER);

END;

IF NOT SPCNGSET

THEN BEGIN

IF STARTCYCLE = 1

THEN MARKSTART:= O

ELSE MARK_START:= STARTCYCLE;

IF QPARM ^= 'D'

THEN BEGIN

WRITESTR (BUFFER S,MARKSTART:-5);

R:= FSWRITEW ( 210,$REP,BUFFER);

END; END;

MAXTIME:= TIME (ENDCYCLE,END_LEVEL); (* MAXIMUM DISPLAY TIME

)

END; (*END READ_LSM_HEADER *)

%page

(* *)

(* ROUTINE NAME: SET_TIMESCALE)

(* ROUTINE TYPE: PROCEDURE *)

(* *)

(* FUNCTION: THIS PROCEDURE WILL ESTABLISII THE MAJOR INCREMENT

SA 9-89-070

(* OF THE HORIZONTAL (TIME) AXIS OF THE 59 FD DISPLAY *)

(*,)

(* PARAMETERS:)

(* 1) T 1 START TIME FOR WAVEFORM/CHARACTER DISPLAY)

(* 2) T 2END TIME FOR WAVEFORM/CHARACTER DISPLAY *)

(* *)

(* RETURNS: GLOBAL PLOT PARAMETERS SET *)

(). procedure SET_TIME_SCALE (CONST T 1,T 2: INTEGER); VARP

R: INTEGER;

CSTR: STRING( 5);

BEGIN (* BEGIN SET__TIMESCALE *)

R:= T 2 T 1;

IF (R -= 0) AND

(PLOT_LENGTH ≥ R)

THEN BEGIN

XINC:= PLOTLENGTH DIV R;

WRITESTR (CSTR,ENDCYCLE:-5);

HSI:= ((LENGTH(TRIM(CSTR))+ 1) * XCHARSIZE + XINC 1) DIV XINC;

IF MODE = $DEBUG (* IF DEBUG MODE *)

THEN HSI:= (HSI + LEVELCYCLE1) DIV LEVELCYCLE;

IF NOT SPCNGSET

THEN BEGIN

MARKSPCNG:= HSI;

IF QPARM = 'D'

THEN RETURN;

WRITESTR (BUFFER S,MARKSPCNG:-5);

R:= FSWRITEW ( 211,$REP,BUFFER);

END

ELSE HSI:= ((HSI + MARK_SPCNG-I) DIV MARKSPCNG) * MARK_SPCNG;

END;

IF QPARM ='D'

THEN RETURN;

WRITESTR (BUFFER S,TOPX:-5);

R:= FSWRITEW ( 245,$REP,BUFFER);

SA 9-89-070

WRITESTR (BUFFER S,SLOT( TOPX)-> NETNAMEPTR-> NAM:-32);

R:= FSWRITEW ( 246,$REP,BUFFER);

END; (*END SET_TIMESCALE *)

%page

(* *)

(* ROUTINE NAME: GENERATE_FLAGS *)

(,,)

(* ROUTINE TYPE: PROCEDURE *)

(* *

(* FUNCTION: THIS PROCEDURE GENERATES A STRING CONTAINING EDIT *)

(* RECORD FLAG BIT INFORMATION (FAULT LIST, PREDECESSOR/ *)

(* SUCCESSOR, AND PRIMARY I/O) FOR THE DISPLAY *)

(* *)

(* PARAMETERS: EDIT RECORD LINE POINTER *)

(* *)

(* RETURNS: STRING WITH FLAG BIT INFORMATION *)

(* *)

(), procedure GENERATEFLAGS (CONST LP: PEDIT__REC;

VAR FSTR: STRING( 5)); ENTRY;

BEGIN (* GENERATE_FLAGS *)

WITH LP-> DO

BEGIN

IF REG_DEF IN NET_FLAGS (* IF NET IS A REGISTER *)

THEN IF ANLG_REG IN NET_FLAGS (* IF ANALOG REGISTER *)

THEN IF REG_TYP IN NET_FLAGS (* IF HEX REGISTER *)

THEN WRITESTR (FSTR,'SR',REGCNT:3)

ELSE WRITESTR (FSTR,'UR',REGCNT-1:3)

ELSE IF REG_TYP IN NET_FLAGS (* IF HEX REGISTER *)

THEN WRITESTR (FSTR,'HR',REGCNT:3)

ELSE WRITESTR (FSTR,'BR',REGCNT:3)

ELSE BEGIN (* ELSE DISPLAY NORMAL NET *)

IF FLT__OUPT IN NETFLAGS ( IF FAULT LIST OUTPUT *)

THEN FSTR:= 'FLO '

ELSE IF FLT_DEF IN NET__FLAGS (* IF FAULT LIST INPUT *)

THEN FSTR:= 'FLI '

ELSE IF NET__PRED IN NETFLAGS (* IF PREDECESSOR LINE *)

THEN WRITESTR (FSTR,'P',NESTINDEX:2,'')

SA 9-89-070

ELSE IF NET__SUCC IN NET_FLAGS (* IF SUCCESSOR LINE *)

THEN WRITESTR (FSTR,'S',SNSTLEVEL:2,' ')

ELSE IF FUNNAMEPTR ^= NIL

THEN FSTR:= ' '

ELSE IF (LP = HEADPTR) OR

(LP = TAILPTR)

THEN FSTR:='*****'

ELSE FSTR:=' ';

IF CMP_Pl IN NET_FLAGS (* CHECK FOR Pl OR PO *)

THEN FSTR( 5):= 'I'

ELSE IF CMPPO IN NETFLAGS

THEN FSTR( 5):= 'O';

END; END;

END; (* END GENERATEFLAGS *)

%PAGE

RUI(* *)

(* ROUTINE NAME: TRANSITION *)

(, *)

(* R TINE TYPE: PROCEDURE

(, *) *)

(* FUNCTION: THIS PROCEDURE DRAWS A WAVEFORM TRANSITION WITH AN

*)

(* APPROPRIATE DELAY INDICATION *)

(*,)

(* PARAMETERS: *)

(* 1) NP POINTER TO EDITOR RECORD *)

(* 2) NLVLCURRENT WAVEFORM LEVEL *)

(* 3) DLAYNET DELAY VALUE *)

(RETURNS: NONE* -

(* RETURNS: NONE * 3

*) procedure TRANSITION (CONST NP: PEDIT__REC;

CONST NLVL: INTEGER;

CONST DLAY: BYTE);

BEGIN

WITH NP-> DO

IF DATABASE AND

(* BEGIN TRANSITION

(*

SA 9-89-070

(DLAY > 1)

THEN IF (MODE = $DEBUG)

THEN BEGIN

GSLT (DLVL); (* SE

GSDRAW (LX-DLAY*XINC,LY);

END;

HOW DELAY AS DOTTED LINE*)

END; (* END TRANSITION *)

%PAGE

(* *)

(* ROUTINE NAME: CHECK_CMPHIT)

(* ROUTINE TYPE: PROCEDURE *)

(* FUNCTION: THIS PROCEDURE CHECKS TO SEE IF A COMPARE 'HIT'

(* OCCURRED ON THIS NET AND, IF SO, OVERLAYS A 'Q' *)

(* AT THE APPROPRIATE CYCLE/LEVEL ON THE DISPLAY ')

(* PARAMETERS: EDIT RECORD LINE POINTER *)

(* *)

(* RETURNS: STRING WITH FLAG BIT INFORMATION

( *)

procedure CHECK__CMPHIT (CONST T 1,T 2: INTEGER); VAR

I,IX,T 3: INTEGER;

CX,CY: INTEGER;

NP: PEDIT_REC;

BEGIN

GSSL ( 3);

GSLT (ULVL);

CY:= YSTART;

(* BEGIN CHECKCMPHIT

(* set character size *)

FOR IX:= TOPX TO BOTX-1 DO

BEGIN

NP:= SLOT( IX);

FOR I:= O TO SLOT( IX)-> REGCNT 1 DO

WITH NP-> DO

BEGIN ) *) )

SA 9-89-070

IF (NOT DISPLAY_WAVE) AND

(I '= 0) AND

((NOT (ANLGREG IN NET_FLAGS) AND

NOT (REG_TYP IN NET_FLAGS)) OR

((I MOD 4) = 0))

THEN CY:= CY YINC;

IF CYCLE_NUMBER > O (* IF 'HIT' OCCURRED

THEN BEGIN

T 3:= TIME (CYCLE_NUMBER,LEVELNUMBER);

IF (T 3 ≥ T 1) AND

(T 3 ≤ T 2) (* IF TIME ON DISPLAY *

THEN BEGIN

CX:= PLOTSTART 4 + ((T 3 T 1) * XINC);

GSCHAR (CX,CY,1,'Q');

END;

ON NET *)

) END;

IF REGREV IN NETFLAGS

THEN NP:= CHAINBACKWARD

ELSE NP:= CHAIN_FORWARD;

END;

CY:= CY YINC;

END;

END; (* END CHECK_CMPHIT *)

%PAGE

(* ROUTINE NAME: DRAWCHAR *)

(* ROUTINE TYPE: PROCEDURE *)

(*FUNCTION: THIS PROC DRAWS THE SELECTED NET CHARACTER DISPLAY

(* *)

(* PARAMETERS:

(* 1) TI START TIME FOR CHARACTER DISPLAY

(* 2) T 2 END TIME FOR CHARACTER DISPLAY

(* RETURNS: NONE

(,) procedure DRAWCHAR (CONST T 1,T 2: INTEGER); )

SA 9-89-070

var

I,J: INTEGER;

X,Y,YMID: INTEGER;

Slot Index: INTEGER;

LP: PEDITREC;

Net Str:STRING(MAXNET);

SHORTREG: BOOLEAN;

*********************************

(* DISPLAY THE NET VALUES FOR THE REQUESTED TIME RANGE *)

begin (* BEGIN DRAWCHAR *)

PLOT_START:= (FUNCTION_LEN + DNAME_LENGTH + 8) * XCHARSIZE;

PLOT_LENGTH:= XMAX PLOT_START;

X:= PLOT_START; (* START X FOR DISPLAY*)

GSLTD ( 4,5,5); (* SET DOTTED LINE PARMS *)

for J:= T to T 2 DO begin

READ_DATA (J);

for Slot Index:= TOPX TO BOTX-1 DO begin LP:= SLOT( Slot Index); (* current line pointer *) with LP-> do BEGIN

IF (REG_DEF IN NET_FLAGS)

THEN IF LR = 1

THEN SHORTREG = TRUE

ELSE SHORT_REG:= FALSE

ELSE IF (NETGAP IN NETFLAGS) (* IF NOT DISPLAYABLE *)

THEN CONTINUE

ELSE SHORTREG = FALSE;

NETSTR:= REGVALUE (LP);

IF (ANLG_REG IN NET_FLAGS)

THEN BEGIN

I:-= ROUND (WAVE_VAL * WAVEINC + YZERO);

IF (J ^= TI)

THEN BEGIN

GSLT (WAVE N+l); (* DRAW APPROPLINE TYPE *)

SA 9-89-070

GSMOVE (X-XINC,LW);

GSDRAW ( X, I);

END;

LW:= I;

END

* ELSE IF NETSTR ^= LASTNETSTR( SLOTINDEX)

THEN BEGIN

IF (X ^= (LX XCHARSIZ + XINC)) AND

(NOT SHORT_REG)

THEN BEGIN

(****DASH DISPLAY****)

GSLT ( 4); (* CONNECT *-* *)

YMID:= LY + YCHAR 78 YCHARI 2 * LR;

GSMOVE (LX,YMID);

GSDRAW (X,YMID);

END;

(****CHAR DISPLAY****)

Y:= LY;

FOR I = 1 TO LR DO

BEGIN

IF (NETSTR( I) = '*')

THEN GSLT ( 1)

ELSE GSLT ( 0);

GSCHAR (X,Y,l,NETSTR( I));

Y:= Y YINC;

END;

LX:= X + XCHARSIZ;

LASTNETSTR( SLOTINDEX):= NETSTR;

END (* END IF VALUE CHANGED*)

ELSE IF (J = T 2) AND

(NOT SHORTREG)

THEN BEGIN

(****DASH DISPLAY****)

GSLT ( 4); (* CONNECT * * *)

YMID:= LY + YCHAR 78YCHAR 12 * LR;

GSMOVE (LX,YMID);

GSDRAW (X+XCHARSIZ,YMID);

END;

END; (* END WITH LP-> *)

end; (* END FOR Slot Index*)

X:= X + XINC;

SA 9-89-070

end;

GSLTD ( 4,0,0);

end;

(* END FORJ *)

(* SET SOLID LINE MODE.

(* end DRAWCHAR *) %page

(* ROUTINE NAME: DRAWWAVE

(* ROUTINE TYPE: PROCEDURE

(* ROUTINE TYPE: PROCEDURE

*) *)

(* *)

(* FUNCTION: THIS PROCEDURE WILL DRAW THE SELECTED NET

WAVEFORMS *)

*)

(* PARAMETERS:

(* 1) T 1 START TIME FOR WAVEFORM DISPLAY

(* 2) T 2 END TIME FOR WAVEFORM DISPLAY

(* *)

(* RETURNS: NONE

(c * **) *) -) *) procedure DRAWWAVE (const Tl,T 2: INTEGER); var

I,J,X: INTEGER;

SI,COUNT,CN: INTEGER;

LSMW,LSMB: INTEGER;

LP: PEDIT_REC;

CR: SIGNED_UNIT;

Net Str: STRING(MAXNET);

ACTV LVL: BOOLEAN;

(* DISPLAY THE NET VALUES FOR THE REQUESTED TIME RANGE

BEGIN (* begin DRAWWAVE *)

PLOTSTART = 2 * XCHARSIZE;

PLOT_LENGTH:= XMAX PLOTSTART;

GSLTD ( 4,5,S); (* SET DOTTED LINE MODE *)

X:= PLOT_START; (* START X FOR WAVEFORMS *)

FOR J:= T 1 TO T 2 + 1 DO

BEGIN

SA 9-89-070

IF J ≤ T 2

THEN READDATA (J)

ELSE X:= X XINC + XCHARSIZ;

MINUS:= YSTART;

FOR SI:= TOPX TO BOTX-1 DO

BEGIN LP = SLOT( Sl); (* current line pointer *)

IF (ANLG_REG IN LP-> NET_FLAGS)

THEN WITH LP-> DO

BEGIN

NETSTR:= REGVALUE (LP);

I:= ROUND (WAVE_VAL * WAVEINC + Y_ZERO);

IF (J ^= TI)

THEN BEGIN

GSLT (WAVEN); (* DRAW APPROP LINE TYPE *

GSMOVE (X-XINC,LW);

GSDRAW ( X, I);

END;

LW:= I;

CONTINUE;

END; %PAGE COUNT:= LP-> REGCNT; (* then get register count ')

FOR I:= I TO COUNT DO

WITH LP-> DO

BEGIN

IF NOT (NET GAP IN NET_FLAGS) (* IF DISPLAYABLE NET *)

THEN BEGIN

IF J > T 2 (* IF LAST DISPLAY *)

THEN CR:= 4 (* SET LAST PASS INDICATOR *)

ELSE BEGIN

CN:= IAX << 1;

LSMW:= (CN >> 4) + 1; (* (IAX DIV 8) + 1 *)

LSMB:= 'OOOE'X && CN & 'OOOE'X;

CR:= (WAVEFORM RECDATA( LSMW) >> LSMB)

AND '0003 'X;

END;

(* DECISION BASED ON LAST VALUE OF THE GIVEN NET *

SA 9-89-070

IF CR -= LR (* LAST VAL -= CURRENT VAL *)

THEN BEGIN (* THEN DRAW LINE *)

CASE LR OF

4: BEGIN

LX:= X; (* SAVE CURRENT X VALUE *)

LY:= MINUS;

END; (*END CASE LR = 4)

(*DECISION BASED ON LAST VALUE OF THE GIVEN NET (CON'T) *)

0,2: BEGIN (* LAST VAL = O (-) OR 2 (+)*)

ACTVLVL:= ((LR = 2) &&

(NETNAME_PTR-> NAM( 1) = '-'));

IF ACTVLVL

THEN GSLT (ALVL) (* ACTIVE LEVEL *)

ELSE GSLT (ILVL);

GSMOVE (LX,LY); (*FRM LST TIME SLOT*)

GSDRAW (X,LY); (* TO NEW TIME SLOT*)

LX:= X; (* SAVE CURRENT X VALUE *)

CASE CR OF (* CASE CURRENT RESULT *)

0: TRANSITION (LP,MINUS,FTIME);

2: TRANSITION (LP,MINUS,RTIME);

OTHERWISE (* OTHERWISE *)

END; (* END CASE CR *)

END; (* END CASE LR = O OR 2)

(*DECISION BASED ON LAST VALUE OF THE GIVEN NET (CON'T) t)

3 0 *********************#** * **** * * *)

1,3: BEGIN (* LAST VAL = '*' OR '?'*)

GSLT (ULVL);

GSMOVE (LX,LY);

GSDRAW (X,LY);

LX:= X;

END; (t END CASE LR = I OR 3 *)

OTHERWISE (* OTHERWISE)

END; (* END CASE LAST RESULT t)

LR:= CR; (* SAVE CURRENT RESULT *)

END; (* END IF SAME AS LASTt)

END; ( END IF NOT NET GAP)

SA 9-89-070

IF REGREV IN NET__FLAGS (* IF A REVERSE REGISTER *)

THEN LP:= CHAINBACKWARD

ELSE LP:= CHAIN_FORWARD;

Et ND; (* end for I with LP*)

MINUS:= MINUS YINC;

END; (* X:= X + XINC

END; (

GSLTD ( 4,0,0);

end;

END FOR SI

END FOR J)

(* SET SOLID LINE MODE.

end DRAWWAVE *) %page

(* *)

(* ROUTINE NAME: DRAWOUTPUT

(* ROUTINE TYPE: PROCEDURE(* ROUTINE TYPE: PROCEDURE

(* *) )

(* FUNCTION: THIS PROCEDURE WILL DISPLAY THE INFORMATION

(* PERTINENT TO A SINGLE NET, AND DRAW THE DISPLAY

(* TIMING SCALE AND THE USER TEST INFORMATION.

*) (*

(*PARAMETERS:)

(* I) T 1 START TIME FOR WAVEFORM/CHARACTER DISPLAY

(* 2) T 2 END TIME FOR WAVEFORM/CHARACTER DISPLAY

(*RETURNS: NONE)

PROCEDURE DRAW_OUTPUT (CONST T 1,T 2: INTEGER); ENTRY;

LABEL

NODRAW;

VAR

MAX REG: REAL;

MAX_REGP:REAL;

MAX_REGN:REAL;

WAVERANGE: REAL;

I,J,K,L,LS: INTEGER;

X,Y: INTEGER;

NWAVE: INTEGER;

E -) *) ) ) (,4 *)

SA 9-89-070

TL,TH,CN: INTEGER;

MARK_MOD: INTEGER; (* DISPLAY MARKS MODULUS *)

MARK 1,MARK 2: INTEGER;

DSP_HEIGHT: INTEGER;

WYINC: INTEGER;

NP,LP PEDITREC;

DATE,TOD: ALFA; (* CURRENT DATE/TIME *)

NAMESTR: STRING ( 62);

FLAGSTR: STRING ( 5);

FNAME: STRING ( 32);

DISPSTR: STRING ( 108);

%PAGE

(* DISPLAY THE NET NAMES OF THE DISPLAYABLE NETS *)

(* LEAVING BOTX POINTING TO THE NEXT LINE TO DISPLAY,

(* ALLOWING FORWARD SCROLLING *)

(S*******SSS*******)SSS*SSSSSS*SSS*S,

BEGIN (* BEGIN DRAWOUTPUT

DSPHEIGHT:= O;

IF DISPLAYWAVE

THEN BEGIN

BACK__SCALE (T 1,201,WAVE_STCYC,WAVESTLEV);

BACK_SCALE (T 2,205,WAVE__ENCYC,WAVEENLEV);

YINC:= YINCW;

YSIZE:= O;

END

ELSE BEGIN

BACKSCALE (T 1,203,CHARSTCYC,CHAR_STLEV);

BACK_SCALE (T 2,207,CHARENCYC,CHAR_ENLEV);

YINC:= YCHARSIZE; (* NET NAME SEPARATION

YSIZE: YCHARSIZ; (* CHARACTER HEIGHT

END; )

YSTART:= YMAXDIMEN YINC;

HYSIZE:= YSIZE DIV 2;

SETTIME_SCALE (T 1,T 2);

IF QPARM -= 'D'

THEN BEGIN

I:= FSMODW ( 200,$OUT,$HIGH,$ON);

I:= FSDISPLAY ($NOWAIT,$NOALARMl END;

(* START AT TOP AND GO DOWN *)

SA 9-89-070

GSERSE;

GSLT ( 0);

IF NOT CSETLOADED

THEN BEGIN

GSLPG ('GAAPAP ');

GSLIM ( 250000,0);

END;

(* LOAD CHAR STROKE TABLE *)

GSVECM ( 15,BOX( 1,0)); (* DRAW BOX AROUND TEST INFO')

GSSL ( 2); (* SET CHARACTER SIZE *)

NAMESBOT:= O;

BOTX:= TOPX;

NWAVE:= O;

MAX REGP:= O;

MAX REGN:= O;

Y:= YSTART;

L:= PLOT_START + (T 2 T 1) * XINC + XCHARSIZ;

%PAGE

REPEAT

NP:= SLOT( BOTX);

IF NP = TAILPTR THEN LEAVE;

WITH NP-> DO (* make record addressable *) BEGIN (* build DISPLAY NA ME LINE *)

*J:= DSP__HEIGHT;

IF DISPLAYWAVE

THEN BEGIN

IF (ANLG_REG IN NET_FLAGS)

THEN BEGIN

WYINC:= YCHARSIZE;

IF (N_WAVE = 0)

THEN BEGIN

J:= J + MINANLG_ HT + YINCW YCHARSIZE;

Y:= Y YCHARSIZE;

END; END

ELSE IF (N_WAVE = 0)

THEN WYINC:= YINCW

ELSE IF (REGDEF IN NETFLAGS) OR

(NOT (NET_GAP IN NET_FLAGS))

THEN LEAVE

t

SA 9-89-070

ELSE WYINC:= YCHARSIZE;

J:= J + WYINC;

END

ELSE BEGIN

LX:= PLOT_START + XCHARSIZXINC; (* TO AVOID TI TEST *)

LASTNETSTR( BOTX):= CHAR('FF'X);

IF (ANLG__REG IN NET__FLAGS)

THEN BEGIN

LR:= I;

IF (N_WAVE = 0)

THEN BEGIN

J:=J+MINANLG_HT;

Y:= Y YCHARSIZE;

END;

END

ELSE IF (N_WAVE = 0)

THEN BEGIN

IF (REG_TYP IN NET_FLAGS)

THEN LR:= (REGCNT + 3) DIV 4

ELSE LR:= REGCNT;

IF LR > MAXNET

THEN BEGIN

SUPERROR ( 31,NIL);

GOTO NODRAW;

END;

END

ELSE IF (REGDEF IN NETFLAGS) OR

NOT (NET GAP IN NET_ FLAGS)

THEN LEAVE

ELSE LR:= 1;

J:= J + LR * YCHARSIZE;

END; %PAGE

IF (J > PLOT_HEIGHT)

THEN LEAVE;

DSPHEIGHT:= J;

IF (ANLG REG IN NET FLAGS)

THEN BEGIN

IF (REGCNT < 3)

THEN MAXREG:= REGCNT

ELSE BEGIN

SA 9-89-070

I:= 1 << (REGCNT 3);

MAX_REG:= REAL(I) * 4 0;

END;

IF (REG_TYP IN NETFLAGS) AND

(MAXREG > MAX REGN)

THEN MAX_REGN:= MAXREG;

IF (MAX REG > MAX REGP)

THEN MAX REGP:= MAXREG;

WAVE_N:= N_WAVE;

N_WAVE:= N_WAVE + 1;

END;

IF DNAMELENGTH > O

THEN BEGIN

NAMESTR:= NETNAME_PTR-> NAM;

J:= DNAME_LENGTH LENGTH (NAME STR);

IF J < O (* IF TRUNCATION NEEDED *)

THEN BEGIN

IF VIEWLEFT

THEN J:= 1

ELSE J:= 1 J;

NAME_STR:= SUBSTR (NAMESTR,J,DNAIMELENGTH);

END

ELSE IF J > O

THEN IF (NETGAP IN NETFLAGS)

THEN NAMESTR:= NAMESTR Il SUBSTR (BLANKS,1,J)

ELSE NAME_STR:= NAME_ STRIISUBSTR(NAME_TAIL,1,J);

END

ELSE NAMESTR:= ";

GENERATE_FLAGS (NP,FLAGSTR);

%PAGE

(* ALSO DISPLAY THE FUNCTION IF ALLOWED *)

3 5 **********(******************* **)

IF (FUNCTION_LEN = 0) OR

(FUNNAMEPTR = NIL)

THEN FNAME:="

ELSE BEGIN

J:= LENGTH(FUNNAME_PTR->)1;

FNAME:= SUBSTR (FUNNAMEPTR->,l,MIN(J,FUNCTIONLEN));

SA 9-89-070

J:= FUNCTIONLEN LENGTH (FNAME);

IF J > O (* IF NAME TAIL IS NEEDED *)

THEN IF (NET-GAP IN NETFLAGS)

THEN FNAME:= FNAME lI SUBSTR (BLANKS,1,J)

ELSE FNAME:= FNAME II SUBSTR (NAMETAIL,I,J);

END;

IF (ANLGREG IN NET FLAGS)

THEN BEGIN (* T He N ANALOG REGISTER*)

GSLT (WAVEN+ 1); (* DRAW APPROP LINE TYPE *)

GSMOVE (PLOTSTART,Y + YCHARD 2);

GSDRAW (PLOTSTART + 13 *XCHARSIZE,Y + YCHARD 2);

GSLT ( 0);

END; (* END ANALOG REGISTER*)

IF DISPLAYWAVE

THEN BEGIN

IF (NOT (ANLG_REG IN NETFLAGS)) AND

((REGDEF IN NETFLAGS) OR

(NOT (NET_GAP IN NETFLAGS)))

THEN BEGIN

NAMES _BOT:=Y;

LR:= 4; (* RESET VALUE FOR WAVES *)

IF (REG_DEF IN NET_FLAGS) THEN

REPEAT (* SCAN FOR END OF REGISTER *)

IF (REG_REV IN NP-> NETFLAGS)

THEN NP:= NP-> CHAINBACKWARD

ELSE NP:= NP-> CHAINFORWARD;

NP-> LR:= 4; (* RESET VALUE FOR DISPLAY *)

UNTIL (REGDEF IN NP-> NET_FLAGS);

END;

Y:= Y WYINC;

END

ELSE BEGIN (* ELSE CHARACTER DISPLAY *)

WRITESTR (DISP STR,NAMESTR,' ',FLAGSTR:-6,FNAME);

GSCHAR ( 0,Y,LENGTH (DISPSTR),DISP STR( 1));

LY:= Y;

Y:= Y LR * YINC;

IF (NOT (ANLG_REG IN NET_FLAGS)) AND

((REG DEF IN NET FLAGS) OR

(NOT (NETGAP IN NETFLAGS)))

THEN BEGIN

SA 9-89-070

NAMES_ BOT:=Y + YCHARSIZ;

IF (REG DEF IN NET__FLAGS) (* IF NET IS A REG *)

THEN BEGIN (* ELSE HEX REGISTER *)

GSMOVE (PLOT_START,LY + YCHAR 78);

GSDRAW (L,LY + YCHAR 78);

GSMOVE (PLOT_START,NAMES_ BOT);

GSDRAW (L,NAMESBOT);

END; (* END NET IS A REGISTER *)

END; (* END NET NOT GAP RECORD *)

END; (* END ELSE CHARDISPLAY *)

END; (* END WITH NP-> DO *)

BOTX:= BOTX + 1; (* INCR LAST SLOT INDEX *)

UNTIL FALSE;

%PAGE

IF (N_WAVE = 0)

THEN SPLITTICK = FALSE;

NAMESCHANGE = FALSE; (* RESET NAMES CHANGED FLAG)

IF (N_WAVE '= 0)

THEN BEGIN

IF (NAMES BOT = 0)

THEN SPLIT_TICK = CYCLE_MARK;

IF SPLITTICK

THEN SCALE CHANGE = TRUE;

WAVERANGE:= MAXREGP + MAX REGN;

WAVE_INC = (PLOTHEIGHT DSPHEIGHT

+ MIN_ENV * YCHARSIZE) / WAVERANGE;

WAVE_TOP = ROUND (X_AXIS + WAVEINC * WAVERANGE);

Y_ZERO = ROUND (WAVE_TOP MAXREGP * WAVEINC);

GSLT ( 6);

GSMOVE (PLOTSTART,WAVE_TOP);

GSDRAW (PLOT__START,XAXIS-20); (* DRAW Y__AXIS *)

GSMOVE (PLOT_START-20,Y_ZERO);

GSDRAW (L,YZERO); (* DRAW XAXIS *)

GSLTD ( 6,2,7);

IF WVAVERANGE < 16

THEN K = TRUNC(WAVERANGE)

ELSE K = 16;

J = TRUNC(WAVERANGE / K);

TH:= (WAVE_TOP XAXIS) DIV K;

FORI:= O TO K-1 DO

BEGIN

SA 9-89-070

GSMOVE (PLOT_START,WAVE_TOP-TH*I);

GSDRAW (L,WAVE_TOP-TH*I);

END;

GSLTD ( 6,0,0);

CN:= WAVE_TOP YCHAR_D 2;

WRITESTR (DISP _STR,MAXREGP:-11:0);

LS:= LENGTH(TRIM(DISP STR)) + 1;

X:= PLOTSTART XCHARSIZE * LS;

FOR 1:= O TO K-1 DO

BEGIN

WRITESTR (DISPSTR,MAXREGP-REAL(I)*J:LS:0);

GSCHAR (X,CN-TH*I,LS,DISP__STR( 1));

END; END; %PAGE

(* DRAW THE HORIZONTAL SCALE FOR THE DISPLAY *)

SCALECHANGE:= FALSE; (* RESET SCALE CHANGED FLAG *)

GSSL ( 2); (* set character sise*) TL:= T 1 + TIME__BIAS; (* adjust for actual time *)

TH:= T 2 + TIME_BIAS;

IF MODE = $DEBUG (* IF DEBUG MODE *)

THEN BEGIN

MARK 1:= LARGE_TICK 1;

MARK 2:= LARGE_TICK 2;

J:= 1 + (TL DIV LEVELCYCLE); (* STARTING CYCLE NUMBER *)

END (* END IF $DEBUG *)

ELSE BEGIN (* ELSE NOT $DEBUG *)

MARK 1:= SMALLTICK 1;

MARK 2:= SMALLTICK 2;

J:= 1 + TL;

END; (* END ELSE NOT $DEBUG*)

CN:= J;

MARK_MOD:= MARK_START MOD MARK_SPCNG;

WRITESTR (DISPSTR,END_CYCLE:-5);

LS:= LENGTH(TRIM(DISPSTR));

K:= (LS 1) * XCHARSIZE;

GSLT ( 6);

X:= PLOT_START; (* START OF SCALE COORD*)

SA 9-89-070

FOR I:= TL TO TH DO (* DRAW "TICK" MARKS ')

BEGIN

IF (MODE = $DEBUG) AND (* IF DEBUG MODE AND *)

((I MOD LEVEL_CYCLE) ^= 0) (* NOT CYCLE SLOT *)

THEN IF XINC > 4 (* THEN: IF LARGE ENOUGH *

THEN BEGIN (* THEN: *)

GSMOVE (X,SMALLTICK 1); (* DRAW SMALL "TICK" MARK *)

GSDRAW (X,SMALLTICK 2);

END (* END IF THEN *)

ELSE (* ELSE NOTHING *)

ELSE BEGIN (* ELSE: *)

IF (CN < MARK_START) OR (* IF NOT AT 1ST MARK YET *)

(CN MOD MARK_SPCNG ^= MARK_MOD) (* IF SMALL MARK *

THEN BEGIN (* DRAW SM Nf ALL 'TICK' MARK *)

GSMOVE (X,MARK 1);

GSDRAW (X,MARK 2);

END

ELSE BEGIN (* DRAW LARGE 'TICK' MARK *)

2 0 GSMOVE (X,LARGETICK 1);

GSDRAW (X,LARGE-_TICK 2);

IF (CN MOD HSI = MARK_MOD) (* IF MAJ SCALE INTERVAL ')

THEN BEGIN

WRITESTR (DISP_STR,CN:LS); (* WRITE CYCLE NO)

GSCHAR (X-K,SCALE_COORD,LS,DISPSTR( 1));

END; END;

CN:= CN + 1; (* INCR CYCLE NUMBER *)

END;

X:= X + XINC; (* INCR X COORDINATE *)

END; (*END FOR I *)

*%PAGE

IF CYCLEMARK

THEN BEGIN

CN:= J;

GSLTD ( 6,2,7);

FOR I:= TL TO TH DO (* DRAW "TICK" MARKS ")

IF (MODE -= $DEBUG) OR (* IF STROBE MODE OR ')

((I MOD LEVELCYCLE) = 0) (* IF CYCLE SLOT *)

THEN BEGIN

IF (CN ≥ MARK START) AND (* IF TO 1ST MARK AND *)

SA 9-89-070

(CN MOD MARK_SPCNG = MARK__MOD) (* IF LARGEMARK)

THEN BEGIN (* DRAW LARGE 'TICK' MARK *)

X:= PLOT_START + (I TL) * XINC;

GSMOVE (X,LARGETICK 2);

IF SPLITTICK

THEN BEGIN

GSDRAW (X,WAVE_TOP);

GSMOVE (X,NAMESBOT);

END;

GSDRAW (X,YMAXDIMEN);

END;

CN:= CN + 1; (* INCR CYCLE NUMBER *)

END; (*END FOR I *)

GSLTD ( 6,0,0);

END;

MODELCHANGE:= FALSE;

GSSL ( 2); (* SET CHARACTER SIZE*)

GSLT ( 3); (* set character size*)

X:= XCHARSIZE;

DISP__STR:= 'MODEL: ' l TRLM(SUBSTR(STR(MODEL),1,8));

GSCHAR (BX O +X,CB,LENGTH (DISP STR),DISPSTR( 1));

DISPSTR:= 'UCODE: '1 TRIM(SUBSTR(STR(UCODE),1,8));

GSCHAR (BX 2 +X,CB,LENGTH (DISP STR),DISPSTR( 1));

TESTCHANGE:= FALSE;

MODE CHANGE:= FALSE;

GSSL ( 2); (* set character size*) DISPSTR:= 'TEST: ' i TRIM(SUBSTR(STR(TEST),1,8));

GSCHAR (BX 1 +X,CB,LENGTH (DISPSTR),DISPSTR( 1));

3 0 WRITESTR (DISPSTR,'NSEC/LEVEL: ',NANOSLEVEL:-4);

GSCHAR (BX 3 +X,CB,LENGTH (DISPSTR),DISPSTR( 1));

IF MODE = $DEBUG (* IF DEBUG MODE *)

THEN DISPSTR:='DEBUG MODE'

ELSE WRITESTR (DISP__STR,'STROBE ',STROBEVALUE:4);

GSCHAR (BX 5 +X,CB,LENGTH (DISP STR),DISPSTR( 1));

CHECKCMPHIT (TI,T 2);

GSLT ( 3); (* set character S YELLOW*) GSSL ( 2); (* set character size*)

DATETIME (DATE,TOD); (* GET CURRENT DATE / TIME *)

DISPSTR:= STR(DATE) I' 'Jl SUBSTR(STR(TOD),1,5);

GSCHAR (BX 4 +X,CB,LENGTH (DISP_STR),DISPSTR( 1));

SA 9-89-070

IF DISPLAY_WAVE

THEN DRAWWAVE (T 1,T 2)

ELSE DRAWCHAR (T 1,T 2);

GSFRCE;

CHANGED:= FALSE; (* reset parm changed flag *)

NODRAW:

CSET_LOADED:= TRUE;

IF QPARM = 'D'

THEN I:= FSMODW ( 200,$OUT,$HIGH,$OFF);

END; (*END DRAWOUTPUT *)

%PAGE

Claims (16)

REVENDICATIONS

1 Procédé pour l'analyse graphique d'in-

formations de réseaux de circuit, utilisant une plu-

ralité d'indices visuels, caractérisé en ce qu'il comporte les étapes suivantes:

(a) Sélection d'un indice visuel représen-

tatif de l'information d'état du circuit choisie.

(b) Tri des informations de réseaux de cir-

cuit et affectation d'un point de départ à une posi-

tion physique particulière.

(c) Détermination d'une fenêtre de temps

intéressante et affichage des indices visuels en ef-

fectuant une corrélation du temps et des informations

de réseaux de circuit.

2 Procédé suivant la revendication 1, ca-

ractérisé en ce qu'il comprend en outre l'étape de réalisation d'une moyenne sur les informations de réseaux de circuit et de présentation dynamique des indices visuels représentatifs des informations de réseaux de circuit ayant fait l'objet d'une opération

de moyenne.

3 Procédé suivant la revendication 1, ca-

ractérisé en ce qu'il comprend en outre l'étape de réalisation d'un test concernant la transition dans

les informations de réseaux de circuit et de modi-

fication des couleurs d'affichage lors de la détection

d'une transition.

4 Procédé suivant la revendication 1, ca-

ractérisé en ce qu'il comprend en outre l'étape de traçage d'une valeur de segment de ligne à partir d'une dernière transition dans les informations de réseaux de circuit, dans un espace tri-dimensionnel en

tant qu'indice visuel.

Procédé suivant la revendication 1, ca-

ractérisé en ce qu'il comprend en outre la visuali-

sation d'une figure tri-dimensionnelle représentative

des informations de réseaux de circuit en tant qu'in-

dice visuel.

6 Procédé suivant la revendication 1, ca-

ractérisé en ce qu'il comprend en outre l'étape de sé-

lection de certaines informations de réseaux de cir-

cuit pour les visualiser de manière transparente.

7 Procédé suivant la revendication 1, ca-

ractérisé en ce qu'il comporte en outre l'étape de -sélection de la perspective destinée à représenter les

informations de réseaux de circuit.

8 Procédé suivant la revendication 1, ca-

ractérisé en ce qu'il comprend en outre l'étape de corrélation de la ligne de temps avec une vitesse de

visualisation de trame spatiale.

9 Procédé suivant la revendication 1, ca-

ractérisé en ce qu'il comprend en outre l'étape de visualitation des informations de réseaux de circuit en régime permanent par superposition de couleurs sur

un affichage.

Appareil pour l'analyse graphique d'in-

formations de réseaux de circuit, utilisant une plu-

ralité d'indices visuels, caractérisé en ce qu'il comprend: (a) Des moyens pour sélectionner un indice

visuel représentatif de l'information d'état de cir-

cuit choisie.

(b) Des moyens pour effectuer un tri des informations de réseaux de circuit par emplacement en

physique et pour allouer un point de départ à un em-

placement physique particulier.

(c) Des moyens pour déterminer une fenêtre de temps intéressante, et (d) Des moyens pour visualiser des indices

visuels en corrélation avec le temps et les informa-

tions' de réseaux de circuit.

11 Appareil selon la revendication 10, ca-

ractérisé en ce qu'il comprend en outre des moyens

pour réaliser une opération de moyenne sur les in-

formations de réseaux de circuit et présenter de ma-

nière dynamique des indices visuels représentatifs des informations de réseaux de circuit ayant fait l'objet

d'une opération de moyenne.

12 Appareil selon la revendication 10, ca-

ractérisé en ce qu'il comprend en outre des moyens pour réaliser un test concernant une transition dans

les informations de réseaux de circuit et pour modi-

fier des couleurs de visualisation lors de la détec-

tion d'une transition.

13 Appareil selon la revendication 10, ca-

ractérisé en ce qu'il comprend en outre des moyens pour tracer une valeur de segment de ligne à partir

d'une dernière transition dans les informations de ré-

seaux de circuit dans un espace tri-dimensionnel en

tant qu'indice visuel.

14 Appareil selon la revendication 10, ca-

ractérisé en ce qu'il comprend en outre des moyens

pour visualiser une figure tri-dimensionnelle repré-

sentative des informations de réseaux de circuit en

tant qu'indice visuel.

Appareil selon la revendication 10, ca-

ractérisé en ce qu'il comprend en outre des moyens pour sélectionner certaines informations de réseaux de

circuit en vue d'une visualisation transparente.

16 Appareil selon la revendication 10, ca-

ractérisé en ce qu'il comprend en outre des moyens pour sélectionner une perspective pour montrer les

informations de réseaux de circuit.

17 Appareil selon la revendication 10, ca-

ractérisé en ce qu'il comprend en outre des moyens pour effectuer une corrélation de la ligne de temps avec une vitesse de visualisation de trame spatiale.

18 Appareil selon la revendication 10, ca-

ractérisé en ce qu'il comprend en outre des moyens pour visualiser des informations de réseaux de circuit en régime permanent par recouvrement de couleurs sur

une visualisation.

19 Procédé d'analyse graphique d'informa-

tions de réseaux de circuit, utilisant une visualisa-

tion tri-dimensionnelle comportant une pluralité d'indices visuels, caractérisé en ce qu'il comprend les étapes suivantes:

(a) Sélection d'un indice visuel représen-

tatif de l'information d'état du circuit choisie.

(b) Détermination d'une fenêtre de temps intéressante. (c) Visualisation des indices visuels en

corrélation avec le temps et les informations de ré-

seaux de circuit sur la visualisation tri-dimension-

nelle. Procédé d'analyse d'informations d'états

dépendant du temps, utilisant une visualisation tri-

dimensionnelle comportant une pluralité d'indices visuels, caractérisé en ce qu'il comprend les étapes suivantes:

(a) Sélection d'un indice visuel représen-

tatif de l'information d'état dépendant du temps.

(b) Détermination d'une fenêtre de temps intéressante, et (c) Visualisation des indices visuels en corrélation avec le temps et l'information d'état

dépendant du temps sur la visualisation tri-dimen-

sionnelle.