Problème de sauvegarde : ralentissement de l'atelier

Bonjour,
j'ai un problème avec mon système de sauvegarde.
En effet, mon quadrillage correspond au casier "carte" et j'enregistre donc le contenu du casier dans un fichier .txt, à l'aide du greffon conduit.
Or, à la lecture de la sauvegarde, celle-ci est relativement longue à s'exécuter et surtout, elle ralentit énormément l'atelier.
Si bien, qu'à chaque fois que je lis ma sauvegarde, je suis ensuite obligé de redémarrer l'atelier.

Voici mes fonctions enregistrer et ouvrir :
[php]
Enregistrer_sous :
c :: conduit
indice1 est un nombre
indice2 est un nombre
temp est un nombre
chemin_sauvegarde est un texte
ligne <
- c.retourchariot()
début
("on vérifie si un quadrillage a été créé")
Si nombre_case == 0 alors lis
numéro_avertissement = 3
Tu vas vers Fenêtre_avertissement
Reviens
ferme

("Si l'utilisateur à cliqué sur le menu "Enregistrer_sous", on ouvre le sélectionneur de fichiers")
Si menu_enregistrer == faux alors lis
évoque c.sélectionneretenregistrer()
évoque c.fermer()
chemin_sauvegarde vaut c.nomfichiercomplet()
ferme

("Si le chemin d'accès est valide, on enregistre directement par dessus la sauvegarde précédente")
Si (c.fichierexiste(chemin_sauvegarde)) et (non(c.répertoire(chemin_sauvegarde))) alors lis
évoque c.enregistrer(chemin_sauvegarde)
ferme
("Si l'utilisateur à cliqué sur le menu "Enregistrer" et que le chemin d'accès est invalide, on ouvre le sélectionneur de fichiers")
Sinon, lis
évoque c.sélectionneretenregistrer()
ferme

chemin_sauvegarde vaut c.nomfichiercomplet()

("on sauvegarde le mini quadrillage")
évoque c.écrire(""+ nombre_case_quadrillage_tileset)
évoque c.écrire(ligne)
évoque c.écrire(""+ largeur_case_quadrillage_tileset)
évoque c.écrire(ligne)
évoque c.écrire(""+ hauteur_case_quadrillage_tileset)
évoque c.écrire(ligne)

("on sauvegarde les tiles contenus dans le mini quadrillage")
Mesure casier_tiles dans indice1
évoque c.écrire(""+ indice1)
évoque c.écrire(ligne)
Si indice1 != 0 alors lis
pour chaque indice1, lis
évoque c.écrire(""+ image de (casier_tiles{joker}))
évoque c.écrire(ligne)
évoque c.écrire(""+ dx de (casier_tiles{joker}))
évoque c.écrire(ligne)
évoque c.écrire(""+ dy de (casier_tiles{joker}))
évoque c.écrire(ligne)
évoque c.écrire(""+ x de (casier_tiles{joker}))
évoque c.écrire(ligne)
évoque c.écrire(""+ y de (casier_tiles{joker}))
évoque c.écrire(ligne)
ferme
ferme

("on sauvegarde le quadrillage")
évoque c.écrire(""+ taille_largeur_case)
évoque c.écrire(ligne)
évoque c.écrire(""+ taille_hauteur_case)
évoque c.écrire(ligne)
évoque c.écrire(""+ nombre_case_largeur)
évoque c.écrire(ligne)
évoque c.écrire(""+ nombre_case_hauteur)
évoque c.écrire(ligne)

("on écrit la sauvegarde de la carte")
Pour chaque nombre_case_hauteur, lis
Pour chaque nombre_case_largeur, lis
Si (carte{indice2}) != -5 alors lis
temp = numéro_tile de (copie_casier_tiles{(carte{indice2})})
Si temp <
= 9 alors lis
évoque c.écrire("00"+ temp)
ferme
Sinon si temp <
= 99 alors lis
évoque c.écrire("0"+ temp)
ferme
Sinon si temp <
= 999 alors lis
évoque c.écrire(temp)
ferme
ferme
Sinon évoque c.écrire("000")
incrémente indice2
ferme
évoque c.écrire(ligne)
ferme

