FORUM DE DISCUSSION SUR LE LANGAGE PANORAMIC

Développement d'applications avec le langage Panoramic
 
AccueilAccueil  FAQFAQ  RechercherRechercher  S'enregistrerS'enregistrer  MembresMembres  GroupesGroupes  Connexion  
Derniers sujets
» Problème de math
par papydall Aujourd'hui à 1:53

» A propos des attributs de fichier
par papydall Hier à 14:33

» Problème de math
par Marc37 Sam 21 Oct 2017 - 23:04

» I Love You
par papydall Sam 21 Oct 2017 - 19:22

» Un petit "coucou" à tous les Panoramiciens !
par mindstorm Sam 21 Oct 2017 - 17:06

» MARK_ON déclenche un événement ON_CLICK à la place de ...
par Jean Claude Mer 18 Oct 2017 - 18:08

» mise a jour calculatrice
par joeeee2017 Mer 18 Oct 2017 - 15:57

» [solved] 3D_LINE How to ?
par Jicehel Mer 18 Oct 2017 - 11:01

» Convertisseur de base 10 de 2 à 36
par gigi75 Mar 17 Oct 2017 - 18:49

» calculatrice avec touches movibles
par joeeee2017 Dim 15 Oct 2017 - 1:11

» CORTANA
par gigi75 Sam 14 Oct 2017 - 16:32

» Calculatrice
par Jean Claude Sam 14 Oct 2017 - 12:30

» Compilateur FBPano
par jean_debord Jeu 12 Oct 2017 - 9:53

» KGF_dll - nouvelles versions
par Klaus Mar 10 Oct 2017 - 18:49

» à propos de Panoramic_Editor [Résolu]
par Klaus Mar 10 Oct 2017 - 3:19

Navigation
 Portail
 Index
 Membres
 Profil
 FAQ
 Rechercher
Rechercher
 
 

Résultats par :
 
Rechercher Recherche avancée
Octobre 2017
LunMarMerJeuVenSamDim
      1
2345678
9101112131415
16171819202122
23242526272829
3031     
CalendrierCalendrier

Partagez | 
 

 Temps d'exécution d'un sous-programme appelé par SUB/GOSUB

Voir le sujet précédent Voir le sujet suivant Aller en bas 
AuteurMessage
papydall

avatar

Nombre de messages : 5551
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Temps d'exécution d'un sous-programme appelé par SUB/GOSUB    Jeu 10 Nov 2016 - 19:16

Code:

rem ============================================================================
rem    Comparaison des temps d exécution d un sous-programme appelé par
rem                     GOSUB et par SUB
rem ============================================================================
rem GOSUB peut doubler, voir tripler la vitesse d exécution du code.
rem Explication:
rem L appel d une procédure SUB relève d un processus relativement coûteux.
rem Panoramic doit conserver le contexte du code appelant (valeurs des variables,
rem point d exécution en cours, etc.), transférer les éventuels arguments vers
rem la pile, puis localiser le point d entrée de la procédure dans la mémoire avant
rem de l appeler.
rem Un sous-programme (appelé par son LABEL) n a pas de telles exigences en matière
rem de temps système, car il ne requiert aucune pile de variables.
rem ============================================================================
label calcul
dim x,y,t1,t2,t_sub,t_gosub
font_bold 0
' Appel par SUB
t1 = NUMBER_TICKS
for x = 1 to 10000
    calcul()
next x
t2 = NUMBER_TICKS
t_sub = (t2-t1)/1000
print " Durée pour SUB -------------> " + str$(t_sub)
rem ============================================================================
' Appel par GOSUB
t1 = NUMBER_TICKS
for x = 1 to 10000
    gosub calcul
next x
t2 = NUMBER_TICKS
t_gosub = (t2-t1)/1000
print " Durée pour GOSUB --------> " + str$(t_gosub)
rem ============================================================================
print : print "Rapport : t_sub / t_gosub = " + str$(t_sub / t_gosub)
print "L'appel par GOSUB est plus rapide"

