Content Addressable Parallel Processor

A Content Addressable Parallel Processor (CAPP) is a type of parallel processor which uses content-addressing memory (CAM) principles. CAPPs are intended for bulk computation. The syntactic structure of their computing algorithm are simple, whereas the number of concurrent processes may be very large, only limited by the number of locations in the CAM. The best-known CAPP may be STARAN, completed in 1972; several similar systems were later built in other countries.

A CAPP is distinctly different from an Von Neumann architecture or classical computer that stores data in cells addressed individually by numeric address. The CAPP executes a stream of instructions that address memory based on the content (stored values) of the memory cells. As a parallel processor, it acts on all of the cells containing that content at once. The content of all matching cells can be changed simultaneously.

A typical CAPP might consist of an array of content-addressable memory of fixed word length, a sequential instruction store, and a general purpose computer of the Von Neumann architecture that is used to interface peripherals.
References

So you need a full array of functional units for every location in the CAM? Let me guess: very few operations are supported or the CAM is very small.

//advanced_content_addressability.c https://gist.github.com/FrozenVoid/363b9098196d3173ab0c
#include "void.h"
//https://gist.github.com/FrozenVoid/87e6ad6212ac9ce496e0
//Content Addressable Parallel Processor
//if you're using advanced pointer magic ,compile with -fno-strict-aliasing
STDSTART
/*
The CAPP executes a stream of instructions that address memory based on the content (stored values) of the memory cells. As a parallel processor, it acts on all of the cells containing that content at once. The content of all matching cells can be changed simultaneously.
*/
//save big bucks with imperative Von Neumann architecture
//only a minor slowdown with search, but you can operate on a million of (same) values at once
u8 arr[8]={1,22,333,444,5555,66666,777777,8888888};//vals
u8p parr[8*8];//8 pointers per val
for(u8 i=0;i<8;i++){for(u8 c=0;c<8;c++)parr[i*8+c]=&arr[i];}
//manipulates a val at PARALLEL! magic?
*parr[2]=0 ;//also affects 7 other pointers
arr[0]+=2;//all first 8 pointers are now 2
p(*parr[0],*parr[1],*parr[2],*parr[3],*parr[4],*parr[5],*parr[6],*parr[7],crlf);//
;//searching arr for a specific value is 8 times faster or N(number of pointers) times faster
//if you hold any pointer(or pointer to pointer) to a value you already found the value
//changing a specific pointer to another value
parr[1]=(u8p)&arr[7];//pointer 1 now points at last val
p(*parr[0],*parr[1],*parr[2],*parr[3],*parr[4],*parr[5],*parr[6],*parr[7],crlf);


//dynamically allocating and linking pointers with values is left as exercise to the reader

STDEND