Bonsoir,
Voici, à présent, une question probablement aussi triviale que les
précédentes, mais qui pourrait finir de me convaincre.
Je travaille sur un Mac Pro. Par conséquent, je dispose de "quatre"
processeurs potentiels. Lorsque je travaille sur de gros algorithmes,
je suis sensible à la bonne exploitation de ce potentiel.
Mon problème est le suivant :
Sur 300 000 requêtes basiques à MySQL, RealBasic est plus de 10 fois
plus rapide que PHP dans mon cas.
En revanche, sur 300 000 requêtes lourdes, il n'est que 30% plus
rapide, ce qui n'est pas du tout comparable. Ce problème vient de la
sous-exploitation de MySQL qui peut exploiter pleinement les quatre
processeurs si on lui envoie des requêtes multiples. Pour cela il me
faudrait avoir la possibilité d'envoyer
des requêtes parallèlement, sans attendre qu'elles soient traitée,
laissant MySQL gérer le flux.
J'ai pensé aux Thread mais j'n’ai probablement pas bien compris, car
je ne vois pas comment envoyer des paramètres.
Par ailleurs, je suis surpris par la faiblesse des tableaux (Array)
en RealBasic. Les fonctions associées sont d'une extrême faiblesse
par rapport au PHP, à Java ou à Perl. Par exemple, je ne trouve pas
de fonction pour enlever les doublons d'un tableau (de type
array_unique), la fonction Sort de tri est très faible, il n'y a même
pas le choix de l'ordre et moins encore du type d'ordre (alpha ou
numérique). Aussi, je n'ai pas trouvé de fonction qui cherche
l'intersection de deux tableaux ou qui cherche la présence d'un
élément dans un tableau. Ces fonctions peuvent être recréées, mais
elles seront inutilement lentes ce qui peut être très regrettable.
J'ai vu par ailleurs qu'il existe les collections et les
dictionnaires, mais les méthodes sont encore plus pauvres.
Il y a probablement une chose qui m'échappe...
Sinon, je suis globalement très agréablement surpris par RealBasic.
On apprend très vite et cela permet de faire des applications
efficaces en peu de temps. Je pense que je vais acheter la version
Pro d'ici la fin de la semaine :-)
Boris
Le 19 janv. 07 à 22:27, Boris (Com) a écrit :
Excellent ce Ticks. Merci.
Boris
Le 19 janv. 07 à 22:08, Mathieu Fay a écrit :
Bonjour,
Pour rafraîchir un ProgressBar, le Timer est très efficace.
Mais il y a aussi une autre solution simple : Les Ticks (temps
depuis la durée de l'allumage micro).
Dans ta boucle d'alimentation, tu utilises une variable :
dim MonTicks as Integer
MonTicks = Ticks() + 60 --- soit le temps actuel + 1 seconde
Et dans la boucle d'alimentation :
--- début Boucle
If MonTicks < Ticks Then
MonTicks = Ticks() + 60
--- Alimantation du ProgressBar ---
Endif
xxx
xxx
xxx
--- fin de boucle
Et comme ça, toute les secondes, ton progressbar est alimenté.
Mathieu
Le 18 janv. 07 à 20:08, Michel LO a écrit :
Je crois qu'il te faudrait relire le timer : car le timer crée un
thread ...
Et cela fonctionne.
Il faut lancer le timer, et tous les x dixièmes (ou bien est-ce
100e, voir la doc) de seconde, lorsque le timer se déclenche, le
code du timer s'exécute.
Je pense que tu n'as jamais utilisé de timer, car il fonctionne
exactement comme tu décris le thread.
Normal, le timer génère un thread.
Michel Lo
BELT
45, rue Aristide Briand
92300 LEVALLOIS-PERRET
L'intégrité de ce message n'étant pas assurée sur internet, BELT ne
peut être tenue responsable de son contenu. Toute utilisation ou
diffusion
non autorisée est interdite. Si vous n'êtes pas destinataire de
ce message,
merci de le détruire et d'avertir l'expéditeur.
The integrity of this message cannot be guaranteed on the Internet.
BELT can not therefore be considered responsible for the contents.
Any unauthorized use or dissemination is prohibited. If you are
not the
intended recipient of this message, then please delete it and
notify the
sender.
Le 18 janv. 07 à 16:15, Arnaud Nicolet a écrit :
Le 18 janv. 07 à 12:32 Soir, Michel LO a écrit:
Il y a plus efficace :
crée un timer que vous lancez au début de traitement (multiple
c'est à dire qui n'arrête pas de tourner) et qui se déclenche
toutes les secondes.
Dans le timer, faire un refresh
A la fin du traitement arrêter le timer.
Comme ca, il ne se met à jour qu'une fois par seconde
indépendamment de la longueur du traitement.
Pas tout-à-fait. Le "Timer" ne va pas s'exécuter plus que le
rafraîchissement de la fenêtre (en d'autres termes: si le
rafraîchissement est bloqué pas une boucle exécutée ailleurs,
alors le "Timer" aussi, il ne va être exécuté qu'à la fin).
Ce que l'on conseille, en général, c'est de déplacer le code
dans un fil d'exécution ("thread" si vous préférez). Pour créer
un fil d'exécution, il faut créer une nouvelle classe.
Usuellement, une application fonctionne sur le fil d'exécution
principal (c'est pour cela que le rafraîchissement ne peut se
faire en même temps qu'autre chose). En créant un nouveau fil
d'exécution, on fait les choses en "parallèle", c'est comme du
multitâche, mais dans la même application.
|