Changes between Version 3 and Version 4 of code/PerformanceTips

Timestamp:

Aug 19, 2005, 12:13:14 PM (19 years ago)

Author:

patrick

Comment:

—

code/PerformanceTips

@@ -4 +4 @@
 Function declared as inline will be included in the calling code in compilation time. This speeds up execution because all the branching stuff doesn't have to be executed. The speedup is maxed out, when these functions are only very small, so when the execution of the function needs approximatly the same time as the branching time. Here a little example:
 {{{
+// in test.h
 class Test
 {
  public:
-  int getSize();
+  int getSize() { return this->iSize; }
  private:
   int size;
 };
 
-inline int Test:getSize()
-{
-  return this->size;
-}
+/* remember that inline functions must be defined in the *.h (header) file! */
 }}}
+Y
 This function will be executed aproximatly 10 times faster on a Pentium II based processor.
 '''BUT'''
-Don't write everywhere inline functions: use it only for time critical stuff, so said functions, that are executed very often during the game-time of orxonox like:
- * ''void !WorldEntity::tick(float time) {}'' this function is called everytime a frame is rendered
- * ''bool !BaseObject::isFinalized()'' this function is called from the garbage collector every time he does its job
+Don't write everywhere inline functions: use it only for :
+ * small interface functions like {{{ int getAttribute {....};}}} or {{{ void setVelocity(float velocity) { this->velocity = velocity; } }}}
+ * time critical stuff, so said functions, that are executed very often during the game-time of orxonox like: ''void !WorldEntity::tick(float time) {}'' this function is called everytime a frame is rendered
 Don't use it for functions that are normally called before and after the game time or functions that are rarely called at all.
-Inlining brings some problems, too. First: Inlined code doesn't have to be made inline by the compiler. Some reasons, why this could happen are: loops in the inlined code, recursive code in the inlined code and function calls in the inlined code.
+Inlining brings some problems, too. First: Inlined code doesn't have to be made inline by the compiler. Some reasons, why this could happen are: loops in the inlined code, recursive code in the inlined code and function calls in the inlined code. Private functions are inlined automaticaly.
  
 == Memory Allocation and Deletion: new, delete ==
@@ -37 +36 @@
 }
 }}}
-To free the memory is very important, if the function is called multiple times! [br]
+To free the memory is very important, if the function is called multiple times! But know, that deleting uses much time again. So if there is a possibliliy of reusing the old function. In time critical parts of the code (like in-game) you can think about creating the objects in initialisation time and delete them after the time-critical part.[br]
 If you write it the following way, you don't have to delete it:
 {{{
@@ -61 +60 @@
 }
 }}}
-The compile will complain about such things with a message like this: "WARNING: taking address of a temporary". And Mr. compiler is absolutly right!
+The compiler will complain about such things with a message like this: "WARNING: taking address of a temporary". And Mr. compiler is absolutly right!
 A better way would be:
 {{{
@@ -73 +72 @@
   Object* obj = new Object*();     /* this is only a local reference! automatically deleted after function return */
   SomeClass* sc = new SomeClass(); /* creation of a new object needs much time, avoid it if possible - here we need it */
-  sc->wantObjectReference(obj);    /* BAD BAD BAD BAD!!!!! */
-  delete sc;
+  sc->wantObjectReference(obj);    
+  delete sc;                       /* remember that creating and deleting object need VERY much time*/
 }
 }}}