User:Lou Montana/Sandbox

ⓘ

This page is an intended replacement for Code Optimisation. It is obviously a WORK-IN-PROGRESS.

---

Code Optimisation

---

Introduction

This article will try to be a general guide about improving your code and its performance.

• The first part (Rules) will focus on having a clean, readable and maintainable code.
• The second part (Code optimisation) is about improving performance, sometimes trading it against code readability.
• The third part (Equivalent commands performance) mentions commands that in appearance have identical effects but may differ in terms of performance according to the use you may have of them.
• The fourth part (Conversion from earlier versions) is a hopefully helpful, short guide about useful new commands or syntaxes to replace the old ways.

Color code

• means you must change your ways today, or with us you will ride…
• means you may want to look at it if you are targeting pure performance
• means the gain is little to insignificant. Going through your code for this replacement is not worth it. You may only consider it for future code.

Rules

In the domain of development, any rule is a rule of thumb. If a rule states for example that it is better that a line of code doesn't go over 80 characters, it doesn't mean that any line must not go over 80 characters; sometimes, the situation needs it. If you have a good structure, do not change your code to enforce a single arbitrary rule. If you break many of them, you may have to change something. Again, this is according to your judgement.

With that being said, here are the three basic rules to get yourself in the clear:

1. Make it work
2. Make it readable
3. Optimise then

Make it work

Template:note Your first goal when coding is to make your code do what you want it does. A good way to reach this objective is to read and getting inspired by other people's code. If you understand it by reading it once, it is probably a good source of inspiration.

• When starting from scratch if you know what you want but miss the specific steps to get to your point, it is a good practice to write down in your native language what you want to do. E.g Get all the units near the city, and for each west soldier in them, add 30% damage.
• Use -showScriptErrors startup parameter and make sure your code doesn't throw errors. Not only will your code run slower but it may also not work at all. Be sure to read the error, isolate the issue and sort it out thanks to this Wiki.
• Read your Arma RPT (report) to read more details about the error that happened in your code.

Make it readable

Whether you are cleaning your code or a different person's, you must understand the code without twisting your brain:

• While SQF is (non-noticeably) impacted by variable name length, this should not take precedence on the fact that code must be readable by a human being. Variables like _u instead of _uniform should not be present.
• One-lining (putting everything in one statement) memory improvement is most of the time not worth the headache it gives when trying to read it. Don't overuse it.
• Indentation is important for the human mind, and space is too. Space is free, use it.
• Same goes for line return; it helps to see a code block wrapping multiple common instructions instead of having to guess where it starts and stops.
• Do you see the same code multiple times, only with different parameters? Now is the time to write a function!
• If you have a lot of if..else, you may want to look at a switch condition, or again break your code in smaller functions.
• Is your function code far too long? Break it in understandable-sized bites for your own sanity.
• Finally, camel-casing (namingLikeThis) your variables and commands will naturally make the code more readable, especially for long names.

ⓘ

_i is an accepted variable standard for a for..do iteration

See the following code:

_w=[]; {_w pushbackunique primaryweapon _x} foreach((allunits+alldeadmen) select{_x call bis_fnc_objectside==east});

The same example is far more readable with proper spacing, good variable names and intermediate results:

_weaponNames = [];
_allUnitsAliveAndDead = allUnits + allDeadMen;
_allEastAliveAndDead = _allUnitsAliveAndDead select { _x call BIS_fnc_objectSide == east };
{ _weaponNames pushBackUnique primaryWeapon _x } forEach _allEastAliveAndDead;

Constants

Using a hard coded constant more than once? Use preprocessor directives rather than storing it in memory or cluttering your code with numbers. Such as:

a = _x + 1.053;
b = _y + 1.053;

And

_buffer = 1.053;
a = _x + _buffer;
b = _y + _buffer;

Becomes

#define BUFFER 1.053 // note: no semicolon
_a = _x + BUFFER;
_b = _y + BUFFER;

This also allows quick modifying of code; with the obvious loss of dynamics, but in that case it isn't a constant anymore.

