Potete quindi provare le fuzionalità del componente acceleratore gb.jit lanciando questo codice con e poi senza la parola "Fast" posta all'inizio del codice medesimo):
Fast
Public Sub Button1_Click()
Dim i As Long
For i = 1 To 1000000000
Next
Print "Funziona !"
End
Lo scopo è verificare quanto tempo sarà impiegherà per stampare in console la frase "Funziona !".
Oppure potete provare quest'altro (sempre con e poi senza la parola "Fast":
Fast
Public Sub Button1_Click()
Dim I As Integer
For I = 1 To 10
Print Test(0.2)
Next
End
Sub Test(X As Float) As Float
Dim Mu As Float = 10.0
Dim Pu, Su As Float
Dim I, J, N As Integer
Dim aPoly As New Float[100]
N = 500000
For I = 0 To N - 1
For J = 0 To 99
Mu = (Mu + 2.0) / 2.0
aPoly[J] = Mu
Next
Su = 0.0
For J = 0 To 99
Su = X * Su + aPoly[J]
Next
Pu += Su
Next
Return Pu
End
Verrà scritta in console una cifra per dieci volte. Se impiegherà pochi secondi, il componente gb.jit funziona, se impiega alcuni minuti il componente non funziona.
Se e quando attivate la parola "Fast" ed il componente gb.jit funziona, noterete la differenza di tempo impiegato ! :o
A parte che non ben capito che prova hai fatto con l'asm, cosa hai usato, come l'hai compilato, e via dicendo...
Ho fatto nuovamente una prova in terminale lanciando con uno script con il motore del codice in asm che conta fino a 1 miliardo:
static unsigned int car asm("raxregistro");
static unsigned int cbr asm("rbxregistro");
int prova(int numero) {
cbr=numero;
asm("mov rbxregistro(%rip),%eax");
asm("ciclo:");
asm("dec %eax");
asm("jne ciclo");
asm("mov %eax,raxregistro(%rip)");
return car;
}
Ha dato mediamente un tempo di 570 millesimi di secondo !
Invece, usando il C puro, sempre lanciato con script da terminale:
#include <stdio.h>
int prova(int numero) {
int i;
for(i = 0; i < numero;i++){
}
return i;
}
In questo caso il risultato è stato: 2091 millisecondi.
Realizzata, invece, la seguente libreria esterna .so, con il primo codice (quello che presenta il motore in asm), ossia:
static unsigned int car asm("raxregistro");
static unsigned int cbr asm("rbxregistro");
int prova(int numero) {
cbr=numero;
asm("mov rbxregistro(%rip),%eax");
asm("ciclo:");
asm("dec %eax");
asm("jne ciclo");
asm("mov %eax,raxregistro(%rip)");
return car;
}
e richiamata con Gambas, passandole il valore di 1 miliardo, si ha un risultato intorno ai 655 millisecondi !
Riguardo alla strana lentezza del codice asm (ma anche con il C come si vede sotto) con Gambas ho posto la questione a Minisini. ;D
Faccio comunque notare che usando Gambas il conteggio da 0 ad 1 miliardo:
* con Fast = ms 966;
* con la libreria esterna scritta in C = ms 2430
* con la libreria esterna con motore asm (ovviamente compilato): ms 655
Quindi, se ho capito bene, hai provato ad eseguire il test con asm e c da terminale (spero)
Sì, da terminale.
per i tempi hai usato time?
Nello script:
tempo1=`date +%s%N | cut -b1-13`
LD_LIBRARY_PATH="." ./demo_use
tempo2=`date +%s%N | cut -b1-13`
sottrazione=$(($tempo2 - $tempo1))
Anche per il C, invece del for... potresti usare lo stesso sistema usato per asm, ovvero con un loop su label...
Visto che ci sei... ;D
Bene, ho fatto, ed ecco i risultati (sempre contando da 0 a 1 miliardo) usando il GOTO all'interno del codice in C puro:
int prova(int numero) {
int i;
zompa:
if (i < numero){
i++;
goto zompa;}
return i;
}
* con script da terminale: ms 1779 (con For invece: ms 2091);
* con libreria .so in Gambas: ms 2011 (con For invece: ms 2430).
Quindi un miglioramento effettivamente c'è !
Riguardo all'esecuzione da gambas, dato che ci sono molte incognite, riguardo al fatto che ci sono chiamate esterne e il passaggio di dati, questo potrebbe influire in maniera notevole sui tempi.
Bisognerà chiamare un esorcista ..... Papa Ceskho I !!! Lui è esperto da quanto so: notare l'antica immagine di Papa Ceskho I eremita che lotta contro il demone che tenta di inserire molte incognite in una libreria esterna .so .