FiveTech Support Forums

Hola foro,
Basado en sus experiencias, ¿cuáles son los procedimientos a seguir para conseguir la velocidad máxima del EXE generado por Harbour + FWH?
Por ejemplo, estoy pensando en lo siguiente:
1. Sustituir código Harbour por código C (en funciones que pueden ser, o deberían ser, optimizadas mediante el uso de código C).
2. Usar variables locales en lugar de variables globales.
3. Para bases de datos usar ADS/ADT en lugar de DBF (no estoy seguro cual sera mas rapido).
4. Uso de tablas HASH en lugar de arrays
5. Uso de los bloques de código y funciones eval()

Algunas preguntas:
Fivetechsoft o algun compañero del foro han hecho pruebas comparando las velocidades de EXE de harbour vs. EXE de lenguaje C?
Seria posible llamar codigo "assembler" desde Harbour?
Es el P-Code, generado por Harbour, una gran limitación para obtener EXE que corran rapido, comparable a los EXE generados por el lenguage C?
Se pudiera anular (o disminuir notablemente) , esta limitación, llamando a funciones escritas en lenguaje C (o assembler) desde el codigo Harbour?

Saludos,

George

George,

La velocidad del .exe depende MUCHO del compilador C que utilices. Te hablo sobre lo que he leído en el foro de Harbour.

Saludos

George...

Si, lo mas problabe es que tengas un optimizacion de 0.00000001 segundo... que lo vas a perder 1.000.000 de veces en el siguiente Do While.. que no esta optimizado.

Lo mejor cuando trabajas con compiladores, especialmente con aquellos que generan codigo C puro y duro, es la optimizacion del procedimiento o funcion que ejecuta ciclos, ahi es donde los problemas aparecen, no en la ejecucion lineal de tu programa.

1.-Evita lo que mas puedas las escrituras y lecturas a disco.
2.-Optimiza al maximo los ciclos. (Do While...End / For...Next etc)
3.-Controla al maximo las excepciones (calculos o recuperaciones de divisiones por cero por ej) Aqui en el foro habia un post muy interesante sobre eso.
4.-Cuida el flujo de tu programa, evita pasos innecesarios, respuestas del usuario.
5.-Menos es mas
6.-Crea consultas inteligentes (en el caso de SQL)
7.-Crea indices de acuerdo a lo que vas a necesitar. Con la seguridad de usarlos y de que te permitan mejorar la respuesta de la DB.

Con eso tienes mas que suficiente para "acelerar" tu exe.
Los internals de C, pueden mejorar tu velocidad, pero en cuanto.. casi imperceptible para el usuario.

Saludos desde Chile
Adolfo

Adolfo,
Muy clara tu respuesta.
Estoy de acuerdo contigo en tus sugerencias y sobretodo en que las instrucciones tipo "loops" y de toma de decisiones nos hacen perder en mucho lo poco que gananos.

Por otro lado imaginate un escenario donde usemos unicamente operaciones bitwise, no "for-next" , no "do while - enddo", no "if-else-endif"
Lo que me gustaria saber es como las operaciones "bitwise" se verian afectadas por P-Code.
Bueno, creo que tendria yo mismo que hacer estas pruebas

Saludos,

George

Gracias thefull.
Ire tomando notas de todos los "tips".

Saludos,

George

Optimización IV - Walter Negro
605 palabras totales en este texto (24 Lecturas) Versión Imprimible
<modules.php?name=Sections&op=printpage&artid=13>
------------------------------------------------------------------------

Comando With Object

WITH OBJECT ... END

Esta es otro de los nuevos comandos de xHarbour que permiten ahorrar
tiempo en tareas repetitivas.

Este comando realiza una cache de un objeto y junto con algunos PCODEs
permite acelerar el acceso a metodos y datas de un objeto.

La sintáxis más común es:

WITH OBJECT oGet
...:Name := "Nombre"
...:VarPut( "Walter" )
END

También se puede usar la función HB_SetWith().
Al pasarle el dato, lo guarda en la cache, y al llamar a esta función
sin parámetros, lo quita.
Para acceder al objeto en el cache se usa la función HB_QWith().
Hay que destacar, que tanto HB_SetWith() como HB_QWith() no son
funciones reales, sino que en tiempo de compilación se transforman en
los mismos PCODEs usados en WITH OBJECT.

HB_SetWith( oGet )
...HB_QWith():Name := "Nombre"
...HB_QWith():VarPut( "Walter" )
HB_SetWith()

Este código genera el mismo PCODE que el ejemplo anterior.

Es posible usar HB_QWith() dentro de WITH OBJECT, pero no es posible
usar la sintáxis reducida (:Name), con HB_SetWith().

WITH OBJECT oGet
...oOtro := HB_QWith() // Correcto
END

HB_SetWith( oGet )
...? :Name // Error
HB_SetWith()

También es posible usar el WITH OBJECT dentro de una macro.

WITH OBJECT oGet
...&(":Name := 'Nombre'")
...&(":VarPut( 'Walter' )")
END

Y el HB_SetWith() también en una macro

&("HB_SetWith( oGet )")
...HB_QWith():Name := "Nombre"
...HB_QWith():VarPut( "Walter" )
&("HB_SetWith()")

WITH OBJECT y HB_SetWith() soportan hasta 32 niveles de anidamiento.
Cada END y cada HB_SetWith() sin parámetros o con parámetro NIL,
"desanidan" un nivel.

Aquí hay un ejemplo de los usos, tomado desde el CVS de xHarbour
xharbour estswith.prg
<http://cvs.sourceforge.net/viewcvs.py/*checkout*/xharbour/xharbour/tests/with.prg?rev=1.3>

Fuente: Blog "Cosa de Negro" por Walter Negro

Optimización V - Walter Negro
1107 palabras totales en este texto (31 Lecturas) Versión Imprimible
<modules.php?name=Sections&op=printpage&artid=14>
------------------------------------------------------------------------

FOR EACH
Acelerando los recorridos sobre un array.

Es muy común que tengamos que recorrer arrays para hacer diferentes
tipos de tareas, buscar, imprimir, copiar, modificar masivamente, etc.

Además de poder hacerlo con un AEVAL(), podemos usar un bucle FOR-NEXT o
un bucle DO WHILE-ENDDO.

En xHarbour se agrega un nuevo bucle exclusivo para la tarea de recorrer
arrays, el FOR EACH-NEXT.

Veremos más adelante que este bucle tiene algunas particularidades muy
interesantes que son su punto fuerte y razón de ser.

La sintáxis de uso es la siguiente:

FOR EACH _var_ IN _array_
[LOOP]
[HB_ENUMINDEX()]
[EXIT]
NEXT

_array_ puede ser cualquier expresión que retorne un array, un objeto o
una cadena de caracteres.

_var_ puede ser cualquier variable previamente declarada, pero es
recomendable que sea una variable local.
Esta variable va a apuntar a una posición del array, comenzando por la
primera posición.

El FOR EACH va a recorrer todo el array completamente, a menos que se
fuerze la salida anticipada con el comando EXIT.
También es posible usar el comando LOOP de la misma forma que se usa en
el comando FOR-NEXT.

La pseudo-función HB_ENUMINDEX() retorna el número de posición del array
que se está procesando en ese momento.


Funcionamiento:

El comando FOR EACH recorre todo el array _array_ y en cada iteración
guarda en la variable _var_ una referencia a la posición actual del array.

Al finalizar el bucle FOR EACH, la variable _var_ queda con valor NIL,
asi que si necesitamos preservar el valor de dicha variable para usarlo
fuera del bucle, debemos copiarla a otra variable antes de salir.


Qué es eso de que la variable es una referencia ?

La variable del FOR EACH funciona de forma similar a los parámetros de
una función que reciben los datos por referencia.

Es como si fuera algo así: (la siguiente sintáxis es de ejemplo, no es
válida)

_var_ := @_array_[n]


Qué ventajas tiene ?

La ventaja de tener en _var_ una referencia a la posición del array es
que para modificar la posición del array, solo es necesario asignar el
dato que queremos a la variable _var_, y lo que realmente estaremos
haciendo, es modificar el contenido del array.


Donde aplicarlo?

Este comando está especialmente diseñado para recorrer arrays
rápidamente y poder usar o modificar su contenido también de la forma
más rápida posible.

Todas los bucles que recorren un array pueden beneficiarse con el uso de
For each.
Cualquier construcción del tipo:

for n:=1 to Len(aArray)
...
next

puede ser convertida a

for each x in aArray
...
next


Los que usan Fivewin, encontrarán muchas construcciones que pueden
optimizarse usando FOR EACH, en muchos de los fuentes del sistema.
También en otras clases como TSBrowse el desempeño mejora notablemente
al usar FOR EACH.

Encontrarán ejemplos y pruebas aquí: foreach.prg
<http://cvs.sourceforge.net/viewcvs.py/*checkout*/xharbour/xharbour/tests/foreach.prg?rev=1.1>
objlist.prg
<http://cvs.sourceforge.net/viewcvs.py/*checkout*/xharbour/xharbour/tests/objlist.prg?rev=1.1>
ivarref.prg
<http://cvs.sourceforge.net/viewcvs.py/*checkout*/xharbour/xharbour/tests/ivarref.prg?rev=1.3>

Los siguientes ejemplos producen el mismo resultado, pero con tiempos de
ejecución diferentes.
El for-next y el aeval, tardan aproximadamente lo mismo, pero el for
each demora la mitad de tiempo.

aArray := arrray(500000)
nLen := Len(aArray)

for n:=1 to nLen
...aArray[n] := n
next

for n:=1 to nLen
...nSum += aArrray[n]
next

------------------------

aeval( aArray, {|a,n| aArray[n]:=n} )
aeval( aArray, {|a,n| nSum += a} )

------------------------

for each x in aArray
...x := HB_EnumIndex()
next

for each x in aArray
...nSum += x
next

Fuente: Blog "Cosa de Negro" por Walter Negro

thefull wrote:

Code (fw): Select all Collapse

aArray := Array( 1000000 )
For x := 1 to len( aArray )   // MALO MALISIMO

for x = 1 to len( aArray )
   if << Aquí la condicion deseada >>
      adel( aArray , x , .T. )
   endif
next x

jm;
Si el array es de muchos registros, como tu sample, te sugiero usar FOR EACH (la explicación en Optimizacion IV).

Saludos

MarioG wrote:Si el array es de muchos registros, como tu sample, te sugiero usar FOR EACH (la explicación en Optimizacion IV).

function main()
local nSegundos , x , n:=0 , nSum:=0 , aArray := array(10000000) , nLen := Len(aArray)
*---
nSegundos:=seconds()
for n:=1 to nLen
   aArray[n] := n
next
for n:=1 to nLen
   nSum += aArray[n]
next
nSegundos:=seconds()-nSegundos
? nSegundos
*---
nSegundos:=seconds()
aeval( aArray, {|a,n| aArray[n]:=n} )
aeval( aArray, {|a,n| nSum += a} )
nSegundos:=seconds()-nSegundos
? nSegundos
*---
nSegundos:=seconds()
for each x in aArray
   x := HB_EnumIndex()
next
for each x in aArray
   nSum += x
next
nSegundos:=seconds()-nSegundos
? nSegundos
*---
return nil