# Kurze frage zu einem Spielprogramier problem



## Cool012345 (3. Juli 2014)

Die frage geht zu einer Physik-Engine

Hallo,

ich hoffe, dass ich hier richtig bin. Mein Bruder arbeitet aktuell an einer Physik-Engine, jedoch wurde er in einem anderem Forum recht stark runter gemacht, so das er nochmal von vorne anfängt und auch verunsichert wurde.

Ich habe mir deshalb einmal seinen Grundaufbau „gemopst“ und frage euch nun, ob dieser ausreicht, oder ob noch etwas fehlt:

Aufbau der Physik-Engine:

1.		User-Interface über die Klasse					„phy“
2.		1. Objekt-Klasse für bewegliche Objekte				„mobject“
3.		2. Objekt-Klasse für unbewegliche Objekte				„sobject“
4.		1. Rechen-Klasse für grundlegende Berechnungen			„basic“
5.		2. Rechen-Klasse für komplexe Berechnungen			„extended“
6.		1. Kollisions-Klasse für grobe Kollisionsberechnungen		„collision“
7.		2. Kollisions-Klasse für genaue Kollisionsberechnungen		„hits“
8.		1. Kräfte-Klasse für globale Kräfte					„global“
9.		2. Kräfte-Klasse für Objektkräfte					„potency“
10.		3. Kräfte-Klasse für Reibungen					„friction“
11.		4. Kräfte-Klasse für Rotationen und Impulserhaltung		„momentum“

Freue mich auf antworten

Grüße
Cool012345


----------



## R4Z0R1911 (3. Juli 2014)

Ich sehe da jetzt kein wirklichen "Aufbau" das sind nur Deklarationen ?! Naja ich hab davon eh kaum Plan


----------



## XPrototypeX (3. Juli 2014)

Naja ich frage mich was man da groß schlecht machen kann? Wie wärs wenn du mit einem Klassendiagramm mit richtigen Beziehungen wieder kommst? So ist das erstmal schön und gut aber wenig hilfreich.

Wenn überhaupt würde ich die Interfaces schon treffend beschreiben. Welche Sprache willst du verwenden?


----------



## Cool012345 (3. Juli 2014)

Ich Programmiere nicht das ist von meinem Bruder er weis davon nichts ich werde ihn aber jetzt in kenntnis setzen da ich nicht weis welche Sprache er verwendet.


----------



## SimonG (3. Juli 2014)

Eins vorweg: Ich nehme mal an Ihr plant eine 2D-Engine. Von 3D würde ich ohne weitere Fragen abraten.

Wichtig ist, dass ihr einen genauen Plan habt. Ein Klassendiagramm ist dabei hilreich. Es muss nicht UML sein - aber so, dass man die Zusammenhänge sieht.
Dann müsst ihr wissen wie eure Implementierung aussehen soll.
Über solche Dinge solltet ihr euch (erfolgreich) Gedanken gemacht haben:
Sind die physikalischen in allen Kombinationen Zusammenhänge klar?
Könnt ihr die auftretenden mathematischen Probleme effizent lösen?
Welche Algorithmen und Datenstrukturen sollen dabei verwendet werden?

Du musst das nicht alles hier beantworten - es reicht wenn ihr wisst, wie ihr es angehen wollt.

Interessant wäre es sicherlich auch die Implementierung anderer Physikengines anzusehen. Ein Kandidat dafür wäre Box2D.


----------



## Cool012345 (3. Juli 2014)

Erstmal guten Abend,

für mich steht fest, eine 3D engine zu machen. Ich habe mir schon die Netown Dinamics angesehen.

Die Programmiersprache ist C++
An ein Klassen diagramm habe ich auch schon gedacht, jedoch habe ich außer einer Javer executable nur kostenpflichtige oder schrott Programme gefunden.
Könnt ihr eines empfehlen?

Bitte kommt mir jetzt nicht "eine Physikengine ist eine sehr komplexe Angelegenhiet" oder "das ich nicht in ein paar Wochen zu machen"
Das ist mir nämlich durchaus bewusst, ich interessiere mich sehr für Physik und Mathematik, so dass ich versuche über die Engine auch die Programmierung mit einfließen zu lassen und so mein Wissen und das Verständniss von der Matherie zu verbessern.

Ich rechne mit einer gesamt Zeit von ca. 1,5 - 3 Jahren. (Je nachdem, wie viel Zeit ich investiere und wie schnell ich Probleme gelöst bekomme)
Eine Funktion zum Wurzelziehen, um die Hypotenuse zu berechnen ist bereits fertig. (z.B. wichtig um Rotationen zu berechnen)

Ich hoffe hier die ein oder andere Antwort auf noch offene Fragen zu bekommen, da mein Bruder (cool012345) fast keine Ahnung vom Programmiern hat.


----------



## XPrototypeX (3. Juli 2014)

Letztendlich besteht ein Klassendiagramm doch nur aus kästen und pfeilen. Das sollte Word oder dessen kostenloses Linux Pendant alle mal hinbekommen. Ich verstehe nur nicht was deine Frage ist? 
Natürlich wünsch ich dir viel Erfolg, bezweifele allerdings das das Erfolg haben wird.


----------



## Laudian (3. Juli 2014)

Ich konnte aus dem Eröffnungspost ein paar Sachen noch nicht so ganz herauslesen:

Soll die Engine die Objekte am Ende grafisch darstellen, oder soll das ganze erstmal nur auf Textbasis laufen ?
Bisher stelle ich mir das ganze bildlich so ähnlich wie diesen bekannten Seifenblasen-Bildschirmschoner vor, bei dem die Seifenblasen über den Bildschirm gleiten und voneinander abprallen.

Ist es für dich wichtig, dass die Engine wissenschaftlich korrekt und effizient arbeitet oder geht es hauptsächlich darum, dir Programmieren/Mathe/Physik beizubringen und dass das Ergebnis halbwegs vernünftig aussieht ?

Dann solltest du dir möglichst früh klarmachen, was die Engine können soll und was nicht.


----------



## Brehministrator (3. Juli 2014)

Cool012345 schrieb:


> Eine Funktion zum Wurzelziehen, um die Hypotenuse zu berechnen ist bereits fertig. (z.B. wichtig um Rotationen zu berechnen)


 Vielleicht verstehe ich ja irgendwas falsch... Aber C/C++ hat doch bereits eine Funktion zum Wurzelziehen, nämlich sqrt() in der math.h?


----------



## Cool012345 (3. Juli 2014)

Ich weiß, jedoch ist es z.B. mit dem Programm (weiß gerade nicht wie es heißt), welches in der Schule genutzt wird einfacher, als mit Word oder änlichem.

Eine Frage ist z.B. ob es besser ist so viele Berechnungen pro Sekunde zu machen wie möglich, oder gerade bei Spielen eine Obergrenze zu setzen?

Zumal ich nicht bei Null anfange, ich beschäftige mich bereits seit Jahren mit physiklischen Ereignissen, so das es nicht all zu schwer sein sollte, dieses auch in einer Funktion zu beschreiben.

In ein paar Jahren kann man einiges auf die Beine stellen. 

@Brehministrator
Ja, es gibt eine Funktion in der math.h jedoch nur für Quadratwurzeln.

@Laudian

Es soll eine reine Physik-engine werden, also ohne Grafiken (jedoch durch eine Grafik-engine natürlich ergänzbar)

Für mich ist die effizent sehr wichtig, weshalb ich fast alle Funktionen selbst schreibe und mich nur an den nötigsten Headern bediene.
Die Genauigkeit der Berechnungen soll so gut wie möglich sein, jedoch werde ich wohl durch Hardwareeinschränkungen bei der Genauigkeit abstriche machen müssen.


----------



## XPrototypeX (3. Juli 2014)

Vielleicht solltest du erstmal eine 3D Welt mit einer fixen Kamera erstellen. Dann kann man sich über so etwas wie Physik Gedanken machen...

Edit: 

