News for hackers. Stuff that matters.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by Coffeewine on Wednesday October 05, 2016 @01:28PM (#12645868)
This is fascinating:

The Epiphany-V was designed using a completely automated flow to translate Verilog RTL source code to a tapeout ready GDS, demonstrating the feasibility of a 16nm “silicon compiler”. The amount of open source code in the chip implementation flow should be close to 100% but we were forbidden by our EDA vendor to release the code. All non-proprietary RTL code was developed and released continuously throughout the project as part of the “OH!” open source hardware library.[20] The Epiphany-V likely represents the first example of a commercial project using a transparent development model pre-tapeout.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by LeifCarrotson on Wednesday October 05, 2016 @02:49PM (#12646634)
RTL = Register Transfer Logic, and EDA = Electronic Design Automation, for anyone else who was curious. I don't know what GDS stands for, but context indicates it's the actual physical description that's used to make the part.

But I'm confused about what part of this is open and not open. Do they mean that they imported their Verilog into a proprietary tool, which generates the design? That doesn't make it open source in practice.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by adapteva on Wednesday October 05, 2016 @03:12PM (#12646822)
HW design is not that different from SW design. Comp table below:

HW SW Verilog --> C/Java/etc EDA --> GCC/LLVM GDS --> Binary (elf)

The GDS is completely tied up in NDAs due to the foundry. The EDA combines/translates open source code with proprietary blobs to produce a "super secret" GDS binary blob that gets sent to the foundry for manufacturing.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by LukeShu on Wednesday October 05, 2016 @05:32PM (#12648094)
For anyone else who was confused by everything being on one line:

    HW          SW
    Verilog --> C/Java/etc
    EDA     --> GCC/LLVM
    GDS     --> Binary (elf)
Re:Epiphany-V: A 1024-core 64-bit RISC processor by NEDM64 on Friday October 07, 2016 @02:19AM (#12658586)
For everyone still confused

  Verilog --> imperative language
  
  EDA --> IDE + compiler
  
  GDS --> Assembly
Re:Epiphany-V: A 1024-core 64-bit RISC processor by signa11 on Wednesday October 05, 2016 @11:50PM (#12650123)
> HW design is not that different from SW design.

reminds me of alan-kay's comment "hardware is just software which has crystallized early"

Re:Epiphany-V: A 1024-core 64-bit RISC processor by ChrisRus on Wednesday October 05, 2016 @05:59PM (#12648308)
> HW design is not that different from SW design.

Shouldn't be. But it is.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by AceJohnny2 on Wednesday October 05, 2016 @06:08PM (#12648386)
Except the economics are vastly different. The complexity and cost of manufacturing, the computationally intensive cost of simulation and various checks and optimizations (be it clock timing or mask optimizations to etch features that are smaller than the wavelength used to etch them), all mean that you can't just "compile and publish", and turnaround times are months, not hours.

And there are no open-source toolchains for any of this. It's a student project to implement a SW compiler, why isn't it to implement an RTL compiler?

Re:Epiphany-V: A 1024-core 64-bit RISC processor by zanny on Wednesday October 05, 2016 @07:28PM (#12648861)
Nothing about the time frames or even production costs justify the disparity in how proprietary and closed hardware manufacturing is. For the exact reason hardware and software are different open sourcing your patterning toolchain has nothing to do with your competitive advantage in actually having built foundries with functioning lithography. The cost is in the later, the former is just abuse of position for power over the end user.

If anything, it hurts your bottom line. You would probably get more third party interest in having print outs of custom hardware if the toolchains were more open. It is not a question of price, its a question of exposure.

I'm not even talking about the 12-20nm stuff. It is still crazy expensive because the hardware and software R&D was huge and these companies are hoarding their toys like preschoolers because of a prisoners dilemma in regards to competitive advantage. But older 45-100nm plants are often still in use but are still just as inaccessible as ever to most hobbyist hardware enthusiasts.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by Klinky on Thursday October 06, 2016 @01:20AM (#12650408)
If it was really that easy then hobbyists would have found a way to do it on their own by now(e.g. 3D printing). You can't just demand that someone open their billion dollar fabs to amateur hobbyists. It is very likely if the fab is still operating at a certain process, it's because they have profitable business churning through it. If it's not profitable, they retool or close it down. An idle fab is money down the drain, and it's really doubtful hobbyists would be able to fill the gap with a bunch of one-off production runs, while likely needing a lot of hand holding.

Custom circuit boards are coming down in price, maybe custom lithography will come down in price at some point to be accessible to hobbyists / startups.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by AceJohnny2 on Wednesday October 05, 2016 @07:54PM (#12649016)
> The cost is in the latter, the former is just abuse of position for power over the end user.

Exactly, hence my question about "student projects" which is really about why aren't there more OSS projects that challenge this. Is it because of the lack of platforms to experiment on, or the inherent difficulty of the task?

Re:Epiphany-V: A 1024-core 64-bit RISC processor by seanp2k2 on Wednesday October 05, 2016 @09:49PM (#12649572)
Thinking about this, yeah it'd be amazing to e.g. Have a community-driven forum with some DIY CPU designs (lisp machines!) with an affordable (let's say under $1k per chip) way to get them made. We'll probably get there eventually, but I'm not aware of where progress on this front is.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by DesiLurker on Thursday October 06, 2016 @04:54PM (#12656018)
this. I always say this, the real credit for success of open source software goes to gcc (egcs for old timers) which allowed developers to make executable code unencumbered with NDAs & royalties.

sometimes I wish somebody with deep pockets (or maybe a semiconductor company) were to buy an ailing EDA company and just opensource all these design tools things would move much faster for opensource h/w design.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by thesz on Thursday October 06, 2016 @06:31AM (#12651359)
In software, the code line of state machine does miriad of things - computes new state, reads input, writes output, etc, etc. In hardware, the code line state machine computes one bit of acknowledgement of having input read. If you lucky,

The hardware programming is way, way too low. Consider assembler programming, even lower.

This is why videocotroller HW takes 9 months for group of 5 engineers and 2 programmers, and driver software for said videocontroller can be wriiten in a month by one graduate student.

The languages also either very dirty or very expensive.

For example of expensiveness, the cost of one license cool shiny Bluespec SystemVerilog compiler can cost you 2-3 yearly salaries of one of your engineers. Yes, it reduces lines (3 times) and error density (another 3 times), but nonetheless.

The example of dirtyness in Verilog: the sized based number literal has three parts - integer size (regular decimal integer with non-significant underscores like 10_00 for thousand), the base, expressed by regexp "'[Ss]?[xXOobBdD], and the value of the literal. These are three separate lexems. You can use preprocessor definition "`define WEIRD(n,b,s) s b n" and use it to construct sized literals backward: WEIRD(dead,'X,42) for 0xdead with size 42. As you can see, the value part of literal can (and will) be matched as regular identifier rule. The compiler right now seems to me as more or less straightforward, though.

The example of dirtyness in VHDL: construction of record where first fiels is character can be written as "RECORD'(')')" - we have successfully constructed a record with character field set to ')'. The single quote mark is either start of character literal (as in 'c'), the prefix of attribute (NAME_OF_ENUMERATED_VALUE'SUCC) or part of typed construction of value exemplified above. VHDL was one of the first languages that untroduced operator and function overloading, including and not limited to, overloading on return types of functions.

Good luck implementing all of this when you are student.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by Ericson2314 on Thursday October 06, 2016 @10:25AM (#12652672)
Look up clash-lang.org. Haskell-modules->Verilog+VHDL with a simple compilation model so you're not leaving performance in the table.

I wrote a 5-stage RISD processor with it for school, was quite simple and easy to abstract.

If hardware was more competitive, industry coding practices would be more efficient. Instead their own self-conception of pain-points prevents them from going after this low-hanging fruit.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by thesz on Thursday October 06, 2016 @01:31PM (#12654338)
Ha!

I wrote something like that long time ago: https://github.com/thesz/hhdl (even before clash)

I had some translation algorithm from pure Haskell code to the HHDL internals. I even wrote MIPS clone using it (and it was simulated OKly).

There's just no market for that.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by Ericson2314 on Thursday October 06, 2016 @06:30PM (#12656672)
Cool! But note that Clash is actually compiling Haskell (i.e. analogous to GHCJS or something), rather than being an EDSL.

I'm hoping (as is the author with http://qbaylogic.nl/) that the market for FPGA soft(?)ware will suck less. Best case it pushes pressure on the fabs for ASICs, but we'll see.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by aseipp on Thursday October 06, 2016 @12:02PM (#12653565)
> And there are no open-source toolchains for any of this.

There is one fully open source flow, but currently only targeting Lattie iCE40 chips: Project IceStorm. http://www.clifford.at/icestorm/

That said, the synthesis tool (Yosys) can actually synthesize netlists suitable for Xilinx tools, as well. In theory any company could probably add a backend component to Yosys to support their chips. arachne-pnr/icetools can only target iCE40 chips, still.

That said, it all works today. I recently have been working on a small 16-bit RISC machine using Haskell/CLaSH as my HDL, and using IceStorm as the synthesis flow. This project wouldn't have been possible without IceStorm - the proprietary EDA tools are just an unbelievable nightmare that otherwise completely sap my will to live after several attempts...[1][2]

[1] Like how I had to sed `/bin/sh` to `/bin/bash` in 30+ shell scripts, to get iCEcube2's Synplify Pro synthesis engine to work. WTF?

[2] Or other great "features", like locking down iCE40-HX4K chips with 8k-usable LUTs to 4k LUTs artificially, through the PR/synthesis tool, to keep their products segmented. I mean, I get the business sense on this one (easier to do one fab run at one size), but ugh.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by chas on Thursday October 06, 2016 @12:12AM (#12650194)
It is[0] and electrical engineering students make them pretty regularly, it's just much more expensive and complicated if you actually want to make a chip with the output of one instead of just simulating it.

[0]https://www.coursera.org/learn/vlsi-cad-logic

Re:Epiphany-V: A 1024-core 64-bit RISC processor by analognoise on Wednesday October 05, 2016 @08:03PM (#12649059)
I don't see how it shouldn't be; it's an entirely different set of constraints?
Re:Epiphany-V: A 1024-core 64-bit RISC processor by NEDM64 on Friday October 07, 2016 @02:24AM (#12658609)
Yes, it is.

Specially when you're working with RF or when you're doing commercial products or when you have a strict timeline and limited resources.

In a software project, the development is only limited by the Human Resources, you can't realistically blame the computer for being too slow to compile your code, and there are no "defects" when your users download your code.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by iheartmemcache on Thursday October 06, 2016 @09:41AM (#12652328)
The limiting factor is your 'building blocks' (component libraries with things their cells, IO and what-have-you)) that your fab (i.e. TSMC) gives to your design software house (e.g. Mentor, Synopsis, Cadence) for a specific process (e.g. $integer-$um|nm CMOS) for a production run is usually built off of heavily NDA'd building blocks locked down by contract[0] (and that's assuming you have the cash to to buy time for that tape out!).

Even designing simple stuff without the fab's component libraries for old processes would be a daunting task. (For some context, something circa the Sega Dreamcast era -- 350 nm/4 layers or there abouts -- is well in the realm of what an undergraduate would be able to design with a fair bit of ease for his capstone (senior-year) project is doable by a talented single 4th year with the component libs. Without the tooling, he'd be lost.) I'm sure Adapteva wanted to open source their final files which went to the fab for tape-out, but you could bet your bottom dollar if they did, a take-down letter would be sent to Github and Adapteva would be slammed with a lawsuit.

SPICE is/was the original open-source project that came out of UC Berkeley in the '70s if you want to go from zero-to-tape-out on an entirely open source stack but it's no trivial task. http://opencircuitdesign.com/links.html has some auxiliary resources, and IIRC there's a Linux distribution with a pretty good toolkit with even things like analog simulators for RFIC (though, as the late-great Bob Pease of NatSemi said - "never trust the simulator" ;)).

Side-note: Adapteva - your work is fascinating, so much so that I read your entire set of ref docs for the Epiphany. I'm in the Boston area, let me buy y'all a coffee at Diesel as I'd love to pick you brains.

--

[0] - (Grey area legality content) - Here's an example of the documentation of the libs you'd be using - normally even these documents are lock&keyed: http://www.utdallas.edu/~mxl095420/EE6306/Final%20project/ts... This looks like a masters level thesis project directory by the course number (didn't go to U of T:D) @ 180 nm sizing.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by bobmoretti on Wednesday October 05, 2016 @04:45PM (#12647686)
Probably RTL would be more correctly known as "Register Transfer Level" as in a level of abstraction, in contrast to for example the lower "gate" level of abstraction.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by avip on Wednesday October 05, 2016 @03:23PM (#12646926)
Graphic Data System. AKA GDSII
Re:Epiphany-V: A 1024-core 64-bit RISC processor by codebook on Wednesday October 05, 2016 @01:51PM (#12646088)
I might be wrong. But if they automated the flow from RTL to GDS, the timing might not be optimal. I understand since they have lack of resources so that this is unavoidable but in normal chip design flow, the backend timing ECO is critical to achieve high frequency for all timing corners.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by adapteva on Wednesday October 05, 2016 @01:55PM (#12646132)
Yes, we are leaving 2X on the table in terms of peak frequency compared to well staffed chipzilla teams. Not ideal, but we have a big enough of a lead in terms of architecture that it kind of works.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by nickpsecurity on Wednesday October 05, 2016 @02:23PM (#12646397)
The comment above said you couldn't release the info due to the EDA vendor. However, people like Jiri Gaisler have released their methodologies via papers that just describe them with artificial examples. Others use non-manufarable processes and libraries (like NanGates) so the EDA vendors feelings don't get hurt about results that don't apply to real-world processes. ;)

So, if you have a 16nm silicon compiler, I encourage you to pull a Gaisler with a presentation on how you do that with key details and synthetic examples designed to avoid issues with EDA vendors. Or just use Qflow if possible.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by adapteva on Wednesday October 05, 2016 @02:31PM (#12646470)
I'll pass for now...Gaisler is in the business of consulting, we survive by building products. I am happy to release sources, but it's completely up to the EDA company.

[edit: was thinking of the wrong Gaisler, still will pass]

Re:Epiphany-V: A 1024-core 64-bit RISC processor by nickpsecurity on Wednesday October 05, 2016 @02:33PM (#12646498)
Damnit. No promises but would you consider putting it together if someone paid your company to do it under an academic grant or something? Quite a few academics trying to do things like you've done with small chance that one might go for that.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by nickpsecurity on Wednesday October 05, 2016 @02:48PM (#12646619)
Btw, your site is down right now.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by gonzalocasas on Wednesday October 05, 2016 @04:12PM (#12647377)
It's pretty ironic that parallella.org is down on an article about high parallelism because -apparently- it cannot take HN-front-page-load-levels.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by nickpsecurity on Wednesday October 05, 2016 @04:21PM (#12647471)
That's concurrency, throughput, and load-balancing of web servers connected to pipes of certain bandwidth. It's not the same as parallel execution of CPU-bound code on a tiled processor. You could know a lot about one while knowing almost nothing about the other.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by sitkack on Wednesday October 05, 2016 @02:21PM (#12646387)
That seems analogous to human assembly optimization vs a compiler. But the time to market is greatly reduced, designs can be vetted and a 2.0 that is optimized for frequency can be shipped later.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by yellowapple on Wednesday October 05, 2016 @02:38PM (#12646544)
IIRC, human assembly optimization is unlikely to be better than a modern compiler nowadays. Same thing could very well happen for this "automated flow" if it starts incorporating its own optimization techniques.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by wolf550e on Wednesday October 05, 2016 @02:49PM (#12646628)
That is a myth. Most developers can't beat LLVM. LLVM can't beat the handcrafted assembly in libjpeg-turbo or x264 or openssl or luajit by compiling the generic C alternative.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by hedora on Wednesday October 05, 2016 @03:51PM (#12647180)
In response to the other replies: I'm not sure about luajit, but the other two examples involved a programmer hand crafting algorithms around specific special purpose CPU instructions -- vector processing and video compression hardware, if I remember the details of x264 correctly. This is so specialized and architecture specific that it probably doesn't make sense to push it into the compiler.

Speaking from experience, even getting purpose-built compilers like ICC to apply "simple" optimizations like fused-multiply-add to matrix multiply is non-trivial.

Taking jpeg decoding as a concrete example of why modern compilers fall over, you have two high-level choices: (1) the compiler automatically translates a generic program into one that can be vectorized using the instructions on the target platforms. This will probably involve reworking control flow, loops, heap memory layout, malloc calls, etc, and will require changing the compressed / decompressed images in imperceptible to humans ways (the vector instructions often have different precision/rounding properties than non-vector instructions). This is well beyond the state of the art.

(2) Find a programmer that deeply understands the capabilities of all the target architectures and compilers, who will then write in the subset of C/Java/etc that can be vectorized on each architecture.

I think you'll find there are many more assembler programmers than there are people with the expertise to pull off (2), and that using compiler intrinsics is actually more productive anyway.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by wolf550e on Wednesday October 05, 2016 @06:33PM (#12648545)
x264 does not use any video compression hardware. It uses only regular SIMD.

I don't agree that SIMD is so specialized. It is needed where ever you have operation over arrays of items of the same type, including memcmp, memcpy, strchr, unicode encoders/decoders/checkers, operations on pixels, radio or sound samples, accelerometer data, etc.

Compilers have latency and dependency models for specific CPU arch decoders/schedulers/pipelines. Compiler authors agree that compilers should learn to do good autovectorization. But it's hard. So people use assembly.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by sqeaky on Wednesday October 05, 2016 @03:25PM (#12646942)
yellowapple said:

> human assembly optimization is unlikely to be better than a modern compiler

You said:

> Most developers can't beat LLVM

Then you pointed out some specific examples where a human can be a compiler.

Seem like you two agree, then you go and call what he is a saying "a myth". I think I need some clarification.

Prior to this my understanding was that if the developer provides the compiler good information with type, const, avoids pointer aliasing and in general makes the code easy to optimize that the compiler can do much better than most humans most of the time, but of course a domain expert willing to expend a huge amount of time with all the knowledge the compiler would have can beat the compiler. It just seems that beating the compiler is rarely cost (time, money, people, etc...) efficient.

Is my understanding close in your opinion?

Re:Epiphany-V: A 1024-core 64-bit RISC processor by wolf550e on Wednesday October 05, 2016 @06:22PM (#12648476)
Making C compilers for different architectures output great code from same source is really hard. e.g. "const" is not used by optimizers because it can be cast away. Interpreters, compression routines, etc. can always be sped up using assembly.

If what your program does can be sped up using vector registers/instructions (e.g. DSP, image and video processing) then you want to do that because x4 and x8 speedups are common. Current autovectorisers are not very good. If it is not the most trivial example like "sum of contiguous array of floats", you'll want to write SIMD assembly or intrinsics or use something like Halide. In practice projects end up using nasm/yasm or creating a fancy macro assembler in a high level language.

The choice to use assembly is economics, and it's all a matter of degree. How much performance is left on the table by the compiler? How many C lines of code take up 50% of the cpu time in your program? How rare is the person who is able to write fast assembly/SIMD code? How long does it takes to write correct and fast assembly/SIMD code for only the hot function for 4 different platforms (e.g. in-order ARM, Apple A10, AMD Jaguar, Haswell)?

If you think "25%, 100k LoC, very rare, man-years" then you conclude it's not worth it. If you think "x8, 20 lines, only as rare as any other good senior engineer, 50 hours" then you conclude it's stupid to not do the inner loop in assembly.

What are the numbers in practice? I don't know. In practice, all the products that have won in their market and can be sped up using SIMD have hand coded assembly or use something like Halide and none of them think the compiler is good enough.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by jmgao on Wednesday October 05, 2016 @11:02PM (#12649917)
> Making C compilers for different architectures output great code from same source is really hard. e.g. "const" is not used by optimizers because it can be cast away.

const most certainly is used by optimizers: https://godbolt.org/g/kLmGr4

The willingness of C compilers to (ab)use undefined behavior for optimization is one of the main criticisms against it.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by beached_whale on Thursday October 06, 2016 @09:35AM (#12652285)
Check out the cppcon 2016 presentation by Jason Turner and watch how eager the compiler optimizes away code when const is enabled on values. Cool presentation too, and uses Godbolt's tool https://www.youtube.com/watch?v=zBkNBP00wJE
Re:Epiphany-V: A 1024-core 64-bit RISC processor by flamedoge on Thursday October 06, 2016 @12:45AM (#12650317)
I think the argument is not against unwillingness, but when and how.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by pcwalton on Wednesday October 05, 2016 @03:21PM (#12646912)
If it's not at least able to match handcrafted assembly using intrinsics, you should file bugs against LLVM. There is no theoretical reason why compilers shouldn't be able to match or beat humans here: these problems are extremely well studied.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by aseipp on Wednesday October 05, 2016 @09:38PM (#12649498)
Sometimes consistency is desirable, as well as performance. Compilers are heuristic. They evolve and get better, but they can mess up, and it's not always a fun time to find out why the compiler made something that was performance sensitive suddenly do worse, intrinsics or not -- from things like a compiler upgrade, or the inlining heuristic changes because of some slight code change, or because it's Friday the 13th (especially when it's something horridly annoying like a solid %2-3 worse -- at least with %50 worse I can probably figure out where everything went horribly wrong without spending a whole afternoon on it). This is a point that's more general than intrinsics, but I think it's worth mentioning.

Sure, I can file bug reports in those cases, and I would attempt to if possible -- but it also doesn't meaningfully help any users who suddenly experience the problem. At some point I'd rather just write the core bit a few times and future proof myself (and this has certainly happened for me a non-zero amount of times -- but not many more than zero :)

Re:Epiphany-V: A 1024-core 64-bit RISC processor by pygy_ on Wednesday October 05, 2016 @04:11PM (#12647372)
You may want to read this Mike Pall post about the shortcomings of high level language compilers regarding interpreters: http://article.gmane.org/gmane.comp.lang.lua.general/75426
Re:Epiphany-V: A 1024-core 64-bit RISC processor by robryk on Wednesday October 05, 2016 @03:30PM (#12646988)
"using intrinsics" is a cop out: you are essentially doing the more complicated part of translating that sequence of generic C code into a rough approximation of a sequence of machine instructions and leave the compiler to do the boring and simpler parts, like register allocation, code layout and ordering of independent instructions.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by maccard on Wednesday October 05, 2016 @02:59PM (#12646716)
Compilers are smart at some things and not so smart at others. I can beat the compiler in tight inner loops almost every time, but it will also do insanely clever things that id never think of!
Re:Epiphany-V: A 1024-core 64-bit RISC processor by mpweiher on Wednesday October 05, 2016 @02:53PM (#12646659)
Common misconception, see Proebsting's Law, "The Death of Optimizing Compilers":

http://cr.yp.to/talks/2015%2E04%2E16/slides-djb-20150416-a4....

as well as 'What every compiler writer should know about programmers or “Optimization” based on undefined behaviour hurts performance '

http://www.complang.tuwien.ac.at/kps2015/proceedings/KPS_201...

Re:Epiphany-V: A 1024-core 64-bit RISC processor by sqeaky on Wednesday October 05, 2016 @03:56PM (#12647221)
Slides with the talk, not my favorite, have a link to the talk?

The second paper is so biased it hurts. It hardly attempts to hide this bias, on the second page it start referring to one group of people as "clueless" and never justifies it describing what what clued in would be.

The second paper also has a strong assumption that compilers should somehow maintain their current undefined behavior going forward. It is almost as though the paper author thinks a compiler can somehow divine what the programmer wants without referring to some pre-agreed upon document, such as the standard for the language.

The second paper also talks only about performance and not about any other real world concern, like maintainability, reliability or portability.

This paper is setting up straw men when it trots out code with bugs (that loop on page 4) and then a pre-release version of the compiler does something unexpected. Of course non-conforming code breaks when compiled. Of course pre-release compilers are buggy.

The paper's author wants code to work the same on all systems even when the code conveys unclear semantics. That is unreasonable.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by flamedoge on Wednesday October 05, 2016 @05:30PM (#12648082)
Why even write a book about it? effectively a no-op
Re:Epiphany-V: A 1024-core 64-bit RISC processor by sqeaky on Thursday October 06, 2016 @11:54AM (#12653482)
To give credit to the paper's author that no-op is part of the SPEC benchmark suite and the author feels that code in that benchmark is being treated as privileged by compiler authors.

Even though I disagree with the author I try to understand some of his perspective.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by GFK_of_xmaspast on Wednesday October 05, 2016 @03:26PM (#12646949)
There's a gap between "humans can't write assembly better than the compilers" and "there's nothing humans can do to help the compiler write better code".
Re:Epiphany-V: A 1024-core 64-bit RISC processor by dnautics on Wednesday October 05, 2016 @04:11PM (#12647371)
Depends. You won't beat llvm if your code uses strictly intrinsics. Some things, like adding carry bits across 64-bit arrays, might need to be done by hand, because of special, knowledge about your data that are not generalizable.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by ithkuil on Wednesday October 05, 2016 @04:54PM (#12647764)
unless you have a language which allows you to express that knowledge of the data
Re:Epiphany-V: A 1024-core 64-bit RISC processor by Coffeewine on Wednesday October 05, 2016 @01:53PM (#12646112)
I agree completely, it's still impressive to me that they presumably managed a competitive offering with such a system. I imagine having it be a highly homogeneous design also helped.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by adapteva on Wednesday October 05, 2016 @01:58PM (#12646165)
Design symmetry and regularity was the key. Harder to achieve that with a heterogeneous architecture.
Re:Epiphany-V: A 1024-core 64-bit RISC processor by runeks on Tuesday October 11, 2016 @06:10AM (#12682898)
The interesting question, to me at least, is how much cheaper this chip is - with its suboptimal maximum clock rate - compared to a chip from a non-automated flow. If peak clock rate is one half, but cost is one hundredth, I'd say it's a spectacular achievement.

100th in costs and one half in performance is, granted, wishful thinking on my part. But I believe the important point is that with a sufficient productivity gain, this technology can reduce the old, non-automated way to something akin to writing software libraries in assembly. Writing software libraries in assembly is useful, but few bother to do it because they'd rather just buy more hardware. Chugging out twice a many chips, once you have your design finished, isn't really that much more expensive, as I understand it.

Re:Epiphany-V: A 1024-core 64-bit RISC processor by executesorder66 on Wednesday October 05, 2016 @02:40PM (#12646556)
> but we were forbidden by our EDA vendor to release the code.

Why? Is there anything that could be done to change that?

Re:Epiphany-V: A 1024-core 64-bit RISC processor by PhilWright on Wednesday October 05, 2016 @11:44PM (#12650098)
You should investigate the RISC-V project.

It is an open source RISC based ISA along with open source implementations of example processor cores. Then you could have had a processor that was completely open and did not include any proprietary code.

https://riscv.org/