Hi,
on ubuntu studio 9.04 and PROCESSING 1.0 (REV 0162), this simple ex runs very slow on size(500,500); while it runs fine on size(100,100);
Is that normal ?

here is the programme (very simple):
Spot sp;

void setup() {
 size(500,500);
 smooth();
 noStroke();
 sp=new Spot(33,50,30,1.5);
}

void draw() {
 fill(0,15);
 rect(0,0,width,height);
 fill(255);
 sp.move();
 sp.display();
}

class Spot {
 float x,y;
 float diameter;
 float speed;
 int direction=1;

 Spot(float xpos, float ypos, float dia, float sp) {
   x=xpos;
   y=ypos;
   diameter=dia;
   speed=sp;
 }

 void move() {
   y+=(speed * direction);
   if ((y>(height-diameter/2)) || (y<diameter/2)) {
     direction*=-1;
   }
 }
 void display(){
   ellipse(x,y, diameter,diameter);
 }
}

Thanks for letting me know.
Alex

To put NoChin's reply another way:

Code:

Spot sp;
Spot sp2;

void setup() {
 size(500,500);
 background(0);
 smooth();
 noStroke();
 sp=new Spot(33,50,30,1.5);
 sp2=new Spot(73,50,30,1.5);
}

void draw() {
 fill(0,15);
 rect(0,0,width,height);
 stroke(150);
 rect(0,0,100,100);
 noStroke();
 fill(255);
 sp.move();
 sp.display();
 sp2.move();
 if(sp2.y>100-15) {
   sp2.direction *= -1;  
 }
 sp2.display();
}

class Spot {
 float x,y;
 float diameter;
 float speed;
 int direction=1;

 Spot(float xpos, float ypos, float dia, float sp) {
   x=xpos;
   y=ypos;
   diameter=dia;
   speed=sp;
 }

 void move() {
   y+=(speed * direction);
   if ((y>(height-diameter/2)) || (y<diameter/2)) {
     direction*=-1;
   }
 }
 void display(){
   ellipse(x,y, diameter,diameter);
 }
} 

I'm running Processing 1.03 (Note that the latest version is 1.05 - rev 0167) on Windows XP on a 2Ghz core Duo with 2Gb RAM.  It runs perfectly well on my machine.  Updating Processing might be a good place to start.

I did wonder at first whether you meant it was actually slow, rather than perceptually so...  One thing I did notice was that CPU usage increased substantially at 500 by 500 compared to 100 by 100 - from around 15% to around 55%; though that's not entirely unexpected since it's got more pixels to render.

Note that the default frameRate is 60.  If I set it to 30 and double the speed parameter of the ball it does look slightly smoother and the cpu usage drops to around 35%.

Now here's something interesting.  I'm just running one of my sketches (at 30 fps) that involves 10 balls bouncing around at random, being influenced by gravity and friction and with collision detection between them all and it's averaging around 40%...  From which I would surmise that it's something to do with having to render a larger display window that causes the greater CPU load.

One thing I've found in the past is that invoking the OPENGL renderer can improve 2D performance (import opengl library from the Sketch menu and then: size(500,500,OPENGL) - assuming you have a graphics card that supports it...)

Also for testing you can println(frameRate);

I've gotten wildly different performance between the different processing renderers on different machines.

Try:

size(500,500,P2D);

or

size(500,500,P3D);

or put this at the top:

import processing.opengl.*;

and use this in your setup function:
size(500,500,OPENGL);


It is very strange that you'd be seeing only 1 frame per second, I agree with alvaro that it sounds like a graphics card issue but what are the specs of the machine you're running it on?

You're using the JAVA2D renderer (default) which is slower for sure, but it could be that you don't have enough video or system memory on the machine you're using.

For a double buffered app with a 500 by 500 pixel view (which probably gets upscaled to the next power of two which would be 512 by 512) results in:

2 buffers * 262144 pixels * 4 bytes per pixel (32 bit color) = 2MB free ram depending on what type of memory the Java2D renderer requires.

You might not have that if you're running on a netbook with integrated graphics and you're running the full Ubuntu - but that's just a guess I could be way off.

Anyways, I just wanted to add a bit more info to the pile! I hope you get it working!

Jack