6  Instructions of Exchange between VM

   The instructions intended for an exchange between VM uses values
   OPCODE in range 128 - 223.  Depending on length of the operands
   field, several formats of the instruction may be defined for one
   OPCODE.  The complete instruction format is defined by aggregate of
   the values of fields OPCODE and OPR_LENGTH.

   The instruction has the field REQ_ID, if in the instruction header
   flag ASK = 1.  REQ_ID is used for the response identification.  The
   value of this field is specifies by VM.  The response is formed by
   VM, too.  The protocol does not check the response and does not
   analyze the value of the field REQ_ID for the instructions of
   exchange between VM.  One of the instructions RSP, DATA, RETURN,
   ADDRESS, OBJECT or PROC_NUM is used for sending of the response.  The
   instructions of response have ASK = 1 and the value taken from the
   confirmed instruction is record in REQ_ID.  The instructions of
   response do not require the response.

   The instructions of exchange between VM may be sent through UDP at
   observance of the following conditions:

   o  ASK = 0;
   o  The instruction is located in one segment UDP;

   The timeouts and the repeated sending are not used at UMSP layer for
   instructions of exchange between VM.  It is explained to, that the
   time of sending instructions with low priority may be very large
   because of the output queues.  Therefore, the VM must make a decision
   on timeout, as only VM has the complete information on type of the
   transmitted data.  Besides, the transport layer protocol must use the
   timeouts.

   A few VM may be connected to the protocol on the node.  VM may
   simultaneously execute several jobs.  Each job may work in its
   address space.  The protocol determines VM and job, which the
   received instruction must transfer to, on field SESSION_ID value.

   The local memory address is located in the instruction in field of
   length 2/4/8 octets.  If memory address length in the instruction is
   not equal to memory address length defined for the node, the
   following variants are possible:

   o  If memory address length is set in 24 bits for the node, the
      address is writes in the end of 4 - octets field.  The 0 value
      sets in an initial (zero) octet.

   o  If the instruction format assumes the memory address length not
      less than 4 octets, 2-octet address is located in the last octets.
      The first 2 octets must set to zero.
   o  If instruction is the member of a chain and it has the less length
      of the memory address, than it is defined for the node - it is
      considered, that the base-displacement addressing is used.  If the
      value of the memory base is not assigned for the chain -
      instruction is erroneous.
   o  If the instruction is not the member of a chain and has the length
      of memory address less, than it is defined for the node, it is
      considered, that the abbreviated address is used.  The complete
      address length must be received by padding in front of it the
      necessary number of zero-value octets.
   o  In all other cases, the instruction is erroneous.

   Complete 128-bit memory address writes in operands in the 16-octets
   field.  The reason of using of the complete address is that the
   additional information, using by the memory control subsystem in the
   node, may contain in its field FREE (see section 2.1).  If the FREE
   of the complete address is set to zero, it is recommended to use
   local address in operands.

   Operands field has a length, which is an integral number of 32 bits.
   The alignment is making by padding, if necessary, of the zero-value
   octets at the end of the field.

   Header fields of the instructions not defined in the formats
   description are used according to the description from section 3.

   The instruction of the transfer control JUMP, CALL, CALL_BNUM and
   CALL_BNAME may contain the information about VM of the sender.  If VM
   type and VM version of the sender are contains in the instruction,
   the call parameters are formed in a format VM of the sender.  Else,
   the call parameters have format defined by VM of the addressee.  The
   code is always connected with of specific VM.

   All instructions of the protocol work with binary data and do not
   provide operations of formats transformation.

6.1  Data Reading/Writing Instructions

