Hello. I'm a compiler

by andremedeiros • 13 years ago

472 152 13 years ago

You can see the upvote counter constantly being updated ATM :)

mjs• 13 years ago

Ugh, it's being edited constantly too! Someone just removed the "Hello" from the first line, which was part of what made it great...

ygra3• 13 years ago

For some reason that change was attributed to me when all I did was adding a comma after the »Hello« o.ô

EDIT: Ouch. I think those are SO's automatic attempts at making answers less chatty by removing salutations and thanks and the like. I'll rollback or try fixing it by doing evil Unicode things, then.

MojoJolo• 13 years ago

Boo. I read it with "Hello" and at that moment, I knew it will be a great read. Why someone remove it?

friendly_chap5• 13 years ago

Stackoverflow is plagued by overzealous editing IMHO. I understand it's hard to balance it, but a question of mine recently got 3 downvotes and a close, to be reopened later! And now it even has 2 upvotes.

A guy answered it immediately, while some other peeps started whining about how it is not a proper question! I only wanted a quick fix, and I got it too, while the others nitpicked.

Hilarious.

qompiler2• 13 years ago

Hello. I'm a programmer.

I noticed you couldn't optimize my code to use SIMD so I went ahead and used inline assembly. It will probably take another 30 years before you can actually think like a human and perform optimizations like this.

friendly_chap5• 13 years ago

Hello, I am your project manager, I thought you were working on the project XYZ, please come into my office.

MrScruff• 13 years ago

You obviously don't work in games...

Scaevolus• 13 years ago

30 years? ICC already does automatic vectorization pretty well. LLVM and GCC have implementations that need more tuning. I bet they'll be solid within 5 years.

You still beat them with inline assembly, but you probably won't accelerate the code vectorwidth times anymore.

raverbashing4• 13 years ago

Exactly

ICC is the best one, but GCC from 4.0 could do it "automatically" (being very loose about the term)

And no one does inline assembly for that, they use intrinsics

pjmlp4• 13 years ago

Commercial compiler vendors tend to invest more in code generation quality as open source developers.

After all they need to provide reasons why you would buy them.

potkor2• 13 years ago

This paper from 2011 compares autovectorization in GCC against two proprietary compilers, from Intel and IBM: http://polaris.cs.uiuc.edu/~garzaran/doc/pact11.pdf

GCC got a 23% speedup vs 15% for XLC and 28% for ICC. GCC did well considering the proprietary compilers' narrow focus and corporate resources.

BTW, Fortran compilers for the 1980's supers did autovectorization pretty well. Funny that we've made it so hard today.

exDM693• 13 years ago

> 30 years? ICC already does automatic vectorization pretty well. LLVM and GCC have implementations that need more tuning. I bet they'll be solid within 5 years.

Unfortunately, the automatic vectorization compilers do is not very smart and is targeted at simple scalar loops in existing code bases. In many cases, a decent programmer can easily outperform the compiler with simple SIMD tricks, especially in cases where you can use clever vector shuffling tricks (e.g. sum of 4 numbers with 2 additions + 2 vector shuffles).

To get the best of both worlds, use compiler/machine specific intrinsic functions or vector extensions with a smart optimizing compiler. Clang's vector extensions work really well.

nwmcsween• 13 years ago

Gcc does not vectorize to simd ins without more work than just using intrins. Gcc will vectorize to word size though

lucian1900• 13 years ago

Actually, most modern compilers can vectorize for you. They are limited by imperative idioms of course, but much of the time they do a good job.

anonymouz• 13 years ago

Ignoring for a moment that compilers are getting better at automatic vectorization, using a compiler allows you to write highly optimized inline assembly for the (usually) tiny parts of the code where it really matters, and gives you the convenience of a high level language everywhere else.

bad_user• 13 years ago

It takes a really good developer with vast knowledge to do optimizations such as using "inline assembly" for stuff like SIMD. And even though there are enough good developers able to do this, the mother of all problems when developing software is managing complexity.

