AS3: Optimisation de la taille de la mémoire de l'objet

Question

J'ai une classe que j'ai écrite, et elle semble plus grande qu'elle ne devrait l'être. Cela ne fait rien, et il y a très peu de choses - ou du moins je le pensais - mais chacune d'elles prend un peu moins de 100k 100 octets (merci back2dos). Je suppose que je n'ai pas une très bonne compréhension de ce qui affecte vraiment la quantité de mémoire qu'un objet prend dans AS3.

Si quelqu'un peut me montrer quelques lectures sur le sujet qui pourrait être utile, ou peut-être expliquer un aperçu de la façon de penser à ce sujet, ce serait génial. Je voudrais garder beaucoup de ces objets en mémoire - et je pensais pouvoir le faire jusqu'à présent, mais à cette taille, je vais devoir les créer ou utiliser une technique de pool d'objets quelconque.

Merci pour l'aide.

Edit:Bien que j'ai ce dans l'ordre, je garde le code que j'ai posté ici pour être complet. La classe a été fortement modifiée par rapport à la version originale. Les valeurs qui faisaient référence à d'autres fichiers ont été rendues statiques pour permettre au code de fonctionner pour quelqu'un d'autre (en théorie hehehe ...). Bien que ma situation soit réglée, je donnerai la réponse à une bonne référence pour l'information sur les classes et la mémoire.

Dans ce cas, la classe a 15 variables. J'utilise seulement une seule chaîne et un tas d'ints, de nombres, et de booléens avec quelques références à plus de la même chose dans les données XML globalement disponibles. Il importe également Point pour le constructeur, bien qu'aucun point ne soit stocké. Dans les tests, même sans les références XML globales ou la classe Point, il reste environ ~ 84k chacun. Il y a des getters pour 7 des variables et quelques méthodes en plus du constructeur. Tout ce qui est inférieur à 20 lignes (et j'ai un style de codage très clairsemé).

La classe mentionné pour référence, mais ne hésitez pas à généraliser:

package 
{ 
    public class AObject 
    { 
     private var _counter:int; 
     private var _frames:int; 
     private var _speed:int; 

     private var _currentState:String; 
     private var _currentFrame:int; 

     private var _offset:int; 
     private var _endFrame:int; 

     private var _type:int; 
     private var _object:int; 
     private var _state:int; 

     private var _x:Number; 
     private var _y:Number; 

     private var _w:int; 
     private var _h:int; 

     private var _update:Boolean; 

     public function AObject(targetX : int, targetY : int, state : int, object : int, type : int) 
     {  

      _x = targetX; 
      _y = targetY; 

      _type = type; 
      _object = object; 
      _state = state; 
      _counter = 0; 
      _w = 32; 
      _h = 32 
      _update = true; 
      setState(state); 
     } 

     public function setState(state:int) : void 
     { 
      _currentState = "bob"; 
      var frameCounter : int = 0; 
      var stateCounter : int = state - 1; 
      while (state > 0) 
      { 
       frameCounter += 4; 
       --stateCounter; 
      } 
      _offset = frameCounter; 
      _currentFrame = _offset; 
      _speed = 10; 
      _frames = 4; 
      _endFrame = _offset + _frames - 1; 
     } 

     public function get state() : int 
     { 
      return _state; 
     } 

     public function animate() : Boolean 
     { 
      if (count()) 
      { 
       if(_currentFrame < _endFrame) 
       { 
        ++_currentFrame; 
       } 
       else 
       { 
        _currentFrame = _offset;  
       } 
       _speed = 10; 
       return true; 
      } 
      else 
      { 
       return false; 
      } 
     } 

     private var adder: Number = 0; 

     private function count():Boolean 
     { 
      _counter++; 
      if (_counter == _speed) 
      { 
       _counter = 0; 
       return true; 
      } 
      else 
      { 
       return false; 
      } 
     } 

     public function get x():int 
     { 
      return _x; 
     } 

     public function get y():int 
     { 
      return _y; 
     } 

     public function get type():int 
     { 
      return _type; 
     } 

     public function get object():int 
     { 
      return _object; 
     } 

     public function get currentFrame():int 
     { 
      return _currentFrame; 
     } 

     public function get w():int 
     { 
      return _w; 
     } 

     public function get h():int 
     { 
      return _h; 
     } 
    } 
} 

Answer 1

je suis étonné, ce tout ... compile quand je tente de le compiler avec le SDK Flex, il crée une collision énorme avec l'objet de classe intégrée, qui est la classe de base de toute classe, ce qui rend ma trace trop-plein de sortie ...

autre que cela, cela est une boucle infinie si vous passez une valeur pour l'état plus grand que 0

while (state > 0) 
{ 
     frameCounter += 4; 
     --stateCounter; 
} 

mais il semble vraiment étrange ces objets sont si grands ... après avoir renommé et en prenant soin de ne pas passer 0 pour l'état, j'ai couru un test:

package { 
    import flash.display.Sprite; 
    import flash.sampler.getSize; 
    import flash.system.System; 
    public class Main extends Sprite { 
     public function Main():void { 
      const count:int = 100000; 
      var start:uint = System.totalMemory; 
      var a:Array = []; 
      for (var i:int = 0; i < count; i++) { 
       a.push(new MyObject(1, 2, 0, 4, 5)); 
      } 
      var mem:uint = System.totalMemory - start - getSize(a); 
      trace("total of "+mem+" B for "+count+" objects, aprox. avg. size per object: "+(mem/count)); 
     }  
    } 
} 

il donne:

total of 10982744 B for 100000 objects, aprox. avg. size per object: 109.82744 

donc c'est tout à fait ok ... je pense que la taille réelle devrait être 4 (pour le bool) + 4 * 11 (pour les ints) + 4 (pour la référence à la chaîne) + 8 * 3 (pour les trois flotteurs (vous avez le adder quelque part sur le count) + 8 pour une classe vide (référence aux objets traits + autre chose), vous donnant un total de 88 octets ... ce qui est, w vous obtenez, si vous getSize l'objet ...s'il vous plaît noter cependant, que getSize vous donnera seulement la taille de l'objet lui-même (calculé ici) en ignorant la taille de quelles chaînes ou d'autres objets votre objet référence ...

alors oui, en dehors de ce nom, vous devez absolument le changement, le problème doit être un autre endroit ...

greetz

back2dos

Answer 2

Si vous voulez vraiment économiser de l'espace, vous pouvez short faux en utilisant des entiers non signés, et en utilisant bits supérieurs/inférieurs pour une chose ou une autre.

Les octets sont de 4 octets par nature, vous pouvez réutiliser cet int sur moins de 2^8.

width height 
0xFFFF + 0xFFFF 

offset endframe 
0xFFFF + 0xFFFF 

Ce bien se laid quand vous voulez écrire quoi que ce soit ou quoi que ce soit lire, à écrire largeur ou la hauteur que vous auriez à:

writing: 
size = (width & 0x0000FFFF) << 16 | (height & 0x0000FFFF); 

reading: 
get width():uint { return (size & 0xFFFF0000) >> 16 }; 

C'est laid. Puisque vous utilisez des getters de toute façon, et en supposant que la vitesse de calcul n'est pas un problème, vous pouvez utiliser des tableaux d'octets internes qui pourraient vous donner encore plus de détails sur la façon dont vous voulez stocker vos informations. En supposant que vos chaînes ont plus de 4 octets, il est plus logique d'utiliser un nombre plutôt qu'une chaîne.

Aussi, je crois que vous allez réellement obtenir une augmentation de la mémoire en déclarant la classe comme définitive, je crois que les fonctions finales se placer dans l'objet traits, plutôt que