Misplaced Pages

#224775

75-499: The original Motorola 68000 family implementation of the Macintosh operating system executes system calls using that processor's illegal opcode exception handling mechanism. Motorola specified that instructions beginning with 1111 and 1010 would never be used in future 68000 family processors, thus freeing them for use as such by an operating system. Further, they each had their own dedicated interrupt vector , separate from

150-520: A 25 MHz 486 and 30 MHz 68040, including floating-point unit support, with the product aiming for mid-1993 production at a per-unit cost of $ 50 to 60 . Amidst the apparent proliferation of emulation support in processors such as the PowerPC 615 , in 1994, IMS had reportedly filed a patent on its emulation technology but had not found any licensees. Repeated delays to the introduction of this product, blamed on one occasion on "a need to improve

225-465: A scaled indexing address mode, and added another level of indirection to many of the pre-existing modes. Most instructions have dot-letter suffixes, permitting operations to occur on 8-bit bytes (".b"), 16-bit words (".w"), and 32-bit longs (".l"). Most instructions are dyadic , that is, the operation has a source, and a destination, and the destination is changed. Notable instructions were: Motorola mainly used even numbers for major revisions to

300-450: A 68020 or a 68030 would force the machine into 24-bit mode, and would only recognize and address the first 8 megabytes of RAM, an obvious flaw in machines whose hardware was wired to accept up to 128 MB RAM – and whose product literature advertised this capability. With System 7, the Mac system software was finally made 32-bit clean, but there were still the problem of dirty ROMs. The problem

375-426: A Palm or Windows application is finished with a handle, it calls MemHandleUnlock or Global/LocalUnlock . Palm OS and Windows keep a lock count for blocks; after three calls to MemHandleLock , a block will only become unlocked after three calls to MemHandleUnlock . Addressing the problem of nested locks and unlocks can be straightforward (although tedious) by employing various methods, but these intrude upon

450-743: A bootloader within an HFS filesystem—a reason having nothing to do with the Toolbox or "old-fashioned" Macs in general. More narrowly, the Startup Disk control panel in the Classic Mac OS and later macOS only allows the user to select a mounted filesystem with very particular constraints. In Mac OS X , the Toolbox is not used at all, though the Classic Environment loads the Toolbox ROM file into its virtual machine. Much of

525-653: A nonsense address. An application accidentally treating a fragment of text or image, or an unassigned location as a pointer could easily overwrite the code or data of other applications or even the OS, leaving "lurkers" even after the program was exited. Such problems could be extremely difficult to analyze and correct. Switcher evolved into MultiFinder in System 4.2, which became the Process Manager in System 7 , and by then

600-592: A performance cost, but did not add protected memory or prevent the memory manager's heap compaction that would invalidate some pointers. Originally the Macintosh had 128 KB of RAM, with a true limit of 4 MB, despite being soldered. This limit was first reached with the Macintosh Plus and its user upgradable memory. These first few Macintosh computers use the 68000 CPU, a 32-bit processor, which has only 24 physical address lines. The 24 lines allow

675-679: A revised 68060, likely with a superior FPU (pipelining was widely speculated upon on Usenet). There was a CPU with the 68070 designation, which was a licensed and somewhat slower version of the 16/32-bit 68000 with a basic DMA controller, I²C host and an on-chip serial port. This 68070 was used as the main CPU in the Philips CD-i . This CPU was, however, produced by Philips and not officially part of Motorola's 680x0 lineup. The 4th-generation 68060 provided equivalent functionality (though not instruction-set-architecture compatibility) to most of

750-668: A similar scheme for memory management, but the Palm and Windows versions make programmer error more difficult. For instance, in Mac OS, to convert a handle to a pointer, a program just de-references the handle directly, but if the handle is not locked, the pointer can become invalid quickly. Calls to lock and unlock handles are not balanced; ten calls to HLock are undone by a single call to HUnlock . In Palm OS and Windows, handles are an opaque type and must be de-referenced with MemHandleLock on Palm OS or Global/LocalLock on Windows. When

825-478: A simple scheme that worked well with those particular constraints. That design choice did not scale well with the development of the machine, creating various difficulties for both programmers and users. The primary concern of the original engineers appears to have been fragmentation – that is, the repeated allocation and deallocation of memory through pointers leading to many small isolated areas of memory which cannot be used because they are too small, even though

