Mike Zero Project Files: Fill & Download for Free

This is one of those questions that seem to happen on Quora frequently. It assumes that a certain thing is true, and asks about it. Do we really know that "assembly is faster than C"? And what do we specifically mean when we say that?I guess we can try a little bit of an investigation to see if assembler really is faster than C.To start, I'll make a simple function. As its input, it takes an integer. Its output will be the sum of all the integers from zero to the integer specified as input. For example, if I pass 3, the function should return 6 because 6 == 3 + 2 + 1.Here's my C code:int getSumUpTo(int n) {  int total = 0;  int x;  for (x = 0; x < n; x++) {  total += x;  }   return total; } I'll compile it with Visual Studio, and ask Visual Studio to print out the assembly code generated for my function. Here's the output of that step:; Listing generated by Microsoft (R) Optimizing Compiler Version 17.00.61030.0    TITLE C:\projects\quora1\loop.c  .686P  .XMM  include listing.inc  .model flat  INCLUDELIB LIBCMT INCLUDELIB OLDNAMES  PUBLIC _getSumUpTo ; Function compile flags: /Ogtpy ; File c:\projects\quora1\loop.c _TEXT SEGMENT _n$ = 8 ; size = 4 _getSumUpTo PROC  ; 3 : int getSumUpTo(int n) {   00000 53 push ebx  00001 57 push edi  ; 4 :  ; 5 : int total = 0; ; 6 : int x; ; 7 : for (x = 0; x < n; x++) {   00002 8b 7c 24 0c mov edi, DWORD PTR _n$[esp+4]  00006 33 c9 xor ecx, ecx  00008 33 d2 xor edx, edx  0000a 33 db xor ebx, ebx  0000c 33 c0 xor eax, eax  0000e 83 ff 02 cmp edi, 2  00011 7c 11 jl SHORT $LC10@getSumUpTo  00013 56 push esi  00014 8d 77 ff lea esi, DWORD PTR [edi-1] $LL11@getSumUpTo:  ; 8 : total += x;   00017 42 inc edx  00018 03 c8 add ecx, eax  0001a 03 d0 add edx, eax  0001c 83 c0 02 add eax, 2  0001f 3b c6 cmp eax, esi  00021 7c f4 jl SHORT $LL11@getSumUpTo  00023 5e pop esi $LC10@getSumUpTo:  ; 4 :  ; 5 : int total = 0; ; 6 : int x; ; 7 : for (x = 0; x < n; x++) {   00024 3b c7 cmp eax, edi  00026 0f 4c d8 cmovl ebx, eax  00029 8d 04 0a lea eax, DWORD PTR [edx+ecx]  0002c 5f pop edi  0002d 03 c3 add eax, ebx  0002f 5b pop ebx  ; 9 : } ; 10 :  ; 11 : return total; ; 12 : }   00030 c3 ret 0 _getSumUpTo ENDP _TEXT ENDS END I've been writing assembly language for a long time, but I don't think I'd ever cook up this solution. (Or, I guess I might, if I had some above-average flash of insight that suggested to me it would be better than the brute-force approach that I'd normally take.)The code is interesting because it unrolls the internal loop to do two additions per loop. It then handles the added complexity of the results being off by one if the intended count was odd. You can see this in the above code at address 0017, where EDX is incremented an extra time. Two versions of the "total" variable are kept: one in ECD, and the other in EDX. The branch at 0021 works out the loop.When done, the test and conditional move at 0024 and 0026 end up choosing the correct running total. If the value is wrong, the second value is considered instead.Me, I wrote the simple version using inline assembler:int getSumUpTo2(int n) {   __asm {  mov ecx, n  xor eax, eax label2:  add eax, ecx  loop label2  }; } You can see I just get the input value into ECX, and zero the EAX register. I then add ECX to EAX in a loop; I decrement ECX and keep looking until ECX has gone to zero. At that point, I just exit my code -- the return value is right in EAX like it should be.On my laptop, without doing too much work to get super accurate results, the compiler-produced code is almost 5 times faster than my hand-written assembler. Maybe a different C compiler would have different results; I know that Microsoft's compiler team is top-notch, and works very closely with the processor vendors to make sure they've got lots of insight into how to generate the best code.This example function is pathetically simple. I've been writing software for almost 30 years, and I don't think I've ever needed a function that did exactly this computation. I had some time to answer an interesting question on Quora, so I cooked up this example. It's simple, so we can understand it at a glance. It doesn't require too much outside setup, so we can just have a look at it in a screen of code, or so.In this specific case, the compiler produced faster code than hand-written assembler because the compiler team has implemented a back end optimizer that knows the processor's performance characteristics better than I do. Or, at least, better than I felt like learning to do while I was writing this code.Maybe, if I was more active with assembly language, I'd know the low-level tuning that went into the code generation that the compiler made. (I figure it's about predictive pipelined execution and how to avoid discarded execution. We can go get one of the Intel optimization manuals and read it and figure out it, one day.)But there are two interesting points I'm compelled to make.First, as far as synthetic benchmarks go, this one is pretty bad. It's simple and understandable, which is good. It demonstrates a point for a specific scenario, which is also good. We have to understand that scenario: this code doesn't call anything external. It does lots of work in memory with data that's in memory. It doesn't call the OS to read files, push data out to the network, or draw something on the screen. When those actions happen, the language doesn't matter much -- we're waiting for the external devices or system or services, and that's that.Next, I know something the compiler doesn't. The compiler might learn Euler's formula, and come up with code that doesn't use a loop to calculate this value. Euler says we can figure out the sum of all the integers from 0 to n with a formula that looks like this:[math]\frac{n(n + 1)}{2}[/math]If I code that up, I end up with something that runs very fast, and runs in the same speed no matter the value of n given to it. That is, this solution is O(1) and not O(n) like the other solutions. That makes it pretty boring to benchmark, but it’s substantially faster.int getSumUpTo3(int n) {   return (int) (((n + 1LL) * n) / 2LL); } At this point, I've beaten the compiler by changing my algorithm. The compiler can tune my code a bit and eek out some performance, even at an impressive ratio. But it can't completely re-write my function to solve my problem with a fundamentally better algorithm.