évoque c.fermer()
menu_enregistrer = faux
Si numéro_avertissement == 5 alors tu vas vers Réinitialisation
Sinon, reviens

Ouvrir :
c :: conduit
mémo1 & mémo2 & mémo3 & mémo4 & mémo5 & mémo6 & mémo7 & mémo8 & mémo9 & mémo10 & mémo11 & mémo12 & mémo13 & mémo14 :: texte
num1 & num2 & num3 & num4 & num6 & num7 & num8 & num9 & num10 & num11 & num12 & num13 & num14 :: nombre
indice1 est un nombre
indice2 est un nombre
i est un nombre
j est un nombre
début
Si nombre_case != 0 alors lis
numéro_avertissement = 5
Tu vas vers Fenêtre_avertissement
ferme

évoque c.sélectionneretouvrir()
mémo1 vaut c.lireligne()
mémo2 vaut c.lireligne()
mémo3 vaut c.lireligne()
mémo4 vaut c.lireligne()

Tu convertis mémo1 en num1
Tu convertis mémo2 en num2
Tu convertis mémo3 en num3
Tu convertis mémo4 en num4

sauvegarde_on = vrai

("on redessine le mini quadrillage")
nombre_case_quadrillage_tileset = num1
largeur_case_quadrillage_tileset = num2
hauteur_case_quadrillage_tileset = num3

Parcours Découpage_tileset
Observe Découpage_tileset

("on remet les tiles dans le mini quadrillage")
indice1 = num4
Si indice1 != 0 alors lis
Pour chaque indice1, lis
mémo5 vaut c.lireligne()
mémo6 vaut c.lireligne()
mémo7 vaut c.lireligne()
mémo8 vaut c.lireligne()
mémo9 vaut c.lireligne()

Tu convertis mémo6 en num6
Tu convertis mémo7 en num7
Tu convertis mémo8 en num8
Tu convertis mémo9 en num9

chemin_tile = mémo5
dx_tile_sauv = num6
dy_tile_sauv = num7
x_tile_sauv = num8
y_tile_sauv = num9

Parcours Affichage_tiles avec i
Observe Affichage_tiles
incrémente i
ferme
ferme

("on récupère la taille du quadrillage")
mémo10 vaut c.lireligne()
mémo11 vaut c.lireligne()
mémo12 vaut c.lireligne()
mémo13 vaut c.lireligne()

Tu convertis mémo10 en num10
Tu convertis mémo11 en num11
Tu convertis mémo12 en num12
Tu convertis mémo13 en num13

taille_largeur_case = num10
taille_hauteur_case = num11
nombre_case_largeur = num12
nombre_case_hauteur = num13

("on calcule le nombre de cases à afficher en fonction des dimensions de la fenêtre de scrolling")
nombre_case_largeur_effectif = entier (largeur de cadre / taille_largeur_case)
nombre_case_hauteur_effectif = entier (hauteur de cadre / taille_hauteur_case)
Si nombre_case_largeur_effectif >
nombre_case_largeur alors nombre_case_largeur_effectif = nombre_case_largeur
Si nombre_case_hauteur_effectif >
nombre_case_hauteur alors nombre_case_hauteur_effectif = nombre_case_hauteur
nombre_case = nombre_case_hauteur_effectif*nombre_case_largeur_effectif
nombre_case_total = nombre_case_hauteur*nombre_case_largeur

("on recréer la sauvegarde de la carte")
pour chaque nombre_case_total, lis
ajoute -5 dans carte
ferme

("on restaure le casier copie_casier_tiles")
Pour chaque nombre_case_hauteur, lis
Pour chaque nombre_case_largeur, lis
mémo14 vaut c.nlire(3)
Tu convertis mémo14 en num14
Si num14 != 0 alors lis
Parcours Sauvegarde_drag avec num14, j
Observe Sauvegarde_drag
ferme
incrémente j
ferme
("on avance le curseur de 2 caractères pour éviter de lire le retour à la ligne")
mémo14 vaut c.nlire(2)
ferme

évoque c.fermer()

