Hi Nikhil,
Thank you for your help.
So may I consider this in this way:
1) Objects who is referenced by any Handle will not be disposed.
2) Objects referenced by Local<>s will be add to a list hold by the
HandleScope object, and while disposing HandleScope object, it will check
all objects in this list whether it should be disposed. And this design is
for objects whose lifecycle is very short to be released immediately to
improve the performance and memory usage.
3) Persistent handles will not add the object to the list of HandleScope,
and the lifecycle of that object is relatively longer, and frequently
disposing HandleScope objects will not check these objects, and as a
result, it will improve performance.
Am I right?
Thank you!
Best Regards.
On Thu, May 31, 2012 at 4:20 PM, Nikhil Marathe <nsm.nik...@gmail.com>wrote:
> On Thu, May 31, 2012 at 1:05 PM, Tony Huang <cnwz...@gmail.com> wrote:
> > According to the document, Local<> handles will be disposed at that time,
> > but let's look at the following code snip:
> > void SayHello() {
> > HandleScope scope;
> >
> > Local<Value> someValue = GetValue();
> > }
> > In this case, at the end of SayHello, the object someValue as well as
> scope
> > object will be disposed. It's C++ scope behavior, so what else will be
> > disposed while disposing the scope object? Is the object referenced by
> > "someValue"?
> >
>
> Hi Tony,
>
> v8 objects referenced *only* by Local<> handles get GCed when all
> local handles go
> out of scope. In this case, if the value returned by GetValue() has
> only someValue referring
> to it, it will get GCed the next time the GC runs after SayHello() is
> done executing.
>
> Every creation of a HandleScope adds a HandleScope to the top of the
> scope stack. When
> new Local<>s are created, they 'belong' to the top scope. When 'scope'
> goes out of C++ scope,
> then it's destructor is invoked, from where v8 will decide which
> Local<>s to delete.
>
> An object referenced by one (or more) Persistent<> handles will not be
> GCed until explicitly told
> to do so. This is useful for preserving JS callbacks across C++
> function boundaries and so on.
>
> I hope that helps.
>
> Best,
> Nikhil
>
--
------------------------------------------------------
Tony Huang cnwz...@gmail.com
wz...@hotmail.com
wz...@vip.sina.com
