IPC_COMMUNICATION ??

#include <stdio.h>

#include <xdc/std.h>
#include <string.h>
/*  -----------------------------------XDC.RUNTIME module Headers    */
#include <xdc/runtime/System.h>
#include <xdc/runtime/IHeap.h>

/*  ----------------------------------- IPC module Headers           */
#include <ti/ipc/Ipc.h>
#include <ti/ipc/MessageQ.h>
#include <ti/ipc/MultiProc.h>
#include <ti/ipc/HeapBufMP.h>

/*  ----------------------------------- BIOS6 module Headers         */
#include <ti/sysbios/BIOS.h>
#include <ti/sysbios/knl/Task.h>

#include <xdc/cfg/global.h>

#define HEAP_NAME   "myHeapBuf"
#define HEAPID      0
#define NUMLOOPS    2

Char localQueueName[10];
Char nextQueueName[10];
UInt16 nextProcId;
UInt16 proc_id;
Void tsk0_func(
				UArg arg0 ,
		        UArg arg1
		      ){
    Int              		status;
    MessageQ_Msg     		msg;
    MessageQ_Handle  		messageQ;
    MessageQ_QueueId 		remoteQueueId;
    UInt16                  msgId = 0;
    HeapBufMP_Handle        heapHandle;
    HeapBufMP_Params        heapBufParams;

	if (MultiProc_self() == 0) {
			printf("Create the heap that will be used to allocate messages.\n");fflush(stdout);
			HeapBufMP_Params_init(&heapBufParams);
	        heapBufParams.regionId       = 0;
	        heapBufParams.name           = HEAP_NAME;
	        heapBufParams.numBlocks      = 1;
	        heapBufParams.blockSize      = sizeof(MessageQ_MsgHeader);
	        heapHandle = HeapBufMP_create(&heapBufParams);
	        if (heapHandle == NULL) {
	            System_abort("HeapBufMP_create failed\n" );
	        }
	}
	else{
		printf("Opened the heap created by the other processor. Loop until opened \n");fflush(stdout);
		do{
			 status = HeapBufMP_open(HEAP_NAME, &heapHandle);

	            if (status < 0) {
	                Task_sleep(1);
	            }
		}while(status<0);

	}
    printf("Registered this heap with MessageQ \n");fflush(stdout);
    printf("Register this heap with MessageQ \n");
    MessageQ_registerHeap((IHeap_Handle)(heapHandle), HEAPID);
    printf("Created the local message queue that is LocalQueueName queue \n");fflush(stdout);
    messageQ = MessageQ_create(localQueueName, NULL);
    if (messageQ == NULL) {
        System_abort("MessageQ_create failed\n" );
    }
    printf("Open the remote message queue. Spin until it is ready \n");fflush(stdout);
    do {
           status = MessageQ_open(nextQueueName, &remoteQueueId);
           /*
            *  Sleep for 1 clock tick to avoid inundating remote processor
            *  with interrupts if open failed
            */
           if (status < 0) {
               Task_sleep(1);
           }
       } while (status < 0);
    if (MultiProc_self() == 0) {
        printf("Allocate a message to be ping-ponged around the processors \n");fflush(stdout);
        msg = MessageQ_alloc(HEAPID, sizeof(MessageQ_MsgHeader));
        if (msg == NULL) {
           System_abort("MessageQ_alloc failed\n" );
        }
      printf("Send the message to the next processor and wait for a message from the previous processor.\n");
      fflush(stdout);
      printf("Start the main loop\n");
      while (msgId < NUMLOOPS) {
          printf("Increment...the remote side will check this\n");fflush(stdout);
          msgId++;
          MessageQ_setMsgId(msg, msgId);
          System_printf("Sending a message #%d to %s\n", msgId, nextQueueName);fflush(stdout);

          status = MessageQ_put(remoteQueueId, msg);
          if (status < 0) {
          System_abort("MessageQ_put had a failure/error\n");
          }
          printf("sent the message to the remote processor \n");
          status = MessageQ_get(messageQ, &msg, MessageQ_FOREVER);
          if (status < 0) {
              System_abort("This should not happen since timeout is forever\n");
          }
          printf("got a message \n");fflush(stdout);
      }
    }
    else{
    	printf("Wait for a message from the previous processor and send it to the next processor \n");fflush(stdout);
    	printf("Start the main loop\n");
    	 while (1){
    		 printf("Get a message\n");fflush(stdout);
             status = MessageQ_get(messageQ, &msg, MessageQ_FOREVER);
             if (status < 0) {
                System_abort("This should not happen since timeout is forever\n");
             }
             System_printf("Sending a message #%d to %s\n", MessageQ_getMsgId(msg),
                             nextQueueName);
             printf("Get a message ID\n");fflush(stdout);
             msgId = MessageQ_getMsgId(msg);
             printf("send the message to the remote processor\n");fflush(stdout);
             status = MessageQ_put(remoteQueueId, msg);
             if (status < 0) {
                    System_abort("MessageQ_put had a failure/error\n");
             }
             printf("test done\n");fflush(stdout);
             if (msgId >= NUMLOOPS) {
                 break;
             }
    	 }
    }
    while (TRUE)                                 /* IPC DETACH FUNCTION IS CALLING HERE */
    {
    	printf("137\n");fflush(stdout);
        status = Ipc_detach(proc_id);
        printf("139\n");fflush(stdout);
        if (status == Ipc_E_NOTREADY) {
            Task_sleep(1);
        }
        else if (status < 0) {
            System_printf("Ipc_detach failed \n");
            break;
        }
        else {
           break;
        }
        printf("150\n");fflush(stdout);
    }
    printf("The test is complete\n");
    BIOS_exit(0);


}


int main(int argc, char* argv[]){

    Int status;
    Int loop_num_processor;
    Int Numprocessor = 0;
    proc_id = MultiProc_self();
    nextProcId   = (MultiProc_self() + 1) % MultiProc_getNumProcessors();
    Numprocessor = MultiProc_getNumProcessors();
    printf("number of cores are %d \n",Numprocessor);fflush(stdout);
    printf("LocalQueueName :%s \n", MultiProc_getName(MultiProc_self()));fflush(stdout);
    printf("NextQueueName  :%s \n",  MultiProc_getName(nextProcId));fflush(stdout);


    /*
     *  Ipc_start() calls Ipc_attach() to synchronise all remote processors
     *  because 'Ipc.procSync' is set to 'Ipc.ProcSync_ALL' in *.cfg
     */
    status = Ipc_start();

    if (status < 0) {
        System_abort("IPS IS NOT STARTED PROPERLY\n");
    }
    //proc_id = MultiProc_self();
    for(loop_num_processor=0;loop_num_processor<2;loop_num_processor++){
    	if(proc_id !=loop_num_processor)
    	{
                while(Ipc_attach(loop_num_processor) < 0){
                Task_sleep(1);
    		}
    	}
    }

    printf("Completed the synchronisation of all cores\n");fflush(stdout);
    BIOS_start();
    return 0;
}