How exactly are messages passed between cores using MessageQ (IPC sample proj)

Hi,

Your understanding is correct about the messageQ write/read (put/get).
Yes, this module supports the structured sending and receiving of variable length messages. Messages are sent and received through a message queue.

• A reader is a thread that gets (reads) messages from a message queue.
• A writer is a thread that puts (writes) a message to a message queue.

Each message queue has one reader and can have many writers. A thread may read from or write to multiple message queues.

Go through the IPC user guide to get the detailed information for messageQ.
C:\ti\ipc_1_xx_xx_xx\docs\IPC_Users_Guide
http://processors.wiki.ti.com/index.php/IPC_Users_Guide/MessageQ_Module
http://processors.wiki.ti.com/index.php/BIOS_MCSDK_2.0_User_Guide#Inter-Processor_Communication_.28IPC.29

Hi pubesh, I understand slightly better on the sending n receiving now. But I don't really get what is being sent over.. I see that 'msg' which is sent over is a struct, and the struct contains all IDs and such, then what exactly am I sending over? What if I have core0 doing some function and I want core0 to send the output to core1? Like maybe a text or something?

Because right now all I see if IDs and msg size etc being sent over, what about actual useful data?

Hi,

Find the test code at mcsdk: C:\ti\mcsdk_2_01_02_06\demos\image_processing\ipc

Before test this, check the image processing user guide.

http://processors.wiki.ti.com/index.php/MCSDK_Image_Processing_Demonstration_Guide

This test code is based on messageQ transport. In addition that, see the multicore based examples at: C:\ti\ipc_1_xx_xx_xx\packages\ti\sdo\ipc\examples\multicore\evm667x

Take a look at the recently posted training slides for IPC. They contain references to a few labs to help better understand the IPC communication..

http://processors.wiki.ti.com/index.php/IPC_3.x#IPC_Training

Jing,

For MessageQ, the transport determines how the message is passed from the local processor to the remote processor. The typical setup is to use TransportShm which is a zero-copy based transport. This transport relies on shared memory which is visible to both processors. Calling MessageQ_alloc will acquire a buffer in the shared memory. The local processor fills the buffer with data.

When the local processor calls MessageQ_put, only the pointer to this buffer is passed to the remote processor. When the remote processor returns from MessageQ_get, it has the pointer to this buffer. So, no data is copied. When the remote processor calls MessageQ_free, the buffer is released back into the pool.

In all cases, the local processor cannot use the message buffer once it has sent it to the remote processor. It has to acquire a new message using MessageQ_alloc.

In the following image, the arrows show the logical data flow, but the physical data is written to and read from the shared memory between the two processors.

When shared memory is not available, then a copy-based transport is used. In this case, when the local processor calls MessageQ_alloc, a buffer is returned from a local pool. When calling MessageQ_put, the transport will read the data in the message and send it to the remote processor using some physical transport (e.g. SRIO, SPI, etc). After the data has been sent, the transport will free the buffer back to the local pool. On the remote processor, the transport will acquire a buffer from the local pool and fill it as the data is received. When all data has been received, the pointer to this local buffer is returned from MessageQ_get.

Re: the message structure. The following image illustrates the message layout in memory. When you call MessageQ_alloc, you must make the message size large enough to contain both the embedded MessageQ_MsgHeader structure as well as your payload. A typical way to do this is to define your own message structure as illustrated.

~Ramsey

Hi, thank you for the detailed explaination, i understood most of it already but your explanation further improved my understanding. Based on the comments section in the MessageQ header file and ur example:

typedef struct{
  MessageQ_MsgHeader header;
  int num;
} MyMsg;

Correct me if i'm wrong. Because MessageQ_put only allows the passing of MessageQ_Header type, my understanding is that i'm supposed to initialize a MyMsg struct which will initialize a MessageQ_Header. This will ensure that the header and my 'int num' will be within the same block of memory. Thus when i pass the pointer of my header over to another core, the receiving core just needs to offset the size of the header to retrieve my 'int num'. Is this how it's supposed to be?

If so, i seem to be having some problems initializing the structs. I'm currently working on the sample project from TI on MessageQ(single image). 

typedef MessageQ_Header *MessageQ (in header)
MessageQ msg;

How should i modify my codes then? Changing the 'MessageQ msg' to 'MyMsg.header msg'? Or should i just initialize the struct MyMsg and it will initialize MessageQ_Header as header on it's own?

Thank you so much for ur patience and sry for my lack of knowledge.

PS: I'm currently working on a PC not connected to the internet thus i'm unable to copy n paste the codes etc. I'm posting from home so its all based on my memory.

Oh! Awesome! It worked.. Thanks a lot! It seems I got confused by what is being sent over. I kept thinking only MessageQ_MsgHeader is able to be sent over, didn't think I could send my whole stuct over. Forgot that its just a pointer after all. Thank you all! :)