("on fait réagir chaque tile du mini-quadrillage au drag&drop")
pour chaque nombre_case_quadrillage_tileset, lis
Fais réagir casier_tiles{joker} à "clic souris" pour Drag
ferme

("on redessine la carte")
Va vers Affichage_quadrillage
[/php]

Je crois que la conversion d'un texte en nombre est assez lente mais ce n'est sans doute pas le seul problème.
Help ?

je vais regarder ça.
Ton exemple fonctionne tout seul ? je peux le tester directement ?

Je note que tu utilises le verbe observer.
Celui-ci s'utilise conjointement avec le verbe Appeler.
Tu peux supprimer son utilisation dans l'exemple que tu as donné.

Peux-tu me dire combien d'éléments as-tu dans le fichier que tu veux charger ?
peux-tu le mettre dans le forum ?

J'ai fait quelques tests et c'est vrai que l'utilisation du conduit avec beaucoup de données peut-être long.
Par contre, si j'arrête l'Atelier, celui-ci revient dans un état stable. Je ne suis pas obligé de le redémarrer.

Je vais voir comment optimiser le conduit.

admincpc a écrit:

Je note que tu utilises le verbe observer.
Celui-ci s'utilise conjointement avec le verbe Appeler.
Tu peux supprimer son utilisation dans l'exemple que tu as donné.

Très bien merci.

admincpc a écrit:

Peux-tu me dire combien d'éléments as-tu dans le fichier que tu veux charger ?
peux-tu le mettre dans le forum ?

Il y a 48 tiles dans le mini quadrillage, donc indice1 = 48.
Et j'essaye de charger un quadrillage de 100x100 : le casier "carte" contient donc 10000 données.

Rectification :
Ce n'est pas l'atelier qui est ralenti mais l'exécution du livre.
Si je tente de lire mon livre 2 fois de suite, il va mettre 3 fois plus de temps à s'ouvrir et mon programme va être énormément ralenti.

Bien vu, je confirme que c'est bien le verbe convertir qui est très lent !
ça va être dur de l'optimiser...

Il faudrait quel le greffon conduit puisse gérer les nombres directement.
Ce n'est pas possible ?

enfin de compte, j'ai ajouté une nouvelle fonction au greffon conduit :

[php]
chargementCasierNombres :
* casier :: casier de nombres
* chemin :: texte
* max ::nombre
c :: conduit
début
évoque c.ouvrir(chemin)
casier vaut c.chargecasiernombres(max)
évoque c.fermer()
[/php]

La fonction chargecasiernombres permet de charger n valeurs dans un casier.

Mon test passe de 38 secondes à 1 seconde !

J'ai hâte de tester ça !
Le greffon conduit ne se trouve pas dans le manageur de greffons ^^

Je suppose que le greffon conduit sera mis à jour avec la prochaine version du langage ?

Je n'arrive pas à comprendre comment utiliser la fonction chargecasiernombres dans mon exemple de code ?

Par exemple, tu as 1000 nombres à charger depuis un fichier .
Au lieu de charger un à un des nombres depuis le fichier en utilisant une boucle,
tu utilises cette fonction en lui indiquant que tu veux charger 1000 nombres :
[php]
exemple :
casier :: casier de nombres
chemin :: texte <
- "/mon chemin/fichier.txt"
c :: conduit
début
évoque c.ouvrir(chemin)
casier vaut c.chargecasiernombres(1000)
évoque c.fermer()
affiche casier
[/php]

L'acteur "casier" contiendra directement les 1000 nombres.

Ça fonctionne !
Le problème c'est que je suis obligé d'indiquer un seul nombre par ligne dans ma sauvegarde :
007
000
005
000
007
000
000
000
000
000
005
000
005
000
000
000
000
000
000
000
007
000
000
000
007

Et donc, si j'ai 1000 nombres, la sauvegarde est beaucoup plus lourde !

C'est pourquoi j'enregistre mes nombres comme ceci :
007000005000007
000000000000000
005000005000000
000000000000000
007000000000007

