AlliedModders Wiki - User contributions [en]

Optimizing Plugins (AMX Mod X Scripting)

2007-04-13T02:37:48Z

P34CH 34732: /* Local Strings */ Fixed BAILOPAN's nonsense code

==Introduction==
[[Admin-Mod]] and [[AMX Mod X]] became very popular because of their easy to use scripting language. However, the words "scripting language" come with a lot of loaded preconceptions. Most people assume that because it's scripted:
*You can't possibly make it any faster
*It's pre-compiled, so it's already quite fast
*Details don't matter, as it's only "scripting" anyway

Especially, with [[Pawn]] (formerly Small), none of these are true. The compiler, in fact, is very poor at optimizing, and you can '''greatly''' increase the speed and efficiency of your plugins by keeping a few rules in mind. Remember - it's more important to minimize instructions than it is to minimize lines of code.

===Terms===
To read this document, you will need to understand a few concepts beforehand:
*<tt>BRANCHING</tt> - When the processor takes a different path of code. For example, to call a function or to use an if statement, the processor will "branch". Modern processors attempt to predict pathways with "branch prediction", but it's best to avoid branching a lot if possible.
*<tt>STACK ALLOCATION</tt> - In Pawn, all local data is stored on the stack, a big chunk of continuous memory. Whenever you create a variable on the stack, it is automatically written with zeroes.
*<tt>HEAP ALLOCATION</tt> - In Pawn, temporary data that needs to be referenced by a native is stored on the heap, another area of contiguous, but less restrictive memory.
*<tt>DATA SECTION</tt> - This is an area of memory built into your .amxx file. In fact, it "becomes" the heap at load time. All your strings and arrays are hardcoded into this area.
*<tt>EXPENSIVENESS</tt> - To be "expensive" in computer science means an operation requires a lot of CPU processing. It usually does not refer to memory size, only to processing cycles and time. Addition is inexpensive, floating power operations are expensive. However, both are inexpensive in comparison to writing a file. An inexpensive operation can also be called "cheap".
*<tt>BIG-OH NOTATION</tt> - O(*) notation refers to the expensiveness of an algorithm. If something is O(n), it occurs in linear time -- meaning that for N items, it will complete relative to N. O(N^2) means with N items, it will complete relative to N^2. O(1) means "constant time" - no matter what N is, it will run in the same amount of time.

==Compiler Optimizations==
These optimizations have to do with changing how your code is compiled. While the syntax may remain the same, you are not only increasing compile time, but increasing your plugin's efficiency and speed at run time.

