Archive

Archive for the ‘Desempenho’ Category

Benchmark de Desempenho Flex / ActionScript 3

Arrays e ArrayCollections

Utilizar [ ] ao invés de new na criação de Arrays


// versão lenta: 126ms
var a:Array = new Array();

// versao otimizada: 56ms (125% mais rápido)
var a:Array = [];

Maneira mais rápida para copiar um Array


var copy:Array = array.concat();

Evitar operações em de inserção e remoção em ArrayCollections quando for possível utilizar Array


// versão lenta: 28117ms
var a:ArrayCollection = new ArrayCollection();
for (var i:int = 0; i < 10; i++)
{
    a.addItem(1);
}
                
var l:int = a.length;
for (i = 0; i < l; i++)
{
    a.removeItemAt(l - 1 - i);
}

// versão otimizada: 374ms (7418% mais rápido)
var a:Array = [];
for (var i:int = 0; i < 10; i++)
{
    a.push(1);
}
                
var l:int = a.length;
for (i = 0; i < l; i++)
{
    a.pop();
}

Utilizar a propriedade //source// do ArrayCollection no lugar do método //toArray()// quando não for necessária uma cópia do conteúdo


// versão lenta: 234ms
var a:Array = arrayCollection.toArray();

// versão rápida: 116ms (102% mais rápido)
 var a:Array = arrayCollection.source;

Loops

Salvar o tamanho do array/collection antes de iterar


// Com Array

// versão lenta: 435ms
for (var i:int = 0; i < array.length; i++)
{
    var a:int = array[i];
    var b:int = a;
}

// versão mediana: 304ms (44% mais rápido)
var l:int = array.length;
for (var i:int = 0; i < l; i++)
{
    var a:int = array[i];
    var b:int = a;
}

// versão otimizada: 254ms (72% mais rápido)
for each (var a:int in array)
{
    var b:int = a;
}

// com ArrayCollection

// versão lenta: 10094ms
for each (var a:int in arrayCollection)
{
    var b:int = a;
}

// versão mediana: 9000ms (13% mais rápido)
for (var i:int = 0; i < arrayCollection.length; i++)
{
    var a:int = int(arrayCollection.getItemAt(i));
    var b:int = a;
}

// versão otimizada: 6530ms (56% mais rápido)
var l:int = arrayCollection.length;
for (var i:int = 0; i < l; i++)
{
    var a:int = int(arrayCollection.getItemAt(i));
    var b:int = a;
}

Não fazer calculos repetidos em loops


// versão lenta: 536ms
for (var i:int = 0; i < 50; i++)
{
    var a:Number = 100 * 180 / Math.PI;
}
                
// versão otimizada: 339ms (58% mais rápido)
var toRad:Number = 180 / Math.PI;
for (var i:int = 0; i < 50; i++)
{
    var a:Number = 100 * toRad;
}


Não fazer acesso a propriedados ou constantes em loops


// versão lenta: 654ms
for (var i:int = 0; i < 100; i++)
{
    var a:int = i + myInt;
}

// versão otimizada: 613ms (7% mais rápido)
var localInt:int = myInt;
for (var i:int = 0; i < 100; i++)
{
    var a:int = i + localInt;
}

Condicionais

Utilizar //if/else// no lugar de //try/catch//


// versão lenta: 1207ms
var s:String = null;
                
try
{
    s = nullBean.myName2;
}
catch (e:Error)
{
    s = "default";
}

// versão rápida: 35ms (3349% mais rápido)
var s:String = null;
                
if (nullBean != null)
{
    s = nullBean.myName2;
}
else
{
    s = "default";
}

Para comparação de inteiros utilizar switch/case no lugar de if/else


// versão lenta: 54ms
var s:int = 0;
                
if (s == 1)
{
}
else if (s == 2)
{
}
else if (s == 3)
{
}
else
{
    var i:int = 0;
}

// versão rápida: 49ms (10% mais rápido)
var s:int = 0;
switch (s)
{
    case 1:
    break;
                    
    case 2:
    break;
                    
    case 3:
    break;
                    
    default:
        var i:int = 0;
    break;
}