I’ll do my best with this, but that’s a question almost nobody can answer for you in completely concrete terms. Most of us haven’t got the slightest idea what individual companies’ in-house engines look like because they are, by definition, not available to anybody but that company. Those who do have that information are often contractually obligated not to tell you what their engines are like. I can share a few “possible suspects” that would resemble the “big three,” though, and a few general insights on what proprietary engines sometimes look like.The Usual Suspects - These are engines that would probably have at least some surface resemblance to Unity, Unreal, and CryEngine.Hammer 2 - Valve’s proprietary engine. Modding kits exist for some of the games they’ve made using it. Their engine has had full-featured level editing dating back to the original Half-Life, it just hasn’t always been as fancy/WYSIWYG as any of the above.Creation Engine - Bethesda’s engine used for the Elder Scrolls and Fallout. Content import pipeline is not as straightforward, and it has a very specific world-building setup designed to streamline the creation of new patches of its expansive world map. Otherwise you could call it competitive with the above engines.id Tech 6 - id Software’s Quake 3 engine is known for setting many of the precedents that define what modern game engines look like today. It’s a safe bet that id Tech 6 builds off their previous engines and looks/feels similar, with competitive features compared with the above engines.Frostbite 3 - EA and DICE’s proprietary engine for the Battlefield franchise has recently been adopted as EA’s go-to engine for all AAA productions under their umbrella. At this point it’s a fairly mature engine that’s been used variously for Battlefield, Star Wars: Battlefront, Mirror’s Edge, and Mass Effect: Andromeda. Safe money is that it’s pretty robust.Dunia Engine - The original Far Cry was created using an earlier version of CryEngine by CryTek before Ubisoft began working on the IP under their own roof. Dunia Engine is the current name for the engine they’re using, but it has been explicitly built up as a parallel evolution of the original CryEngine. As such it will probably look and feel familiar to anybody who’s used CryEngine.Anvil - Ubisoft’s internal engine for the Assassin’s Creed series. It’s also been used in For Honor, Ghost Recon, and the 2008 Prince of Persia, among others. With as frequent as Ubisoft’s releases with it have come it’s fairly mature, and they’ve stated that they’re trying to integrate C# scripting in addition to its base C++ code. One of its most notable features is procedural structure generation, which is used to cut down on the time required to build urban environments.Fox Engine - RIP, Metal Gear Solid. The proprietary engine developed by Kojima Productions for Metal Gear Solid V, both Ground Zeroes and The Phantom Pain used it. The engine was specialized towards the production of open worlds and had robust cinematic tools. It was to be used for Silent Hills before Konami canned their AAA efforts. Previews of the engine seemed to indicate an intention to license it, and it is known to have an extremely robust world editor.Decima - Guerrilla Games’ proprietary engine used for Killzone Shadow Fall and later Horizon: Zero Dawn. Kojima Productions is notably adopting it for Death Stranding, with Kojima himself noting that it was almost perfectly ideal for his studio’s needs. Decima is known to have a procedural landscape generator that can produce a functioning open-world game environment in a very short time.Insomniac Game Engine - Insomniac, makers of Ratchet and Clank as well as Resistance: Fall of Man and the upcoming Spider-Man game, uses their own engine. Past versions of it feature lua scripting and a level design-centric workflow, though when I spoke with some of their recruiters a few years ago they mentioned a recent move to visual scripting. Known to have VR features, as Insomniac has gone all-in with Oculus.Foundation Engine - Crystal Dynamics’ proprietary engine used for Rise of the Tomb Raider. I don’t know a whole lot about it except that they re-designed it from the ground up to have a rapid iteration level design workflow, the better to support the game’s puzzles, platforming, and extensive Metroid-like network of environments.There’s probably more I haven’t caught, but these are all off the top of my head.Proprietary engines aren’t usually known to be as clean or as user-friendly as the likes of Unreal, Unity, or even modern iterations of CryEngine. When you’re making an engine or a workflow for nobody except yourself it’s not unusual to have inconveniences, rough edges, or hacky work-arounds in the implementation process for ingame content. To that effect you’ll often see proprietary formats for models and images that require special converters; text files that need to be altered by hand in order to add assets to the level editor’s database; or engines that forego having a scripting language at all in favor of just writing everything in C++ code.It’s also not uncommon to have the tools be split between multiple applications rather than being integrated into a single editor the way it is in Unreal and Unity. The Uncharted series, at least up through its PS3 entries, utilized Autodesk Maya as its level editor, for example. The engine would import files output by the level designers in Maya, and objects in the Maya scene would have metadata for the engine to interpret when running gameplay. Metal Gear Solid 4 did something quite similar with SoftImage XSI, though they had a separate application entirely for editing and previewing lighting data in a level.All the engines I’ve listed are meant with specific games or genres of games in mind, and as such are probably not going to be as broadly applicable as something like Unreal, which is designed to give you a highly mutable baseline engine. Their engineers tend to be very dismissive of the likes of Unity and Unreal owing to the fact that a large number of their features are unnecessary for their own specific projects — “bloated” is the term.By comparison, something like Infinity Ward’s engine for the Call of Duty franchise can do one thing and one thing only, that being cinematic first-person shooter gameplay — there is no assumption that you’d do anything else with it at all. At the same time, they hardly ever have to re-program or debug the player pawn’s behavior and the game’s engine is only ever doing exactly what it needs to, with no extraneous graphics features to speak of, giving them buttery-smooth 60 FPS gameplay with little issue.One day I’d love to be able to experience a production with one of these engines to have more of a basis for comparison. Video game production methodology and tools workflows are one of my main interests, and I have to imagine that for as robust as the “big three” have become there’s so many more untapped methods for producing games out there. In the meantime, though, I hope this information has been helpful!

