When is assembly faster than C?

Question

One of the stated reasons for knowing assembler is that, on occasion, it can be employed to write code that will be more performant than writing that code in a higher-level language, C in particular. However, I've also heard it stated many times that although that's not entirely false, the cases where assembler can **actually** be used to generate more performant code are both extremely rare and require expert knowledge of and experience with assembly. This question doesn't even get into the fact that assembler instructions will be machine-specific and non-portable, or any of the other aspects of assembler. There are plenty of good reasons for knowing assembly besides this one, of course, but this is meant to be a specific question soliciting examples and data, not an extended discourse on assembler versus higher-level languages.Can anyone provide some **specific examples** of cases where assembly will be faster than well-written C code using a modern compiler, and can you support that claim with profiling evidence? I am pretty confident these cases exist, but I really want to know exactly how esoteric these cases are, since it seems to be a point of some contention.

Answer 1

Well, you've laid out the proper foundation for answering this question very well ...

Modern C compilers generate pretty efficient assembly language,

and generally speaking, just as high performing as equivalent human-developer code could

ever be. There are exceptions however - I mean in the universe of application

coding solutions across all processor platforms, how could there not be?

There will be times when the compiler insists on generating code that looks like this:

instruction 1

instruction 2

instruction 3

instruction 4

instruction 5

conditional branch -> instruction 1

when it could have been written more efficiently like this without impacting functionality,

therefore saving 2 instructions per iteration:

some other instruction 1

some other instruction 2

some other instruction 3

conditional branch -> some other instruction 1

What's a specific example?

Can't give you one without running into it first hand ...

But as you say, the gained efficiency needs to be balanced against with other realities - such as

the fact that a human developer now needs to maintain processor-specific assembly language

for functionality that could have been coded in C.

When I started coding processionally in 1982, code generators were less optimized, and

processors were many orders of magnitude slower than they are today.

So notional examples like the above [worth addressing with custom assembly code]

would have been more commonplace then than now.

Without hard data to back me up, I'll still go out on a limb here and say that we would be

more hard pressed to encounter such examples in 2019 ...

Anyway, nothing contentious about it if we stay away from general conclusions.

The exceptions to the rule will be context specific:

- application

- C code block

- processor

- ...