Need For Speed II SE - BY ----DBX----- RePack
Hugues Abidi
The cabin features adjustable sliding sport seats upholstered in black leather with embossed Caterham logos and six-point Schroth harnesses. There are imperfections in the vinyl dash covering around the voltmeter, the floor carpet piping is torn off, and there is a tear in the driver-seat headrest.
The microsuede Motamec quick-release steering wheel fronts Caterham-branded instrumentation including a 160-mph speedometer, an 8k-rpm tachometer, and auxiliary gauges for oil pressure, fuel level, coolant temperature, and voltage. The digital odometer indicates 17k miles, approximately 2k of which have been added during current ownership. The gas gauge does not work, and the speedometer reads incorrectly. A Momo flat-bottom steering wheel is included in the sale.
The 1,700cc Ford Cosworth inline-four was reportedly rebuilt in 2015 and features a Titan Motorsports dry-sump system, a replacement steel block, forged pistons, CP Carrillo connecting rods, a low-temp thermostat, and Dellorto DHLA 45 twin carburetors. Work under current ownership is said to have included a carburetor cleaning and replacement of the throttle cable, coolant hoses, thermostat, radiator fan switch, oil breather and return tubes, sump gasket, oil tank O-ring seal, and fuel line. The engine hesitates at 3k-rpm, and there is an oil leak.
Power is sent to the rear wheels via a BGH Geartech five-speed manual transmission and a Titan limited-slip differential. The exhaust system features stainless steel four-to-one headers and a Raceco silencer that was reportedly repacked with Acousta-fil PTX Exhaust silencer packing. A skid plate was installed beneath the exhaust silencer under current ownership.
When you bid we pre-authorize your credit card for the service fee (this helps prevent fraud). If you win the auction, your card will be charged for the service fee and you pay the seller directly for the vehicle. If you don't win, the pre-authorization will be released.
EXCHANGE RATES: You are bidding for this item in USD. This means, if you have the winning bid, you will need to make your payment to the seller in [USD]. It is your responsibility to check the conversion rate, and you should also note that exchange rates may fluctuate between now and the due date of your payment after the end of the auction.
TAXES: If you are the highest bidder, you will also need to pay the seller any applicable taxes/VAT. Your bid may not be inclusive of these amounts. Relevant details are included in the listing, so please ensure you have read and understood this information before placing your bid. Note that, if you will need to import the vehicle to your country, you may be responsible for import-related taxes.
Programming language development has been influenced by hardware design. One example from this answer mentions how C pointers were, at least in part, influenced by the design of the PDP-11. Has the reverse taken place, where a construct provided by a language drove the development of hardware?
To be clear, I'm wondering about core language constructs, like pointers for example, rather than industry consortiums coming up with something like OpenGL then being implemented in hardware. Perhaps hardware floating-point support?
It's a myth to suggest C's design is based on the PDP-11. People often quote, for example, the increment and decrement operators because they have an analogue in the PDP-11 instruction set. This is, however, a coincidence. Those operators were invented before the language was ported to the PDP-11.
In the former category we have most of the interesting eventual dead ends in computer hardware history. Perhaps the one of the earliest examples of a CPU architecture being targeted at a high level language is the Burroughs B5000 and its successors. This is a family of machines targeted at Algol. In fact, there wasn't really a machine language as such that you could program in.
The B5000 had a lot of hardware features designed to support the implementation of Algol. It had a hardware stack and all data manipulations were performed on the stack. It used tagged descriptors for data so the CPU had some idea of what it was dealing with. It had a series of registers called display registers that were used to model static scope* efficiently.
Other examples of machines targeted at specific languages include the Lisp machine already mentioned, arguably the Cray series of supercomputers for Fortran - or even just Fortran loops, the ICL 2900 series (also block structured high level languages), some machines targeted at the Java virtual machine (some ARM processors have hardware JVM support) and many others.
One of the drivers behind creating RISC architectures was the observation that compilers tended to use only a small subset of the available combinations of instructions and addressing modes available on most CPU architectures, so RISC designers ditched the unused ones and filled the space previously used for complex decoding logic with more registers.
In the second category, we have individual features in processors targeted at high level languages. For example, the hardware stack is a useful feature for an assembly language programmer, but more or less essential for any language that allows recursive function calls. The processor may build features on top of that for example, many CPUs have an instruction to create a stack frame (the data structure on the stack that represents a function's parameters and local variables).
*Algol allowed you to declare functions inside other functions. Static scope reflects the way functions were nested in the program source - an inner function could access the variables and functions defined in it and in the scope in which it was defined and the scope in which that scope was defined all the way up to global scope.
And not just a few instructions, but whole CPUs have been developed with languages in mind. Most prominent maybe Intel's 8086. Already the basic CPU was designed to support the way high level languages handle memory management, especially stack allocation and usage. With BP a separate register for stack frames and addressing was added in conjunction with short encodings for stack related addressing to make HLL programs perform. The 80186/286 went further in this direction by adding Enter/Leave instructions for stack frame handling.
While it can be said that the base 8086 was geared more toward languages like Pascal or PL/M (*1,2), later incarnations added many ways to support the now prevalent C primitives - not at least scaling factors for indices.
Since many answers pile now various details of CPUs where instructions may match up (or not), there are maybe two other CPUs worth mentioning: The Pascal Microengine and Rockwells 65C19 (as well as the RTX2000).
The Pascal Microengine was a WD MCP1600 chipset (*3) based implementation of the virtual 16 bit UCSD p-code processor. Contrary to what the name suggests, it wasn't tied to Pascal as a language, but a generic stack machine tailored to support concepts for HLL operations. Beside a rather simple, stack based execution, the most important part was a far reaching and comfortable management of local memory structures for functions and function linking as well as data. Modern time Java Bytecode and its interpreter as a native Bytecode CPU (e.g. PicoJava) isn't in any way a new idea (*4).
The Rockwell R65C19 is a 6500 variant with added support for Forth. Its 10 new threaded code instructions (*5) implemented the core functions (like Next) of a Forth system as single machine instructions.
Forth as a language was developed with a keen eye on the way it is executed. It got more in common with Assemblers than many other HLL (*6). So it's no surprise that, already in 1983, its inventor Charles Moore created a Forth CPU called N4000 (*7).
*2 - Stephen Morse's 8086 primer is still a good read - especially when he talks about the finer details. Similar and quite recommended his 2008 interview about the 8086 creation where he describes his approach as mostly HLL driven.
One interesting example of programming languages driving hardware development is the LISP machine. Since "normal" computers of the time period couldn't execute lisp code efficiently, and there was a high demand for the language in academia and research, dedicated hardware was built with the sole purpose of executing lisp code. Although lisp machines were initially developed for MIT's AI lab, they also saw sucess in computer animation.
These computers provided increased speed by using a stack machine instead of the typical register based design, and had native support for type checking lisp types. Some other important hardware features aided in garbage collection and closures. Here's a series of slides that go into more detail on the design: Architecture of Lisp Machines (PDF) (archive).
The architecture of these computers are specialized enough that in order to run c code, the c source is transpiled into lisp, and then run normally. The Vacietis compiler is an example of such a system.
Yes. Case in point, the VAX. The instruction set design was influenced by the requirements of the compiled languages of the day. For example, the orthogonality of the ISA; the provision of instructions that map to language constructs such as 'case' statements (in the numbered-case sense of Hoare's original formulation, not the labelled-case of C), loop statements, and so on.
I am not claiming the VAX is unique in this respect, just an example I know a little about. As a second example, I'll mention the Burroughs B6500 'display' registers. A display, in 1960s speak, is a mechanism for efficient uplevel references. If your language, such as Algol60, permits declaration of nested procedures to any depth, then arbitrary references to the local variables of different levels of enclosing procedure require special handling. The mechanism used (the 'display') was invented for KDF9 Whetstone Algol by Randell and Russell, and described in their book Algol 60 Implementation. The B6500 incorporates that into hardware:
b1e95dc632