Yes, you can take a subroutine and apply local optimizations on it. Building complex software in assembly that on the whole is better optimized than what a compiler can do is next to impossible.

Speaking of SIMD and stuff like it, there are already optimizations that LLVM is doing, but such optimizations are hard to apply ahead of time because (1) if you want to distribute those binaries easily, then you need to compile for the common denominator (which is less of an issue with LLVM) and (2) your programming language sucks. It's not the compiler's fault, but rather your own fault that you're using a programming language so confusing that inferring intent from your code is next to impossible. How can the compiler know that you're sorting freaking numbers if you're specifying exactly how bits move around in memory while doing so?

If you're speaking about virtual machines though, there are projects out there for .NET or Scala for instance that can recompile/retarget code at runtime to run with SIMD instructions or on your GPUs if you have any. All you need is a virtual machine that runs bytecode and a programming language (slash compiler) that lets you access at runtime the syntax trees of the routines that you want to optimize and that lets you generate new bytecode. So you can easily shove this kind of optimizations in libraries for special-purpose and descriptive DSLs (e.g. LINQ).

Of course, it gets tricky and doing stuff like this at runtime has overhead, but it's better than what 99.99% of developers can do, not to mention that good developers first and foremost ship.

eru4• 13 years ago

> It's not the compiler's fault, but rather your own fault that you're using a programming language so confusing that inferring intent from your code is next to impossible.

And that's the long-running argument for why high-level languages have the possibility to be compiled to faster code eventually. We are mostly still waiting for the languages and compilers. (Even though ghc gives us hope.)

pjmlp4• 13 years ago

Hello I am a processor.

I have picked up your clever optimized SIMD and decided it was better to change the execution order, because another unit was bored without nothing to do.

Unfortunately the L2 cache seems to have some issues getting all required data for your instructions due to the way all your threads are manipulating the required addresses from multiple cores.

qompiler2• 13 years ago

I have to admit this is the painful truth. The speed of the vector operations didn't actually improve using SSE3. But that doesn't dismiss the issue with compilers not being able to actually vectorize properly.

potkor2• 13 years ago

> It will probably take another 30 years before you can actually think like a human and perform optimizations like this.

ITYM "It will probably take another 30 years before I use a language that tells you what the required semantics of the code are, meanwhile I'll use my requirements interpretation privileges to relax the semantics in a few places"

exDM693• 13 years ago

Hello, this is the compiler calling back at you. I am very sorry that I cannot write efficient SIMD code but neither can you. If we can work together, we will outperform our individual selves as a team.

So you go ahead and write clever SIMD code but please use the SIMD intrinsics I can understand, not inline assembler which I cannot do anything with. You are very good in expressing algorithms in a SIMD friendly way and do a decent job in instruction selection.

You, however, are not very good in doing instruction scheduling and register allocation, so let me handle that and we can achieve a result that can keep the CPU pipelines busy. When you make the tiniest change to the program, I can re-do instruction scheduling and register allocation in an instant, when that would take you hours to rewrite the whole algorithm to use different registers.

my point: SIMD intrinsics + a smart C compiler produces a lot better code than a programmer writing assembly. Clang + vector extensions in particular is very good at it.

loup-vaillant2• 13 years ago

Reminds me that the best current chess player is actually a team mixing humans and computers. Even in that domain where computers are undoubtedly better than humans, the best solution still involve humans.

to3m• 13 years ago

This has never quite been my experience. Look-mummy-my-first-SIMD-routine is usually within spitting distance of the compiler's best effort, and a lot neater-looking. Then you can just take it from there.

The compiler's output is far from useless, because compilers generally know a few tricks and/or cute sequences that you can copy. And using intrinsics is certainly better than relying on it to automatically vectorize things itself - I've never heard of that do anything remotely interesting. But, even though it's 2013, it still seems like the compiler is easier to beat by hand than you'd think.

