Multi-cellular paradigm The molecular level can support self- replication (and self- repair). But we also need cells that can be designed to fit the specific application and at the same time able to support bio- inspired mechanisms for self-replication and fault tolerance.

Cellular differentiation Cells adapt their physical structure to fit the “application” Can circuits/processors do the same? Physically? No Logically? Yes, but… Can they do it easily (dare we say, automatically)?

Conventional processors

Fetch, decode and control unit

Instruction encoding Instructions encode both the operation and the operands. For example, in the MIPS architecture

Instruction encoding in “real life”

The Arithmetic and Logic Unit

Common processor components

State of the art computing

Bio-inspired processors However, none of these “standard” architectures is quite flexible enough to implement many of the behaviours required for bio- inspired computing Needed: adaptable cellular architecture That is, a processor architecture that is Customizable Compact Powerful Easy to design and modify Amenable to evolution and learning Possible solution: MOVE architectures

The MOVE paradigm One single instruction : move Data displacements trigger operations Architecture based around data ≠ operation centric Regular structure : functional units + data network Scalable and modular architecture Example: Sum of two values Conventional architecture: add R1, R2, R3; MOVE architecture: move O(Fxxx), I1(Fsum) move O(Fyyy), I2(Fsum) move O(Fsum), I(Fzzz)

Example – add operation

Cellular differentiation Main features: Only one instruction (OK, maybe two) that MOVEs data to and from the CUs and FUs (dataflow architecture) Conventional fetch/decode mechanism – compatible with bio-inspired mechanisms No pipeline: computation carried out in specialized functional units (FU) Communication carried out in specialized communication units (CU)

Cellular differentiation Main advantages: Can be easily customized by introducing application- specific functional and communication units. Perfectly fits the requirements of systolic arrays (arbitrarily complex communication patterns). The introduction of custom components does not affect the assembler language, the code structure, the fetch and decode units, or the transport bus.

Genotype Layer Phenotype Layer Example – Automatic Synthesis Application-specific (parallel) functions Developmental algorithm Genetic code Mapping Layer

Example – Automatic Synthesis Phenotype Layer Mapping Layer Genotype Layer Totipotent Cell

Example – Automatic Synthesis Totipotent Cell Programmable Logic

Example – Automatic Synthesis Programmable Logic Cellular Array

What kind of applications can take advantage of this kind of system? Complex "real-world" streaming applications computation is carried out sequentially can be represented by a DAG of computation nodes each node processes data locally then forwards them to the next node in the graph Applications ×+÷≠ FFT + × DCT INOUT

READDCTQNTZCMPRWRT Example: JPEG Specialized MOVE functional units can be designed for each of these steps INOUT

Programmable substrate ×+÷≠ FFT + × DCT Context INOUT Problem: task or resource allocation – i.e. how do we map the graph nodes to the array? Specifically: dynamic allocation

Self-Scaling Stream Processing Source Funct A Funct B Funct C JoinFunct A Funct C Funct A Funct C Funct A Funct C

SSSP The MJPEG application consists of a four-stage computation pipeline. The data to be compressed are composed of 192 bytes corresponding to an 8x8 array of pixels using 24- bit colour. The maximum rate achievable (determined by the input rate) is of 700 packets per second - roughly 1 MBit/second. With a single pipeline, the performance tops at about 60 packets per second.

SSSP When performance peaks, the average output rate is of 675 packets per second (out of a maximum of 700): this technique allows to multiply the throughput by a factor of 11 using 28 processors.

Next lecture What kind of tools have to be developed to implement a complete system? How do we determine optimal Fus for a given application? Idea: let’s use evolution!