Portierung von Java nach C

Portierung von Java nach C
EDV1 - Portierung Java C
Verbindungen zwischen Java und C
• Warum Verbindung zwischen Java und C?
• Java und C haben unterschiedliche Vor- und Nachteile
EDV1 - Portierung Java C
2
Java
C
Portabilität
++
+
Geschwindigkeit des Programms
-
+
Standardisierung der GUI
++
-
Standardisierung der Sprache
++
+
Verfügbarkeit von Software
+
++
Programmsicherheit
++
-
Programmwartbarkeit
++
0
EDV1 - Portierung Java C
3
• In nutzerfreundlichen Anwendungen wird der weit Überwiegende
Teil (z.B. 95%) des Programmtextes für die Oberfläche und die
Behandlung von Fehlern und Ausnahmen benötigt. Der Rest (z.B.
5%) wird für die Realisierung des eigentlichen Inhaltes (z.B. der
Numerik) entwickelt.
• Andererseits wird der weit überwiegende Teil der Rechenzeit (z.B.
99%) in einem sehr kleinen Teil des Quelltextes verbraucht. Der
Rest (z.B. 1%) wird für die Realisierung der Oberfläche und für die
Behandlung von Fehlern und Ausnahmen benötigt.
• Ein größeres Projekt besteht also in der Regel aus einem großen
Teil in dem wenig Ressourcen benötigt werden, der aber sehr
kompliziert zu entwickeln ist und einem kleinen Teil der die
Ressourcen verbraucht aber relativ einfach strukturiert ist.
• Für die Entwicklung der Oberfläche eignet sich Java sehr gut.
Für die Programmierung des numerischen Kernes eignet sich C
(oder FORTRAN) besser.
• Es ergibt sich die Notwendigkeit Java und C zu "verheiraten".
Umsetzung von Java nach C
EDV1 - Portierung Java C
4
• Die Entwicklung eines Algorithmus ist sehr günstig in Java zu
realisieren. Wenn das Programm ausgereift ist kann es dann in
C umgesetzt werden, um die notwendige Geschwindigkeit zu
erreichen.
• Mögliche Vorgehensweise:
– Entwickeln und Testen des Programms in Java
– Feststellen der Ressourcen-kritischen Programmteile mit
Hilfe eines Profilers
– Umsetzen der Ressourcen-kritischen Programmteile nach C
QuickSort.java
EDV1 - Portierung Java C
5
public class QuickSort
{
static long Vergleich = 0;
static long Tausch = 0;
static long Aufruf = 0;
public static void QuickSort(double[] v)
{
QuickSort(v, 0, v.length-1);
}
EDV1 - Portierung Java C
6
public static void QuickSort(double[] v, int l, int r){
Aufruf++;
int i = 0; int j = 0;
double x = 0; double h = 0;
i = l; j = r;
x = v[(l+r)/2];
do
{
while (v[i] < x) { i++; Vergleich++; }
while (x < v[j]) { j--; Vergleich++; }
if (i <= j)
{
h = v[i];
v[i] = v[j];
v[j] = h;
i++; j--;
Tausch++;
}
} while (i <= j);
if (l < j) QuickSort(v, l, j);
if (i < r) QuickSort(v, i, r);
}
}
static long Vergleich = 0;
static long Tausch = 0;
static long Aufruf = 0;
Umsetzung in C
EDV1 - Portierung Java C
7
In einem Modul:
int Vergleich;
int Tausch;
int Aufruf;
In weiteren Modul:
extern int Vergleich;
extern int Tausch;
extern int Aufruf;
Die Initialisierung von extern-Variablen ist nicht erlaubt. Es muss
also eine explizite Initialisierung im Programm stattfinden:
Vergleich = 0;
Tausch = 0;
Aufruf = 0;
Programmkopf:
public static void QuickSort(double[] v)
bzw.
public static void QuickSort(double[] v,int l,int r)
EDV1 - Portierung Java C
Umsetzung in C
Programmkopf:
void QuickSort(double[] v, int len-1)
Der zweite Aufruf kann ersetzt werden durch:
QuickSort(v+l,r-l);
V[0] V[1]
8
V[l]
V[r]
V+l[0]
V+l[r-l]
V[len-2] V[len-1]
EDV1 - Portierung Java C
9
Aufruf++;
int i = 0; int j = 0;
double x = 0; double h = 0;
i = 0
l; j = r;
r
x = v[(l+r)/2];
do
{
while (v[i] < x) { i++; Vergleich++; }
while (x < v[j]) { j--; Vergleich++; }
if (i <= j)
{
h = v[i];
v[i] = v[j];
v[j] = h;
i++; j--;
Tausch++;
}
} while (i <= j);
if (l0 < j) QuickSort(v, l, j );
if (i < r) QuickSort(v,+i,r-i
i, r
);