I make no claim that this is worth doing in every case.

(As for the suggestion that the compiler can't rearrange inline assembly language, or provide symbolic register names - whyever not? Perhaps people have been conditioned by gcc and VC++ never to expect anything except the absolute bare minimum from inline assembly language support, but that's no reason to assume that these tasks are impossible. Code Warrior for Wii would rearrange assembly language for you to avoid holdups due to instruction latencies, and while automatically assigning registers for you. I believe most modern assemblers will do similar reordering and at least let you assign names to the registers you're using.)

dbecker• 13 years ago

Hello. I'm another programmer.

I noticed that it takes forever to understand inline assembly. I don't foresee myself ever thinking like a computer and reading assembly as well as a high-level language.

yen223• 13 years ago

It isn't closed or locked? Huh.

ygra3• 13 years ago

Only questions are closed or locked, I think. And only if they are not very good questions that will just lead to debate or opinions but should stay around out of historical interest. This here is a question that can be answered reasonably but has a single whimsical answer. So no need of closing or locking here.

And even though the tone of that answer is humourous it still is a good answer, explaining why we don't all write Assembly instead of HLLs.

andremedeiros2• 13 years ago

Yeah, I thought it was a great read as well. That answer pops to my mind every now and again.

BitMastro• 13 years ago

Aaaand it's closed. I hate that SO can close a question as "non constructive" while I find it constructive instead.

sonergonul2• 13 years ago

Not closed or locked. In SO, only the questions can closed, answers and questions can locked. But this question is open for everybody, for now..

Achshar• 13 years ago

It was just closed as not constructive.

Swizec3• 13 years ago

Fascinating, while I was reading that, it got 5 upvotes! Mindblowing.

This is a really awesome description too. The only thing I know about compilers is that I implemented one for class (without fancy optimisations) and I am surprised any software works, ever. Compiler are just ... mindbogglingly complex things. Almost as much voodoo dark magic as engineering.

perlgeek• 13 years ago

One of the reason software still works is that compilers are (mostly ()) very easy to test. Just just need an input source code, and expected outcome (either compiler error, or the result when running the code). No intermediate state to consider, no concurrency, no test database to set up etc.

Oh, and many serious compilers can compile themselves, so bootstrapping is a pretty good test too.

Another reason is that compilers simply must* work for software development to continue, so people have spend the necessary amount of energy to get implementation and tests "right".

(*) There are always exceptions, like when a compiler auto-parallelizes code and introduces a race condition that is rarely triggered. But those cases are blessedly rare.

Swizec3• 13 years ago

Testing was the hardest thing I came across.

You have on your hands a compiler that you can no longer think of a program for, that would produce an incorrect result. You're happy.

Then your friend comes along and the first thing they try behaves incorrectly.

The problem isn't even that the compiler would crash and burn, it lovingly compiles the input program into something that does the wrong thing!

eru4• 13 years ago

What did you write your compiler in? Writing compilers in, say, raw C is indeed a complex endeavour. But using, say, OCaml or Haskell (which is secretly a DSL for compiler writing) should make it much easier to not fail silently.

Swizec3• 13 years ago

We used Java and a bunch of professor supplied code to speed us along. The input language was a subset of Pascal.

Xcelerate• 13 years ago

The poor compilers do the best with what they have. And by "what they have", I mean the things they can't make assumptions about. Which turns out to be a crapload. Until that happens, very highly-tuned assembly will continue to outperform the best compilers.

Of course, a more typical scenario is hand-tuning a few loops where 99% of the clock cycles occur and letting the compiler take care of the rest.

(Also, I was attempting to send a Morse code message by flashing the vote counter between up and down, but I don't think anyone got it :( )

timmipetit• 13 years ago

I saw the flashing vote counter, and was just thinking that SO was getting funky.

andremedeiros2• 13 years ago

I will meet you at said coordinates and bring the pineapple you've requested.

andrewaylett• 13 years ago

I used to work on a compiler for an embedded system. One fun trick we used while writing the run-time libraries was to write them in C, then optimise the generated assembly (possibly by rewriting it from scratch), then fix the compiler so it generated that assembly :). Sometimes that did require using (and occasionally adding) new intrinsics.

eru4• 13 years ago

How stable where those fixes? I.e. if you made slight changes to the C code, did the optimizations still kick in?

keeperofdakeys• 13 years ago

There are some magic keywords, like const, which definitely help the compiler. Unfortunately these kinds of optimisations are far too numerous, and soon become tedious. After a certain point, more structured languages could allow much more rigid optimisation. These days JIT seems to have taken over though, which isn't really a bad thing.

AshleysBrain2• 13 years ago

Const doesn't actually help compilers (at least in C/C++ based languages). Since it can be const_cast away and still work in a standards compliant way, any optimisation assuming const values never change is a bug. Instead the compiler will use other techniques, e.g. finding variables that are only written to on initialisation, and those don't even need to be marked const.

bitwize2• 13 years ago

Oh God. Don't get me started on const.

    const char * const fuck_this(const char *shit) const;

Thing #1: In C++ the word "const" can mean many things depending on position and inflection: declaring a symbol an actual constant; a pointer argument has in (as opposed to in-out) semantics; a function has no side effects. I keep forgetting which use of const does what.

Thing #2: Each use of const, regardless of meaning, induces a different type. Which makes API design a pain in the ass since you can't pass in stuff that wasn't declared with the same constness if the procedure expects const parameters without casting the parameters. I actually worked on a codebase where a guy broke much of our code by checking in a "fix" for our APIs to make them comply with what he considered best practice regarding constness.

Thing #3: Passed-in pointers and references are not 'const' by default. You should have to declare intent to clobber their referents.

Thing #4: And as someone said downthread, you can cast around it in most cases anyways.

This is why I say, if you're thinking of using C++, reach for Ada instead. Ada's reputation has been necessarily tainted by whiners complaining about its verbosity. But I swear that figuring out a page of Ada code is easier than figuring out a few lines of sufficiently complicated C++. For one thing, in Ada, function/procedure parameters are 'in' (i.e., const) by default, and you must declare intent to modify parameters in side effects by declaring them 'in out'.

codeflo• 13 years ago

Most of all, the compiler can't change the layout of your data. Many of the use cases for hand-crafted assembly involve SIMD instructions, which perform several operations in parallel. These vector instructions can be incredibly fast, but their limitations often mean that you need to carefully design the data structures of the whole program around the optimization of one single critical loop.

colanderman5• 13 years ago

I've written lots of code that either GCC has autovectorized into SIMD instructions, or that I've represented using GCC's vector types which produce SIMD instructions. While it is true that a poor choice of data structure will preclude SIMD optimizations, use of a compiler does not preclude the same.

zurn• 13 years ago

> the compiler can't change the layout of your data

Sure it can, this is the most promising optimization avenue currently. Not just on the micro level to make data layout more SIMD-friendly, but more cache friendly object layout etc.

Modern systems are primarily memory bound, not ALU bound, so squeezing out clock cycles from computations is pretty far in the dimishing returns territory.

C/C++ have forbidden these kinds of optimizations but it's a the future (tm) in high level languages.

orangethirty3• 13 years ago

As someone who is working on a project where the CTO demands more LOC, this makes me warm inside.

raverbashing4• 13 years ago

Yes, from that comment I think I can infer what CTO means in this context

You can easily go creative on this

eru4• 13 years ago

That should be hard to believe, save for my honed cynicism. Could you please elaborate?

orangethirty3• 13 years ago

I'm working on a project where the CTO of this huge company is criticizing the lack of code I'm writing. Doesn't matter the fact that my code meets every criteria. No functionality is being left out. But, he wants more code. It has been very difficult for me to deal with this, because its the first time I have ever faced such idiocy.

jordanwallwork• 13 years ago

Am I the only one just enjoying watching the upvotes rocketing up on SO?

quorn3000• 13 years ago

NO!

shared4you• 13 years ago

I upvoted when the counter was 520. Now it is 1500! (or more, by the time you read this :)

EDIT: Looks like it's locked at 1788!

johncoltrane• 13 years ago

This is the first time I see the vote count grow by 10 in real time. Impressive stuff.

ck24• 13 years ago

Are they pushing those realtime vote counts with websockets? Pretty slick. Beats polling by far.

Looks like IE is holding it back as usual:

https://developer.mozilla.org/en-US/docs/WebSockets#Browser_...

ygra3• 13 years ago

Unless my eyes are strange that page says it's supported on IE.

ck24• 13 years ago

This chart is easier to read:

http://caniuse.com/#feat=websockets

Only IE10 and above. And IE Mobile would be dubious.

Even older safari 5.1 has partial support but not IE.

Surprised to see android mobile does not have support - is that chart correct?

adieulot• 13 years ago

Yes that’s websockets it seems. Must be quite a overhead, they use it on all answers.

Trufa• 13 years ago

But it's awfully cool when you see it going up or down :)

naiquevin• 13 years ago

Yes, it's websockets. You can check it in Chrome by keeping the console open and refreshing the page. Would be interesting to test in IE.

BTW, as much as I am amazed to see websockets in action, the real time updating of vote count feels creepy and distracting at the same time :-)

