object destruction

[Joey Marino]

[Note: parts of this message were removed to make it a legal post.]

I have a list of objects and after each initialization a few methods are
called on them. They are inherently different but perform the same tasks on
a different set of data. These tasks require ALOT of memory. After the
object has performed its tasks on the data, it is no longer needed and can
be destroyed. This way, its memory space can be used for the next object. I
am having difficulty destroying these objects since there is no destructor
capability in ruby that I can find. I have tried using the garbage collector
like follows:

-------------------------------------------------
include GC
GC.enable
GC.starto

obj = Object1.new
obj.method
obj.finalize

ObjectSpace.garbage_collect

obj2 - Object2.new
obj2.method
obj.finalize

ObjectSpace.garbage_collect

####################

class Object
def initialize
ObjectSpace.define_finalizer(self,self.finalize)
end

def finalize
proc{ |id| puts "finalizing #{id}" }
end
end

class Object1 < Object
def initialize
super
@some_attribute = 1
end
end

class Object2 < Object
def initialize
super
@some_attribute = 2
end
end
_________________________

I am assuming this does not destroy the objects since there is no output and
memory is not released. I am not even getting output of a finalized object
at the end of runtime.
Am I doing something wrong or just missing out a key concept here?

 

[ara howard]

ObjectSpace.define_finalizer(self,self.finalize)

finalizers cannot, in any way , refer to the object being destroyed
otherwise the reference prevents the object from ever being freed.

why not simply do

if fork do
memory_intensive_work
end

Process.wait

this way memory will always be freed.

regards.

a @ http://drawohara.com/

 

[Robert Klemme]

[Note: parts of this message were removed to make it a legal post.]

I have a list of objects and after each initialization a few methods are
called on them. They are inherently different but perform the same tasks on
a different set of data. These tasks require ALOT of memory. After the
object has performed its tasks on the data, it is no longer needed and can
be destroyed. This way, its memory space can be used for the next object. I
am having difficulty destroying these objects since there is no destructor

You do not need to destroy objects explicitly - GC will take care. It's
more important to make sure all resources (such as file handles) are
released and you do not hold longer onto your instances than needed.

capability in ruby that I can find. I have tried using the garbage collector
like follows:

-------------------------------------------------
include GC
GC.enable
GC.starto

obj = Object1.new
obj.method
obj.finalize

ObjectSpace.garbage_collect

obj2 - Object2.new
obj2.method
obj.finalize

ObjectSpace.garbage_collect

####################

class Object
def initialize
ObjectSpace.define_finalizer(self,self.finalize)
end

def finalize
proc{ |id| puts "finalizing #{id}" }
end
end

The code above does not work as intended as Ara has pointed out.

I am assuming this does not destroy the objects since there is no output and
memory is not released. I am not even getting output of a finalized object
at the end of runtime.
Am I doing something wrong or just missing out a key concept here?

Yes, see above.

Kind regards

robert

 

[Robert Dober]

I have a list of objects and after each initialization a few methods are
called on them. They are inherently different but perform the same tasks on
a different set of data. These tasks require ALOT of memory. After the
object has performed its tasks on the data, it is no longer needed and can
be destroyed. This way, its memory space can be used for the next object. I
am having difficulty destroying these objects since there is no destructor
capability in ruby that I can find. I have tried using the garbage collector
like follows:

-------------------------------------------------
include GC
GC.enable
GC.starto

obj = Object1.new
obj.method
obj.finalize

ObjectSpace.garbage_collect

obj2 - Object2.new
obj2.method
obj.finalize

ObjectSpace.garbage_collect

####################

class Object
def initialize
ObjectSpace.define_finalizer(self,self.finalize)
end

def finalize
proc{ |id| puts "finalizing #{id}" }
end
end

class Object1 < Object
def initialize
super
@some_attribute = 1
end
end

class Object2 < Object
def initialize
super
@some_attribute = 2
end
end
_________________________

I am assuming this does not destroy the objects since there is no output and
memory is not released. I am not even getting output of a finalized object
at the end of runtime.
Am I doing something wrong or just missing out a key concept here?

Hopefully this is helpful
destroyed_objects = 0
finalizer = proc { destroyed_objects += 1 } # in this scope no
instance of MyObject is caught in the closure!!!
MyObject = Class::new( Object ) {
define_method :initialize do
ObjectSpace.define_finalizer self, finalizer
end
}
a = Array.new(100_000){ MyObject.new }
GC.start

puts "Finalized objects #{destroyed_objects}"
a.each_index do |idx|
a[idx] = nil
end
puts "Finalized objects #{destroyed_objects}"
GC.start
puts "Finalized objects #{destroyed_objects}"

existing_objects = 0
ObjectSpace.each_object( MyObject ) do
existing_objects += 1
end
puts "Existing objects #{existing_objects}"


Cheers
Robert