DE4040992A1 - DATA PROCESSING SYSTEM - Google Patents

Description

Modern data processing systems are designed so that all information within the system through hardware knew, memory-resident information structures, the objects are called, are represented. This is called objektori termed computer architecture. An object stops Data packet of related information that in ei a logically contiguous addressed amount of memory be managed.

In such an object-oriented data processing system Each object type or class has a number operations that may be performed on objects, wel also belong to this class. This is called objectbe termed access mechanism. The internal structure of the Objects is not accessible to the programmer; he can single with allowed operations to manipulate the objects. Access to an object you get by means of a on the object court tiled pointer, which is called an access descriptor. the This access descriptor describes the type of representation rights (rep), such as reading or writing, the the various, from the owner of the access descriptor for the Object defined access types defined.

In one described in US patent application 4 55 625 System will increase the complexity of programming in one jector-oriented computer system by the identifier of in Spei saved words, so that the protective mechanism between ordinary data and protected access descriptors can differ. This type of protection is called net as a performance-related protection mechanism the older status-related protection mechanisms. A status-related The protection mechanism is based on a monitoring program status and user status, with privileged commands can only be executed in the monitoring state. Around Compatibility with older, dangling and new operating systems To create stemen with identifier is the mapping of Überwa  Calling an operating system without an ID on a Be drive system with identifier desirable.

Therefore, an object of the present invention to provide a call / return mechanism with on the one hand a performance-related protection mechanism and others on the other hand, a status-based protection mechanism can.

The above-described objects are provided according to the invention achieved by a first processor object and a first Execution environment that verifies with a first range object is linked, defining first process object and one with egg second execution set associated with the second range object are provided. A first environment table object becomes linked to the first process. This first environment bar lenobjekt contains a subsystem connection information containing Steuerkellerspeicher (tax stack), a field of control cell storage entries representing the status of the first, calling execution environment for recovery by returning from the second execution environment.

The first area object includes a region 0 access descriptor for referring to the object defining region 0 of the second (target) execution environment, which is the target of a subsystem call, and also an access descriptor of region 1 for referencing the object, which is the region 1 of FIG defines a second (target) execution environment, which is the target of a subsystem call, and a subsystem ID, which points to an entry in a subsystem table in the first environment table associated within the first process object. A subsystem entry in the subsystem table specifies the object defining the region 2 of the destination execution environment, the frame pointer, and the cellar memory pointer of the topmost window storage frame in the target environment. A watchdog memory pointer, ie, a linear address (in words) for the watchdog store used in invoking a watch call in the user mode (instead of a cell memory pointer in the current frame) to locate the new frame, is provided.

The first domain object further includes procedures idle, specifying the type and address of the destination procedure Each of these procedure entries includes a procedure Support type field, which indicates the type of procedure to be called and not just a monitoring procedure and a subsystem procedure and an offset into the destination execution environment contains. This offset specifies the first one Command of the target procedure.

According to one aspect of the invention, the environment stack object includes two data structures, a subsystem table and a control store memory. The subsystem table locates all of the cell store objects of area 2 and their associated topmost frame and their cell store pointers associated with a process.

According to one embodiment of the invention is a current Subsystem ID in the second process object together with the aktu Subsystem table offset for the current subsystem into the subsystem table associated with the first process and on the other hand, the linear address of the uppermost frame and the cellar memory pointer in the subsystem entry under the Be preserves a subsystem by means of a call of a another subsystem is left.

These and other tasks, features and benefits of The invention will become apparent from the following detailed description an embodiment of the invention, which in the Drawing is shown. In the drawings shows:

Fig. 1 is a block diagram of processor registers and Sy stemobjekten in which the invention is implemented;

Fig. 2 is a detailed block diagram of the linear address space structure of the execution environment of Fig. 1;

FIG. 3 is a detailed block diagram of a region object of FIG. 1; FIG.

FIG. 4 is a detailed block diagram of a process entry in the region object of FIG. 2; FIG.

Fig. 5 is a detailed block diagram of the ambient state object of Fig. 1;

Fig. 6 is a detailed block diagram of a subsystem entry of the environment table object of Fig. 5;

Fig. 7 is a most detailed block diagram of the control cell storage entry of the environment table object of Fig. 5;

Figs. 8 and 9 are a flowchart of the calling system command;

Fig. 10 is a flow chart of the intersubsystem call subroutines of the polling system command of Figs. 8 and 9; and

Fig. 11 is a flowchart of Intrasubsystemaufrufsubrou tine of the call instruction system of FIG. 8 and 9.

An object-oriented computer architecture in a data processing system is designed to contain all information within the system by hardware-recognized, memory resi dente information structures called objects, re are presented. An object puts a data packet on top of each other related information in a coherent way addressed amount of memory spaces are managed.

In such an object-oriented data processing system Each object type or class has a number operations that may be performed on objects, wel also belong to this class. This is called objectbe termed access mechanism. The internal structure of the Objects is not accessible to the programmer; he can single with allowed operations to manipulate the objects. Access to an object you get by means of a on the object court tiled pointer, which is called an access descriptor. the  This access descriptor describes the type of representation rights (rep), such as reading or writing, the the various, the owner of the access descriptor for the Object defined access types defined.

