Processing Forum

Worrying performace issues.

[11 Replies]
- 06-Dec-2012 03:50 AM
- Forum: Programming Questions
Been doing some more messing around with processing and, whether it's my laptop or just linux, processing apps consume a lot of ram and run slowly. While my laptop isn't the fastest machine around a simple app should not be using up 100mb of ram. Also the opengl renderer seems rather slow. Most likely this is me coding unoptimized pieces of code. Lastly what kind of size (in ram) is a pshape (yes this'll change on different shapes). I'll upload a sample app i made to see what you think of it.
1. void setup()
  {
  frameRate(30);
  smooth();
  size(displayWidth, displayHeight, OPENGL);
  SizeDone = true;
  Targets[0] = new Target(0, 0, displayWidth, displayHeight, true, SizeDone, true);
  Targets[0].GraphicsInit();
  }
  
  void draw()
  {
  background(255);
  Targets[0].Draw();
  }
  
  void mousePressed()
  {
  if (mouseButton == LEFT) {
  Targets[0].Shot();
  }
  else if (mouseButton == RIGHT)
  {
  
  }
  }
1. boolean SizeDone = false;
  Target[] Targets = new Target[1];
  String Mode = "Target";
  int ModeNumber = 0;
1. class Shot
  {
  public PShape Bullet;
  public PShape Averagess;
  private double TargetScale;
  public ArrayList Vectors = new ArrayList();
  public Shot(double Targetscale)
  {
      TargetScale = Targetscale*0.04869565217;
      Setup();
  }
  public void Setup()
  {
      float Size = (float)TargetScale;
      Bullet = createShape(ELLIPSE, 0, 0, Size, Size);
      Averagess = createShape(RECT, Size/4, Size/4, Size/2, Size/2);
      Averagess.fill(255, 60);
      Bullet.fill(0, 60);
      Bullet.noStroke();
  }
  public void AddShot(Vector2 shot)
  {
      shot.X -= TargetScale/2;
      shot.Y -= TargetScale/2;
      Vectors.add(shot);
  }
  public void SaveShots()
  {
  }
  public void Draw()
  {
      //    Iterator itr = Vectors.iterator();
      //    while (itr.hasNext ()) {
      //      //Vector2 element = itr.next();
      //      object xz = itr.next();
      Vector2 Average = new Vector2(0, 0);
      for (int i = Vectors.size()-1; i >= 0; i--) {
        Vector2 vectors = (Vector2) Vectors.get(i);
        Average.X += vectors.X;
        Average.Y += vectors.Y;
      }
      Average.X = Average.X/Vectors.size();
      Average.Y = Average.Y/Vectors.size();
      pushMatrix();
      translate(Average.X,Average.Y);
      shape(Averagess);
      popMatrix();
      for (int i = Vectors.size()-1; i >= 0; i--) {
        // An ArrayList doesn't know what it is storing,
        // so we have to cast the object coming out.
        Vector2 vectors = (Vector2) Vectors.get(i);
        pushMatrix();
        translate(vectors.X, vectors.Y);
        shape(Bullet);
        popMatrix();
      }
  }
  }
  
  class Vector2
  {
  public float X;
  public float Y;
  public Vector2(float eX, float eY)
  {
      X = eX;
      Y = eY;
  }
  }
class Target
{
private PShape Targets;
private int X;
private int Y;
private int SizeX;
private int SizeY;
private boolean InnerRing;
public Shot Shots;
public Target(int Xc, int Yc, int SizeXc, int SizeYc, boolean Ring, boolean SizeDone, boolean RetainSize)
{
    X = Xc;
    Y = Yc;
    SizeX = SizeXc;
    SizeY = SizeYc;
    if (RetainSize == true)
    {
      if (SizeX > SizeY)
      {
        SizeX = SizeY;
      }
      else
      {
        SizeY = SizeX;
      }
    }
    InnerRing = Ring;
    if (SizeDone == true)
    {
      GraphicsInit();
    }
}
public void GraphicsInit()
{
    Shots = new Shot(SizeX);
    Targets = createShape(GROUP);
    PShape Ring1 = createShape(ELLIPSE, 0, 0, SizeX, SizeY);
    PShape Ring2 = createShape(ELLIPSE,
    (0.60869565217/2)*SizeX, (0.60869565217/2)*SizeY,
    0.39130434782*SizeX, 0.39130434782*SizeY);
    PShape Ring3 = createShape(ELLIPSE,
    (0.35)*SizeX, (0.35)*SizeY,
    0.3*SizeX, 0.3*SizeY);
    Ring1.fill(200);
    Ring1.noStroke();
    Ring2.fill(255);
    Ring2.noStroke();
    Ring3.fill(200);
    Ring3.noStroke();
    Targets.addChild(Ring1);
    Targets.addChild(Ring2);
    Targets.addChild(Ring3);
}
public void Shot()
{
    Shots.AddShot(new Vector2(mouseX, mouseY));
}
public void Draw()
{
    shape(Targets);
    Shots.Draw();
}
}

If you can give me any help with these issues i'd be pretty happy.

keyPressed() needs some clarification.

[3 Replies]
- 30-Nov-2012 06:37 PM
- Forum: Programming Questions
In the documentation for KeyPressed() it should be explicitly noted that it is only called synchronously with draw. Not asynchronously.
1. timer time;
  void setup()
  {
  time = new timer();
  size(90,90,P3D);
  }
  
  void draw()
  {
  frameRate(0.5);
  background(255);
  }
  
  void keyPressed()
  {
  time.Turn();
  //print(keyCode);
  }
  
  class timer
  {
  private int time;
  private boolean tim;
  private int downtime;
  public timer()
  {
      tim = false;
  }
  public int Turn()
  {
      if (tim == false)
      {
        time = millis();
        tim = true;
        return 0;
      }
      else
      {
        downtime = millis();
        tim = false;
        println(downtime - time);
        return downtime - time;
      }
  }
  }
Example output:
1. 2003
  0
  1996
  1999
  0
  0
  0
  2001
  4000
  4000
This code, if Keypressed() was asynchronous, would print values of an exact nature. However as KeyPressed() is only synchronous it only prints values similar to 2000 as that is the set framerate. It should be stated on the KeyPressed() site that it is synchronous, or, better still, it be made asynchronous to allow for more exact and responsive key presses (a very usefull, and uncommon, feature for games).

On the other hand if there is an asynchronous Keypressed() function could you inform me how to create or use it.

C++ vs processing test weird results.

[6 Replies]
- 27-Nov-2012 05:30 AM
- Forum: Programming Questions
For a game I'm designing i wanted to test out the performance differences between C++, C# and processing. However I became stumped after processing ran over twice as fast as C++ for a simple test I made. Does this make sense??

The processing timer class code is :
1. class Testerlegacy
  {
  double one;
  double two;
  int counter = 0;
  int calcs;
  
  public void test(double p)
  {
      println("single core checker to proceeding");
      one = 2;
      two = p;
      calcs = 1000000;
      println("start");
      int init, Final;
  
      init=millis();
  
      while ( counter < calcs)
      {
        one = one * two;
        two = one * one;
        one = one * two;
        two = one * one;
        one = one * two;
        two = one * one;
        one = one * two;
        two = one * one;
        one = one * two;
        two = one * one;
        one = one * two;
        two = one * one;
        one = one * two;
        two = one * one;
        one = one * two;
        two = one * one;
        one = one * two;
        two = one * one;
        one = one * two;
        two = one * one;
        counter = counter + 1;
      }
      Final=millis()-init;
      double Final2 = Final;
      println("time taken for all calcs:");
      println(Final2 / 1000);
      println("Calcs per 1/30 seconds:");
      println(calcs*20);
      print(((calcs*20)/(Final2 / 1000))/30);
      print(" - ");
      println((((calcs*21)/(Final2 / (1000)))/30));
  }
  };
The C++ timer class code is:
1. class Testerlegacy
  {
     double one;
     double two;
     double counter;
     string checker;
     int calcs;
  public:
     void test(double x)
  {
  cout << "Do you wish for single core checker to proceed? Press n for no." << endl;
  cin >> checker;
  if (checker == "n")
  {
  return;
  }
  one = 2;
  two = x;
  calcs = 1000000;
     cout << "start" << endl; // 300000 calcs assumes cout counter and while loop add up to 1
  clock_t init, final;
  
  init=clock();
  
      while ( counter < calcs)
         {
         one = one * two;
             two = one * one;
         one = one * two;
             two = one * one;
         one = one * two;
             two = one * one;
         one = one * two;
             two = one * one;
         one = one * two;
             two = one * one;
         one = one * two;
             two = one * one;
         one = one * two;
             two = one * one;
         one = one * two;
             two = one * one;
         one = one * two;
             two = one * one;
         one = one * two;
             two = one * one;
         counter = counter + 1;
         }
  final=clock()-init;
  cout << init << endl;
  cout << (double)final << endl << (double)CLOCKS_PER_SEC << endl;
  cout << "time taken for all calcs: " << (double)final / ((double)CLOCKS_PER_SEC) << endl;
  cout << "Calcs per 1/30 seconds: " << ((calcs*20)/((double)final / ((double)CLOCKS_PER_SEC)))/30 << " - " << ((calcs*21)/((double)final / ((double)CLOCKS_PER_SEC)))/30;
  cout << endl;
     cout << "end" << endl;
  
  }
  };
After running these pieces of code multiple times on C++ I averaged around 1,60,000 calcs per 1/30 whereas the processing code was getting 1,100,000 calcs per 1/30.

sample output for C++ :
1. Do you wish for single core checker to proceed? Press n for no.
  k
  start
  0
  4.7e+06
  1e+06
  time taken for all calcs: 4.7
  Calcs per 1/30 seconds: 141844 - 148936
  end
sample output for processing code:
1. single core checker to proceeding
  start
  time taken for all calcs:
  0.583
  Calcs per 1/30 seconds:
  20000000
  1143510.5774728418 - 1200686.1063464838
Is my computer playing up? Is my code wrong? Is it an unbalanced test? Or does processing just beast C++?

Activity Trend