KyleBrandt• 13 years ago

We currently have ~ 128k open sessions for sockets (They all go through HAProxy).

They socket server process runs on 9 web servers, and each service is using less than 1% CPU at the moment.

So very efficient from a sysadmin perspective (We did some tuning with conntrack so only the outside is tracked on the load balancers).

Devs could give a lot more detail.

gdalgas• 13 years ago

You can read a bit more about our implementation here: http://meta.stackoverflow.com/questions/168145/sockets-used-...

gilgoomesh• 13 years ago

Cute. Although I think my compiler has different things to say.

Hello, I'm a C compiler that still can't handle C99. I hope you're wearing waterproof clothing because I'm gonna throw up on you. Also, I've been drinking heavily so your C++ code is going to take a while to compile and when it's done, it's gonna smell funny.

valdiorn• 13 years ago

Visual C++ ? :)

pjmlp4• 13 years ago

C++ compiler != C compiler

ck24• 13 years ago

Isn't Steve Gibson ( http://www.grc.com/stevegibson.htm ) still coding large, complex programs in pure assembly?

His work on spinrite is legendary, for those born before IDE hard drives were invented.

B-Con• 13 years ago

From his podcasts I hear that it is pure assembly. He's borderline machine, though.

dschiptsov3• 13 years ago

