Apparatus and method for managing resources in a network combining operations with name resolution functions

Abstract

When the name of a resource is inputted to a given context holder, a name analysis unit analyzes the name and a name translation unit converts it into first or second resource implementation representations. A name resolution unit receives the first or second resource implementation representations from each context holder. When the result of conversion is of the second resource implementation representations, the name resolution unit outputs a resource name of a second series or string of resource elements included in the second resource implementation representations to its corresponding context holder. This operation is executed on a chain basis to solve the name. A resource implementation unit outputs a handle for the resource corresponding to the result of name resolution therefrom. A user can obtain access to a virtual resource corresponding to the input name by using the handle. Owing to the above construction, an apparatus for and a method of managing resources can be provided which is capable of embodying a high-flexible distributed system providing name spaces for performing local resource access every users, which reflect preference and intentions for an access method by each individual user.

Claims

What is claimed is:

1. An apparatus for managing resources, which is suitable for use in a network information system wherein a plurality of computer systems for carrying out information processing are connected to one another by a network, comprising:

a plurality of context holding means each having a context identifier; and

name resolving means;

said plurality of context holding means each including:

name analyzing means for receiving therein a resource name corresponding to the name given to a resource and analyzing the name of the resource name; and

name translating means for converting the result of analysis by said name analyzing means into a result of name conversion, which is either a first resource implementation representation composed of a pair of a first series of resource elements with resource identifiers inherently held by real resources realized in advance within said each computer system as elements and a first series of implementation elements corresponding to procedure information for processing the real resources specified by the first series of resource elements to produce another resource or a second resource implementation representation composed of a pair of a second series of resource elements with individual pairs of a context identifier and a resource names as elements and a second series of implementation elements corresponding to procedure information for processing resources specified by the second series of resource elements to produce another resource; and

said name resolving means receiving the result of name conversion from the name translating means, determining whether the result of name conversion is the first resource implementation representation or the second resource implementation representation, if the result of name conversion is the second resource implementation representation, outputting a resource name included in the second series of resource elements to said context holding means specified by the corresponding context identifier, and if the result of name conversion is the first resource implementation representation, making a result of name resolution, which is a list of the resource identifier and the procedure information, according to the first resource implementation representation.

2. The apparatus for managing resources according to claim 1 further comprising:

resource implementing means for interpreting the procedure information included in the result of name resolution made by said name resolving means, and producing a resource, based on the result of the interpretation and the pre-realized real resource corresponding to the resource identifier included in the result of name resolution.

3. An apparatus for managing resources, which is suitable for use in a network information system wherein a plurality of computer systems for carrying out information processing are connected to one another by a network, comprising:

at least one first context holding means having a context identifier; and

at least one second context holding means having a context identifier;

said first context holding means including:

first name analyzing means for receiving a resource name corresponding to a name given to a resource and analyzing the name of the resource name;

first name translating means for converting the result of analysis by said first name analyzing means into a first series of resource elements with only resource identifiers inherently held by real resources realized in advance within said each computer system as elements;

first name resolving means for converting the result of conversion by said first name translating means into a first result of name resolution corresponding to a pair of the first series of resource elements converted by said first name translating means and procedure information for processing the, first series of resource elements; and

first resource implementing means for interpreting the procedure information included in the first name resolution result converted by said first name resolving means, effecting the result of interpretation on a real resource corresponding to the first series of resource elements to thereby produce a resource and outputting handle information for operating the resource;

said second context holding means including:

second name analyzing means for receiving a resource name therein and analyzing the name of the resource name;

second name translating means for converting the result of analysis by said second name analyzing means into a second series of resource elements with individual pairs of a context identifier and a resource name as elements;

second name resolving means for outputting a resource name of the second series of resource elements converted by said second name translating means to the first context holding means associated with the corresponding context identifier and converting the result of conversion by said second name translating means into a second result of name resolution corresponding to a pair of handle information obtained from said first context holding means and procedure information for processing a resource corresponding to the handle information; and

second resource implementing means for interpreting the procedure information included in the second name resolution result converted by said second name resolving means and effecting the result of interpretation on the resource corresponding to the handle information to thereby produce a resource.

4. An apparatus for managing resources, which is suitable for use in a network information system wherein a plurality of computer systems for carrying out information processing are connected to one another by a network, comprising:

at least one first context holding means having a context identifier; and

at least one second context holding means having a context identifier;

said first context holding means including:

first name analyzing means for receiving a resource name corresponding to a name given to a resource and analyzing the name of the resource name;

first name translating means for converting the result of analysis by said first name analyzing means into a first series of resource elements with resource identifiers inherently held by real resources realized in advance within said each computer system as elements; and

first name resolving means for outputting a first result of name resolution corresponding to a pair of the first series of resource elements converted by said first name translating means and procedure information for processing the first series of resource elements; and

said second context holding means including:

second name analyzing means for receiving a resource name therein and analyzing the name of the resource name;

second name translating means for converting the result of analysis by said second name analyzing means into a second series of resource elements with individual pairs of a context identifier and a resource name as elements; and

second name resolving means for outputting a resource name of the second series of resource elements converted by said second name translating means to the first context holding means specified by the corresponding context identifier, receiving therein the first result of name resolution from said first context holding means and outputting a second result of name resolution corresponding to a pair of each resource identifier and procedure information for processing a real resource corresponding to the resource identifier using the first result of name resolution received from said first context holding means.

5. An apparatus for managing resources, which is suitable for use in a network information system wherein a plurality of computer systems for carrying out information processing are connected to one another by a network, comprising:

at least one first context holding means having a context identifier;

at least one second context holding means having a context identifier; and

resource implementing means;

said first context holding means including:

first name analyzing means for receiving a resource name corresponding to a name given to a resource and analyzing the name of the resource name;

first name translating means for converting the result of analysis by said first name analyzing means into a first series of resource elements with only resource identifiers inherently held by real resources realized in advance within said each computer system as elements;

first name resolving means for outputting a first result of name resolution corresponding to a pair of the first series of resource elements converted by said first name translating means and procedure information for processing the first series of resource elements;

said second context holding means including:

second name analyzing means for receiving a resource name therein and analyzing the name of the resource name;

second name translating means for converting the result of analysis by said second name analyzing means into a second series of resource elements with individual pairs of a context identifier and a resource name as elements; and

second name resolving means for outputting a resource name of the second series of resource elements converted by said second name translating means to the first context holding means specified by the corresponding context identifier and outputting a second result of name resolution corresponding to a pair of each resource identifier and procedure information for processing a real resource corresponding to the resource identifier using the first result of name resolution received from said first context holding means; and

said resource implementing means interpreting the procedure information included in the second name resolution result outputted from said second name resolving means provided within said second context holding means and effecting the result of interpretation on the pre-realized real resource corresponding to the resource identifier to thereby produce a resource.

6. An apparatus for managing resources, comprising:

a first context holding means having a context identifier; and

a second context holding means having a context identifier;

the first context holding means

inputting a resource name corresponding to a name given to each of the resources,

analyzing the resource name, specifying a resource identifier, which identifies a real resource realized in advance, and procedure information for processing the real resource identified by the resource identifier in accordance with the result of analysis,

interpreting the procedure information,

producing a resource by the result of interpretation on the real resource identified by the resource identifier, and

outputting handle information for operating the produced resource;

the second context holding means

receiving a resource name,

analyzing the resource name,

specifying a context identifier and a resource name in accordance with the result of analysis,

outputting the specified resource name to the first context holding means identified by the specified context identifier,

receiving handle information corresponding to the output resource name from the first context holding means,

specifying procedure information for processing the resource corresponding to the handle information in accordance with the result of the analysis,

interpreting the procedure information, and

producing another resource by applying the result of interpretation to the resource corresponding to the handle information.

7. An apparatus for managing resources, which is suitable for use in a computer system for performing information processing, comprising:

at least one name analyzing means for receiving a resource name corresponding to a name associated with an attribute and given to a resource and analyzing the name of the resource name;

at least one name translating means associated with the attribute for converting the result of analysis by said name analyzing means into a result of conversion, which is either a first resource implementation representation composed of a pair of a first series of resource elements with resource identifiers inherently held by real resources realized in advance within said each computer system as elements and a first series of implementation elements corresponding to procedure information for processing the first series of resource elements or a second resource implementation representation composed of a pair of a second series of resource elements with pairs of each retrieval expression for directly or indirectly specifying the attribute and a resource name as elements and a second series of implementation elements corresponding to procedure information for processing a resource obtained from the second series of resource elements;

selecting means for selecting said name analyzing means and said name translating means receiving therein the result of name analysis from said name analyzing means, based on the retrieval expression included in the second resource implementation representation converted by said name translating means or the input retrieval expression; and

name resolving means for determining whether the result of the name conversion is the first resource implementation representation or the second implementation representation, if the result of the name conversion is the second resource implementation representation, transferring the resource name of the second series of resource elements included in the second resource implementation representation converted by said name translating means or the input resource name to the name analyzing means selected by said selecting means, and if the result of name conversion is the first resource implementation representation, making a result of name resolution, which is a list of the resource identifier and the procedure information, according to the first resource implementation representation.

8. An apparatus according to claim 7, wherein said name translating means comprises at least one name translation information associated with the attribute, said selecting means selects the name translating means by specifying said at least one name translation information and has name translation constructing means constituting said name translating means based on said at least one name translation information specified by said selecting means, and the name analyzing means selected by said selecting means transfers the result of name analysis to the corresponding name translating means constructed by said name translation constructing means.

9. An apparatus according to claim 7, wherein said name resolving means exists as plural in association with the attribute, said selecting means further selects said name resolving means, and the name translating means selected by said selecting means transfers the first resource implementation representation or the second resource implementation representation to the name resolving means selected by said selecting means.

10. An apparatus according to claim 7, further comprising resource implementing means for interpreting the first series of implementation elements in the first resource implementation representation obtained from said name translating means and producing a resource, based on the pre-realized real resource corresponding to the first series of resource elements from the result of interpretation.

11. An apparatus according to claim 10, wherein said resource implementing means exists as plural in association with the attribute, said selecting means further selects said resource implementing means, and said name resolving means transfers the first resource implementation representation to the resource implementing means selected by said selecting means.

12. In a network information system including a plurality of context holding units, a method for managing resources executed in each of the context holding unit, comprising the steps of:

receiving a resource name corresponding to a name given to each of the resources;

analyzing the resource name;

obtaining a result of name conversion in accordance with the result of analysis, the result of name conversion being either a first representation comprising a resource identifier, which identifies a real resource realized in advance, and first procedure information for processing the real resource identified by the resource identifier, or a second representation comprising a pair of a context identifier and another resource name and second procedure information for processing the resource specified by the resource name;

determining whether the result of name conversion is the first representation or the second representation;

if the result of name conversion is the first representation, interpreting the first procedure information;

producing a resource by applying the result of interpretation on the real resource identified by the resource identifier, and

outputting handle information for operating the produced resource;

if the result of name conversion is the second representation, outputting the second resource name to another context holding unit identified by the specified context identifier;

receiving handle information corresponding to the output second resource name from another context holding unit;

interpreting the second procedure information; and

producing a resource by applying the result of interpretation to the resource corresponding to the handle information.

Description

BACKGROUND OF THE INVENTION

1. Field of the Invention

The present invention relates to a system for managing resource handled by a plurality of computer systems for performing information processing, which is suitable for use in a network information system wherein the plurality of computer systems are connected to one another by a network.

2. Description of the Related Art

As one of conventional resource management systems, a resource management system for offering clearing house service, which has been proposed by U.S. Xerox corporation, has been described in, for example, a technical literature "Local Area Network, outline of Ethernet," revised second edition, by Akihiro Uetani, published by Maruzen Co., Ltd. The clearing house service corresponds to a distributed data base employed in the resource management system for managing names of resources employed in a distributed system so as to correspond to arbitrary number of attributes.

The clearing house service can handle the type of resource, a password, an alias, name of a file server, name of a mail box, name of a printer, a group, a list of delivery destinations, etc. as the attributes. However, the clearing house service does not provide the function of allowing names based on a plurality of local naming rules according to the uses and needs of individual users as well as global names to be given to the resources employed in the distributed system and enabling their treatment.

As another resource management system, there is known one employed in a GALAXY operating system described in, for example, a technical literature "Distributed Operating System, That Coming Next to UNIX"(UNIX is a trade mark of UNIX System Laboratories, Inc.)" by Kentaro Shimizu, Mamoru Maekawa and Hyo Ashihara, published by Kyoritsu Shuppan Co., Ltd., pp. 243-264 and a technical literature "Computer Software," Vo. 6, No. 3 (1989), pp. 19-34. This is of a system wherein a plurality of contexts corresponding to environments for interpreting names are provided and the contexts are constructed as a set of directories each composed of external names, translation names and a list of attributes.

This type of resource management system holds and manages a corresponding relationship of the external names to the translation names, based on a hash table or a table using a B-tree or the like. Therefore, the resource management system can handle the resources in the distributed system under unified external names given to the resources, thereby improving its operability. Further, since different external names can be given to the same resource in each context, the present system can provide local name spaces capable of giving a plurality of local names according to the uses and needs to the resources in the distributed system and handling the named resources. Since, however, the naming rule and the rule for name interpretation are all the same to each context, the resources in the distributed system cannot be handled by providing different naming rules every users and giving flexible local names according to the resource uses and needs to the resources respectively.

As a further resource management system, there is known a name resolution mechanism used in a distributed system, which has been described in a technical literature "A Model of Name Resolution in Distributed System" by Douglas E. Comer, Larry L. Peterson, in Proceedings The 6th International Conference on Distributed Computing Systems, (1986), pp. 523-530. When a client process makes a request for resolution of a name corresponding to a predetermined resource, the name resolution mechanism starts from an initial context at which the client process is operating and repeatedly performs conversion of the resource into another context and a name defined thereat. While contexts are successively displaced under this repetition, a resource defined in association with the name requested by the client process is finally converted into a final context managed in practice and a resource identifier interpretable under that context.

The use of the name resolution mechanism can realize a resource management system capable of applying local names local every contexts to resources in a distributed system and handling the so-named resources under the control of the resources, names and contexts capable of interpreting the names. At this time, the resource management system includes a single name resolution function for the entire system, for resolving the name while the name is allowed to act on the context and converting it into the final context and resource identifier while recursively performing its resolution. A mechanism of the name resolution function can be realized by a context having a name translation function of looking up a table with a name analysis for analyzing a first name and extracting a second name and a second name as keys so as to extract a pair of a second context and a third name therefrom and moving the process to the second context.

Since the aforementioned resource management system has the inherent name analysis and name translation functions every contexts, a plurality of naming rules can be introduced into the system. Accordingly, the resource management system can prepare a plurality of contexts according to the uses and needs and provide local and flexible name spaces every contexts. Since, however, the name translation function of the resource management system is confined to the conversion of one name into a single name or a set of plurality of names, no reference is made to a method of varying action operating on a resource represented by the third name and the second context. Namely, since the common name resolution function is used in the entire system, the name resolution mechanism cannot change a resource operation at each context.

Further, this literature makes a reference to the fact that the name resolution mechanism provides expansion to resolve the first name so as to fall into a set composed of a plurality of identifiers. In the name resolution mechanism, the first name corresponds to a group of a plurality of names for another context. A description has been made of the case where the name resolution mechanism is activated so that the same operation is applied to the plurality of identifiers using broadcasting communications, for example. In the name resolution mechanism, however, the operation to the first name cannot be implemented by combining different operations relative to the plurality of identifiers resolved by the name resolution mechanism. Further, no reference is made to a contrivance for embodying such a mechanism.

A name management system disclosed in Japanese Patent Laid-Open No. Hei 5-216799 (1993) is of a name associating management system for automatically converting a name in a certain name space into a name in another name space while avoiding the names from overlapping. This type of name management system is basically based on the same mechanism as the name resolution mechanism described in the disclosure of Douglas E. Comer, Larry L. Peterson. Therefore, the present name management system has the same problems as described above.

A method of connecting large-scale distributed computer systems having hierarchical structures, which has been disclosed in Japanese Patent Laid-Open No. Hei 5-189389 (1993), refers to a system for managing object identifiers from identifiers of objects in local name spaces forming a hierarchical structure to identifiers of objects constituting the identifiers of the objects in other local name spaces. The present management system is also basically based on the same mechanism as the name resolution mechanism described in the disclosure of Douglas E. Comer, Larry L. Peterson. Therefore, the present management system involves the same problems as described above.

An apparatus and a method suitable for use in a combined naming system, which is capable of disintegrate or resolving a combined name composed of names employed in several types of dissimilar naming systems disclosed in Japanese Patent Laid-Open No. Hei 5-274274 (1993), refer to an apparatus for and a method of resolving names by a combination of a plurality of different-type naming systems.

The aforementioned apparatus and method are basically based on the same mechanism as the name resolution mechanism described in the disclosure of Douglas E. Comer, Larry L. Peterson. This merely describes both a method of dividing names by a combination of dissimilar naming systems and an interface. Therefore, the apparatus and method involve the same problems as described above.

A name resolving device disclosed in Japanese Patent Laid-Open No. Hei 5-342134 (1993) refers to a parameter setting means for defining or specifying reliability and a name resolving device activated so as to automatically create or erase a duplicate of a directory defined as the result of name resolution depending on the degree of reliability specified by parameters and to request the duplicated directory to resolve a name when the duplicate exists.

The apparatus and method described above are basically based on the same mechanism as the name resolution mechanism described in the disclosure of Douglas E. Comer, Larry L. Peterson. This merely describes the name resolving device activated so as to automatically create the duplicate of the directory using the parameters given by a user and to resolve the name within its own node without requesting other context to resolve the name when the duplicate exists. Therefore, the apparatus and method involve the same problems as described above.

Further, any one of the aforementioned resource management systems does not refer to a mechanism in which contexts are provided as resources indicative of groups that some or all of resolvable names are members. Owing to the absence of the mechanism, group resources having desired members cannot be locally realized when a user fixes a context in which the intended member is regarded as a resolvable name.

SUMMARY OF THE INVENTION

The present invention provides an apparatus for managing resources, which is capable of defining the resources activated so as to differ from each other every contexts realized by applying predetermined operations on global real resources and providing local names based on naming rules different from one another every contexts.

Further, the present invention provides an apparatus for managing a plurality of resources, which is capable of respectively applying different operations on the resources so as to provide the function of accumulating their results of operations to thereby handle virtual resources unrealized in advance on a computer system and having properties desired by a user as if to exist as local resources respectively having local names.

Furthermore, more complex virtual resources can be hierarchically formed by other context, using virtual resources produced under a certain context.

It is thus an object of the present invention to provide an apparatus for and a method of managing resources, which is capable of embodying a high-flexible distributed system which provides name spaces for performing local resource access every users, which reflect preference and intentions for an access method by each individual user.

According to one aspect of the present invention, for achieving the above object, there is provided an apparatus for managing resources, which is suitable for use in a network information system wherein a plurality of computer systems for carrying out information processing are connected to one another by a network, comprising:

at least one first context holding means having a context identifier; and

at least one second context holding means having a context identifier;

the first context holding means including:

first name analyzing means receiving a resource name corresponding to a name given to a resource and analyzing the name of the resource name;

first name translating means converting the result of analysis by the first name analyzing means into a first series of resource elements with only resource identifiers inherently held by real resources realized in advance within each computer system as elements;

first name resolving means converting the result of conversion by the first name translating means into a first result of name resolution corresponding to a set of the first series of resource elements converted by the first name translating means and procedure information for processing the first series of resource elements; and

first resource implementing means interpreting the procedure information included in the first name resolution result converted by the first name resolving means, effecting the result of interpretation on a real resource corresponding to the first series of resource elements to thereby produce a resource and outputting handle information for operating the resource;

the second context holding means including:

second name analyzing means receiving a resource name therein and analyzing the name of the resource name;

second name translating means converting the result of analysis by the second name analyzing means into a second series of resource elements with individual sets of context identifiers and resource names as elements;

second name resolving means outputting a resource name of the second series of resource elements converted by the second name translating means to the first context holding means associated with the corresponding context identifier and converting the result of conversion by the second name translating means into a second result of name resolution corresponding to a pair of handle information obtained from the first context holding means and procedure information for processing a resource corresponding to the handle information; and

second resource implementing means interpreting the procedure information included in the second name resolution result converted by the second name resolving means and effecting the result of interpretation on the resource corresponding to the handle information to thereby produce a resource.

In the present invention, the name resolving means and the resource implementing means constructed so as to be included in the context may be realized as other processes.

By storing the contexts every parts forming each context in advance without realizing the context as a single process and inputting a retrieval expression, the contexts may be suitably constructed in combination.

The above and other objects, features and advantages of the present invention will become apparent from the following description and the appended claims, taken in conjunction with the accompanying drawings in which preferred embodiments of the present invention are shown by way of illustrative example.

BRIEF DESCRIPTION OF THE DRAWINGS

The invention will now be described with reference to the accompanying drawings wherein:

FIG. 1 is a block diagram showing a first embodiment of a resource management apparatus according to the present invention;

FIG. 2 is a configurational view showing a first specific example of the first embodiment shown in FIG. 1;

FIG. 3 is a view for describing one example of a corresponding table showing the relationship between a series of resource elements and resource implementation representations employed in each name translation unit of the first specific example of the first embodiment shown in FIG. 1;

FIG. 4 is a flowchart for describing one example of a procedure concat operation;

FIG. 5 is a flowchart for explaining one example of a read operation in the example of the procedure concat operation shown in FIG. 4;

FIG. 6 is a flowchart for explaining one example of a write operation in the example of the procedure concat operation shown in FIG. 4;

FIG. 7 is a flowchart for describing one example of the operation of a name resolution unit 4 employed in the first specific example of the first embodiment shown in FIG. 1;

FIG. 8 is a view for describing one example of a corresponding table employed in a name translation unit of a second context holder in a second specific example of the first embodiment shown in FIG. 1;

FIG. 9 is a view for explaining one example of a corresponding table employed in each name translation unit in a third specific example of the first embodiment shown in FIG. 1;

FIG. 10 is a flowchart for describing one example of a operation of a procedure interpolate.sub.-- 400.sub.-- 100;

FIG. 11 is a block diagram showing a second embodiment of a resource management apparatus according to the present invention;

FIG. 12 is a configurational view illustrating a first specific example of the second embodiment shown in FIG. 11;

FIG. 13A-B is a view for describing a local file system;

FIG. 14 is a configurational view showing one example of a resource manager in the first specific example shown in FIG. 12;

FIG. 15 is a configurational view showing one example of a group manager in the first specific example shown in FIG. 12;

FIGS. 16(A) to (D) are views for describing examples of corresponding tables held in each name translation unit in the first specific example shown in FIG. 12;

FIG. 17 is a configurational view showing one example of a group manager in a second specific example of the second embodiment shown in FIG. 11;

FIGS. 18(A) to (I) are views for describing examples of corresponding tables held in each name translation unit in the second specific example shown in FIG. 17;

FIG. 19 is a flowchart for describing one example of a procedure for creating each corresponding table in the second specific example shown in FIG. 17;

FIG. 20 is a flowchart for describing another example of the corresponding-table creating procedure shown in FIG. 19;

FIG. 21 is a configurational view showing one example of a group manager in a third specific example of the second embodiment according to the present invention;

FIGS. 22(A) to (D) are views for describing examples of corresponding table held in each name translation unit in the third specific example shown in FIG. 21;

FIG. 23 is a configurational view illustrating another example of the group manager shown in FIG. 21;

FIGS. 24(A) to (D) are views for describing other examples of corresponding tables held in each name translation unit in the third specific example shown in FIG. 21;

FIG. 25 is a configurational view showing a further example of the group manager shown in FIG. 21;

FIGS. 26(A) to (D) are views for describing further examples of corresponding tables held in each name translation unit in the third specific example shown in FIG. 21;

FIG. 27 is a configurational view showing one example of a group manager in a fourth specific example of the second embodiment according to the present invention;

FIG. 28 is a block diagram showing a third embodiment of a resource management apparatus according to the present invention;

FIG. 29 is a configurational view illustrating a first specific example of the third embodiment shown in FIG. 28;

FIG. 30 is a view for describing one example of a name resolution tree;

FIG. 31 is a configurational view illustrating one example of a group manager in the first specific example shown in FIG. 29;

FIG. 32 is a view for describing a process of resolving a name "/by-G/G1/monthly report" in the first specific example shown in FIG. 29;

FIG. 33 is a view for describing one example of a process of resolving a name "/by-G/G1" in the first specific example shown in FIG. 29;

FIG. 34 is a view for explaining one example of a process of resolving a name ".backslash.by-document.backslash.monthly report.backslash.G1" in the first specific example shown in FIG. 29;

FIG. 35 is a view for describing another example of the process of resolving the name "/by-G/G1/monthly report" in the first specific example shown in FIG. 29;

FIG. 36 is a view for describing a further example of the process of resolving the name "/by-G/G1/monthly report" in the first specific example shown in FIG. 29;

FIG. 37 is a configurational view showing a second specific example of the third embodiment according to the present invention;

FIG. 38 is a configurational view illustrating one specific example of a fourth embodiment according to the present invention;

FIG. 39 is a view for describing one example of a resource retrieval expression employed in the specific example shown in FIG. 38;

FIG. 40 is a configurational view showing one specific example of a fifth embodiment according to the present invention;

FIG. 41 is a view for describing one example of a resource retrieval expression employed in the specific example shown in FIG. 40;

FIG. 42 is a flowchart for describing one example of retrieval operations of a name analysis unit and a name translation unit in the specific example shown in FIG. 40;

FIG. 43 is a configurational view showing one specific example of a sixth embodiment according to the present invention;

FIG. 44 is a view for describing one example of a name translation information set in the specific example shown in FIG. 43;

FIG. 45 is a view for describing another example of the name translation information set in the specific example shown in FIG. 43;

FIG. 46 is a view for describing a further example of the name translation information set in the specific example shown in FIG. 43;

FIG. 47 is a view for describing one example of a resource retrieval expression in the specific example shown in FIG. 43;

FIG. 48 is a flowchart for describing one example of operations for retrieval of each name analysis unit and retrieval of name translation information, which are executed in the specific example shown in FIG. 43;

FIG. 49 is a view for describing a specific example of name translation information that satisfies conditions for the resource retrieval expression in the specific example shown in FIG. 43; and

FIG. 50 is a view for describing a specific example of a name translation unit produced in the specific example shown in FIG. 43.

DESCRIPTION OF THE PREFERRED EMBODIMENTS

Each individual embodiment to be described below shows a resource management system or apparatus wherein a plurality of computer systems which perform information processing, are dispersedly disposed on a network and resources, having properties desired by individual users, of resources locally or extensively managed every computer systems and handled by the computer systems can be handled as resources local to the individual users. Each of the embodiments includes a description of the operation for localizing groups or files typified as resources by a file system, particularly, a directory every users. The resources are not necessarily limited to the files or groups in the file system. For example, the resources may be hyper-text documents expressed by a grammar well known as HTML (Hyper Text Markup Language) in which SGML (ISO8879: Standard Generalized Markup Language) has been extended.

In general, the resource management apparatus according to the present invention may be realized so that the computer systems handle resources that can obtain a handle in which names are respectively given to hosts, memories, files, groups, ports, processes, users, data bases, etc. and operations relative to the resources indicated by the names can be applied to the names. As the operation relative to the file resource, open, read, write or close indicative of a file operation can be applied. However, the operation is not necessarily limited to it. The operation may be a part of them. Alternatively, seeks may be done.

The operation relative to the group resource is by-member represented but is not necessarily limited to this. A member-addition or member-deletion may be performed. As an operation with respect to HTML, may be any of operations which have been provided based on the protocol well known as HTTP (Hyper Text Transfer Protocol).

In the case of the file resource, for example, the handle is defined as a file ID obtained by opening a file. However, a pointer relative to a file structure in which the attribute of the opened file is stored, may be used as the handle. As the handle, may be a pointer relative to a socket ID or a socket structure to which the operation to the file can be applied. If ports for applying the operations relative to the resources thereto are used, then any ones may be generally used.

Each of the embodiments to be described below includes a description of a resource management apparatus realized as a single process of a single computer system. It is however not essential to realize it as the single process. Generally, the resource management apparatuses according to the present invention may be realized as a plurality of processes operated by performing mutual communications over a single or a plurality of computer systems.

Further, the embodiments to be described below include a resource management apparatus realized in accordance with procedure orientations. It is however not essential to realize it in accordance with the procedure orientations. The resource management apparatus may be realized in accordance with object orientations. Generally, the resource management apparatus of the present invention may use any implementation methods including the procedure orientations and the object orientations.

Furthermore, the embodiments to be described below include a resource management apparatus realized as a message communication using a port. It is however not essential to materialize it as the message communication using the port. Generally, the resource management apparatuses according to the present invention may be realized using communications among all processes including a remote program, a remote procedure, a socket and a shared memory.

Still further, the embodiments to be described below include a resource management apparatus having a cache relative to an access to each resource. It does not necessarily require the cache.

FIG. 1 is a block diagram showing a first embodiment of a resource management apparatus according to the present invention. In the drawing, reference numerals 1-1 through 1-n indicate context holders respectively, reference numerals 2-1 through 2-n indicate name analysis units respectively, reference numerals 3-1 through 3-n indicate name translation units respectively, reference numeral 4 indicates a name resolution unit, reference numeral 5 indicates a resource implementation unit, and reference numerals 6-1 through 6-n, 7-1 through 7-n and 8 through 12 indicate terminals respectively. The first embodiment comprises n context holders ranging from the context holder 1-1 to the context holder 1-n, the single name resolution unit 4 and the single resource implementation unit 5. The number of the context holders may be one. The first embodiment may normally include a desired number of context holders. Similarly, the name resolution unit may be one and the first embodiment may normally include a desired number of name resolutions units. Similarly as well, the resource implementation unit may be one and the first embodiment may normally include a desired number of resource implementation units.

The context holders 1-1 through 1-n respectively have inherent context identifiers. Further, the context holders 1-1 through 1-n have the terminals 6-1 through 6-n and the terminals 7-1 through 7-n respectively. The terminals 6-1 through 6-n are respectively of input terminals used for the context holders 1-1 through 1-n. Resource names are inputted to the terminals 6-1 through 6-n respectively. Further, the terminals 7-1 through 7-n are respectively of output terminals used for the context holders 1-1 through 1-n. The terminals 7-1 through 7-n respectively output resource implementation representations corresponding to the resource names input to the terminals 6-1 through 6-n.

Further, the context holders 1-1 through 1-n are respectively provided with the name analysis units 2-1 through 2-n and the name translation units 3-1 through 3-n. The name analysis units 2-1 through 2-n respectively analyze the names of the resources, which are inputted from the terminals 6-1 through 6-n. In response to the results of analysis by the name analysis units 2-1 through 2-n, the name translation units 3-1 through 3-n respectively convert the results thereof into first or second resource implementation representations. Each first resource implementation representation is composed of a combination or set of a first list or series of resource elements in which resource identifiers are defined as elements and a first list or series of implementation elements indicative of procedure information for processing the first series of resource elements. Now, the resource identifier is called an identifier inherently held by an actual resource which has been realized in advance in each computer system. Further, each second resource implementation representation is composed of a combination or set of a second list or series of resource elements in which individual sets of context identifiers and resource names are defined as elements and a second list or series of implementation elements indicative of procedure information for processing the second series of resource elements. The converted first and second resource implementation representations are respectively outputted from the terminals 7-1 through 7-n to the name resolution unit 4.

The name resolution unit 4 has the terminals 8 through 10. The terminal 8 is of an output terminal used for the name resolution unit 4 and outputs a resource name to any one of the context holders 1-1 through 1-n. The terminal 9 is of an input terminal used for the name resolution unit 4 and is supplied with the first or second resource implementation representation corresponding to the resource name outputted to any of the context holders 1-1 through 1-n from the terminal 8. The terminal 10 is of an output terminal used for the name resolution unit 4. The terminal 10 outputs the result of name resolution corresponding to any one of the first resource implementation representations inputted to the terminal 9. Namely, the name resolution unit 4 receives the first or second resource implementation representations outputted from the terminals 7-1 through 7-n of the context holders 1-1 through 1-n from the terminal 9. When the second resource implementation representations are received therein at this time, the name resolution unit 4 outputs a resource name of the second series of resource elements included in the second resource implementation representations to its corresponding context holder designated by a context identifier corresponding to the resource name from the terminal 8 thereof. The context holder, which has output the resource name, sends back the first or second resource implementation representations to the terminal 9. Thus, the first resource implementation representations can be obtained by suitably using the context holder on a linkage basis. The name resolution unit 4 outputs the result of name resolution corresponding to all or any of the resultant first resource implementation representations from the terminal 10.

The resource implementation unit 5 has the terminals 11 and 12. The terminal 11 is of an input terminal to which the result of name resolution outputted from the name resolution unit 4 is inputted. The terminal 12 is of an output terminal from which a handle of a resource associated with the result of name resolution outputted from the name resolution unit 4 is outputted. By using the handle outputted from the terminal 12 of the resource implementation unit 5, a user can effect access to and processing on a virtual resource corresponding to an input local resource name.

FIG. 2 is a configurational view showing a first specific example of the first embodiment of the resource management apparatus according to the present invention. In the drawing, the same elements of structure as those shown in FIG. 1 are identified by like reference numerals and their description will therefore be omitted. Reference numerals 21-21 through 21-n indicate resource holders respectively, reference numeral 22 indicates a resource manager, reference numeral 23 indicates a communication unit, and reference numeral 24 indicates a context manager. The resource management apparatus described in accordance with this specific example comprises M resource holders 21-1 through 21-M, a resource manager 22, a communication unit 23, a context manager 24, N context holders 1-1 through 1-N, a name resolution unit 4 and a resource implementation unit 5.

The resource holders 21-1 through 21-n hold actual resources therein respectively and are respectively provided with resource identifiers res-1 through res-M. The resource manager 22 controls or manages the resources held in the resource holders 21-1 through 21-M extensively or locally to a specific computer system. The communication unit 23 performs communications between the resource manager 22 and the context manager 24 and performs communications with other computer systems.

The context manager 24 controls the context holders 1-1 through 1-N. Further, the context manager 24 solves a name and acquires a handle using the name resolution unit 4 and the resource implementation unit 5. In the present specific example, context identifiers ctxt-1 through ctxt-N of the context holders 1-1 through 1-N and numbers of ports indicative of handles effecting communications on the context holders 1-1 through 1-N are constructed so as to be managed in sets by tables Upon retrieval, all the tables are scanned to search or find out an entry of a table coincident with a context identifier of a context holder to be retrieved, thus realizing the retrieval such that a handle for communicating with a context holder having the context identifier of the retrieved context holder is send back or returned. As the retrieval, a retrieval method known as the hash retrieval using a hash table without using a simple table may be used. In the present embodiment, the context manager 24 may acquire the handle for communicating with the context holder from the context identifiers. Therefore, if, for example, character strings or numbers defined as context identifiers and numbers defined as handle identifiers are managed so as to correspond to one another and a data base that provides a retrieval function based on a context identifier is used, the retrieval may be realized even in the form of any modes.

The context holders 1-1 through 1-N also have the context identifiers ctxt-1 through ctxt-N respectively and are respectively composed of name analysis units 2-1 through 2-N and name translation units 3-1 through 3-N.

Each of the name analysis units 2-1 through 2-N performs a lexical analysis and a syntax analysis of each name, for example and can be constructed so as to output an analysis tree as the result of name analysis. Algorithms of the lexical analysis and the syntax analysis have been described in the "Compilers", Addison-Wesley Publishing Co., Ltd. by A. V. Aho, R. Sethi, J. D. Ullman, Chapters 1 to 4, 1986, for example. Alternatively, all the input names may be constructed so as to be outputted to their corresponding name translation units as the results of name analyses as they are. In the following description of specific operations, the name analysis units will be described as having the construction of the latter.

Each of the name translation units 3-1 through 3-N outputs resource implementation representations that are a pair of a series of resource elements and a series of implementation elements, to each input name. The name translation units 3-1 through 3-N can be constructed as follows: For example, sets of names, a series of resource elements and a series of implementation elements are managed as a table. A series of resource elements and a series of implementation elements are acquired by referring to the table from the input name. Thereafter, resource implementation representations are produced and outputted in the form of sets.

Elements in the series of implementation elements for the resource implementation representations show procedures which allow handles for predetermined kinds of resources to be produced, directions for predetermined operations to be received from the resource handles and data to be input or output based on the resource handles. Further, the elements may be names or identifiers for procedures realized by using any of a process of providing each of resource identifiers given in resource implementation representations for a procedure input and effecting predetermined operations on a resource defined based on the provided resource identifier; a process of inputting or outputting data to the resource given based on the resource identifier; a process of referring to the contents of a predetermined memory; a process of changing the contents of the predetermined memory; and a process of processing desired data or by using the plurality of processes in combination.

FIG. 3 is a view for describing one example of a corresponding table showing the relationship between a series of resource elements and resource implementation representations employed in each of name translation units in the first specific example of the first embodiment according to the present invention. FIG. 3 shows a corresponding table in which four names composed of a name1, a name2, a name3 and a name4 are represented as table entries. In the table, the name1 is realized by a resource of a resource identifier res-1, a resource of a resource identifier res-2 and a procedure concat. Similarly, the name2 is materialized by the resource of the resource identifier res-1, a resource of a resource identifier res-3 and the procedure concat. The name3 is realized by the resource of the resource identifier res-1, a procedure archive and a procedure unarchive. Further, the name4 is realized by the resource of the resource identifier res-2, a procedure crypt and a procedure decrypt.

In the following description, the name translation unit 3-1 outputs resource implementation representations <{concat}, {res-1, res-2}> that show a pair of a series of resource elements {res-1, res-2} and a series of implementation elements {concat} to the input name name1. When the input name is other than the name1, the name translation unit 3-1 sends back an empty resource implementation representation { }. Now, the "concat" shows a name for a coupling procedure.

The aforementioned resource implementation representations <{concat}, {res-1, res-2}> means resources obtained by supplying the resources given to the name name1 by the resource identifiers res-1 and res-2, as first and second arguments for the procedure concat.

For example, the resources represented by the resource identifiers res-1 and res-2 are of normal files. The handle shows a socket for a UNIX operating system. The procedure concat can be realized as a process of swapping data obtained by reading and writing two files with the socket. In the present example, the procedure concat is realized so that the socket is produced as a handle corresponding to the resources having the name name1. As a result of name resolution with open instructions to the resources of the name name1 as a momentum, the handle is produced based on the procedure concat.

When, for example, a read operation is further applied to the handle produced by the procedure concat, the procedure concat serves so as to read the contents obtained by coupling the contents of a file supplied to the first argument and the contents of a second file applied thereto to one another. Further, when, for example, a write operation is applied to the handle, the procedure concat is operated so that data having a predetermined number of bytes alone is written into the resource having the resource identifier res-1 from the head and the remainder is written into the resource having the resource identifier res-2. In the present example, the contents of the two files given as the arguments are simply coupled to each other with the contents as the former portion and the latter portion. However, a plurality of files may be coupled to one another in any form.

FIGS. 4 and 6 are flowcharts for describing one example of a procedure concat operation. At S31, all the files given as arguments are first opened. When they are successfully opened, one socket is produced. At S32, data about all the files are read into an array R indicative of a cache in order from the file of the first argument. At S33, a pointer P for accessing each of elements in the array R is initialized so as to point out a first element in the array R. At S34, a pointer Q is initialized so as to point out the final element in the array R.

At S35, an operation effected on the socket is placed in a waiting state. When the operation is executed, it is determined at S36 which operation would be done. Thereafter, the corresponding processes are successively executed from the result of determination. If the operation to the socket is found to be "read" at S36, then a read process is executed at S37. The read process is shown in FIG. 5. It is judged at S51 of FIG. 5 whether the pointer P shows the end of a file. If the pointer P is found to be the termination of the file, then instructions indicative of absence of data to be read are outputted to the socket at S52. If the pointer P is found not to be the end of the file at S51, then data about an element in the array R, which is specified by the pointer P, is outputted to the socket at S53. Thereafter, the routine procedure proceeds to S41 in FIG. 4.

If the operation to the socket is found to be "write" at S36, then a write process is executed at S38. The write process is shown in FIG. 6. It is further judged at S54 of FIG. 6 whether the pointer P indicates the end of a file. If the answer is found to be Yes at S54, then an empty element is provided subsequent to the final element in the array R and the pointers P and Q are set so as to point out the newly-provided final element at S55. At S56, data written from the socket is written into an element in the array R, which is pointed out by the pointer P. If the answer is found to be No at S54, then the data written from the socket is written into the element in the array, which is pointed out by the pointer P at S57. Thereafter, the routine procedure proceeds to S41 in FIG. 4.

If the operation to the socket is found to be "end (close)" at S36, then data are written every predetermined amounts in order from the initial element in the array R so as to start from the file of the first argument in order of appearing in arguments at S39, thereby flashing the cache. Thereafter, all the files are closed at S40, followed by proceeding to the end of the routine procedure.

It is judged at S41 whether the pointer P is equal to the pointer Q. If they are found to be equal to each other at S41, then a value indicative of the end of the file is set to the pointer P at S42. If the answer is found to be No at S41, then the pointer P is set so as to point out the next element at S43. Thereafter, the routine procedure is returned to S35 from which the processing is repeated.

The present embodiment describes the case where the handle produced by the procedure concat is allowed to carry out both the read and write operations. However, the handle may be caused to carry out either one of them. A file operation other than the read and write operations may be carried out by the handle. For example, a seek process as well as the open process and the close process may be carried out.

If resource implementation representations are input to the name resolution unit 4 and a pair of an identifier for a context holding means and a name is included in the input resource implementation representations, then the name resolution unit 4 outputs a name constituting the set to a context holder determined by the identifier of the context holding means, which constitutes the set, thereby obtaining a second resource implementation representation associated with the name constituting the set. Next, the set is replaced by the so-obtained second resource implementation representation. Thus, the above operation is repeated until the identifier for the context holding means is not included in the input resource implementation representations. Alternatively, respective sets of identifiers in context holders and names, which are recursively included in resource implementation representations, are successively replaced by their corresponding resource implementation representations as in the case where a second set is replaced by a third resource implementation representation, a third set is replaced by a fourth resource implementation representation, . . . , an n-1th set is replaced by a nth resource implementation representation to thereby finally obtain the result of name resolution excluding the sets of the identifiers for the context holding means and the names.

FIG. 7 is a flowchart for describing one example of the operation of the name resolution unit 4 in the first specific example of the first embodiment according to the present invention. It is first judged at S61 whether a pair <C; N> of a context identifier C and a name N is included in resource implementation representations given as arguments. If the answer is found to be Yes at S61, then processes of next S62 through S66 are executed. At S62, the context identifier C is inputted to the context manager 24 to obtain a handle HC for the context identifier C. Further, the name N is inputted to the so-obtained handle HC at S63 and a resource implementation representation RN corresponding to the name N is obtained from the handle HC at S64. The processing of the name resolution unit 4 is recursively executed based on the resultant resource implementation representation RN at S65. At S66, the pair <C; N> is replaced by the result of name resolution I obtained at S65.

At S67, the resource implementation representation obtained from the result of replacement at S66 is sent back or returned as the result of name resolution. If it is judged at S61 that the pair <C; N> has not been included, i.e., the above replacement has not been made, then the resource implementation representations given as the arguments are returned as the result of name resolution as they are.

One example of the operation of the first specific example of the first embodiment will be described below. Here, the operation for designating or specifying the context identifier ctxt-1 and making a resolution request for the name name1 to the communication unit 23 will be described. When the resolution request for the name name1 under the designation of the context identifier ctxt-1 is received, the communication unit 23 requests the context manager 24 to search or retrieve the context holder with the context identifier as ctxt-1 from the context holders 1-1 through 1-N held and managed by the context manager 24.

The context manager 24 retrieves the context holder with ctxt-1 held as the context identifier. As described above, the context manager 24 represents the context identifiers of the context holders and the numbers of the ports indicative of the handles effecting communications on the context holders in the form of the sets and manages them by the table. By referring to the table, the number of the port indicative of the handle that communicates with the context holder 1-1 held associated with the context identifier ctxt-1 is obtained. In the following description, the resultant number of port is often called "handle".

Thus, the communication unit 23 inputs the name name1 to the context manager 24 to obtain a handle corresponding to the context holder 1-1. Next, the communication unit 23 requests the context holder 1-1 based on the handle to perform a name resolution process. The context holder 1-1 inputs the name name1 to the name analysis unit 2-1 and requests the name analysis unit 2-1 to analyze the same. The name name1 inputted to the name analysis unit 2-1 is outputted to the name translation unit 3-1 as it is.

The name translation unit 3-1 outputs the resource implementation representations <{concat}, {res-1, res-2}> indicative of the pair of the series of resource elements {res-1, res-2} and the series of implementation elements {concat} to the input name name1 and sends it back to the context manager 24.

The context manager 24 inputs the resource implementation representations <{concat}, {res-1, res-2}> returned from the name translation unit 3-1 to the name resolution unit 4. Since no context identifier is included in the resource implementation representations <{concat}, {res-1, res-2}> in the present example, the name resolution unit 4 returns the input resource implementation representations to the context manager 24 as the result of name resolution as they are.

The resource implementation unit 5 receives therein the result of name resolution <{concat}, {res-1, res-2}>, starts up the procedure concat as a process, assigns a handle identifier h1 to the handle produced by the procedure concat and outputs the handle identifier h1 to the context manager 24. The context manager 24 associates the name name1 and the handle identifier h1 with each other through the communication unit 23 and returns the handle identifier h1 to a client that issued the request for the resolution of the name name1. The client performs operations such as a data read operation, a data write Operation, etc. using the handle identifier h1.

As described above, the user gives a local name called name name1 to a local resource having properties equivalent to those of a hypothetical file obtained by coupling the file res-1 and the file res-2 to one another and can handle the name name1 as if the name name1 would be an actually-existing single file.

Since the resource management apparatus according to the first embodiment is constructed such that each of the name translation units outputs the resource implementation representations including the series of implementation elements as described above, the user can set the name name1 to the context holder 1 as the local resource, e.g., "the name1 is a resource obtained by coupling the res-1 and the res-2 to one another in accordance with the procedure concat". Thus, since the resource having the properties desired by the user can be locally realized, the resource management apparatus according to the first embodiment is able to solve the aforementioned problems.

A second specific example of the first embodiment according to the present invention will now be described. The second specific example is identical in structure to the first specific example except for the provision of second context holders as well as inclusive of the first specific example. The second context holders are identical in structure to the context holders 1-1 through 1-N in the configuration shown in FIG. 2. The second context holders are managed by the context manager 24. Namely, some of the context holders 1-1 through 1-N shown in FIG. 2 may be constructed as the second context holders. In the present example, the context holder 1-2 will be described as being regarded as the second context holder. A description will be specifically made of an example of a context holder in which the name name2 is used as a character string of "name1.Z" and which is activated such that when a read access is made under the name "name1.Z", a result obtained by expanding a resource of the name name1 in accordance with a predetermined compression/expansion method is read, whereas when a write access is made under the name "name1.Z", a result compressed by the predetermined compression/expansion method is written into the resource of the name name1.

The name analysis unit 2-2 of the context holder 1-2 indicative of the second context holder analyzes the input second name name2 in accordance with a lexical analysis or a syntax analysis and divides it into a name "Z" and a name "name1" in the form of symbols. Thereafter, the name analysis unit 2-2 outputs the name "Z" and the name "name1" to the name translation unit 3-2.

FIG. 8 is a view for describing one example of a corresponding table employed in a name translation unit of a second context holder in the second specific example of the first embodiment according to the present invention. The name translation unit 2-2 has the corresponding table shown in FIG. 8. A name "Z", a resource implementation element {compress} composed of a procedure compress, and a context identifier ctxt-1 are set in the corresponding table shown in FIG. 8 so as to correspond to one another.

The name translation unit 3-2 obtains the resource implementation element {compress} and the context identifier cntx-1 by referring to the corresponding table shown in FIG. 8 under the name "Z" inputted from the name analysis unit 2-2 and outputs resource implementation representations <{compress}, {<ctxt-1, name1>}>. Based on the resource implementation representations, the name "name1.Z" is able to show a local resource realized by both a resource represented by the local name name1 of the context identifier cntx-1 and the procedure compress.

The resource implementation representations <{compress}, {<ctxt-1, name1>}> are delivered to a name resolution unit 4. The name resolution unit 4 is activated in a manner similar to the first specific example. Namely, the name resolution unit 4 is operated in accordance with the flowchart shown in FIG. 7. In this case, each individual set of a context identifier and a name is included in the resource implementation representations. Therefore, the processes of S62 to S66 shown in FIG. 7 are executed. According to the processes, the context holder 1-1 having the context identifier ctxt-1 is called up to perform the resolution of the name name1. If, for example, the context holder 1-1 sends back the resource implementation representations <{concat}, {res-1, res-2}> as in the aforementioned first specific example, then {<ctxt-1, name1>} in the resource implementation representations is replaced by the above resource implementation representations and <{compress}, {<{concat}, {res-1, res-2}>}> are outputted as the result of name resolution by the name resolution unit 4. Further, a resource implementation unit 5 receives the result of name resolution therein so as to start up the procedure compress. The resource implementation unit 5 is identical in operation to that employed in the first specific example except for the startup of the procedure compress used as an alternative to the procedure concat.

Thus, the user gives a local name called name name2 to a local resource having such properties that upon reading, data obtained by expanding data about the resource represented by the name name1 in a predetermined mode is read, whereas upon writing, written data is compressed in the predetermined mode and the compressed data is written into the data about the resource represented by the name name1. Further, the user is able to handle the name name2 as if it would be an actually-existing single file.

Thus, since the resource management apparatus according to the first embodiment is able to have a plurality of context holders, a context holder capable of resolving the name name2 corresponding to a character string including the name name1 is constructed so as to solve a portion that do not include the name name1, whereas a context holder capable of resolving the name name1 is constructed so as to solve the remaining portions, thereby making it possible to hierarchically solve names. Consequently, the name name2 can be set to the context holder 2 as /name name2 is a resource obtained by compressing the name name1 of the context identifier cntx-1 in accordance with the procedure compress/, for example. Thus, since the resources having the properties desired by the user can be hierarchically designed and locally realized, the aforementioned problems of the resource management apparatus can be resolved. Since the design of name resolution can be hierarchically carried out under the above construction, each name space can be easily designed and new context holders can be constructed so as to use the already-existing context holders, thereby making it possible to easily re-use the name space.

A third specific example of the first embodiment according to the present invention will now be described. The third specific example is substantially identical in structure and operation to the first specific example. As the present specific example, an example will be described in which procedures for performing interpolation and extrapolation processes are carried out in combination to solve each of names. Here, the name will be represented in the form of "data name--resolution". The resolution is regarded as a character string indicative of positive real numbers.

In the following description, the data name is regarded as a name3 and represents image data. The resolution of the image data is regarded as 17.5.1. Namely, an input resource name is shown as "name3175.1". A resource res-1 is of image data whose resolution is regarded as a value scan-inputted on a 400 pixels-per-inch (=25.4 mm which will be the same below) basis. Further, a resource res-2 is also of image data whose resolution is regarded as a value scan-inputted on a 100 pixels-per-inch basis.

In the third specific example, the context holder 1-3 will be called up. The name analysis unit 2-3 in the context holder 1-3 analyzes an input name in accordance with a lexical analysis and a syntax analysis in a manner similar to the aforementioned second specific example. Here, implementation elements are separated into a character string on the left side as seen from a symbol ".sub.-- " used in place of the separator " " and a character string on the right side as seen from the same symbol.

FIG. 9 is a view for describing one example of a corresponding table employed in each of name translation units in the third specific example of the first embodiment according to the present invention. A name translation unit 3-3 has the corresponding table shown in FIG. 9. A series or string of resource implementation elements interpolate.sub.-- 300.sub.-- 100 and a series or string of resource elements res3 and res2 are registered in the corresponding table shown in FIG. 9 so as to correspond to a name name1. A series of resource implementation elements interpolate.sub.-- 800.sub.-- 100 and a series of resource elements res4 and res2 are registered in the corresponding table so as to correspond to a name name2. Further, a series of resource implementation elements interpolate.sub.-- 400.sub.-- 100 and a series of resource elements res1 and res2 are registered in the corresponding table so as to correspond to a name name3.

The name translation unit 3-3 receives therein a pair of the name name3 and a character string "175.1" indicative of a real number and acquires a procedure interpolate.sub.-- 400.sub.-- 100, a resource identifier res-1 and a resource identifier res-2 from the name name3 by referring to the corresponding table shown in FIG. 9. As a result, the name translation unit 3-3 outputs resource implementation representations <{interpolate.sub.-- 400.sub.-- 100 (175.1)}, res-1, res-2> therefrom. Now, the interpolate.sub.-- 400.sub.-- 100 (175.1) is defined as a procedure for forming or constituting images of 400 pixels per inch and 100 pixels per inch by an interpolation process and an image having a resolution of 175.1 pixels per inch by an interpolation process. Since the character string "175.1" indicative of the resolution is of a character string determined from an input name, it is constructed so as to be inputted to the procedure interpolate.sub.-- 400.sub.-- 100 as an argument for the procedure interpolate.sub.-- 400.sub.-- 100. Further, a character string indicative of a resolution of "400" or "100" or the like in the procedure name may be constructed so as to be inputted to the procedure interpolate as an argument for the procedure interpolate.

A name resolution unit 4 is activated in a manner similar to the first specific example. Further, a resource implementation unit 5 is activated in a manner similar to the resource implementation unit 5 of the first specific example upon starting up the procedure interpolate.sub.-- 400.sub.-- 100 except that 175.1 is inputted as the argument.

Since some of the names is given to the procedure as the argument in the third specific example as described above, a context holder can solve an infinite number of names different from one another. Accordingly, groups having an infinite number of members and groups capable of approximately handling names having continuity corresponding to real numbers as members so long as the accuracy of expression of data by a computer is allowed, can be constructed. Now, the handling of the names having the continuity as the members means that, for example, a name A-100. x constructed by a resolution x that satisfies 100.1<x<100. 2 between A-100. 1 and A-100. 2 is included as a member and can be resolved.

Thus, since the names and the procedures are respectively managed in combination, the conventional problem that the groups having the infinite number of members cannot be realized, can be resolved. By selecting a name having properties necessary for each individual user from the names having the continuity and enabling the resolution of the selected name, a high-flexible distributed system providing name spaces for resource access, which include local group resources reflecting preference and intentions for an access method by the individual users every users, is embodied.

One example of a process for the procedure interpolate.sub.-- 400.sub.-- 100 will be described as the last of the third specific example. FIG. 10 is a flowchart for describing one example of the process of the procedure interpolate.sub.-- 400.sub.-- 100. Now, the procedure interpolate.sub.-- 400.sub.-- 100 will take a format of "interpolate.sub.-- 400.sub.-- 100 (Param1)(ARG1, ARG2)".

At S71, files given as arguments ARG1 and ARG2 are all opened. When they are successfully opened, one socket is produced. At S72, data about all the files are read into two-dimensional arrays R400›x!›y! and R100›X!›Y! indicative of caches in order from a file given as a first argument.

At S73 through S76, arrays D›u!›v! are produced. Firstly, u=0 and v=0 at S73. Calculations of D›u!›v! at S74 through S76 are selected every Paraml steps according to the value of Paraml from combinations of all the u at which int(u*100/Paraml)+1 does not exceed the maximum value of X and all the u at which int(v*100/Paraml)+1 does not exceed the maximum value of Y. Here, the term int(x) will be regarded as a whole number of x, and the term frac(x) will be regarded as a decimal fraction of x.

When 100<Paraml <400, D›u!›v! is calculated at S74 as follows:

    ______________________________________
    D›u!›v! = (1 - (Paraml - 100)/(400 - 100)){(1-
    frac(u*100/Paraml))*(1 -
    frac(v*100/Paraml))*R100›int(u*100/Paraml)!›int(v*100/Pa
    raml) + 1! + frac(u*100/Paraml)*(1 -
    frac(v*100/Paraml))*R100›int(u*100/Paraml) +
    1!›int(v*100/Paraml)! + (1-
    frac(u*100/Paraml)*frac(v*100/Paraml)*R100›int(u*
    100/Paraml)!›int(v*100/Paraml) + 1! +
    frac(u*100/Paraml)*frac(v*100/Paraml)*R100›int(u*
    100/Paraml) + 1!›int(v*100/Paraml) + 1! + (Paraml -
    100)/(400 - 100)*{(1 - frac(u*400/Paraml))*(1 - frac
    (v*400/Paraml))*R400›int(u*400/Paraml)!›int(v*
    400/Paraml) + 1! + frac(u*400/Paraml)*(1 -
    frac(v*400/Paraml))*R400›int(u*400/Paraml) + 1!›int
    (v*400/Paraml)! + (1 -
    frac(u*400/Paraml))*frac(v*400/Paraml)*R400›int(u*400/Pa
    raml)!›int(v*400/Paraml) + 1! +
    frac(u*400/Paraml)*frac(v*400/Paraml)*R400›int
    (u*400/Paraml) + 1!›int(v*400/Paraml) + 1!
    ______________________________________

    ______________________________________
    D›u!›v! = (1 - frac(u*400/Paraml))*(1 -
    frac(v*400/Paraml))*R400›int(u*400/Paraml)!›int
    (v*400/Paraml) + 1! + frac(u*400/Paraml)*(1 -
    frac(v*400/Paraml))*R400›int(u*400/Paraml) +
    1!›int(v*400/Paraml)! + (1 -
    frac(u*400/Paraml))*frac(v*400/Paraml)*R400›int(u*400/Pa
    raml)!›int(v*400/Paraml) + 1! +
    frac(u*400/Paraml)*frac(v*400/Paraml)*R400›int(u*400/Par
    aml) + 1!›int(v*400/Paraml) + 1!
    ______________________________________

    ______________________________________
    D›u!›v! = (1 - frac(u*100/Paraml))*(1 -
    frac(v*100/Paraml))*R100›int(u*100/Paraml)!›int(v*
    100/Paraml) + 1! + frac(u*100/Paraml)*(1 -
    frac(v*100/Paraml)*R100›int(u*100/Paraml) + 1!›int(v*
    100/Paraml)! + (1 -
    frac(u*100/Paraml))*frac(v*100/Paraml)*R100›int(u*100/Pa
    raml)!›int(v*100/Paraml) + 1! +
    frac(u*100/Paraml)*frac(v*100/Paraml)*R100›int(u*
    100/Paraml) + 1!›int(v*100/Paraml) + 1!
    ______________________________________