Generell gibt es erst-mal ein Main Thread. Das Thread das faktisch in einer "Endlosschelife" Events prüft, Berechnen macht etc... Man errechnet aus dieser Gameloop auch seine FPS nämlich wenn diese einmal durchgelaufen ist wird ein Frame berechnet und Ausgegeben. Danach richten sich also auch deine Phsysikberechnungen später


----------



## SimonG (3. Juli 2014)

Cool012345 schrieb:


> für mich steht fest, eine 3D engine zu machen. Ich habe mir schon die Netown Dinamics angesehen.


Ok. Das ist abitioniert, aber du scheinst die nötige Motivation zu haben.
Für den Anfang würde ich zum Üben aber trotzdem erstmal mit 2D Experimentieren.



Cool012345 schrieb:


> Die Programmiersprache ist C++






Cool012345 schrieb:


> An ein Klassen diagramm habe ich auch schon gedacht, jedoch habe ich außer einer Javer executable nur kostenpflichtige oder schrott Programme gefunden.
> Könnt ihr eines empfehlen?


Stift und Papier? Ansonsten kann man z.B. auch auf https://www.lucidchart.com schöne Diragramme erstellen. Es muss ja nicht immer gleich UML sein, solange der Plan dabei klar wird. 



Cool012345 schrieb:


> Bitte kommt mir jetzt nicht "eine Physikengine ist eine sehr komplexe Angelegenhiet" oder "das ich nicht in ein paar Wochen zu machen"
> Das ist mir nämlich durchaus bewusst, ich interessiere mich sehr für Physik und Mathematik, so dass ich versuche über die Engine auch die Programmierung mit einfließen zu lassen und so mein Wissen und das Verständniss von der Matherie zu verbessern.


Zum Einen: Eine Physikengine ist keine komplexe Angelegenheit und das ist nicht in ein paar Wachen zu machen.
Zum Anderen: Wenn du die Motivation und das Wissen hast, dann mach es. Sei aber nicht enttäuscht, wenn die erste Version ständig abstürzt und die Berechnungen total behämmert sind. Sowas ist bei einem Lernprozess volkommen normal.



Cool012345 schrieb:


> Ich rechne mit einer gesamt Zeit von ca. 1,5 - 3 Jahren. (Je nachdem, wie viel Zeit ich investiere und wie schnell ich Probleme gelöst bekomme)


Du solltest zuerst die Probleme angehen und dich nicht auf die einfachen Teile stürzen. Sonst schiebst du die schweren Probleme vor dir her.
Du solltest Spaß daran haben mathematische Probleme zu lösen.



Cool012345 schrieb:


> Eine Funktion zum Wurzelziehen, um die Hypotenuse zu berechnen ist bereits fertig. (z.B. wichtig um Rotationen zu berechnen)


Entschuldige, aber gerade zweifle ich an deinen Fähigkeiten. Zum Wurzelziehen braucht man in C++ keine besondere Funktion (sqrt und pow erledigen das bereits) und die Hypotenuse zu berechnen ist ja auch keine Kunst mit dem trigonometischen Pythagoras. Das ist zwar schonmal ein Anfang, aber die Probleme werden komplizierter werden als das.

Solltest du die Wurzel und solche Dinge wegen der Effizenz selbst implementieren wollen ist das zwar löblich und zum Lernen auch durchaus sinnvoll, aber ob du es besser hinbekommst als die Profis, die den C++ Standart implementiert habe bezweifle ich.



Cool012345 schrieb:


> Ich hoffe hier die ein oder andere Antwort auf noch offene Fragen zu bekommen, da mein Bruder (cool012345) fast keine Ahnung vom Programmiern hat.


Was wären dann da für offene Fragen?


----------



## Cool012345 (3. Juli 2014)

Das weiß ich bereits und das ist auch logisch, meine Frage ist jedoch ob ich für die Frames die Möglichkeit ein Maximum zu setzen geben soll, um Framerate einstürze zu verringern.
Und somit für ein flüssigeres Game zu sorgen. 

Bei Simulationen ist ein Begrenzung jedoch absolut sinnlos. 

@SimonG
Ich werde mir deine Ratschläge zu Herzen nehmen.

Da eine Wurzel nicht immer und immer wieder gezogen werden muss, habe ich eine eigene Funktion geschrieben, um ein Möglichst genaues Ergebnis zu bekommen.
Hier steht float gegen long Double.


----------



## SimonG (3. Juli 2014)

Cool012345 schrieb:


> Das weiß ich bereits und das ist auch logisch, meine Frage ist jedoch ob ich für die Frames die Möglichkeit ein Maximum zu setzen geben soll, um Framerate einstürze zu verringern.
> Und somit für ein flüssigeres Game zu sorgen.
> 
> Bei Simulationen ist ein Begrenzung jedoch absolut sinnlos.


 
Normalerweise läuft das (glaube ich) so. Das Spiel überträgt der Physikengine in jedem Duchlauf des Mainloop einmal die Kontrolle. Dann liefert die Physikengine ihre Ergebnisse und diese werden dann auf die Spielwelt angewendet. Es wird also immer nur auf Anfrage ein Schritt berechnet. Wie groß dieser Schritt ist hängt davon ab wie schnell (oder langsam) der Mainloop vom Spiel läuft. Das wäre zumindest mein (single Thread) Ansatz.


----------



## XPrototypeX (3. Juli 2014)

Wenn kein Vsync aktiviert ist so viel wie geht.


----------



## bingo88 (3. Juli 2014)

Cool012345 schrieb:


> Da eine Wurzel nicht immer und immer wieder gezogen werden muss, habe ich eine eigene Funktion geschrieben, um ein Möglichst genaues Ergebnis zu bekommen.
> Hier steht float gegen long Double.


 Soll das jetzt ein Spiel oder eine Simulation werden?


----------



## Cool012345 (3. Juli 2014)

SimonG schrieb:


> Wie groß dieser Schritt ist hängt davon ab wie schnell (oder langsam) der Mainloop vom Spiel läuft. Das wäre zumindest mein (single Thread) Ansatz.



Das ist gut, dass du es Erwähnst, da es bei der Bewegungsberechnung zwei Ansätze gibt. 
1. Das schnellste Objekt hat eine Geschwindigkeit von "1" dadruch werden Springende Grafiken verringert, jedoch auch die gesamte Geschwindigkeit herunter gesetzt, da die anderen Geschwindigkeiten relativ zur schnellsten herab gesetzt werden müssten.
2. Einen festen Zeitsprung, so können auch schnelle Bewegungen gut berechnet werden, jedoch gibt es dann acuh einige Springer, da nicht zu jedem Zeitpunkt die Position bekannt ist.

Ich werde wohl über mindestnes 3 Threads gehen. (Dafür binde ich auch einen Header ein, der nicht zu mir gehört sondern zum Qt Repertoire)


@bingo88

Der Vorteil einer guten Engine ist, dass sie sich sowol in Spiele als auch in Simulationen intigrieren lässt.
Ich werde je nach Verwendungszweck Einstellungsparameter setzten lassen, um z.B. Berechnungen früher zu Runden usw.


Bei dem Vorgänger, habe ich mithilfe von drei for-schleifen zunächst 500000 Objekte (Quader) erstellt, um sie danach sofort wieder zu löschen. (keine Grafische ausgabe oder ähnliches)
Der Thread des Programmes hat dabei 394,5 MiB vom RAM genutzt, ist dass gut, oder zu viel?


----------



## bingo88 (3. Juli 2014)

Cool012345 schrieb:


> @bingo88
> 
> Der Vorteil einer guten Engine ist, dass sie sich sowol in Spiele als auch in Simulationen intigrieren lässt.
> Ich werde je nach Verwendungszweck Einstellungsparameter setzten lassen, um z.B. Berechnungen früher zu Runden usw.


 Hmmm. Ich sag mal so, bei Spielen kommt es so dermaßen auf Performance an, dass man teilweise ungenaue Rechenfunktionen als Compilerflag aktiviert.



Cool012345 schrieb:


