Machine-level primitives A
machine instruction, usually generated by an
assembler program, is often considered the smallest unit of processing although this is not always the case. It typically performs what is perceived to be one operation such as copying a
byte or
string of bytes from one
computer memory location to another or adding one
processor register to another.
Microcode primitives Many of today's
computers, however, actually embody an even lower unit of processing known as
microcode which interprets the
machine code and it is then that the microcode instructions would be the
genuine primitives. These instructions would typically be available for modification only by the
hardware vendor's programmers.
High-level language primitives A
high-level programming language (HLL) program is composed of discrete
statements and
primitive data types that may also be
perceived to perform a single operation or represent a single data item, but at a higher semantic level than those provided by the machine. Copying a data item from one location to another may actually involve many
machine instructions that, for instance, • calculate the address of both
operands in
memory, based on their positions within a
data structure, • convert from one
data type to another before finally • performing the final store operation to the target destination. Some HLL statements, particularly those involving
loops, can generate thousands or even millions of primitives in a
low-level programming language (LLL), which comprise the genuine
instruction path length the processor has to execute at the lowest level. This perception has been referred to as the
abstraction penalty.
Interpreted language primitives An
interpreted language statement has similarities to the HLL primitives, but with a further added
layer. Before the statement can be executed in a manner very similar to an HLL statement: it must first be processed by an
interpreter, a process that may involve many primitives in the target machine language.
Fourth and fifth-generation language primitives Fourth-generation programming languages (4GL) and
fifth-generation programming languages (5GL) do not have a simple one-to-many correspondence from high-to-low level primitives. There are some elements of interpreted language primitives embodied in 4GL and 5GL specifications, but the approach to the original problem is less a
procedural language construct and are more oriented toward
problem solving and
systems engineering. ==See also==