j'ai un problème de lenteur de traitement sur une table mémoire depuis le passage à WD16.
En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT)
POUR nCompteur=1 A nNBaImporter
TableSelectPlus(TABLEIMPORT,nCompteur)
[traitements divers : vérification que le contenu de certaines colonnes correspondent à des valeurs précises et écritures dans des fichiers textes]
FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ 1500 lignes, en WD12 et presque 2mn en WD16 !
Quelqu'un aurait-il une idée ?
Merci d'avance,
cordialement.
N.B. : si ça intéresse quelqu'un, voici le code complet :
************************
nNBaImporter = TableOccurrence(TABLEIMPORT)
POUR nCompteur=1 A nNBaImporter
TableSelectPlus(TABLEIMPORT,nCompteur)
sDateTemp = Milieu(SansEspace(TABLEIMPORT.Date_Naissance),9,2)+"/"+Milieu(SansEspace(TABLEIMPORT.Date_Naissance),6,2)+"/"+Gauche(SansEspace(TABLEIMPORT.Date_Naissance),4)
HLitRecherche(CodeApogee,CA_code_etape,Majuscule(SansEspace(Milieu(TABLEIMPORT.IAE_Etape_code,2,5))))
SI HTrouve(CodeApogee) ALORS
sLigneTempEtudIUT = UneLigneEtudIUT(sDateTemp)
sLigneTempEtud = UneLigneEtud(sDateTemp)
sLigneTempLnx = UneLigneLinux(sDateTemp,CodeApogee.CA_linux_serveur,CodeApogee.CA_linux_home)
sLigneTempScoDoc = UneLigneScoDoc(sDateTemp)
sLigneTempExcel = UneLigneExcel(sDateTemp)
// on écrit également dans les "regroupements" :
fEcrit(nNumFicIUT,sLigneTempEtudIUT)
SI (SansEspace(CodeApogee.CA_groupe) <> SansEspace(CodeApogee.CA_nom_fichier)) ALORS
fEcrit(taNumFicGrpEtud[SansEspace(CodeApogee.CA_groupe)+NumériqueVersChaîne(CodeApogee.CA_annee)],sLigneTempEtud)
fEcrit(taNumFicGrpLnx[SansEspace(CodeApogee.CA_groupe)+NumériqueVersChaîne(CodeApogee.CA_annee)],sLigneTempLnx)
fEcrit(taNumFicGrpScoDoc[SansEspace(CodeApogee.CA_groupe)+NumériqueVersChaîne(CodeApogee.CA_annee)],sLigneTempScoDoc)
TableAjoute(ScoDoc_Excel,taNumFicGrpExcel[SansEspace(CodeApogee.CA_groupe)+NumériqueVersChaîne(CodeApogee.CA_annee)] + TAB + sLigneTempExcel)
FIN
SINON
sLigneTempEtudIUT = UneLigneEtudIUT(sDateTemp)
fEcrit(nNumFicSansCode,sLigneTempEtud)
nNbPasTrouve++
sTextePasTrouve += NomPrenom(TABLEIMPORT.Individu_Nom,TABLEIMPORT.Individu_Prenom)+RC
FIN
nNbRecup++
FIN
*******************
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Fredo
Le 24/05/2011 17:38, Yves Bourhis a écrit :
Bonjour,
j'ai un problème de lenteur de traitement sur une table mémoire depuis le passage à WD16. En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT) POUR nCompteur=1 A nNBaImporter TableSelectPlus(TABLEIMPORT,nCompteur) [traitements divers : vérification que le contenu de certaines colonnes correspondent à des valeurs précises et écritures dans des fichiers textes] FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ 1500 lignes, en WD12 et presque 2mn en WD16 ! Quelqu'un aurait-il une idée ?
Merci d'avance, cordialement.
N.B. : si ça intéresse quelqu'un, voici le code complet :
************************ nNBaImporter = TableOccurrence(TABLEIMPORT) POUR nCompteur=1 A nNBaImporter TableSelectPlus(TABLEIMPORT,nCompteur) sDateTemp > Milieu(SansEspace(TABLEIMPORT.Date_Naissance),9,2)+"/"+Milieu(SansEspace(TABLEIMPORT.Date_Naissance),6,2)+"/"+Gauche(SansEspace(TABLEIMPORT.Date_Naissance),4)
// on écrit également dans les "regroupements" : fEcrit(nNumFicIUT,sLigneTempEtudIUT) SI (SansEspace(CodeApogee.CA_groupe) <> SansEspace(CodeApogee.CA_nom_fichier)) ALORS fEcrit(taNumFicGrpEtud[SansEspace(CodeApogee.CA_groupe)+NumériqueVersChaîne(CodeApogee.CA_annee)],sLigneTempEtud)
sLigneTemp = TABLEIMPORT.Individu_Code_Etudiant + csSepRubriqueEtud sLigneTemp += TABLEIMPORT.Individu_Nom + csSepRubriqueEtud sLigneTemp += TABLEIMPORT.Individu_Prenom + csSepRubriqueEtud sLigneTemp += csSepRubriqueEtud // on saute le champ 'Et_nom-marital' prévu dans la base "Lycées" sLigneTemp += TABLEIMPORT.Individu_Sexe + csSepRubriqueEtud + sDateTemp + csSepRubriqueEtud + TABLEIMPORT.IAE_Etape_code + csSepRubriqueEtud sLigneTemp += TABLEIMPORT.CODE_LYCEE + csSepRubriqueEtud + csSepRubriqueEtud // on saute la 'classe' sLigneTemp += TABLEIMPORT.Bac_Libelle + csSepRubriqueEtud + TABLEIMPORT.Bac_Annee sLigneTemp += csSepEnregEtud
RENVOYER sLigneTemp *******************
-- Yves Bourhis
Bonjour,
Le plus simple c'est de lancer le code en mode "analyse de performance", pour voir les traitements qui prennent du temps. Cela peut venir d'un changement dans la façon dont est traité l'affichage de la table mémoire (déjà eu le cas, ce qui fait que je traite depuis fort longtemps maintenant tous les traitements de ce type dans un tableau mémoire plutôt que dans un champ table.
A vérifier aussi peut-être l'écriture du fichier texte.
Mais bon, l'analyseur permettra déjà d'isoler les traitements longs.
Bon dev,
Fred.
Le 24/05/2011 17:38, Yves Bourhis a écrit :
Bonjour,
j'ai un problème de lenteur de traitement sur une table mémoire depuis
le passage à WD16.
En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT)
POUR nCompteur=1 A nNBaImporter
TableSelectPlus(TABLEIMPORT,nCompteur)
[traitements divers : vérification que le contenu de certaines colonnes
correspondent à des valeurs précises et écritures dans des fichiers textes]
FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ
1500 lignes, en WD12 et presque 2mn en WD16 !
Quelqu'un aurait-il une idée ?
Merci d'avance,
cordialement.
N.B. : si ça intéresse quelqu'un, voici le code complet :
************************
nNBaImporter = TableOccurrence(TABLEIMPORT)
POUR nCompteur=1 A nNBaImporter
TableSelectPlus(TABLEIMPORT,nCompteur)
sDateTemp > Milieu(SansEspace(TABLEIMPORT.Date_Naissance),9,2)+"/"+Milieu(SansEspace(TABLEIMPORT.Date_Naissance),6,2)+"/"+Gauche(SansEspace(TABLEIMPORT.Date_Naissance),4)
// on écrit également dans les "regroupements" :
fEcrit(nNumFicIUT,sLigneTempEtudIUT)
SI (SansEspace(CodeApogee.CA_groupe) <>
SansEspace(CodeApogee.CA_nom_fichier)) ALORS
fEcrit(taNumFicGrpEtud[SansEspace(CodeApogee.CA_groupe)+NumériqueVersChaîne(CodeApogee.CA_annee)],sLigneTempEtud)
sLigneTemp = TABLEIMPORT.Individu_Code_Etudiant + csSepRubriqueEtud
sLigneTemp += TABLEIMPORT.Individu_Nom + csSepRubriqueEtud
sLigneTemp += TABLEIMPORT.Individu_Prenom + csSepRubriqueEtud
sLigneTemp += csSepRubriqueEtud // on saute le champ 'Et_nom-marital'
prévu dans la base "Lycées"
sLigneTemp += TABLEIMPORT.Individu_Sexe + csSepRubriqueEtud + sDateTemp
+ csSepRubriqueEtud + TABLEIMPORT.IAE_Etape_code + csSepRubriqueEtud
sLigneTemp += TABLEIMPORT.CODE_LYCEE + csSepRubriqueEtud +
csSepRubriqueEtud // on saute la 'classe'
sLigneTemp += TABLEIMPORT.Bac_Libelle + csSepRubriqueEtud +
TABLEIMPORT.Bac_Annee
sLigneTemp += csSepEnregEtud
RENVOYER sLigneTemp
*******************
--
Yves Bourhis
Bonjour,
Le plus simple c'est de lancer le code en mode "analyse de performance",
pour voir les traitements qui prennent du temps. Cela peut venir d'un
changement dans la façon dont est traité l'affichage de la table mémoire
(déjà eu le cas, ce qui fait que je traite depuis fort longtemps
maintenant tous les traitements de ce type dans un tableau mémoire
plutôt que dans un champ table.
A vérifier aussi peut-être l'écriture du fichier texte.
Mais bon, l'analyseur permettra déjà d'isoler les traitements longs.
j'ai un problème de lenteur de traitement sur une table mémoire depuis le passage à WD16. En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT) POUR nCompteur=1 A nNBaImporter TableSelectPlus(TABLEIMPORT,nCompteur) [traitements divers : vérification que le contenu de certaines colonnes correspondent à des valeurs précises et écritures dans des fichiers textes] FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ 1500 lignes, en WD12 et presque 2mn en WD16 ! Quelqu'un aurait-il une idée ?
Merci d'avance, cordialement.
N.B. : si ça intéresse quelqu'un, voici le code complet :
************************ nNBaImporter = TableOccurrence(TABLEIMPORT) POUR nCompteur=1 A nNBaImporter TableSelectPlus(TABLEIMPORT,nCompteur) sDateTemp > Milieu(SansEspace(TABLEIMPORT.Date_Naissance),9,2)+"/"+Milieu(SansEspace(TABLEIMPORT.Date_Naissance),6,2)+"/"+Gauche(SansEspace(TABLEIMPORT.Date_Naissance),4)
// on écrit également dans les "regroupements" : fEcrit(nNumFicIUT,sLigneTempEtudIUT) SI (SansEspace(CodeApogee.CA_groupe) <> SansEspace(CodeApogee.CA_nom_fichier)) ALORS fEcrit(taNumFicGrpEtud[SansEspace(CodeApogee.CA_groupe)+NumériqueVersChaîne(CodeApogee.CA_annee)],sLigneTempEtud)
sLigneTemp = TABLEIMPORT.Individu_Code_Etudiant + csSepRubriqueEtud sLigneTemp += TABLEIMPORT.Individu_Nom + csSepRubriqueEtud sLigneTemp += TABLEIMPORT.Individu_Prenom + csSepRubriqueEtud sLigneTemp += csSepRubriqueEtud // on saute le champ 'Et_nom-marital' prévu dans la base "Lycées" sLigneTemp += TABLEIMPORT.Individu_Sexe + csSepRubriqueEtud + sDateTemp + csSepRubriqueEtud + TABLEIMPORT.IAE_Etape_code + csSepRubriqueEtud sLigneTemp += TABLEIMPORT.CODE_LYCEE + csSepRubriqueEtud + csSepRubriqueEtud // on saute la 'classe' sLigneTemp += TABLEIMPORT.Bac_Libelle + csSepRubriqueEtud + TABLEIMPORT.Bac_Annee sLigneTemp += csSepEnregEtud
RENVOYER sLigneTemp *******************
-- Yves Bourhis
Bonjour,
Le plus simple c'est de lancer le code en mode "analyse de performance", pour voir les traitements qui prennent du temps. Cela peut venir d'un changement dans la façon dont est traité l'affichage de la table mémoire (déjà eu le cas, ce qui fait que je traite depuis fort longtemps maintenant tous les traitements de ce type dans un tableau mémoire plutôt que dans un champ table.
A vérifier aussi peut-être l'écriture du fichier texte.
Mais bon, l'analyseur permettra déjà d'isoler les traitements longs.
Bon dev,
Fred.
JeAn-PhI
Le 24/05/2011, Yves Bourhis a supposé :
Bonjour,
j'ai un problème de lenteur de traitement sur une table mémoire depuis le passage à WD16. En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT) POUR nCompteur=1 A nNBaImporter TableSelectPlus(TABLEIMPORT,nCompteur) [traitements divers : vérification que le contenu de certaines colonnes correspondent à des valeurs précises et écritures dans des fichiers textes] FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ 1500 lignes, en WD12 et presque 2mn en WD16 ! Quelqu'un aurait-il une idée ?
Merci d'avance, cordialement.
pour traiter des lignes de table rapidement je fais comme ceci
pour i = 1 _a_ tableoccurrence(matable) trace(matable.macol[i]) fin
-- Cordialement JeAn-PhI
Le 24/05/2011, Yves Bourhis a supposé :
Bonjour,
j'ai un problème de lenteur de traitement sur une table mémoire depuis le
passage à WD16.
En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT)
POUR nCompteur=1 A nNBaImporter
TableSelectPlus(TABLEIMPORT,nCompteur)
[traitements divers : vérification que le contenu de certaines colonnes
correspondent à des valeurs précises et écritures dans des fichiers textes]
FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ 1500
lignes, en WD12 et presque 2mn en WD16 !
Quelqu'un aurait-il une idée ?
Merci d'avance,
cordialement.
pour traiter des lignes de table rapidement je fais comme ceci
pour i = 1 _a_ tableoccurrence(matable)
trace(matable.macol[i])
fin
j'ai un problème de lenteur de traitement sur une table mémoire depuis le passage à WD16. En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT) POUR nCompteur=1 A nNBaImporter TableSelectPlus(TABLEIMPORT,nCompteur) [traitements divers : vérification que le contenu de certaines colonnes correspondent à des valeurs précises et écritures dans des fichiers textes] FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ 1500 lignes, en WD12 et presque 2mn en WD16 ! Quelqu'un aurait-il une idée ?
Merci d'avance, cordialement.
pour traiter des lignes de table rapidement je fais comme ceci
pour i = 1 _a_ tableoccurrence(matable) trace(matable.macol[i]) fin
-- Cordialement JeAn-PhI
Firetox
bonjour,
"JeAn-PhI" a écrit dans le message de news:4ddcb1b7$0$20748$
Le 24/05/2011, Yves Bourhis a supposé :
Bonjour,
j'ai un problème de lenteur de traitement sur une table mémoire depuis le passage à WD16. En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT) POUR nCompteur=1 A nNBaImporter TableSelectPlus(TABLEIMPORT,nCompteur) [traitements divers : vérification que le contenu de certaines colonnes correspondent à des valeurs précises et écritures dans des fichiers textes] FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ 1500 lignes, en WD12 et presque 2mn en WD16 ! Quelqu'un aurait-il une idée ?
Merci d'avance, cordialement.
pour traiter des lignes de table rapidement je fais comme ceci
pour i = 1 _a_ tableoccurrence(matable) trace(matable.macol[i]) fin
-- Cordialement JeAn-PhI
apres windev 12 l'instruction qui prend le plus de temps est le TableSelectPlus avec le reaffichage de la table comme le dit jean-phi il faut parcourrir l a table sans selection avec l'indice uniquement et pour gagner 30 % de temps il faut aussi mettre la table en invisible car il n'y aura pas de reaffichage de la fenetre comme cela
matable..visible = faux au debut du traitement et un matable..visible = vrai a la fin du traitement
en general c'est 30 % de gagner en vitesse
sino aussi comme il a ete dit faire un profile du projet pour voir l'instruction qui prend le plus de temps pour savoir si on peut l'optimiser ou non
cordialement Firetox
bonjour,
"JeAn-PhI" <nospam@nospam.fr> a écrit dans le message de
news:4ddcb1b7$0$20748$426a74cc@news.free.fr...
Le 24/05/2011, Yves Bourhis a supposé :
Bonjour,
j'ai un problème de lenteur de traitement sur une table mémoire depuis le
passage à WD16.
En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT)
POUR nCompteur=1 A nNBaImporter
TableSelectPlus(TABLEIMPORT,nCompteur)
[traitements divers : vérification que le contenu de certaines
colonnes correspondent à des valeurs précises et écritures dans des
fichiers textes]
FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ
1500 lignes, en WD12 et presque 2mn en WD16 !
Quelqu'un aurait-il une idée ?
Merci d'avance,
cordialement.
pour traiter des lignes de table rapidement je fais comme ceci
pour i = 1 _a_ tableoccurrence(matable)
trace(matable.macol[i])
fin
--
Cordialement JeAn-PhI
apres windev 12 l'instruction qui prend le plus de temps est le
TableSelectPlus avec le reaffichage de la table
comme le dit jean-phi il faut parcourrir l a table sans selection avec
l'indice uniquement et pour gagner 30 % de temps il faut aussi mettre la
table en invisible car il n'y aura pas de reaffichage de la fenetre comme
cela
matable..visible = faux au debut du traitement et un
matable..visible = vrai a la fin du traitement
en general c'est 30 % de gagner en vitesse
sino aussi comme il a ete dit faire un profile du projet pour voir
l'instruction qui prend le plus de temps pour savoir si on peut l'optimiser
ou non
"JeAn-PhI" a écrit dans le message de news:4ddcb1b7$0$20748$
Le 24/05/2011, Yves Bourhis a supposé :
Bonjour,
j'ai un problème de lenteur de traitement sur une table mémoire depuis le passage à WD16. En gros, voici le code :
nNBaImporter = TableOccurrence(TABLEIMPORT) POUR nCompteur=1 A nNBaImporter TableSelectPlus(TABLEIMPORT,nCompteur) [traitements divers : vérification que le contenu de certaines colonnes correspondent à des valeurs précises et écritures dans des fichiers textes] FIN
Ce traitement prenait une dizaine de secondes, pour une table d'environ 1500 lignes, en WD12 et presque 2mn en WD16 ! Quelqu'un aurait-il une idée ?
Merci d'avance, cordialement.
pour traiter des lignes de table rapidement je fais comme ceci
pour i = 1 _a_ tableoccurrence(matable) trace(matable.macol[i]) fin
-- Cordialement JeAn-PhI
apres windev 12 l'instruction qui prend le plus de temps est le TableSelectPlus avec le reaffichage de la table comme le dit jean-phi il faut parcourrir l a table sans selection avec l'indice uniquement et pour gagner 30 % de temps il faut aussi mettre la table en invisible car il n'y aura pas de reaffichage de la fenetre comme cela
matable..visible = faux au debut du traitement et un matable..visible = vrai a la fin du traitement
en general c'est 30 % de gagner en vitesse
sino aussi comme il a ete dit faire un profile du projet pour voir l'instruction qui prend le plus de temps pour savoir si on peut l'optimiser ou non
cordialement Firetox
JeAn-PhI
Firetox a exposé le 25/05/2011 :
apres windev 12 l'instruction qui prend le plus de temps est le TableSelectPlus avec le reaffichage de la table comme le dit jean-phi il faut parcourrir l a table sans selection avec l'indice uniquement et pour gagner 30 % de temps il faut aussi mettre la table en invisible car il n'y aura pas de reaffichage de la fenetre comme cela
matable..visible = faux au debut du traitement et un matable..visible = vrai a la fin du traitement
en general c'est 30 % de gagner en vitesse
sino aussi comme il a ete dit faire un profile du projet pour voir l'instruction qui prend le plus de temps pour savoir si on peut l'optimiser ou non
apres windev 12 l'instruction qui prend le plus de temps est le
TableSelectPlus avec le reaffichage de la table
comme le dit jean-phi il faut parcourrir l a table sans selection avec
l'indice uniquement et pour gagner 30 % de temps il faut aussi mettre la
table en invisible car il n'y aura pas de reaffichage de la fenetre comme
cela
matable..visible = faux au debut du traitement et un
matable..visible = vrai a la fin du traitement
en general c'est 30 % de gagner en vitesse
sino aussi comme il a ete dit faire un profile du projet pour voir
l'instruction qui prend le plus de temps pour savoir si on peut l'optimiser
ou non
apres windev 12 l'instruction qui prend le plus de temps est le TableSelectPlus avec le reaffichage de la table comme le dit jean-phi il faut parcourrir l a table sans selection avec l'indice uniquement et pour gagner 30 % de temps il faut aussi mettre la table en invisible car il n'y aura pas de reaffichage de la fenetre comme cela
matable..visible = faux au debut du traitement et un matable..visible = vrai a la fin du traitement
en general c'est 30 % de gagner en vitesse
sino aussi comme il a ete dit faire un profile du projet pour voir l'instruction qui prend le plus de temps pour savoir si on peut l'optimiser ou non
Merci pour vos réponses : c'était effectivement l'affichage de la table qui prenait trop de temps ! Du coup j'ai même accéléré le traitement par rapport à WD12 :-)
Merci pour vos réponses : c'était effectivement l'affichage de la table qui prenait trop de temps !
Du coup j'ai même accéléré le traitement par rapport à WD12 :-)
Merci pour vos réponses : c'était effectivement l'affichage de la table qui prenait trop de temps ! Du coup j'ai même accéléré le traitement par rapport à WD12 :-)
