Parallella Community

As I know sending data between core can be done using 2 method, DMA and direct write.
If we don't use DMA we should define a pointer and set its address like 0x6000 that is pointed to core local memory. Then we can use e_get_global_address to find others core address.
in this situation I have some questions that will be appreciated if answered!
How I can find code size that placed in local memory (using internal.hdf) in order to prevent conflict between code and data pointer?
Is writing to others core is blocking? For example when core1 write in core2, how core2 know that new data is presented in its memory?
Is using volatile for pointers be mandatory? What happen if we don't use it?
when we define an array in program, where this array is placed? How we can update its value from other cores?
Is using barrier can belp to synchronize cores, while(it seems) writing to other cores memory is non-blocking and based on fire and forget?

Thanks for your reply, it was helpful.

It is very good that ic code+buffer exceed the local memory length, linker complain. But is there any way that I can know the code size, before linked error?

As you said I can define communication buffer statically and I can define an array in any core and other cores can access to it, if they know its address. How I can find an array address?

So communicating with other cores while using array is possible only when different core code be the same, otherwise we cannot find its address using array name?

You can't find out an address at runtime when you only know the name.

If all cores run the exact same program, the same variable ends up at the same address, which is a special case. In that case (and only in that case), you can use e_get_global_addr() to access other core's arrays. In all other cases, you have to find a solution to communicate the address of the array.