PureBasic

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.

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:

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

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 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.

Normalement une map n'est qu'un très grand tableau dynamique.
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

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...

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 = ""

(Edité) J'ai corrigé et commenté la routine, et rajouté un exemple.

@Ollivier

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)

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"

PureBasic

Hard-copie d'une routine pour exécution sans condition préal

Hard-copie d'une routine pour exécution sans condition préal

Re: Hard-copie d'une routine pour exécution sans condition p

Re: Hard-copie d'une routine pour exécution sans condition p

Re: Hard-copie d'une routine pour exécution sans condition p

Re: Hard-copie d'une routine pour exécution sans condition p

Re: Hard-copie d'une routine pour exécution sans condition p