It is funny how people want to believe in tools. In fact, the optimizations compiler does are incomparable with those programmer could do by choosing an appropriate data-structure with corresponding algorithms and by being aware of strengths and weakness of a particular CPU architecture.

JVM, which is nothing but a stack-based byte-code interpreter is the most famous case.) People seems to believe it can do wonders, especially in memory management and data throughput.

It is so strange to see how people are trying to create a whole world inside a JVM. What it is called when people are building models of ships inside a bottle?)

btw, now, it seems, they are trying to build a whole world inside a V8 bottle.)

lmm2• 13 years ago

My experience in the industry is just the opposite; people will do anything to avoid admitting that the tools can do better than they than. I've had senior programmers sneeringly declare that anyone who uses a debugger must be an inferior programmer, and then watched them spend a full day figuring out a bug that could be found in half an hour with the appropriate tool.

You know why it's worth recreating the world inside a JVM? Because its behaviour is so much more thoroughly specified and predictable. Prior to Java, C++ didn't even have a memory model; every new release of GCC breaks a whole raft of C programs that didn't realise they were invoking undefined behaviour by having integer overflow. By the C standard, even a single instance of undefined behaviour invalidates your whole program, making it virtually impossible to predict the behaviour of any nontrivial-sized codebase.

dschiptsov3• 13 years ago

