Optimizing Performance

Question

I am having a problem with my program as I am not getting the
desired frame rate due to all the code that is getting executed per
tick. So I have some questions about director and lingo as to which
way actually executes faster.
1. Multiple
ExitFrame calls vs a single
ExitFrame call.
I have alot of sprites in my app. Almost all of them have an
ExitFrame handler.
Question: is it faster to have each sprite handle it's own
ExitFrame routine and do code specific to that sprite or is
it faster to have one generic
ExitFrame to loop through and execute code for each sprite?
2. Puppeted sprites vs Non-Puppeted sprites.
I have a alot of sprites in my program. To make life ALOT
easier, I simply allocated a good chunk of sprite channels to sole
use of "dynamically created sprites". My program can have hunders
of puppeted sprites from any given moment to the next.
Question: Does director progress faster or slower depending
on if a sprite is puppeted or not? Or is there any difference at
all?
3. Checking to see if a variable is set before setting it.
I have only recently come into the Director/Lingo world of
programming. I am originally a VB programmer for almost a decade.
In visual basic, I have noticed that the code executes faster if
you don't do unneeded variable assignments by checking to see if it
was already set.
Example: In visual basic, let's say you have an array of 1000
elements, some elements are already set, some are not.
for i = 1 to 1000
var(i) = i
next
The above code executes fast, but if you are doing that very
very often, it can be a bottle neck.
the below code, while doing the exact same thing, actually is
faster.
for i = 1 to 1000
if var(i) <> i then var(i) = i
next
In VB, it's faster to do a check of a variable than it is to
do the assignment when it's not needed. Now granted, this is a poor
example, usually I am dealing with much more complex routines, but
the basic principle of what I am trying to get across is the same.
Question: in Director/lingo, would it speed up the execution
of code to do a variable check before the assignment, or is the
very act of adding the check going to slow the down the execution?
Anyone have any ideas about these? Or anyone have any other
tips about stupid little things to speed up execution of
code?

Answer 1

>
1. Multiple
ExitFrame calls vs a single
ExitFrame
> call.
You should consider dropping the exitframe approach, in favor
of an oop
model.
OOP is not faster, as a dual core processor is not faster
than a single core
one running at double the speed. In fact, the second should
be faster, since
there is no synchronization penalty. However, it is much
smoother. Same with
oop, you have a penalty, since you are using more objects,
but the objects
can be smart enough to adjust the number of instructions they
execute as
required.
If you e.g. have objects whose coordinates can be calculated
and stored
inside the object, you don't have to update the stage each
time an object
moves. You can do that once, for all objects in set
intervals. Long as the
interval is large enough to handle all intermediate
processing and
updatestage cost, you'll have a very smooth movie.
>
2. Puppeted sprites vs Non-Puppeted sprites.
Puppeting does not affect performance -or at least it
shouldn't. The number
of sprites, and number of behaviors attached to each sprite
does. However,
even when there is a very large number of sprites active, the
procedure
should be a joke for any modern cpu. What does cost, is
redrawing the
sprites. So, if it's image sprites we are talking about, you
should perhaps
consider a single bitmap member you should use as a buffer,
and imaging
lingo for drawing each frame. The mouse click events can be
evaluated by
keeping a list of virtual sprite positions. Even if not
familiar with the
above, the time you'll invest in learning what is required,
will be rewarded
with a significant -up to times x- performance increase.
>
3. Checking to see if a variable is set before setting it.
You can create a simple lingo benchmarking script to get your
answers. As a
general principle, the less commands the faster. Though not
really into VB
(I find c++ and lingo to be a killer combination), I can
assume why this is
happening: when setting a variable, vb is executing some code
to evaluate
what the value was, and what -if anything- has to be
released. Though
nowhere documented, it seems that several years ago, someone
in the director
dev team was smart enough to take this matter into account
when creating the
object that is known as a lingo variable (64bit internally,
btw). So,
director doesn't suffer slow variable release - releasing
what shouldn't be
released that is.
> Anyone have any ideas about these? Or anyone have any
other tips about
> stupid
> little things to speed up execution of code?
You know, a few years ago, lingo performance/speeding up
director was a
regular discussion issue in this list. This is not the case
anymore. And
though I can guess a couple reasons why, I found none to be
qualified as an
explanation.. Not in my book at least. Case you have any more
questions, I'd
be happy to answer. Building a site with director performance
hints /
optimizing lingo code is high in my to do list.
"DaveGallant" <[email protected]> wrote in
message
news:[email protected]...
>I am having a problem with my program as I am not getting
the desired frame
> rate due to all the code that is getting executed per
tick. So I have some
> questions about director and lingo as to which way
actually executes
> faster.
>
>
1. Multiple
ExitFrame calls vs a single
ExitFrame
> call.
>
> I have alot of sprites in my app. Almost all of them
have an
>
ExitFrame
> handler.
> Question: is it faster to have each sprite handle it's
own
>
ExitFrame
> routine and do code specific to that sprite or is it
faster to have one
> generic
>
ExitFrame to loop through and execute code for each sprite?
>
>
2. Puppeted sprites vs Non-Puppeted sprites.
>
> I have a alot of sprites in my program. To make life
ALOT easier, I simply
> allocated a good chunk of sprite channels to sole use of
"dynamically
> created
> sprites". My program can have hunders of puppeted
sprites from any given
> moment
> to the next.
> Question: Does director progress faster or slower
depending on if a sprite
> is
> puppeted or not? Or is there any difference at all?
>
>
3. Checking to see if a variable is set before setting it.
>
> I have only recently come into the Director/Lingo world
of programming. I
> am
> originally a VB programmer for almost a decade. In
visual basic, I have
> noticed
> that the code executes faster if you don't do unneeded
variable
> assignments by
> checking to see if it was already set.
>
> Example: In visual basic, let's say you have an array of
1000 elements,
> some
> elements are already set, some are not.
>
> for i = 1 to 1000
> var(i) = i
> next
>
> The above code executes fast, but if you are doing that
very very often,
> it
> can be a bottle neck.
> the below code, while doing the exact same thing,
actually is faster.
>
> for i = 1 to 1000
> if var(i) <> i then var(i) = i
> next
>
> In VB, it's faster to do a check of a variable than it
is to do the
> assignment
> when it's not needed. Now granted, this is a poor
example, usually I am
> dealing
> with much more complex routines, but the basic principle
of what I am
> trying to
> get across is the same.
>
> Question: in Director/lingo, would it speed up the
execution of code to do
> a
> variable check before the assignment, or is the very act
of adding the
> check
> going to slow the down the execution?
>
>
>
> Anyone have any ideas about these? Or anyone have any
other tips about
> stupid
> little things to speed up execution of code?
>