In the description of a process, an operator is the, which indicates the activities to be performed on operands. On Operand is usually given by an address part of a command identified. Each command specifies an operator and several references. The operator specifies that Processor, which hardware operation is performed, and the References select the one to use or manipulate Operands. The operator specified in a command is in encoded two fields, the class field and the opcode field. The class field specifies the operator class, to wel the operator belongs; the opcode field selects them out of this class of hardware operation.

execution environment

A process sees a flat, linear address space from which he assigns data, commands and cellar storage space. A callback fails forms a new basement storage frame (Activation da Tensatz) on a sequentially allocated basement memory. More information about basement storage frames can be found in the US-PS 48 11 208 can be found.

An execution environment consists of the following object a linear address space, a group of global and Floating-point registers, an instruction pointer, and arithmetic tax register.

The global registers are displayed when the process is exceeded Reich borders not touched. One of these registers beinhal sets the current frame pointer (FP) while the rest is Uni general registers. This FP contains the linear address (Pointer) into the current execution environment for the current one (top) basement storage frame. The associated with a process global registers are saved in the process control block,  while no process execution is running.

Also in the process control block are those with a Process linked floating-point registers saved while the Process is not running. An execution environment is equivalent to one process-wide address space in other systems. The system under supports multiple execution environments per process, but can only one execution environment at a given time for to be active every process.

The arithmetic controls are used to control the arithmetic tic and error properties of the numerical commands and to Storage of condition codes used. Is a process ended? If so, the arithmetic control information in the Pro stored control block. Becomes a call operation to a new frame is performed, the return instruction pointer is in the Cellar storage frame in the current, linear address space stores.

instruction pointer

The instruction pointer (IP) is a linear address (pointer) in the current, linear address space to the first byte of the current one Command.

The register model consists of the sixteen global registers and four floating point registers across process area boundaries Be protected, and from multiple groups of sixteen local (or frame) registers. The register model is in the described above US Patent Application 9 35 193.

At any one time, an instruction can have thirty-six of the registers address as follows:

register type register name Global register | G0. , , G15 Floating point register (floating point operand) FP0. , , FP 3 local register L0. , , L15

Global register

There are sixteen registers associated with a process which, while the process is not activated, in the process control block are stored.

Of the sixteen 32-bit registers, G15 contains the current one Frame pointer (FP) and G0. , , G14 are universal registers. The FP contains the linear address of the current (top) cellar memory frame. Since basement storage frame is set to SALIGN * 16 byte loading aligned (SALIGN is one of a spe dependent implementation), the N become low ignored valued FP bits and always interpreting as zero (N is given by SALIGN * 16 = 2 ** N). This register is initialized by call and by returns recycled.

A reference to a register as an operand that is larger is 32 bits, uses the registers with consecutive higher register numbers.

floating-point registers

There are four floating point regi associated with a process In the process, while no process is taking place be stored in the control block. Floating point registers are only available as Operands accessible from floating point instructions.

Local (or frame) registers

The registers L0. , , L15, the local registers denote none Register of the ordinary kind; they are assigned to process calls, and the mapping is undone on returns.

Multiple banks of local registers are provided, viz one per process activation, as far as the program contains the Re gister does not need to explicitly save and return.

If these registers have to be stored in a memory, they are stored in the first sixteen words of the cell memory frame of the associated process. They represent the first sixteen words of the cellar memory frame as far as the register L 0 is formed into the linear address FP + 0 to FP + 3, the register Li is formed into the linear address FP + 4i to FP + 4i + 3, etc.

Because commands must begin at word boundary (4-byte), are the two low-order bits of the command pointer always zero.

arithmetic controls

The arithmetic controls (AC) are used to control the Arithmetic and error properties of numeric commands and used to store the operating codes. Is a process un broken, so are the arithmetic controls in the process stored in the control block.

Arithmetic Control (AC) includes the following information:
Condition Code (Bits 0-2): A set of flags set by compare instructions (and other instructions) and examined by conditional branch instructions (and other instructions).

Arithmetic Status (Bits 3-6): This field is called an Indi changed by certain floating point commands.

Integer Overflow Flag (Bit 8): The flag is set, always if an integer overflow occurs and the mask is set. The flag is never deleted implicitly.

Integer overflow mask (bit 12): If this mask is set, then an integer overflow does not cause an arithmetic error. is S is the target size, then S becomes the least significant bits of the Results stored in the target, unless other specifications have been made.

NO IMPRECISE error (bit 15): Is this error (NIF)? sets, so mistakes must be precise. If NIS is deleted, you can certain mistakes be imprecise.

Floating point overflow flag (bit 16): The flag is set, in when a floating point overflow occurs and the mask is set is. The flag is never deleted implicitly.

Floating point underflow flag (Bit 17): The flag is set, in when a floating point underflow occurs and the mask is set  is. The flag is never deleted implicitly.

Floating point invalid op flag (Bit 18): The flag is set, whenever an invalid floating point operation takes place and the mask is set. The flag is never deleted implicitly.

Floating Point Zero Division Flag (Bit 19): The flag is loosened sets whenever a floating point division is zero det and the mask is set. The flag never becomes implicit deleted.