> Bei  dem Vorgänger, habe ich mithilfe von drei for-schleifen zunächst 500000  Objekte (Quader) erstellt, um sie danach sofort wieder zu löschen.  (keine Grafische ausgabe oder ähnliches)
> Der Thread des Programmes hat dabei 394,5 MiB vom RAM genutzt, ist dass gut, oder zu viel?


 Um das beurteilen zu können, musst du uns schon mitteilen wie die Quader definiert sind (4 3D-Vektoren? Sonstige Daten, z. B. Material, Textur?).

Wenn ich mal von 3D Vektoren mit DP ausgehe, habe ich pro Vektor 3 * 8 Byte = 24 Byte. 1 Quader = 4 Vektoren = 4 * 24 Byte = 96 Byte. Macht bei 500.000 Objekten etwa 46 MB.


----------



## Brehministrator (3. Juli 2014)

Cool012345 schrieb:


> Ja, es gibt eine Funktion in der math.h jedoch nur für Quadratwurzeln.


 Beliebige Wurzeln zieht man mit der "pow()"-Funktion zum Potenzieren (ebenfalls in der "math.h" enthalten), da "n-te Wurzel" identisch ist zu "hoch 1/n" 

Ein Beispiel: Die 7-te Wurzel einer Zahl x erhalte ich in C++ mit "pow(x, 1/7.0)".

Das kannst du ja benutzen, um die Genauigkeit deiner eigenen Implementierung mal zu testen. Mich würde auch interessieren, welchen Algorithmus du zur Berechnung von Wurzeln benutzt. Das ist nämlich nicht gerade einfach, das genau und vor allem numerisch stabil (für alle Eingabewerte von klein bis groß) hinzukriegen.


----------



## Cool012345 (3. Juli 2014)

Das waren nur Quader, die mithilfe eines std::vektors von der Klasse unbewegliches Objekt waren.
Mit allen nötigen Variablen um damit theoretisch zu rechnen. Die Quader waren nur logisch vorhanden (X, Y, Z Länge definiert, um die Eckpunkte zu berechnen, um Kollisionsberechnungen vor zu bereiten, da alles was sich zwischen diesem Punkten defindet nunmal mit dem Quader kollidieren würde), jedoch fanden keine Interaktionen statt, bzw. wurden dabei Texturen geladen.

Ja, dass es bei Spielen auf die Performance ankommt, habe ich bedacht, so würde z.B. die Luftreibung bei Geschossen in z.B. Shootern nicht oder nur ungenau einbezogen werden.

Ich nutze eine Form des Heronverfahrens (hoffe es heißt so :S ) um relativ schnell eine gute Genauigkeit zu erlangen.
Wird die Quadratzahl kleiner als 1, verringert sich auch der Startwert der Annäherung. (Aktuell ist die kleinste Möglcihe Quadratzahl aus der ich die Wurzel berechnen kann 0,0001) das sollte für die meisten Berechnungen reichen.


----------



## bingo88 (3. Juli 2014)

Mach mal ein sizeof(Klasse unbew. Objekt) und lass dir das ausgeben. Dann weißt du, wie groß ein einzelnes Objekt ist.


```
class MyClass
{
};

// ...
size_t clsize = sizeof(MyClass);
```


----------



## Laudian (3. Juli 2014)

Cool012345 schrieb:


> Der Vorteil einer guten Engine ist, dass sie sich sowol in Spiele als auch in Simulationen intigrieren lässt.


 
Naja, eigentlich nicht. Eine Simulation muss vor allem exakt sein, für eine Spieleengine dagegen reicht es aus wenn die Ergebnisse realistisch aussehen.

Das ist deswegen wichtig, weil man bei Simulationen die Schrittweite oft dynamisch anpasst, z.B. um die Genauigkeit der Kollisionserkennung zu erhöhen.


----------



## Cool012345 (3. Juli 2014)

bingo88 schrieb:


> Mach mal ein sizeof(Klasse unbew. Objekt) und lass dir das ausgeben. Dann weißt du, wie groß ein einzelnes Objekt ist.
> 
> 
> ```
> ...


 
Das werde ich Morgen machen und das Ergebnis hier posten, da ich bereits um 5 Uhr aufstehen darf, muss ich jetzt off gehen.
@Laudian
Gerade wenn die Engine gut ist, hat man Dynamische Klassen, die nur genutzte Variablen anlegen, somit kommt man bei Spielen auf "Es sieht gut aus und braucht wenig Leistung" und bei Simulationen "Das ist recht genau berechnet", im 2. Fall natürlich unter Einsatz von mehr Resourccen.


----------



## bath92 (3. Juli 2014)

Für Diagramme (z.B. UML) kannst du yED nutzen. Ist Freeware, kann dafür aber ausreichend viel erstellt werden.

http://www.yworks.com/de/products_yed_about.html


----------



## bingo88 (3. Juli 2014)

Die wenigsten Spiele haben ein Problem mit der Memory Wall (speicherlimitiert), da gibt es vorher andere Probleme. Jedenfalls ist mir nicht ganz klar, was du mit "dynamische Klassen" meinst, meines Wissens sieht eine Klasse in C++ so aus wie sie zur Compilezeit definiert wurde (und sobald eine Variable da ist belegt sie auch Speicher, ob man sie nutzt oder nicht).


----------



## Supercomputer (4. Juli 2014)

Hallo,
ich habe mir nun einen eigenen Account gemacht, damit nicht alles über meinen Bruder läuft.


Mit dynmischen Klassen, meine ich eher das verwenden von std::vektor und anderen dynamischen Speichern


Mit freundlichen Grüßen
Supercomputer


----------



## XPrototypeX (4. Juli 2014)

Das wären dann eher dynamische Datenstrukturen. Also Objekte die während der Laufzeit dynamisch Speicher anfordern und auch wieder freigeben können. Klassen beschreiben eigentlich nur Objekte. Wie gut sind denn deine C++ Kenntnisse hinsichtlich Vererbung und Polymorphie? So etwas ist eigentlich bei so einem Projekt unerlässlich.


----------



## Supercomputer (4. Juli 2014)

Zur Thema Vererbung und Polymorphie bestehen Grundkenntnisse, die jedoch erweitert werden.

Heißt es auch dynamische Datenstruktur, wenn die Klassen durch Templates erst zum Einsatz kommen, wenn sie gebraucht werden?


----------



## bingo88 (4. Juli 2014)

Supercomputer schrieb:


> Zur Thema Vererbung und Polymorphie bestehen Grundkenntnisse, die jedoch erweitert werden.
> 
> Heißt es auch dynamische Datenstruktur, wenn die Klassen durch Templates erst zum Einsatz kommen, wenn sie gebraucht werden?


 Templates werden nicht zur Laufzeit generiert, das passiert beim Kompilieren. Dynamische Datenstrukturen werden zur Laufzeit angelegt.


----------



## taks (4. Juli 2014)

bath92 schrieb:


> Für Diagramme (z.B. UML) kannst du yED nutzen. Ist Freeware, kann dafür aber ausreichend viel erstellt werden.
> 
> yEd - Graph Editor


 

Ich benutze dafür immer Astah


----------



## Supercomputer (4. Juli 2014)

bingo88 schrieb:


> Templates werden nicht zur Laufzeit generiert, das passiert beim Kompilieren. Dynamische Datenstrukturen werden zur Laufzeit angelegt.


 
Sorry, meinte eigentlcih auch std::verktor :/

Bin leider momentan etwas Krank. 



taks schrieb:


> Ich benutze dafür immer Astah


 
Dieses Programm scheint es nur für Windoof zu geben, oder?

yED macht auf den ersten Augenschein einen guten Eindruck


----------



## taks (4. Juli 2014)

Supercomputer schrieb:


> Dieses Programm scheint es nur für Windoof zu geben, oder?


 

Also auf der Seite werden auch Bilder von Mac Screenshots angezeigt.
Also sollte es das Programm auch für Mac geben 


_edit: Gibts für Mac und Linux
Gugst du hier: Klick mich!_


----------



## Cool012345 (4. Juli 2014)

Auf allen Systemen von uns ist Linux fest installiert und auf dem Netbook zu dem Windoof was nicht gerade häufig verwendet wird, mein Bruder hat auf der Seite von dem Programm nur downloads für Windoof 32 Bit /64 Bit gefunden


----------



## taks (4. Juli 2014)

Hier der Linux-Direktlink


----------



## Cool012345 (4. Juli 2014)

taks schrieb:


> Hier der Linux-Direktlink


 
Danke


----------



## Supercomputer (5. Juli 2014)

Aktuell nutze ich von der Softwareverwaltung direkt ein Programm, trägt den Namen Umbrello und macht einen recht guten Eindruck.


----------



## Supercomputer (7. Juli 2014)

Brehministrator schrieb:


> Beliebige Wurzeln zieht man mit der "pow()"-Funktion zum Potenzieren (ebenfalls in der "math.h" enthalten), da "n-te Wurzel" identisch ist zu "hoch 1/n"
> 
> Ein Beispiel: Die 7-te Wurzel einer Zahl x erhalte ich in C++ mit "pow(x, 1/7.0)".
> 
> Das kannst du ja benutzen, um die Genauigkeit deiner eigenen Implementierung mal zu testen. Mich würde auch interessieren, welchen Algorithmus du zur Berechnung von Wurzeln benutzt. Das ist nämlich nicht gerade einfach, das genau und vor allem numerisch stabil (für alle Eingabewerte von klein bis groß) hinzukriegen.


 
Ich habe meine Funktion jetzt mal mit Quadratwurzel von 23 getestet, dabei kam folgendes heraus:

sqrt =           4.79583152331272
Meine Funktion = 4.7958315233127195415484267382311145

Bei anderen Exponenten zickt sie noch etwas, aber das ist nicht so schlimm, da ich nur die Quadratwurzel benötige. 


Mit freundlichen Grüßen
Supercomputer


----------



## bingo88 (7. Juli 2014)

Ich kann es nur noch einmal wiederholen, für Simulation ok, für Spiele vollkommen uninteressant. Hast du mal die Laufzeit beider Funktionen gemessen? Das würde mich nämlich jetzt eher interessieren.


----------



## Supercomputer (7. Juli 2014)

Die Laufzeit habe ich noch nicht gemessen, aber ich habe jetzt auch den size_t gemacht, es kam 304 raus.


Wie messe ich die Laufzeit einer Funktion?
Habe sowas noch nicht machen müssen.


----------



## bingo88 (7. Juli 2014)

Also: 304 Byte / Objekt * 500.000 Objekte = ca. 145 MB Daten

Laufzeitmessung ist leider Plattformabhängig. Unter Linux kannst du das so machen


```
#include <sys/time.h>

