flashpixx

Schau Dir im Router / DHCP Server an, was konfiguriert ist und vergleiche das mit den Einstellungen am Rechner. Du solltest erst prüfen, ob es Probleme am Router gibt (d.h. wie schon genannt tracert, nslookup und ggf ping auf dem Router laufen lassen, bei den meisten Geräten gibt es dafür ein CLI). Wenn das fehlerfrei läuft ist die Verbindung bis zum Router in Ordnung, dann im Grunde das gleiche von den Rechnern.

Nein das ist falsch. Es sagt nur dass Du keine IP, Subnetzmaske, DNS & Router IP per DHCP bekommen hast und der Rechner via Zeroconf selbst eine IP sucht. Das bringt rein gar nichts, ständig Verbindung zu trennen und wieder aufzubauen. Wenn man via "ipconfig /renew" den Rechner anweist eine neue IP beim DHCP Server anzufordern ist es analog zu dem ständigen Verbindungsab- und aufbau. Eine statische Einstellung der Daten sollte ebenfalls funktionieren, sofern sie korrekt ist und die Hardware richtig konfiguriert ist. Grundsätzlich wäre ein überlegtes Vorgehen sinnvoll: Modem + Router prüfen und richtig konfigurieren und sicherstellen, dass sie auch funktionieren im nächsten Schritt Rechner anbinden und ebenfalls prüfen ob die Einstellungen richtig sind und auch wenn DHCP eingesetzt wird prüfen, ob die Daten korrekt vom DHCP Server an die Rechner übermittelt wurden. Treten dann weiter Probleme auf, dann ist der Fehler an den Rechnern zu suchen

Danke dafür. Genau das ist wohl der Kern. Mein Ziel ist, dass man Spaß und auch Freude dabei hat und eben auch der Lerneffekt da ist. Es ist natürlich einfach, wenn man z.B. weiß wie man Broadcastadresse oder Netzwerkadresse berechnet, wenn man das schon x-mal gemacht hat. Ich denke da nicht mehr wirklich drüber nach, genauso wenn ich Daten über das Netz auslesen will, DNS Auflösung, Socket erzeugen, Daten übertragen. Mein Problem ist, dass ich primär Probleme habe, die sich mit Hilfe der Boost (dort überwiegend der Ublas Bereich) und LAPack beschäftigen, also keine GUIs o.ä. Teilweise eben noch Netzwerkanbindung wie eben die Twitter API, HTML Parser usw. Ich möchte halt, dass ich auf dem bestehenden Wissen des Studiums solide aufsetzen kann und dann eben das theoretische Wissen anhand praktischer Beispiele umsetzen kann und natürlich auch ein Ergebnis raus kommt, bei dem man sagen kann, das ist "gut gelaufen". Ich will auch nicht den Druck machen, dass jemand mit Bauchschmerzen sich an die Probleme setzt. Ich habe halt die Bandbreite von "hat noch gar nicht entwickelt" bis zu "entwickelt schon seit Jahren und muss nur den Syntax lernen". Für viele ist eben C++ schon erschlagend und wenn dann noch so Bibliotheken wie die Boost, LAPack / JNI dazu kommen, dann ist bei vielen einfach die Panik da. Mir würde es eigentlich im Moment genügen, wenn man diese Angst etwas nehmen kann und eben in kleinen Schritten versucht sich an die Bibliothek und an die Lösung heran zu tasten (mein letztes Beispiel war erst einmal eine klassische Skalarberechnung und Matrix-Matrix-Multiplikation, einmal sie händisch mit Arrays zu implementieren und dann sich anzuschauen wie die Boost das umsetzt und es eben auszuprobieren - dabei habe ich dann auch gleich mal g++, javac und Makefiles versucht zu erklären). Das setze ich eigentlich voraus, also Datentypen, Klassen, Kontrollstrukturen usw. Header etc hat man bei C/C++ und nicht bei Java, aber ich denke das sollte nicht schwer sein. Die Idee mit dem Pong finde ich gut, obwohl ich jetzt auch spontan passen müsste, wie man direkt die die Bildschirmpositionen abfragt. Was ich gerne als Beispiel nehme, da es ja auch in den mathematischen Context passt, ist das Lösen eines linearen Gleichungssystems, also Daten einlesen und passend konvertieren und an die passende Bibliotheksfunktion reichen und die Lösung ausgeben. Ich habe hier eben eher wenig mit GUI o.ä. Anwendung zu tun, sondern eher Backend / Algorithmen. Ich muss mir da wirklich Gedanken machen, wie man einem Anfänger wirklich das Wissen für die Entwicklung bei bringt. Ich möchte aber auch nicht "dünn drüberwischen", d.h. mir wäre es dann lieber, wenn eben das Erlernt solide sitzt als dafür eher viel und dann alles nur mit Halbwissen. Vor allem wäre mir wichtig, dass man einen soliden "Plan" dem Anfänger geben kann, wie man von einem sprachlich formulierten Problem einen Algorithmus zur Lösung entwirft, den man dann auch in Quellcode umsetzen kann. Danke an alle

