Werden bei der Programmierung in C zusammengesetzten Datentypen wie struct verwendet ist es möglich, dass aus Gründen des Alignments zwischen den Teilelementen der Struktur nicht genutzte Füllbytes eingefügt werden. Zurückzuführen ist das Einfügen dieser Füllbytes auf die Rechnerarchitektur und die Art und Weise wie ein Prozessor auf den Hauptspeicher zugreift. Wenn ein Prozessor Daten aus dem Hauptspeicher liest, dann erfolgt der Zugriff mit der Verarbeitungsbreite des Prozessors. Ist der Prozessor ein 32-bit Prozessor, dann werden in einem Schritt 4 Byte gelesen. Diese Annahme gilt für alle weiteren Beispiele.

Ein Datenelement ist dann richtig im Speicher angeordnet, wenn seine Speicheradresse einem ganzzahligen Vielfachen seiner Größe entspricht. Für diesen Fall kann der Prozessor das Datenelement optimal einlesen (ohne Überlappung und notwendige Verschiebung) und das Datenelement wird als aligned bezeichnet. Werden nun Elemente mit unterschiedlichen Speichergrößen wie unsigned short (2 Byte), unsigned char (1 Byte) oder unsigned int (4 Byte) in einem Verbunddatentyp gemischt verwendet ist es möglich, dass Füllbytes eingefügt werden um das Alignment zu gewährleisten.

Zur weiteren Erklärung soll nun folgende Datenstruktur betrachtet werden:

struct test_data {
        unsigned short alpha;
        unsigned char beta;
        unsigned int gamma;
        unsigned char delta;
};

In dieser Datenstruktur wird zwischen den Elementen beta und gamma ein Füllbyte eingefügt um gamma entsprechend den Alignment-Anforderungen auszurichten. Das Füllbyte ist notwendig, da alpha und beta zusammen 3 Byte, also beispielhaft die Adressen 0 bis 2 belegenen und gamma als Datentyp mit 4 Byte Speicherbedarf auf Adresse 4 ausgerichtet wird. Die Adresse 3 bleibt dann ungenutzt und geht als verfügbarer Speicher verloren. Diese Löcher in den Strukturen sind nicht optimal und können teilweise durch Umordnen der Elemente entfernt werden. Das manuelle Berechnen dieser Löcher ist zwar möglich, durch geeignete Werkzeuge allerdings auch automatisierbar.

Das Linux-Werkzeug pahole (Poke-a-Hole) ist ein Hilfsmittel um Datenstrukturen zu analysieren, Alignement-Löcher zu identifizieren und Umordnungsvorschläge anzugeben. Ziel ist die Reduzierung von Strukturgrößen im Speicher und dadurch die Reduzierung des Speicherbedarfs von Programmen während der Laufzeit. Ein wichtiger Effekt ist außerdem die bessere Ausnutzung von Caches und dadurch eine Beschleunigung des Programms bei Speicheroperationen. Durch die Entfernung der Füllbytes entsteht eine geringere Belastung des Speicherbusses.

Da pahole kein Tool zur statischen Quellcodeanalyse ist, sondern den mit Debug-Informationen ausgestatteten Object-Code untersucht, sind neben dem Build-Werkzeug cmake zum Kompilieren noch weitere Bibliotheken zur Unterstützung des DWARF2-Debug-Formates notwendig. Die Installation erfolgt unter Ubuntu mit:

sudo aptitude install libdw-dev libelf-dev cmake

Der Programmcode von pahole ist aufgrund des Ursprungs in der Linux-Kernel-Entwicklergemeinde im Kernel-Git-Repository verfügbar, man erhält den Quellcode mit folgendem Befehl:

git clone git://git.kernel.org/pub/scm/linux/kernel/git/acme/pahole.git

Unter Ubuntu 9.10 Karmic Koala ist unter Umständen wie in diesem Bugreport beschrieben vor dem Kompilieren noch ein Patch notwendig. Dabei ist der find_library Ausdruck für EBL_LIBRARY in cmake/modules/FindDWARF.cmake durch set (EBL_LIBRARY -ldw) zu ersetzen.

