When I was writing object code a ways back I had looked into ATMEL AT90 MCU's available and got the idea that one MCU could support 1 or more code objects and thought about how that might work until work intruded.
On a single AVR I have tasks inside of void loop() that read/write variables that other tasks read/write in response. My tasks interact through variables and loop() goes round and round and it all fits on one chip. When more chip is needed then get more chip, or board.
Caveat, the bus I'm going to suggest is much slower than running everything on one chip.
If I split the tasks among > 1 AVR's and connect them in a ring using serial links then the ring becomes loop(). Each AVR TX connects to the next in order AVR's RX with last TX to first RX. Serial now circles in one direction chip to chip.
Labeled data/commands flow from chip to chip through serial links, all in the ring but the originator repeat the message if not for them and may repeat/change/end the message if it is.
Now objects on each chip run in parallel and interact through passed values. Each chip adds a CPU over all-on-1-AVR.
It sounds a bit abstract unless you flesh it out with some concrete examples of where it could be applied. I had to look hard to find what WIP stand for in this context (Wireless Interface Processor?) - so you are clearly much more "leading edge" than me - but I guess you are talking about an architecture for multiple cooperating micro-controller based systems.
This is going further than simple function offloading (separate processor for driving a display etc.) and probably goes in the direction of applications like co-coordinating autonomous vehicles (self-drive cars) etc.
GoForSmoke:
objects on each chip run in parallel and interact through passed values. Each chip adds a CPU over all-on-1-AVR.
This is the essence of High Performance Computing: divide code into smaller chunks/ parallelize to run multiple functions simultaneously, and then communicate results between cores. A poor man's HPC might be a network of AVRs…
I've seen projects go from Uno to Mega2560 that really didn't need to.
With some work, I might get a system down. I already have a fast keyword identifier.
I dunno how efficient it will be given how many tasks usually don't run all the time plus there's the serial tx of the ring overhead.
But it should let tasks be divided in a way that's analogous enough to void loop() that original code can port w/o big changes.
Throw 328P-B or 1284P and the topology could split and join to suit a job, they have 2 USARTs. 2 rings meet at 1 chip?
The Mega2560 though... poor man's Transputer?
And every AVR USART can function as a full speed master mode SPI port.
Anyhow when I wrote PC code I saw objects as something MCU's could host in some kind of net. Since joining in with Arduino I learn more and more what I can do, often things that can support the older idea but that was a very open idea.
I can see ring-nodes that include add-on hardware like SD or motor-driver and MCU that responds to serial commands. Dr. Liu's displays with 328P serial-control 'backpacks' are like that, even have built-in support software for menus and like. A 1284P with SD slots would make a good file-server, just saying.
If it can work, there could be a ring-modules market. It'd be a bit like adding libraries to sketches, only physical and code.
I can see ring nodes being on an SPI bus as well for fast data xfers including broadcasting. The ring serves one purpose, it's not a limit just a bit limited.
6v6gt:
It sounds a bit abstract unless you flesh it out with some concrete examples of where it could be applied. I had to look hard to find what WIP stand for in this context (Wireless Interface Processor?) - so you are clearly much more "leading edge" than me - but I guess you are talking about an architecture for multiple cooperating micro-controller based systems.
This is going further than simple function offloading (separate processor for driving a display etc.) and probably goes in the direction of applications like co-coordinating autonomous vehicles (self-drive cars) etc.
Work In Progress --- part of the LOL, ROFL, AFK, BRB, etc set.
It is for splitting tasks across MCU's in a way that mimics cooperative tasking in void loop().
Function offloading fits, why not a display node? Or will the serial pass-thru make the display slow?
The function of the ring is mainly to pass state changes and commands in a loop of running code objects but it is WIP.
One node might combine sensing and motor control with coordinating functions. The node just before that might run a think process that passes abstract commands to the sense and control node that does not pass those along. The think node may get input from other nodes sending updates along the ring. On an AVR you can set and read variables in void loop() but with the ring the values are passed along, responses between nodes will be slower but should be faster than human.
Note that a single node can have very fast response that covers a range of actions. Info from another node will be nowhere near as fast to access as a variable in a big single-node solution. But even a 2560 has only one core.