Dans ce cas, il faudrait que je puisse "traduire" le code ci-dessous en utilisant c.chargecasiernombres() :
[php]
Pour chaque nombre_case_hauteur, lis
Pour chaque nombre_case_largeur, lis
mémo14 vaut c.nlire(3)
Convertis mémo14 en num14
Si num14 != 0, lis
Parcours Sauvegarde_drag avec num14, j
ferme
incrémente j
ferme
// on avance le curseur de 2 caractères pour éviter de lire le retour à la ligne
mémo14 vaut c.nlire(2)
ferme
[/php]

Dans cet exemple, je prend les 3 premiers chiffres : 0, 0, 7
je le convertis en un seul chiffre : 7
le 7 correspond alors au numéro de l'image que je veux afficher.

Je prend ensuite les 3 chiffres suivants de la même ligne : 0, 0, 0
et je le convertis en un seul chiffre : 0
Et ainsi de suite...

Or c.chargecasiernombres(1) va essayer de convertir tous les chiffres de la ligne en un seul chiffre, soit : 0, 0, 7, 0, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 7
Ce qui bien entendu fait planter mon programme ^^

Pour que je puisse enregistrer mes nombres comme ceci :

007000005000007
000000000000000
005000005000000
000000000000000
007000000000007

Il faudrait que c.chargecasiernombres() lise les chiffres, pas seulement jusqu'au retour à la ligne, mais également jusqu'à un symbole.
Par exemple, une virgule.

Ainsi en faisant ceci :

007,000,005,000,007
000,000,000,000,000
005,000,005,000,000
000,000,000,000,000
007,000,000,000,007

c.chargecasiernombres(1) lirait les 3 premiers chiffres "007", le convertirais en nombre "7", puis lirait les 3 suivant "000", qui donnerait le nombre "0",...

Cela me permettrais de réduire considérablement la taille de mon fichier de sauvegarde.

C'est possible ?

ok, je regarde ça !

Malgré l'utilisation de la méthode chargecasiernombres(), si je tente de lire mon livre 2 fois de suite, l'ouverture de ma sauvegarde passe de 2 secondes à 7 secondes et mon programme est énormément ralenti.
Si je tente de lire mon livre une troisième fois, mon pc plante...

Tant que j'y suis, est-ce que la fonctionnalité demandée dans mon dernier post à été ajoutée ?

Je vais ajouter une méthode clire au conduit.


Pour le problème de mémoire et de plantage.

Si tu pouvais me faire un exemple....
Si tu charges plusieurs fois ton fichier. Est-ce que tu supprimes bien les précédents éléments chargés pour ne pas surcharger la mémoire ?

Difficile pour moi de te mettre un exemple fonctionnel sans devoir te donner mon code en entier.
Mon programme consiste à prendre une image, la découper, créer un quadrillage et positionner les morceaux de l'image dans le quadrillage pour dessiner une "carte".
Ensuite, je peux sauvegarder et ouvrir cette carte comme bon me semble.

Voici un extrait de mon code :

[php]
prototype
pos_x_init & pos_y_init & numéro_case & numéro_case_init & index_copie_casier_tiles & index_grille4 & numéro_tile & index_carte :: nombre
validation_drop & tile_invisible :: drapeau
type mongraphique hérite de image et contient pos_x_init, pos_y_init, numéro_case, numéro_case_init, index_copie_casier_tiles, index_grille4, numéro_tile, validation_drop, tile_invisible

globale
taille_largeur_case :: nombre
taille_hauteur_case :: nombre
nombre_case_largeur :: nombre
nombre_case_hauteur :: nombre
nombre_case_total :: nombre
casier_tiles :: casier de image
copie_casier_tiles :: casier de mongraphique
carte :: casier de nombre
nombre_drag :: nombre

Enregistrer_sous :
c :: conduit
temp :: nombre
chemin_sauvegarde :: texte
ligne <
- c.retourchariot()
début
Essaie lis
// Si l'utilisateur à cliqué sur le menu "Enregistrer_sous", on ouvre le sélectionneur de fichiers
Si menu_enregistrer == faux, lis
évoque c.sélectionneretenregistrer()
évoque c.fermer()
chemin_sauvegarde vaut c.nomfichiercomplet()
ferme