Das Kompilieren und die Installation erfolgt dann im Verzeichnis pahole mit den Befehlen:

mkdir build
cd build
cmake -DCMAKE_INSTALL_PREFIX=/usr ..
make
sudo make install

Das zu untersuchende Programm hello oder Object-File hello.o ist dann mit dem Compiler im Debug-Modus, also gcc -g zu kompilieren. Der Befehl

pahole hello

beziehungsweise

pahole hello.o

gibt dann einen Bericht in folgender Art für alle verwendeten, nicht-anonymen Strukturen aus:

struct test_data {
	short unsigned int         alpha;        /*     0     2 */
	unsigned char              beta;         /*     2     1 */
 
	/* XXX 1 byte hole, try to pack */
 
	unsigned int               gamma;        /*     4     4 */
	unsigned char              delta;        /*     8     1 */
 
	/* size: 12, cachelines: 1, members: 4 */
	/* sum members: 8, holes: 1, sum holes: 1 */
	/* padding: 3 */
	/* last cacheline: 12 bytes */
};

Der hinzugefügte Kommentar enthält für jedes Element die Adresse in Bezug auf den Anfang der Struktur und die Größe des Elementes. Zusätzlich werden Löcher in den Strukturen und die Gesamtgröße der Struktur angegeben.

Neben der Identifikation der ungenutzten Speicherbereiche kann mit dem Befehl

pahole -RC test_data hello

auch ein Hinweis für die Reorganisation der Elemente ausgegeben werden. Im vorhandenen Beispiel wäre dies die Anordnung des Elementes delta nach beta und vor gamma um das Loch von einem Byte zu füllen.

Abschließend bleibt anzumerken, dass die Relevanz dieser Optimierungen auf modernen 64-bit Architekturen höher ist, da durch die größere Verarbeitungsbreite Löcher in den Strukturen häufiger auftreten und diese auch größer sind.

Ähnliche Artikel:

1. Hardware-PWM für Foxboard G20
2. Arithmetik ohne Begrenzungen

Eine einfache, experimentelle Erkundung des Syracuse-Problems könnte so aussehen:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <stdio.h>
 
int main()
{
    int a;
 
    scanf("%d", &a);
 
    while (a != 1) {
	printf("%d ", a);
	a = syracuse(a);
    }
 
    printf("1\n");
 
    return 0;
}
 
int syracuse(int n)
{
    if (n % 2) {
	return 3 * n + 1;
    } else {
	return n / 2;
    }
}

Mit der GNU MP Bignum Library wird daraus:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#include <stdio.h>
#include <gmp.h>
 
void mpz_syracuse(mpz_t n);
 
int main()
{
    mpz_t a;
    mpz_init(a);
 
    mpz_inp_str (a, NULL, 0);
 
    while ( mpz_cmp_si(a,1) ) {
	mpz_out_str (NULL, 0, a);
	printf("\n");
	mpz_syracuse(a);
    }
 
    printf("1\n");
 
    return 0;
}
 
void mpz_syracuse(mpz_t n)
{
    if (mpz_divisible_ui_p(n,2)) {
	mpz_divexact_ui (n, n, 2);
    } else {
	mpz_mul_ui (n, n,3);
	mpz_add_ui (n, n, 1);
    }
}

Damit kann man dann auch für sehr große natürliche Zahlen die Zahlenfolge bestimmen, kompiliert wird wie gewohnt, allerdings muss man mit -lgmp linken.

Ähnliche Artikel:

1. Statische Codeanalyse mit Uno
2. Unmaintainable Code
3. Mathematik ist.

Uno ist ein Tool, mit dem man nach drei der häufigsten Fehlerarten in C-Quellcode suchen kann:

• Nutzung uninitialisierter Variablen
• Dereferenzierung von NULL-Pointern
• Bereichsüberschreitung bei der Array-Adressierung