double get_time(void)
{
    struct timeval tv;
    gettimeofday(&tv, NULL);

    return (tv.tv_sec + (tv.tv_use * 1E-6));
}

void foo(void)
{
    double tstart, telapsed;

    tstart = get_time();
    /* Mach was */
    telapsed = get_time() - tstart;
    printf("Time: %f\n", telapsed);
}
```
Unter Windows geht das am besten mit QueryPerformaceCounter.


----------



## Laudian (7. Juli 2014)

Oder auf die altmodische Art:

Lass das Programm in einer Schleife 1000 mal durchlaufen, am Ende "fertig" in der Konsole ausgeben und auf die Uhr gucken.


----------



## Supercomputer (7. Juli 2014)

bingo88 schrieb:


> Also: 304 Byte / Objekt * 500.000 Objekte = ca. 145 MB Daten
> 
> Laufzeitmessung ist leider Plattformabhängig. Unter Linux kannst du das so machen
> 
> ...


 
Ich nutze nur Linux

Bekomme beim Ausfüren die Meldung "printf was nut declared in this scope" (habe sogar die printf.h includiert, jedoch gleiches Resultat)

Wenn ich versuche im Debugg modus zu starten, um die Variablen einfach aus zu lesen, bekomme ich folgende Fehlermeldung

ptrace: Die Operation ist nicht erlaubt

Was kann ich dagegen machen?


----------



## bingo88 (7. Juli 2014)

Für printf musst du natürlich noch die stdio.h includen. Ist das eine GUI oder Konsolenanwendung? Wenn GUI musst du das über ein Terminal starten, um die Ausgabe zu sehen.


----------



## Supercomputer (7. Juli 2014)

Meine Funktion ist 75.5 mal langsamer als sqrt


----------



## bingo88 (7. Juli 2014)

Supercomputer schrieb:


> Meine Funktion ist 75.5 mal langsamer als sqrt


 So etwas hatte ich erwartet 

Hast du das als Release Build getestet (Debug ist immer langsamer)?


----------



## Supercomputer (7. Juli 2014)

Nein, nur Debug

Ich habe auch damit gerechnet, dass ich langsammer bin, aber dass es so viel ist 

Dafür ist meine Funkrion genauer


----------



## bingo88 (7. Juli 2014)

In der Regel ist es auch so, dass genauere Ergebnisse länger dauern.

Du müsstest das mal als non-Debug Build testen, damit das einigermaßen vergleichbar ist.


----------



## Laudian (7. Juli 2014)

Und vor allem solltest du die Funktion nicht nur einmal sondern wenigstens 20-30 mal durchlaufen lassen um zufällige Schwankungen auszugleichen.


----------



## Supercomputer (7. Juli 2014)

Wenn ich auf Realeas stelle, bekomme ich die sqrt nicht gemessen, selbst bei 10 Milionen Durchläufen kommt 0.000000 raus.
Bei meiner Funktion bekomme ich bei 1000 Durchläufen 0.000014 raus.

Jedoch habe ich noch eine Optimierung gefunden, die eventuell nochmal die Geschwindigkeit verdoppelt, sie ist aber noch nicht implementiert.


----------



## bingo88 (7. Juli 2014)

Dann mach das mal anders. Mess mal bitte die Gesamtlaufzeit, also außerhalb der Schleife.


----------



## Supercomputer (7. Juli 2014)

Ich messe ja außerhalb der Schleife.

Die Schleife (for) befindet sich bei dem geschickten Code bei "/* Mach was */"


----------



## bingo88 (7. Juli 2014)

Upps ^^ Okay, mit Bordmitteln wird man dann nicht genauer herankommen. Eventuell ginge noch ein großes Array.


```
int length = 1024 * 1024 * 64;
double *a = new double[length];

tstart = ...;
for (int i = 0; i < length; ++i)
{
    a[i] = sqrt(a[i]);
}

telapsed = ...;

