Algorithme, mémoire et performance

[Thyrion]

Bonsoir à tous !

Ayant fini mes études en informatique, je me suis lancé dans un projet de jeu-vidéo en 2D en Java avec mon cousin.
Pas trop d'informations pour l'instant, classé confidentiel.

Bref, grâce à l'IUT j'ai appris beaucoup de choses, et notamment en algorithme, un truc que j'adore. Cependant, même si j'arrive plutôt bien à coder de façon optimiser, j'ai quelques questions en tête.

--------------------------------------------------------------------------------------------------------------------------------
Les boucles
Déjà là je suis sur un traitement de tableaux, et j'utilise des boucles for.
Et je me suis rendu compte que finalement, lorsque j'ai un résultat je pourrais arrêter l'une de ses boucles en plein milieu.
Pourquoi est-ce mal d'utiliser l'instruction break dans une boucle for ?
Je pensais qu'il y avait une raison au niveau de la mémoire, mais en regardant vite-fait sur Internet, apparemment il s'agit simplement d'une question de lisibilité de code.
Or dans mon cas, je trouve ça beaucoup plus lisible d'utiliser un simple break plutôt que d'avoir des conditions à rallonge dans les instructions de boucles.
--------------------------------------------------------------------------------------------------------------------------------
Le parcours d'un tableau

Code: Tout sélectionner

for (int i=0 ; i<tableau.length) ; i++) {}

Code: Tout sélectionner

int taille = tableau.length ;
for (int i=0 ; i<taille) ; i++) {}

Code: Tout sélectionner

short taille = (short) tableau.length ;
for (short i=0 ; i<taille) ; i++) {}

Lequel est le plus performant entre ces trois là ? Est-il vrai que pour le premier cas, à chaque itération il va calculer la taille du tableau ? Et pour un tableau de petite taille fixe, est-il préférable d'utiliser un short plutôt qu'un int ?
Cela paraît un peu trop infime, mais j'ai besoin de faire beaucoup de calculs par seconde, et même les nanosecondes comptent ! Non je plaisante, mais j'aime être le plus performant possible.
--------------------------------------------------------------------------------------------------------------------------------
Les variables et variables de classes

Code: Tout sélectionner

class A { int poids = 8 ; int getPoids(){ return this.poids } }
class B { ...{ for (int i=0 i<a.getPoids() ; i++) {} } }

Code: Tout sélectionner

class A { int poids = 8 ; int getPoids(){ return this.poids } }
class B { ...{ int p = a.getPoids() ; for (int i=0 i<p ; i++) {} } }

Y a-t-il une différence de temps d'accès à la valeur 8 ? Bon dans cet exemple c'est inutile, mais si dans une quadruple boucle, toute de taille en milliers, on calcul via la même valeur d'une variable de classe - mieux vaut la stocker dans un variable hors des boucles ou le temps d'accès à la méthode get() est de toute façon quasiment nulle ? (Si cela dépasse 0,2ms, j'utiliserais la seconde méthode en exemple. )
--------------------------------------------------------------------------------------------------------------------------------

Voilà voilà, pour l'instant c'est tout ce qui me trotte dans la tête. Bon là c'est du Java, mais bien sûr je pose la question pour tous les langages.
Merci d'avance pour vos réponses !

[H3bus]

Salut,

Alors, dans l'ordre :

Pourquoi est-ce mal d'utiliser l'instruction break dans une boucle for ?

La réponse est simple : l’énorme avantage d'une boucle for, c'est que tu sais exactement combien de passages tu fais, ce qui n'est pas le cas avec while ou do while. Pour évaluer la complexité de ton algo (le fameux O(N)), il faut que tu saches combien de passages tu fais dans tes boucles, dans le pire des cas...

Lequel est le plus performant entre ces trois là ?

Hum... je ne suis pas sur là. Si ce qui t'intéresse, c'est la puissance de calcul, et non l'allocation mémoire (le fait d'allouer des variables plus grandes n'affecte pas la puissance, seulement la place qu'occupe ton programme en mémoire), il faut réfléchir en terme de nombre d'opérations. En gros, réserver un short ou un int, c'est kif kif au niveau du processeur, ça bouffe juste un poil plus de mémoire. Si ça t'évite de faire des conversions, c'est bon à prendre.

