Linked by MOS6510 on Fri 17th May 2013 22:22 UTC
Hardware, Embedded Systems "It is good for programmers to understand what goes on inside a processor. The CPU is at the heart of our career. What goes on inside the CPU? How long does it take for one instruction to run? What does it mean when a new CPU has a 12-stage pipeline, or 18-stage pipeline, or even a 'deep' 31-stage pipeline? Programs generally treat the CPU as a black box. Instructions go into the box in order, instructions come out of the box in order, and some processing magic happens inside. As a programmer, it is useful to learn what happens inside the box. This is especially true if you will be working on tasks like program optimization. If you don't know what is going on inside the CPU, how can you optimize for it? This article is about what goes on inside the x86 processor's deep pipeline."
Thread beginning with comment 562120
To view parent comment, click here.
To read all comments associated with this story, please click here.
RE[5]: Comment by Drumhellar
by Alfman on Mon 20th May 2013 04:03 UTC in reply to "RE[4]: Comment by Drumhellar"
Alfman
Member since:
2011-01-28

theosib,


I'd like to say software engineers could figure it out given widely accessible hardware, but I might be overestimating our abilities ;) Most CS grads these days just end up becoming ridiculously overqualified web devs since that's where most jobs are.


"The holy grail is being able to convert software source code into logic gates. There's plenty of work on that, but the results aren't necessarily all that great. There's a huge difference in performance between a custom-designed FPGA circuit (i.e. knowing what you're doing) versus something that came out of an automatic translator."


This surprises me a bit. Even though the human mind is an incredible analytical machine, it has it's limits whereas computers just keep getting better. In the Kasparov vs Deep Blue chess championship, it was inevitable that the brute force capabilities of the computer would ultimately overtake the best humans, the only question was when.

At university I made a realtime 3d java program to place components on a virtual circuit board using genetic algorithms and a fitness function. It was just a fun project I presented for an undergrad GA course I was taking, to be honest I don't know if it's solutions were any good since it was never compared against expert solutions. But in any case my gut instinct tells me that given enough computing power, even a naive algorithm should be able to brute force the finite solution space and consistently beat the best humans. I do believe you when you say automatic solutions aren't as good as experts, however do you think that could change if there were more computing power thrown at the FPGA problem?

I'm interested in what you have to say about it because I don't have expertise with FPGAs and I don't personally know anyone else who does either.

Reply Parent Score: 2

RE[6]: Comment by Drumhellar
by theosib on Mon 20th May 2013 14:12 in reply to "RE[5]: Comment by Drumhellar"
theosib Member since:
2006-03-02

My opinion is that this is less about more compute power and more about the limits of compiler developers. This reminds me of Ray Kurzweil's stupid singularity thing, which seems to imply that the instant that computers are as fast as the human brain, they'll magically develop human intelligence. It doesn't matter how fast they are if we don't know the algorithms for human intelligence. And we still don't.

There's the same problem with compilers. I'm reminded of two events in computer history. One is LISP machines, and the other is Itanium. In both cases, hardware designers assumed that a "sufficiently smart compiler" would be able to take advantage of their features. But people were not able to develop those sufficiently smart compilers. Consider predicated execution for Itanium. Predication turns out to be a hard problem. With architectures (like ARM32) that have only one predicate, it gets used SOME of the time. Itanium has an array of 64 predicate bits. Humans can specially craft examples that show the advantages of the Itanium ISA, but compilers just don't exist that can do that well in the general case.

Reply Parent Score: 3

RE[7]: Comment by Drumhellar
by Alfman on Mon 20th May 2013 15:22 in reply to "RE[6]: Comment by Drumhellar"
Alfman Member since:
2011-01-28

theosig,

"This reminds me of Ray Kurzweil's stupid singularity thing, which seems to imply that the instant that computers are as fast as the human brain, they'll magically develop human intelligence. It doesn't matter how fast they are if we don't know the algorithms for human intelligence. And we still don't."

I don't know if I could believe that. I think we might eventually get computers that are convincing enough to mentally pass as human and be indiscernible in every non-physical test, and yet I'd still have alot of trouble considering that any such invention could be sentient because I "know" that it's not, but then again it's hard to understand what consciousness is at all.


"There's the same problem with compilers. I'm reminded of two events in computer history. One is LISP machines, and the other is Itanium. In both cases, hardware designers assumed that a 'sufficiently smart compiler' would be able to take advantage of their features."

I know what you mean, however it's not necessarily the case that we'd have to solve such problems directly. With brute forcing (or optimized variants like genetic algorithms) the programmer doesn't solve the problem at all, but writes a fitness function who's sole purpose is to rate the success of solutions that are derived in random and/or evolutionary ways.


There was a pretty awesome game I played (a java applet) many years ago where you would specify the fitness function, and the game would evolve 2d "creatures" with muscles and basic neurons and after a few thousand iterations you'd have creatures that could walk. More iterations and they could avoid obstacles. Maybe it would be possible to develop a genetic algorithm for the compiler as well. It's kind of what I meant earlier, even naive (unintelligent) approaches like this can produce good results, given enough iterations.

Reply Parent Score: 2