Path: news.cc.utah.edu!news.cs.utah.edu!cs.utexas.edu!uwm.edu!news.alpha.net!news.mathworks.com!uunet!munnari.oz.au!yoyo.aarnet.edu.au!harbinger.cc.monash.edu.au!news.cs.su.oz.au!metro!seagoon.newcastle.edu.au!peach.newcastle.edu.au!c9412417 From: email@example.com (Robert Atkins) Newsgroups: comp.sys.amiga.misc Subject: Re: Next Amiga OS should steal TAOS ideas! Date: 10 Apr 1995 08:43:10 GMT Organization: The University of Newcastle Lines: 473 Message-ID: <firstname.lastname@example.org> References: <email@example.com> NNTP-Posting-Host: peach.newcastle.edu.au X-Newsreader: TIN [version 1.2 PL2]Well, I got one request for more info and that's good enough for me :).
By the way, if the following sounds like advertising spiel, that's because it is. If you disagree with it being posted and have to flame someone, flame me - I'll cheerfully ignore you. I am in no way affiliated with Tantric - I just saw an article in Byte and found the email address. It's long, but read all the way through it and see just how much Micro$loth has blinkered the thinking of the general public. If this is on the market now, just think of what will be possible soon...
Anyway, here are all the tasty specs for Taos. Take a look, you'll be impressed.
The Taos operating system addresses these issues. Its existence and success is good news for technology from small embedded systems through to supercomputers and large scale network applications.
Taos is not conventional, as it has not evolved from an existing operating system. Tao Systems developed Taos taking into account the commercial and technological realities of the time whilst also removing the limitations enforced upon the user market.
Taos exploits the power of the hardware, whilst presenting the programmer with a clean, simple and powerful programming environment. Taos enables programmers to think about the design of their applications in terms of parallel processes. They are completely free to build any structure of processes and communications they need. It is the programmer's responsibility to think about their application and identify the appropriate decomposition into parallel processes. But once this is determined, Taos will manage the distribution of these processes on any target network. Programmers need not concern themselves with the details of the actual hardware and network architecture upon which their applications will run, including adjustments to the network size. Taos grows over all processors available on the network, and will expand if more processors are added; whilst applications grow over the available processors as they create objects during their execution. This means that it is easier to write 'shrink-wrapped' applications for parallel computers using Taos than it is to write them for single processor operating systems, as applications code will run on any processor supported by Taos.
Taos uses a process and communications model of parallelism. Each process can execute on a separate processor, and talk by sending messages to each other. The processes are fast and can only interact by passing messages.
There is deliberately no concept of shared memory, though Taos can be implemented on shared memory machines. Taos does not attempt to evolve from a sequential model; extracting parallelism from sequential programs does not and will not work. So, Taos has been designed as a perfect fit for parallel systems. Taos software exploits parallelism; creating parallel applications using Taos is easy. By creating objects and passing messages, the programmer generates the opportunity for Taos to distribute the objects over processors, and thus generate parallelism.
The final important point to re-emphasise is that it is up to the programmer to write their programs so that the objects can execute in parallel. Parallelism is not automatically created, nor should it be. There are instances where a program must be sequential to behave correctly.
Taos can be ported with little effort to any processor or communications hardware. The only part of Taos that needs to be re-coded to support a new physical processor, is the Translator. The Translator is the program which converts VP code into the native code for the processor. Once the translator is written, all applications written for any processor, in any language which compiles to VP, will become instantly executable on the new processor type. So, to reiterate; programs written on any supported platform will run on all other supported platforms without any changes; you don't even have to recompile.
It would be wrong to think that this slows the system down. Most processors are able to translate VP into native code faster than the VP code can be loaded from disk and sent across the network, so there is no visible overhead. Indeed, VP code is often more compact than the native code; therefore less disk space is used and code is loaded faster than if it were the native for the processor.
If there are particular advantages in using a native version of the code, then this can be stored on disk and will be loaded in preference to the VP version. This would be because the performance of the code would benefit from specific instructions supported in hardware by a particular processor.
A VP version of the code will run on any processor for which a translator is available. There is no need for re-compilation. see Portability, above.
Heterogeneous processing is the exploitation of a range of different types of processor memory and communications hardware to create a versatile parallel computing machine. Such machines may be built from a variety of hardware to support different kinds of computation. For example, a vision system requires a front end to do the initial work on the raw images being received, to find edges, shapes, etc. This stage of the problem is well suited to data parallel hardware, whereas the back end will need to extract meaning from the shapes, which is more suited to implementation on hardware supporting list or network processing. The ability of software to run a variety of hardware is essential for this type of machine to be successfully exploited.
Furthermore, Taos provides access to information about the hardware available in the network. So, programs can take advantage of special purpose hardware to run specific objects. This means that sophisticated adaptive programs can be written within the Taos model to get the most from heterogeneous machines.
Heterogeneous processing is the complete Open System, in which all aspects of the processing are distributed across dissimilar processors, networks and architecture's. It benefits consumers who can select processors on the basis of current price:performance or whichever criteria they select as their priority, without prejudicing future decisions. For manufacturers, it gives them the flexibility to improve hardware design and not become locked into historical decisions for the sake of software compatibility.
The key to Taos' applicability to so many areas lies in its compact kernel. This is all that is needed for a processor to provide all of the Taos services. The Taos kernel provides all the facilities needed to support its simple execution model, yet the whole kernel is only 12K. The kernel executes on every processor in the network from boot, and its facilities include memory management and caching, object creation, distribution and execution, object message passing and tool calling. There are also calls to provide global name management, local timer and scheduling, and access to network hardware information.The programmer is free to add objects to the system as appropriate. Examples of these may be hardware drivers or file system objects.
Taos objects are also parallel processes. Each object which Taos creates is given its own process to execute it. The difference between objects and processes lies what they are about; objects are about data and code, they occupy memory space; processes are about processors, they consume processor time. Put the two together and you have an object which is executing, consuming memory space and processor time. A process brings an object to life.
Objects can only interact with other objects by sending and receiving messages. As objects can exist on separate processors, memory can not be shared between objects. Taos provides a light-weight-mail system to communicate between processors. Messages are just like letters, you send them by posting them in a mail box with an address on it. You use letters to communicate with people to whom you cannot talk directly. So it is also with Taos objects; you use messages to communicate with other objects, as you cannot talk to them directly since they can be on separate processors.
When you send a message you specify the mail address of the recipient. The sending of mail is equivalent to popping a letter into a post-box. Conversely, each process has a mail-box in which mail is placed by the messaging system. Objects receive mail by checking their mail-boxes. Messages are typed, so the object can distinguish between a variety of possible incoming message types. Messages conform to the basic node format, plus extensions, to hold the sender's address and the message's destination address. When mail arrives it is left on a list for the receiving process to look at.
Taos provides a simple mechanism to send messages, there being only two facilities in its messaging system, to send and receive messages. Messages are sent asynchronously; once a message has been sent on its way the sending process is free to continue its execution. Synchronous communication can be achieved by waiting for a returned acknowledge message. Taos' method of communication ensures that parallel processes execute independently of one another for as much of the time as possible. An object may need to wait for a message before it continues processing, but a sending object will not wait until the destination has received it.
The mailing system uses a distributed algorithm which finds multiple paths to a destination and may use more than one route for each message sent, thus making best use of all available communication paths. If one route is bottlenecked then the message will get through via another. The whole conceptual approach to the design, implementation and execution of Taos is organic. A program evolves to fill the network during runtime. Other systems introduce bottlenecks by requiring a system-wide time-stamp on all messages, or by maintaining a central control over the distribution algorithm.
Taos does not attempt to impose a central control over the execution of an application. The kernel is small enough to exist on every processor, providing local services to the objects on its processor and interacting with adjacent processors' kernels to provide message passing and process distribution.
Distribution is based on processes which pass messages. Load balancing (the distribution of processes over the network to maximise the performance of the system) is achieved via a simple algorithm based on the computation and communication requirements of the objects. When an object is created, the loading on the local processor is compared with the loading on neighbouring processors and the object is allocated to the most suitable processor.
Each processor holds minimal routing information for each communications channel to enable messages to be forwarded towards their destinations. Messages are routed to their destinations in much the same way as water flows down through pipes under the effect of gravity.
During the execution of a program, processes distribute themselves over the available processors as they are created. The net effect is that objects spread out over the available processors in much the same way as a liquid spreads out over a surface.
Taos was conceived to take advantage of the reusability and robustness provided by an object based approach to design. Object ideas are exploited at all levels of Taos, from kernel data structures to high level classes. Kernel objects are used to build higher level messaging passing objects.
The basic data node structure used by Taos is inherited by all objects in the system. This enables Taos to manipulate all entities which conform to this very simple structure. Message passing objects, the messages which they pass to each other and the tools which they use to process their data all conform to this basic data structure. New types of object may be introduced by the programmer.
Taos executes objects and manages memory in a very consistent manner. The Taos software model uses processes, messages and objects, whilst its hardware model uses processors with local memory and communication channels between processors. The way to view objects is that they consume memory space, whereas processes consume processor time. An object needs a process to enable it to execute. Upon creation of an object Taos allocates the object to a processor and then allocates a process to execute the object. A typical Taos object is a few hundred bytes in size. So, they lie between fine-grain Smalltalk-style objects and course-grain UNIX-style objects.
The lowest level object in Taos is the 'node'. This is the simplest entity with which Taos deals. It is a variable sized packet of data which can be placed in a doubly linked list. All Taos entities conform to this basic format. From this basic building block, other structures have been grown, such as tools, messages and other types of system object.
Nodes have a type field which identifies what type of Taos object the node holds and hence how it should be processed. Pre-defined types include: Tools, Control Objects, Bitmaps, Graphical Objects and Class Objects. The user can define new types.
Nodes are held in one of two forms. When the node is on disk or being communicated across a network, it is held in 'template' form, as it is loaded into memory and made ready to be executed it is converted to 'process-ready' form. As the template is converted to process-ready, any translation from VP code to the local processor's native code is performed, and the node is inserted into a list of other process-ready objects (see Dynamic Binding and Portability). Once a node is in a process-ready list it can be processed. The node type determines how it is to be processed. Two types to focus on are the Control object and the Tool object.
When a Control object is created the object's template is distributed and made process ready on a processor. A process is made available to the object and it starts to execute. A Control object is made up of one or more components, which are all Taos nodes of one type or another. Each component is executed in sequence until the last one is finished when the Control object closes and its process finishes. The components may be other Control objects, tools, graphic objects etc.
Tools are bits of code which operate on the data defined in a Control object. For example, they may perform calculations and send and receive messages to and from other Control objects. All Control objects are created by another Control object, and each has the mail address of its parent, forming a tree. Tools, being nodes, can be manipulated by the kernel. A Control object may consist of some local memory space and some constituent tools which operate on the data.
Whilst the Control object is the smallest entity which can execute in parallel, it is not the finest granularity of memory management. Individual tools can be loaded from disk, as they are also Taos objects (conforming to the basic node format). A Control object template only holds the text names of its constituent components, not the actual code. As a Control object is created, the kernel checks to see if the tools which the components reference are already available in memory, and if they are, simply points to them. Only if an object is not present will it be loaded from disk and be made process-ready. So all Taos objects can be multi-threaded. You will never have two copies of the same object in the same memory space, unless you specifically request it (See Dynamic Binding).
Another feature of this execution mechanism is that only those components which are needed are ever loaded. If you design your application so that it is built of hierarchically structured Control objects, then code will only ever be loaded if it is executed. If the path of execution does not pass the particular component then it will not be loaded and thus occupy no space. So, the amount of memory consumed is kept to an absolute minimum and is driven by the execution of the program.
Taos is the ground breaking revolution for which the electronics, computing and communications worlds have been waiting. For years the information world has been outgrowing its boots, becoming cumbersome and sluggish. The push of new technologies and of parallel processing in particular has forced a profound re-think of what an operating system should be.
Taos provides what is needed, no more no less; it is simply the right product at the right time. Elegant, compact and versatile, it provides the programmer with simple yet powerful tools to exploit emerging technologies.
Taos is not just another development, it is a Holy Grail, a complete product with substance as strong as the claims made for it, and implications that can not yet be realised. Exactly what it is that makes Taos so significant may be argued for a long time given its many benefits.
For those of us who are carrying the torch of OPEN COMPUTING, Taos provides the ultimate open platform through distributed processes across dissimilar processors to achieve HETEROGENEOUS PROCESSING. This is achieved by having totally PORTABLE CODE. Taos-based applications are written only once, so that software houses can now channel funding into the development of new products rather than having to allocate vast sums towards the porting of existing packages from one platform to another.
Taos' PARALLEL PROCESSING facilities generate a MASTERLESS NETWORK with no practical limit on its size and providing LINEAR SCALABILITY of performance. Developing products for a parallel environment has traditionally been a major stumbling block. But writing parallel programs for Taos is as easy as writing programs for a single processor environment; and once a program is written it will run on any processor supported by Taos without any changes. The LOAD BALANCING techniques employed by Taos enable applications to exploit additional processing power as it is added, without re-compilation, even during the execution of a program.
Taos' OBJECT ORIENTATED programming techniques have led to the creation of thousands of reusable tools which will be used over and over again in future software developments. Object Orientated techniques have so far failed to live up to expectations, but Taos shows that this methodology can, if employed wisely, yield massive benefits to the programmer and end user.
Taos' lack of protocol layers makes it very reactive to stimuli and this combined with its highly efficient DYNAMIC BINDING, provides the basis for truly REAL TIME systems.
Taos' SCALABILITY enables it to underpin massive superscalable networks, whilst its COMPACTNESS makes it an obvious choice for embedded applications.
This only provides a brief overview of just some of the features and benefits of Taos; despite this document's limitations, what we hope it does emphasise is the remarkable flexibility of Taos and the broad range of markets for which it is ideally suited.However, if it failed to answer all your questions please contact:
Tel. +44 81 905 5708; Fax. +44 81 905 5709
Tel. +44 703 230 340; Fax. +44 703 230 440
or write to
PO Box 2320, London NW11 6PW, England
MARCH 13, 1995 * TANTRIC TECHNOLOGIES CO-OP LTD.
+--- -- - Robert Atkins, firstname.lastname@example.org | "When is Microsoft going to use its resources : : to do something truly revolutionary?" | - WiReD 2.10 - -- ---+