Optimise then

Once you know what is what, you can understand your code better.

• Use private variables instead of global variables (preceded with an underscore) as much as possible
• You were iterating multiple times on the same array?
  • You should be able to spot your issue now.
• Are you using execVM on the same file, many times?
  • Store your function in memory to avoid file reading every call with _myFunction = compile preprocessFileLineNumbers "myFile.sqf";
• Is your variable name far too long?
  • Find a smaller name, according to the variable scope:

e.g

{ _opforUnitUniform = uniform _x; systemChat _opforUnitUniform; } forEach _allOpforUnits;

becomes

{ _uniform = uniform _x; systemChat _uniform; } forEach _allopforUnits;

Code optimisation

⚠

Please note: tests and benchmarks were done with the latest Arma 3 version at the time (v1.82, Tanks DLC). Game engine performance may have changed since.
Benchmark result in milliseconds (ms) is an average for 10000 iterations.

Scheduled and unscheduled environment

There are two code environment types, scheduled and unscheduled.

• A scheduled script has an execution time limit of 3 ms before being suspended to the benefit of another script until his turn comes back. It is a bit slower than unscheduled but suspending (sleep, waitUntil) is allowed.
• An unscheduled script is not watched and will run without limitations. It is recommended for time-critical scripts, but suspending (sleep, waitUntil) is not allowed!

Lazy evaluation

private _myVar = [33, 66] select (false);									// 0.0013 ms
private _myVar = if (false) then { 33; } else { 66; };						// 0.0020 ms
private "_myVar"; if (false) then { _myVar = 33; } else { _myVar = 66; }; 	// 0.0025 ms

Successive condition check

In SQF the following code will check all and every condition, even if one fail:

if (condition1 && condition2 && condition3) then { /* thenCode */ };

This code will check condition1, and if it is not true condition2 and condition3 will execute anyway. To avoid this behaviour, you can either imbricate ifs or use lazy evaluation such as the following:

if (condition1 && { condition2 } && { condition3 }) then { /* thenCode */ };

This method will stop condition evaluation on the first false statement.

Using lazy evaluation is not always the best way as it could speed up the code as well as slow it down, depending on the current condition being evaluated:

["true  || {{false} || {false}}", nil, 100000] call BIS_fnc_codePerformance;	// 0.00080 ms
["true  ||  {false} || {false }", nil, 100000] call BIS_fnc_codePerformance;	// 0.00105 ms
["false ||   false  ||  false  ", nil, 100000] call BIS_fnc_codePerformance;	// 0.00123 ms
["true  ||   false  ||  false  ", nil, 100000] call BIS_fnc_codePerformance;	// 0.00128 ms
["false ||  {false} || {false} ", nil, 100000] call BIS_fnc_codePerformance;	// 0.00200 ms

Concatenating multiple small strings together

myString = myString + otherString works fine for small strings, however the bigger the string gets the slower the operation becomes:

myString = ""; for "_i" from 1 to 10000 do { myString = myString + "123" }; // 290 ms

The solution is to use a string array that you will concatenate later:

strings = [];
for "_i" from 1 to 10000 do {strings pushBack "123"};
strings = strings joinString ""; // 30 ms

Manipulating arrays

Adding elements

New commands append and pushBack hold the best score.

private _array = [0,1,2,3]; _array append [4,5,6];			// 0.0020 ms
private _array = [0,1,2,3]; _array = _array + [4,5,6];		// 0.0023 ms
private _array = [0,1,2,3]; { _array set[count _array, _x]; } forEach [4,5,6];	// 0.0080 ms

private _array = [0,1,2,3]; _array pushBack 4;				// 0.0016 ms
private _array = [0,1,2,3]; _array = _array + [4];			// 0.0021 ms
private _array = [0,1,2,3]; _array set [count _array, _x]; 	// 0.0022 ms

Removing elements

private _array = [0,1,2,3]; _array deleteAt 0;				// 0.0015 ms
private _array = [0,1,2,3]; _array set [0, objNull]; _array = _array - [objNull];		// 0.0038 ms

