Liberar memoria ao fechar Formulario com objeto criado

Mensagem por **JoséQuintas** » 28 Set 2022 09:41

Num resumo simples: sei lá qual opção tem a ver com Harbour ou com sistema operacional.

Mensagem por **JoséQuintas** » 28 Set 2022 10:10

Este faz mais sentido, HB_MEM_VM, espaço pra máquina virtual do Harbour:

#include "hbmemory.ch"
#define MEM_TEST HB_MEM_VM
#pragma -w0

PROCEDURE Main

   LOCAL nCont

   SetMode(40,100)
   CLS
   ? "Main: " + Ltrim( Str( Memory(MEM_TEST) ) )
   FOR nCont = 1 TO 3
      ?
      ? "Main before subtest: " + Ltrim( Str( Memory(MEM_TEST) ) )
      SubTest()
      ? "Main after subtest: " + Ltrim( Str( Memory(MEM_TEST) ) )
   NEXT
   ?
   ? "Main after for/next: " + Ltrim( Str( Memory(MEM_TEST) ) )

   Inkey(0)

   RETURN

FUNCTION SubTest()

   LOCAL aList, F

   aList := {}
   ? "Before array: " + Ltrim( Str( Memory(MEM_TEST) ) )
   FOR F := 1 TO 1000000
      AAdd( aList, { F, Hb_RandomInt(99) , hb_RandomInt(99), Date() - F, F % 2 == 0, hb_RandomInt(99), F * 10   } )
   NEXT
   ? "After array: " + Ltrim( Str( Memory(MEM_TEST) ) )
   aList := {}
   ? "Empty List: " + Ltrim( Str( Memory(MEM_TEST) ) )
   aList := Nil
   ? "Nil: " + Ltrim( Str( Memory(MEM_TEST )) )

   RETURN Nil

Só que, se for isso mesmo, limpar o array com Nil libera mais memória.
Isso DENTRO DA ROTINA, porque sem o Nil, sair da rotina libera memória.

Considerando que esse teste seja válido.....
Poderá ser problema variáveis PUBLIC e STATIC contendo array, porque nunca são eliminadas.

Só surgiram mais dúvidas:
E se esse espaço só liberado com NIL se referir a uma classe com objeto Windows por exemplo, será que o objeto fica preso ocupando memória ?
Será que atribuir Nil a tudo que for destruído será melhor ? isso seria um atraso na programação....

De um modo geral, cheguei a conclusão de que não entendi bost. nenhuma, e não faço idéia de como avaliar isso.
E muito menos se isso tem a ver com o meu problema não resolvido, e se tem a ver com o problema do post.
Nem sei se é pra ficar colocando NIL em todo fonte, coisa que inclusive a compilação -ws -es2 vai impedir.

Mensagem por **JoséQuintas** » 28 Set 2022 10:20

E a cada execução um valor ligeiramente diferente, pra confundir tudo.
Nesse caso o mesmo EXE rodando em várias janelas, ao mesmo tempo.

Mensagem por **JoséQuintas** » 28 Set 2022 11:36

Código: Selecionar todos


#include "hbmemory.ch"
#define MEM_TEST HB_MEM_VM
#pragma -w0

PROCEDURE Main

   LOCAL nCont, nM

   SetMode(40,100)
   CLS
   nM := Memory( MEM_TEST )
   ? "Main: " + Ltrim( Str( nM ) )
   FOR nCont = 1 TO 4
      ?
      ? "Main before subtest: " + ShowMemory( nM )
      SubTest( nM )
      ? "Main after subtest: " + ShowMemory( nM )
   NEXT
   ?
   ? "Main after for/next: " + ShowMemory( nM )

   Inkey(0)

   RETURN

FUNCTION SubTest( nM )

   LOCAL aList := {}, F

   ? "Before array: " + ShowMemory( nM )
   FOR F := 1 TO 1000000
      AAdd( aList, { F, Hb_RandomInt(99) , hb_RandomInt(99), Date() - F, F % 2 == 0, hb_RandomInt(99), F * 10   } )
   NEXT
   ? "After array: " + ShowMemory( nM )
   StoreValue( @aList, {} )
   ? "Empty List: " + ShowMemory( nM )
   StoreValue( @aList, {}, .T. )
   ? "Nil: " + ShowMemory( nM )

   RETURN Nil

FUNCTION StoreValue( xVar, xValue, lNil )

   IF lNil != Nil .AND. lNil
      xVar := Nil
   ENDIF
   xVar := xValue

   RETURN Nil

FUNCTION ShowMemory( nM )

   RETURN Ltrim( Str( nM - Memory( MEM_TEST ) ) ) + " in use"

Mais interessante, pra bost. nenhuma
O mesmo EXE rodando em 3 janelas.
Em duas janelas, o Nil parece ter feito diferença.
Mas se o Nil faz diferença, porque não fez nas 3 janelas ?

Mensagem por **JoséQuintas** » 28 Set 2022 11:43

Comentário:

Se tivesse acontecido de fazer 2 testes, com os dois últimos resultados, a conclusão seria o NIL fazer efeito.

Mas como num dos testes não fez diferença.... não dá pra afirmar isso.

Muito doido isso.

Baseado em um teste, poderia sair alterando o aplicativo pra Nil.
Mas baseado nos 3 testes, Nil não faz diferença nenhuma.

Mensagem por **JoséQuintas** » 28 Set 2022 14:15

Aproveito pra acrescentar mais uma:

Será que multithread ajudaria nisso ?
Será que a memória seria liberada por thread ?
E como medir essa memória, já que nos testes ficou confuso ?

Mensagem por **JoséQuintas** » 28 Set 2022 14:23

Pelo gerenciador de tarefas????

captura começando a criar o array

captura no final, primeiro teste

captura no final, segundo teste

Tamos fud....
Totalmente doido o troço.
Alguém entendeu alguma coisa ?? MESMO EXE.

Mensagem por **JoséQuintas** » 28 Set 2022 14:32

E que tal assim ?
Rodar 4 vezes o programa ao mesmo tempo, e num deles ocupar 500 vezes mais memória !!!
Notem que nos 4 o processamento já havia encerrado, portanto, todos na mesma situação, e deveriam consumir a mesma quantidade de memória.

Mensagem por **JoséQuintas** » 28 Set 2022 14:38

Importante, talvez:

Notem que a medida no Harbour é bem próxima, pra não dizer igual, à do gerenciador de tarefas.

carlos_dornelas · Mensagem por **carlos_dornelas** » 28 Set 2022 14:41

Pessoal, comigo aconteceu algo parecido e que tem haver com o consumo de memória. Numa determinada rotina chegava ao ponto de travar completamente o programa.

Eu utilizo o xharbour .99.60 ainda nessa tal rotina e acabei solucionando o problema da seguinte forma:

Antes era utilizado o seguinte para popular uma matriz:

FOR X=1 TO 1000
DECLARE XLISTA[3]
FOR G=1 TO 3
Xlista[G]= X+G
NEXT
NEXT

Depois, para solucionar o problema de consumo de memória, fiz:
FOR X=1 TO 1000
XLISTA:={}
FOR G=1 TO 3
aadd(xlista,X+G)
NEXT
NEXT

Ou seja, o DECLARE, a cada vez parece que alocava mais memória para a mesma matriz...

[]s

Mensagem por **JoséQuintas** » 28 Set 2022 14:55

Antes eu achava que poderia ser algo assim mas.....
trata-se do MESMO EXE COM MESMOS FONTES, cada hora um resultado diferente.

2MB pra 1GB.... sendo tudo exatamente igual.... inexplicável.

Mensagem por **JoséQuintas** » 28 Set 2022 16:06

Resta fazer teste no Windows 7, por exemplo, pra testar o sistema operacional.

carlaoonline · Mensagem por **carlaoonline** » 29 Set 2022 09:26

Bom dia!

JoséQuintas escreveu:Nota: O copiar/colar do console no windows 10 tá uma bost... vira um linguição.

: Copiar Colar em Modo Console

Para NÃO ficar linguição tem que DESmarcar essa caixa.

Habilitar/desabilitar essas caixas geram padrões diferentes no copiar/colar em modo console, dependendo o caso ajuda OU atrapalha.

Mensagem por **JoséQuintas** » 29 Set 2022 12:52

No Harbour-users apareceu outro usuário que notou essa diferença no uso de memória.
Também reparei que o número de threads é diferente, chegou a 4 threads, sendo que só está usando UMA.
O mesmo usuário no harbour-users comentou que notou isso também.
O usuário está usando WINDOWS 11.

NÃO SEI se o problema da minigui tem a ver com esse.

É um problema gravíssimo, e não temos acesso pra resolver, ainda mais se for problema do sistema operacional.

E se for só com programa 32 bits..... provavelmente a solução da Microsoft será acabar com 32 bits.

carlaoonline · Mensagem por **carlaoonline** » 29 Set 2022 16:12

Compilei o programa abaixo em dois formatos:
Harbour 3.2 + Bcc 5.8 ( Usando #include "MiniGui.ch" )
E
Harbour 3.2 + MinGW 7.3 ( Usando #include "Hmg.ch" )

Código: Selecionar todos

#include "MiniGui.ch"
//#include "Hmg.ch"

//---------------------------------------------------------
Function MAIN
//---------------------------------------------------------
Public nMemoriaInicial:=ltrim(transform(Memory(0),"999 999 999 999 999"))
Public cMensagem:="Data: "+Dtoc(date())+" Hora: "+Time()+ "   Mem. Inicial antes dos Forms -> "+nMemoriaInicial+" Kb."+Hb_Eol()
Public aLista:={}, lineFeed:=Hb_Eol()  // +Hb_Eol()


DEFINE WINDOW Form_Main;
   TITLE "Form_Main" MAIN WIDTH 850 HEIGHT 300 ;
   ON GOTFOCUS Atualiza_botao() 
   @ 145,10 LABEL Lbl_1 WIDTH 170  HEIGHT 25 SIZE 12 VALUE "Quant. de elementos"
   @ 145, 185 textBox Get_1 WIDTH 100  HEIGHT 25 value "1000000" On Enter (Form_Main.btn01.action)
   @ 135,320 button btn01 caption "Gerar array  -  (Memoria Inicial = "+nMemoriaInicial +"Kb.)" Width 480 Height 50 action CriaArray()
END WINDOW

ON KEY ESCAPE of Form_Main ACTION Form_Main.Release
ACTIVATE WINDOW Form_Main

RETURN


//---------------------------------------------------------
Function CriaArray()
//---------------------------------------------------------
Local cForm:="FORM_"+ALLTRIM(SUBST(Arq_Temporario(),3,10))
Local F, nVoltas:=3, nMemoria

DECLARE WINDOW &(cForm) 

DEFINE WINDOW &cForm width 740 height 650 Title "cForm = "+cForm;
       ON INIT Atualiza_Botao();
       ON RELEASE Atualiza_Botao()
       @ 15, 20 LABEL Lbl_Memoria FontColor BLUE WIDTH 720  HEIGHT 500 SIZE 12;
       VALUE cMensagem
END WINDOW

cMensagem:=cMensagem+"Memoria apos criacao do Form_Main e do "+cForm+"  -> "+ltrim(transform(Memory(0),"999 999 999 999 999"))+" Kb."+Hb_Eol()

FOR F=1 TO  nVoltas
    Preenche_Array(.T., cForm, nVoltas)   // .T. = Preenche     .F. = Zera ela
    Preenche_Array(.F., cForm, nVoltas)   // .T. = Preenche     .F. = Zera ela
NEXT

&(cForm).Lbl_Memoria.value:=GetProperty(cForm,"Lbl_Memoria","Value")+LineFeed+ ;
            "Antes da execucao de 'hb_gcAll()'   -> Memoria = "+ltrim(transform(Memory(0),"999 999 999 999 999"))+" Kb."

DO EVENTS
hb_gcAll()
DO EVENTS
wApi_Sleep(500)       


nMemoria=Memory(0)

&(cForm).Lbl_Memoria.value:=GetProperty(cForm,"Lbl_Memoria","Value")+LineFeed+ ;
            "Apos a execucao de  'hb_gcAll()'   -> Memoria = "+ltrim(transform(Memory(0),"999 999 999 999 999"))+" Kb."


// ATREPL("abc",cVariavel,"123")   Troca os abc por 123 na variavel mencionada

&(cForm).Lbl_Memoria.value:=GetProperty(cForm,"Lbl_Memoria","Value")+LineFeed+Hb_Eol()+ ;
            "Diferenca de memoria = "+ltrim(transform(  Val(ATREPL(" ",nMemoriaInicial,""))-nMemoria   ,"999 999 999 999 999"))+" Kb."+Hb_Eol()+;
            "Compilador : "+Hb_Compiler()+Hb_Eol()+;
            "Harbour    : "+Version()+Hb_Eol()+;
            "Sistema    : "+Os() +" - "+IF(hb_osIs64bit(),"64 Bits","32 Bits")

cMensagem="Data: "+Dtoc(date())+" Hora: "+Time()+ "   Mem. Inicial antes dos Forms -> "+nMemoriaInicial+" Kb."+Hb_Eol()

@ 520,420 button btn02 parent &cForm caption "Copiar p/ ClipBoard" Width 120 Height 30 action System.Clipboard := GetProperty(cForm,"Lbl_Memoria","Value")   // CopyToClipboard(GetProperty(cForm,"Lbl_Memoria","Value"))

ON KEY ESCAPE OF &cForm ACTION &(cForm).Release
ACTIVATE WINDOW &cForm
RETURN 
//---------------------------------------------------------


//---------------------------------------------------------
Function Preenche_Array(lPreencher, cForm, nVoltas)
//---------------------------------------------------------
Static nVezes:=1, cTimeInicial
Local cString:="", nQuantElem:= Val(GetProperty("Form_Main","Get_1","value"))

IF lPreencher
   Atualiza_Botao()
   WAIT WINDOW "Adicionando "+transform(nQuantElem, '99 999 999 999')+" elementos em aLista{}. Etapa "+Alltrim(str(nVezes))+"/"+alltrim(str(nVoltas)) NOWAIT
   cString=alltrim(Str(nVezes))+" - Antes de criar aLista com "+transform(nQuantElem, '99 999 999 999')+" elementos:  Memoria="+ltrim(transform(Memory(0),"999 999 999 999 999"))+" Kb."
   cMensagem=cMensagem+LineFeed+cString
   cTimeInicial=Time()
   FOR F := 1 TO nQuantElem
       AAdd( aLista, { F, Hb_RandomInt(99) , RandStr( 10 ), Date() - F, if( F % 2 == 0, .T., .F. ), RandStr( 10 ), F*10   } )
   NEXT
   WAIT CLEAR
   cString=alltrim(Str(nVezes))+" - APOS criar aLista com "+transform(nQuantElem, '99 999 999 999')+" elementos:  Memoria="+ltrim(transform(Memory(0),"999 999 999 999 999"))+" Kb."
   cMensagem=cMensagem+LineFeed+cString+"   Tempo: "+ElapTime(cTimeInicial,Time())
 ELSE
   Release aLista
   Public aLista:={}
   cString=alltrim(Str(nVezes))+" - Apos Release, e nova criacao de 'aLista' com 'Zero' elementos:  Memoria="+ltrim(transform(Memory(0),"999 999 999 999 999"))+" Kb."
   cMensagem=cMensagem+LineFeed+cString+Hb_Eol()
   nVezes=IF(nVezes=3,1,nVezes+1)
ENDIF
&(cForm).Lbl_Memoria.value:=cMensagem+Hb_Eol()
Atualiza_Botao()
Return
//---------------------------------------------------------


//---------------------------------------------------------
Function Atualiza_Botao()
//---------------------------------------------------------
SetProperty("Form_Main","btn01","caption","Gerar Array    ( Memoria Inicial = "+nMemoriaInicial+"    Memoria Atual = "+ltrim(transform(Memory(0),"999 999 999 999 999"))+" Kb.")
Return NIL
//---------------------------------------------------------


//---------------------------------------------------------
FUNCTION RandStr( nLen )
//---------------------------------------------------------
LOCAL cSet := "qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM"
LOCAL cPass := ""
LOCAL i

FOR i := 1 TO nLen
    cPass += SubStr( cSet, Random( 52 ), 1 )
NEXT

RETURN cPass
//-----------------------------------------------------------


//-----------------------------------------------------------
FUNCTION Arq_Temporario()    // Gera nome de arquivo temporario
//-----------------------------------------------------------
RETURN "Y_"+ALLTRIM(RIGHT(NETNAME(),2))+ ALLTRIM(   STR(INT(SECOND()))  )
//-----------------------------------------------------------

No Windows Server 2012 deu o mesmo resultado em ambas compilações, Criando os Arrays NOUTRO MUNDO, POIS NÃO ACUSA OCUPAÇÃO DE MEMÓRIA com a criação do array de 1.000.000 de elementos, sendo que não deve ter sido em disco a julgar pelo tempo e que este PC não possui SSD.

: Teste de memória no Windows Server 2012 r2 (Não acusa utilização de memória)

Num Windows 10 64 bits com 3 Giga de memória , Tanto com Bcc 5.8 quanto com MinGW 7.3 deram ocupação semelhante de memória após zerar os arrays. A diferença é que com MinGW demorou quase 4 VEZES mais tempo para executar o mesmo processo (fiz 2 vezes pra ter certeza)

Resultado com Bcc

Código: Selecionar todos

Data: 09/28/22 Hora: 17:42:50   Mem. Inicial antes dos Forms -> 1 311 260 Kb.
Memoria apos criacao do Form_Main e do FORM_5063781  -> 1 313 504 Kb.

1 - Antes de criar aLista com      5 000 000 elementos:  Memoria=1 313 504 Kb.
1 - APOS criar aLista com      5 000 000 elementos:  Memoria=212 916 Kb.   Tempo: 00:01:40
1 - Apos Release, e nova criacao de 'aLista' com 'Zero' elementos:  Memoria=327 892 Kb.

2 - Antes de criar aLista com      5 000 000 elementos:  Memoria=328 660 Kb.
2 - APOS criar aLista com      5 000 000 elementos:  Memoria=293 012 Kb.   Tempo: 00:01:37
2 - Apos Release, e nova criacao de 'aLista' com 'Zero' elementos:  Memoria=406 432 Kb.

3 - Antes de criar aLista com      5 000 000 elementos:  Memoria=660 088 Kb.
3 - APOS criar aLista com      5 000 000 elementos:  Memoria=497 992 Kb.   Tempo: 00:01:38
3 - Apos Release, e nova criacao de 'aLista' com 'Zero' elementos:  Memoria=625 016 Kb.


Antes da execucao de 'hb_gcAll()'   -> Memoria = 625 016 Kb.
Apos a execucao de  'hb_gcAll()'   -> Memoria = 612 492 Kb.

Diferenca de memoria = 698 768 Kb.
Compilador : Borland C++ 5.8.2 (32-bit)
Harbour    : Harbour 3.2.0dev (r2104281802)
Sistema    : Windows 10 10.0 - 64 Bits

Resultado com MinGW

Código: Selecionar todos

Data: 09/29/22 Hora: 07:53:22   Mem. Inicial antes dos Forms -> 1 175 912 Kb.
Memoria apos criacao do Form_Main e do FORM_5028410  -> 1 170 888 Kb.

1 - Antes de criar aLista com      5 000 000 elementos:  Memoria=1 170 888 Kb.
1 - APOS criar aLista com      5 000 000 elementos:  Memoria=112 580 Kb.   Tempo: 00:07:16
1 - Apos Release, e nova criacao de 'aLista' com 'Zero' elementos:  Memoria=718 160 Kb.

2 - Antes de criar aLista com      5 000 000 elementos:  Memoria=729 056 Kb.
2 - APOS criar aLista com      5 000 000 elementos:  Memoria=199 056 Kb.   Tempo: 00:07:03
2 - Apos Release, e nova criacao de 'aLista' com 'Zero' elementos:  Memoria=783 232 Kb.

3 - Antes de criar aLista com      5 000 000 elementos:  Memoria=815 904 Kb.
3 - APOS criar aLista com      5 000 000 elementos:  Memoria=187 820 Kb.   Tempo: 00:07:00
3 - Apos Release, e nova criacao de 'aLista' com 'Zero' elementos:  Memoria=667 132 Kb.


Antes da execucao de 'hb_gcAll()'   -> Memoria = 667 724 Kb.
Apos a execucao de  'hb_gcAll()'   -> Memoria = 669 692 Kb.

Diferenca de memoria = 506 412 Kb.
Compilador : MinGW GNU C 7.3 (32-bit)
Harbour    : Harbour 3.2.0dev (r2011030937)
Sistema    : Windows 10 10.0 - 64 Bits