delete[] a;
```


----------



## Supercomputer (7. Juli 2014)

```
long double base::gethyp(long double lega, long double legb)
{
    long double hyp;
    long int N = 0;
    long double middle1;
    long double middle2;
    long double middle3;
    hyp = 23;//lega * lega + legb * legb;
    for (int n = 0; n * n <= hyp; n++) // Bescleunigeung der Annäherung
    {
        N++;
    }
    middle1 = hyp / N;
    middle2 = (middle1 + N) / 2;
    middle3 = hyp / middle2;
    for (int i = 0; i < 5; i++) // Bei 23 reichen auch schon 3, jedoch weiß ich nicht, wie adere Zahlen ragieren (Genaugkeit von 35 Stellen in der Variable)
    {
        middle2 = (middle2 + middle3) / 2;
        middle3 = hyp / middle2;
    }
    return (middle2);
}
```

Das ist mein aktuelle Funktion, wißt ihr vllt, noch eine optimierungsmöglichkeit?
Die funktioniert so nur für Zahlen >= 1.

Habe es jetzt hin bekommen, lasse die Schleife jetztz 1000000.0 mal durchlaufen und bekomme heraus, dass meine Funktion genau 38.725490196 mal langesammer als sqrt ist.

Gerade nochmal durchlaufen lassen ohne etwas zu ändern, jetzt ist meine Funktion auf einmal nur noch 3.430225673 mal langsammer O.o


----------



## XPrototypeX (7. Juli 2014)

for(int n = n*n; n >= hyp; n--) 

rechnet nicht in jedem schleifen durchgang n*n. 

Ansonsten kann ich auf den ersten blick nichts finden. 

Aber es ist schwachsin jetzt zu optimieren. Schreib bzw nehm die Funktionen die du brauchst und mach dein Ding (so Sachen werden dein Programm garantiert nicht merklich verlangsamen). Wenn die performance nicht stimmt kannst du immer noch optimieren aber dann richtige bottlenecks und nicht so etwas. So geht dir einfach nur Zeit verloren ohne das du etwas sichtbares auf die Beine stellst. 

Wieso verwendest du C und nicht C++? Du könntest dir eine utility Klasse schreiben mit solch Berechnungen. Sollten halt static und ggf. inline sein.

So Micro Benchmarks sind schwer zu machen. Die CPU ist mal mehr mal weniger Ausgelastet. Manche instructionen stehen vielleicht nach in irgendeinen Cache. Das kann dir alles dazwischen Funken.


----------



## Supercomputer (7. Juli 2014)

XPrototypeX schrieb:


> for(int n = n*n; n >= hyp; n--)
> 
> rechnet nicht in jedem schleifen durchgang n*n.
> 
> ...


 
Damit wird "n" doch auf irgedneinen zufälligen Wert gesetzt, oder?

Ich nutze C++, nicht C.

Diese Funktion gehört zur Klasse "base".


----------



## XPrototypeX (7. Juli 2014)

Ah, ja vergess das bin leicht übermüdet.... Hab den code nicht nachvollzogen.

Da es jedoch utility methoden sind sollten sie besser static sein.


----------



## Supercomputer (7. Juli 2014)

XPrototypeX schrieb:


> Ah, ja vergess das bin leicht übermüdet.... Hab den code nicht nachvollzogen.
> 
> Da es jedoch utility methoden sind sollten sie besser static sein.


 
Ist doch nichts passiert, alles in Ordnung 

Danke für den Tipp, es static zu setzen.


----------



## XPrototypeX (7. Juli 2014)

Joa aber so micro Optimierungen sind echt nicht nötig. Wenn es wirklich zu Problemen mit der Performance kommen sollte, hilft dir ein Profiler. Der deckt dann auf and welchen Stellen das Program am meisten Zeit benötigt. Ich an deiner Stelle würde weiter machen und ggf. Optimierungen ganz am Ende machen.


----------



## Supercomputer (8. Juli 2014)

Das denke ich mir mittlerweile auch.


----------



## Bunny_Joe (19. Juli 2014)

Hi


Ich zitiere mich mal kurz ausm anderen Thread:



Bunny_Joe schrieb:


> Hey ich hätte da noch ein Buch für dich: Game Engine Architecture
> 
> Das Buch "Game Engine Architecture" wurde vom Naughty Dog Lead Programmierer Jason Gregory geschrieben und erscheint am 5. August in einer zweiten Ausgabe.
> In der überarbeiteten Ausgabe wurde viel hinzugefügt und überarbeitet.....unter anderem:* extended/updated sections on multicore programming, pipelined CPU architecture and optimization, localization, C++11, pseudovectors and Grassman algebra, dual quaternions, SIMD vector math, memory alignment and anti-aliasing*
> ...


----------



## Supercomputer (19. Juli 2014)

Danke für den Tipp, das hört sich sehr gut an 

Da kommt mir jedoch eine Frage auf, kann ich (meine Engine) irgendwie herausbekommen, wie viele Threads die aktuell verwendete CPU gleichzeitig bearbeiten?
Oder muss ich vom User eingeben lassen: "Wie viele Threads bearbeitet ihre CPU gleichzeitig (echte und virtuelle Kerne)"

Um so eine perfekte Auslastung der Vorhandenen Ressourcen zu bekommen.


----------



## Bunny_Joe (19. Juli 2014)

Habe mal das hier gefunden:
c++ - Programatically detect number of physical processors/cores or if hyper-threading is active on Windows, Mac and Linux - Stack Overflow


Das gibt dir die Anzahl der Threads aus(nicht der echten Kerne).

```
#include <iostream>
#include <boost/thread.hpp>