private _array = [0,1,2,3]; _array deleteRange [1, 2];		// 0.0018 ms
private _array = [0,1,2,3]; { _array set [_x, objNull] } forEach [1,2]; _array = _array - [objNull];		// 0.0078 ms

Multiplayer recommendations

• Do not saturate the network with information: publicVariable or public setVariable shouldn't be used at high frequency, else everyone's performance experience is at risk!
• The server is supposed to have a good CPU and a lot of memory, use it: store functions, run them from it, send only the result to the clients
• publicVariable and setVariable variable name length impacts network, be sure to send well-named, understandable variables
  (and not playerNameBecauseThePlayerIsImportantAndWeNeedToKnowWhoTheyAreAllTheTimeEspeciallyInsideThisImpressiveFunction)
• Use, use and use remoteExec & remoteExecCall. Ditch BIS_fnc_MP for good!

Equivalent commands performance

if

if..then { /* thenCode */ };							// 0.0011 ms
if..exitWith { /* exitCode */ };						// 0.0014 ms
if..then { /* thenCode */ } else { /* elseCode */ };	// 0.0015 ms
if..then [{ /* thenCode */ },{ /* elseCode */ }]		// 0.0016 ms

if and select

Use [array] select Boolean instead of the lazy-evaluated if.

_result = ["false result", "true result"] select true;					// 0.0011 ms
_result = if (true) then { "true result"; } else { "false result"; };	// 0.0017 ms

if and switch

_result = call {
	if (false) exitWith {};
	if (false) exitWith {};
	if (true)  exitWith {};
	if (false) exitWith {};
	if (false) exitWith {};
};							// 0.0032 ms

_result = switch (true) do {
	case (false): {};
	case (false): {};
	case (true): {};
	case (false): {};
	case (false): {};
};							// 0.0047 ms

for

The for..from..to..do is twice as fast as its alternative syntax, for..do.

for "_i" from 0 to 10 do { /* forCode */ };						// 0.015 ms
for [{_i = 0}, {_i < 100}, {_i = _i + 1}] do { /* forCode */ };	// 0.030 ms

forEach vs count vs findIf

Both commands will step through supplied array of elements one by one and both commands will contain reference to current element in the _x variable. However, count loop is a little faster than forEach loop, but it does not have _forEachIndex variable.
Also, there is a limitation as the code inside count expects Boolean or Nothing while itself returns Number.

{ diag_log _x } count [1,2,3,4,5];		// 0.082 ms
{ diag_log _x } forEach [1,2,3,4,5];	// 0.083 ms

_someoneIsNear = (allUnits findIf { _x  distance [0,0,0] < 1000 }) != -1;	// 0.0046 ms
_someoneIsNear = { _x distance [0,0,0] < 1000 } count allUnits > 0;			// 0.0047 ms
_someoneIsNear = {
	if (_x distance [0,0,0] < 1000) exitWith { true };
	false
} forEach allUnits;															// 0.0060 ms

findIf (since Arma 3 v1.82) stops array iteration as soon as the condition is met.

[0,1,2,3,4,5,6,7,8,9] findIf { _x == 2 };				// 0.0050 ms
_quantity = { _x == 2 } count [0,1,2,3,4,5,6,7,8,9];	// 0.0114 ms

+ and format

When concatenating more than two strings, format is faster than +.

format ["%1%2%3%4%5", "string1", "string2", "string3", "string4", "string5"];	// 0.0019 ms
"string1" + "string2" + "string3" + "string4" + "string5";						// 0.0021 ms

format and str

str 33;				// 0.0016 ms
format ["%1", 33];	// 0.0022 ms

private

Direct declaration (private _var = value since Arma 3 v1.53) is faster than declaring then assigning the variable.

private _a = 1;
private _b = 2;
private _c = 3;
private _d = 4;
// 0.0023 ms

