L'exemple avec les maps est assez pertinent.
Prenons une routine d'accès de données.
Elle est exécutée systématiquement pour "accéder aux données".
La base de données change de taille.
La routine actuelle n'est plus adéquate.
Installons donc une suite de routines d'accès, et stockons leur adresse dans une VTable.
Problème: un saut sélectif est nécessaire. C'est plus lent qu'un simple saut.
Dégageons l'installation et ne gardons qu'un tampon de routine.
Dès qu'une map est créée, un petit tampon est créé et la routine initiale y copiée. Pour l'instant, strictement rien de nouveau. La routine est exécutée à chaque accès.
C'est quand une insertion/suppression est effectuée qu'un test de niveau de taille de base de données est effectué: si le niveau change, la routine d'accès est écrasée dans son tampon par une nouvelle routine adéquate au nouveau niveau. C'est une sorte de mise à jour à l'instar d'une boîte de vitesses séquentielle.
Les mises à jour peuvent reportées (si possible), en vue d'un "tir groupé".
L'accès aux données reste inchangé. La nature des routines fait gagner plus de temps que les mises à jour peuvent en faire perdre.
Hard-copie d'une routine pour exécution sans condition préal
Re: Hard-copie d'une routine pour exécution sans condition p
Bonjour Spock,
je comprends la difficulté que tu rencontres à ma lecture.
Je parle d'une chose assez compliquée dont j'en ai le concept mais pas toutes les règles (je ne sais pas quel algo est actuellement utilisé, même si c'est un excellent algo).
Je cherche à ce qu'une perte de temps soit enlevée durant un simple accès à une "grosse" map vide ou quasiment.
Cela, pour que des codes sources puissent fonctionner sur des petites configurations. Evidemment, cela ne doit pas faire perdre de temps sur les grosses configurations.
Pour te donner une idée, tu connais l'instruction
'Gosub NomLabel'. Tu connais aussi l'instruction
'On LabelIndex Gosub Label1, Label2, Label3, ... , LabelN'
La 1ère est plus rapide que la 2nde.
Imagine une pseudo-instruction:
Cela permet d'ajouter un élément dans une map sans se soucier de sa taille, autrement que par l'asservissement via 'AjourneAjout'.
Imagine que suite au label MapAjoute, tu aies directement le code sans passer par un saut sélectif, tu gagnes du temps.
je comprends la difficulté que tu rencontres à ma lecture.
Je parle d'une chose assez compliquée dont j'en ai le concept mais pas toutes les règles (je ne sais pas quel algo est actuellement utilisé, même si c'est un excellent algo).
Je cherche à ce qu'une perte de temps soit enlevée durant un simple accès à une "grosse" map vide ou quasiment.
Cela, pour que des codes sources puissent fonctionner sur des petites configurations. Evidemment, cela ne doit pas faire perdre de temps sur les grosses configurations.
Pour te donner une idée, tu connais l'instruction
'Gosub NomLabel'. Tu connais aussi l'instruction
'On LabelIndex Gosub Label1, Label2, Label3, ... , LabelN'
La 1ère est plus rapide que la 2nde.
Imagine une pseudo-instruction:
Code : Tout sélectionner
MapAjoute:
On NiveauMap Gosub PetiteMapAjoute, MoyenneMapAjoute, GrandeMapAjoute
Gosub AjourneAjout
Return
AjourneAjout:
N + 1
TestExcuser = N & $3FF
If Not TestExcuser
Test = N
If Test: NiveauMap = 1: EndIf
Test >> 10
If Test: NiveauMap = 2: EndIf
Test >> 10
If Test: NiveauMap = 3: EndIf
Return
Imagine que suite au label MapAjoute, tu aies directement le code sans passer par un saut sélectif, tu gagnes du temps.
Re: Hard-copie d'une routine pour exécution sans condition p
Normalement une map n'est qu'un très grand tableau dynamique.Je parle d'une chose assez compliquée dont j'en ai le concept mais pas toutes les règles (je ne sais pas quel algo est actuellement utilisé, même si c'est un excellent algo).
Je cherche à ce qu'une perte de temps soit enlevée durant un simple accès à une "grosse" map vide ou quasiment.
Ta clé est l'index du tableau, le problème c'est que si ta clé est plus grande que le tableau, il faut agrandir le tableau , si la mémoire contigüe n'est pas disponible, il faut tout copié vers un emplacement contigüe.
J'ai une procédure de hashage , tu peu la transformé facilement en macro et faire un test de rapidité :
Code : Tout sélectionner
Procedure.q hash(string.s, seed.q = 0)
hash.q = seed
For i = 0 To Len(string)-1
hash = hash * 101 + Asc(Mid(string,i+1,1))
Next
ProcedureReturn hash
EndProcedure
Re: Hard-copie d'une routine pour exécution sans condition p
En prenant ton exemple (calcul modifié), on obtiendrait ce code ci-dessous. Imaginons une directive fictive qui récupère une macro ainsi :
SetSequence(#PB_Seq_Load0, AnHash() )
Ça serait puissant...
(Edité) J'ai corrigé et commenté la routine, et rajouté un exemple.
SetSequence(#PB_Seq_Load0, AnHash() )
Ça serait puissant...
Code : Tout sélectionner
; Entrée(s) :
; EBP : Adresse de la chaîne
; EAX : Souche1
; EDX : Souche2
; Sortie(s) :
; EAX : Valeur de la clé
Macro AnHash()
! DEC EBP ; On prend de l'élan...
AnHash#MacroExpandedCount: ; Ligne de départ
! ADD EAX, EDX ; Addition des souches 1 et 2
! MOV EBX, EAX ; Dans "101n" il y a "1n"
! XOR EDX, EDX ; Ménage total en souche2
! INC EBP ; Lettre suivante
! ROL EAX, 7 ; Dans "101n" il y a "100n"
! ADD EAX, EBX ; Additionne 100n et 1n
! OR DL, BYTE [EBP] ; Lettre mise en souche2
! JNZ l_anhash#MacroExpandedCount ; Charabia
; qui signifie "rebelote en ligne de départ
; si lettre différente du signal de fin de chaîne
EndMacro ; En fait j'ai fait avec %10000001 pas 101.
; (exemple)
Define.L Key
MyString.S = "maClé"
Repeat
*MyString = @MyString
! MOV EBP, [p_MyString]
! XOR EAX, EAX
! XOR EDX, EDX
AnHash()
! MOV [v_Key], EAX
MyString = InputRequester(Hex(Key, #PB_Long), "Contenu de la chaîne (Chaîne vide pour quitter)", MyString)
Until MyString = ""
Re: Hard-copie d'une routine pour exécution sans condition p
@Ollivier
Je ne suis pas certain d'avoir compris, mais ne serait-ce pas çà que tu cherches à faire ?
Je ne suis pas certain d'avoir compris, mais ne serait-ce pas çà que tu cherches à faire ?
Code : Tout sélectionner
Prototype calc(a, b)
Procedure calcA(a, b)
ProcedureReturn a + b
EndProcedure
Procedure calcB(a, b)
ProcedureReturn a - b
EndProcedure
Procedure calcC(a, b)
ProcedureReturn a * b
EndProcedure
Procedure calcD(a, b)
ProcedureReturn a / b
EndProcedure
Define func.calc
func = @calcA() : Debug func(60, 2)
func = @calcB() : Debug func(60, 2)
func = @calcC() : Debug func(60, 2)
func = @calcD() : Debug func(60, 2)
Re: Hard-copie d'une routine pour exécution sans condition p
Non, mais ce que je demande est trop spécifique.
En revanche, il est super ton code. Il signifie pour moi :
"Si tu te plains, n'oublie pas que c'est un plaisir de se servir soi-même, sers-toi, fais-en bon usage"
En revanche, il est super ton code. Il signifie pour moi :
"Si tu te plains, n'oublie pas que c'est un plaisir de se servir soi-même, sers-toi, fais-en bon usage"