9 ms·
A 1000-processor chip powered by an AA battery (2016)
- Bluestein 6y ago"The chip is the most energy-efficient 'many-core' processor ever reported, Baas said. For example, the 1,000 processors can execute 115 billion instructions per second while dissipating only 0.7 Watts, low enough to be powered by a single AA battery. The KiloCore chip executes instructions more than 100 times more efficiently than a modern laptop processor."
- Bluestein 6y ago(Reminds me of this other chip - built by a "giant" of computing - that was designed to be -very- energy efficient, while having a very large number of very simple cores ... ... ran a special FORTH if I am not mistaken ... I cannot remember where I found a very nice presentation the gent gave about it ... :/ )
- palsecam 6y agohttp://www.GreenArrayChips.com/ http://www.GreenArrayChips.com/ by Chuck Moore, father of Forth.
- ajb 6y agoThere were previous iterations as well. I think this was all funded by some patent they licenced to Intel. The most astonishing part was that he rolled his own VLSI CAD system: https://mschuldt.github.io/www.colorforth.com/vlsi.html https://mschuldt.github.io/www.colorforth.com/vlsi.html
- Bluestein 6y agoWow.
- brandonmenc 6y agoA video of him demonstrating that system: https://www.youtube.com/watch?v=Dbd7Xu0ibJM https://www.youtube.com/watch?v=Dbd7Xu0ibJM
- Bluestein 6y agoSo kind :) Thank you.- Right on the dot ... (I found it fascinating, when I first saw it :)
- agumonkey 6y agoThere was two talks of Moore on GA chips. Multi core forth processors were (and still are) so inspiring.
- Bluestein 6y agoThat's it, indeed :)
- karmakaze 6y agoYeah, thought it was interesting that the subject chip didn't have a heat sink/fan and one supporting? chip on the board behind it did.
- FpUser 6y agoThis is very interesting stuff. I'd love for these kind of chips to be sold in a form of a coprocessor cards for PCs for example. For some type of servers and other uses it'd be a blessing.
- jpm_sd 6y agoThose are called GPUs! Or, if you like, GPGPUs. Readily available in The Cloud(TM) and everything. https://docs.aws.amazon.com/dlami/latest/devguide/gpu.html https://docs.aws.amazon.com/dlami/latest/devguide/gpu.html
- FpUser 6y agoNope. GPUs are SIMD. KiloCore is however 1000 totally independent cores.
- captainbland 6y agoMy understanding is that on Nvidia cards, each SM is basically an independent SIMD processor. So a RTX 3090 is like a processor with 82 independent but super-wide cores. I think the truth is actually even more complicated still with multiple warps being able to execute on a single SM with some memory subsystem limitations but it's something like that. The equivalent is true with AMD GPUs, too, just substitute the terminology where appropriate. Either way still not close to 1000 independent cores.
- desertrider12 6y agoIn a way, there are many more independent cores in an Nvidia GPU than #SMs, since the SIMD (warp) is only 32 threads wide, and >1k threads can be active at a time per SM. Each warp has its own independent program counter. So if you really wanted to, you could have a kernel with blocks that are Nx32, and code like: if(blockIdx.x == 0) doThing1(); else if(blockIdx.x == 1) doThing2(); ... etc., and the doThings could run at the same time, even on the same SM. Not super practical but it's allowed.
- 6y ago
- Zenst 6y agoSome more detailed information here: https://en.wikichip.org/wiki/uc_davis/kilocore https://en.wikichip.org/wiki/uc_davis/kilocore No idea how it has progressed or if sample units became accessible - which would be nice.
- karmakaze 6y agoIn addition to the memory access I was wondering how they got to 1000 cores and not 1024. > The chip is designed as a massively parallel processor array, with 992 cores arranged as a grid 32 by 31. Eight additional cores are found along with 12 memory modules of 64 KB SRAM each (for a total of 768 KB). Communication between cores is done via a dual-layer source-synchronous circuit-switched network and a very-small-area packet router (see wormhole routing). The circuit-switched network supports communication between adjacent and distant processors, as resources allow, with each link supporting a maximum rate of 28.5 Gbps. Maximum throughput is 45.5 Gbps per router. Both network types contribute to an array bisection bandwidth of 4.2 Tbps.
- AtlasBarfed 6y agoProcess/Fab errors? 24 cores of failure out of 1000 would be an error rate around 2%, which would help in yields.
- kingosticks 6y agoThat's a good reference. I had assumed there were 1000 instruction memory SRAMs in there but of course that'd be impossible considering the leakage numbers and there's actually just 12 x 64KB SRAMs shared by all the cores: Per core 640 bytes (128x40-bit) local instruction memory 512 bytes (256x16-bit) local data memory 768 KB SRAM on-die 12 shared SRAM memory modules, 64 KB each Those local per-core memories are tiny and presumably implemented with registers. But can you really do much with just 128 instructions? The following makes it sound like they might be instruction caches: > Instructions may come from the local instruction memory or they may be fetched from one of the independent memory module But then goes onto say: > the KiloCore's processors do not contain traditional caches. Hopefully their paper has more info. The survey that the "World’s First 1,000-Processor Chip" claim is based on (http://vcl.ece.ucdavis.edu/misc/many-core.html http://vcl.ece.ucdavis.edu/misc/many-core.html) doesn't seem to include any network processors, some of which are technically programmable. But even if it had, they wouldn't have found any of the information required for the table and definitely not a datasheet!
- oblio 6y agoWe're probably a programming language revolution away from these kinds of CPUs being practical. Isn't parallelism complicated and practically dangerous in most mainstream languages? Is there any language where you can just go: parallel-for: do-my-stuff and have the programming language Do The Right Thing with no further hassle? The right thing usually being blocking execution until every parallel do-my-stuff finishes execution, in my experience. In most programming languages I've seen this is a 20+ line boiler plate full of caveats and risks.
- foerbert 6y agoI'm not sure this is the best link, but I don't have anything better in mind and it was the first thing that popped up, so... Anyway, there's a language called ParaSail[0] that's doing stuff in that direction. A little bit back the guy behind it got hired by AdaCore (Ada compiler folks) and they seem to have adopted it and continuing with it. I haven't heard too much about it though. [0]https://adacore.github.io/ParaSail/ https://adacore.github.io/ParaSail/
- 4gotunameagain 6y agoMATLAB has parfor, but that's barely a language..
- jackpeterfletch 6y agoOccam has exactly this. SEQ executes statements sequentially. PAR executes them in parallel, though the language is based on CSP and Cooperative Multitasking, so the idea of it doing 'the right thing' with a PAR is a little different. Think of Occam programs as big Factorio factories. https://en.wikipedia.org/wiki/Occam_(programming_language) https://en.wikipedia.org/wiki/Occam_(programming_language) Alot the ideas that came out of Occam and CSP have been brought into various coroutine libraries though. Kotlin Coroutines, Goroutines, etc. So its definitely something that is explored.
- jacquesm 6y agoI was looking for this comment before posting. Thank you.
- kitd 6y agoCores ... transfer data directly to each other rather than using a pooled memory area that can become a bottleneck for data This sounds like transputers. IIRC they had direct memory linkage too.
- thawkins 6y agoyep each transputer had 4 serial links, which could be connected in matrixes, and allow data to be moved across the array directly. They used a language called OCCAM, and there was an OS called TAOS that allowed you to run various transputer topologies.
- rbanffy 6y agoDick Pountain wrote a lot of articles for BYTE about that. This is one: https://sites.google.com/site/dicknewsite/home/computing/pripar-machines?authuser=0 https://sites.google.com/site/dicknewsite/home/computing/pri...
- kitd 6y agoOCCAM!! That was it! Thx I was trying to remember the name of the language they used. I wonder whether OCCAM would be usable here, or if not, then something based on the lessons learnt from it.
- TickleSteve 6y agoOCCAM implemented CSP (Communicating Sequential Processes) that Go took a lot of lessons from. (https://en.wikipedia.org/wiki/Communicating_sequential_processes https://en.wikipedia.org/wiki/Communicating_sequential_proce...)
- TickleSteve 6y agoTAOS also ran on many other architectures (68K, x86, ARM). It implemented a virtual processor (VP1) and evolved into Elate but didn't get much recognition despite its novelty. TAOS was definitely ahead of its time, but rarely gets mentioned unfortunately.
- DrNosferatu 6y ago...from 2016. back in grad school, I did a comparison between the (then new) XeonPhi and GPUs to run my own N-Body engine using the same OpenCL implementation - the rest is history: GPUs still rule today for high intensity computational needs. Look at Machine Learning: GPUs are so good at SIMD, that if your domain can benefit from faster computation, /i you should make it SIMD i/, if it's not already. ;)
- klelatti 6y agoIt's sad that OpenCL development seems to have lost its way. I have some OpenCL workloads where a running on a CPU is faster and some where GPUs are much quicker. The beauty of OpenCL is that I can choose between the two with zero code changes. But CUDA and ML have steamrollered everything!
- lasagnaphil 6y agoI really hope SYCL (https://en.m.wikipedia.org/wiki/SYCL https://en.m.wikipedia.org/wiki/SYCL) can gain some traction (since Intel also jumped on the GPU competition and are backing a substantial amount of it)
- MayeulC 6y agoI heard of Hallide quite recently, and find it promising: https://halide-lang.org/ https://halide-lang.org/ Not only you can decide on CPU vs GPU, you have more control over the kind of parallelism and intermediate results.
- DrNosferatu 6y agoIndeed, OpenCL runs on everything - if you can set it up... :/ Actually, at the time, what I did was a 3-way comparison between GPU, XeoPhi and classic CPU (was it 8 cores?) running the same OpenCL code. Anyways, the "many-core" specimen, XeonPhi, benched at the geometric mean between classic CPU and GPU - so closer to classic CPU! (we were using beta hardware, our intel specialist - nice, helpful guy actually - went mute after I got those results :D ) On top of that, reimplementing the same algo in CUDA gave ~10% advantage over OpenCL on NVidia hardware. I wonder how it would fare on a FPGA of the same price/TDP? And more relevant for 2021: - I wonder if we would get the same kind of results using Vulkan? - Speaking of which, does anyone know of any good books / tutorials / runnable examples of Vulkan in a compute-oriented application? Cheers!
- deleted 6y ago[deleted]
- amelius 6y agoOne of the big difficulties with conventional processors is the memory hierarchy, where the entire memory is viewed as a shared memory space. There is no information in the article on how these processors communicate, so I'm guessing that this processor side-stepped the entire shared memory issue by offering only local memory combined with a simpler form of communication (e.g. message passing).
- cromwellian 6y agoReminds me of the PS/2 CELL Architecture, with the SPUs having limited local memory, and needing to DMA stuff around in a streaming fashion to build up larger programs.
- rbanffy 6y agoThe Cell was a pain to program because of that hateful memory architecture. The anemic PowerPC CPUs didn't help much either. Nothing really prevents an architecture where part of the address space is core-local (with low latency) and not directly accessible from other cores, and the rest points to a (much higher latency) shared memory pool. I have a feeling this would be much nicer to program than a Cell or the average GPU.
- jabl 6y ago> Nothing really prevents an architecture where part of the address space is core-local (with low latency) and not directly accessible from other cores, and the rest points to a (much higher latency) shared memory pool. I have a feeling this would be much nicer to program than a Cell or the average GPU. Many GPU's have this kind of local scratchpad memory. Nvidia GPU's even allows the programmer to partition the local SRAM between the scratchpad memory (called shared memory in CUDA docs) and L1 cache.
- rbanffy 6y agoIt's a shame nobody came up with an OS that runs entirely on a GPU.
- superrad 6y agoShould we be training on TIS-100[0] to be ready for when these chips become a necessity. [0]https://en.wikipedia.org/wiki/TIS-100 https://en.wikipedia.org/wiki/TIS-100
- peter_d_sherman 6y agoThis might make a good candidate architecture to become a future GPU (see discussion here): Nyuzi – An Experimental Open-Source FPGA GPGPU Processor https://news.ycombinator.com/item?id=26132726 https://news.ycombinator.com/item?id=26132726
- dang 6y agoDiscussed at the time: https://news.ycombinator.com/item?id=11935999 https://news.ycombinator.com/item?id=11935999
- guerrilla 6y agoI can't escape the nagging question: is it really 1,000 or actually 1,024 and simplified for the press release?
- Bluestein 6y agoUseful comment upthread :) - https://news.ycombinator.com/item?id=26143976 https://news.ycombinator.com/item?id=26143976
- kristianp 6y agoClearly there's enough runway in conventional low core-count processors that this isn't a viable path to take any time soon. Will it become the way forward in a decade or so?