6.1.1   REQ_DATA

   The instruction "To request a data" (REQ_DATA) is used for the data
   request from the remote node.  Two instructions REQ_DATA with length
   of the length field 2 and 4 octets are defined.  These instructions
   have the following values of fields:

      OPCODE = 130/131      ; For length of the length field of 2/4
                              octets.
      OPR_LENGTH = 1/2/3/5  ; Depends on address length.
      Operands:
         2/4 octets: The length field. The number of the required data in
                     octets.
         2/4/8/16 octets: The memory address of the required data.

   The instruction DATA, containing required data, is sent in reply to
   it.  If the data cannot be sent, the instruction RSP with the non-
   zero basic return code, comes back.

6.1.2   DATA

   The instruction "The data" (DATA) is sent in reply to the instruction
   REQ_DATA and OBJ_REQ_DATA.  The instruction has the following values
   of fields:

      OPCODE = 132
      OPR_LENGTH = 0 - 65535  ; Depends on the immediate data length of
                                the operand.
      Operands:
         0 - 262140 octets: Immediate data.  If OPR_LENGTH = 0, this
                            field are absent.
      Extension headers:
         _DATA - Contains immediate data.  If OPR_LENGTH <> 0, this
                 header are absent.

   The extension header is used, if the data are more then an maximum
   operands field size.  The data must not be sent simultaneously in
   operands and in the extension header.  To make the length of data
   multiple of 4 octets, 1 - 3 zero-value octets are padded in the end
   of a field.

6.1.3   WRITE

   The instruction "To write the data" (WRITE) is used for data writing
   on the remote node.  The instruction has the following values of
   fields:

      OPCODE = 133/134/135/136  ; For memory address length of 2/4/8/16
                                  octets.
      OPR_LENGTH = 1 - 65535    ; Depends on length of the immediate
                                  data.
      Operands:
         2/4/8/16 octets: The memory address for writing the data.
         0 - 262136 octets: Immediate data for write.

      Extension headers:
         _DATA - Contains immediate data.  This header is present only,
                 if the data does not contain in operands.

   At address length of 2 octets the data length must be 2 octets.  In
   all other cases, address length must be not less than 4 octets and
   data length must be multiple of 4 octets.  The data must not be sent
   simultaneously in operands and in the extension header.

   The instruction RSP is sent in reply to the instruction WRITE.  The
   zero basic return code defines normal executing.

6.1.4   WRITE_EXT

   The instruction "The extension writing of data" (WRITE_EXT) is used
   for the data writing on the remote node.  Length of the data may be 1
   - 262132 octets with a step 1 octet.  The instruction has the
   following values of fields:

      OPCODE = 137
      OPR_LENGTH = 3 - 65535  ; Depends on length of the immediate data.
      Operands:
         1 octets: Always set to zero.
         3 octets: The number of the write data in octets.  The zero-
                   value is not available.
         4 - 262132 octets: Immediate data for write.  The data length
                            must be multiple of 4 octets.
         4/8/16 octets: The memory address for writing the data.

   To make the immediate data multiple of four octets, the data is
   padded with 1 - 3 zero-value octets at the end of a field.

   The instruction RSP is sent in reply to the instruction WRITE_EXT.
   The zero basic return code defines normal executing.

6.2  Comparison Instructions

6.2.1   CMP

   The instruction "To compare" (CMP) is used for binary data
   comparison.  It has the following values of fields:

      OPCODE = 138/139/140/141  ; For the address length of 2/4/8/16
                                  octets.
      OPR_LENGTH = 1 - 65535    ; Depends on length of the immediate
                                  data.

      Operands:
         2/4/8/16 octets: The memory address for compared data.
         2 - 262136 octets: The immediate data for the comparison.

   At the address length of 2 octets the data length must be 2 octets.
   In all other cases length of the address must not be less than 4
   octets and the data length is multiple to four octets.