In my opinion it is a computer architecture that has a memory model, not Java or C++.

For some strange reasons nginx - a mere C program - works for millions. So does postgresql or redis or whatever.

jawerty• 13 years ago

It's even better when you read what the question was.

detay• 13 years ago

Yet another spark of genius from ssg.

sonergonul2• 13 years ago

Yeah..

majmun• 13 years ago

Compiler got AI human language capabilities?

Nikolas0• 13 years ago

Now I can't wait to get a message from the kernel :D

Arjuna• 13 years ago

Anytime I read about the topic of assembly language, I can't help but think of Michael Abrash. For example, check out Chapter 22 [1] from his Graphics Programming Black Book entitled Zenning and the Flexible Mind for a pleasant stroll down Optimization Lane.

You might also enjoy his book entitled The Zen of Assembly Language which features the Zen Timer (a timing tool for performance measuring).

[1] http://downloads.gamedev.net/pdf/gpbb/gpbb22.pdf

mmphosis• 13 years ago

Hello, I am a programmer.

I have little idea what modern day compilers are doing, or what the CPU, or the operating system is doing for that matter. Often, way too often, compilers fail, hardware fails, operating systems fail, lots of things fail. I am not going to read the millions of lines of code written by other programmers (in f-ing emacs no less) in the any number of differing complex beasts, the compilers. It seems crazy-making to me, that other programmers would create compilers that would use millions of possibilities of optimizing a single line of mine using hundreds of different optimization techniques based on a vast amount of academic research that I won't be spending years getting at. I do feel embarrassed, yes very icky, that I have little to no idea what a three-line loop will be compiled as, but bloat would be my guess. There is risk in going to great lengths of optimization or doing the dirtiest tricks. And if I don't want the compiler to do this, I have no idea how to stop this behavior, nor do I want to invest in the specific knowledge of the nuances any particular compiler. The compiler does not allow me easy access because the compiler itself is an overly complex piece of software written by other programmers. I could care less about how a compiler would make my code would look in assembly, on different processor architectures and different operating systems and in different assembly conventions. Transformation comes with how we as programmers write code, not in compiler-fu.

P.S. Oh, and by the way if I really wasn't using half of the code I wrote, I would throw the source code away.

simias3• 13 years ago

You seem to be saying that you're at the same time completely clueless about how programs get built and executed and yet you know better that the compiler what needs to be done.

I've found that in the general case Compilers Know Better. It might not be true for very simple and limiter architecture such as small microcontrolers, but modern CPUs are so much complex and "quirky" that most of the time the compiler will beat you.

These days I only use assembly for very low level stuff where I need complete control of the execution flow (dealing with cache invalidation, MMU etc...) or some very specific and aggressive optimisation (like implementing <string.h> in ASM).

But hey, if you want to ditch C and write everything in ASM, be my guest (as long as we don't work together).

wbl• 13 years ago

The reverse is actually true. On simple orthogonal architectures the compiler is much more able to take advantage of all the features, while on x86 there are many instructions a compiler will never generate because of limitations on when they can be used. A human can occasionally do better then the necessarily limited algorithm used for scheduling and instruction selection.

cliffbean• 13 years ago

> I have little to no idea what a three-line loop will be compiled as, but bloat would be my guess.

This is unfortunately too often true. Some compilers are tuned too much for looking good on artificial benchmarks, in which turning 3-line loops into thousands of instructions sometimes helps, even if it hurts on most real-world code.

> And if I don't want the compiler to do this, I have no idea how to stop this behavior, nor do I want to invest in the specific knowledge of the nuances any particular compiler.

The -O0 option, or its equivalent, is pretty easy to find in many compilers. If you're happy with the performance of your code without all those fancy techniques being applied, feel free to use it. Most people aren't ;-).

