Help Setting up Multicore

[tonycarbon]

Hi

[ please bear with me I am not an experienced C++ person ]

I have been studying the Mandelbrot example in the Circle Samples folder
to try and understand how the Mulitcore class works.

I think I have understood it, and have implemented a class for it, based
on the example.
Please see below for my code.

But my questions is, how do I set Core 1 running with a subroutine, from
Core0.

From the Madelbrot example, it never returns to the Kernel::Run sub so
persumably Core 0 cannot continue with other functions.

Any help greatly appreciated.

CMC_tasks.h

#ifndef _CMC_tasks_hß
#define _CMC_tasks_h

#include <circle/multicore.h>
#include <circle/memory.h>
#include <circle/types.h>
#include "circle/timer.h"

class CMCTask
#ifdef ARM_ALLOW_MULTI_CORE
	: public CMultiCoreSupport
#endif
{
public:
    CMCTask (CTimer *mTimer, CMemorySystem *pMemorySystem);
	~CMCTask (void);

#ifndef ARM_ALLOW_MULTI_CORE
	boolean Initialize (void)	{ return TRUE; }
#endif

    void Run (unsigned nCore);
private:

    CTimer *m_pTimer;
};

#endif

CMC_tasks.cpp

#include "CMC_tasks.h"

CMCTask::CMCTask (CTimer *pTimer, CMemorySystem *pMemorySystem)
:
#ifdef ARM_ALLOW_MULTI_CORE
    CMultiCoreSupport(pMemorySystem),
#endif
    m_pTimer (pTimer)
{
}


CMCTask::~CMCTask (void)
{
  //  m_pTimer=0;
}

void CMCTask::Run(unsigned int nCore)
{

    switch (nCore)
    {
        case 1:
            Run_Display();
            break;

        case 2:
            Run_OBP();
            break;

        default:
            break;
    }

}

[rsta2]

The communication between multiple cores is part of the magic of an multi-core application and one could probably write books about this. That's why I can only give an example.

First you have to know, that a variable, which is defined in a Circle multi-core app is visible on all cores. So if you write to this variable on one core, an other core can watch this. So variables can be used for communication between multiple cores.

Unfortunately you cannot directly call a subroutine from one core on another core. All cores run their one code, normally in a loop, and process the data, they are working on. But they can communicate, if they share some of this data.

It depends on, what your application is doing, how this could look like in detail.

The sample/17-fractal is special in this point, because here each core calculates a part of a Mandelbrot image, they write the resulting pixels to an area in the frame buffer, which is reserved for them, and they are working on a parameter range, which is already known, when the cores are starting their calculation. So no communication is necessary between them.

A more complex example is the MiniSynth Pi audio synthesizer application. Here each core has to calculate the next audio sample values for 6 active voices (24 voices total). Core 0 controls, when the secondary cores (1, 2, 3) are starting their calculation. This is done in the class CVoiceManager with the variable m_CoreStatus[], which is an array with an enum TCoreStatus value for each secondary core. Because core 0 is the controlling core, the value for core 0 is not used here.

The overlying logic calls CVoiceManager::NextSample(), when the next audio sample is needed. Now core 0 kicks the secondary cores by setting their value in m_CoreStatus[] to CoreStatusBusy. After this core 0 starts its own voice calculation. When it is ready with this, it waits for the other cores to complete their work by watching m_CoreStatus[] going to CoreStatusIdle. When this is completed, core 0 sums up the output level from each core, which was written to m_fOutputLevel[] by each core.

Now let's watch, what the secondary cores did in the meantime in CVoiceManager::Run(). Each secondary core in a loop first waits for its m_CoreStatus[] set to CoreStatusBusy. Until this happens, it is just waiting. If m_CoreStatus[] goes to CoreStatusExit the core is returning from Run() and is terminated as a special condition. Now in the normal condition the secondary core processes its 6 voices in ProcessVoices() and writes the resulting output level to m_fOutputLevel[] to be summed up on core 0 later (see above). After that the secondary core is ready (and idle) and writes CoreStatusIdle to its m_CoreStatus[]. Core 0 can watch this.

This is one possible inter-core communication scenario. It depends on, what your application is doing, if you can reuse this or need an other protocol.

[tonycarbon]

thanks very much Rene.
took me a while to understand it.
My problem was I didnt realise that cores(1,2,3) are started automatically

thanks again