end
rem ============================================================================
Calcul:
   y = sqr(x) + 3*sin(3*pi/4)
return
rem ============================================================================
SUB Calcul()
     y = sqr(x) + 3*sin(3*pi/4)
END_SUB
rem ============================================================================
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Ouf_ca_passe

avatar

Nombre de messages : 197
Age : 69
Localisation : Villeneuve d'Ascq (59-Dpt du NORD) France
Date d'inscription : 21/12/2015

MessageSujet: Très bon à savoir   Jeu 10 Nov 2016 - 19:26

Très bon à savoir

Cordialement
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Ouf_ca_passe

avatar

Nombre de messages : 197
Age : 69
Localisation : Villeneuve d'Ascq (59-Dpt du NORD) France
Date d'inscription : 21/12/2015

MessageSujet: Et GOTO dans tout ça ?    Lun 14 Nov 2016 - 10:48

J'ai pas réussi avec GOTO ?!?


Code:

rem =====
rem  Comparaison des temps d exécution d'un sous-programme appelé par
rem        GOSUB, SUB et GOTO
rem =====
label calcul1,calcul2
dim x,y,t1,t2,t_sub,t_gosub,t_goto
font_bold 0
' Appel par SUB
t1 = NUMBER_TICKS
for x = 1 to 10000
    calcul()
next x
t2 = NUMBER_TICKS
t_sub = (t2-t1)/1000
print " Durée pour SUB -------------> " + str$(t_sub)
rem =====
' Appel par GOSUB
t1 = NUMBER_TICKS
for x = 1 to 10000
    gosub calcul1
next x
t2 = NUMBER_TICKS
t_gosub = (t2-t1)/1000
print " Durée pour GOSUB --------> " + str$(t_gosub)
rem =====
' Appel par GOTO
t1 = NUMBER_TICKS
    goto calcul2
t2 = NUMBER_TICKS
t_goto = (t2-t1)/1000
print " Durée pour GOTO --------> " + str$(t_goto)
rem =====
' print : print "Rapport : t_sub / t_gosub = " + str$(t_sub / t_gosub)
' print "L'appel par GOSUB est plus rapide"
end
rem =====
Calcul1:
  y = sqr(x) + 3*sin(3*pi/4)
return
rem =====
SUB Calcul()
  y = sqr(x) + 3*sin(3*pi/4)
END_SUB
rem =====
Calcul2:
  for x = 1 to 10000
    y = sqr(x) + 3*sin(3*pi/4)
  next x
return



Nostalgie :
https://www.youtube.com/watch?v=170E9Maoocw
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
papydall

avatar

Nombre de messages : 5551
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Re: Temps d'exécution d'un sous-programme appelé par SUB/GOSUB    Lun 14 Nov 2016 - 13:13

Salut tout le monde

Ouf_ca_passe a écrit:
J'ai pas réussi avec GOTO ?!?

Le contraire m’aurait surpris !
Sache que :
1) L’appel à une procédure SUB se fait en invoquant la SUB par son nom.
Le programme se branche sur la 1ere instruction de la SUB et exécute le code jusqu’à l’instruction END_SUB.
Cette dernière déclenche un branchement du programme vers l’instruction qui suit l’instruction d’appel.
(Tu me suis toujours ?)
Il y a donc sauvegarde de l’environnement du travail lors de l’appel puis restitution de cet environnement.
2) L’appel à un sous-programme localisé par un identificateur de LABEL se fait par l’instruction GOSUB (GO TO SUBROUTINE).
Le programme se branche et exécute les instructions entre le LABEL et le RETURN.
Cette dernière instruction (RETURN) indique au programme qu'il doit se brancher à l’instruction juste après celle de l’appel. C'est donc une instruction de retour.
3) Le GOTO est un branchement  vers  une partie du programme SANS RETOUR !.
La fin du bloc d’instructions NE DOIT PAS contenir l’instruction RETURN. Ça n’a pas de sens.