Floating Point Inexact Flag (Bit 20): The flag is set, in when an inexact glide point result occurs and the Mask is set. The flag is never deleted implicitly.

Floating point overflow mask (bit 24): If this is set, then Floating point overflow does not lead to a REAL_ARITHMETIC Error.

Floating point underflow mask (bit 25): If this is set, then Floating point underflow does not lead to a REAL_ARITHMETIC Error.

Floating point op-op mask (bit 26): If set, so an invalid floating-point operation does not result in one REAL_ARITHMETIC error.

Floating-point zero-division mask (bit 27): If this is set, Thus, a floating-point division by zero does not lead to a REAL_ARITHMETIC error.

Floating point inexact mask (bit 28): If this is set, then does not lead to an inexact glide point result REAL_ARITHMETIC error.

Floating Point Normalization Mode (Bit 29): Is this mode set, then denormalized numbers in real, long Real or extended reals first normalized before the arithmetic is performed. Does this mode not exist so denormalized numbers lead to a REAL_ARITHMETIC error ler.

Slide point rounding control (bits 31-30): This field shows the current rounding mode for floating point calculation:

00 - rounding to the next one (even),
01 - rounding off (towards minus infinity),
10 - rounding up (towards plus infinity),
11 - skip (rounding to zero).

Stack frame

The basement storage frame is a contiguous part ak linear linear address space containing data in batches. This stack grows from low addresses to high ones Addresses. There is a basement storage per akti fourth process, which local variable, parameters and verbin contains information about the training. A call operation detects a new basement storage frame, while a return operation the release again. As soon as a new basement storage frame he is set, it is set to a SALIGN * 16 byte range limit in which SALIGN is a predefined value.

The page or the simple object into which he or she 64 bytes of a frame must be mapped possess own lifetime. The life of the page or the simple object is checked during a call. This restriction is for the efficient manipulation of access descriptors in necessary to the local registers.

In addition to the requirement that a frame be mapped to a local page or a local simple object, the mixed bit of the page or object descriptor is set, although no tag bit must be written to the frame. This restriction is again necessary for the efficient manipulation of access descriptors in the local registers. The fields in the basement storage frames are defined as follows:
Padding area: This area is used to align the frame pointer to the next SALIGN 16 byte area boundary. The size of this range varies from zero to SA LIGN * 16-1 bytes. When a call operation is performed, the padding area is added to round the calling memory cellar pointer to the next range boundary so that the frame pointer for that frame can be formed. If the cellar memory pointer of the caller is already aligned, the padding area is missing.

Frame status (L0): The frame status, after a call, captures the information associated with the frame that should be used when returning from the frame. The fields of a frame status are defined as follows:
Return Status RRR (Bits 0-2): This 3-bit field captures the call mechanism used in forming this frame and is used to select the return mechanism used for the return. The encodings of this field are:

000 local,
001 error,
010 monitor, trace was disabled before call,
011 Supervisor, trace was enabled before the call,
100 subsystem (intrasubsystem),
101 subsystem (intersubsystem),
110 break,
111 interruption.

Prereturn trace, P (bit 3): During a Re turns from a frame in a single-prereturn Trace bit occurs prereturn trace (if enabled) before any operation procedure linkage with the return operation. This bit is initialized on a call to zero, if no call Tracing occurs; otherwise it is initiali to one Siert.

Previous Frame Pointer, PFP (Bit 4-31): A linear Address to the first byte of the previous frame. As frame aligned to area boundaries of sixteen bytes or more are only the 28 most significant bits of the frame saved.  

During a call, the RRR field becomes initia as follows lisiert:

000 - Local call or monitor call from monitor mode,
001 - error call,
01T - monitor call from the user mode,
100 - intrasubsystem call,
101 - intersubsystem call,
110 - Interrupt call from hibernation,
111 - Interrupt call from the execution state

T outputs the value of the trace enable flag process controls. For all returns, the PRRR Bits interpreted as follows:

1xxx generation of a prereturn trace,
0000 performing a local return,
0001 execution of an error return,
001T in supervisor mode performing a supervisor reset.

The T bit is traced in the process controllers associated with the activation bit, which becomes the execution mode bit set to user. Otherwise, a local return will occur guided.

010x execution of a subsystem return,
0110 Execution of a rest interruption return,
0111 Performing an interrupt return.

Basement memory pointer, SP (L1): This represents a linear Address to the first free byte of the stack, d. H. the Address of the last byte in the stack plus one. The SP will initialized by the call operation to the FP plus 64 to show.

Return instruction pointer, RIP (L2): If a call operation is performed on a new frame, the return be error pointer stored here. If the process is interrupted, so the instruction pointer of the next instruction is stored here.  

It contains a 32-bit linear address to the controller after returning to this frame is returned. The content of the return instruction pointer of the current frame is not defi ned. There is the implication that a process call the Be stores the miss pointer in a register of the current frame. Because implicit process calls can occur (due to errors) learning and interruptions), programs should use this registry do not use for other purposes.

Linear address space structure

Each execution environment defines a 32-bit linear address space which, as shown in Fig. 2, is divided into four areas (areas 0-3 ). The first three regions of an execution environment are specific to the current process (eg, defined by the process control block). The composition of these process-specific areas can be changed by a subsystem call / return. The fourth area of an execution environment is shared by all processes ie defined by the process control block). The Sy stem does not limit, where in the linear address space Be missing, cellar storage frame or data are placed.