SECTION 10

#1732775552225

900-595: A variety of systems, from high-end Texas Instruments calculators (the TI-89 , TI-92 , and Voyage 200 lines) to all of the members of the Palm Pilot series that run Palm OS 1.x to 4.x (OS 5.x is ARM -based), and even radiation-hardened versions in the critical control systems of the Space Shuttle . The 680x0 CPU family became most well known for powering desktop computers and video game consoles such as

975-566: A way other than flagging the high bits of handles. But many Macintosh application programmers and a great deal of the Macintosh system software code itself accessed the flags directly rather than using the APIs, such as HLock() , which had been provided to manipulate them. By doing this they rendered their applications incompatible with true 32-bit addressing, and this became known as not being "32-bit clean". In order to stop continual system crashes caused by this issue, System 6 and earlier running on

1050-405: Is also worth noting its earlier, bigger and more professional counterpart, the "DraCo" (1995). The groundbreaking Quantel Paintbox series of early based 24-bit paint and effects system was originally released in 1981 and during its lifetime it used nearly the entire range of 68000 family processors, with the sole exception of the 68060, which was never implemented in its design. Another contender in

1125-470: Is separate from the carry flag . This permits the extra bit from arithmetic, logic, and shift operations to be separated from the carry for flow-of-control and linkage. While the 68000 had a 'supervisor mode', it did not meet the Popek and Goldberg virtualization requirements due to the single instruction 'MOVE from SR', which copies the status register to another register, being unprivileged but sensitive. In

1200-628: Is the stack pointer , and assemblers accept the label SP as equivalent to A7. In addition, it has a 16-bit status register. The upper 8 bits is the system byte, and modification of it is privileged. The lower 8 bits is the user byte, also known as the condition code register (CCR), and modification of it is not privileged. The 68000 comparison, arithmetic, and logic operations modify condition codes to record their results for use by later conditional jumps. The condition code bits are "zero" (Z), "carry" (C), "overflow" (V), "extend" (X), and "negative" (N). The "extend" (X) flag deserves special mention, because it

1275-611: The Jaguar includes a 68000 intended for basic system control and input processing, but was frequently used for running game logic. Many arcade boards also use 68000 processors including those from Capcom, SNK, and Sega. The first several versions of Adobe's PostScript interpreters were 68000-based. The 68000 in the Apple LaserWriter and LaserWriter Plus was clocked faster than the version used then in Macintosh computers. A fast 68030 in later PostScript interpreters, including

1350-563: The Mac OS nanokernel , which offered few services directly useful to applications. The Toolbox is composed of commonly used functions, but not the most commonly used functions. As a result, it grew into a hodgepodge of different API libraries . The Toolbox encompasses most of the basic functionality which distinguished the Classic Mac OS. Apple's references “Inside Macintosh: Macintosh Toolbox Essentials” and “Inside Macintosh: More Macintosh Toolbox”, similarly vague in scope, also document most of

1425-445: The Macintosh 128K , Amiga , Sinclair QL , Atari ST , Genesis / Mega Drive , NG AES / Neo Geo CD , CDTV . They were the processors of choice in the 1980s for Unix workstations and servers such as AT&T's UNIX PC , Tandy's Model 16/16B/6000 , Sun Microsystems' Sun-1 , Sun-2 , Sun-3 , NeXT Computer , Silicon Graphics (SGI), and numerous others. The Saturn uses the 68000 for audio processing and other I/O tasks, while

