Dear all,

Many thanks for all the great ideas!

As mentioned, I checked all the options (I did not tried the brilliant idea of 'recycle NVO' as well the refactoring since it change my SW architecture, I just wanted to find rapid solution).

All the tries indicate that unfortunately,  PB clean only approx. 30%, it just stay on the heap, as explained.

BTW, I found that irritate and destroy all datastore on the array, is almost equal to call of GarbageCollect ( )

Once again, thanks all for the help, for now, i will implement the 30% release on memory.

Thanks!

John,

Thanks for the reply, I tried that, assign an empty datastore array to the data store array on the NVO that just destroyed, but it did not released any memory:

for ll_ndx = 1 to 3000
 uo_test.test[ll_ndx].reset()
 uo_test.test[ll_ndx].dataobject = ''

 destroy uo_test.test[ll_ndx]
next
uo_test.test = lds_empty
destroy uo_test
GarbageCollect ( )

Actually all the lines after the Next, did not released any memory

I made additional test and tried not to use the loop...next to destroy the data store array, as well, assign the empty data store array did not helped, but i noticed that the GarbageCollect ( ) have similar effect on the memory, if i don't use the for next loop to destroy all datastores

I need to find the way how to release the memory, why power builder keep using so much memory after the Destroy?

Many thanks

Amit

Hi, Amit -

If the "test" instance array of DataStore object references is an unbounded array, then I suggest you also try resetting that instance array with another unbounded (and unused) array of DataStore object references, then destroy the NVO, then perform GarbageCollect().

I would hope/expect nearly all of the memory utilized for the array would then be freed.

For example:

DataStore lds_empty_array[]

   .
   .
   .
   destroy uo_test.test[ll_ndx]
Next
uo_test.test = lds_empty_array
Destroy uo_test
GarbageCollect()

Best regards, John

Thanks Chris, for the answer.

Gave it a try with and without the key on the PB.INI looks pretty much the same:

Memory consumption: 

with INI key:
start: 25
Pick: 147.8
End: 115.2

Without key:
Start: 25.1
Pick: 147.9
End: 115.0

i was doing a similar process that used arrays of datastores.

• fix 1 was to use garbagecollect.  runs out of memory easily.  If you are not actually running out of memory, then just keeping it this way is an option.
• fix 2 was to create my own recycle nvo to create/destroy the datastores.  instead of destroying the arrays of datastores, it resets them and saves them in the nvo and then uses them again rather than create new ones.  this worked well (and was faster) however that only works if you are doing a process with large arrays in a loop.  easy to implement.  still ran out of memory on a very very large process it was running.  the nvo has 3 functions - recycle of a single datastore, recycle for an array of datastores (these reset the datastores and stores them on a heap), and a create that returns a datastore either off the datastore heap, or if none, creates a new datastore.
• refactoring:   I restructured things into a nvo with just 2 datastores. the main datastore was basically my array of datastores - i had an extra field/column that tracked which virtual datastore it was (index of the array).  The 2nd datastore tracked each array and some meta information.    It is at least 10x faster than the nvo recycle, and uses a fraction of the memory.  lot more work to do as it ended up being pretty much being an in-memory database written in powerbuilder.

Hi Amit;

  Have you tried a custom PB.INI with the following setting ...

[Data Window]

UseHwnd=no

Regards ... Chris