Reserved to the system are the physical address mapping of linear addresses from 16 # e000_0000 'to 16 # efff_ffff # or the range 3 offsets from 16 # 2000_0000 to 16 # 2fff_ffff #. These locations can be mapped into physical addresses for the area 3 object independent of the object addressing mechanism.

A static linear address space with transparent Be Reichsgrenzen can by common use of Seitentabel be achieved when all areas are two-sided. The Access descriptors to the four areas are always so in interpreted as having read / write representation rights. It is not possible to access each area using the access descriptor Protect representation rights differently. Seitenebe Protection can be used for finer grain protection. above  In addition, the implementation must include the tag bits on the Be do not check riches descriptors (that is, they have the Option to require access descriptors or data to interpret as scope access descriptors).

The size of each area can be changed independently. It creates a gap at the end of an area, when the de Finition of an area used object less than a giga byte is.

It can be a simple object to define an area be used when the object is either 512, 1K, 2K or 4K By This is great. The base address of a single-range object must be be directed to physical address area boundaries, wel are multiples of their size. If a simple object to De The finition of an area uses length and base address of the simple object as the above requirements seeks.

When a process expires, all four areas must be unique (in the sense that everyone has a different appearance an area descriptor must have).

The virtual memory error handler is not Subsystem error handler, the following happens. For anybody process in the execution state, the ready state, or blocked status, the descriptors must have its area as be valid (that is, the V flags must be set).

command protection

For the processor to be able to execute commands, it is read-only necessary for memories containing instructions.

Command-caching

The system allows read-only caching of bytes in the Instruction stream in a non-transparent manner. The command cache Storage is independent of the cache-storable bit in the page where commands are located. Self-modified Pro gramme are not in a transparent by the system Way supported.  

Local process mechanism

A process begins at any word address in a linear address space. Process calls and returns use a stack in the linear address space, as shown in FIG .

Two parameter message mechanisms are possible:
Global register: Parameters are copied by the caller into the global registers and (if necessary) copied out by the called party after the call from the global registers. Return or result parameters are copied to the global registers by the called party and copied out by the caller from the global registers after a return. This is optimized for processes with a small number of parameters.

Argument List: An argument pointer to an argument list on the stack is used. This is called Escape Mecha nism, if there are more parameters than by means of the Global registers can be forwarded.

The global register way is always faster than that Path of the argument pointer. Therefore, the latter way should be only as an escape mechanism and not the only mecha be used.

If a process never invokes another process, can he copying his parameters from the global registers avoid the basement storage frame.

commands

local call
CALL
CALL_EXTENDED.

CALL and CALL_EXTENDED call the process at the specifier address. CALL specifies the process as an instruction pointer plus a 24-bit shift. CALL_EXTENDED specifies the Process by means of a general storage effective address.

During the call operation becomes a new cellar memory assigned to the framework and the tax procedure is based on the specifi  transferred process.

Return command return

The return command transfers the control back to the Call procedure and gives the cellar storage frame of the called free of charge. The command execution runs at the command, to which the Return Command Pointer (RIP) in the frame of the further process.

Various commands

MODIFY_AC
FLUSH_LOCAL_REGISTERS
CONVERT_ADDRESS

MODIFY_AC is used to read or modify the current len arithmetic controls used. FLUSH_LOCAL_REGISTERS writes all local register sets except the current ones into theirs associated frame in memory. Since the area access descrip are not directly accessible, the CONVERT_ADDRESS Command to convert a linear address into a virtu same address can be used.

The microprocessor is logical in five larger units subdivided: the instruction fetch unit, the instruction decoder and Microinstruction sorter, the address translation buffer, the logical bus sorted and the integer execution and floating point unit.

Inter-area transfer

Reference is made to Figure 1. Inter-environment calls / returns result in synchronous communication between execution environments. In addition to a 2-status protection mechanism (user status and monitor status), the system also supports an object-oriented, subsystem-based protection mechanism.

According to the present invention, the process call is via Surroundings boundaries provided to allow a process access to such data structures and procedures can win otherwise for a private environment. An area object becomes to represent the "public" interface of an environment be  uses. An area object is also used as an interface for an area-based and a supervisor call mechanism mus used. An area object includes a procedure ta belle, the addresses and types (subsystem or supervisor) all public procedures or operations. The Be handle "subsystem transfer" (call / return) becomes a descrip- tion use of the subsystem protection mechanism. The term Supervisor Transfer "becomes the description of the supervisor protection mechanism used.

execution modes

There may be two execution modes, user mode and the supervisor mode, so that conventional operating systems can be emulated. The system does not define the Concept of a privileged command. It can handle all commands either in user mode or in supervisor mode become. A program is governed by the nature of its access rights and privileges its execution mode. Become more accessible as rep rights, as Nuremberg Read, read / write rights or no access. The page representation be sentation rights in the current linear address space different, depending on the execution mode interpreted. Memory used by the operating system generally has pages representation rights that do not allow user access, but the read-only rights or read / write rights in the About have watch mode.