// Si le chemin d'accès est valide, on enregistre directement par dessus la sauvegarde précédente
Si (c.fichierexiste(chemin_sauvegarde)) et (non(c.répertoire(chemin_sauvegarde))), évoque c.enregistrer(chemin_sauvegarde)
// Si l'utilisateur à cliqué sur le menu "Enregistrer" et que le chemin d'accès est invalide, on ouvre le sélectionneur de fichiers
Sinon évoque c.sélectionneretenregistrer()

chemin_sauvegarde vaut c.nomfichiercomplet()

// on sauvegarde le quadrillage
évoque c.écrire("" + taille_largeur_case)
évoque c.écrire(ligne)
évoque c.écrire("" + taille_hauteur_case)
évoque c.écrire(ligne)
évoque c.écrire("" + nombre_case_largeur)
évoque c.écrire(ligne)
évoque c.écrire("" + nombre_case_hauteur)
évoque c.écrire(ligne)

// on écrit la sauvegarde de la carte
Pour chaque nombre_case_total, lis
Si (carte{joker}) != -5, lis
temp = numéro_tile de (copie_casier_tiles{(carte{joker})})
Si temp <
= 9, évoque c.écrire("00" + temp)
Sinon si temp <
= 99, évoque c.écrire("0" + temp)
Sinon si temp <
= 999, évoque c.écrire(temp)
ferme
Sinon évoque c.écrire ("000")
évoque c.écrire(ligne)
ferme
ferme

évoque c.fermer()

Ouvrir :
c :: conduit
casier :: casier de nombres
num :: nombre
temps :: texte
début
évoque c.sélectionneretouvrir()

Essaie lis
casier vaut c.chargecasiernombres(3)

parcours start de chrono

// on récupère la taille du quadrillage
casier vaut c.chargecasiernombres(4)

taille_largeur_case = casier{0}
taille_hauteur_case = casier{1}
nombre_case_largeur = casier{2}
nombre_case_hauteur = casier{3}

// on calcule le nombre de cases à afficher
nombre_case_total = nombre_case_hauteur*nombre_case_largeur

// on recréer la sauvegarde de la carte
pour chaque nombre_case_total, ajoute -5 dans carte

// on restaure le casier copie_casier_tiles
casier vaut c.chargecasiernombres(nombre_case_total)

Pour chaque nombre_case_total, lis
num = casier{joker}
Si num != 0, parcours Sauvegarde_drag avec num, joker
ferme

parcours stop de chrono avec temps
affiche "Le fichier à été ouvert en " + temps + " secondes"
ferme

évoque c.fermer()

Sauvegarde_drag :
*numéro_tile_dessin :: nombre
*numéro_case_tile :: nombre
création_tile :: mongraphique
x_tile_init :: nombre
y_tile_init :: nombre
début
incrémente nombre_drag

ajoute création_tile dans copie_casier_tiles
image de création_tile = image de (casier_tiles{numéro_tile_dessin - 1})
dx@création_tile vaut dx de (casier_tiles{numéro_tile_dessin - 1})
dy@création_tile vaut dy de (casier_tiles{numéro_tile_dessin - 1})
largeur@création_tile vaut largeur_case_quadrillage_tileset
hauteur@création_tile vaut hauteur_case_quadrillage_tileset
position de création_tile = position de (casier_tiles{numéro_tile_dessin - 1})
numéro_case de création_tile = numéro_case_tile
numéro_case_init de création_tile = numéro_case_tile
index_copie_casier_tiles de création_tile = nombre_drag - 1
numéro_tile de création_tile = numéro_tile_dessin
tile_invisible de création_tile = vrai

// on met à jour la carte
carte{numéro_case_tile} = nombre_drag - 1
Reviens
[/php]

Je faisait des tests de mon système de sauvegarde quand j'ai constaté mon problème :
- j'exécute ma fonction Enregistrer_sous
- je ferme mon programme en cliquant sur le bouton Stop de l'atelier ou sur la croix de ma fenêtre qui renvoie sur le verbe Terminer
- j'ouvre ma sauvegarde en exécutant la fonction Ouvrir
- je ferme mon programme en cliquant sur le bouton Stop de l'atelier ou sur la croix de ma fenêtre