int main()
{
    std::cout << boost::thread::hardware_concurrency();
    return 0;
}
```

In C++11
http://en.cppreference.com/w/cpp/thread/thread/hardware_concurrency


----------



## Supercomputer (19. Juli 2014)

Danke, da die Betriebssystem die Threads eh auf echte so wie virtuelle Kerne verteilt, ist eigentlich nur die Zahl der Threads wichtig.


Danke für den Code, der wird mir helfen.
Es ist halt so, legt man zu viele Threads an kann das Programm ruckeln, da die alle nach einander ausgeführt werden. Legt man zu wenige an, kann die CPU nicht komplett genutzt werden.


----------



## bingo88 (19. Juli 2014)

Supercomputer schrieb:


> Danke, da die Betriebssystem die Threads eh auf echte so wie virtuelle Kerne verteilt, ist eigentlich nur die Zahl der Threads wichtig.


 Jaein, das hängt von der Art der Anwendung ab. SMT, wie Intels HT, sind keine echten Kerne. Bei ungünstiger Verteilung kann das durchaus Performancenachteile mit sich bringen. Aber das ist wieder diese "Vorzeitige Optimierungsgeschichte". Solange du nicht weißt, dass das ein Problem ist, musst du dir da auch keine Sorgen drum machen.


----------



## Keksdose12 (19. Juli 2014)

Wie baut man denn software die mit einer variablen anzahl an threads ungehen kann ? Muss man dann bei der entwicklung dann das zusammenlegen von threads programmieren ? Oh gott ist das alles kompliziert mich freut, dass java in der hinsicht nicht allzu kompliziert ist.


----------



## Bunny_Joe (19. Juli 2014)

Keksdose12 schrieb:


> Wie baut man denn software die mit einer variablen anzahl an threads ungehen kann ? Muss man dann bei der entwicklung dann das zusammenlegen von threads programmieren ? Oh gott ist das alles kompliziert mich freut, dass java in der hinsicht nicht allzu kompliziert ist.




Bei Java ist Multithreading sogar ein elementarer Bestandteil.


----------



## Supercomputer (19. Juli 2014)

Ich wüsste auch nicht, dass eine Engine mit Java programmiert wurde.


Da hast du wieder recht bingo88

Ich werde jetzt erst mal weiter planen und dann warten bis das Buch in Deutschland verfügbar ist (Wahrscheinlich 25. August)


----------



## Bunny_Joe (19. Juli 2014)

Supercomputer schrieb:


> Ich wüsste auch nicht, dass eine Engine mit Java programmiert wurde.



Minecraft läuft mit Java.....siehst ja an der Performance. xD


Ich denke c++ ist schon mit die beste Wahl für ne Engine.


----------



## Supercomputer (19. Juli 2014)

Die einzigen Möglichkeiten, die vllt schneller laufen (die ich kenne), aber bei weitem nicht übersichtlich sind, währen reines C oder Assembler


----------



## Bunny_Joe (19. Juli 2014)

Supercomputer schrieb:


> Die einzigen Möglichkeiten, die vllt schneller laufen (die ich kenne), aber bei weitem nicht übersichtlich sind, währen reines C oder Assembler



C ist etwas blöd dafür, da nicht objektorientiert und NUR Assembler zu benutzen? Da wirste nie fertig xD

In der Industrie wirds wohl oft so sein:
99℅ C++ und 1% des Codes Assembler für die sehr zeitkritischen Sachen.


Und vergiss nicht die simple 80/20 Regel: Zu 80℅ der Zeit laufen nur 20℅ des Codes.
Natürlich nur zur Orientierung wegen der Performance.


----------



## Supercomputer (19. Juli 2014)

Ich weiß, rein von der Geschwindigkeit sind es Assembler, C und dann C++.

Wie ich schon geschrieben habe, wird es in C oder Assembler hässlich.

Daher werde ich alles in C++ machen und dann die kritischen Teile durch Assembler austauschen, sofern es Performance Probleme gibt. 

EDIT: Lisp ist aber auch recht schnell, gerade bei Schleifen..


----------



## XPrototypeX (19. Juli 2014)

Supercomputer schrieb:


> Die einzigen Möglichkeiten, die vllt schneller laufen (die ich kenne), aber bei weitem nicht übersichtlich sind, währen reines C oder Assembler


 
Ist es nicht eh so das die heutigen Compiler eigentlich "schneller" Assembler Code erzeugt, da er den kompletten Code und deren Abhängigkeiten analysieren kann bzw Plattform spezifische Optimierungen durchführen kann, die der Mensch so gar nicht kennt? Der Hauptgrund warum Java nicht in der Spieleentwicklung benutzt wird ist das man auf OpenGl bzw. DirectX nicht nativ zugreifen kann. Da wird viel mit JNI gearbeitet das relativ langsam ist. Ansonsten hängt Java C++ durch HotSpot und JIT Compiler gar nicht mehr so hinterher, ist sogar in manchen Gebieten um einiges schneller.


----------



## Bunny_Joe (19. Juli 2014)

Supercomputer schrieb:


> Daher werde ich alles in C++ machen und dann die kritischen Teile durch Assembler austauschen, sofern es Performance Probleme gibt.



Das sagst du jetzt so....dafür brauchst du dann ziemlich viel Erfahrung über die CPU Architektur....ansonsten wirds dann im schlimmsten Fall noch langsamer xD


----------



## Supercomputer (19. Juli 2014)

Das weiß ich nicht genau.

Ich werde Hauptsächlich auf Linux mit Qt Programmieren.


EDIT: 
Ich weiß, im schlimmsten Fall muss ich den Assemblercode auch mehrfach für die einzelnen Architekturen schreiben :/


----------



## Bunny_Joe (19. Juli 2014)

Supercomputer schrieb:


> Das weiß ich nicht genau.
> 
> Ich werde Hauptsächlich auf Linux mit Qt Programmieren.



Auch auf Linux bleibt x86 dann x86.


----------



## DarkMo (19. Juli 2014)

Supercomputer schrieb:


> EDIT: Lisp ist aber auch recht schnell, gerade bei Schleifen..


 dann biste aber ganz weit weg von c und konsorten ^^ und ob man mit lisp nen spiel bauen kann...  also mit grafik und so. ich weis nur, wenn ich ned zwingend muss, halt ich mich fern davon  sin mir zuviele klammern xD


----------



## XPrototypeX (19. Juli 2014)

Supercomputer schrieb:


> Das weiß ich nicht genau.
> 
> EDIT:
> Ich weiß, im schlimmsten Fall muss ich den Assemblercode auch mehrfach für die einzelnen Architekturen schreiben :/


 
Und du kennst die einzelnen Architekturen besser als ein Compiler? :S Ich meine da sitzen Wissenschaftler von Intel bzw. AMD dran, die zum Teil die entsprechende CPU Architektur mit entwickelt haben... Allerdings frage ich mich wieso du als mit Performance kommst zu mal du noch keine Grundstruktur hast. Sich über Performance Gedanken zu machen kommt eigentlich wenn man weiß wo konkrete leaks sind.


----------



## Supercomputer (19. Juli 2014)

DarkMo schrieb:


> dann biste aber ganz weit weg von c und konsorten ^^ und ob man mit lisp nen spiel bauen kann...  also mit grafik und so. ich weis nur, wenn ich ned zwingend muss, halt ich mich fern davon  sin mir zuviele klammern xD


 
Ja, das ist mit Lisp nicht so einfach, aber wegen der Vollständigkeit halber einmal genannt.
Aber ist es nicht theoretisch möglich C++ mit Lisp zu Kombinieren, also "C++L" 

Natürlich ist das nicht in ein paar Jahren zu schaffen....


EDIT: Von AMD weiß ich, dass sie größten Teils auf die ARM Architektur setzen


----------



## XPrototypeX (19. Juli 2014)

Nö x86 bzw x64 für Desktop Anwendungen (mehr interessiert den Compiler erstmal nicht). Es gibt natürlich auch Compiler die auf entsprechende CPUs optimieren. Intel hat glaube ich einen eigenen Compiler.


----------



## Supercomputer (19. Juli 2014)

XPrototypeX schrieb:


> Nö x86 bzw x64 für Desktop Anwendungen (mehr interessiert den Compiler erstmal nicht). Es gibt natürlich auch Compiler die auf entsprechende CPUs optimieren. Intel hat glaube ich einen eigenen Compiler.


 
Wenn es auf die optimale Auslastung ankommt, sollte  man schon auf jede einzelne in frage kommende CPU Architektur optimieren.


----------



## Bunny_Joe (19. Juli 2014)

Supercomputer schrieb:


> Wenn es auf die optimale Auslastung ankommt, sollte  man schon auf jede einzelne in frage kommende CPU Architektur optimieren.



Ja und das wäre in deinem Fall x86-64

Oder willst du es auch auf PPC, ARM, usw. zum Laufen bekommen?


----------



## bingo88 (19. Juli 2014)

Meine Erfahrungen zum Thema Assembler: Zum einen haben Compiler sehr viele Tuningmöglichkeiten, die man zum Teil aber explizit aktivieren muss (der Intel Compiler geht da übrigens ab wie Schmitz Katze, da kommen andere Compiler nicht dran). Zum anderen, um einen hochoptimierenden Compiler mit Assembler zu schlagen, bedarf es sehr viel Erfahrung. Nicht umsonst gibt es Leute, die sich auf so etwas spezialisieren. Besonders im HPC-Umfeld gibt es da einige Leute, die machen echt krude Sachen um noch den letzten Pfurz Performance aus dem Cluster zu kitzeln


----------



## Supercomputer (19. Juli 2014)

Eines frage ich mich nur, wie sind unendliche Schleifen möglich, da Assembler soweit ich weiß keine eigenen Schleifen besitzt.


----------



## XPrototypeX (19. Juli 2014)

Ich glaube der TO weiß nicht genau was eine CPU Architektur ist...

Edit: Wenn du VS hast kannst du dir den Assembler Output anschauen.. Das sagt glaube ich mehr aus als jetzt zu erklären was JMP Befehle sind..


----------



## Supercomputer (20. Juli 2014)

Sorry, dass ich Assembler erst auf Mikrocontroller anwenden muss.


----------



## bingo88 (20. Juli 2014)

Naja, es gibt viele Dinge, die du aus Hochsprachen kennst, die aber in Assembler nicht direkt existieren.

Zum einen sagt mir diese Aussage, dass der Compiler wohl besseren Code produzieren würde (nicht böse gemeint). Zum anderen gibt es bereits innerhalb der Hochsprache selbst Dinge, die Auswirkungen auf die Performance haben - bevor der Compiler seine Finger dran bekommt. Beispielsweise kannst du durch ungünstige Schleifen auf Arrays sogenannten Cache Thrashing erzeugen, was die Performance tief in den Keller bringt, da es sich hierbei meist um speichergebundene Probleme handelt (also die Geschwindigkeit direkt von der verfügbaren Speicherbandbreite abängt). Das sind zum Beispiel so Sachen wie Vektoraddition oder AXPY.

Das Optimieren des Assembly Codes ist also die letzte Stufe einer langen Latte von möglichen Optimierungen. Wenn du da vorher schon Mist gebaut hast, wirst du das untenrum nicht mehr retten können.


----------



## Supercomputer (20. Juli 2014)

bingo88 schrieb:


> Naja, es gibt viele Dinge, die du aus Hochsprachen kennst, die aber in Assembler nicht direkt existieren.
> 
> Zum einen sagt mir diese Aussage, dass der Compiler wohl besseren Code produzieren würde (nicht böse gemeint). Zum anderen gibt es bereits innerhalb der Hochsprache selbst Dinge, die Auswirkungen auf die Performance haben - bevor der Compiler seine Finger dran bekommt. Beispielsweise kannst du durch ungünstige Schleifen auf Arrays sogenannten Cache Thrashing erzeugen, was die Performance tief in den Keller bringt, da es sich hierbei meist um speichergebundene Probleme handelt.


 
Das weiß ich, Assembler ist fast Maschinen Code, daher gibt es sehr vieles nicht, oder nur indirekt. Zudem muss man alles selbst machen z.B. Die Variablen in den Speicher schreiben.

Das es nicht böse gemeint glaube ich dir auch so, da Anfängercode nun mal nicht optimal ist, gerade bei Assembler kann jeder Fehler fatale Folgen haben.
Mache ich irgend etwas "falsch"? Der Stack hat ja nur 8 MB, jedoch kann ich mühelos Vektoren habe die insgesamt weit über 100 MB groß sind, jedoch gebe ich nicht an, dass ein neues Objekt eines Vektors im Heap gespeichert werden.

Werden Vektoren also immer auf dem Heap erzeugt?


----------



## DarkMo (20. Juli 2014)

Supercomputer schrieb:


> Aber ist es nicht theoretisch möglich C++ mit Lisp zu Kombinieren, also "C++L"


 gute frage. aber rein theoretisch: wieso nich. mir fällt in bezug auf logische programmiersprachen nur die beispiel-anwendung als ki ein. damit war aber glaube eher prolog gemeint. aber im endeffekt kann man ja auch problemlos sql mit c usw verbinden. und sql ist nun bei weitem auch keine imperative sprache ^^ zählz glaube auch zur 4th generation language oder (c usw zur 3rd...)? wie war das? maschinen code war erste, dann asambler, dann die hochsprachen, dann die logischen allgemein? oder eher genereller formuliert? also es ging im kernpunkt eher darum, dass der "code" näher ans gesprochene wort kommt mit jeder generation. aus 0en und 1en wird jpnz bla bla wird ne for schleife (ausm arm gezaubert) wird "gib mir alle daten zu..." ^^ achne, sql zählte zu den descriptiven sprachen *glaub* sag nicht WIE ein problem gelöst wird, dag WAS du möchtest, das wie passiert intern von ganz allein. also hätten wir imperative, logische und descriptive? das wird ja langsam kompliziert ><

edit:


Supercomputer schrieb:


> Mache ich irgend etwas "falsch"? Der Stack  hat ja nur 8 MB, jedoch kann ich mühelos Vektoren habe die insgesamt  weit über 100 MB groß sind, jedoch gebe ich nicht an, dass ein neues  Objekt eines Vektors im Heap gespeichert werden.
> 
> Werden Vektoren also immer auf dem Heap erzeugt?


  soweit ich weiß (ich sollte den mist eigentlich grad büffeln  )  sind heap und stack die dynamischen bereiche des speichers eines  prozesses. aufm stack wird eher "interner" kram gespeichert (zeugs fürn  sheduler), während der heap wohl für die ganzen variablen is. aber wie  gesagt, ich bin noch beim büffeln, aber irgendwie sowas stand da ^^


----------



## Supercomputer (20. Juli 2014)

Will nicht Mark Zuckerberg eine Programmiersprache entwickeln, mit der Zitat: "Jeder Programmieren kann"?


----------



## bingo88 (20. Juli 2014)

DarkMo schrieb:


> soweit ich weiß (ich sollte den mist eigentlich grad büffeln  )  sind heap und stack die dynamischen bereiche des speichers eines  prozesses. aufm stack wird eher "interner" kram gespeichert (zeugs fürn  sheduler), während der heap wohl für die ganzen variablen is. aber wie  gesagt, ich bin noch beim büffeln, aber irgendwie sowas stand da ^^


 Ja, das kommt in etwa hin.

Dynamischer Speicher wird in C und C++ nur verwendet, wenn du das als Entwickler explizit tust (malloc in C, new in C++). Globale statische Daten, deren Größe zur Compilezeit feststehen, werden im sogenannten Datensegment des Programms abgelegt - und das kann durchaus größer als 8 MB sein. Lokale Variablen, die innerhalb einer Funktion nicht-statisch deklariert werden, werden allerdings auf dem Stack angelegt.

Edit:


Supercomputer schrieb:


> Will nicht Mark Zuckerberg eine  Programmiersprache entwickeln, mit der Zitat: "Jeder Programmieren  kann"?


 Naja, es gibt durchaus Sprachen, die sehr einfach sind, bspw. Python. Wer das nicht rafft, kommt auch mit den anderen Sprachen nicht klar.


----------



## Supercomputer (20. Juli 2014)

Und wenn diese zu groß werden, gibt es den Stackoferflow.


----------



## DarkMo (20. Juli 2014)

habs sogar fix gefunden, siehe anhang ^^ btw wird scheinbar der komplette adressraum (bei 32bit also die ganzen 4gig) in diese bereiche aufgeteilt - gilt wohl also prozessübergreifend.


----------



## Supercomputer (20. Juli 2014)

Soweit ich weiß, kann unter 32 Bit 1 Prozess die 4 GB nutzen, jedoch bleibt wegen fehlender Adressbits nichts mehr für die andern übrig.


----------



## DarkMo (20. Juli 2014)

rein theoretisch, ja. er kann ja adressen mit 32 bit ansprechen - also eben diese 4gig. jedoch bekommen andere prozesse ja auch speicher zugesprochen und auslagerung auf sekundärspeicher (platte ^^ - virtueller speicher bla) gibts auch noch. uund win limitiert(e - also die 32bit systeme) auf max 2gig je prozess.


----------



## bingo88 (20. Juli 2014)

Nein. Moderne OS nutzen das Konzept des virtuellen Speichers und Paging. Prinzipiell verfügt jede 32 Bit Anwendung über ihren eigenen Adressraum von 4 GB, wobei das in der Praxis natürlich nicht alles nutzbar ist. AFAIK ist bei 32 Bit Windows sogar bei 2 GB Schicht im Schacht, sofern die Anwendung nicht Large Address Aware ist (dann 3 GB bei 32 Bit bzw. volle 4 GB bei 64 Bit/WOW64). Das ist ein relativ komplexes Thema, um das jetzt noch zu dieser Uhrzeit in Textform erläutern zu können


----------



## Supercomputer (20. Juli 2014)

Ich nutze lieber Linux als Windows, unter Linux hat man keine Begrenzung das maximalem Speichers auf 192 GB (Win 7 ab Proffesional).


----------



## bingo88 (20. Juli 2014)

Da verstehst du mich falsch. Ich spreche von 32-Bit Anwendungen, da ist auch bei Linux mit 4 GB das Maximum erreicht. Was ich meinte, unter Windows 32-Bit kann eine 32-Bit Anwendung out of the box keine vollen 4 GB Speicher nutzen, da ist meist bei 2 GB Schluss. Die Anwendung muss mit Support für große Addressen kompiliert werden, um mehr nutzen zu können (mal wieder Legacy-Kram aus alten Tagen). Jedenfalls ist dieses Flag auch bei 64-Bit Windows erforderlich, sonst bekommt die 32-Bit Anwendung auch da nur 2 GB. Bei echten 64-Bit Anwendung besteht dieses Limit nicht.

Abgesehen davon, was Paging und virtuellen Speicher angeht, das funktioniert auch so unter Linux. Das wird nämlich zum Teil von der Hardware vorgegeben.


----------



## Supercomputer (20. Juli 2014)

Ok, danke für die Aufklärung.

Solche "Diskussionen"  bringen mich weiter, man kann schließlich kein Haus bauen, wenn man keine Grube ausgräbt.
Je exakter die Grube ist, desto besser.


----------



## bingo88 (20. Juli 2014)

Das ist wohl war, zumal Paging bei der Spieleentwicklung durchaus ein Problem werden kann. Ausgelagerter Speicher muss nämlich von der Platte wieder in den RAM geladen werden und das bedeutet lange Wartezeiten.


----------



## Supercomputer (20. Juli 2014)

Das kenne ich von meinem System zu gut 1GB RAM @217 MHz (DDR 400 Slots auf dem Board), jedoch immer noch schneller als die Platte.
Die Aufgabe für Performance ist so wenig wie Möglich den Speicher bewegen. Da der Speicher langsam ist.


----------



## bingo88 (20. Juli 2014)

Die wachsende Diskrepanz zwischen CPU- und Speichergeschwindigkeit ("Memory Wall") ist in der Tat ein Problem. Man muss halt versuchen, die Speicherzugriffe so gut wie möglich zu verstecken, ganz vermeiden kann man sie ja nicht. Zumal du bei Spielen noch mit dem Problem zu kämpfen hast, dass du oft nicht alle notwendigen Daten vor dem Spielstart in den Speicher bekommst (kein Platz) und du den Kram zwischenzeitlich von Platte laden musst. Bei Half-Life 1 gab es ja auch diese schönen Loadings zwischendurch  Bei Konsolen sieht das zum Teil noch viel schlimmer aus, da du deine Daten oft noch von einem optischen Datenträger beziehst. Wie sehr man damit zu kämpfen hat, hängt aber vom Spiel ab. Open World Titel haben damit ein echtes Problem, Spiele wie Sidescroller oder Point-and-Click Adventures eher weniger.


----------



## Supercomputer (20. Juli 2014)

Je mehr Daten da sind, desto schwieriger wird es.


----------



## bingo88 (20. Juli 2014)

Kann man im Prinzip so sagen, ja. Ist halt auch eine Herausforderung, das macht das meiner Meinung nach auch so interessant.


----------



## Supercomputer (20. Juli 2014)

Der einzige wirklich schnelle Speicher ist der L1 Cache 
Danach wird es wirklich langsam.

So wird man gezwungen mit möglichst kleinen Daten möglichst viel zu machen, das ist die Herausforderung und der Grund warum mache Menschen programmieren,


----------



## bingo88 (20. Juli 2014)

Supercomputer schrieb:


> Der einzige wirklich schnelle Speicher ist der L1 Cache
> Danach wird es wirklich *immer* langsam*er*.


 So würde ich das ausdrücken ^^ Selbst der L3 Cache kann noch was rausholen.



Supercomputer schrieb:


> So  wird man gezwungen mit möglichst kleinen Daten möglichst viel zu  machen (...)


Sofern die Problemstellung das zulässt, ist das durchaus sinnvoll.


----------



## Supercomputer (20. Juli 2014)

Ok, der Vorteil vom L3 Cache ist halt, dass die Kerne sich den teilen.


----------



## Gary94 (20. Juli 2014)

Supercomputer schrieb:


> Der einzige wirklich schnelle Speicher ist der L1 Cache


 
Da kommen aber vorher noch die Register der einzelnen Kerne.


----------



## Supercomputer (20. Juli 2014)

Die Register halten doch nur die aktuellen Befehlen


----------



## bingo88 (20. Juli 2014)

Nein, das stimmt so nicht. Es gibt verschiedene Register, die unterschiedliche Aufgaben übernehmen. Einige enthalten Daten, andere Befehle, andere Statusinformationen (Flags, Speicheradressen, etc.).


----------



## Supercomputer (20. Juli 2014)

Oh, ok


----------



## Supercomputer (7. August 2014)

Mittlerweile bin ich beim Konstruieren der Objekte, jedoch kommt mir da eine Frage, wie viele Punkte sollten für einen Kreis/ eine Kugel berechnet werden?
Also wie groß sollte das Raster sein?


----------



## Bunny_Joe (8. August 2014)

Du musst erstmal entscheiden welche Art von Raster du verwenden willst. Hat nen großen Einfluss auf die Polygonzahl.
https://dl.dropboxusercontent.com/u/448525/keep/Polycount/spheres_and_polycounts.png

Dann kannst du ggf. noch Optimierungen vornehmen.
http://i42.photobucket.com/albums/e305/muzzoid/optimisation.png


----------



## Supercomputer (8. August 2014)

Ja, darüber habe ich mir auch schon Gedanken gemacht, je kleiner das Raster, desto runder ist die Kugel und um so genauer sind Kollisionsberechnungen, jedoch braucht dies auch wieder mehr Rechenleistung.


----------



## Supercomputer (9. August 2014)

Ich werde als Raster ein symmetrisches Raster nutzen. Also alle Punkte sind von den umgebenen Punkten gleich weit entfernt.
Nun habe ich jedoch noch eine Frage an euch. Welche Form würdet ihr bevorzugen?

```
1. setroomheight(long double lenght) // Hiermit werden die Längen definiert
   setroombasicform(bool circle, bool square, bool rectangle, bool sphere, bool cube, bool cuboid) // Mit dieser Funktion wird der Raum erstellt