6.2.2   CMP_EXT

   The instruction "The extension compare" (CMP_EXT) is used for binary
   data comparison.  Length of the data may be 1 - 262132 octets with a
   step 1 octet.  The instruction has the following values of fields:

      OPCODE = 142
      OPR_LENGTH = 3 - 65535  ; Depends on length of the immediate data
                                and the address.
      Operands:
         1 octet: Always set to 0.
         3 octets: The length of compared data in octets.  The zero-value
                   is not available.
         4 - 262132 octets: The immediate data for the comparison.  The
                            length of field is multiple of 4 octets.
         4/8/16 octets: The memory address of compared data.

   To make the immediate data multiple of four octets, the data is
   padded with 1 - 3 zero-value octets at the end of a field.

6.2.3   Response to Comparison Instructions

   The instruction RSP is sent in reply to the instruction CMP, CMP_EXT
   and OBJ_CMP (see below).  If the comparison was executed, the basic
   return code is equal to zero.  The additional return code is equal to
   -1, if the data at the address memories are less then the data from
   the operand; 0, if they are equal; and 1, if they are more.  If the
   comparison cannot be executed, the basic return code of the
   instruction RSP must be non-zero.

6.3  Control Transfer Instructions

6.3.1   JUMP, CALL

   The "Unconditional jump" (JUMP) and "To Call-subroutine" (CALL)_
   instructions have an equal format and differ only by OPCODE.  These
   instructions have the following values of fields:

      OPCODE = 143/144  ; Correspondingly for the JUMP not containing
                          and containing the information about VM.

               145/146  ; Correspondingly the CALL not containing and
                          containing the information about VM.
      OPR_LENGTH = 2 - 65535  ; Depends on inclusion of the information
                                about VM, address length and parameters
                                length.
      Operands:
         2 octets: The VM type of the sender.  If OPCODE=143/145 this
                   field is absent.
         2 octets: The VM version of the sender.  If OPCODE=143/145 this
                   field is absent.
         4/8/16 octets: The address of memory, where is necessary to
                        transfer control.
         2 octets: The number of 32 bit words in the call parameters
                   field.
         4 - 262134 octets: The immediate data are the parameters of a
                            call.

   On the reception side the processing of the instructions of a control
   transfer occurs as follows:

   o  The memory address is checked.  If it has erroneous value, the
      negative response RSP is sent.  At this stage, the correctness of
      parameters of a call may be also checked up.
   o  If the memory address and the parameters of a call have correct
      value, the positive response RSP is sent for the instruction JUMP.
      The transmitting side considers the instruction JUMP executed
      after receiving response.
   o  For response of an execution of the instruction CALL the
      instruction RETURN is sent.  The instruction RETURN may contain
      the returned values.  If there is an exception condition in a
      thread of control created by the CALL instruction, the instruction
      RSP with a non-zero basic return code is sent instead of RETURN.

6.3.2   RETURN

   The instruction "Return of control" (RETURN) is used at return of
   control from the instructions CALL, MVRUN, CALL_BNUM and CALL_BNAME
   (see below).  Those instructions have the following values of fields:

      OPCODE = 147
      OPR_LENGTH = 0 - 65535  ; Depends on length of the immediate data.
      Operands:
         0 - 262140 octets: Immediate data returned from the subroutine.

   If it is not required to send returned value, the instruction RETURN
   does not contain operands. The data format coincides with the
   instruction, for which the response (format VM of the sender or
   addressee) will be sent.

6.4  Memory Control Instructions

   UMSP gives means for division of memory for a code and for the data.
   The protocol does not make checks of correctness of operations with
   memory.  The code and the data use common address space.  The control
   of memory is completely realized by VM.

6.4.1   MEM_ALLOC

   The instruction "To allocate a memory for the data" (MEM_ALLOC) is
   used for request of the allocation of memory under the data.  The
   instruction has the following values of fields:

      OPCODE = 148
      OPR_LENGTH = 1
      Operands:
         4 octets: The size of required memory in bytes.

   For the positive response on the instruction MEM_ALLOC, the
   instruction ADDRESS, for negative - RSP with the non-zero basic
   return code is sent.  The received address can be used by the
   protocol in the instructions of reading/writing, comparison and
   synchronization.

6.4.2   MVCODE

   The instruction "To move the code" (MVCODE) is used for moving of the
   executable code from one node on another.  The instruction has the
   following values of fields:

      OPCODE = 149
      OPR_LENGTH = 1 - 65535 ; Depends on length of the code field.
      Operands:
         2 octets: The VM type of addressee.
         2 octets: The VM version of addressee.
         0-262136 octets: contains the executable code.
      The extension headers:
         _DATA - contains the executable code.  This header is present
                 only, if the code does not contain in operands.

   The code is always connected with VM of the definite type.  The code
   field is always transparent for the protocol.  It is formed by the VM
   of sender and must contain all the information necessary VM of the
   receiver.  The code must not simultaneously be sent in operands and
   in the extension header.

   For the positive response on the instruction MVCODE, the instruction
   ADDRESS, for negative - RSP with the non-zero basic return code is
   used.  The code transferred on the instruction MVCODE, may be
   executed by the instruction JUMP or CALL.

6.4.3   ADDRESS

   The instruction "The memory address" (ADDRESS) is used for the
   positive response on the instruction MEM_ALLOC and MVCODE.  ADDRESS
   has the following values of fields:

      OPCODE = 150
      OPR_LENGTH = 1/2/4; Depends on length of the address.
      Operands:
         4/8/16 octets: The address of the allocated memory.

   For the instruction, MEM_ALLOC the address specifies first byte of
   the allocated data area.  For the instruction MVCODE the contents of
   the address is defined VM, by which the code is connected.

6.4.4   FREE

   The memory allocated with the instructions MEM_ALLOC and MVCODE, must
   be explicitly release.  For this purpose, the instruction "To free
   the memory" (FREE) is used.  It has the following values of fields:

      OPCODE = 151
      OPR_LENGTH = 1/2/4; Depends on length of the address
      Operands:
         4/8/16 octets: the address of free memory.

   VM must free this memory automatically at end of the task on the
   node.

6.4.5   MVRUN

   The instruction "To move and run" (MVRUN) is used for simultaneous
   move of a code and its execution.  The instruction has the following
   values of fields:

      OPCODE = 152
      OPR_LENGTH = 1 - 65535 ; Depends on length of the code field.
      Operands:
         2 octets: The addressee VM type.
         2 octets: The addressee VM version.
         4 - 262136 octets: Contains an executable code.

      The extension headers:
         _DATA - Contains an executable code.  This header is present
                 only, if the code does not contain in operands.

   The executable code is the transparent buffer with the binary data
   for the protocol.  The format of this field is defined by the VM and
   it must contain all the information necessary for the loader VM of
   the addressee, including parameters of a call.

   The code must not simultaneously be sent in operands and in the
   extension header.

   The answer to the instruction MVRUN is formed similarly to
   instruction CALL.  It is not necessary to release memory allocated
   for a code by this instruction.  The memory must deallocate the VM.

6.5  Other Instructions

6.5.1   SYN

   The instruction "To Synchronize" (SYN) is used for the single message
   about the data change.  The instruction has the following values of
   fields:

      OPCODE = 153/154/155 ; For length of the address 4/8/16 octets.
      OPR_LENGTH = 2 - 65535; Depends on length of the data
      Operands:
         4/8/16 octets: The memory address of the tracking data.
         2 - 131068 octets: The initial data.  Length of the data must be
                            multiple of two octets.
         2 - 131068 octets: A mask for comparison.  Length of this field
                            is equal to length of a field of the initial
                            data.

   The tracking data is set by the memory address in the first operand.
   These data are originally compared to the initial data value from the
   second operand.  If the values do not coincide, it is considered,
   that the data have changed.  The third operand allows setting a mask
   for comparison.  Set to one bits of the mask specifies bits in the
   data, which change must be traced.

   The following variants of the answer are probable on the instruction:

   o  If the address of local memory is incorrect, the instruction RSP
      with the non-zero basic return code is sent for the response.
   o  If the data do not change, in the response nothing is sent.
   o  If the data have changed, the instruction DATA with new value of
      the traced data is sent.

6.5.2   NOP

   The instruction "No operation" (NOP) has the following values of
   fields:

      OPCODE = 156
      OPR_LENGTH = 0 - 65535
      Operands:
         0 - 262140 octets: Encapsulated data.
      Extension headers:
         Any Extension headers.

   The instruction NOP is intended for the decision of the following
   tasks:

   o  Send the control extension headers, when there are no other
      instructions for sending in a session
   o  Encapsulate the fragmented instructions and transactions with the
      established flag of special processing (see section 7).

6.6  Work with Objects

   The protocol has a set of the instructions being expansion of the
   protocol RPC [6].  As against RPC, UMSP allows immediately to address
   memory on remote nodes and to send the pointers in parameters and
   returned values.

   The UMSP object is identified by the 4-octet number.  The values are
   divided into the following ranges:

        I -> %x00000000 - 1FFFFFFF   are assigned for standard objects
       II -> %x20000000 - 3FFFFFFF   are assigned for users objects
      III -> %x30000000 - 4FFFFFFF   free
       IV -> %x50000000 - DFFFFFFF   transient
        V -> %xE0000000 - FFFFFFFF   reserved

   The objects from a range I must be definite, as standard, and the
   specifications of their interfaces must be published.  The protocol
   does not suppose the private or not described interfaces of standard
   objects.

   The objects from a range II must be registered, but the
   specifications of their interfaces may be optional published.  These
   numbers are applied in cases, when it is required to exclude the
   probable conflict of systems of the different manufacturers.

   The range III can be used freely.  The objects accessible on these
   numbers may be created statically or dynamically.  These objects can
   have any interfaces.

   All objects, concerning ranges I, II and III, is common for all jobs
   on the node, including zero-session.  Their interfaces are accessible
   to all tasks on the node, depending on parameters of authentication.

   The range IV is intended for objects created dynamically within the
   framework of one job.  These objects are the isolated associative
   memory of the job.  The access to these objects must be granted only
   for one job.  The zero-session has no access to these objects.

   The protocol grants the access to the data of object, as to the
   continuous segment of memory.  The memory of objects may be
   overlapping or no overlapping with flat local memory of the node.
   The offset field is used in the instructions of work with the data of
   object.  The offset rules writing are similar to the local address
   rules writing.

   The address memory length of the node, definite for the UMSP
   protocol, limits the maximal data size of one object.  The
   instructions definite in the given section, allow to work with
   associative memory with the theoretical limiting size on one node -
   2^96 (7,9 * 10^28) Byte.

   In addition to the number, the object has the version, 2 octets
   length, and realization, 2 octets length.  The protocol requires
   obligatory compatibility from bottom-up for all realizations of one
   version of object.  The publication of new realization of standard
   object may contain only added interfaces.

   If for the sender of the instruction the version and/or the
   realization of object do not play any role or is unknown, the
   instruction may contain zero fields of the version and realization of
   object or only zero field of realization.  The zero field of the
   version and non-zero field of realization are not allowed.

6.6.1   Reading/Writing of the Objects Data

6.6.1.1  OBJ_REQ_DATA

   The instruction "To request the data of object" (OBJ_REQ_DATA) is
   used for request of data of the Object from the remote node.  The
   instruction has the following values of fields:

      OPCODE = 192/193   ; For length of the field of length 2/4 octets.
      OPR_LENGTH = 3/4/5 ; Depends on length of the offset field.
      Operands:
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.
         2/4 octets: The length of the required data in octets.
         2/4/8 octets: Offset required data from the beginning of object
                       in bytes.

   At length of the length field of 2 octets the offset length must be 2
   octets.  In all other cases, length of the length field and offset
   length must be not less than 4 octets.

   The instruction DATA, containing the required data, is sent for reply
   to instruction OBJ_REQ_DATA.  If the data cannot be transmitted, the
   instruction RSP from the non-zero basic return code comes back.