1500-468: The Motorola 68010 and later, this was made privileged, to better support virtualization software. The 68000 series instruction set can be divided into the following broad categories: The Motorola 68020 added some new instructions that include some minor improvements and extensions to the supervisor state, several instructions for software management of a multiprocessing system (which were removed in

1575-558: The P5 Pentium line, but it was not nearly as widely used as its predecessors, since much of the old 68000 marketplace was either defunct or nearly so (as was the case with Atari and NeXT), or converting to newer architectures ( PowerPC for the Macintosh and Amiga , SPARC for Sun , and MIPS for Silicon Graphics (SGI)). There are dozens of processor architectures that are successful in embedded systems . Some are microcontrollers which are much simpler, smaller, and cheaper than

SECTION 20

#1732775552225

1650-844: The PDP-11 or VAX usually feel comfortable with the 68000 series. With the exception of the split of general-purpose registers into specialized data and address registers, the 68000 architecture is in many ways a 32-bit PDP-11. It had a more orthogonal instruction set than those of many processors that came before (e.g., 8080) and after (e.g., x86). That is, it was typically possible to combine operations freely with operands, rather than being restricted to using certain addressing modes with certain instructions. This property made programming relatively easy for humans, and also made it easier to write code generators for compilers. The 68000 series has eight 32-bit general-purpose data registers (D0-D7), and eight address registers (A0-A7). The last address register

1725-588: The QUICC and the DragonBall . With the advent of FPGA technology an international team of hardware developers have re-created the 68000 with many enhancements as an FPGA core. Their core is known as the 68080 and is used in Vampire-branded Amiga accelerators. Magnetic Scrolls used a subset of the 68000's instructions as a base for the virtual machine in their text adventures . During

1800-605: The Space Shuttle . Although no modern desktop computers are based on processors in the 680x0 series, derivative processors are still widely used in embedded systems . Motorola ceased development of the 680x0 series architecture in 1994, replacing it with the PowerPC RISC architecture, which was developed in conjunction with IBM and Apple Computer as part of the AIM alliance . 68010 : 68020 : 68030 : 68040 : 68060 : The 680x0 line of processors has been used in

1875-578: The System suitcase from disk (in fact before ROMs on NuBus cards were executed), which is when the decision to use 24-bit or 32-bit addressing has to be made. (System 7's support for 32-bit addressing requires 32-bit clean ROMs, as older Mac ROMs do not have support for this). The need for diagnostics as in the BIOS resident for IBM PC compatibles ' boards is not necessary since the Macintosh has most of its diagnostics in POST and automatically reports errors via

1950-461: The disk partition selected as the boot device . The boot blocks then verify that a suitable rudimentary environment exists, and use it to load the System suitcase. A different operating system with a different file system can boot by simply using its own code in the boot blocks. This system was not used for PowerPC Linux, however, because Open Firmware in New World ROM machines requires

2025-412: The " Sad Mac " codes. The similarity between the boot-up environment and the actual operating system should not be confused with being identical, however. Although the "Classic Mac OS" boot process is convoluted and largely undocumented, it is not more limited than an IBM PC compatible BIOS. Like a PC's master boot record , a ROM-based Mac reads and executes code from the first blocks ("boot blocks") of

2100-457: The 1980s and early 1990s, when the 68000 was widely used in desktop computers, it mainly competed against Intel 's x86 architecture used in IBM PC compatibles . Generation 1 68000 CPUs competed against mainly the 16-bit 8086 , 8088 , and 80286 . Generation 2 competed against the 80386 (the first 32-bit x86 processor), and generation 3 against the 80486 . The fourth generation competed with

2175-601: The 256-entry OS dispatch table of later ROM revisions.) In 1994, Apple released Macintoshes using the PowerPC architecture, which lacked hardware support for the A-trap mechanism available on 68k systems. Because of their use in applying software patches, however, the dispatch tables were retained. The API library code underlying any Toolbox routine then does nothing except reference the dispatch table. The dispatch table linked only to emulated 68000 family code. Toolbox functions implemented in native PowerPC code have to first disable

2250-488: The 68000 family have been used in a huge variety of applications. CPU32 and ColdFire microcontrollers have been manufactured in the millions as automotive engine controllers. Many proprietary video editing systems used 68000 processors, such as the MacroSystem Casablanca, which was a black box with an easy to use graphic interface (1997). It was intended for the amateur and hobby videographer market. It

2325-420: The 68000, while others are relatively sophisticated and can run complex software. Embedded versions of the 68000 often compete with processor architectures based on PowerPC , ARM , MIPS , SuperH , and others. 32-bit clean Historically, the classic Mac OS used a form of memory management that has fallen out of favor in modern systems. Criticism of this approach was one of the key areas addressed by

Macintosh Toolbox - Misplaced Pages Continue

2400-478: The 68030 instruction set and reportedly offering a performance rating of 16 VAX MIPS. Similar deals with Nixdorf Computer and Hitachi were also signed in 1989. Edge Computer reportedly had an agreement with Motorola. Despite increasing competition from RISC products, Edgcore sought to distinguish its products in the market by emphasising its "alliance" with Motorola, employing a marketing campaign drawing from Aesop's fables with "the fox (Edgecore) who climbs on

2475-481: The 68060 was in development, that the Intel 80486 was not progressing as quickly as Motorola assumed it would, and that 68060 was a demanding project, the 68050 was cancelled early in development. There is also no revision of the 68060 , as Motorola was in the process of shifting away from the 68000 and 88k processor lines into its new PowerPC business, so the 68070 was never developed. Had it been, it would have been

2550-412: The 68060), some support for high-level languages which did not get used much (and was removed from future 680x0 processors), bigger multiply (32×32→64 bits) and divide (64÷32→32 bits quotient and 32 bits remainder) instructions, and bit field manipulations. The standard addressing modes are: Plus: access to the status register , and, in later models, other special registers. The Motorola 68020 added

