©1996 by Titus Weber
Dieses Handbuch wurde im Rahmen des Laborpraktikums erstellt von:
Titus Weber, Grimmaer Str.12a, 04668 Großbothen/Sachsen,
Deutschland
Telefon: 034384 / 72906
E-Mail: Titus.Weber@irb.cs.uni-magdeburg.de
WWW: http://irb.cs.uni-magdeburg.de/~tweber
IF RV-91,
Universität "Otto von Guericke" Magdeburg,
Fakultät für Informatik,
Institut für Rechnerverbund und verteilte Betriebssyteme
Dieses Dokument wurde unter Microsoft
Windows 95 mit Microsoft Word 7.0 für Windows 95 und Shapeware
Visio 3.0 erstellt.
Für die HTML-Version wurde zusätzlich der Microsoft
Word Internet Assistant 2.0z verwendet.
Alle verwendeten Hardware- und Softwarebezeichnungen sind gleichzeitig
auch eingetragene Warenzeichen oder sollten als solche betrachtet
werden.
1. Einleitung
2.1 Grundlagen
2.3.1 Der LOGISCOPE-Workspace
2.3.2 Das Menü File
2.3.2.1 Der Menüpunkt File | Load...
2.3.2.2 Der Menüpunkt File | Set Option
2.3.2.3 Der Menüpunkt File | Save Metrics...
2.3.3 Das Menü Edit
2.3.3.1 Der Menüpunkt Edit | Properties
2.3.3.2 Der Menüpunkt Edit | Source File
2.3.4 Das Menü View
2.3.5 Das Menü Graph
2.3.6 Das Menü Component
2.3.6.1 Der Menüpunkt Component | Control Graph
2.3.6.2 Der Menüpunkt Component | Kiviat Graph
2.3.6.3 Der Menüpunkt Component | Criteria Graph
2.3.6.4 Der Menüpunkt Component | Relative Call Graph
2.3.6.5 Der Menüpunkt Component | Relative Call Measurements
2.3.7 Das Menü Global
2.3.7.1 Der Menüpunkt Global | Call Graph
2.3.7.2 Der Menüpunkt Global | Overall Kiviat Graph
2.3.7.3 Der Menüpunkt Global | Metrics Distribution ...
2.3.7.4 Der Menüpunkt Global | Criteria Distribution ...
2.3.7.5 Der Menüpunkt Global | Quality Report
2.3.8 Das Menü Help
LOGISCOPE, entwickelt von der Firma VERILOG (Frankreich), ist ein Tool zur Softwareanalyse, zur Kontrolle des Prozesses der Softwareentwicklung und zur Unterstützung der Software-Qualitätssicherung. Die Hauptfunktionen von LOGISCOPE sind die Bewertung der Komplexität von Struktur und Anweisungen eines Programmes und die Unterstützung bei der Qualitätsanalyse. Die ermittelten Meßwerte werden graphisch dargestellt. Der Einsatz dieses Tools sollte in den folgenden Phasen der Softwareentwicklung erfolgen:
- Design
- Codierung
- Testung
- Validierung.
Durch die Funktionen des Reverse Engineerings wird dem Software-Entwickler eine Hilfe zum Verständnis bestehender Softwarestrukturen gegeben. Zusätzlich kann es zur Unterstützung des Projekt-Management bei der Softwareentwicklung herangezogen werden.
LOGISCOPE ist für eine Vielzahl von Programmiersprachen verfügbar, wie z.B. C, C++, Ada, Cobol, Fortran und Pascal.
Folgende Tools sind Bestandteil von LOGISCOPE:
- Standard Analyzer (log_c++)
- Copier (log_cpy)
- Formatter (log_format)
- Metric File Parser (log_met_parser)
- Static Editor (log_edsta)
- Dynamic Editor (log_eddyn)
- Static Archiver (log_arcsta)
- Dynamic Archiver (log_arcdyn)
- Graphic Analyzer (log_gui).
Durch diese Tools bietet LOGISCOPE dem Entwickler Unterstützung
zur Erreichung der Stufen 2 und 3 des Capability Maturity Model
(CMM) des Software Engineering Institutes (SEI) und automatisiert
verschiedene Schritte des Zertifikationsprozesses nach ISO-9001
und ISO-9126.
Für weitergehende Informationen zu LOGISCOPE und Verilog
empfehle ich:
Die folgenden Ausführungen beziehen sich auf die Version 1.5.1 von LOGISCOPE.
Zur fehlerfreien Analyse eines Programmes sollte der Benutzer
sich im Softwaremeßlabor des IRB mit dem Account smlab
und dem Paßwort smlab.. einloggen. Die LOGISCOPE-Tools
laufen jedoch auch unter dem privaten IRB-Account.
LOGISCOPE bietet für die Bewertung eines Programmes zwei Möglichkeiten an:
- statische Analyse
- dynamische Analyse.
Die statische Analyse basiert auf dem Quellcode eines Programmes (siehe Abbildung 1). Im ersten Schritt erfolgt eine lexikographische und syntaktische Analyse des Quellcodes. Die Ergebnisse werden in einem sogenannten Analysis Results File (*.res) und Basic Counts File (*.cb) gespeichert. Diese werden von LOGISCOPE zur Gewinnung von Software-Metriken genutzt, wie z.B. die Bestimmung der Codekomplexität. Außerdem wird ein Indented List File (*.lst) erstellt. In diesem ist der Quellcode in übersichtlicher Form angeordnet, also eine Zeile pro Anweisung und Einrückung der Codezeilen.
Bei der dynamischen Analyse wird das Programm
in seiner Einheit getestet (siehe Abbildung 2).
Es erfolgt eine Prüfung der C1-Testabdeckung und eine Messung
der Durchlaufhäufigkeiten. Hierbei wird zusätzlich noch
ein Instrumented List File erstellt. Das Indented List
File ist mit Zeilennumerierungen und Strukturkennzeichnungen
versehen. Strukturkennzeichnungen sind dabei Instruction Blocks
(IB), Decision to Decision Paths (DDP) und Linear Code Sequences
and Jumps (LCSAJ).
- Anweisungsanzahl
- Halstead-Länge
- McCabe-Maß
- maximale Verschachtelungstiefe
- Programmpfadanzahl
- GOTO-Anzahl
- Kommentaranteil
- durchschnittliche Anweisungslänge
- Vokabularanteil
- Anzahl Einstiegs-/Ausstiegspunkte.
Die Wertebereiche für diese Maße sind abhängig
von der Programmiersprache, in dem das zu analysierende Programm
implementiert wurde. Diese Werte können vom Benutzer an seine
Anforderungen angepaßt werden, d.h. er kann seine eigenen
Software-Metriken erstellen. Dazu muß die Referenz-Datei
des LOGISCOPE-Editors geändert werden. Die Referenz-Datei
befindet sich im Installationsverzeichnis von LOGISCOPE und trägt
den Namen ref.dat oder ref_iso_9126.dat. Für
die Programmiersprache C++ hat LOGISCOPE z.B. folgende Grenzwerte
vorgegeben (Zur Beachtung: Alle in diesem Dokument
aufgeführten Metrikberechnungen beziehen sich auf die Programmiersprache
C++):
| Programmaß | Abkürzung | Minimum | Maximum |
| Number of Statements | N_STMTS | ||
| Program Length (Halstead) | PR_LGTH | ||
| Cyclomatic Number (McCabe) | VG | ||
| Max Number of Levels | MAX_LVLS | ||
| Number of Noncyclic Paths | N_PATHS | ||
| Number of Unconditional Jumps (GOTO) | UNCOND_JUMP | ||
| Comment Frequency | COM_R | ||
| Average Size of Statements | AVG_S | ||
| Vocabulary Frequency | VOC_F | ||
| Number of Entry and Exit Nodes | N_IO |
Nachfolgend eine kurze Erläuterung dieser Werte:
- Number of Statements:
- Anzahl der Anweisungen in einer Komponente (z.B. DO, FOR, IF [ELSE], RETURN, SWITCH, WHILE, BREAK, ...)
- Program Length (Halstead):
- Programmlänge als Halstead-Maß N
- N = N1 + N2
- N1...Anzahl des Vorkommens des Operators
- N2...Anzahl des Vorkommens des Operanden
- Cyclomatic Number (McCabe-Maß):
- Anzahl der linear unabhängigen Pfade in einem verbundenen Graph
- V(g) = E - N + 1
- E...Anzahl der Kanten zwischen den Knoten des Graphen
- N...Anzahl der Knoten im Graph
- Max Number of Levels:
- maximale Anzahl der Control Structures in der Funktion plus 1
- Verschachtelungtiefe
- Number of Noncyclic Paths
- Anzahl der linear unabhängigen Pfade (z.B. IF-THEN-ELSE, WHILE, CASE)
- für IF-THEN-ELSE z.B.:
- PATH(if then else endif) = PATH(body of then) + PATH(body of else)
- Number of Unconditional Jumps:
- Anzahl der unbedingten Sprunganweisungen (GOTO)
- Comment Frequency:
- Anzahl der Kommentare in Abhängigkeit von der Anweisungszahl
- COM_R = N_COM / N_STMTS
- N_COM...Anzahl der Kommentare
- Average Size of Statements:
- durchschnittliche Anweisungslänge
- AVG_S = PR_LGTH / N_STMTS
- Vocabulary Frequency:
- beschreibt die durchschnittliche Vokabularverwendung in einer Komponente
- VOC_F = (N1 + N2) / (n1 + n2)
- Rückwärtskompatibilität: VOC_F = PR_LGTH /
VOC_SZ
- VOC_SZ...Vocabular Size
- ergibt sich aus der Halstead-Vokabularanzahl bezogen auf eine Anweisung
- VOC_SZ = n = n1 + n2
- n1...Anzahl der verwendeten Operatoren
- n2...Anzahl der verwendeten Operanden
- Number of Entry and Exit Nodes:
- Anzahl der Einstiegs- (N_IN) und Ausstiegsknoten (N_OUT)
- N_IO = N_IN + N_OUT
- für Programme in der Sprache C ist N_IN immer 1
Der erste Teil einer Programmbewertung, die Quellcodeanalyse, erfolgt sowohl bei der statischen als auch bei der dynamischen Variante kommandozeilenbasiert.
Wichtig für die Analyse ist das Vorhandensein aller Include-Dateien
des zu bewertenden Programmes. Diese sollten in einem für
LOGISCOPE zugänglichen Verzeichnis liegen und beim Aufruf
des LOGISCOPE-Standard-Analyzers und -Copiers angegeben werden.
LOGISCOPE Copier (log_cpy):
Dieses Tool dient der Vorverarbeitung des Quelltextes für die Instrumentation, welche für die dynamische Analyse notwendig ist. Sämtliche #include filename-Anweisungen werden dabei in #include instrumented filename-Anweisungen umgewandelt.
Bei Aufruf von log_cpy ohne Parameter erfolgt eine
Ausgabe der möglichen Startwerte:
log_cpy [-s filename]
- [[-sun4] | [-hp8] | [-borland] | [-microsoft_15] | [-microsoft_20]]
- [-Y Standard Directory]
- [-I Directory]
- [-ddef Resource Configuration File]
- [-app [Application File]]
- [-q]
- [-make [Specific for Application Instrumentation]]
- [-i [prefix = ...] [suffix = ...] |
-ia [prefix = ...] [suffix = ...] |
-ic [prefix = ...] [suffix =
...]]
-s filename:
Pfad der zu analysierenden Quelltextdatei (absolut oder relativ).
-sun4 | -hp8 | -borland | -microsoft_15 | -microsoft_20:
Angabe der einzubeziehenden Compilerfeatures.
(Die Resource-Dateien hierfür liegen im LOGISCOPE-Verzeichnis.)
-Y Standard Directory:
Neuer Suchpfad für #include-Dateien an Stelle der Default-Liste.
-I Directory:
Neuer Suchpfad für #include-Dateien, die nicht im Standard-Verzeichnis liegen ("#include filename").
-ddef Resource Configuration File:
Datei für dialektspezifische Makros, Assertions und Standard-Verzeichnisse.
(Diese vordefinierten Komponenten befinden sich in ../LOGISCOPE/ref/gb.)
-app [Application File]:
Das Application File enthält eine Beschreibung der analysierten Datei.
Diese ist nützlich für die dynamische Analyse.
-q:
Unterdrückt die Ausgabe von Informationen während der Analyse.
-make [Specific Makefile]:
Generiert ein spezifisches Makefile und führt es aus.
-i [prefix = ...] [suffix = ...]:
Komplette Instrumentation des Quellcodes (Call und Control Daten).
Name des Instrumented Files: prefix filename suffix.ext
-ia [prefix = ...] [suffix = ...]
Nur Call Daten Instrumentation.
-ic [prefix = ...] [suffix = ...]
Nur Control Daten Instrumentation.
Für die Analyse des Beispielprogrammes (shape.cpp) wurde folgender Aufruf von log_cpy benutzt:
log_cpy -s shape.cpp -sun4 -app application.app -i prefix
= vlg_ suffix = .inst
Das enstandene Instrumented File hat den Namen vlg_shape.inst.cpp.
LOGISCOPE Standard Analyzer (log_c++):
Bei Aufruf von log_c++ ohne Parameter erfolgt ebenfalls
eine Ausgabe der möglichen Startwerte auf dem Bildschirm:
log_c++ [-s filename]
- [[-sun4] | [-hp8] | [-borland] | [-microsoft_15] | [-microsoft_20]]
- [-Y Standard Directory]
- [-I Directory]
- [-A Assertion ([tokens])]
- [-D Macro]
- [-U Macro]
- [-ddef Resource Configuration File]
- [-app [Application File]]
- [-r Results File]
- [-c [Basic Counts File]]
- [-l [Listing File]]
- [-h [Excluded Components Output File]]
- [-x [Excluded Components Input File]]
- [-q]
- [-make [Specific for Application Instrumentation]]
- [-i [prefix = ...] [suffix = ...] |
-ia [prefix = ...] [suffix = ...] |
-ic [prefix = ...] [suffix =
...]]
-s filename:
Pfad der zu analysierenden Quelltextdatei (absolute oder relativ).
-sun4 | -hp8 | -borland | -microsoft_15 | -microsoft_20:
Angabe der einzubeziehenden Compilerfeatures.
(Die Resource-Dateien hierfür liegen im LOGISCOPE-Verzeichnis.)
-Y Standard Directory:
Neuer Suchpfad für #include-Dateien an Stelle der Default-Liste.
-I Directory:
Neuer Suchpfad für #include-Dateien, die nicht im Standard-Verzeichnis liegen ("#include filename").
-A Assertion ([tokens]):
Verbindet Assertion mit dem token für die #assert-Anweisung (Preprozessor).
-D Macro:
Definiert einen Namen mit dem Wert Macro ähnlich einer #define-Anweisung.
-U Macro:
Entfernt alle Definitionen mit dem Namen Macro.
-ddef Resource Configuration File:
Datei für dialektspezifische Makros, Assertions und Standard-Verzeichnisse
(Diese vordefinierten Komponenten befinden sich in ../LOGISCOPE/ref/gb.)
-app [Application File]:
Das Application File enthält eine Beschreibung der analysierten Datei.
Diese ist nützlich für die dynamische Analyse.
-r filename.res:
Generiert ein Analysis Results File mit dem Namen filename.res.
Wenn nicht angegeben, wird es mit dem Namen source_file_root.res erstellt.
-c [filename.cb]:
Generiert ein Basic Counts File mit dem Namen filename.cb.
Wenn kein File-Name angegeben, wird es unter source_file_root.cb erstellt.
-l [filename.lst]:
Generiert ein Indented List File mit dem Namen filename.lst.
Wird bei der dynamischen Analyse zusätzlich noch der Parameter -i oder -ic angegeben, so enthält dieses Indented List File noch Control Structure Information. Wenn kein File-Name angegeben, wird es unter source_file_root.cb erstellt.
-q:
Unterdrückt die Ausgabe von Informationen während der Analyse.
-h [filename.xcd]:
Einbeziehen von Komponenten und Klassen in Include-Dateien mit dem selben Namen wie die analysierte Datei.
-x filename.icd:
Unterdrückt Resultate für die in dieser Datei aufgeführten Verzeichnisse, Dateien, Klassen oder Komponenten.
-make [Specific Makefile]:
Generiert ein spezifisches Makefile und führt es aus.
-i [prefix = ...] [suffix = ...]:
Komplette Instrumentation des Quellcodes (Call und Control Daten).
Name des Instrumented Files: prefix filename suffix.ext
-ia [prefix = ...] [suffix = ...]
Nur Call Daten Instrumentation.
-ic [prefix = ...] [suffix = ...]
Nur Control Daten Instrumentation.
Zum Abschluß der Analyse gibt das Tool einen Status Code
zurück. Dieser ist bei fehlerfreiem Durchlauf 0 (Warnungen
werden angezeigt), ansonsten 1 (ein oder mehr kritische Fehler).
Für die Analyse des Beispielprogrammes (shape.cpp) wurde folgender Aufruf von log_c++ benutzt:
log_c++ -s shape.cpp -sun4 -app application.app -r shape.res -c shape.cb
-l shape.lst -i prefix = vlg_ suffix = .inst
Nachfolgend noch einige Auszüge aus den entstandenen Dateien:
Abbildung 3: Analysis Results File
<archive V3.0>
*NA*
SOURCE
.EF.
LANG/C++
*CV*
CURRENT_VERSION
*CM*
CURRENT_VERSION
shape/main 04/24/96-16:12:39
myshape::move:int:int 04/24/96-16:12:39
myshape::draw 04/24/96-16:12:39
myshape::myshape:point:point 04/24/96-16:12:39
screen_refresh 04/24/96-16:12:39
screen_clear 04/24/96-16:12:39
put_line:int:int:int:int 04/24/96-16:12:39
put_point:int:int 04/24/96-16:12:39
on_screen:int:int 04/24/96-16:12:39
screen_destroy 04/24/96-16:12:39
screen_init 04/24/96-16:12:39
*MO*
screen_init 04/24/96-16:12:39
.EM.
LANG/C++
.DT.
INST 5
COMM 0
OOPN 12
OPEN 11
OOPT 13
OPET 7
.DC.
...
...
1 Begin 10
2 For-Loop 10 y < YMAX
3 For-Loop 11 x < XMAX
4 End-For-Loop 12 not (x < XMAX)
5 End-For-Loop 12 not (y < YMAX)
*MO*
...
Abbildung 4: Basic Counts File
< Logiscope C++ V1.5.1 >
Basic counts of class:
myshape
-------------------------------------------------------------------------------
| Number of public data | 0 | Number of public
functions | 3 |
| Number of protected data | 0 | Number of protected
functions | 0 |
| Number of private data | 3 | Number of private
functions | 0 |
| Number of inherited classes | 1 | Number of
constructors | 1 |
| Number of comments | 0 | Number of destructors
| 0 |
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
| Base classes | Base classes |
-------------------------------------------------------------------------------
| rectangle | |
-------------------------------------------------------------------------------
< Logiscope C++ V1.5.1 >
Basic counts of component:
screen_init
-------------------------------------------------------------------------------
| Number of statements | 5 | Number of comments
| 0 |
| Total number of operators |13 | Number of different
operators | 7 |
| Total number of operands |12 | Number of different
operands | 7 |
| Total number of calls | 0 | Number of different
calls | 0 |
| Number of implicite conversi. | 0 | | |
-------------------------------------------------------------------------------
-------------------------------------------------------------------------------
| Operators | Nber | Operators | Nber |
-------------------------------------------------------------------------------
| ++ | 2 | ; | 1 |
| < | 2 | = | 3 |
| [] | 2 | for(;;) | 2 |
| {} | 1 | | |
-------------------------------------------------------------------------------
...
Abbildung 5: Indented List File (statische Analyse)
#line 1 "shape.cpp"
#line 1 "shape.h"
#include "iostream.h"
const int XMAX = 40;
const int YMAX = 24;
struct point
{
int x, y;
point ()
{
}
point (int a, int b)
{
x = a;
y = b;
}
};
extern void put_point (int a, int b);
inline void put_point (point p)
...
Abbildung 6: Indented List File (dynamische Analyse)
1 #line 1 "shape.cpp"
2 #line 1 "shape.h"
3 #include "iostream.h"
4
5 const int XMAX = 40;
6
7 const int YMAX = 24;
8
9 struct point
10
11 {
12 int x, y;
13 point ()
14
15 {
16 }
17 point (int a, int b)
18
19 {
20 x = a;
21 y = b;
22 }
23 };
24
25 extern void put_point (int a, int b);
26
27 inline void put_point (point p)
...
Abbildung 7: Commented Indented List File (dynamische Analyse mit DDPs)
237 void screen_init ()
238
239 {
240 /* DDP 1 Begin */
241 for (int y = 0; y < YMAX; y++) /* DDP 2
For-Loop */
242 for (int x = 0; x < XMAX; x++) /* DDP 3
For-Loop */
243 screen [x] [y] = white;
244 /* DDP 4 End-For-Loop */
245 /* DDP 5 End-For-Loop */
246 }
...
Abbildung 8: Instrumented Source File
...
int main ()
{
vlg_cpp_cd1 ("shape/main", "04/24/96-16:12:39");
(vlg_cpp_app ("shape/main", "screen_init"),
screen_init ());
shape * p1 = (vlg_cpp_app ("shape/main",
"rectangle::rectangle:point:point"),
new rectangle ((vlg_cpp_app ("shape/main",
"point::point:int:int"),
point (0, 0)), (vlg_cpp_app ("shape/main",
"point::point:int:int"),
point (10, 10))));
shape * p2 = (vlg_cpp_app ("shape/main",
"line::line:point:int"),
...
vlg_cpp_cdf ("shape/main");
return 0;
}
...
Zur Auswertung der in der Quelltextanalyse (sowohl in der statischen
als auch in der dynamischen) gewonnenen Daten besitzt LOGISCOPE
ein graphisch orientiertes Tool. Dieses soll auf den nächsten
Seiten ausführlich beschrieben werden. Gestartet wird dieses
Tool entweder von der Eingabeaufforderung mit dem Befehl log_gui
oder mit logiscope. Einfacher ist es jedoch mittels
des mit der rechten Maustaste abrufbaren Pull-Down-Menüs
der Windows-Oberfläche (nur wenn das Einloggen mit smlab
erfolgte!). In diesem Menü befindet sich ein Punkt namens
LOGISCOPE, der ebenfalls das graphische Tool startet.
Das graphische Tool meldet sich mit dem LOGISCOPE - Current Workspace,
der Arbeitsoberfläche für die Auswertung der Meßdaten
(siehe Abbildung 9).
Beim Start wird außerdem automatisch
die Dialogbox Load (siehe Abbildung 10)
geöffnet. Auf diese wird weiter unten eingegangen. Im folgenden
werden die Menüpunkte der Startoberfläche einzeln betrachtet.
Einige Menüs passen sich der gezeigten Graphik an, d.h. sie
ändern ihren Inhalt dynamisch. Da diese Menüs allerdings
nur einige Dialogboxen zur Feinabstimmung der jeweiligen Diagramme
und Graphen beinhalten, werden sie nicht näher beschrieben.
Das Menü File besteht aus den folgenden Unterpunkten:
- Load...
- Set Option
- Control Graph
- Call Graph
- Metrics Distribution
- Print...
- Save Metrics...
- Exit.
Die Punkte Load, Set Option und Save Metrics
werden noch näher erläutert. Print druckt die
gerade angezeigte Graphik auf einen angeschlossenen Drucker oder
in eine Datei. Mit dem Menüpunkt Exit wird das Programm
beendet.
2.3.2.1 Der Menüpunkt File | Load...
Mittels dieser Dialogbox (siehe Abbildung 10)
erfolgt die Auswahl der zu analysierenden Dateien. Es kann hierbei
mittels zweier Radio-Buttons zwischen der statischen und der dynamischen
Auswertung der Meßdaten gewählt werden. Als Eingabe
erwartet LOGISCOPE das während der kommandozeilenbasierten
Quelltextanalyse erstellte Analysis Results File mit der Dateierweiterung
*.res.
Das Editor Reference File (*.dat) ist vorgegeben und braucht normalerweise nicht geändert zu werden. Die Referenz-Datei trägt den Namen ref.dat oder ref_iso_9126.dat und befindet sich im Installationsverzeichnis von LOGISCOPE (/usr/localapp/logiscope/ref/gb/). In diesem File sind u.a. die Wertebereiche für die Auswertung innerhalb des Kiviatdiagrammes (siehe Tabelle 1) gespeichert. Ist man mit diesen Vorgabewerten nicht einverstanden, so sollte eine neue Referenz-Datei erstellt oder die bestehende geändert und dann an dieser Stelle geladen werden. Die Datei sollte zu einer Änderung aber in das eigene Startup-Verzeichnis kopiert werden.
Wurde ein Analysis Results File in den LOGISCOPE Workspace geladen,
so werden sämtliche in dem Programm enthaltenen Komponenten
in einer Liste übersichtlich angezeigt (siehe Abbildung 11).
2.3.2.2 Der Menüpunkt File | Set Option
Die Erscheinungsweise der verschiedenen Diagramme bzw. Graphen
läßt sich über den Menüpunkt File | Set
Option beeinflussen. Dies betrifft den Control Graph, den
Call Graph und die Präsentation der Metrics Distribution.
Für den Control Graph kann unter
anderem der Pseudo-Code an die Programmiersprache des zu analysierenden
Files angepaßt werden und zwischen einer Darstellung des
Control Graphen mit oder ohne Zeilennummern gewählt werden
(siehe Abbildung 12).
Der Call Graph (siehe Abbildung 13) kann mit den Komponentennamen, den Komponentennummern oder mit den PPP-Zahlen präsentiert werden. PPP (Procedure to Procedure Path) ist nur bei einer dynamischen Testung verfügbar und beschreibt die Aufrufbeziehung zwischen zwei Komponenten.
Ausgeführte PPPs werden dabei im Call Graph als durchgezogene
Linien dargestellt. Nicht ausgeführte PPPs sind dagegen als
unterbrochene Linien gezeichnet.
Für die Metrics Distribution (siehe
Abbildung 14) läßt sich
eine Darstellung des Histograms mit einer Skala der berechneten
Intervalle festlegen. Die Anzeige von akzeptablen Grenzen (Limits)
als High- und Low-Werte kann zusätzlich noch erfolgen. Diese
werden dann in der graphischen Darstellung durch Pfeile repräsentiert.
Für die Ausgabe der Diagramme und
Graphen über einen angeschlossenen Drucker lassen sich die
verschiedensten Einstellungen treffen (siehe Abbildung 15).
Diese reichen von einer Nachfrage beim Nutzer bis zum direkten
Druck. Dazu muß noch der entsprechende Drucker angegeben
werden und die Art des Ausdrucks. Hier kann z.B. die Ausgabe als
PostScript gewählt werden.
2.3.2.3 Der Menüpunkt File | Save Metrics...
Die Speicherung der berechneten Metriken
kann unter dem Menüpunkt File | Save Metrics vorgenommen
werden. Dazu erscheint eine Dialogbox, in welcher der gewünschte
Name angegeben werden kann (siehe Abbildung 16).
Das Menü Edit beinhaltet folgende Punkte:
- Properties
- Source File
- Select
- All
- Complement
- From Previous View
- From Properties
- From Workspace
- Deselect All
- Component Workspaces
- Current Workspace
- Set
- Add To
- Remove From
- Invert
- Reset
- Save Cur
- Open Cur.
Die Punkte Properties und Source File werden weiter
unten ausführlicher erläutert. Mit dem Menüpunkt
Select kann die Anzahl der zu analysierenden Komponenten
des geladenen Projektes bestimmt werden. Die Verwaltung des Workspaces
von LOGISCOPE ist über die Punkte Component Workspaces
und Current Workspace möglich.
2.3.3.1 Der Menüpunkt Edit | Properties
Unter diesem Punkt werden die wichtigsten Kenndaten der aus dem Projekt ausgewählten Komponente angezeigt, also z.B. Name, Dateiname und Programmiersprache (siehe Abbildung 17).
2.3.3.2 Der Menüpunkt Edit | Source File
Der zu analysierende Quelltext wird mit dem Menüpunkt Edit
| Source File in einem Fenster angezeigt (siehe Abbildung 18).
Dabei ist die z.Zt. gewählte Komponente mit einem Pfeil versehen.
Das Menü View ist folgendermaßen aufgebaut:
- Zoom In
- Zoom Out
- Full Clip
- Textual Representation
- Info.
Mit den Menüpunkten Zoom In, Zoom Out und Full Clip läßt sich die Darstellung der Daten an die jeweilige Fenstergröße anpassen, die Ansicht vergrößern / verkleinern oder die originale Darstellungsgröße wiederherstellen.
Jede angezeigte graphische Darstellung kann auch in einer Textdarstellung eingesehen werden. Dies erfolgt über den Punkt Textual Representation. Beispiele hierfür folgen bei der Beschreibung der Graphen und Diagramme.
Informationen zu der gerade aktiven Ansichtsebene, zur geladenen
Anwendung und zu den in dem Projekt enthaltenen Komponenten erhält
der Benutzer in einer Informationsbox unter dem Menüpunkt
View | Info (siehe Abbildung 19).
Dieses Aussehen hat das Menü Graph:
- Graphic Nodes
- Source Line Numbers
- Instruction Numbers
- Source Structure
- Structured View
- Full Reduction
- Step Reduction
- Filter
- Pseudo Code Style...
Alle diese Menüpunkte wirken sich unmittelbar auf das Aussehen
der graphischen Darstellung aus. Es kann also bei den Graphen
(Control Graph, Call Graph) zwischen der Anzeige von nur graphischen
Knoten (Menüpunkt Graph | Graphic Nodes), der Anzeige
der Knoten mit Quellcodezeilennummern (Menüpunkt Graph
| Source Line Numbers) oder Anzeige der Nummern der Instruction
Blocks (Menüpunkt Graph | Instruction Numbers) gewählt
werden. Die Ansicht kann als unmodifizierte Quellcodestruktur
(Menüpunkt Graph | Source Structure) oder strukturiert
(Menüpunkt Graph | Structural View) erfolgen. Die
strukturierte View kann entweder in Einzelschritten (Menüpunkt
Graph | Step Reduction) oder sofort vereinfacht werden
(Menüpunkt Graph | Full Reduction). Das Programm ist
nach den Richtlinien der strukturierten Programmierung implementiert,
wenn sich die Untergraphen reduzieren lassen. Der Untergraph darf
somit z.B. keine Sprunganweisungen enthalten. Der reduzierte Untergraph
wird in der graphischen Darstellung des Control Graphen als einzelner
ausgefüllter Knoten dargestellt. Ein sehr gut strukturiertes
Programm läßt sich bis zu einem McCabe-Maß (Cyclomatic
Number) von 1 (V(g)=1) reduzieren. Es besitzt dann nur noch einen
einzigen Graphen. Mit dem Menüpunkt Graph | Filter
läßt sich die Anzeige des Control Graphen verändern.
Die Darstellung der Textrepräsentation des Control Graphen
läßt sich über den Menüpunkt Graph | Pseudo
Code Style einstellen.
Das Menü Component besteht aus den folgenden Unterpunkten:
- Control Graph
- Kiviat Graph
- Criteria Graph
- Relative Call Graph
- Relative Call Measurements.
Da alle Menüpunkte der Darstellung der verschiedenen Graphen
dienen, soll an dieser Stelle die Erklärung der darin verwendeten
Symbole erfolgen.
Noch etwas allgemeines zu allen Beschreibungen
von graphischen Darstellungen auf den nächsten Seiten. In
der Statusbar am unteren Bildschirmrand des LOGISCOPE-Fensters
befinden sich mehrere anklickbare Schaltfelder (Next, Previous,
Go To...). Diese sind für die Anzeige der Komponenten gedacht,
d.h. mit Next gelangt man zu der nächsten, mit
Previous zu der vorhergehenden und mit Go To...
läßt sich eine beliebige Komponente auswählen.
2.3.6.1 Der Menüpunkt Component | Control Graph
Dieser Punkt stellt den Control Graph des analysierten Programmes
dar (siehe Abbildung 25).
Die Knoten des Control Graphen können selektiert werden. Wird z.B. der Bedingungs-Knoten einer IF-THEN-ELSE-Struktur markiert, so wird automatisch der ENDIF-Knoten farblich hervorgehoben.
Zum besseren Verständnis des Graphen gibt es auch eine Ausgabe in Textform (siehe Abbildung 26).
Sämtliche wichtigen Daten und Metriken dieser ausgewählten Komponente, wie die Anzahl der Knoten, der Kanten und das McCabe-Maß, lassen sich über die Measurement Representation anzeigen (siehe Abbildung 27).
Die Darstellung der Knoten des Control
Graphen kann auf verschiedene Weise erfolgen. Dabei kann zwischen
der Beschriftung mit den Zeilennummern des Quellcodes (siehe Abbildung 28)
oder den Nummern der Anweisungsblöcke (Instruction Blocks,
IB) gewählt werden.
2.3.6.2 Der Menüpunkt Component | Kiviat Graph
Eine unmittelbare visuelle Einschätzung in Hinsicht auf eine Wertebereichsüber- oder -unterschreitung ermöglicht die Darstellung der Metriken in einem Kiviat-Diagramm (siehe Abbildung 29). Folgende Maße werden im Kiviat-Graph dargestellt:
- Number of Statements (N_STMTS)
- Program Length (Halstead, PR_LGTH)
- Cyclomatic Number (McCabe, VG)
- Max Number of Levels (MAX_LVLS)
- Number of Noncyclic Paths (N_PATHS)
- Number of Unconditional Jumps (GOTO, UNCOND_JUMP)
- Comment Frequency (COM_R)
- Average Size of Statements (AVG_S)
- Vocabulary Frequency (VOC_F)
- Number of Entry and Exit Nodes (N_IO).
Diese Metriken und deren Wertebereiche sind weiter oben schon näher beschrieben worden (siehe Grundlagen).
Jede Metrik wird durch einen "Radius" repräsentiert. Die zwei Kreise sind die akzeptierten und in der Referenz-Datei (z.B. ref.dat) angegebenen Grenzen bzw. Wertebereiche. Das Polygon dient der Darstellung der für die gewählte Komponente gemessenen Werte. Die Komponente erfüllt alle Anforderungen der jeweiligen Metrik, wenn das Polygon sich innerhalb der zwei Kreise befindet.
Auch für diese graphische Darstellung läßt sich
wieder eine Repräsentation als Text ausgeben, in der die
Metrikwerte genauer ablesbar sind (siehe Abbildung 30).
2.3.6.3 Der Menüpunkt Component | Criteria Graph
Auf der Grundlage des Kiviat-Graphen erfolgt eine Qualitätsbewertung in einem Criteria Graph (siehe Abbildung 31).
Dabei werden diese Kriterien untersucht:
- Testability
- Simplicity
- Readability
- Self-Descriptiveness.
Die Ermittlung der Werte für diese Kriterien erfolgt nach
den unter der Abbildung aufgeführten Formeln. Die entsprechende
Einstufung und die Gewichtung für den Quality-Report ist
der Referenz-Datei (z.B. ref.dat) zu entnehmen.
Testability = 40 * VG + 40 * MAX_LVLS + 20 * N_IO
Simplicity = 40 * VG + 40 * N_STMTS + 20 * AVG_S
Readability = 25 * VG + 25 * PR_LGTH + 25 * MAX_LVLS + 25 * AVG_S
Self-Descriptiveness = 100 * COM_R
Eine Textdarstellung der ermittelten Werte ist auch hier wieder
möglich (siehe Abbildung 32).
2.3.6.4 Der Menüpunkt Component | Relative Call Graph
In diesem Abschnitt wird der Call Graph allgemein beschrieben,
d.h. es wird nicht zwischen dem Menüpunkt Component |
Relative Call Graph und dem später folgenden Menüpunkt
Global | Call Graph unterschieden. Der Call Graph (siehe
Abbildung 33) bietet einen Überblick
über die Architektur einer Applikation. Ein Knoten repräsentiert
darin eine Komponente und eine Kante stellt die Aufrufbeziehung
zwischen zwei Komponenten dar.
In der Textdarstellung des Call Graphen (siehe Abbildung 34)
existieren zwei Listen. In der Components List werden die graphischen
Knoten pro Level angezeigt. Der untere Bereich zeigt eine Liste
der isolierten Komponenten. Die in der graphischen Darstellung
markierte Komponente ist auch in der Textrepräsentation markiert.
Wird hier eine andere Komponente ausgewählt, so wirkt sich
dies ebenfalls auf die graphische Ansicht aus.
2.3.6.5 Der Menüpunkt Component | Relative Call Measurements
Eine Auswertung der von LOGISCOPE für den Call Graphen ermittelten Programmaße ist über diesen Menüpunkt erhältlich. Dabei sind folgende Darstellungen wählbar:
- Calling/Called Component Table
- Accessibility Table
- Testability Table
- Call Kiviat Graph
- Call Criteria Graph.
Die Calling/Called Component Table (siehe
Abbildung 35) enthält eine
Auflistung derjenigen Funktionen, die von dem im Call Graph markierten
Knoten aufgerufen werden und der Funktionen, die wiederum von
diesen Funktionen aufgerufen werden.
In der Accessibility Table (siehe Abbildung 36)
ist die Zugriffshäufigkeit auf die jeweilige Komponente Mi
aufgeführt. Ermittelt wird diese wie folgt:
C(Mi) gibt dabei die Anzahl der durch Mi aufgerufenen
Komponenten an.
Der Einfluß der Pfadtiefe und der
Call-Anzahl auf die Testbarkeit eines Pfades wird in der Testability
Table (siehe Abbildung 37) zum
Ausdruck gebracht. Die Berechnung erfolgt nach folgender Formel:
Im Call Kiviat Graph (siehe Abbildung 38) erfolgt die graphische Auswertung mehrerer Programmaße, die im Call Graph ermittelt wurden. Dazu gehören:
- Number of Levels (LEVEL)
- Hierarchy Complexity (HIER_CPX)
- Structural Complexity (STRU_CPX)
- Average Path Number/Component (AVG_PA)
- Call Graph Entropy (ENTROPY).
Mit Number of Levels ist die Anzahl der Ebenen des Call Graphen gemeint.
Die hierarchische Komplexität ist ein Maß für die durchschnittliche Anzahl der Komponenten pro Call-Graph-Level und die strukturelle Komplexität ist die durchschnittliche Anzahl der Aufrufe pro Komponente.
Die Anzahl direkter Aufrufe (Average Path Number/Component) gibt
die Anzahl der Knotenaustrittskanten innerhalb des Strukturgraphen
an und wird nach dieser Formel berechnet:
Das wohl umfangreichste Programmaß in diesem Graph ist die Call Graph Entropie. Diese wird wie folgt ermittelt:
Dabei ist xi die Anzahl der Komponenten des i-ten Pfades.
Die nachfolgend aufgeführten Werte werden bei Verwendung
der Standard-Referenz-Datei nicht im Call Kiviat Graph angezeigt:
- Number of Nodes
- Number of Call-Paths
- Number of Edges
- System Testability.
Die Systemtestbarkeit wird mittels dieser Formel berechnet:
mit Np als Anzahl der Pfade im System und Tpi
als Testbarkeit des i-ten Aufrufpfades.
Der Criteria Graph des aktuellen Call Graphen (siehe Abbildung 39)
stellt in Abhängigkeit der soeben erläuterten Werte
die Kriterien Modularity und Clarity dar.
Das Menü Global hat den folgenden Aufbau:
- Current Workspace Components
- Call Graph
- Overall Kiviat Graph
- Metrics Distribution...
- Criteria Distribution...
- Quality Report.
Mittels des Menüpunktes Global | Current Workspace Components
werden alle Komponenten des geladenen Projektes angezeigt (siehe
Abbildung 11). Dies ist die gleiche
Ansicht des LOGISCOPE Workspaces wie zu Beginn einer Analyse mit
dem graphischen Tool, also nach dem Einladen eines Projektes.
2.3.7.1 Der Menüpunkt Global | Call Graph
Die Beschreibung dieses Menüpunktes deckt sich mit der Erläuterung
des Menüpunktes Components | Relative Call Graph.
Es wird aus diesem Grunde auf Menüpunkt Component | Relative Call Graph,
verwiesen. Der Unterschied besteht hier lediglich in der Darstellung
des Call Graphen für die gesamte Anwendung gegenüber
der Darstellung für eine einzelne Komponente dieser Anwendung.
2.3.7.2 Der Menüpunkt Global | Overall Kiviat Graph
Dieser Menüpunkt zeigt das Kiviat-Diagramm für alle
Komponenten des Current Workspaces an (siehe Abbildung 40).
Die angewandten Metriken wurden bereits erläutert (siehe
Grundlagen). Dieser Overall Kiviat Graph
gibt einen schnellen Überblick, ob die Standards für
alle Komponenten und alle Metriken erreicht wurden.
2.3.7.3 Der Menüpunkt Global | Metrics Distribution ...
In dieser Dialogbox (siehe Abbildung 41)
lassen sich die Metriken für die Darstellung in einem Balkendiagramm
auswählen. In diesem sogenannten Metrics Distribution Histogram
wird die Verteilung der Komponenten der zu analysierenden Anwendung
für die selektierte Metrik angezeigt. Als Beispiel wurde
hier die Metrik Program Length (Halstead) ausgewählt (siehe
Abbildung 42).
2.3.7.4 Der Menüpunkt Global | Criteria Distribution ...
Unter diesem Menüpunkt läßt sich ein, mehrere oder alle der in der Listbox (siehe Abbildung 43) angezeigten Kriterien für eine Auswertung in einem Criteria Distribution Histogram auswählen. Die Kriterien sind dabei:
- Testability
- Simplicity
- Readability
- Self Descriptiveness.
In dem Criteria Distribution Histogram ist die Verteilung der
Komponenten der zu analysierenden Anwendung in Bezug auf die selektierten
Qualitätsanforderungen ablesbar. Als Beispiel wurde das Kriterium
Simplicity genommen (siehe Abbildung 44).
2.3.7.5 Der Menüpunkt Global | Quality Report
Eine Zusammenfassung der Aussagen über die Qualitätsmerkmale des analysierten Programmes nach dem vom Benutzer in der Referenz-Datei (ref.dat) festgelegten Qualitätsmodell wird in dem Quality Report getroffen (siehe Abbildung 45).
Dieses Menü enthält diese Punkte:
- Index
- On Version.
Unter dem Menüpunkt Index läßt sich eine
kleine Hilfe zu einzelnen Programmpunkten abrufen und mittels
On Version die Version des LOGISCOPE-Tools erfragen.
Zurück zum Inhaltsverzeichnis
Abbildung 1: Statische Analyse
Abbildung 2: Dynamische Analyse
Abbildung 3: Analysis Results File
Abbildung 4: Basic Counts File
Abbildung 5: Indented List File (statische Analyse)
Abbildung 6: Indented List File (dynamische Analyse)
Abbildung 7: Commented Indented List File (dynamische Analyse mit DDPs)
Abbildung 8: Instrumented Source File
Abbildung 9: LOGISCOPE-Workspace
Abbildung 10: Dialog Load...
Abbildung 11: Workspace mit Project-File
Abbildung 12: Einstellungen Control Graph
Abbildung 13: Einstellungen Call Graph
Abbildung 14: Einstellungen Metrics Distribution
Abbildung 15: Einstellungen Print
Abbildung 16: Dialog Save Metrics
Abbildung 17: Properties
Abbildung 18: Anzeige des Quelltextes
Abbildung 19: Info
Abbildung 20: Symbole des Control Graphen
Abbildung 21: Darstellung von IF-THEN-ELSE-ENDIF
Abbildung 22: Darstellung von WHILE-DO-END_WHILE
Abbildung 23: Darstellung von REPEAT-UNTIL
Abbildung 24: Darstellung von CASE-OF-END
Abbildung 25: Control Graph mit Graphic Nodes
Abbildung 26: Textuelle Repräsentation des Control Graphen
Abbildung 27: Measurement Representation
Abbildung 28: Control Graph mit Quellcodezeilennummern
Abbildung 29: Kiviat Graph
Abbildung 30: Kiviat Graph - Textual Representation
Abbildung 31: Criteria Graph
Abbildung 32: Criteria Graph - Textual Representation
Abbildung 33: Call Graph
Abbildung 34: Call Graph - Textual Representation
Abbildung 35: Calling/Called Component Table
Abbildung 36: Accessibility Table
Abbildung 37: Testability Table
Abbildung 38: Call Kiviat Graph
Abbildung 39: Call Criteria Graph
Abbildung 40: Overall Kiviat Graph
Abbildung 41: Metrics Distribution
Abbildung 42: Metrics Distribution - Program Length
Abbildung 43: Criteria Distribution Selection
Abbildung 44: Criteria Distribution - Simplicity
Abbildung 45: Quality Report