Skip to content
Snippets Groups Projects
Commit 5b2a6d46 authored by Celina's avatar Celina
Browse files

ueb 7 done

parent fe4b2a6b
No related branches found
No related tags found
No related merge requests found
No preview for this file type
File added
No preview for this file type
// erstes C-Program
#include <stdio.h>
int main (void)
{
int a = 0;
int b = 0;
a = 2;
b = 3;
a = a * b;
printf("a: %i", a);
return a;
}
No preview for this file type
......@@ -3,7 +3,7 @@
\newcommand{\dozent}{Prof. Dr. Claudia Müller-Birn, Barry Linnert} % <-- Names des Dozenten eintragen
\newcommand{\tutor}{Benjamin Berendsohn} % <-- Name eurer Tutoriun eintragen
\newcommand{\tutoriumNo}{06} % <-- Nummer im KVV nachschauen
\newcommand{\ubungNo}{01} % <-- Nummer des Übungszettels
\newcommand{\ubungNo}{06} % <-- Nummer des Übungszettels
\newcommand{\veranstaltung}{Nichtsequentielle und verteilte Programmierung} % <-- Name der Lehrveranstaltung eintragen
\newcommand{\semester}{SoSe 19} % <-- z.B. SoSo 17, WiSe 17/18
\newcommand{\studenten}{Niels Thiele, Celina Loeper, Konstantin Jaehne} % <-- Hier eure Namen eintragen
......
./aufgabe1
K0: x=0.000000, y=0.000000
K1: x=10.000000, y=0.000000
K2: x=0.000000, y=10.000000
ITERATION 0
K0: x=0.066743, y=0.066743
K1: x=9.909660, y=0.023597
K2: x=0.023597, y=9.909660
ITERATION 1
K0: x=0.135329, y=0.135329
K1: x=9.816627, y=0.048043
K2: x=0.048043, y=9.816627
...
ITERATION 997
K0: x=-5.378830, y=-5.378830
K1: x=15.321764, y=0.057066
K2: x=0.057066, y=15.321764
ITERATION 998
K0: x=-5.361036, y=-5.361036
K1: x=15.297544, y=0.063492
K2: x=0.063492, y=15.297544
ITERATION 999
K0: x=-5.343170, y=-5.343170
K1: x=15.273225, y=0.069945
K2: x=0.069945, y=15.273225
elapsed time = 18693913 nanoseconds
export OMP_NUM_THREADS=4
./aufgabe2
K0: x=0.000000, y=0.000000
K1: x=10.000000, y=0.000000
K2: x=0.000000, y=10.000000
ITERATION 0
K0: x=0.066743, y=0.066743
K1: x=9.909660, y=0.023597
K2: x=0.023597, y=9.909660
ITERATION 1
K0: x=0.135329, y=0.135329
K1: x=9.816627, y=0.048043
K2: x=0.048043, y=9.816627
ITERATION 2
K0: x=0.205888, y=0.205888
K1: x=9.720698, y=0.073414
K2: x=0.073414, y=9.720698
...
ITERATION 997
K0: x=-5.378830, y=-5.378830
K1: x=15.321764, y=0.057066
K2: x=0.057066, y=15.321764
ITERATION 998
K0: x=-5.361036, y=-5.361036
K1: x=15.297544, y=0.063492
K2: x=0.063492, y=15.297544
ITERATION 999
K0: x=-5.343170, y=-5.343170
K1: x=15.273225, y=0.069945
K2: x=0.069945, y=15.273225
elapsed time = 15306967 nanoseconds
File added
// gcc -Wall -Werror -Wextra -pedantic -lm -std=gnu11 aufgabe1.c -o aufgabe1 -lrt
// ./aufgabe1
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <time.h>
#define NUM_BODY 3 // Anzahl der Koerper
#define BILLION 1000000000L
double norm3(double x, double y) { // Hilfsfunktion zur Norm hoch drei
return pow(sqrt(pow(x,2)+pow(y,2)),3);
}
int main(void) {
uint64_t diff; // Zeitunterschied
struct timespec start, end;
double G = 6.6743; // Gravitationskonstante, skaliert
double x_values[NUM_BODY]; // x-Werte der Koerper
double y_values[NUM_BODY]; // y-Werte der Koerper
double masses[NUM_BODY]; // Massen der Koerper
double mov_x[NUM_BODY]; // Bewegung in x-Richtung
double mov_y[NUM_BODY]; // Bewegung in y-Richtung
x_values[0] = 0; // Initialisierung mit geeigneten Werten
x_values[1] = 10;
x_values[2] = 0;
y_values[0] = 0;
y_values[1] = 0;
y_values[2] = 10;
masses[0] = 1;
masses[1] = 1;
masses[2] = 1;
struct timespec ts;
timespec_get(&ts, TIME_UTC);
clock_gettime(CLOCK_MONOTONIC, &start); // bekomme aktuelle Zeit
for (int n = 0; n < NUM_BODY; n++) { // Anfangszustand ausgeben
printf("K%d: x=%f, y=%f \n", n, x_values[n], y_values[n]);
}
for (int i = 0; i < 1000; i++) {
for (int j = 0; j < NUM_BODY; j++) { // momentane Bewegung initialisieren
mov_x[j] = 0;
mov_y[j] = 0;
}
for (int jj = 0; jj < NUM_BODY; jj++) { // Fuer jeden Koerper ...
for (int t = 0; t < NUM_BODY; t++) { // Interferenz mit anderen Koerpern betrachten
if (t != jj) {
double dist = norm3(x_values[jj]-x_values[t],y_values[jj]-y_values[t]); // Distanz der momentan betrachteten Koerper
double koeff = G * masses[jj]*masses[t]/dist; // Koeffizient der Bewegung
mov_x[jj] = mov_x[jj] + koeff*(x_values[t]-x_values[jj]); // Bewegungsaenderung in x durch zweiten Koerper berechnen
mov_y[jj] = mov_y[jj] + koeff*(y_values[t]-y_values[jj]); // Bewegungsaenderung in y durch zweiten Koerper berechnen
}
}
}
for (int jjj = 0; jjj < NUM_BODY; jjj++) {
x_values[jjj] = x_values[jjj] + mov_x[jjj]; // Durchfuehren der errechneten Bewegung in x
y_values[jjj] = y_values[jjj] + mov_y[jjj]; // Durchfuehren der errechneten Bewegung in y
}
printf("ITERATION %d\n", i);
for (int m = 0; m < NUM_BODY; m++) { // momentanen Zustand ausgeben
printf("K%d: x=%f, y=%f \n", m, x_values[m], y_values[m]);
}
}
clock_gettime(CLOCK_MONOTONIC, &end); // bekomme aktuelle Zeit
diff = BILLION * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec; // berechne Differenz
printf("\nelapsed time = %llu nanoseconds\n", (long long unsigned int) diff);
//https://www.cs.rutgers.edu/~pxk/416/notes/c-tutorials/gettime.html
}
// gcc -Wall -Werror -Wextra -pedantic -lm -std=gnu11 aufgabe2.c -o aufgabe2 -fopenmp -lrt
// export OMP_NUM_THREADS=4
// ./aufgabe2
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>
#include <omp.h>
#include <time.h>
#define NUM_BODY 3 // Anzahl der Koerper
#define BILLION 1000000000L
double norm3(double x, double y) { // Hilfsfunktion zur Norm
return pow(sqrt(pow(x,2)+pow(y,2)),3);
}
int main(void) {
uint64_t diff; // Zeitunterschied
struct timespec start, end;
double G = 6.6743; // Gravitationskonstante, skaliert
double x_values[NUM_BODY]; // x-Werte der Koerper
double y_values[NUM_BODY]; // y-Werte der Koerper
double masses[NUM_BODY]; // Massen der Koerper
double mov_x[NUM_BODY]; // Bewegung in x-Richtung
double mov_y[NUM_BODY]; // Bewegung in y-Richtung
x_values[0] = 0; // Initialisierung mit geeigneten Werten
x_values[1] = 10;
x_values[2] = 0;
y_values[0] = 0;
y_values[1] = 0;
y_values[2] = 10;
masses[0] = 1;
masses[1] = 1;
masses[2] = 1;
struct timespec ts;
timespec_get(&ts, TIME_UTC);
clock_gettime(CLOCK_MONOTONIC, &start); // bekomme aktuelle Zeit
for (int n = 0; n < NUM_BODY; n++) { // Anfangszustand ausgeben
printf("K%d: x=%f, y=%f \n", n, x_values[n], y_values[n]);
}
for (int i = 0; i < 1000; i++) {
for (int j = 0; j < NUM_BODY; j++) { // momentane Bewegung initialisieren
mov_x[j] = 0;
mov_y[j] = 0;
}
#pragma omp for
for (int jj = 0; jj < NUM_BODY; jj++) { // Fuer jeden Koerper ...
for (int t = 0; t < NUM_BODY; t++) { // Interferenz mit anderen Koerpern betrachten
if (t != jj) {
double dist = norm3(x_values[jj]-x_values[t],y_values[jj]-y_values[t]); // Distanz der momentan betrachteten Koerper
double koeff = G * masses[jj]*masses[t]/dist; // Koeffizient der Bewegung
mov_x[jj] = mov_x[jj] + koeff*(x_values[t]-x_values[jj]); // Bewegungsaenderung in x durch zweiten Koerper berechnen
mov_y[jj] = mov_y[jj] + koeff*(y_values[t]-y_values[jj]); // Bewegungsaenderung in y durch zweiten Koerper berechnen
}
}
}
for (int jjj = 0; jjj < NUM_BODY; jjj++) {
x_values[jjj] = x_values[jjj] + mov_x[jjj]; // Durchfuehren der errechneten Bewegung in x
y_values[jjj] = y_values[jjj] + mov_y[jjj]; // Durchfuehren der errechneten Bewegung in y
}
printf("ITERATION %d\n", i);
for (int m = 0; m < NUM_BODY; m++) { // momentanen Zustand ausgeben
printf("K%d: x=%f, y=%f \n", m, x_values[m], y_values[m]);
}
}
clock_gettime(CLOCK_MONOTONIC, &end); // bekomme aktuelle Zeit
diff = BILLION * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec; // berechne Differenz
printf("\nelapsed time = %llu nanoseconds\n", (long long unsigned int) diff);
//https://www.cs.rutgers.edu/~pxk/416/notes/c-tutorials/gettime.html
}
ueb07/test 100644 → 100755
No preview for this file type
// erstes C-Program
#include <stdio.h>
#include <stdio.h> /* for printf */
#include <stdint.h> /* for uint64 definition */
#include <stdlib.h> /* for exit() definition */
#include <time.h> /* for clock_gettime */
#define BILLION 1000000000L
int main(void)
{
int a = 0;
int b = 0;
a = 2;
b = 3;
a = a * b;
printf("a: %i", a);
return a;
uint64_t diff;
struct timespec start, end;
int i;
/* measure monotonic time */
clock_gettime(CLOCK_MONOTONIC, &start); /* mark start time */
sleep(1); /* do stuff */
clock_gettime(CLOCK_MONOTONIC, &end); /* mark the end time */
diff = BILLION * (end.tv_sec - start.tv_sec) + end.tv_nsec - start.tv_nsec;
printf("elapsed time = %llu nanoseconds\n", (long long unsigned int) diff);
}
File added
......@@ -3,7 +3,7 @@
\newcommand{\dozent}{Prof. Dr. Claudia Müller-Birn, Barry Linnert} % <-- Names des Dozenten eintragen
\newcommand{\tutor}{Benjamin Berendsohn} % <-- Name eurer Tutoriun eintragen
\newcommand{\tutoriumNo}{06} % <-- Nummer im KVV nachschauen
\newcommand{\ubungNo}{01} % <-- Nummer des Übungszettels
\newcommand{\ubungNo}{07} % <-- Nummer des Übungszettels
\newcommand{\veranstaltung}{Nichtsequentielle und verteilte Programmierung} % <-- Name der Lehrveranstaltung eintragen
\newcommand{\semester}{SoSe 19} % <-- z.B. SoSo 17, WiSe 17/18
\newcommand{\studenten}{Niels Thiele, Celina Loeper, Konstantin Jaehne} % <-- Hier eure Namen eintragen
......@@ -12,56 +12,31 @@
\begin{document}
\input{src/titlepage} % erstellt die Titelseite
% /////////////////////// Aufgabe 1 /////////////////////////
\section{Korrektheit \hfill (10 Punkte)}
Beschreiben Sie kurz (stichpuntartig) was notwendig ist, damit Ihre Programme korrekt ausgeführt werden.
\section{N-Body in C \hfill (10 Punkte)}
In einem zwei-dimensionalem Universum (Fläche) befinden sich mehrere Objekte. Für diese Objekte wird angenommen, dass sie eine Masse haben, aber keine Fläche einnehmen (Massepunkte). Die Massepunkte ziehen sich gegenseitig an. Die Anziehungskraft wird durch die Masse und die Entfernung voneinander bestimmt. Implementieren Sie in C eine Simulation des Problems als sequentielles Programm. Wählen Sie für alle Eingaben und Bedingungen geeignete Werte. Dokumentieren Sie Ihr jeweiliges Programm und stellen Sie immer die Ausgaben des jeweiligen Programms zur Verfügung.
\begin{itemize}
\item Korrekter Ablauf
\begin{itemize}
\item korrekte Umsetzung der Befehle \& Funktionen
Compiler, Hardware
\item befehle unabhängig von Zeitpunkt \& Umgebung korrekt ausgeführt
\end{itemize}
\item Determinieren
\begin{itemize}
\item jeder programmdurchlauf liefert bei gleichem Eingabedaten, gleichen Endzustand
\end{itemize}
\end{itemize}
Quelle: Vorlesung 2 Determinismus, Folien 4 ff
% ///////////////////// Aufgabe 2 ///////////////////
\section{Programmierung in C \hfill (12 Punkte)}
Richten Sie sich eine Programmierumgebung für die Programmierung in C ein.
Beschreiben Sie Ihre Umgebung kurz (stichpunktartig) und testen Sie die Beispiele aus der Vorlesung.
Geben Sie zudem an, welche Möglichkeiten der Fehlersuche und -behandlung Ihnen zur Verfügung stehen.
\lstinputlisting[style=C, title=Aufgabe 1]{aufgabe1.c}
\newpage
\lstinputlisting[style=C, firstline=1, lastline=27, title=Ausgabe Aufgabe 1]{Ausgabe.txt}
\begin{itemize}
\item visualstudio code
\begin{itemize}
\item \"fancy\" gui editor mit C/C++ Extension
\item eher IDE als reiner editor
\item debugging mittels print an entsprechende stelle setzen
\item oder eingebautes debugging tool benutzen
\end{itemize}
\item (n)vim \& gcc
\begin{itemize}
\item CLI editor und standard c compiler
\item mit vielen plugins erweiterbar und individualisierbar
\item code wird mit gcc compiliert und gelinked
\item debugging mittels print
\item oder mit gdb (GNU Debugger)
\end{itemize}
\end{itemize}
% ///////////////////// Aufgabe 2 ///////////////////
\section{N-Body mit OpenMP \hfill (10 Punkte)}
Erweitern Sie Ihre Lösung der Aufgabe 1 mit Hilfe von OpenMP so, dass geeignete Bereiche der Simula- tion durch mehrere Prozessoren parallel bearbeitet werden.
\lstinputlisting[style=C, title=Aufgabe 2]{aufgabe2.c}
\newpage
\lstinputlisting[style=C, firstline=29, lastline=61, title=Ausgabe Aufgabe 2]{Ausgabe.txt}
% ///////////////////// Aufgabe 3 ///////////////////
\section{Performance \hfill (8 Punkte)}
Beschreiben Sie mindestens eine sinnvolle Anwendung, die durch eine Ausführung mit mehreren Prozessen einen Geschwindigkeitszugewinn erfahren kann. Geben Sie an, an welcher Stelle der Programmausführung der Geschwindigkeitsgewinn erzielt wird.
\section{Bewertung der Lösungen \hfill (10 Punkte)}
Vergleichen Sie Ihre Lösungen aus Aufgabe 1 und 2 bei der Ausfhrung mit einem Prozessor. Ermitteln Sie den Speed-up Ihrer Lösung der Aufgabe 2 mindestens bis zur Benutzung von 4 Prozessoren. Wie wird sich der Speed-up für Ihre Lösung beim Einsatz weiterer Prozessoren vermutlich entwickeln? Begründen Sie Ihre Antwort.
Falls mehrere Prozessoren zur Verfügung stehen: Quicksort\\
Da bei Quicksort in einem Rekursionsschritt die Teillisten jeweils unabhängig voneinander bearbeitet werden können, würde die parallele Bearbeitung der linken und rechten Teilliste einen Geschwindigkeitsgewinn erzielen. Es würde schon genügen, den Algorithmus beim ersten Rekursionsaufruf einmalig in zwei Prozesse aufzuteilen und die linke und rechte Teilliste mit regulärer Quicksort separat sortieren zu lassen, was den Algorithmus etwa doppelt so schnell ausführen sollte. Alternativ könnte diese Teilung bei jedem Rekursionsaufruf geschehen, wobei der zusätzliche Geschwindigkeitsgewinn von der Anzahl der Prozessoren limitiert wird.\\
Das erste Programm benötigt $18693913$ $ns$. Während das zweite Programm mit vier Threads
$15306967$ $ns$ benötigt. Das heißt das das zweite Programm $3386946$ $ns$ schneller läuft.
Ob wir mit mehr als 4 Threads schneller oder langsamer sind, kommt darauf an wie oft wir die for-Schleife
durchlaufen. Wenn sie bei $1000$ Durchläufen bleibt, dann wird das Programm mit 5 Threads schneller laufen als mit 4.
Mit 6 Threads werden wir langsamer als mit 5 Threads, bleiben aber trotzdem noch schneller als mit 4 Threads.
Quelle: \url{https://en.wikipedia.org/wiki/Quicksort#Parallelization}
% /////////////////////// END DOKUMENT /////////////////////////
\end{document}
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment