>You could read from the heap on a concurrent thread but there is no 
synchronization when writing to the heap from the main thread

My current thinking is something like this - ie I'd be blocking in the main 
thread until the serialization is done 
in main thread:
 handles[] = getHandlesToSerialize(); 
 results[] = []
 threads[] = spawnThreads(N, handles, results);

 join(threads);


One problem though is that I can't use the Handles directly in other 
threads as they'd require access to the Isolate and thus would require 
synchronization to enter/lock the Isolate. So the only option, as you 
alluded to, is to copy off-heap then serialize, which I need to test to see 
if it would result into any perf benefits due to the high setup cost for 
going multi-threaded. Maybe I'll find a way to actually keep pointers to 
underlying data rather than actually copy - will report here what I find. 




On Thursday, May 16, 2019 at 6:18:06 AM UTC-7, Peter Marshall wrote:
>
> On Wednesday, May 15, 2019 at 9:09:18 PM UTC+2, Ledion Bitincka wrote:
>>
>> Thanks! 
>>
>> > While I understand that this is tempting, please be aware that only one 
>> thread may be active in one Isolate at any given time.
>> I was hoping that there could be multiple threads that had "read-only" 
>> access to an Isolate's heap - I was looking through how ValueSerializer 
>> works 
>> and now I understand there's no such thing as "read-only" given the 
>> getter/setter functions. However, wondering if this would be possible for 
>> simple objects (key/value) and bail for more complex ones. Any other 
>> suggestions for how that work can be parallelized, is it even possible? 
>> (this is custom serialization, not JSON)
>>
>>>
>>> You could read from the heap on a concurrent thread but there is no 
> synchronization when writing to the heap from the main thread, so there's 
> no guarantee that what you are reading is not being concurrently written 
> e.g. when it is being allocated, when it is modified by user JS code or 
> when the GC moves it.
>
> If the serialization work itself was particularly expensive (e.g. the 
> format is very complicated or the data requires a lot of processing) then 
> you could copy the relevant parts of the heap objects off-heap and then 
> serialize from concurrent threads.
>

-- 
-- 
v8-users mailing list
v8-users@googlegroups.com
http://groups.google.com/group/v8-users
--- 
You received this message because you are subscribed to the Google Groups 
"v8-users" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to v8-users+unsubscr...@googlegroups.com.
To view this discussion on the web visit 
https://groups.google.com/d/msgid/v8-users/6284f2d2-2229-4d9b-b26e-6140f015c2e4%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.

Reply via email to