Entsprechende Beispiele und ein Download des Werkzeuges sind auf der Seite von Uno zu finden. Eine kurze Probe hier hat gezeigt, daß sich sowohl einfache Beispiele konstruieren lassen bei dem Dereferenzierungsfehler gefunden werden, als auch Beispiele, bei dem das Werkzeug die Fehler übersieht.

Hier wird der Fehler gefunden:

1
2
3
4
5
6
7
8
9

int *ptr;
 
int main() {
    if (ptr)
        *ptr = 123;
    else
        *ptr = 345;
    return 0; 
}

uno:#1: possible global use or deref before def:
[R ptr global_nullptr_deref.c 9]
in fct main global_nullptr_deref.c 4

und hier nicht:

1
2
3
4
5
6
7
8
9
10
11

int main() {
 
    int *ptr;
    ptr = NULL;
 
    if (ptr)
        *ptr = 123;
    else
        *ptr = 345;
    return 0;
}

Generell ist die quelloffene Verfügbarkeit von leistungsfähigen Werkzeugen zur Codeanalyse nicht gegeben, die Werkzeuge übersehen Fehler oder liefern zuviele Falschpositive. Professionelle Tools wie Coverity stehen wiederum nicht zur freien Verfügung. Wer sich mehr mit diesem Thema beschäftigen will, findet allerdings auf der Seite von Dawson Engler, dem Gründer von Coverity, einen guten Einstiegspunkt mit ein paar interessanten Veröffentlichungen, auch zur probalistischen Analyse von Quellcode.

Ähnliche Artikel:

1. Arithmetik ohne Begrenzungen
2. Unmaintainable Code
3. Cache Attack auf AES

Allem gemeinsam ist, dass die Intelligenz der Geräte durch Microcontroller verwirklich wird. Bei mikrocontroller.net findet man gute Dokumentation, unter anderem ein umfassendes Tutorial zur Atmel-Programmierung in C.

Ähnliche Artikel:

1. AVR Butterfly
2. The Code Linux
3. FOX Board G20

#include <stdio.h>
float o=0.075,h=1.5,T,r,O,l,I;int _,L=80,s=3200;main(){for(;s%L||
(h-=o,T= -2),s;4 -(r=O*O)<(l=I*I)|++_==L&&write(1,(--s%L?_<L?--_
%6:6:7)+"123456 \n",1)&&(O=I=l=_=r=0,T+=o/2))O=I*2*O+h,I=l+T-r;}

Wem so etwas Spaß macht, sollte einfach mal das Unmaintainable Code Howto von Roedy Green anschauen.

Ähnliche Artikel:

1. Arithmetik ohne Begrenzungen
2. Statische Codeanalyse mit Uno
3. The Code Linux

Ähnliche Artikel:

1. Datenspuren 2005
2. Dresden-Events Herbst 2005
3. Prof. Tanenbaum in Dresden

Ähnliche Artikel:

1. Speicheroptimierung mit pahole

“The Art of Computer Programming” von Donald E. Knuth ist eines der Standardwerke der Informatik. In drei Bänden werden die Themen Fundamentale Algorithmen, (Semi-)Numerische Algorithmen und Suchen und Sortieren umfassend behandelt. Nach Angaben des Autors ist das Werk mit ingesamt sieben Bänden geplant. Um dieses sehr große Projekt umzusetzen, hatte Knuth sich bereits 1992 emeritieren lassen.

Mittlerweile sieht es so aus als ob ein vierter Band über kombinatorische Probleme (Backtracking, Graphentheorie, Optimierung) erscheinen wird. Auf den Seiten von Professor Knuth finden sich bereits erste Vordrucke. Als Gesamtwerk steht TAOCP auf jeden Fall auf meiner Wunschliste!

Update (Sommer 2009):
Die Teile 0-4 (Fascicles) des vierten Bandes sind im Buchhandel erhältlich und sollen zu gegebener Zeit als Gesamtband veröffentlicht werden.

Ähnliche Artikel:

1. Graphentheorie
2. Open Source Jahrbuch 2007
3. Abelpreis 2005