Click for a map of the "logical" components of the platform (may resize and keep displayed while reading this intro)
Click for a
"flow" view of the platform (in a new window)
What is it?
A platform for parallel programming that covers all aspects of software, from authoring through run-time.
The platform includes an intermediate format, source languages, development environment, and OS interface.
What's good about it?
It allows (if successful):
"write once, compile once, run high performance anywhere"
The platform enables separation of concerns in parallel software, separating application concerns from hardware concerns. Application programmers write their code without hardware knowledge and produce a distribution-bundle. Meanwhile, each hardware platform has a translator written specifically for it by hardware experts. When a distribution bundle is installed on a machine, the translator on that machine translates the bundle into a machine-specific form.
The platform lets the code-task-size and data-task-size be adjusted, by the translator, to fit the hardware. The computation model causes the translator to receive the application-information it requires to split up the code and thereby adjust the computation-to-communication ratio. The computation model also causes the run-time to be able to divide up the data, thereby adjusting to communication time. Together, comp-to-comm ratio and comm-time of tasks determine how efficient a program will run on specific hardware. By enabling the hardware-specific translator and hardware-specific run-time to adjust these when a program is installed, the program is made highly efficient on the specific hardware it is installed on.
The computation model is easy and productive to program in, in part because it has no syncs, locks, guards, tuple operations or other "difficult" programming paradigms. These are replaced by boolean "assertions" on data. The programmer does not have to predict the ordering of operations, race conditions are eliminated by the compiler, and there are no dead-locks.
The platform includes the software environment, so programmers and users see a single software environment, independent of hardware. The same development software runs on all CodeTime enabled machines, and the code created likewise runs on all CodeTime enabled machines.
The platform includes a hardware-independent OS interface that remains the same across parallel hardware platforms.
The platform has benefits for large projects, including naturally-occuring interfaces that encourage re-use, a self-documenting code environment, and a natural metaphore for distributed development.
What's an OS Instance?
When a machine is booted, that "boot sequence" causes the operating system program to run. All interactions that an application program or a user has with the "machine" are actually interactions with the running instance of the operating system. In CodeTime, the operating-system instance is made persistent. Rebooting a machine does not create a new instance of the OS, but rather re-loads a portion of the existing OS instance.
An OS instance, then, is like a "virtual server". It is the logical entity that one logs into, installs programs into, runs programs inside of, and so on.
A CodeTime OS Instance may have multiple physical machines "underneath" it, however, the actual hardware is never seen by a user. There is no way for a program to detect what hardware is assigned to the OS Instance the program is running inside of.
The OS Instance is the thing that contains all of the persistent data. Rather than data being though of as being on a hard-disk, or somewhere else on a machine, it is instead inside an OS Instance. Data goes through an "install" process where it goes from being outside the OS Instance to being inside. This process translates the data, changing, for example, primitive data-types from their external form to the OS Instance's internal form. This translation of data formats is one way that hardware independence is enforced by the OS.
A program is treated as data, and so must also be installed, during which it is translated from the intermediate format to some hardware-specific format, such as a collection of executable files. This translation is normally done by a "back end" compiler. This compiler is written by people with in-depth knowledge of the hardware, including network topology, network latencies, processor speeds, even memory hierarchies.
Portions of the OS Instance are implemented by the run-time system. The run-time system is the thing that is created in memory when hardware is booted. It contains the task-scheduler, performs inter-processor communications, and has other glue needed to implement the CodeTime computation model and the OS Interface.
Why require an IDE?
The development environment, which includes a test harness, is a key to the ability to enforce conformance among various implementations of the platform and to guarantee that software will run across those platforms.
It also provides large-project benefits and generates profile information.
The standard test-harness guarantees that all software-distributions include profile information, which is valuable to the back-end compiler to use during hardware-specialization transforms.
BaCTiL, one of the high-level CodeTime languages, has code reuse and self documentation features that rely on interacting with the programmer in certain ways that the IDE implements.
Back To Home