private ["_a", "_b", "_c", "_d"];
_a = 1;
_b = 2;
_c = 3;
_d = 4;
// 0.0040 ms

However, if you have to reuse the same variable in a loop, external declaration is faster.
The reason behind this is that a declaration in the loop will create, assign and delete the variable in each loop.
An external declaration creates the variable only once and the loop only assigns the value.

private ["_a", "_b", "_c", "_d"];
for "_i" from 1 to 10 do
{
	_a = 1; _b = 2; _c = 3; _d = 4;
};
// 0.0195 ms

for "_i" from 1 to 10 do
{
	private _a = 1; private _b = 2; private _c = 3; private _d = 4;
};
// 0.0235 ms

isNil

isNil "varName"; // 0.0007 ms
isNil {varName}; // 0.0012 ms

isEqualType and typeName

isEqualType is much faster than typeName

"string" isEqualType 33;			// 0.0006 ms
typeName "string" == typeName 33;	// 0.0018 ms

objectParent and vehicle

isNull objectParent player;	// 0.0013 ms
vehicle player == player;	// 0.0022 ms

nearEntities and nearestObjects

• nearEntities is much faster than nearestObjects given on range and amount of objects within the given range.

If range is over 100 meters it is highly recommended to use nearEntities over nearestObjects.

Note: nearEntities only searches for alive objects. Killed units, destroyed vehicles, static objects and buildings will be ignored by the nearEntities command.

Config path delimiter

>> is slightly faster than / when used in config path with configFile or missionConfigFile.

configFile >> "CfgVehicles";	// 0.0019 ms
configFile / "CfgVehicles";		// 0.0023 ms

getPos* and setPos*

getPosWorld			// 0.0015 ms
getPosASL			// 0.0016 ms
getPosATL			// 0.0016 ms
getPos				// 0.0020 ms
position			// 0.0020 ms
getPosVisual		// 0.0021 ms
visiblePosition		// 0.0021 ms
getPosASLW			// 0.0023 ms

setPosWorld			// 0.0060 ms
setPosASL			// 0.0060 ms
setPosATL			// 0.0060 ms
setPos				// 0.0063 ms
setPosASLW			// 0.0068 ms
setVehiclePosition	// 0.0077 ms with "CAN_COLLIDE"
					// 0.0390 ms with "NONE"

Conversion from earlier versions

Each iteration of Bohemia games (Operation Flashpoint, Arma, Arma 2, Take On Helicopters, Arma 3) brought their own new commands, especially Arma 2 and Arma 3.
For that, if you are converting scripts from older versions of the engine, the following aspects should be reviewed.

Loops

• forEach loops, depending on the situation, can be replaced by:
  • apply
  • count
  • findIf
  • select

Array operations

• Adding an item: myArray + [element] and myArray set [count myArray, element] have been replaced by pushBack
• Selecting a random item: BIS_fnc_selectRandom has been replaced by selectRandom
• Removing items: myArray set [1, objNull]; myArray - [objNull] has been replaced by deleteAt and deleteRange
• Concatenating: myArray = myArray + [element] has been reinforced with append: if you don't need the original array to be modified, use +
• Comparing: use isEqualTo instead of BIS_fnc_areEqual or a custom comparison function
  • count myArray == 0 is pretty fast, but direct comparison with isEqualTo is still a little faster: myArray isEqualTo []
• Finding common items: in forEach loop has been replaced by arrayIntersect
• Condition filtering: forEach can be replaced by select (alternative syntax)

result = [];
{
	if (_x % 2 == 0) then
	{
		result pushBack _x;
	};
} forEach arrayOfNumbers; // 2.57 ms
result = (arrayOfNumbers select { _x % 2 == 0 }); // 1.55 ms

String operations

String manipulation has been simplified with the following commands:

• string select index
• toArray and toString have been reinforced with splitString and joinString

Type comparison

• typeName has been more than reinforced with isEqualType

Multiplayer

• BIS_fnc_MP has been replaced by remoteExec and remoteExecCall and internally uses them. Use the engine commands from now on!