En résumé :
SUB doit contenir END_SUB (éventuellement EXIT_SUB) qui est une instruction de retour vers l’appelant.
Le s/p débutant par l’identificateur d’un LABEL et appelé par GOSUB doit contenir RETURN qui est une instruction de retour.
L’appel par GOTO est un branchement sans retour.

Personnellement je n’utilise GOTO que pour montrer comment elle fonctionne et jamais dans mes codes car elle est (selon moi) la négation de la programmation structurée.
Quand on structure son code convenablement on n’a pas  besoin de GOTO.

Pour SUB et GOSUB le système gère lui-même le retour.
Par contre pour GOTO, le programmeur doit gérer lui-même les branchements / débranchements pour finir avec un beau treillis inextricable qu'il est TOUJOURS (ou presque) possible d'éviter.

J'ai modifié ton code pour utiliser GOTO


Code:

rem =====
rem  Comparaison des temps d exécution d'un sous-programme appelé par
rem        GOSUB, SUB et GOTO
rem =====
label calcul1,calcul2,retour
dim x,y,t1,t2,t_sub,t_gosub,t_goto
font_bold 0
' Appel par SUB
t1 = NUMBER_TICKS
for x = 1 to 10000
    calcul()
next x
t2 = NUMBER_TICKS
t_sub = (t2-t1)/1000
print " Durée pour SUB -------------> " + str$(t_sub)
rem =====
' Appel par GOSUB
t1 = NUMBER_TICKS
for x = 1 to 10000
    gosub calcul1
next x
t2 = NUMBER_TICKS
t_gosub = (t2-t1)/1000
print " Durée pour GOSUB --------> " + str$(t_gosub)
rem =====
' Appel par GOTO

t1 = NUMBER_TICKS
    goto calcul2
retour:
t2 = NUMBER_TICKS
t_goto = (t2-t1)/1000
print " Durée pour GOTO --------> " + str$(t_goto)
rem =====
' print : print "Rapport : t_sub / t_gosub = " + str$(t_sub / t_gosub)
' print "L'appel par GOSUB est plus rapide"
end
rem =====
Calcul1:
  y = sqr(x) + 3*sin(3*pi/4)
return
rem =====
SUB Calcul()
  y = sqr(x) + 3*sin(3*pi/4)
END_SUB
rem =====
Calcul2:
  for x = 1 to 10000
    y = sqr(x) + 3*sin(3*pi/4)
  next x
  goto retour


Mon conseil : évite tant que faire se peut d'utiliser l'instruction GOTO dans tes codes!
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Jean Claude

avatar

Nombre de messages : 5040
Age : 63
Localisation : 83 Var
Date d'inscription : 07/05/2009

MessageSujet: Re: Temps d'exécution d'un sous-programme appelé par SUB/GOSUB    Lun 14 Nov 2016 - 15:26

J'ai testé ton code Papydall,

Effectivement on a au moins 40% d'écart de durée d'exécution.
C'est à retenir pour certains cas de traitement.

A+
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
papydall

avatar

Nombre de messages : 5551
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Re: Temps d'exécution d'un sous-programme appelé par SUB/GOSUB    Lun 14 Nov 2016 - 16:00

Préférer GOSUB à SUB lorsqu’on est en présence d’un long traitement qui demande beaucoup de temps machine.
Pour un GOSUB le système ne retient que le point de retour (l’instruction après l’appel) lorsqu’il rencontre RETURN.
Par contre, l’appel à SUB oblige le système à retenir le point de retour, mais aussi à gérer les éventuels arguments de la SUB, l’utilisation de la pile, la sauvegarde de l’environnement (variables globales et locales) et ça demande un temps précieux.

Ça entre dans la phase d’optimisation du code pour les gros projets !
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Laurent (Minibug)

avatar

Nombre de messages : 2353
Age : 51
Localisation : Vienne (86)
Date d'inscription : 10/02/2012