Viele kennen das nicht, ebenso wie navigieren auf der Konsole.... d.h. ein einfaches "javac myclass.java" oder "g++ -c mysource.cpp" ist nicht ohne Hilfe möglich. Wo ist der Unterschied zur Twitter API !? HTTP Anfrage über Socket senden, Daten empfangen und an den HTML Parser geben, bei Twitter: HTTP Anfrage über Socket senden, Daten empfangen und an JSON Parser geben. Der Unterschied ist nur, dass ich zwei unterschiedliche Verarbeitungen der Daten schreiben muss. Es geht mir ja darum, wie man jemanden beibringt das Problem zu lösen nicht auf den Papier oder mit Diagrammen sondern mit einem konkreten funktionierenden und durchdachten Ergebnis. Ich kann doch nicht da anfangen, wo ich bei einem Azubi im 1. LJ anfangen würde, ich habe Studenten am Ende des Bachelor !?

Ja, es scheint mir aber genau, dass ich evtl zu viel erwarte wieder an lesen ist in meinen Augen überhaupt kein Problem. Das war auch mein Gedanke und in manchen Fällen klappt das auch sehr gut. Ich habe die Erfahrung gemacht dass manche sprichwörtlich irgendwo verloren im Wald stehen, d.h. wenn ich das Problem sehr allgemein formuliere, dann fehlt einigen der Ansatz, wo man überhaupt beginnt. Als Bsp hatte ich einen kleinen Twitter Client gedacht. Twitter stellt eine API zur Verfügung an die man ein Get Request Schickt und dann JSON Daten zurück erhält. Ich hatte jetzt erwartet, dass man sich eben in die API einliest, sich eine JSON Bibliothek (vielleicht auch 2 oder 3 zum ausprobieren) besorgt und diese für das Parsen verwendet und dann einfach via Socket einen HTTP Request absetzt und die Daten in Empfang nimmt. Selbst wenn man das noch nie gemacht hat, dann kann man sich die RTF für HTTP und eine Menge von Beispielen im Web zu diesem Problem anschauen. Ich war leider mit dem Ergebnis enttäuscht z.B.: dass man einen Namen für die Socketverbindung via DNS erst einmal auflösen muss, wie man dann einen fehlerfreien HTTP Request sendet. Bei den meisten war die Frage "ich habe hier die API Dokumentation und wie setzt man das nun real um" und ich weiß leider nicht, was man da machen kann, denn selbst bei Beispielen muss man sich ja überlegen wie man von einem Problem zur Lösung kommt und welche technischen Mittel man dafür einsetzt und letzteres lernt man durch Recherchieren

