[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

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