In systems with disabled identifier, the identifier bit also not to distinguish between data and pointers Access Descriptors (ADs). There all operands have tag bits of zero, each ver performs to execute instructions or operand specifiers that require an access descriptor, an error in the Be user mode. In supervisor mode, the error is disabled and the data is treated as an access descriptor. the This monitor mode allows you to execute commands that  Use access descriptors as operands (eg, the Command sending an access descriptor to a port object).

In systems with activated identifier, the only Un difference between the user and supervisor mode in the In Interpretation of the page representation rights. The automatic Interpretation of Data as Access Descriptors in the Survey The backup mode is not supported. Commands, the access require scribes can then be executed when the specified operand represents an access descriptor.

In a system without an identifier, the only way is the Execution mode to change to audit mode error free, in the command CALL_SYSTEM. The system report contains a sentence entry procedures for the operating system.

Supervisor procedure mechanism

The supervisor procedure call is similar to a local call. If a supervisor procedure in the procedure table in a Area object is specified, so specifies the area object the new supervisor basement store pointer. If the pro If it is in user mode, this monitor will Cellar memory pointer used as a new frame pointer. is If the process already in the supervisor mode, so will the basement Memory pointer in the current frame to the next 64-byte Be aligned to form the new frame pointer. This allows calling supervisor procedures from one Supervisor procedure out. The supervisor store must there be frozen at. This represents an intra-execution environment tion transfer, except that the execution mode (and the trace activation) of the process as part of the call can be changed.

The return status field is used to signal a monitor cher returns when using a return from the frame. An over Alarm clock is only performed when the process is in supervisor mode at the beginning of the command. Anson a local return is performed. This prevents the  Modification of the flow control and the selection of either an error or an interrupt return by an Opera tion in user mode.

The supervisor procedure mechanism becomes simple used without identification, the only two Kel memory or stack (user store memory and monitor cellar memory), which require the same linear address space and share two levels of protection.

Protection on a subsystem basis

In Fig. 1, a subsystem transfer mechanism is shown. The execution environments use a region-based protection mechanism. The target execution environment of a subsystem call is defined by the content of a scope object 100 . The procedure table 102 in one area object is independent of those in another area for the same execution environment; Thus, selected procedures in the area can be grouped together using another area object. This property also supports process or process variables.

Public information or an environment associated with it Objects can run programs running in other environments be accessible. These objects are through an area object accessible, the access (by other Ausführungsumge exercises) on public procedures only, public Constants and public variables of a data package limits.

Private information or an environment associated with Ob Objects are not directly about an area object of others Execution environments accessible. Objects and data, too to whom the area object does not find access are called as in viewed privately. As part of a subsystem call peration objects that define the execution environment within the execution environment.

The representation rights of the access descriptor (AD) 101 for reference to a domain object are set to read-only rights to access public read-only information, in direct access to the object's public variables, and pointers to the public procedures to allow. With the exception of the range object type manager, a range object access descriptor 101 is not given write permission. If this were different, the protection could be circumvented by modifying a domain object. The read-only public information may be copied in the area object to avoid an additional indirect level if it is located in a separate object. The variable public variables are placed in a separate object to which both the domain and the target execution environment 104 have an access descriptor with read-write privileges.

Target execution environment

An area object 100 is used to specify the destination environment 104 of a subsystem call. A subsystem transfer can modify one or more objects that define the current execution environment. With a suitable arrangement in three areas (data object, command object and stack or Kel storage object) of static data, basement storage frames and commands, a subsystem transfer does not need to change all three areas simultaneously. This information is arranged in the three areas as follows:
Data Object: Range 0 (110) is used for static data and private variables. A subsystem call / return changes at least this range 0 .

Command Object: Region 1 (112) is used for commands. This allows the command portion of a domain to be shared by copying a single access descriptor without having to share the page table. This area can remain unchanged during a subsystem call / return if the execution environments are in the same compilation unit.

Batch Storage Object: Area 2 (114) is used for basement storage frames. This area is process-specific and can not be shared by processes. This area can be left unchanged during a subsystem call / return if the execution environments are in the same protected subsystem.

The virtual memory error handler is in the Error table specified as a subsystem, the ob object table entries (OTE) for the areas of this subsystem be marked as valid. In case of missing marking This leads to a system error or an incorrect frame or stack memory pointer when error handling ler is called.

Subsystem ID and subsystem table

A region 100 does not directly specify the region 2 access descriptor (AD) of the target environment 104 , but indirectly by means of a subsystem ID 106 . The subsystem table 108 locates all the cellar storage objects of the area 2 and their associated topmost frame and their cellar memory pointers associated with a process. There is a one-to-one correspondence between a subsystem ID and an access descriptor for area 2 within a process. A subsystem ID can be mapped to various area 2 access descriptors associated with all of the various processes. Subsy stem ID is used to select a subsystem entry 107 in subsystem table 108 in the environment table object associated with the current process (FIG. 5 ). A subsystem entry ( Figure 6), in turn, specifies the access descriptor for area 2 (109) and the top cellar storage frame in the area.

