Discussion :

[UbuntuMan]

Bonjour,

J'ai une moving map avec des textures que je charge dynamiquement et j'ai un problème de performance.

Je m'explique :

Actuellement les textures sont chargées(*) via une asynctask DownloadTextureTask lancée depuis le constructeur
de ma classe Tile à la fin de l'initialisation.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
public class Tile {
 
  boolean loaded = false;
 
  public Tile() {
    // bla bla initialisation
    new DownloadTextureTask().execute;
  }
 
  private class DownloadTextureTask extends AsyncTask<..., ..., ...> {
    protected ... doInBackground(...) {
      // chargement file system
      // ou 
      // chargement réseau
    }
 
    protected void onPostExecute(...) {
      loaded = true;
    }
 
  }
}

Les instances de la classe Tile sont instanciées dans une boucle dans ma classe SceneRenderer à la demande car ça
évolue en permanence. Les Tiles sont cachées dans une Lru donc j'alloue que ce dont j'ai besoin. Mais en gros je peux
avoir besoin de 121 Tiles d'un coup (Matrice 11x11).

Alors j'ai l'impression que l'allocation des Tiles se fait de façon séquentielle malgré le fait que le fait que ça soit dans
une AsyncTask. Est-ce que ça provient du onPostExecute() qui bloque ou attend la fin de la tâche ?

(*) L'async task utilise 2 niveaux de cache, le file system et le réseau. Quand c'est le réseau, avec un compteur de type
static je vois bien que je n'ai qu'une requête en parallèle à un instant t.

J'ai essayé les ThreadPoolExecutor à la place de l'AsyncTask, mais si là au niveau réseau ça marche bien en parallèle,
ça saccade carrément au niveau de l'affichage OpenGL même lorsque les Tiles sont sur le file system ! J'ai essayé de limiter
le nombre de Thread dans le ThreadPoolExecutor, mais ça ne change rien.

Bref un truc de ouf. Avec l'async task ça fonctionne bien (aucun lag OpenGL) quand c'est en local, par contre les textures
mettent pas mal de temps à apparaitre (même dans ce cas pas de lag).

Bref je sais plus trop quoi explorer !

[UbuntuMan]

Ok donc à priori le lag semble venir de ma function updateModel (celle qui crée les Tiles) et ceci uniquement
lorsque j'utilise les ThreadPoolExecutor alors qu'avec l'AsyncTask ça se passe bien (sauf pour le réseau ou ça rame).

J'ai l'impression que ça vient du ThreadPoolExecutor qui n'appartiendrait pas au Thread UI alors que l'AsyncTask oui
(je pense).

Du coup je charge la hierarchie de Thread d'opengl (qui n'en n'a pas besoin) et non celle de l'ui...

Faut que je creuse ça.

[UbuntuMan]

A priori en utilisant le ThreadPoolExecutor et en settant la priorité des Threads à Thread.MIN_PRIORITY
j'arrive à retrouver la rapidité de l'AsyncTask (quasiment presque pas de ralentissement à l'affichage) tout
en ayant un maximum de parallélisme sur les requêtes réseaux.

Mais faut que j'analyse encore tout ça.