2. setroomheight(long double lenght) // Hiermit werden die Längen definiert
   setroombaiscform(int id) // Mit der id wird dann der Raum initialisiert

3. setroomascicle(long double widht, long double height) // Cicle kann auch eine Ellipse werden, daher sind 2 Längenangaben möglich, bleibt eine jedoch werden sie automatisch gleich gesetzt
```

Bei den Funktionen, die eine bestimmte Eigenschaft vor geben z.B. "height" oder "cicle" werden dementsprechend für jede Eigenschaft geschrieben.

Oder hättet ihr eine andere/bessere Idee?


----------



## Magogan (16. August 2014)

Length, nicht lenght 

Die Kollisionserkennungen bei einer Kugel solltest du lieber anhand des Abstandes zum Mittelpunkt machen anstatt anhand des Modelles. Das verringert den Rechenaufwand enorm.

Ich würde eine einzige Funktion zum Initialisieren des Raumes benutzen. Ggf. auch überladen, da du bei einer Kugel ja nur Mittelpunkt und Radius brauchst, bei einem Zylinder aber mindestens 2 Punkte und einen Radius. Vielleicht doch wirklich pro Typ eine eigene Funktion, ist wahrscheinlich sinnvoller. Je nachdem, was einfacher für dich ist.


----------



## Supercomputer (16. August 2014)

Magogan schrieb:


> Length, nicht lenght


 Schande über mein Haupt 


Mir ist es recht egal, welche Variante ich nehme das, was von den Usern am liebsten verwendet wird.


----------



## Supercomputer (25. Oktober 2014)

Nach der "Sommerpause" bin ich nun mal wieder zum Programmieren gekommen und kann an jeden der an größeren Projekten arbeitet nur sagen, kommentiert alles, schreibt Romane sonnst kommt ihr nicht mehr zurecht.


----------



## Bunny_Joe (26. Oktober 2014)

Supercomputer schrieb:


> Nach der "Sommerpause" bin ich nun mal wieder zum Programmieren gekommen und kann an jeden der an größeren Projekten arbeitet nur sagen, kommentiert alles, schreibt Romane sonnst kommt ihr nicht mehr zurecht.


Da hats wohl jemand auf die harte Tour gelernt?


----------



## Magogan (26. Oktober 2014)

Sinnvolle Variablennamen etc. sind aber auch nicht schlecht, wenn man später den Code verstehen will. Ich verstehe auch ohne viele Kommentare, was mein Programm macht, allerdings weiß ich nicht, wie das nach ein paar Monaten Pause aussieht. Das meiste ist aber logisch und nachvollziehbar benannt, also sollte ich keine größeren Probleme haben.


----------



## Supercomputer (26. Oktober 2014)

Ich kann doch auch ganz einfach, aus jeder Form eine eigenen Klasse machen, oder?

aktuell frage ich nur z.B.

```
set_as_cube(bool SET);
```
und mit SET wird dann bool is_cube gesetzt; (Standard ist es false)

ich könnte doch auch einfach eine Klasse mit is_cube anlegen und dann nur die dafür gebrauchten Operationen zur Verfügung stellen, oder liege ich da falsch?


----------