The word containing a subsystem ID may be either an access descriptor or a data element. When access descriptors are used to represent subsystem IDs, the object index field of the access descriptor provides a system wide and unique ID for the subsystem. Otherwise, software assigns a unique ID to each subsystem within a single process. The subsystem ID, along with the sub system table, serve the following functions:
Shared stacks or basement storage object usage under scopes: Scopes in the same protected subsystem use the same subsystem ID to allow sharing of a baseline storage object.

Re-entry of a cellar storage object: If a Subsy stem from a call to another subsystem, so does the linear address of the topmost frame in the subsy stored. This allows a call to subsy stem A to subsystem B, which in turn subsystem A without return from the subsystem B calls.

Familiar Subsystems: A Null Subsystem ID indicates that the current Tier 2 storage object is being used. This allows two mutually suspicious subsystems to share a confidential library module (eg a runtime library).

Warranty Store Storage Resource: Because the subsystem's cached storage resource does not need to be shared with other subsystems, in some situations the software can guarantee that the basement storage resources never run out. This allows the synchronous treatment of certain errors. Area Object Division Among Processes: The subsystem ID also allows the same area to be used by different processes, although the same area is mapped to different area 2 access descriptors using various process specific cellars.

control stack

The subsystem call / return mechanism manages one Control stack or store (in which a process zugeord Neten environment table object) for the subsystem connection  formations. A tax stack represents a matrix of tax dollars peleinträge, which indicates the status of a return storing execution environment.

Extended subsystem environment

If the subsystem model is used, the execution environment is extended to include the following:
Environment table object: This contains both the subsystem table and the control store memory or stack.

Current Subsystem ID: This process is a subsystem ID assigned, which together with associated information such as the current subsystem table offset for the current subsystem stem entry is stored in the process object.

If the subsystem model is not used, then the Fields in the advanced environment are unused and can continue fall.

Interrupt / rest area

When the process is in an interrupted state or in Ru is an interruption environment table ject in subsystem calls. The interruption environment table contains an additional system-defined entry for the standard interrupt subsystem ID.

objects section

In Fig. 3, a range object is shown. An area sobjekt has an architected system type. The type rights in a range object access descriptor are not interpreted. The fields of a range object are defined as follows:

Area 0 Access Descriptor (Bytes 0-3): This access descriptor references the object that defines area 0 of the target execution environment for a subsystem call. If the identification bit is 0, a CONSTRAINT.INVALID_AD error is caused.

Area 1 access descriptor (bytes 4-7): This access descriptor references the object that defines area 1 of the target execution environment for a subsystem call. If the identification bit is 0 , a CONSTRAINT.INVALID_AD error is caused.

Subsystem ID (bytes 8-11): This mixed value represents the subsystem ID used to select an entry in the subsystem table in the environment table associated with the process object. A subsystem entry in the subsystem table specifies the object that defines the region 2 of the target execution environment and the frame pointer of the top most Kelster storage frame in the environment. If this field is a data word of zero, the current area 2 is used and the current frame is the topmost cellar storage space. Bits 6-31 of the subsystem ID are used to form a control value in the subsystem table.

Trace Control T (Byte 12, Bit 0): This bit specifies the trace activation bit of the process After a subsystem or supervisor call by means of this Object. This bit can be used for activation or inactivation tracing within a new execution environment serve. The bit is ignored when calling a monitor in the monitoring mode. It has the same encoding as the bit in the process controllers.

Supervisor stack pointer (bytes 12-15, bits 2-31):
This represents a linear address (in words) to the supervisor stack. This field is used in a call of a supervisor call in the user mode to locate the new frame (instead of the stack pointer in the current frame).

The process only distinguishes between one user stack or shelf (in user mode) and one over Conserve stack or store storage (in supervisor mode). If the supervisor stack pointers vary in different areas dene values, all cellar storage must be large enough to meet the requirements of all supervisor procedures  Therefore, the monitors used by a process should stack pointer to be the same. Because the error table is a processor All the Pro sharing the same processor must be assigned have a supervisor cellar storage, as he through the Supervisor error handler procedures. So the supervisor stack pointer should be a system-wide constant his.

Procedure entries (from byte 48 to the end of the object): A process entry, as shown in Figure 4, specifies the type and address of the destination procedure. The fields of a procedure entry are defined as follows:

Procedure Entry Type (bits 0-1): This field shows the entry calling procedure type. The encodings of this field are like follows:

00 - local procedure
01 - Specific implementation
10 - monitor procedure
11 - Subsystem procedure

Offset (bits 2-31): This 30-bit field is a word offset in the target execution environment to the first command of the target process major.

Environment table object

The environment table object, shown in FIG. 1, includes two data structures: a subsystem table 111 and a controller storage stack 113 . This object contains the information necessary for all subsystem transfers within a single process; therefore, there is a one-to-one correspondence between a process object and an environment table object.

This is shown in more detail in FIG . The environment table object has no defined system type. The fields of an environment table object are defined as follows: Subsy stemtable: This area is described in the following section. The first entry is used to store the current control cell storage pointer, the control cell storage limit, and the subsystem table size.

Steuerkellerspeicher: This area is in the following Section described.

subsystem table