Das ist richtig, obwohl ich hier auch schon die Erfahrung gemacht habe, dass jemand extrem nervös war und im Grunde ein Blackout hatte und fachlich oberflächlich große Lücken gezeigt hat. Als er dann real in der Entwicklung saß, kann ich nur sagen, hervorragende Arbeit. Es lag eben an der Situation des Gespräches Da ist eben genau das Problem. Viele können "hübsche Diagramme" malen, aber wenn es darum geht, das ganze mit Leben zu füllen, dann hakt es eben oft. Ich möchte halt auch nicht sagen, dass ich einfach einen Schwellwert setze, wie "wer das nicht schafft fliegt raus", sondern eher dass jemanden Hilfestellung leistet um zu prüfen, ob es für ihn das richtige ist. Wir haben häufig die Stolpersteine: Wie kommt man von der sprachlichen Problemformulierung z.B. zu einem Algorithmusentwurf oder Klassendiagramm und im nächsten Schritt wie kommt man von so etwas auf real funktionierenden Code. Ich kann mir natürlich für jeden Anfänger nun Beispiele ausdenken und sie durchgehen, das halte ich aber für seltsam, denn eigentlich ist das doch das Wissen aus dem Studium !? Wäre sicherlich eine gute Idee, leider haben wir da wohl das Problem, da wie ich ja schon geschrieben habe, heuristische und numerische Verfahren umsetzen, fehlt eben einem 1. oder 2. Semester einfach die mathematische Grundlage bzw. das Wissen ist noch nicht so fest im Kopf, wie man es braucht. Wir müssen eh mit jedem die mathematischen Verfahren anhand des Codes und eben Erklärungen durchgehen. Mir sind leider so etwas die Ideen ausgegangen, wie man "gut" das notwendige Wissen vermitteln kann, so dass man durchaus Freude daran hat und nicht irgendwann demotiviert in der Ecke sitzt, aber eben auch, dass man nicht ständig daneben sitzen muss, damit überhaupt etwas funktionsfähiges heraus kommt. Mir hat immer so ein Ansatz geholfen: "Das Verfahren XYZ kennt man aus der Vorlesung Algebra, wird aber als Optimierungsprinzip für Problem Z angewendet, weil man mit Hilfe von A, B und C es so lösen kann". Wenn man dabei aber XYZ und A, B, C nicht kennt bzw damit nichts anfangen kann, dann hilft das nun mal nicht weiter Schon einmal vielen Dank an alle

nein leider nicht. Wieso kann ich das nicht im 5. Semester erwarten? Im 6. wäre man fertig und hätte ggf Verantwortung oder müsste auch Azubis anleiten. Genau das ist das Problem, in einem solchen Gespräch kann man im Grunde eine Lösung erklären, muss man sie dann aber real umsetzen, sieht das schon ganz anders aus. Nur weil man in einem Gespräch sich eben on-fly eine Problemlösung ausdenkt, muss das in der Realität noch lange nicht so funktionieren und das kann man leider erst später feststellen. Mein Eindruck ist eben eigentlich "nur" der, dass eben oft ein Schein- / Prüfungsmarathon gemacht wurde, aber das Wissen nicht vernetzt wird.

So ist es hier auch gelöst. Wir diskutieren im Moment, was wir noch als "akzeptabel" betrachten sollten. Wir wissen vorher, ob eben Programmierkenntnisse vorhanden sind und wenn ja, in welcher Sprache (primär haben wir Java). In der Entwicklung wird hier Java, C++ und C verwendet, wobei Java eigentlich nur als "Wrapper" dient. Natürlich, das verlangen wir auch nicht. Jeder darf sich auch die Zeit nehmen Sachen zu wiederholen bzw sich anzueignen, so dass er sich eine Arbeitsgrundlage schafft. Und es wird auch nicht jeder an MPI oder Multithreadding von Anfang an gesetzt. Wir fangen im Grunde mit "einem-Klassen-Problem" an, so dass man eben einmal das Framework sich anschauen kann, was es dort alles schon gibt. Wir möchten jedem die Möglichkeit bieten zu lernen, wobei bei mir häufig einfach der Eindruck entsteht, dass man letztendlich eine Schritt-für-Schritt-Anleitung bei vielen durchführen muss, d.h. Algorithmusentwurf (und hierbei schon helfen muss) auf einem Zettel ggf UML Diagramm, Framework nach passenden Codestrukturen durchsuchen ggf auch mal im Netz nach passenden Bibliotheken schauen und dann codieren. Wir haben es schon probiert, dass wir die gleiche Aufgabe mehrfach verteilt haben und dann nach einer gewissen Zeit uns alle zusammen gesetzt haben und jede Lösung hinsichtlich pro und contra zusammen diskutiert haben. Ja nach Problemstellung konnte man dann durchaus aus zwei Lösungen eine zufriedenstellende erzeugen. Das trifft die Problematik eigentlich ganz genau