===Always Save Results===
Observe the example code snippet below:
<pawn>if (get_user_team(player) == TEAM_T)
{
//...code
} else if (get_user_team(player) == TEAM_CT) {
//...code
} else if (get_user_team(player) == TEAM_SPECTATOR) {
//...code
}</pawn>
This is a mild example of "cache your results". When the compiler generates assembly for this code, it will (in pseudo code) generate:
<pre>
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
CALL get_user_team
COMPARE+BRANCH
</pre>
Notice the problem? We have called <tt>get_user_team</tt> an extra two times than necessary. The result doesn't change, so we can save it. Observe:
<pawn>new team = get_user_team(player)
if (team == TEAM_T)
{
//...code
} else if (team == TEAM_CT) {
//...code
} else if (team == TEAM_SPECTATOR) {
//...code
}</pawn>
Now, the compiler will only generate this:
<pre>
CALL get_user_team
COMPARE+BRANCH
COMPARE+BRANCH
COMPARE+BRANCH
</pre>
If <tt>get_user_team</tt> were an expensive operation (it's relatively cheap), we would have recalculated the entire result each branch of the <tt>if</tt> case.

===Switch instead of If===
If you can, you should use <tt>switch</tt> cases instead of <tt>if</tt>. This is because for an if statement, the compiler must branch to each consecutive <tt>if</tt> case. Using the example from above, observe the switch version:
<pawn>new team = get_user_team(player)
switch (team)
{
case TEAM_T:
//code...
case TEAM_CT:
//code...
case TEAM_SPECTATOR:
//code...
}</pawn>
This will generate what's called a "case table". Rather than worm through displaced <tt>if</tt> tests, the compiler generates a table of possible values, which the virtual machine knows to browse through:
<pre>
CALL get_user_team
COMPARE
COMPARE
COMPARE
</pre>

===Don't Re-index Arrays===
A common practice in Small is to "save space" by re-indexing arrays. There are a few myths behind this, such as saving memory, assuming the compiler does it for you, or readability. Fact: none of these are true. Observe the code below:
<pawn>new players[32], num, team
get_players(players, num)
for (new i=0; i<num; i++)
{
if (!is_user_connected(players[i]))
continue;
team = get_user_team(players[i])
set_user_frags(players[i], 0)
}</pawn>
For this, the compiler generates code similar to:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
CALL is_user_connected
LOAD i
LOAD players
CALC
LOAD players[i]
CALL get_user_team
LOAD i
LOAD players
CALC
LOAD players[i]
CALL set_user_frags
</pre>
See what happened? The compiler does not cache array indexing. Because we've used <tt>players[i]</tt> each time, every instance generates 4-6 (or more) instructions which load <tt>i</tt>, the address of <tt>players</tt>, computes the final location, and then grabs the data out of memory. It is much faster to do:
<pawn>new player
for (new i=0; i<num; i++)
{
player = players[i]
if (!is_user_connected(player))
continue;
team = get_user_team(player)
}</pawn>
Not only is this more readable, but look at how much cruft we've shaved off the compiler's generated code:
<pre>
:LOOP_BEGIN
LOAD i
LOAD players
CALC
LOAD players[i]
STORE player
CALL is_user_connected
LOAD player
CALL get_user_team
LOAD player
CALL set_user_frags
</pre>
In a large loop you can drastically reduce codesize in this manner.

===Global vs Local and Variables in Loops===
It is important to realize that every variable in [[Pawn]] is automatically zeroed. For global variables, they are static and permanent, thus they are zeroed when your plugin is loaded. Variables in functions, however, must be zeroed dynamically. This is a slow and tedious operation, and you should not only avoid relying on it when necessary, but you should keep that fact in mind when using arrays.

[[Arrays]] in [[Pawn]] are "cells" of data. Each cell is four or eight bytes, depending on whether your processor is 32bit or 64bit. To create an array of 4096 cells, for example:
<pawn>new array[4096]</pawn>
The compiler generates code to manually zero every single one of the 16,384 bytes in that location. Normally, this isn't too bad -- but it can be absolutely deadly in a function which is called quite often. For example, <tt>server_frame</tt> is called on every [[server tick]] in [[AMX Mod X]]. To declare an array of that size in <tt>server_frame</tt> is highly unnecessary. Instead, you can take advantage of the fact that not only are globals free of charge, but <tt>server_frame</tt> does not need to be re-entrant. That is, you will never call <tt>server_frame</tt> inside of <tt>server_frame</tt>, so making the variable global will not bring up the problem of one instance of the function overwriting data from another instance of the same function. Observe:
<pawn>new g_serverframe_array[4096]
public server_frame()
{
//...code that uses g_serverframe_array
}</pawn>
This will execute conseridably faster. You can do this with smaller arrays too.

Likewise, it is equally important to avoid declaring arrays inside of loops. Consider the following block of code:
<pawn>for (new i=0; i<num; i++)
{
new message[255], name[32], player
player = players[i]
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
If there are 32 players, this loop will actually resize and zero out over 1K of memory thirty two times in a row. Not good! However, on the other hand, it's nice that the message is zeroed out for us each time. <tt>Tip:</tt> you often only need to zero out the first character of a string. This will make the entire string empty. The code below is much more efficient:
<pawn>new message[255], name[32], player
for (new i=0; i<num; i++)
{
player = players[i]
name[0] = '^0'
message[0] = '^0'
get_user_name(player, name, 31)
format(message, 254, "Hello, %s", name)
}</pawn>
This has the effect of safely making the string empty beforehand, as well as largely reducing a lot of run-time overhead.

===Static vs Global===
An alternative to global variables is static variables, which are internally the same but easier to work with for programming.

A variable declared with the keyword "static" instead of "new" operates in the same way a global does (it is created only once) but the variable is local to the function; this means the code is much easier to read, while drastically improving speed just like a global variable. Example:
<pawn>stock SomeBigFunction()
{
static gaben[255];
format(gaben, "%L", LANG_SERVER, "STUFF");
}</pawn>

This has the same effect as declaring <tt>gaben</tt> as global, except only <tt>SomeBigFunction</tt> can use it.

{{qnotice|Be careful of re-entrancy!}}
When a variable is static, it has the same re-entrancy problems of a global variable. That means, if your function might be called recursively, or twice in the same stack frame, you should not use static variables. This is most often the case for API provided to other plugins or helper functions. Triggered events are usually never called twice on the same execution chain.

===Constant variables===
You can declare a variable "constant" by adding the "const" keyword before the variable name:

<pawn>new const AMX_GABEN[] = "amx_gaben"</pawn>

What this does is prevents the variable from being changed; essentially, you've locked the variable to a certain value. In this way, a constant can offer a type safe method of simplifying code, unlike a define, which is not type safe.

In addition, constant variables are often optimized out, resulting in quicker and smaller code.

===For Loop Comparisons===
A common mistake is to write code like this:
<pawn>new string[256] = "something long"
for (new i=0; i<strlen(string); i++)
//...code</pawn>
This plays off a similar principle from before: cache results. The compiler will actually recompute your string length on each iteration of the loop. This will have even worse effects if your string changes mid-loop. A more sensible method is:
<pawn>new string[256] = "something long"
new len = strlen(string)
for (new i=0; i<len; i++)
//...code</pawn>

==Tips and Tricks==
===Lookup Tables===
Precompute what can be precomputed. For example, say you have a mapping of weapon indices to names:
<pawn>if (weapon == CSW_AK47)
copy(name, len, "weapon_ak47")</pawn>
Ignoring the fact that we have <tt>get_weapon_name</tt> in [[AMX Mod X]], this is inefficient. We could precompute this result in a table:
<pawn>new g_WeaponNamesTable[TOTAL_WEAPONS][] = {
//..0 to CSW_AK47-1
"weapon_ak47",
//..CSW_AK47+1 to TOTAL_WEAPONS-1
};</pawn>

===Perfect Hashing===
:TODO: explain this

===Local Strings===
The [[Pawn]] compiler does not optimize the DATA section, which stores all hardcoded strings and global arrays. If you reference the same hardcoded string 500 times in your plugin, it will appear 500 different times. If this seems bad enough, it actually does this with all strings. For example, the empty string ("") appears everywhere in the include files, usually used as a default parameter to many natives. This too is copied into the data section for each unique reference.

For example:
<pawn>set_cvar_num("amx_gaben", get_cvar_num("amx_gaben") + 1)</pawn>
This will create two copies of "amx_gaben" in the DATA section. While this doesn't really hurt, it does increase the size of your plugin.

Similarly, this has the same problem:
<pawn>#define AMX_GABEN "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>
The only way to avoid this mess is to use global variables. As stated earlier, they're basically free storage.
<pawn>new AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Again, while not necessary, this will reduce your plugin's size in memory and on disk. If you're already using defines, you can make this switch easily.

In order to prevent this from changing, you may want to declare it constant:

<pawn>new const AMX_GABEN[] = "amx_gaben"
set_cvar_num(AMX_GABEN, get_cvar_num(AMX_GABEN) + 1)</pawn>

Now it is a perfectly safe method of storage.

==Faster Natives==
AMX Mod X replaces many of the old AMX Mod natives with faster versions. Read below to discover them.

===Cvar Pointers===
As of AMX Mod X 1.70, you can cache "cvar pointers". These are direct accesses to cvars, rather than named access. This is a critical optimization which is dozens of times faster. For example:
<pawn>new g_enabled = register_cvar("csdm_enabled", "1")
//OR
new g_enabled = get_cvar_pointer("csdm_enabled")

stock SetCSDM(num)
set_pcvar_num(g_enabled, num)

stock GetCSDM()
return get_pcvar_num(g_enabled)
</pawn>
All of the cvar* functions (except for set_cvar_string) are mapped to [get|set]_pcvar_*. You can get a cached cvar pointer with get_cvar_pointer() or register_cvar().

===FormatEX===
As of AMX Mod X 1.70, there is an ultra high-speed version of format() called formatex(). It skips copy-back checking, unlike format(). formatex() cannot be used if a source input is the same as the output buffer. For example, these are invalid:
<pawn>new buffer[255]
formatex(buffer, 254, "%s", buffer);
formatex(buffer, 254, buffer);
formatex(buffer, 254, "%d %s", buffer[2]);</pawn>

It should be noted that format() will behave the same as formatex() if it detects that there will be no copy-back needed. However, formatex() does not check this, and thus is slightly faster for situations where the coder is sure of its usage.

===File Writing===
As of AMX Mod X 1.70, there are new natives for file writing. Read_file and write_file are O(n^2) functions for consecutive read/writes. fopen(), fgets(), fputs(), and fclose() are O(n) (or better) depending on how you use them.

[[Category:Scripting (AMX Mod X)]]

User:P34CH 34732

2007-04-12T08:32:49Z

P34CH 34732:

:''"Good morning! How much does that weigh?"
:''"Ham!"

:''"These beefs are tender. And the exuberance?"
:''"Insubstantial!"

User:P34CH 34732

2007-04-12T08:30:33Z

P34CH 34732: New page: :'"Good morning! How much does that weigh?"' :'"Ham!"' :'"These beefs are tender. And the exuberance?"' :'"Insubstantial!"'

:'"Good morning! How much does that weigh?"'
:'"Ham!"'

:'"These beefs are tender. And the exuberance?"'
:'"Insubstantial!"'

User:Greentryst/Uncyc/Turtle

2007-04-12T07:56:25Z

P34CH 34732: Updated to a more recent version

The '''turtle''' is an [[bisexual|amphibious]] [[animal]] with an armored [[tank|shell]], an M1 [[penis|helmet]], night-vision [[goggles]], an [[AK-47]] assault [[rifle]], a nasty disposition, and <strike>great sharp teeth</strike> a cute little [[tail]].

==Lots of Turtles==
There are [[billions and billions]] of species of turtles in the world, ranging in size from the genetically engineered 90 nanometer Metal-Oxide-Semiconducting Field Effect Turtle of [[Japan]], to the thunderous fire-breathing 10,000 meter [[Godzilla|Turtlezilla]], also of Japan. In fact, Japan is practically overrun with turtles of all sizes, because turtles play a vital role in the [[Shinto]] religion (which are sacrificed in great numbers to the Shinto [[god]] [[Godzilla|Turtlezilla]] in order to persuade him not to eat [[Tokyo]]).

==Natural Enemies==
Turtles, being some of nature's fiercest [[humans|predators]], have few natural enemies. Of this small, elite group of cyborg animals, however, is the pirate [[bear]] and of course [[cabbage]]. While most bears are docile creatures from the fish kingdom, pirate [[bears]] feed plentifully on the jewel encrusted turtles of the [[Mediterranean]]. These specific turtles provide the basic nutrients necessary to power a bear's [[boob|warp core]]. Human natural enemies are THE GUJU and this big green hotdog.

==Celebrities who swallowed a turtle in early childhood==

*[[Chuck Norris]] (See also: [[Teenage Mutant Ninja Turtles]])
*[[Oscar Wilde]]
*[[Keith Chegwin]]
*[[Michael Jackson]]
*[[Jack Bauer]]
*Ozzy
*Mr. Potato Head
*Santa Claus
*Bob Dole
*The Gujurati
*Fudge

==Lots of Even More Turtles==
*In [[1973]], [[Stephen Hawking]] theorized that turtles play a major role in cosmology. His proposed model, "Turtles All the Way Down", combined an [[infinity|infinite]] stack of turtles with the principles of [[general relativity]]. Unfortunately, this [[theory]] had to be scrapped because it turned out to be totally inconsistent with godless [[evolution|evolutionism]] and the laws of [[quantum cheddardynamics]].
*Turtle is also the title bestowed apon the champion of a "turtle match." All participants crawl into seperate sleeping bags, and proceed to pass gas. The person who can put up with the stench the longest is a Turtle
*Turtles are also the surname of the Austrian royal family, comprising to the inheriters to the Hapsburg Throne. The family was initially started by the gay dance troupe the "Teenage Mutant Ninja Turtles" and their incestuous latvian accountant Master Splinter. To celebrate the founding of the family, Splinter transformed into a rat (as is customary in Latvia)
*The [[Earth]] rests upon the back of a huge turtle, which in turn rests on the back of another huge turtle. Turtles-turtles-turtles, all the way!"
*Turtles are the Truth. Turtles are therefore the guiding principle of every star-fleet officer, according to [[Captain Picard.]]

==Cooking with Turtles==
Turtles are the primary ingredient of Turtle Soup.

===Turtle Soup===
*4 quarts boiling [[water]]
*3 medium-sized [[potato|potatoes]] (diced)
*1 cup minced [[onion]]
*2 tablespoons [[olive oil]]
*1 teaspoon [[salt]]
*1 clove [[garlic]] (carded)
*1 pinch [[MSG|monosodium glutamate]]
*1 bay leaf
*1 large live turtle

The important thing is not to use the turtle, because if you use any part of the turtle its fellow turtles will find out and they will come for you in the night. Via your sock drawer.
Anyway, don't use the turtle. Instead you may substitute any kind of meat, but prime tarantula steak is best. Simmer for approximately 2 hours until the potatoes are moderately soft and the steak looks like something a human would want to eat. Serves 4.

==How to recognise a turtle==
It's like a flat snail, but round.

Usually drives a Douche Trough.

Proudly boasts about its future success, which will never be achieved under any circumstances ever.

Can also be identified by asking the following question:

"Are you a turtle?"

If they respond with the following statement they are. If anything else is said, they are NOT a turtle

"You bet your sweet @$$ I am!"

==See Also==
*[[Awkward Turtle]]
*[[Nazi turtle]]
*[[Animal sacrifice]]
*[[Gravity]]
*[[Cooking]]
*[[Turtle Washers anonymous]]
*[[User:Tompkins|Tompkins]]
[[category:Reptiles]]
[[category:Food]]

Turtle

2007-04-12T07:51:46Z

P34CH 34732: Redirecting to User:Greentryst/Uncyc/Turtle

#REDIRECT [[User:Greentryst/Uncyc/Turtle]]

Turtle

2007-04-12T07:50:44Z

P34CH 34732: New page: #REDIRECT [http://uncyclopedia.org/wiki/Turtle]

#REDIRECT [http://uncyclopedia.org/wiki/Turtle]

Recursion

2007-04-12T07:39:50Z

P34CH 34732: New page: See <span class="plainlinks">[http://wiki.alliedmods.net/Recursion Recursion]</span>.

See <span class="plainlinks">[http://wiki.alliedmods.net/Recursion Recursion]</span>.