Discussion :

[HammerK]

Bonjour,


Je travail sous éclipse ou je développe un modèle mathématique qui prend en entré des données de type precipitation/Température/.. répartie temporellement et par pixel.

ces données étant en très grand nombre (11GO par variables (il y en a 6)), elles sont stockées dans 6 fichier (1 par variable) de type NETCDF.

Je me suis donc servis des de la bibliothèques NETCDF JAVA library (NJL)

http://www.unidata.ucar.edu/software/netcdf-java/

Le problème est que la lecture des donnée est parfois tres longue. Je m'explique, je calcul pour chaque pixel les sortie du modèle, et pour chaque pixel, je dois donc aller chercher les valeur journalière de donnée comme la température, les precipitations etc... Pour certain pixel, cette lecture devient bizarrement longue (1 minute pour lire mes 8 données (fois 365*nb année simulé)) alors que pour la plupart des pixel, cette lecture prend a peine 1 seconde. Je precise bien sur que pour chaque pixel la taille des donnée à lire est toujours similaire.....


Je ne comprend pas cette irrégularité dans le temps de lecture? je pense que la NJL traffic des truc avec la mémoire.

N'etant pas expert en Java, est ce qu'il existe des moyens de voir ce qui se passe au niveau du Garbage collector ? si celui travaille, a quelle fréquence??

Est il possible d'avoir une fuite mémoire en JAVA qui sature la mémoire utile du process dans lequel s'exécute mon modèle???

Est ce qu'un utilisateur pourrait me renseigner sur une bonne façon d'utiliser la NJL dans le cas ou je m'en sert mal.

D'autant plus que depuis cet après midi, alors que j'ai juste modifié très légèrement le code (j'ai remplacé un coef multiplicateur par un autre) le ralentissement ce fait maintenant a tout les pixels.

Ha oui, il se passe autre chose d'étrange. si depuis éclipse, je lance le run sur par exemple les 4 premiers pixel. J'arrete le run et je relance alors là, comme par magie, pour ces 4 pixel, le temps d'accès en lecture au variable et de nouveaux rapide (comme si des chose en mémoire avait été stocké)..... Bref, j'ai un peu de mal a comprendre le pourquoi du comment

Merci pour votre aide.

[HammerK]

J'oubliais de precisier :

Je travail sous XP.

Et lorsque le ralentissement a la lecture est en cour si je regarde le taux d'utilisation du CPU il est a zero % (ainsi que l'acces noyaux) du coup mon programme va a deux à l'heure alors et le CPU ne travail pas ....

Je ne comprend pas???

[msami]

Est ce que c'est possible de voir une portion de code ?

[bouye]

Vi parceque la bon...

Je n'ai jamais eut de reel probleme avec la lib Netcdf mais les volumes de donnees que le manipule sont beaucoup moins important.

Comment-lis-tu tes donnees ? Pixel par pixel ? Ou plan par plan ? Ou caches-tu un sous-partie (tile) d'un plan, etc... Bref des optimisations sont possibles en changeant de strategie de lecture.

Et puis 11 Go (x6 en plus !) c'est quand meme enorme... est-ce que l'OS sous-jacent peut cacher et correctement manipuler des fichiers aussi gros ?

[tchize_]

C'est toujours pour les mêmes données? Est-ce possible que ce soit lié à leur position dans le fichier? Un support de stockage endommagé pourrais expliquer ce problème, la zone concernée prendrait alors plusieurs essais à l'OS pour être lue correctement.

[HammerK]

je vais détillé avec du code ma "stratégie" de lecture :

dans un premier temps j'ouvre mes fichiers :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
		temperature_min=NetcdfFile.open(nc_tmin);
		temperature_max=NetcdfFile.open(nc_tmax);
		precipitation=NetcdfFile.open(nc_precip);
		humidite=NetcdfFile.open(nc_hum);
		rayonnement=NetcdfFile.open(nc_ray);
		vent=NetcdfFile.open(nc_vent);
 
		var_tmin = temperature_min.findVariable("Temperature_min");
		var_tmax = temperature_max.findVariable("Temperature_max");
		var_precip = precipitation.findVariable("Total_Precipitation");
		var_hum = humidite.findVariable("Relative_humidity");
		var_vent = vent.findVariable("U_wind_component");
		var_ray = rayonnement.findVariable("Incoming_Short_Wave_Radiation");

puis je lis mes variable de cette façon:

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
24
25
26
27
 
System.out.println("1.1");
		int[] origin = new int[] {dStart-1, indexLatitude-1, indexLongitude-1 };
		int[] size = new int[] {tStop, 1, 1};
 
		data3D = var_tmin.read(origin, size);
		listTAirMin = data3D.reduce();		
 
		data3D = var_tmax.read(origin, size);
		listTAirMax = data3D.reduce();
 
 
		data3D = var_precip.read(origin, size);
		listPrecipTemp = data3D.reduce();
		listPrecip=listPrecipTemp.copy();
		listET0=listPrecipTemp.copy();		
 
		data3D = var_hum.read(origin, size);
		listHum = data3D.reduce();	
 
		data3D = var_vent.read(origin, size);
		listWind = data3D.reduce();			
 
		data3D = var_ray.read(origin, size);
		listRay = data3D.reduce();	
 
		System.out.println("1.6");

c'est entre les deux println que le code ralentie énormément.

Comme vous le remarquez le lis les données pixel/pixel mais sur la durée de ma simulation.

Code :

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

int[] size = new int[] {tStop, 1, 1};

mon tstop vaut 7300.