Производительность участка кода зависит от разной компоновки одного и того же?

[switcher!]

Не раз уже сталкиваюсь со странными (для меня) явлениями в исполнении кода. Например, скорость исполнения участка кода зависит от последовательности его в этом самом коде (при этом параллельных операций, а-ля Loader'им картинку - не производится; общая нагрузка на процессор - так же стабильная).
Те же самые операторы +=, ++ ведут себя по разному для одних и тех же операций. При чем отклонения не пару миллисекунд, а сотни.

Примеры: здесь тестировался миф о том, что типизованный массив с фиксированной длиной исполняется быстрее:

var v:Vector.<int> = new Vector.<int>();	var v:Vector.<int> = new Vector.<int>();
v[0] = 0;					v[0] = 0;
v.fixed = true;						
 
var t:int;					var t:int;
t = getTimer();					t = getTimer();
 
for (v[0] = 0; v[0] < 100000000; v[0]+=1) ;	for (v[0] = 0; v[0] < 100000000; v[0]+=1) ;
trace (getTimer() - t); //1206			trace (getTimer() - t); //1208
 
v.fixed = false;				v.fixed = true;
t = getTimer();					t = getTimer();
 
for (v[0] = 0; v[0] < 100000000; v[0]+=1) ;	for (v[0] = 0; v[0] < 100000000; v[0]+=1) ;
trace (getTimer() - t); //1243			trace (getTimer() - t); //1247

Что это? Кто первый тот и папа? ))


Или это:

// пример №1
var n:Number = 1.13456;
var t:int;
 
t = getTimer();
 
for (var i:uint = 0; i<100000000; i+=1)
{
 n = Math.floor(n);
 n = 1.13456;
}
 
trace(getTimer()-t); //10289
t = getTimer();
 
for (var j:uint = 0; j<100000000; j+=1)
{
 n = n >> 0;
 n = 1.13456;
}
 
trace(getTimer()-t); //1860
 
===================================
 
// пример №2
var n:Number = 1.13456;
var t:int;
 
t = getTimer();
 
for (var i:uint = 0; i<100000000; i++)
{
 n = Math.floor(n);
 n = 1.13456;
}
 
trace(getTimer()-t); //10253
t = getTimer();
 
for (var j:uint = 0; j<100000000; j++)
{
 n = n >> 0;
 n = 1.13456;
}
 
trace(getTimer()-t); //1485
 
=====================================
 
// пример №3
"var n:Number = 1.13456;
var t:int;
 
t = getTimer();
 
for (var i:uint = 0; i<100000000; i++)
{
 n = Math.floor(n);
 n = 1.13456;
}
 
trace(getTimer()-t); //10192
t = getTimer();
 
for (var j:uint = 0; j<100000000; j+=1)
{
 n = n >> 0;
 n = 1.13456;
}
 
trace(getTimer()-t); //1328

Примеры тестировались не раз, погрешность -- незначительна. (на более слабых ПК погрешность увеличивается - но не суть, пропорция остается)
Как видите, от перекомпоновки операторов в счетчике цикла мы получаем разные значения для одних и тех же вычислений.
Это что ж получается -- "от перемены мест слагаемых сумма..." меняется ?

[etc]

Для начала не надо использовать Flash IDE (если и использовать, то только обернув тест в функцию) и режим дебага для подобных тестов.

[switcher!]

н-да, в пакетах(FD) и функциях(Flash IDE) - все ровно для разных случаев.
Только debug в Flash IDE стабильно показывает небольшое отставание исполнения первого кода над вторым (в обоих случаях, из первого примера).
Примерно, 1730/1690.

Единственное, что сильно напрягло, это непомерная разница исполнения кода в пакете и в функции в таймлане (для второго примера).
19922/10266(в пакете) против 10306/688(в функции таймлайна)

[wvxvw]

Math.floor() !== A >> 0

[switcher!]

что функция не есть побитовый сдвиг? =) Знаю... интересует, почему код в функции кода на таймлайне - исполняется гораздо быстрее, чем тот же код в пакете, в конструкторе класса, например