> P.S. Oh, and by the way if I really wasn't using half of the code I wrote, I would throw the source code away.

Only if you were aware of it ;-). I wish that compilers would focus a little more on helping me make my code better, rather than so much on magically making things better under the covers.

JasonFruit• 13 years ago

If you want your compiler to do more to help you improve your source, you might like Go, which offers a lot of (sometimes unwelcome) mandatory suggestions that force you to do the right thing even when you don't want to. (Ada and Pascal do the same thing according to a very different philosophy.)

ncallaway3• 13 years ago

Even better for him, -O0 is the default (for most compiler's I've worked with). You need to opt-in to optimizations most of the time.

kaffeinecoma• 13 years ago

I never noticed that the Stackoverflow js pulls updates for vote tallies in real-time. Browsing this answer while HN is sending lots of traffic there is almost like watching a car odometer.

mrleinad• 13 years ago

Really? HN is now including witty posts in Stackoverflow as news?

opminion• 13 years ago

Ah, the irony of Knuth being the proponent of Literate Programming, and at the same time the last man standing in general purpose assembly.

Breakthrough• 13 years ago

And on the Fourth Day, God proclaimed "Thou shalt have the ability to use inline assembly in thy C/C++ code for performance-critical tasks".

I can think of absolutely zero reason to write an entire program in x86 assembly, let alone any other kind of assembly (GCC spits out some pretty optimized code for my little Atmel MCU)... It's a lot nicer to write everything in a high-level, and then write any performance specifics in inline assembly.

The really cool thing to see is how other newer languages have adopted this scheme (e.g. PyASM for Python, or the ability to edit the instructions for interpreted languages that run in their own VM). And as always, great power comes with great responsibility ;)

ohwp• 13 years ago

"I can think of absolutely zero reason to write an entire program in x86 assembly,"

I can think of 2 reasons: study and fun.

tedajax• 13 years ago

For x86 I'd say study but I don't think there's any fun to be had there. Something like MIPS32 would be pretty fun because that instruction set actually makes sense to a human.

drp4929• 13 years ago

Now a days, compiler writers sees zero reason to write inline assembly.

First of all, it throws a wrench in high level optimizer's analysis. Plus, compilers and processors are getting smarter day by day while inline assembly in shipping code becomes more and more untouchable everyday.

tomjen3• 13 years ago

You have never written embedded code, or code to deal with low level hardware in drivers?

I haven't either, but I imagine ASM would be required here.

dragontamer2• 13 years ago

Hello. I'm an assembly programmer. I used a compiler to generate the majority of code, and can hand-craft any assembly that comes out of it. I understand how compilers auto-generate SIMD instructions can be more easily compiler-generated if I make a "struct of arrays" instead of "an array of structs".

TLDR: Real performance programmers need to understand the assembly a compiler generates if they hope to tune the compiler to generate optimal assembly. Also, GCC -O3 is prone to removing too much code and reordering it, causing memory barrier issues and the like. All multi-threaded programmers need to understand how the compiler generates assembly (ie: by reordering your code), and how it can generate new bugs if you don't use the right compiler flags.

colanderman5• 13 years ago

Also, GCC -O3 is prone to removing too much code and reordering it, causing memory barrier issues and the like.

Whoah, that's what __sync_synchronize() and volatile are for. If you're trying to write order-dependent multithreaded code without those, the bug's in your code, not in compiler flag juju.

oliland• 13 years ago

This answer purports a myth that compilers are magical black boxes, the sum of millions of hours of intense academic research that "you will never understand".

Replace "compiler" with "computer". Doesn't that make you angry? Answers like these do nothing but prevent people from learning about them.

If you are interested in compilers, here's Edinburgh University's notes from the course "Compiling Techniques", probably a good place to start. Don't let internet tough-guys stop you from learning.

http://www.inf.ed.ac.uk/teaching/courses/ct/