During a subsystem call, an area object directly specifies only two out of three objects that define the new execution environment. The scope object includes a subsystem ID 106 that indirectly specifies the third object 114 of the new execution environment. A subsystem table represents a data structure within an environment table object that causes the mapping of a subsystem ID 106 to an access descriptor to area 2 (109) of the new environment. Area 2 is used to allocate the basement storage frames on calls / returns; therefore, this object can not be shared by different processes.

The first subsystem table entry of Figure 5 is a blind entry with the following defined fields:
Current control store memory pointer, CCSP, (bytes 0-3, bits 4-31): This is a four-word index for this object on the next available control store entry (CSE). This field is incremented on a subsystem call and decremented on a subsystem return.

Control Cell Memory Limit, CSL, (bytes 4-7, bits 4-31): This is a four-word index for this object on the first CSE reserved for the control stack overflow error handler (ie, not for regular use). As shown in Fig. 11, a CONTROL_STACK.OVERFLOW error is generated when CCSP is equal to CSL upon completion of a subsystem call.

Subsystem table size (12-125 bytes, 4-29 bits): This Field contains the sizes (in units of subsystem entries) gen) -1 of the subsystem table. This subsystem table size must be a power of 2; therefore, this field contains a bitmap  Mask of ones in the least significant bits. Anson their behavior is unpredictable.

Subsystem ID for subsystem entry mapping

As shown in Fig. 9, the subsystem command decoder selects the corresponding subsystem entry in the subsystem stem table as follows:
If the specified subsystem ID is 0 or equal to the current subsystem ID, the current subsystem ID is used. Otherwise, the subsystem table must be searched for the following description.

Bits 6-31 of the specified subsystem ID are in logi ANDing the subsystem table size to the initial subsystem entry index.

The following is repeated:

• 1) If the subsystem ID in the selected subsystem entry 0, an OPERATION.SUBSYSTEM_NOT-FOUND error may result will call.
• 2) Fits the subsystem ID in the selected subsystem entry to that of the specified subsystem ID (compare_mixed) to go out of the search.
• 3) The previous subsystem entry should be chosen, i. it's looking backwards. The entry zero runs to the last The entry is pointed to by the system table size will be.
• 4) If this is the initial subsystem entry and the Process is not in the interruption state is a OPERATION.SUBSYSTEM_NOT_FOUND error. is If the process is in the interruption state, then the current one becomes Subsystem used.

subsystem entry

The structure of a subsystem entry is shown in FIG. 6. The fields of a subsystem entry are defined as follows:
Top Frame Pointer (Bytes 0-3, Bits 6-31): This field contains the frame pointer of the uppermost cellar memory frame. During a subsystem call in this environment, this field will be used as the previous frame pointer in the new frame. During a subsystem call from this environment, the current frame pointer is stored here. During a sub system return to this environment, it will be used as the target frame pointer. During a subsystem return from this environment, the previous frame pointer is stored in the current frame here.

Upper Cellar Memory Pointer (Bytes 4-7): This field be includes the basement store pointer in the top cellar cherrahmen. During a subsystem call in this environment this field is used to calculate the frame pointer of the new one Frame used. During a subsystem call from this Surroundings the current cellar memory pointer is fedi here chert. During an inter-subsystem return from this environment The current cellar memory pointer (ie the rounded cell Cellar memory pointer in the previous frame) here fedi chert. During other inter-subsystem returns from this environment The current frame pointer -64 (that is, the rounded Cellar memory pointer in the previous frame) here chert. During a return to this environment this becomes Field ignored.

Subsystem ID (bytes 8-11): This ID 105 identifies the subsystem associated with the target execution environment. This ID is used as a key to adapt the subsystem ID 106 to the object for the range 2-114 ; thus it is unique within the subsystem table. A subsystem ID value of zero indicates that this subsystem entry is not assigned. A subsystem table entry zero with a subsystem only subsystem ID is used to store control cell memory information.

Event Error Inactivation (Byte 8, Bit 2): If this Subsystem is entered, this flag defines the current one  Value of the event error inactivation bit. Will the event go lerinaktivierungsbit set, then no Event.Notice error signaled. When the event error inactivation bit is cleared is an Event.Notice error occurs when the event error request flags are set. In an intersubsystem call / return, which sets the event error flag to zero, becomes an upcoming event error request after the up call / return.

Area 2 AD (bytes 12-15): This access descriptor ( 109 ) references the object which defines area 2 of the destination execution environment partially specified by this entry. This access descriptor must have read / write access, otherwise a protection.ad-rep-rights error can be called.

Control stack memory (stack)

The organization of the control cell storage 113 is shown in FIG . A control cell storage entry ( Figure 7) is placed on the control cell storage at a subsystem call and removed from the control cell storage on a subsystem return. The control cell memory is limited at the low end by a reserved control cell entry, at the high end by the control cell storage area + a number of reserved entries (for the control cell storage overflow error handler). The number of entries reserved for the cellar overflow error handler is software-defined.

If the corresponding process is executed, parts or the entire Steuerkellerspeicher internally in the processor gehal (that is, the memory image may not be accurate, and that Reading or writing the memory image is not necessary have an effect on the Steuerkellerspeicher). The load_control_stack_pointer command can be used to remove any flood cached information and invalidate it to be let.  

Control stack entry