6.6.1.2  OBJ_WRITE

   The instruction "To write the data in object" (OBJ_WRITE) is used for
   write of the data in object.  The instruction has the following
   values of fields:

      OPCODE = 194/195/196   ; For length of the offset field of 2/4/8
                               octets.
      OPR_LENGTH = 3 - 65535 ; Depends on the data length.
      Operands:
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.
         2/4/8 octets: The offset in object for the data writes.
         2 - 262128 octets: The immediate data for write.
      The extension headers:
         _DATA - Contains immediate data for write.  This header is
                 present, only if the data is not present in operands.

   At length of the field-offset of 2 octets, length of the data must be
   2 octets.  In all other cases, the offset length must be not less
   than 4 octets and the data length is multiple to four.  The data must
   not simultaneously be sent in operands and in the extension header.

   The instruction RSP is sent in reply to the instructions OBJ_WRITE.
   The zero basic return code defines the normal execution.

6.6.1.3  OBJ_WRITE_EXT

   The instruction "The extension writing of the data in object"
   (OBJ_WRITE_EXT) is used for write of the data in object.  Length of
   the data may be 1 - 262132 octets with the step 1 octet.  The
   instruction has the following values of fields:

      OPCODE = 197
      OPR_LENGTH = 3 - 65535; Depends on the data length and the address
                              length.
      Operands:
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.
         1 octet: Always set to 0.
         3 octets: Length written down data in octets.  The zero-value is
                   incorrect.
         4 - 262124 octets: The immediate data for write.  Length of the
                            data is multiple of 4 octets.
         2/4/8 octets: Offset in object for the data write.

   If the length of the written down data is not multiple of four
   octets, the data is padded with 1 - 3 zero octets at the end.

   The instruction RSP is sent in reply to the instructions
   OBJ_WRITE_EXT.  The zero basic return code defines the normal
   execution.

6.6.2  Comparison Instructions of the Objects Data

6.6.2.1  OBJ_DATA_CMP

   The instruction "To compare the data of object" (OBJ_DATA_CMP) is
   used for binary comparison of data of the object by the immediate
   data from operands.  The instruction has the following values of
   fields:

      OPCODE = 198/199/200  ; For length of offset field of 2/4/8
                              octets.
      OPR_LENGTH = 3 - 65535; Depends on length of the data.
      Operands:
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.
         2/4/8 octets: Offset in object for the compared data.
         2 - 262128 octets: The immediate data for comparison.

   At length of a field of 2 octets offset the data length must be 2
   octets.  In all other cases the offset length must be not less than 4
   octets and the data length is multiple to 4 octets.

   The response to the instruction OBJ_DATA_CMP is described in section
   6.2.3.

6.6.2.2  OBJ_DATA_CMP_EXT

   The instruction "The extension compare of data of the object"
   (OBJ_DATA_CMP_EXT) is used for binary comparison of data of the
   object by the immediate data from operands.  Length of the data may
   be 1 - 262132 octets with a step 1 octet.  The instruction has
   following values of fields:

      OPCODE = 201
      OPR_LENGTH = 5 - 65535  ; Depends on length of the immediate data
                                and the address length.
      Operands:
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.
         1 octet: Always set to 0.
         3 octets: The length of compared data in octets.  The zero-value
                   is incorrect.
         4 - 262124 octets: The immediate data for the comparison.  The
                            length of field is multiple of 4 octets.
         4/8 octets: Offset in object for the compared data.

   To make the immediate data multiple of four octets, the data is
   padded with 1 - 3 zero-value octets at the end.

   The response to the instruction OBJ_DATA_CMP_EXT is described in
   section 6.2.3.

6.6.3   Execution of the Objects Procedures