Basically: Chuck Thacker was simply amazing.I recounted some of the history of the Alto in “The Early History of Smalltalk”, and both Butler Lampson and Chuck also wrote histories of that time that included accounts of the Alto development (all can be found via the ACM, and I think they are online also).It was part of the ARPA research M.O. to “compute in the future rather than in the present” by either using existing supercomputers, or by making a kind of supercomputer. There was enough science and engineering substantiation to allow a reasonable faith that the supercomputers of the present would be the commodity computers of the future. Beside needing to try out ideas and designs in many areas, there was also the brute fact that inventing and implementing new software ideas took quite a while to do — with really big dreams, a 10–15 year horizon was needed.I’ve written elsewhere in Quora a few things about the Alto, so I won’t repeat here.Was the Xerox Alto a prototype or a finished product?To what extent did the Xerox PARC Alto inspire the Apple Macintosh?I think I might have also written about “MAXC”, the emulated PDP-10 that was the first project done by the computer researchers at Parc (in 1971). Xerox wouldn’t allow us to buy one (it was in the process of becoming the standard TSS computer on the ARPAnet) — instead they wanted us to use a Xerox Data Systems computer — so everyone almost walked out right at the beginning.We had in Butler Lampson very likely the best OS designer in the world — so we could do our own OS on the XDS machine — but even really good people need 3 or so years to do a good and reliable OS, so that was out. Then the discussion turned to “but we could make an emulated PDP-10 in less than a year” — and — “we could use and learn about the new VLSI DRAM chips from Intel”, etc….Every thing about MAXC (Multiple Access Xerox Computer) was quite different than the DEC PDP-10 (including being much more reliable). This project was headed by Chuck Thacker, and required most of the computer researcher resources then at Parc. The result — in just 9 months — was both a successfully running mainframe machine plus technological leverage, especially with regard to the new DRAM.In parallel, the idea was floating that we would do some kind of a personal computer look-ahead to have an “Interim Dynabook”, to explore serious UIs and local applications, to try distributed computing using local area networks, etc. We decided that it would be worth sacrificing RAM to have a dynamic bitmap display (because then we could show “anything”). We wanted “printing quality fonts” and bitmap painting. I wanted dynamic 2.5D animation and 12 polytimbral voices of music synthesis, etc. We built HW in early 1972 that allowed simulation of all five of these aims. This gave us a pretty crisp understanding of what kind of HW power would be required.We knew that we wanted the microcode of the computers to be able to efficiently emulate byte-codes as fast as main memory could cycle — because we were in the process of inventing a variety of new languages that would be implemented this way (Smalltalk, Mesa, etc.). The parties involved decided in the summer of 1972 on a scheme as to how that could be done nicely.We had all agreed that we would always “engineer for 100 users”, so if we did a personal machine, we had to be able to manufacture 100 of them (in fact, close to 2000 of them were eventually made).The actual project wound up being started — in late Nov 1972 — secretly because of some politics, and — as with a few other projects at Parc — as the result of a bet: Chuck said that a futuristic computer could be done “in three months” and a Xerox exec bet him a case of wine that it couldn’t be done.Even though the DRAM was now understood, and the prior simulations established figures of merit for everything, there was still a lot of work to be done in just 3 months! (For example: designing and building and debugging the first machine!)The Alto was put together partly using wire-wrap technology in one 19 inch rack. Most of the boards were DRAM (128K bytes organized as 16 bit words), and a very fast couple of processor boards which held the 16 program counter zero-overhead-task-switched microcoded CPU and register file. The backplane was also wire-wrapped.Most of the detailed design and much of the building was done by Chuck*. He had two technicians to help (Larry Clark and Mike Overton). Ed McCreight (another of the truly amazing multitalent computerists at Parc, designed the disk interface).Three months later: voila! We used to say: “Chuck just threw the parts at the wall and they fell down Alto!”From left to right: Larry Clark, Chuck Thacker, moi, Ed McCreight, and on the screen the Alto’s first image, a bit-map painting of the Cookie Monster on “Bilbo”, the first Alto. (Mike Overton, not pictured)A closer look at Bilbo at birth, the Cookie Monster, and the board monsterThe Alto could easily emulate 12 high quality polytimbral voices in real-time (and 8 FM voices), and could handle two keyboards and pedals organ console input.The Alto could animate about 120 square inches of bit-map images at 10 frames per second in 2.5D.The happy user in his office at Parc.Chuck with his 2009 Turing Award bowl. He is one of those special people you can’t praise too highly in all respects of his life.We were all shocked when Chuck went away and left us in 2017. It is a vast understatement to say that we miss him greatly* From the Alto Hardware Manual:“The Alto was originally designed by Charles P. Thacker and Edward M. McCreight, and was based on requirements and ideas contributed by Alan Kay, Butler Lampson, and other members of PARC’s Computer Sciences Laboratory and Systems Science Laboratory”