Cliquer sur le bouton Stop de l'atelier ou fermer mon programme avec le verbe Terminer ne supprime donc pas les éléments chargés en mémoire ?

J'en profite pour signaler qu'il faut cliquer 2 fois sur le bouton Stop de l'atelier pour fermer mon programme :
Quand je clique 1 fois sur le bouton Stop, mon programme se ferme, disparait de la barre des tâches mais le bouton Stop n'est pas grisé.
Il faut alors cliquer une seconde fois pour qu'il se grise et ne devienne plus cliquable.

Le fait que le bouton "fermer" ne marche pas, est une bonne piste.

Peux-tu lancer l'Atelier depuis une ligne de commande ?

Dans le répertoire de Linotte, tu tapes:

java -jar Linotte.jar

Tu fais tes tests et tu me retournes ce que tu vois dans la console.

Utilise la version 2.1 alpha 2

1) J'ai lancé l'atelier via la console.

2) Dans l'atelier j'ai démarré mon livre.
3) J'ai alors chargé ma sauvegarde.
4) Puis j'ai arrêté le livre en cliquant sur le bouton Stop de l'atelier (2 fois).

J'ai exécuté les étapes 2 à 4, quatre fois.

La 1ère fois, l'ouverture de ma sauvegarde s'est faite en 2s.
La 2ème fois, l'ouverture de ma sauvegarde s'est faite en 1s.
La 3ème fois, l'ouverture de ma sauvegarde s'est faite en 4s.
La 4ème fois, ma sauvegarde ne s'est jamais ouverte : j'ai dû passer par le gestionnaire de tâches pour fermer l'atelier.

Voici ce qui s'est affiché dans la console les 3 premières fois :

Disposal was interrupted:
java.lang.InterruptedException
at java.lang.Object.wait(Native Method)
at java.lang.Object.wait(Object.java:503)
at java.awt.EventQueue.invokeAndWait(Unknown Source)
at java.awt.Window.doDispose(Unknown Source)
at java.awt.Window.dispose(Unknown Source)
at org.linotte.greffons.impl.swing.Formulaire.destruction(Formulaire.jav
a:144)
at org.linotte.moteur.xml.alize.kernel.RuntimeContext.setStopLecture(Run
timeContext.java:193)
at org.linotte.moteur.xml.alize.kernel.RuntimeContext.closeRuntime(Runti
meContext.java:243)
at org.alize.kernel.AKRuntime.execute(AKRuntime.java:51)
at org.linotte.frame.FrameProcess.action(FrameProcess.java:147)
at org.linotte.frame.FrameProcess.run(FrameProcess.java:265)


Voici ce qui s'est affiché dans la console la 4ème fois :

Exception in thread "Thread-16" java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Unknown Source)
at java.lang.AbstractStringBuilder.expandCapacity(Unknown Source)
at java.lang.AbstractStringBuilder.ensureCapacityInternal(Unknown Source
)
at java.lang.AbstractStringBuilder.append(Unknown Source)
at java.lang.StringBuilder.append(Unknown Source)
at org.linotte.frame.ProcessStyle.action(ProcessStyle.java:72)
at org.linotte.frame.outils.Process.run(Process.java:56)
Exception in thread "Thread-24" java.lang.OutOfMemoryError: Java heap space
at java.util.Arrays.copyOf(Unknown Source)
at java.util.Arrays.copyOf(Unknown Source)
at java.util.concurrent.CopyOnWriteArrayList.add(Unknown Source)
at org.linotte.frame.latoile.JPanelLaToile.addActeursAAfficher(JPanelLaT
oile.java:422)
at org.linotte.moteur.xml.actions.EtatEspece.analyse(EtatEspece.java:589
)
at org.linotte.moteur.xml.alize.kernel.ProcessusSimple.execute(Processus
Simple.java:22)
at org.linotte.moteur.xml.alize.kernel.Job.execute(Job.java:55)
at org.alize.kernel.AKJob.execute(AKJob.java:65)
at org.linotte.moteur.xml.ThreadLinotte.run(ThreadLinotte.java:76)
at java.lang.Thread.run(Unknown Source)

ça confirme ce que je pensais.... une fuite mémoire...
je dois trouver l'origine....

Autre information,