The format of a control cell storage entry is shown in FIG . The fields of a control cell storage entry are defined as follows:
Range 0 return access descriptor (bytes 0-3): This access descriptor refers to the object that defines area 0 of the calling execution environment of the corresponding subsystem call. With a subsystem return, area 0 is returned to this object. This accessor script must contain read / write permissions, otherwise protection. ad_rep_rights error is caused.

Return-Zugangsdeskriptor for region 1 (4-7 bytes): this Zugangsdeskriptor refers to the object, which defines the loading rich 1 the calling execution environment of the corresponding subsystem call. With a subsystem return, area 1 is returned to this object. This accessor script must contain read / write permissions, otherwise a protec tion. ad_rep_rights error is caused.

Trace Control, T, (Byte 8, Bit 0): This bit contains the trace enable bit in the process controls during the corresponding normal subsystem call. During a subsystem return, the trace becomes tion control returned to this bit.

Return mode, MMM (byte 8, bits 1-3): This 3-bit field indicates the entry type. This field is encoded as follows:

000-Normal intra subsystem 001-Normal Inter subsystem 010 Reserved (CONTROLSTACK.UNDERFLOW error) 011 Reserved (CONTROLSTACK.UNDERFLOW error) 100 Error intra subsystem 101 Error Inter subsystem 110 Reserved (CONTROLSTACK UNDERFLOW error) 111-Reserved (CONTROLSTACK UNDERFLOW error)

Return subsystem entry offset (bytes 8-11, bits 4-31): This field contains the entry index in the subsystem table (in the environment table) for the subsystem entry that defines area 2 of the calling execution environment.

When a subsystem table expands and re-checks is changed, the subsystem entry offset changes and must be brought up to date.

Access descriptor for the area of the called (bytes 12-15): This access descriptor ( 120 ) refers to the area object used in this subsystem. This is initialized during a call, but not used during a return.

Call Return CALL_DOMAIN command

The CALL_DOMAIN command calls the through number in the specified area object specified procedure and changes according to the specification by the area ob project, the execution environment. The specified range must have reading rights. The procedure number becomes as a word index in the procedure table in the specified area sobjekt used for a procedure entry.

CALL_SYSTEM command

The CALL_SYSTEM command calls a procedure in the system rich. The system area is an area to which the Pro controller control block. It is necessary, supervisor calls in a system without an identifier. In a system with Identifier is the system area used to map supervisor fen of an operating system without identification on an operating system used with identifier.

Figs. 8 to 11 illustrate a flow chart of the CALL_SYSTEM command. Fig. 10 shows in detail the intersubsystem call subroutine of the system call command, and Fig. 11 shows the intrasubsystem call subroutine of the system call command.

Return instruction

The special return process is due to the return status field in the previous frame of the current frame be Right. This allows the calling of procedures from within or outside their associated areas, even if ver various operations are performed.

LOAD_CONTROL_STACK_POINTER command

The LOAD_CONTROL_STACK_POINTER keeps the current control basement store pointer of the process back.

Claims (5)

A data processing system for communicating between a current (calling) execution environment and a (called) target execution environment, wherein a plurality of addressable objects containing a first processor object and a first process object ( 64 ) having a first execution environment associated with a first domain object and a second Define execution environment associated with the execution object and stored in an address space of the memory, characterized
that a first environment table object is associated with the first process that the environment table object contains a control cell storage for storing subsystem connection information, the control cell storage being an array of control cell storage entries that store the status of the retrieving first execution environment upon a return from the second execution environment;
in that the second area object defines an area 0 access descriptor for reference to an object which defines area 0 of the second (target) execution environment as the target of a subsystem call, an area 1 -AD for referring to an object which area 1 of the second ( Destination) execution environment as the destination of a subsystem call, and includes a subsystem ID that points to an entry in a subsystem table in the environment table within the process object, with a subsystem entry in that subsystem table showing area 2 of the destination execution environment and the frame specifying the object defining the topmost cell storage frame in the target environment, and providing a linear address store (in words) for calling a supervisor call in the user mode (instead of the stack pointer in the current frame) to locate the new one Framework used over wacherke represents llerpeicher, and
the scope object contains procedure entries specifying the type and address of the destination procedure, each of these procedure entries containing a procedure entry type field indicating the type of procedure to call, including a supervisor procedure and a subsystem procedure, and further including the first command of the destination procedure Specifying the specified offset into the target execution environment. 2. System according to claim 1, characterized in that the environment table object contains two data structures, a Subsystemta belle and a Steuerkellerspeicher or control stack, and in that the Subsystemtabelle all Kellerspeicherobjekte ( 114 ) for area 2 and its corresponding uppermost frame and egg nem process associated basement memory pointer localized. 3. System according to claim 1 or 2, characterized that a current subsystem ID in the second process object too together with the current subsystem table offset for the aktu ellen subsystem entry in the first process associated Subsystem table is stored. 4. System according to one of claims 1 to 3, characterized draws that the linear address of the topmost frame in the sub system entry is stored under the condition that a Subsystem on a call to another subsystem left becomes. 5. System according to one of claims 1 to 4, characterized in that the area 0 a data object containing static data and private variables ( 110 ), area 1, a command object containing object ( 112 ) and area 2, a cell memory object ( 114 ). is that contains a cellar storage frame associated with a specific process.