kami8845• 13 years ago

>computers are magical black boxes, the sum of millions of hours of intense academic research

Isn't that awesome? I can use the thing without ever understanding what it does :) I'm so glad my car works without me ever having to know anything about how it works. I know it requires some form of money (gas) to work. That's it. Money in -> Transport out. Perfect.

The linked post never proclaimed no one "will ever understand" compilers. That's just what you're reading into it. You try to get upset at it, so you do. It merely proclaims that compilers are incredibly complex, which is the nice thing about them. If compilers were stupid they'd be a lot less useful.

endlessvoid94• 13 years ago

He's just saying the answer makes compilers sound intimidating.

Confusion• 13 years ago

That doesn't make me angry. I fully accept there are aspects of the stack that allow me to type this message that I will never understand.

Can you e.g. explain how a transistor works, from basic quantum mechanical principles? If not, then there's something in the stack you may never understand, because you're simply not interested in spending the time necessary to understand that at the level a physicist does.

Spooky23• 13 years ago

Keep in mind that it's an answer to the question "Why don't we program in assembly?"

Computer Science majors should be familiar with how compilers work and the theory behind them. But the answer to the question is that for 99% of cases, using a higher-level language and leaving the optimization to a compiler written by subject matter experts makes sense. (ie. Don't re-invent the wheel.)

ncallaway3• 13 years ago

I think you might have misinterpreted the context of "optimizing a single line of yours using hundreds of different optimization techniques based on a vast amount of academic research that you would spend years getting at" was lost.

He isn't saying compilers are based on a "millions of hours of intense academic research that you won't understand". He's saying the specific optimizations implemented by these compilers are based on "millions of hours of intense academic research that you won't understand".

While the general theory behind compilers isn't particularly complex (and is totally worth learning! Your message about people learning about compilers is spot on), production compilers do employ a significant number of complex optimizations. You won't be able to match these unless you spend a very significant amount of effort learning about these specific optimization techniques.

While learning the theories behind compilers is quite useful, I'd argue that learning N tricks to more efficiently translate C into ASM isn't practical unless you want to turn your compiler into a production one.

Scriptor• 13 years ago

Sure you can understand the basics of a compiler from a college course on them. But what sets apart industrial level compilers is all the accumulated knowledge built into them. Students are expected to understand the whole compiler they build for class. But how many people understand every single optimization that GCC can do?

My point is, there's understanding how compilers work, and then there's understanding all of GCC. I wouldn't like it if someone made the former sound too intimidating for me, but I don't mind feeling intimidated by the latter.

davidroberts• 13 years ago

The best comment: "Thank you compiler, but perhaps if you weren't commenting on StackOverflow, you could get me a drink and play some nice music while you're working?"

cobrausn• 13 years ago

This was linked in the comments (by the author):

https://www.facebook.com/sedatk/posts/10151240841812644

Sedat Kapanoglu · 2,372 followers

3 hours ago near Maslak, Istanbul

Today I was at the Istanbul courthouse third time this year. I attended a trial defending myself to a judge. Then I bore my testimony to a prosecutor about a different case. Both cases were about the free speech platform I own in Turkey. Meanwhile in the world, one of my older posts in Stackoverflow became Hackernews #1 & reddit/programming #1. I wish it was Turkey which made me feel better about myself, not the rest of the world.

dragontamer2• 13 years ago

Hey, my name is ICC, and I'm one of the most respected compilers in the industry. I also sabotage your code so that it works poorly on AMD CPUs, while making sure that Intel CPUs run my code at full speed. After all, Intel likes to establish market dominance.

http://www.agner.org/optimize/blog/read.php?i=49#49

Blind trust in the compiler is bad people. Good luck discussing this issue without any Assembly Programers who can fully understand what is going on here.

_kst_2• 13 years ago

http://imagemacros.files.wordpress.com/2009/07/hianteater.jp...

Hello. I'm a compiler

Related Stories