Y a-t-il une différence de temps d'accès à la valeur 8 ?

le premier algo est plus performant, tu fais une allocation mémoire en moins.

Après, il y a un autre truc en Java, c'est de savoir quelle structure de donnée utiliser. Par exemple, les tableaux c'est bien, mais il faut connaître la taille, et ne pas avoir à faire d'insertions. Les insertions dans les tableaux sont lentes, alors que les lectures sont rapides (car tu connais l'id). A l'inverse, les listes sont intéressantes si tu veux faire de l'empilage et du dépilage, mais pour la lecture d'un item particulier, c'est lent...

Un peu de lecture : http://moukouop.developpez.com/tutoriel ... es/#LIII-A

Bon courage !

[Thyrion]

Ah nickel, merci pour toutes ces réponses ! Et pour le lien, on a étudier ça à l'IUT, mais là je ne gère pas une base de données, seulement des tableaux. Par contre, ça sera utile pour le futur du projet.

Tant mieux si je peux utiliser les méthodes get() directement même dans une boucle plutôt que de créer des variables à gogo.

En fait, je suis dans le traitement de pixels là, donc je connais exactement les limites des valeurs (0-255), donc un short. Je pourrais utiliser un byte pour sa taille, mais le problème est la reconversion puisqu'un byte est de -128 à 127.
Et pour le premier parcours du tableau, il calcule à chaque fois le length du coup ?

Et du coup, les boucles for sont surement plus adaptées à ce que je fais puisque je connais exactement la taille des tableaux à parcourir. Mais tu ne réponds pas à cette question : Est-ce sale ? Sale de faire un break dans un for ?

[H3bus]

Est-ce sale ? Sale de faire un break dans un for ?

Moi je l'ai déjà fait, et personne n'en est mort...

[Thyrion]

Bon tant mieux, parce que c'est carrément plus pratique là. Et en plus, les while c'est dangereux à cause des boucles infinies.

Merci !

[Thyrion]

Rebonsoir tout le monde !

Voilà voilà je suis un peu perplexe sur le Java Graphique, notamment les images. Je vous explique :

AWT permet de faire des Panels, Borders, etc. Un peu la base de l'interface graphique.
Swing est mieux que AWT, je sais plus trop en quoi, mais cette partie là je ne m'en occupe pas trop.

Or, dans notre projet, je pensais avoir fini (ou presque) la gestion des images, get/set ainsi que du traitement par pixel.
De base, je charge le fichier image en mémoire dans un BufferedImage, pour ensuite avoir une ImageIcon.
Déjà un point : Pour les méthodes paint() (...), il me faut une Image (classe abstraite), et donc je dois faire imageIcon.getImage. Pourquoi ? Pourquoi on peut pas utiliser ImageIcon directement ? Est-ce lourd de faire cette "conversion" ?
Mais le problème plus important reste le traitement :
Lorsque je charge le fichier image, je crée donc une ImageIcon, mais aussi à côté un mappage de pixels, tableau à trois dimensions [ X ][ Y ][ COULEUR ].
J'arrive donc à créer une ImageIcon à partir de ce mappage, via un BufferedImage. Mais malheureusement, l'inverse est impossible : Impossible de récupérer chaque couleur de chaque pixel d'une ImageIcon, or ça m'est utile lorsque j'ai besoin de recréer le mappage à partir d'une ImageIcon et ainsi faire du traitement.

J'ai une solution, mais je ne sais pas si c'est propre : Tout le temps utiliser un BufferedImage, même s'il n'y a pas de lecture/écriture dans le disque. C'est le seul moyen de récupérer les pixels d'une image.

Donc en gros : Que me conseillez-vous ?
Je poste ce problème dans ce topic, car c'est avant tout un soucis de performance/gestion des images en Java.
Merci d'avance pour vos réponses !