2625-421: The A-trap as a parameter. This is true of the most commonly used subroutines. However, the Toolbox was composed of the less commonly used subroutines. The Toolbox was defined as the set of subroutines which took no parameters within the A-trap, and were indexed from a 1024-entry, 4-kilobyte dispatch table . (Machines shipped with less than one megabyte of RAM use a single table of 512 entries, which corresponds to

2700-491: The CPU core such as 68000, 68020, 68040 and 68060. The 68010 was a revised version of the 68000 with minor modifications to the core, and likewise the 68030 was a revised 68020 with some more powerful features, none of them significant enough to classify as a major upgrade to the core. There was no 68050, though at one point it was a project within Motorola. Odd-numbered releases had always been reactions to issues raised within

2775-413: The Mac OS memory model. While the Mac OS memory model, with all its inherent problems, remained this way right through to Mac OS 9 , due to severe application compatibility constraints, the increasing availability of cheap RAM meant that by and large most users could upgrade their way out of a corner. The memory was not used efficiently, but it was abundant enough that the issue never became critical. This

2850-467: The Mac – first Object Pascal , then later C++ – also caused problems for the memory model adopted. At first, it would seem natural that objects would be implemented via handles, to gain the advantage of being relocatable. These languages, as they were originally designed, used pointers for objects, which would lead to fragmentation issues. A solution, implemented by the THINK (later Symantec ) compilers ,

2925-598: The Macintosh II, which used the 32-bit Motorola 68020 CPU. The 68020 had 32 physical address lines which could address up to 4 GB of memory. The flags that the Memory Manager stored in the high byte of each pointer and handle were significant now, and could lead to addressing errors. On the Macintosh IIci and later machines, HLock() and other APIs were rewritten to implement handle locking in

3000-875: The Sun Microsystems Sun-1 , Sun-2 and Sun-3 , the NeXT Computer , NeXTcube , NeXTstation , and NeXTcube Turbo , early Silicon Graphics IRIS workstations, the Aesthedes , computers from MASSCOMP , the Texas Instruments TI-89 / TI-92 calculators, the Palm Pilot (all models running Palm OS 4.x or earlier), the Control Data Corporation CDCNET Device Interface, the VTech Precomputer Unlimited and

3075-493: The Toolbox was restructured and implemented as part of Apple's Carbon programming API, allowing programmers familiar with the Toolbox to port their program code more easily to Mac OS X. Motorola 68000 family The Motorola 68000 series (also known as 680x0 , m68000 , m68k , or 68k ) is a family of 32-bit complex instruction set computer (CISC) microprocessors . During the 1980s and early 1990s, they were popular in personal computers and workstations and were

Macintosh Toolbox - Misplaced Pages Continue

3150-518: The Toolbox. Because much of the Toolbox is implemented in ROM, alongside the computer's firmware , it was convenient to use as a bootloader environment. In conjunction with resources stored on the ROM chip, the Toolbox can turn the screen gray, show a dialog box with the signature "Welcome to Macintosh" greeting, and display the mouse cursor. By using Toolbox to help boot the machine, a rudimentary Mac-like environment can be initialized before ever loading

3225-430: The advent of Switcher , which was a way for a Mac with 512 KB or more of memory to run multiple applications at once. This was a necessary step forward for users, who found the one-app-at-a-time approach very limiting. Because Apple was now committed to its memory management model, as well as compatibility with existing applications, it was forced to adopt a scheme where each application was allocated its own heap from

3300-402: The advent of System 7) placed flags in the high 8 bits of each 32-bit pointer and handle . Each address contained flags such as "locked", "purgeable", or "resource", which were stored in the master pointer table. When used as an actual address, these flags were masked off and ignored by the CPU. While a good use of very limited RAM space, this design caused problems when Apple introduced