MessageSujet: Re: Temps d'exécution d'un sous-programme appelé par SUB/GOSUB    Mer 16 Nov 2016 - 21:33

Salut Papydall !

Voila une réflexion très intéressante. Merci pour le résultat de ces recherches.

Moi qui remplace systématiquement tous les sous-programme xxxxxx:/RETURN par les SUB xxx()/END_SUB quand cela est possible, me donne matière à réflexion pour mes prochaines réalisations !

Comme tu le dit si bien lors de l'usage dans de gros programmes où les sous-programmes sont parfois imbriqués les uns dans les autres, le résultat peut être surprenant si l'on gagne 40% de temps comme le dit notre amis Jean Claude

Du coup je me pose la question pour GPP sur les modification à apporter ?!
Encore du déménagement dans l'air en prévision... Wink
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
Jean Claude

avatar

Nombre de messages : 5040
Age : 63
Localisation : 83 Var
Date d'inscription : 07/05/2009

MessageSujet: Re: Temps d'exécution d'un sous-programme appelé par SUB/GOSUB    Mer 16 Nov 2016 - 22:15

Bonsoir,
Sur ce sujet, restons prudent pour éviter une mauvaise interprétation.
Comme vous l'avez suggéré tous les deux, il ne s'agit pas de supprimer l'usage des SUB(s), surtout pour celle quii sont appelées sans passage de paramètres.
Mais, comme dit Papydall:
Citation :
Préférer GOSUB à SUB lorsqu’on est en présence d’un long traitement qui demande beaucoup de temps machine.

Pour un gros traitement, là c'est justifié, mais pour les petits traitements, les SUB(s) restent bien pratique.
De plus la vitesse des processeurs actuels permettent quelques petits écarts...

L'usage des SUB(s) trouve son intérêt, surtout, dans le passage de paramètres pour un traitement et/ou avec un retour de valeur(s).


A+
Revenir en haut Aller en bas
Voir le profil de l'utilisateur
papydall

avatar

Nombre de messages : 5551
Age : 67
Localisation : Moknine (Tunisie) Entre la chaise et le clavier
Date d'inscription : 03/03/2012

MessageSujet: Re: Temps d'exécution d'un sous-programme appelé par SUB/GOSUB    Jeu 17 Nov 2016 - 2:41

Tu as bien compris mon idée, Jean Claude.
En fait, pourquoi faire des programmes ?
Réponse : C’est pour trouver une solution à un problème que l’on se pose.
Donc, en première analyse, c’est écrire un code qui marche, sans se soucier  ni de la performance ni de l’optimisation.
Si le programme fait ce qu’il est sensé faire, c’est déjà un exploit.
On peut en rester là pour un projet modeste.

Mais si on entre dans une application costaude (comme pour GPP de Minibug ou  Maxi-scool de Pedro Alvarez, etc.) toute microseconde gagnée dans un traitement (multipliée par N très grand) aura son importance.
Revenir en haut Aller en bas
Voir le profil de l'utilisateur http://papydall-panoramic.forumarabia.com/
Contenu sponsorisé




MessageSujet: Re: Temps d'exécution d'un sous-programme appelé par SUB/GOSUB    

Revenir en haut Aller en bas
 
Temps d'exécution d'un sous-programme appelé par SUB/GOSUB
Voir le sujet précédent Voir le sujet suivant Revenir en haut 
Page 1 sur 1
 Sujets similaires
-
» les sous-programmes, les variables globales et locales
» (RESOLU) Comment enlever des entrées de l'exécution automatique dans windows 7 ?
» Désinstallation impossible de Nero 7 Démo (sous Vista)
» J'chante sous ma douche, même si j'perd un temps fouuu
» Combien de temps avant activation des services (sondage)

Permission de ce forum:Vous ne pouvez pas répondre aux sujets dans ce forum
FORUM DE DISCUSSION SUR LE LANGAGE PANORAMIC :: PANORAMIC :: Vos sources, vos utilitaires à partager-
Sauter vers: