Table of Contents DOS
TCP/IP Tutorial and Technical Overview

4.11 Network Computing System (NCS)

Figure: Network Computing System (NCS)

The APOLLO Network Computing System (NCS) is an implementation of the Network Computing Architecture developed to provide tools for designing, implementing and supporting applications requiring distributed data and distributed computing. This is achieved through implementation of NCS on top of the Remote Procedure Call interface, which is different from Sun RPC.

The Network Computing Architecture is object-oriented. This allows programs to access objects through interfaces no matter which machines they communicate with. These types of programs have a simpler design and are less susceptible to hardware and network changes.

An object is an entity managed by defined operations having a type specifying the class or category. For example, a disk file is an object and it can be an ASCII type.

An interface is a set of operations that manipulate the objects.

The Network Computing Architecture uses an expanded concept called replicated objects which are copies of an object that have the same identifier. It can be weakly or strongly consistent. Weakly consistent replicated objects can be accessed even if they are not identical. Strongly consistent replicated objects can only be accessed when they are identical. The use of one or the other depends on the performance, availability and consistency required.

Distributed data and processing is achieved through the use of the following components:

  1. The Remote Procedure Call (RPC) runtime library
  2. The Network Interface Definition Language (NIDL) compiler
  3. The Location Broker

The Network Computing Kernel consists of the Location Broker and the RPC runtime library, which provides runtime support for network computing. This kernel and the NIDL compiler support the development and implementation of distributed applications. NCS RPC

The NCS RPC can use the Domain network communications protocols (DDS) and the DARPA Internet Protocols (UDP/IP). The selection is made by the destination address given so that a program can access a Domain and non-Domain entity.

The Berkeley socket concept is used in NCS RPC. It can listen to more than one socket identified by a socket address divided into address family (which defines the structure of the address), network address (host address) and port number (endpoint address).

Figure: NCS (Components of the Network Computing System)

The client procedure uses standard procedure calling conventions, but it is remotely executed by the server. The program that makes remote procedure calls to request operations is called an RPC client. It does not know how an interface is implemented and may not know the location of the server.

The process that receives the operation request packet from the RPC runtime library is the RPC server. It is responsible for sending the response with the results of the operation. A server can export an interface for more than one object.

The client process has three components: the client procedure that makes calls, the client stub and the RPC runtime library. The client stub is responsible for making use of the RPC runtime library to have the client procedure's calls executed.

The server process has three components: the manager procedures corresponding to the client application, the server stub corresponding to the client stub and the RPC runtime library. The server can be called a manager.

When the client requests an operation on a particular object through an RPC it must indicate the object on which the operation is to be performed and the server that exports the interface containing the operation. This information is passed by a handle, created and managed by several calls provided by NCS. The representation of the server in the handle is called binding. The client may or may not bind the handle by requesting an RPC with the following states:

The stubs are responsible for making the remote call as transparent as possible. They mediate between the client and the manager procedures, converting data for the use of RPC runtime routines.

The RPC runtime library transmits RPC packets containing routines, tables and data for supporting communication between the client and server stub. There are three types of calls: Network Interface Definition Language

The NIDL is a development language that completely defines the interface and each RPC's parameters. Two syntaxes can be used, one more comfortable for C programmers and the other for Pascal programmers.

The NIDL compiler translates the NIDL commands into executable stubs that will be linked with clients and servers. These stubs will be generated in C source code but are fully compatible with Pascal programs.

Figure: NIDL Compiler - Generated files.

The NIDL Compiler generates two client stub files: name_cstub.c and name_cswtch.c. The second one is a switch file used to create replicated servers to provide access to a replicated object and ensure consistency. The client calls are sent to the client switch that contains the public procedures, leaving the client stub only with the private procedures.

The stub generated can have two major responsibilities: The Location Broker

The Location Broker is used by the client to request information about objects and interfaces. This information is registered in the Location Broker by the servers.

The Location Broker is composed of three components:

The GLB may have several replicas running to ensure the availability of the information. To ensure the consistency of the replicas' data all the manipulation is done by the Data Replication Manager (DRM), which propagates any change in the database. The DRM uses a replica list containing the location of every replica. Clients are allowed to do lockups and updates even in the propagation procedures, which gives weak consistency but high availability.

The Location Broker database has the following fields:

Here are some definitions:

4.11.1 Implementations VM

The following list indicates the parts and versions of NCS that were ported to VM:

The IBM VM implementation of NCS differs from the Apollo Computer, Inc. implementation of NCS:

The VM implementation of NCS consists of three virtual machines: MVS

The same parts and versions of NCS were ported to MVS as in VM. Please refer to VM.

The MVS implementation of NCS consists of two servers: OS/400

NCS is not implemented in TCP/IP on the OS/400 system. AIX/ESA

NCS for IBM AIX/ESA is a port of Hewlett-Packard/Apollo's NCS Version 1.5.1 to the IBM AIX/ESA. For details, please refer to Network Computing System for AIX/ESA Planning and Administration. AIX/6000

NCS with the Network Computing Kernel, runtime services and the NIDL compiler are supported in both AIX Versions.

The implementation includes the Local Location Broker (llbd daemon) and the Non-replicated Global Location Broker (nrglbd daemon). Both daemons are controlled by the SRC (System Resource Controller) and can be started by uncommenting the #startsrc -s llbd and #startsrc -s nrglbd lines in the /etc/rc.ncs file. For more details, please refer to AIX Version 3.2 for RISC System/6000 Communication Concepts and Procedures and AIX Version 3.2 for RISC System/6000 General Programming Concepts.

The lb_admin, nidl and uuid_gen commands are available. Please see the online InfoExplorer facility for details. OS/2

NCS is not implemented in TCP/IP for OS/2. DOS

NCS is not implemented in TCP/IP for DOS.

Table of Contents Network File System (NFS)