6.6.3.1  CALL_BNUM

   The instruction "To call the object procedure over number"
   (CALL_BNUM) transfers control to the object procedure over indication
   of the number.  The instruction has following values of fields:

      OPCODE = 202/203 ; Accordingly for the instructions not containing
                         and containing the information about VM.
      OPR_LENGTH = 4 - 65535 ; Depends on inclusion of the information
                               about VM and call parameters length.

      Operands:
         2 octets: The VM type of the sender.  If OPCODE=202 this field
                   is absent.
         2 octets: The VM version of the sender.  If OPCODE=202 this
                   field is absent.
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.
         4 octets: The number of the called procedure.
         4 - 262128 octets: Parameters of the call.

   The processing on the reception side is made similarly instructions
   CALL (see section 6.3.1).

6.6.3.2  CALL_BNAME

   The instruction "To call the object procedure over name" (CALL_BNAME)
   transfers control to the object procedure over indication of the
   name.  The instruction has following values of fields:

      OPCODE = 204/205  ; Accordingly for the instructions not
                          containing and containing the information
                          about VM.
      OPR_LENGTH = 3 - 65535 ; Depends on inclusion of the information
                               about VM and call parameters length.
      Operands:
         2 octets: The VM type of the sender.  If OPCODE=204 this field
                   is absent.
         2 octets: The VM version of the sender.  If OPCODE=204 this
                   field is absent.
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.
         4 - 262128 octets: Parameters of the call.
      The extension header:
         _NAME - Contains the name of the called procedure.

   The processing on the reception side is made similarly instructions
   CALL (see section 6.3.1).

   The names may have the procedures of the objects belonging to ranges
   III and IV.  The procedures of the objects belonging to ranges I and
   II must not have a name on the UMSP layer.  They must have the number
   only.

6.6.3.3  GET_NUM_PROC

   The instruction "To get the name of object procedure" (GET_NUM_PROC)
   allows receiving number of the procedure for objects in ranges III
   and IV over procedure name.  The instruction has following values of
   fields:

      OPCODE = 206
      OPR_LENGTH = 2
      Operands:
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.
      The extension header:
         _NAME - Contains procedure name.

   For the positive response on the instruction GET_NUM_PROC, the
   instruction PROC_NUM, for negative - RSP with the non-zero basic
   return code is sent.

6.6.3.4  PROC_NUM

   The instruction "The procedure number" (PROC_NUM) is sent in reply to
   the instruction GET_NUM_PROC.  The instruction PROC_NUM has following
   values of fields:

      OPCODE = 207
      OPR_LENGTH = 3
      Operands:
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.
         4 octets: The number of procedure.

6.6.4   The Objects Creation

   The objects from the ranges I and II (standard and assigned for the
   user) cannot be created on the remote node through the UMSP
   interface.  These objects must be created only through API of the VM.
   The objects from the ranges III and IV can be created on the remote
   node by the protocol instructions.

   The realization of objects from the ranges I - III (not connected
   with the certain job) is difficult enough.  The reason is that the
   different jobs can have the different address spaces of memory.  The
   pointers must be processed in the context of the job, from which they
   are received.  Besides, these objects must trace the end of the jobs

   for deallocation of dynamic resources.  The specified requirements
   impose essential restrictions on these objects.  The protocol does
   not impose any restrictions on objects from the range IV.

   Unique key identifying object on node, is number of object.  To
   objects from the ranges, III and IV the name may be assigned.  The
   objects from range I and II must not have names on the UMSP layer.
   Within the framework of one task must not be two objects having one
   number or one name.