3375-419: The allocation function should take a boolean parameter, or there should be two allocation functions. To pass a parameter would require an additional two-byte instruction, which would be inefficient. Having two functions would require at least an extra four bytes of RAM used for the address in the function look-up table. The most efficient solution is to map multiple A-traps to the same subroutine, which then uses

3450-545: The application quit, fragmentation was minimized. The memory management system had weaknesses; the system heap was not protected from errant applications, as would have been possible if the system architecture had supported memory protection , and this was frequently the cause of system problems and crashes. In addition, the handle-based approach also opened up a source of programming errors, where pointers to data within such relocatable blocks could not be guaranteed to remain valid across calls that might cause memory to move. This

3525-414: The appropriate task and performs it. There were two advantages to this mechanism: The system was further optimized by allotting some bits of the A-trap instruction to store parameters to the most common functions. For example, memory allocation is a very common task, so it should be expressed in as few bytes of code as possible. Sometimes the programmer wants to clear the memory block to zeros, so either

3600-426: The available RAM. The amount of actual RAM allocated to each heap was set by a value coded into the metadata of each application, set by the programmer. Sometimes this value wasn't enough for particular kinds of work, so the value setting had to be exposed to the user to allow them to tweak the heap size to suit their own requirements. While popular among " power users ", this exposure of a technical implementation detail

3675-457: The back of the stallion (Motorola) to pluck fruit off the higher branches of the tree". Other folktale advertising themes such as Little Red Riding Hood were employed. With the company's investors having declined to finance the company further, and with a number of companies having been involved in discussions with other parties, Arix Corp . announced the acquisition of Edgcore in July 1989. Arix

3750-505: The basis of comments made by an Intel representative who had characterised TechSearch's business model unfavourably in remarks to the press. After the mainline 68000 processors' demise, the 68000 family has been used to some extent in microcontroller and embedded microprocessor versions. These chips include the ones listed under "other" above, i.e. the CPU32 (aka 68330 ), the ColdFire ,

3825-420: The change to Mac OS X . The original problem for the engineers of the Macintosh was how to make optimum use of the 128 KB of RAM with which the machine was equipped, on Motorola 68000 -based computer hardware that does not support virtual memory . Since at that time the machine could only run one application program at a time, and there was no fixed secondary storage , the engineers implemented

SECTION 50

#1732775552225

3900-492: The chip's speech-processing capabilities", apparently led to the company seeking to introduce another chip, the Meta6000 , aiming to compete with Intel's P6 products. Ultimately, IMS entered bankruptcy having sold patents to a litigator, TechSearch, who in 1998 attempted to sue Intel for infringement of an IMS patent. TechSearch reportedly lost their case but sought to appeal, also seeking to sue Intel for "libel and slander" on

3975-515: The company introduced the Edge 1000 range of "32-bit superminicomputers implementing the Motorola instruction set in the Edge mainframe architecture", employing two independent pipelines - an instruction fetch pipeline (IFP) and operand executive pipeline (OEP) - relying on a branch prediction unit featuring a 4096-entry branch cache, retrieving instructions and operands over multiple buses. An agreement between Edge Computer and Olivetti subsequently led to

4050-453: The data. If a memory request required compaction of memory, this was done and the table, called the master pointer block, was updated. The machine itself implemented two areas in memory available for this scheme – the system heap (used for the OS), and the application heap. As long as only one application at a time was run, the system worked well. Since the entire application heap was dissolved when