UI

Evitar Repeaters

Evitar chamadas ao setStyle()

Usar o mínimo de containers possível

Utilizar posicionamento e dimensionamento absoluto sempre que possível

Utilizar //visible=false// no lugar de //alpha = 0//

Outros

Não usar new para criar Object


// versão lenta: 63ms
var o:Object = new Object();

// versão otimizada: 55ms (15% mais rápido)
var o:Object = {};

Criar método de reflexao próprio


// versão lenta: 164ms
var c:Class = Class(getDefinitionByName(getQualifiedClassName(myBean)));

// versão otimizada: 45ms (264% mais rápido)
public class MyBean {
  public function getClass():Class {
    return MyBean;
  }
}
...
var c:Class = myBean.getClass();

Utilizar atributos públicos no lugar de get/set nos VOs


// versão lenta: 64ms
public class MyBean {
  private var _myName:String;

  public function get myName():String {
    return _myName;
  }

  public function set myName(value:String):void
  {
    _myName = value;
  }
}
...
myBean.myName = "Alison";
var a:String =  myBean.myName;

// versão otimizada: 32ms (100% mais rápido)
public class MyBean {
  public var myName:String;
}
...
myBean.myName = "Alison";
var a:String =  myBean.myName;

Utilizar objetos tipados ao invés de Object (ou classes dynamic) quando for necessário acessar métodos ou atributos, visto que o Object tem que procurar se a propriedade/método existe.


// versão lenta: 63ms
var o:Object = array;
var l:int = o.lenght;

//versão rápida: 61ms (4% mais rápido)
var o:Array = array;
var l:int = o.lenght;


Referências

http://www.insideria.com/2009/04/51-actionscript-30-and-flex-op.html

http://www.rozengain.com/blog/2007/05/01/some-actionscript-30-optimizations/

http://www.lostinactionscript.com/blog/index.php/2008/09/28/tips-on-how-to-write-efficient-as3/

http://www.danielhai.com/blog/?p=55

http://www.adobe.com/livedocs/flashlite/2/main/wwhelp/wwhimpl/common/html/wwhelp.htm?context=LiveDocs_Parts&file=00000089.html

Categorias:Desempenho, Flex Tags:,

Técnicas para melhorar desempenho com Flex.

Bueno!

Um dos grandes problemas do Flex é desempenho, portando resolvi passar algumas dicas para ajudar o desenvolvimento de aplicações com Flex.

Trabalhando com Arrays:

Arrays são muito utilizados no desenvolvimento porém normalmente não é tirato proveito de todo o poder deles, com isso segue a baixo algumas dicas para melhorar o desempenho com Arrays e laço de repetição FOR.

Procure não usar NEW para declarar Arrays.

   Evite:
        public var arrayTeste1:Array = new Array();
   Opte por: 
        public var arrayTeste1:Array = [];
        public var arrayTeste2:Array = ['valor a', 'valor b'];


Trabalhando com laço de repetição For:

O tipo de dado Number ocupa muito espaço na memória virtual, 
portanto utilizar o tipo primitivo int ou uint para melhor 
desempenho, uint é usado para números positívos, já int 
serve para positívo e negativo.


   Evite: 
        for(var cont:Number = 0; cont < 1000; cont++){}
   Opte por:
        for(var cont:int = 0; cont < 1000; cont++){}


Utilizando o length dentro do for a cada iteração é necessário 
acessar uma propriedade dentro do array para comparar este valor, 
parece que não mas esse acesso é custoso e não é preciso obter o 
valor a cada iteração, basta criar uma variavel int para receber 
este valor e acessar apenas uma vez o tamanho do array. 


   Evite:
       for(var cont:int = 0; cont < array.length; cont++){}
   Opte por:
       var tamanhoArray:int = array.length;
       for(var cont:int = 0; cont < tamanhoArray; cont++){}

Espero ter ajudado um pouco sobre desempenho com Arrays e For.

Até o próximo post.

Categorias:Desempenho, Flex Tags:,