6.6.4.1  NEW, SYS_NEW

   The format of both instructions "New object" (NEW) and "New system
   object" (NEW_SYS) is similar.  First instruction creates object in
   the range IV, second - in the range III.  These instructions have the
   following values of fields:

      OPCODE = 208/209; Accordingly for NEW/NEW_SYS.
      OPR_LENGTH = 3
      Operands:
         2 octets: The addressee VM type.
         2 octets: The addressee VM version.
         2 octets: The version of object.
         2 octets: The realization of object.
         4 - 262136 octets: Immediate data necessary for creation of
                            object.
      The extension headers:
         _DATA - Contains immediate data, necessary for creation of
                 object.  This header is present, only if the data is not
                 present in operands.
         _NAME - Contains the name of object.  This header is optional.

   The instruction NEW_SYS is used for the creation of object accessible
   from any job, NEW - for creation of object accessible only from its
   job.  If the object is created, the instruction OBJECT is sent for
   the response.  If the object cannot be created, the instruction RSP
   with the non-zero basic return code is sent.

   The immediate data field is transparent for the protocol.  It is
   formed by the sender VM and it must contain the information, which is
   necessary to the addressee VM for the creation of object.  Data must
   not simultaneously be sent in operands and in the extension header.

   The field SESSION_ID of the instruction cannot have the zero value.
   The dynamic object must be created only in the context of the
   definite job.  The object is always created on VM, with which the
   session is connected.

   The zero values of the version and the realizations of object means,
   that the object have no these values.

   It is possible to register the name of object simultaneously with its
   creation.  The name contains in the _NAME extension header.

   All objects created upon the instructions NEW and NEW_SYS must be
   obviously deleted.  VM must automatically delete all dynamic objects,
   created and not deleted by the task, at the end of the task.

6.6.4.2  OBJECT

   The instruction "The Object" (OBJECT) is used for the positive
   response on the instruction NEW and NEW_SYS.  The instruction OBJECT
   has following values of fields:

      OPCODE = 210
      OPR_LENGTH = 2
      Operands:
         4 octets: The number of object.
         2 octets: The version of object.
         2 octets: The realization of object.

6.6.4.3  DELETE

   The instruction "To delete the object" (DELETE) is used for the
   deleting of object created on the instruction NEW or NEW_SYS.  The
   instruction DELETE has the following values of fields:

      OPCODE = 211
      OPR_LENGTH = 1
      Operands:
         4 octets: number of object

   The object may be deleted only from the job, which has created it.
   The instruction RSP is sent in reply to this instruction.

6.6.5   The Objects Identification

   At registration of object on the node, it may be identify by the
   name, the length of 4 - 254 octets.  The name contains the symbols
   ASCII.  The following versions of the protocol may define other types
   of the name.

   The name identifies with the number of object and is its synonym.
   The names of all active objects in one task on the node must be
   unique.  Thus, all active objects from the range of number I - III

   must have the unique names for all tasks on the node.  The protocol
   allows receiving the number of object by the name and the name of
   object by the number.

6.6.5.1  OBJ_SEEK

   The instruction "To seek the object" (OBJ_SEEK) is used for seek of
   number of the object by the name.  It has the following values of
   fields:

      OPCODE = 212
      OPR_LENGTH = 0
      The extension header:
         _NAME - contains the name of object for search.

   If the object is found - the instruction OBJECT is sent in the
   answer.  If the object is not found - the instruction RSP with the
   non-zero basic return code is sent for the response.

   The instruction OBJ_SEEK may be sent broadcast through UDP.  In this
   case, it concerns to zero-session.  The instruction may contain the
   field REQ_ID for identification of answers.  The positive responses
   in this case must be sent only.  The response may be transmitted
   through UDP.

6.6.5.2  OBJ_GET_NAME

   The instruction "To get a name of the object" (OBJ_GET_NAME) is used
   for get of the name of object by number.  It has the following values
   of fields:

      OPCODE = 213
      OPR_LENGTH = 1
      Operands:
         4 octets: number of object for getting

   If the object is present - the instruction OBJECT with the extension
   header _NAME is sent for the response.  If the object is not present
   - the instruction RSP with the non-zero basic return code is sent for
   the response.