4125-620: The emulator using the Mixed Mode Manager. For the sake of uniformity and extensibility, new function entries even continued to be added to the Toolbox after the PowerPC transition. An alternative mechanism did exist, however, in the Code Fragment Manager, which was used to load and dynamically link native PowerPC programs. The PowerPC system call facility, analogous to the A-trap mechanism, was used to interface with

4200-613: The features of the Intel P5 microarchitecture . The Personal Computers XT/370 and AT/370 PC-based IBM-compatible mainframes each included two modified Motorola 68000 processors with custom microcode to emulate S/370 mainframe instructions. An Arizona-based company, Edge Computer Corp , reportedly founded by former Honeywell designers, produced processors compatible with the 68000 series, these being claimed as having "a three to five times performance – and 18 to 24 months’ time – advantage" over Motorola's own products. In 1987,

4275-416: The generic illegal opcode handler. As 1111 was reserved for use by co -processors such as the 68881 FPU , Apple chose 1010 ( A in hexadecimal ) as the prefix for operating system calls. Handling illegal instructions is known as trapping , so these special instructions were called A-traps . When the processor encounters such an instruction, it transfers control to the operating system, which looks up

4350-470: The latter introducing products in its own "Linea Duo" range based on Edge Computer's machines. The company was subsequently renamed to Edgcore Technology Inc. (also reported as Edgecore Technology Inc. ). Edgcore's deal with Olivetti in 1987 to supply the company's E1000 processor was followed in 1989 by another deal with Philips Telecommunications Data Systems to supply the E2000 processor, this supporting

4425-994: The primary competitors of Intel 's x86 microprocessors. They were best known as the processors used in the early Apple Macintosh , the Sharp X68000 , the Commodore Amiga , the Sinclair QL , the Atari ST and Falcon , the Atari Jaguar , the Sega Genesis (Mega Drive) and Sega CD , the Philips CD-i , the Capcom System I (Arcade), the AT&;T UNIX PC , the Tandy Model 16/16B/6000 ,

4500-473: The prior even numbered part; hence, it was generally expected that the 68050 would have reduced the 68040's power consumption (and thus heat dissipation), improved exception handling in the FPU, used a smaller feature size and optimized the microcode in line with program use of instructions. Many of these optimizations were included with the 68060 and were part of its design goals. For any number of reasons, likely that

4575-601: The processor to address up to 16 MB of memory (2 bytes), which was seen as a sufficient amount at the time. The RAM limit in the Macintosh design was 4 MB of RAM and 4 MB of ROM with the remaining 8 MB addresses split between the SCC, IWM and VIA chips , because of the structure of the memory map. This was fixed by changing the memory map with the Macintosh II , allowing up to 8 MB of RAM, by shrinking ROM and I/O addresses to 1 MB each and allocating

SECTION 60

#1732775552225

4650-461: The readability of the associated code block and require awareness and discipline on the part of the coder. Awareness and discipline are also necessary to avoid memory "leaks" (failure to deallocate within the scope of the allocation) and to avoid references to stale handles after release (which usually resulted in a hard crash —annoying on a single-tasking system, potentially disastrous if other programs are running). The situation worsened with

