Re : Pourquoi l'écriture et l'appel d'une fonction peuvent considérablement accélérer le temps d'exécution ? Et quelle est la règle de base pour écrire JSL pour la complexité temps/espace la plus efficace ?Je ne m'attendrais pas à ça non plus. Il y a une petite surcharge pour l'appel de fonction, liée à la copie des paramètres et à la configuration des variables locales.
Mais ... s'il y a un énorme tableau impliqué, utilisant plus de la moitié de la mémoire disponible, l'utilisation d'une variable locale dans la fonction garantirait que la mémoire est libérée avant qu'elle ne soit à nouveau nécessaire.Considérez ce JSL :
x = J(20000,20000,0);
...
x = J(20000,20000,0);
la première allocation nécessite 3 Go de mémoire. La deuxième allocation nécessite 3 Go supplémentaires avant de pouvoir libérer la première (lorsque x est écrasé.) Si x est un local dans la fonction, plutôt qu'un global, la mémoire pour x est libérée lorsque le x local est oublié à la fin de la fonction. Sinon, une machine de 4 Go paginera l'ancien x sur le disque tout en mettant à zéro la mémoire pour la nouvelle mémoire qui remplacera x. Ensuite, il oubliera ce qu'il a paginé sur le disque.
Si cela ressemble à ce que vous faites, essayez ceci pour le prouver :
x = J(20000,20000,0);
...
x=0; // forget the old allocation first
x = J(20000,20000,0);
Re : Pourquoi l'écriture et l'appel d'une fonction peuvent considérablement accélérer le temps d'exécution ? Et quelle est la règle de base pour écrire JSL pour la complexité temps/espace la plus efficace ?...et hptime() est la fonction microseconde. (hautes performances ? Vous ne savez pas ce que signifie hp.)
Pourquoi l'écriture et l'appel de la fonction peuvent considérablement accélérer le temps d'exécution ? Et quelle est la règle de base pour écrire JSL pour la complexité temps/espace la plus efficace ?Salut tout le monde,
L'une de mes tâches consiste à effectuer l'analyse de fiabilité, dans laquelle j'utilise Fit Life by X.
Ce faisant, j'ai deux scripts JSL qui sortent exactement les mêmes résultats mais avoir différentes approches de codage .
La première approche a simplement plusieurs morceaux de code en cascade ensemble. Le pseudo-code ressemble à ceci :
// Plot Fit Life by X #1
Fit Life by X(...);
// Plot Fit Life by X #2
Fit Life by X(...);
// Plot Fit Life by X #3
Fit Life by X(...);
// And so on
Le second a une seule fonction que nous appelons répétée avec différentes colonnes X, Y et censeur. Le pseudo-code ressemble à ceci :
// Function that contains Fit Life by X
reli_analysis = function(
{input parameters},
{local variables},
Fit Life by X(...);
);
// Call the above function multiple times
reli_analysis(input parameters set #1);
reli_analysis(input parameters set #2);
reli_analysis(input parameters set #3);
// And so on
Ce que j'ai vécu, c'est que le deuxième code est beaucoup plus rapide que le premier, de l'ordre de près de 10 fois plus rapide. (Mon JSL réel avec le jeu de données réel a le temps d'exécution (mesuré par le temps de l'horloge murale) d'environ 17 secondes à partir du code n ° 2 contre environ 170 secondes à partir du code n ° 1)
J'ai trois questions comme suit:
1. Pourquoi appeler la fonction est beaucoup plus rapide que d'écrire explicitement tous les codes ?
2. Quelles sont les autres pratiques/conseils que je devrais généralement suivre pour m'assurer que mon code a la complexité temporelle et/ou spatiale la plus efficace ?
3. Je ne sais pas si JSL a des fonctions de synchronisation intégrées comme le temps CPU et l'heure de l'horloge murale ? J'ai chronométré les exécutions de code en utilisant la fonction today(), mais cela implique beaucoup de codage manuel. De plus, les temps écoulés ainsi calculés sont toujours légèrement différents selon qu'il y a ou non d'autres tâches en cours d'exécution.
Je vous remercie beaucoup pour votre aide.
Version JMP : 17.0
Automatisation et scriptIngénierie de la qualité et des procédésles fenêtresRe : Pourquoi l'écriture et l'appel d'une fonction peuvent considérablement accélérer le temps d'exécution ? Et quelles sont les règles empiriques pour écrire du JSL pour la complexité temps/espace la plus efficace ?Autre possibilité : si le graphique précédent est ouvert et que la table de données est modifiée pour créer le nouveau graphique, l'ancien graphique peut réagir à chaque modification de la table de données. Peut-être que la version de la fonction ferme l'ancien graphique plus tôt ?