Das stimmt wohl, aber sagen wir mal so, dass nach ab dem 3/4 Semester da durchaus klar sein sollte wie man kleinere Algorithmen konzipiert Ich habe dahin gehend den Eindruck, dass zwar der Stoff gelernt wurde, aber das Wissen nicht vernetzt wird, d.h. man kennt die Definitionen, weil man das mal auswendig gelernt hat, aber das man z.B. Inhalte aus der Mathematik dann real in einem Algorithmus braucht, das ist Neuland. Wäre eigentlich auch mein Gedanke, aber hier entsteht das Problem, dass ich nicht jede Lücke füllen kann. Würde ich gerne machen, aber wo fängt man da an. Ich meine ich hatte schon mal einige Klassen aus dem Echtsystem genommen, Methodencode entfernt und einfach diesen "neu schreiben" lassen. Aber viele können Compiler- und Linkerfehler überhaupt nicht interpretieren bzw. daraus den Rückschluss ziehen, wo der Fehler im Code liegt. Genau das war mein Gedanke auch, aber mein Eindruck scheint dahin zu gehen, dass es inzwischen viele sind. Wenn ich nur die Noten sehe, dann liegt es nicht daran. Was für viele ein "Schock" ist, dass sie auf einmal eine Konsole benutzen müssen und Klassen eben nicht per Drag-and-Drop erstellen und zusammen klicken und Methodencode auf einmal implementieren sollen. So wie ich viele verstanden habe, lernen sie häufig OOP Modelle mit irgendwelchen GUI Tools zu erstellen, implementieren aber nie wirklich Inhalte. Dann ist ein Linux, indem man händisch bzw mit Makefiles arbeitet doch schon etwas anderes. Auch Begriffe wie call-by-reference / call-by-value kennen viele gar nicht, da im Studium z.B. rein Java gemacht wurde. Auch Begriffe wie Mutex, Deadlock, Transaktionssicherheit wird damit wegargumentiert "das macht doch die Programmiersprache". Es gibt halt zwischendrin Mal ein paar, die wirklich richtig super sind, bei denen man nach zwei Wochen sagen kann, sie können alleine arbeiten, aber bei den meisten muss ich wirklich von vorne beginnen. Für mich ist die Frage eigentlich diese, ab wann man die Grenze ziehen soll, also was würde man erwarten können und was ist auf jeden Fall nicht mehr zu akzeptieren.

Mache ich auch. Mein Ansatz ist erst mal recht einfach, dass sie sich die Umgebung selbst installieren, gerade beim selbst kompilieren diverser Bibliotheken, muss man eben schon mal etwas nachdenken. Im Grunde haben sie alle eine Programmiervorlesung besucht, d.h. Klassen, Variablen etc sollten in meinen Augen bekannt sein. Was ich natürlich mache so etwas noch mal dann anhand des Codes erklären, weil ja die Strukturen je nach Sprache unterschiedlich aussehen. Meine Standardbsps sind z.B. einen kleinen Taschenrechner schreiben, der von der Konsole gestartet wird wie z.B. "rechner 4 + 5", aber schon dort sind massive Schwierigkeiten z.B. viele prüfen z.B. die Eingaben nicht, einige Wissen überhaupt nicht wie bzw wo sie anfangen z.B. in Java wäre ja eben die Entwicklung einer main-Klasse mit entsprechender Funktion (in C++ ist es ähnlich) [da ich beide Sprachen benutze, mache ich so Bsps immer in beiden Sprachen]. Ich meine es ist ja nicht wie bei einem Azubi, bei dem man keine Grundkenntnisse voraussetzt, sondern der Bachelor ist ein Abschluss, d.h. Theorie sollte da sein, auch macht man während dem Studium einige praktische Umsetzungen, so dass man wenigstens "kleine" Aufgaben erledigen kann. Oft scheitert es aber schon an dem Aufbau eines Algorithmus, also das klassische Fluss- oder Nassi-Schneider-Diagramm, von UML Klassendiagramm, State-Chart o.ä. brauche ich gar nicht anfangen. Da eben die Codes sich nicht nur mit "Anwendungsprogrammierung" beschäftigen, sondern eben viele numerische / heuristische Verfahren implementieren, sind sie natürlich nicht unbedingt einfach, aber kein Anfänger wird z.B. direkt an die LAPack dran gelassen, sondern es geht um Sachen wie z.B. Klassenentwicklung um z.B. einen Webservice abzufragen o.ä. und ich denke das sollte mit Hilfe machbar sein. Ich stehe halt sowohl für Syntax-, wie auch inhaltliche Frage immer zur Verfügung, nur oft fehlen so grundlegende Dinge, wie z.B. Consolen Bedienung unter Linux, das korrekte Aufrufen des Compilers etc. Ich denke eigentlich, dass man das erwarten kann bzw. jemand in der Lage ist dafür auch mal eine Suchmaschine zu verwenden. Die Codes in denen sie dann nach der Einarbeitung arbeiten sind vollständig dokumentiert, d.h. man findet zu jeder Klasse / Namespace / Methode / Property immer eine Information, genauso wie Callergraphen existieren, wo man sich ggf anschauen kann, wie Methoden aufgerufen werden Beides ist der Fall.

Hallo, ich bräuchte einfach mal ein paar Anregungen zu folgender Problematik: Ich habe häufiger mit Studenten der Informatik im Bachelor zu tun, die zwar die Vorlesungen besucht haben, aber völlig überfordert sind die Kenntnisse auf reale Projekte zu übertragen. Es geht letztendlich z.B. um Fragen: Wie fange ich mit der Programmierung an? Wie strukturiert man einen Algorithmus einmal theoretisch und dann praktisch in einer Sprache? In der Praxis verstehen die Leute oft die Programmierung, aber wenn sie selbst ein Problem umsetzen müssen, sind sie hilflos überfordert. Zusätzlich kommen Probleme dazu, dass sie noch nicht einmal wissen, nach welchen Schlagwörtern sie im Netz suchen sollen, um sich dem Problem anzunähern. Wenn z.B. die Aufgabe heißt "entwickle eine Klasse zum auslesen von Webseiten", dann wären ja Schlagwörter wir HTTP, Socket, HTML, Parser usw. Möglichkeiten grundlegende Informationen zu sammeln. Hat jemand Ideen, wie man da helfen kann? Ich denke eigentlich, dass man selber diesen Sprung schaffen sollte, natürlich wird man mit der Zeit besser und auch schneller, aber manchmal weiß ich nicht, ob ich mit einem (fast) abgeschlossenen Bachelorstudium nicht "zu viel" erwarte, obwohl ich eigentlich selbst weiß, dass solche Dinge in der Ausbildung vermittelt werden, somit ein Student analog können muss.

Prüfe es einmal genau nach, wenn das bei Deiner "NumberOfIterations" Variablen passieren würde, wäre das ein Problem. Das würde jedenfalls erklären, warum das Programm dann nicht beendet wird, denn innerhalb eines Threads eine undefinierter Abbruch erfolgt, aber das Threadding darauf wartet, dass alle Threads korrekt beendet werden, um das Reduce durch zu führen, wird dieser Zustand nie erreicht, denn alle Threads warten und einer wurde undefiniert beendet. Die Folge das Programm hängt. Sollte es, schau es Dir aber im Debugger ggf einmal nach Nein, jeder Thread für exakt eine Operation aus, die Zuweisung x = 253; Von einer Schleife habe ich nichts gesagt.

Du brauchst hier keine Schriftgrößen zu verwenden, um Deinen Fragen Nachdruck zu verleihen. Ein normal geschriebener Text reicht vollkommen aus. Es scheint so, dass OpenMP im Gegensatz zu MPI generell bei Schleifen, sofern man nichts anderes angibt, direkt wie Du richtig sagst, die Schleife auftrennt und auf die Anzahl Threads verteilt. Finde ich zwar jetzt sehr seltsam, weil das durchaus Probleme machen kann, aber es scheint so zu sein. http://openmp.org/mp-documents/OpenMP3.1-CCard.pdf Dort sind die Operatoren, die das Reduktion verwenden kann in der Tabelle auf der zweiten Seite angegeben. Ich werde Dir hier keinen fertigen C++ Code schreiben, so dass Du ihn nur compilieren musst, damit Du das verstehst. Pseudocode soll das Problem verdeutlichen, die Übersetzung in die Sprache mit der Du arbeitest, musst Du selbst leisten. Wenn ich Dir hier Beispiele fertig vorkaue, dann muss ich dafür extrem viel Zeit aufwenden, die ich nicht habe. Wenn Du es so nicht verstehst, dann müsstest Du ggf mal eine Anfrage stellen, so dass man sich preislich über einen Lehrgang o.ä. einigen kann. Ich war davon ausgegangen dass der MPI und OpenMP Standard hier identisch sind, es ist aber wohl nicht so. @topic: Schau Dir noch einmal das Beispiel an und evtl übersetzt Du es auch einmal in Deinen C++ Code uchar x = 0; do parallel with x is private on each thread { x= 253; } reduce with + { x }; Versuche Dir einmal für das Minibeispiel die folgenden Fragen zu beantworten: Was hat x für einen Wert nach dem Reduce bei einem oder mehr als einem Thread !? Wenn das Reduce zu einer Bitweisen Verknüpfung wie z.B. & oder | änderst, wie sehen dann die Ergebnisse aus !? Das Beispiel setzt bevor parallel gearbeitet wird eine unsigned char Variable und weist einfach in jedem Thread dieser den Wert 253 zu und führt dann ein Reduce auf (einmal eine arithmetische Addition und einmal ein boolsches and bzw oder). Überlege Dir ganz genau was mit der Variablen bei dem Reduce passiert und wie das mit der Anzahl der Threads zusammen hängt. Vor allem schau Dir einmal an wie groß ein uchar ist (sizeof liefert diese Information). Wichtig ist, dass Du das Beispiel einmal mit einem Thread gedanklich durchgehst und einmal mit mehr als einem, zwei Threads reichen da schon aus. Es soll Dir zeigen, was bei dem Reduce passieren kann und wie sich das dann auf Deine Programmierung auswirkt.

Ich möchte Dir hier jetzt nicht jedes Beispiel einzeln erklären, das sprengt hier jeden Rahmen. Hier ist der Hinweis auf die Literatur eigentlich passend, denn Parallelität spielt sich nicht nur im Code ab. Man hat ggf mehrschichte Architektur z.B. arbeite ich mit Threadparallelität & Parallelität auf MPI Ebene, was letztendlich dazu führt, dass ich den Algorithmus auf einer physikalischen Maschine parallelisiere und eine Datenparallelität über mehrere physikalischen Maschinen habe. genau das, natürlich erreicht man das auch durch parallel arbeitende Schleifen, nur muss man dann auf den richtigen Datenbereichen arbeiten & die Ergebnisse die entstehen passend verbinden. Das steht in der OpenMP Doku Das wäre aber mal die Mindestvoraussetzung, um anständig arbeiten zu können. Das war Pseudocode => schau in die Doku da findet sich dazu die passenden Befehle. Bei MPI heißen die Befehle "size" und "rank". Beispiel (Pseudocode) uchar x = 0; do parallel with x is private on each thread { x= 253; } reduce with + { x }; was hat x für einen Wert nach dem Reduce bei einem oder mehr als einem Thread !? Wenn das Reduce zu einer Bitweisen Verknüpfung wie z.B. & oder | änderst, wie sehen dann die Ergebnisse aus !? In diesem Bereich gibt es keine Anfängerbeispiele, denn sobald Du eine Schleife hast spielen auch die Daten, die Du verwendest eine Rolle. Die "beste" Parallelisierung erreicht man auf Algorithmusebene und muss man einiges an Wissen hineinstecken, um gute Lösungen zu produzieren. Alle Frameworks die existieren können dies nicht, sondern sie arbeiten rein auf Codeebene. Es liegt am Programmierer für die richtigen Daten und auch die passenden Datentypen zu sorgen.

siehe OpenMP später wird dann auf die private Variable im Thread z.B. ein "std::max(var_thread1, var_thread2...)" gemacht .... .... und Du bekommst Deine 2400. Alleine das "reduce" sagt doch schon aus was passiert. Du hast n Werte, auf n Threads verteilt und nun wird nach irgendeiner Relation diese n Werte auf einen reduziert. Diese Relation kann z.B. das Max / Min oder sonst irgendwie etwas sein. Nein Du implizierst in Deinen Gedanken, dass OpenMP durch das Reduce eine Aufteilung der Daten macht und das tut es nicht. OpenMP macht genau das was Du ihm sagst: 1. mache Variable auf jedem Thread privat (der Wert der Variablen wird letztendlich per copy-by-value n-fach repliziert) 2. führe Schleife aus 3. reduziere die Variable wieder auf eine Instanz zurück Woher soll OpenMP wissen, dass er die ersten k Elemente auf den ersten, die zweiten k Elemente auf den zweiten Thread usw. packen soll !? Man könnte auch denken, dass OpenMP vielleicht ein Round-Robin-Prinzip anwendet, also erstes Element auf ersten Thread, zweites Element auf zweiten usw (bis Elementindex % Threadanzahl) woher soll OpenMP wissen, wie Du es gerne haben möchtest? Wenn eine Abhängigkeit zwischen den Daten besteht, z.b. Element 1 muss berechnet sein, bevor 2 berechnet werden kann, dann wäre es schlecht, wenn 1 und 2 auf getrennten Threads liegen würden, im worst-case holst Du Dir dann einen Deadlock. Das sind Größen / Variablen, die OpenMP bereitstellt (für den genauen Synatx bitte Doku ansehen). Lastthread wäre letztendlich "threadnumber == threadcount-1" OpenMP und Message Passing Interface sind sehr ähnlich bzw. in vielen Punkten identisch. Ich empfehle Dir, dass Du gerade zur Parallelisierung erst einmal Grundlagen Dir anschaust. Als Literatur wäre dafür z.B. Parallele Programmierung: Amazon.de: Thomas Rauber, Gudula Rünger: Bücher Parallele numerische Verfahren Springer-Lehrbuch Masterclass: Amazon.de: Götz Alefeld, Ingrid Lenhardt, Holger Obermaier: Bücher geeignet. Parallelisierung ist nicht trivial und naive Ansätze sind oft schlechter als ein sequentieller Code. Nur weil eine Bibliothek wie OpenMP einem viele Komponenten bereitstellt, heißt das nicht, dass es mal eben "schnell" gemacht ist. Parallele Algorithmen sind extrem schwierig und erfordern zunächst einmal entsprechendes Wissen über parallele Verarbeitung, denn neben der parallelen Ausführung ist auch der Datenfluss / -zugriff extrem relevant. Dein Code liefert beim Compileraufruf: test.cpp:11:31: warning: integer constant is so large that it is unsigned test.cpp:11: warning: this decimal constant is unsigned only in ISO C90 test.cpp:13:42: warning: integer constant is so large that it is unsigned test.cpp:13: warning: this decimal constant is unsigned only in ISO C90 test.cpp: In function ‘int main(int, char**)’: test.cpp:26: warning: iteration variable ‘k’ is unsigned test.cpp:26: error: invalid controlling predicate Wobei Du eben bei dem Reduce überlegen solltest, was passiert wenn Du eine Bereichsüberschreitung bekommst, sprich wenn Die Iterationsanzahl * Threadanzahl die Größe des Datentypes überschreitet

Nein in Deinem Beispiel nicht. Du läuft in der Schleife von K=1 bis k==NumValues, d.h. Deine For-Schleife wird "Anzahl-Threads x NumValues" ausgeführt, jede Thread läuft somit von K=1 bis k==NumValues. Erst nachdem die Schleife beendet wurde wird das Reduce auf der Variablen NumberOfIterations ausgeführt. Du musst die Schleife von von k=1 bis k==NumValues / Anzahl-Thread + ((isLastThread) ? NumValues % AnzahlThreads : 0) laufen lassen. Das "pragma omp parallel reduction" macht letztendlich nur einen copy-by-value für jeden Thread, der Wert ist aber für alle Threads gleich, sofern Du es nicht änderst. Der Compiler kann nicht Deine Daten automatisch verteilen, dafür bist Du als Programmierer zuständig.

Nein das kann man pauschal nicht sagen, es kommt drauf an, was real an Code generiert wird (z.B.: Loop Enrollment, Semaphore ...). Allgemein gilt: Amdahlsches Gesetz bzw Gustafsons Gesetz

Mach doch mal einen kleineren Test, um zu schauen welche Optionen sich nicht vertragen.

Ich kann den Fehler leider nicht nachvollziehen: Dein Programm liefert bei mir auf OSX & Gentoo: Array-Summe SERIELL: 112507500 Benötigte Iterationen: 15000 Array-Summe PARALLEL: 112507500i Benötigte Iterationen: 15000

Du gehst hier anscheinend immer von dem klassischen Kartesisches Koordinatensystem aus. Ich verweise einmal auf Geodätische Distanz so dass man eben einen Vektor als "Struktur von Zahlen" auffassen kann. D.h. wenn Du z.B. Punkte auf einer Sphäre beschreibst, dann wäre das ein Vektor mit zwei Dimensionen nämlich die Winkel (ggf. drei Dimensionen, wenn Du noch einen Radius hast). Da einfach mit Addition, Multiplikation zu arbeiten würde fatal enden :-P Das ist ja eigentlich auch der gängige Fall es so zu machen. Die Frage wäre, ob man einen std::vector braucht. Da die Dimension meist konstant ist, kann man das Allokieren des Speichers auch selbst machen und würde sich die ganze std::vector Struktur spare. Ich nutze generell Boost Basic Linear Algebra - Boost 1.47.0 denn gerade wenn man sparse / dünnbesetzte Strukturen braucht bietet die Boost schon alles fertig. Ebenso lassen sich die Automatically Tuned Linear Algebra Software und LAPACK direkt an die Boost Datenstrukturen anbinden. Zugriff auf die Vektoren / Matrizen geschieht einfach per []-Operator bzw ()-Operator. Ich würde von einer eigenen Implementierung abraten, denn die Boost Strukturen sind sowohl sehr umfangreich, wie auch sehr performant. Außerdem würde man Vektoren generell als n-dimensional auffassen und nicht fest von der Dimension vorgeben. Auch würde ich hier keine Verschachtelungen machen, also eine Matrix würde ich nicht als "Vektor von Vektoren" auffassen. Wenn man diese Operatoren braucht, dann kann man durch entsprechende Methoden überladen. Ich benutze Chapter*24.*Thread - Boost 1.47.0 für Mutex. OpenMP unterstützt auch kritische Bereiche, so dass man das auch ohne weiteres implementieren kann (CUDA habe ich leider keine Erfahrung). Bei std::vector muss man unterscheiden, ob man eine resize Operation (push_back) macht oder nur auf Elemente lesend zugreift. Aber ein Vektor wird nicht einmal "spontan" seine Dimension ändern. Im Normalfall ist die Dimensionalität während der Berechnung konstant, so dass man recht einfach parallelisieren kann. OT: Evtl kannst Du hier einmal rein schauen Machine Learning Framework | flashpixx.de dort arbeite ich mit den genannten Strukturen. Ggf auch PM an mich wenn Fragen sind

Ich verweise einmal auf Polnische Notation und das man so etwas als Baum aufbaut. Als Alternative kann man auch für mathematische Ausdrücke eine Formale Grammatik verwenden. Für den Fall eines Rechners reicht aber die polnische Notation mit einem Baum mit der Information, dass in den Knoten die Operatoren und in den Blättern die Operanden / Zahlen stehen. Zusätzlich empfehle ich reguläre Ausdrücke, die sich direkt in Java umsetzen lassen (siehe Java Tutorial Regex) und dazu passend die Java String Klasse

@streffin: Da gebe ich Dir vollkommen recht :-P

Das Commando "top" ist nicht in jedem DBMS enthalten z.B. mySQL oder Postgres kennen "top" nicht.

Ich helf Dir mal mit nem kleinen Tip auf die Sprünge: Du hast zwei 3-dimensionale Vektoren, dann sieht die Vektoraddition mit Schleife so aus: for(i=0; i < 3; ++i) target[i] = source1[i] + source2[i] Cuda oder auch OpenMP sind Strukturen um parallel zu arbeiten und jetzt überleg' Dir einmal, ob das 0te Element bei der Addition eine Abhängigkeit zu dem 1. oder 2. hat. Also kannst Du das 0te Element unabhängig von der 1. oder 2. berechnen? Zu der Frage nach der "Funktion", schau Dir dafür die Piplinetechnologie der Graphikkarte an und überlege Dir, wie dann Dein real geschriebener Code auf der Karte ausgeführt wird. Zu weiteren Frage der Berechnung von Skalaren, so heißen Deine eindimensionalen Vektoren. Wieso muss man einen Vektor als n-dimensionale topologische Struktur auffassen, evtl kann man doch einfach einen Vektor als "Menge von Zahlen" auffassen, die man zu einer anderen Menge addieren will !?

Ja anhand des Schlüssels bzw eines passendes Kriterium des Datensatzes