Avant de lire ton livre, peux-tu activer l'audit dans l'onglet Audit.

Puis, quand tu cliques sur le bouton stop, peux-tu me dire ce qu'affiche l'onglet Audit ?

Merci

Voici ce qu'indique l'audit lors du 1er clique sur le bouton Stop :

<
ToileAudit>
Nombre d'acteurs sur la toile = 10902
<
ChronoAudit>
Chronomètre = 14016 ms
<
RuntimeAudit>
Nombre de runtimes = 1
<
RuntimeAudit>
job = Editeur de cartes 0.16.liv § Fenêtre_principale
<
LibrairieVirtuelleAudit>
Nombre de d'acteurs = 90

Et voici ce qu'indique l'audit lors de 2ème clique sur le bouton Stop :

<
ToileAudit>
Nombre d'acteurs sur la toile = 10902
<
ChronoAudit>
Chronomètre = 21359 ms
<
RuntimeAudit>
Nombre de runtimes = 0
<
LibrairieVirtuelleAudit>
Nombre de d'acteurs = 90

Je pense que la fuite mémoire provient des images.

Mon programme consiste à charger une image et à la découper :
Pour cela, je copie mon image plusieurs fois, en indiquant différentes valeurs dx et dy.
Voici un exemple :

[php]
globale
tileset :: image, position vaut 5

Découpage_tileset :
x_mini_case :: nombre <
- x de bordure_gauche + 1
y_mini_case :: nombre <
- y de bordure_gauche + 1
début
pour chaque nombre_case_quadrillage_tileset, lis
ajoute #tileset dans casier_tiles
dx@(casier_tiles{joker}) vaut dx_tile - dx_init + 1
dy@(casier_tiles{joker}) vaut dy_tile - dy_init + 1
hauteur@(casier_tiles{joker}) vaut hauteur_case_quadrillage_tileset
largeur@(casier_tiles{joker}) vaut largeur_case_quadrillage_tileset
déplace casier_tiles{joker} vers x_mini_case et y_mini_case
Projette casier_tiles{joker}
x_mini_case = x_mini_case + largeur_case_quadrillage_tileset
si x_mini_case >
((x de bordure_gauche + 1) + (largeur de bordure_gauche - 1) - largeur_case_quadrillage_tileset), lis
x_mini_case = x de bordure_gauche + 1
y_mini_case = y_mini_case + hauteur_case_quadrillage_tileset
ferme
si y_mini_case >
((y de bordure_gauche + 1) + (hauteur de bordure_gauche - 1) - hauteur_case_quadrillage_tileset), lis
y_mini_case = y de bordure_gauche + 1
ferme
ferme

pour chaque nombre_case_quadrillage_tileset, lis
Fais réagir casier_tiles{joker} à "clic souris" pour Drag
ferme
[/php]

Ensuite, mon programme consiste à déplacer ces bouts d'images dans un quadrillage :
Pour cela, je copie là encore mon image et je la drag&drop dans mon quadrillage.
Voici un extrait de ma fonction Drag :

[php]
Drag :
*tile_drag :: image
copie_tile :: mongraphique
numéro_tile_drag :: nombre
début
// on recréer l'image à l'identique
ajoute copie_tile dans copie_casier_tiles
image de copie_tile = image de tile_drag
dx de copie_tile vaut dx de tile_drag
dy de copie_tile vaut dy de tile_drag
hauteur de copie_tile vaut hauteur_case_quadrillage_tileset
largeur de copie_tile vaut largeur_case_quadrillage_tileset
déplace copie_tile vers x_tile et y_tile
position de copie_tile = position de tile_drag
Projette copie_tile

Fais réagir copie_tile à "glisser-déposer" pour Drop
[/php]

Ainsi, le quadrillage de ma sauvegarde fait 10000 cases, il contient alors 10 000 images.

C'est cette sauvegarde qui fait planter mon programme.

Lors de mon test, bien que mon quadrillage contienne 10000 images, ce dernier disposant d'un système de scrolling, j'affiche "seulement 400 bouts de mon image" à l'écran.

Très bonne piste !
Je n'y avais pas pensé.... je vais voir comment améliorer ça.