4725-534: The remaining 6 MB addresses to the NuBus slots. Connectix products MAXIMA, RAM Doubler, and Virtual allowed accessing and reallocating the 6 MB addresses allocated to the NuBus cards for a total of 14 MB, minus 1 MB per slot occupied. Because memory was a scarce resource, the authors of Classic Mac OS decided to take advantage of the unused byte in each address. The original Memory Manager (up until

4800-424: The scheme was long entrenched. Apple made some attempts to work around the obvious limitations – temporary memory was one, where an application could "borrow" free RAM that lay outside of its heap for short periods, but this was unpopular with programmers so it largely failed to solve the problems. Apple's System 7 Tune-up addon added a "minimum" memory size and a "preferred" size—if the preferred amount of memory

4875-663: The standard resolution LaserWriter IIntx, IIf and IIg (also 300 dpi), the higher resolution LaserWriter Pro 600 series (usually 600 dpi, but limited to 300 dpi with minimum RAM installed) and the very high resolution Linotronic imagesetters, the 200PS (1500+ dpi) and 300PS (2500+ dpi). Thereafter, Adobe generally preferred a RISC for its processor, as its competitors, with their PostScript clones, had already gone with RISCs, often an AMD 29000-series. The early 68000-based Adobe PostScript interpreters and their hardware were named for Cold War -era U.S. rockets and missiles: Atlas, Redstone, etc. Microcontrollers derived from

4950-401: The total free memory may be sufficient to satisfy a particular request for memory. To solve this, Apple engineers used the concept of a relocatable handle , a reference to memory which allowed the actual data referred to be moved without invalidating the handle. Apple's scheme was simple – a handle was simply a pointer into a (non-relocatable) table of further pointers, which in turn pointed to

5025-588: The video arena, the Abekas 8150 DVE system, used the 680EC30, and the Play Trinity, later renamed Globecaster, uses several 68030s. The Bosch FGS-4000/4500 Video Graphics System manufactured by Robert Bosch Corporation, later BTS (1983), used a 68000 as its main processor; it drove several others to perform 3D animation in a computer that could easily apply Gouraud and Phong shading. It ran a modified Motorola VERSAdos operating system. People who are familiar with

5100-512: Was a real problem for almost every system API that existed. Because of the transparency of system-owned data structures at the time, the APIs could do little to solve this. Thus the onus was on the programmer not to create such pointers, or at least manage them very carefully by dereferencing all handles after every such API call. Since many programmers were not generally familiar with this approach, early Mac programs suffered frequently from faults arising from this. Palm OS and 16-bit Windows use

5175-515: Was against the grain of the Mac user philosophy. Apart from exposing users to esoteric technicalities, it was inefficient, since an application would be made to grab all of its allotted RAM, even if it left most of it subsequently unused. Another application might be memory starved, but would be unable to utilize the free memory "owned" by another application. While an application could not beneficially utilize another application's heap, it could certainly destroy it, typically by inadvertently writing to

5250-468: Was not available, the program could launch in the minimum space, possibly with reduced functionality. This was incorporated into the standard OS starting with System 7.1, but still did not address the root problem. Virtual memory schemes, which made more memory available by paging unused portions of memory to disk, were made available by third-party utilities like Connectix Virtual, and then by Apple in System 7 . This increased Macintosh memory capacity at

5325-586: Was published by software utility company Connectix , whose System 6 extension, OPTIMA, reinitialized the Memory Manager and repeated early parts of the Mac boot process, allowing the system to boot into 32-bit mode and enabling the use of all the RAM in the machine. OPTIMA would later evolve into the more familiar 1991 product, MODE32 , for System 7. Apple licensed the software from Connectix later in 1991 and distributed it for free. The Macintosh IIci and later Motorola based Macintosh computers had 32-bit clean ROMs. It

5400-447: Was quite a while before applications were updated to remove all 24-bit dependencies, and System 7 provided a way to switch back to 24-bit mode if application incompatibilities were found. By the time of migration to the PowerPC and System 7.1.2, 32-bit cleanliness was mandatory for creating native applications and even later Motorola 68040 based Macs could not support 24-bit mode. The rise of object-oriented languages for programming

5475-527: Was reportedly able to renew its deal with Hitachi in 1990, whereas the future of previous deals with Olivetti and Philips remained in some doubt after the acquisition of Edgcore. In 1992, a company called International Meta Systems (IMS) announced a RISC-based CPU, the IMS 3250 , that could reportedly emulate the "Intel 486 or Motorola 68040 at full native speeds and at a fraction of their cost". Clocked at 100  MHz , emulations had supposedly been developed of

5550-403: Was that the decision to use 24-bit or 32-bit addressing has to be made very early in the boot process, when the ROM routines initialized the Memory Manager to set up a basic Mac environment where NuBus ROMs and disk drivers are loaded and executed. Older ROMs did not have any 32-bit Memory Manager support and so was not possible to boot into 32-bit mode. Surprisingly, the first solution to this flaw

5625-565: Was to use Handles internally for objects, but use a pointer syntax to access them. This seemed a good idea at first, but soon deep problems emerged, since programmers could not tell whether they were dealing with a relocatable or fixed block, and so had no way to know whether to take on the task of locking objects or not. Needless to say this led to huge numbers of bugs and problems with these early object implementations. Later compilers did not attempt to do this, but used real pointers, often implementing their own memory allocation schemes to work around

#224775