JP3342659B2 - Distributed processing method, network system and node device - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a distributed processing method capable of controlling load allocation to a desired state on a distributed system, and appropriately performing real-time processing. The present invention relates to a network system capable of appropriately performing desired real-time processing by appropriately performing such operations, and a node device suitable for being applied to a node on such a distributed system.

[0002]

2. Description of the Related Art With the development of communication technology and an increase in demand for information processing, the computation on a network is becoming increasingly important in various fields such as distributed multimedia processing and distributed high-performance computation. Therefore, the spread of a system that can flexibly use various computing resources in various network-wide situations is expected. In order to construct such a system more easily, a method for handling distributed processing in a wide-area environment with an integrated framework and an efficient global parallel computation therefor are required.

[0003] Various methods have been proposed as methods for realizing calculations in such a wide-area environment. However, there have been proposed functions for handling global-area calculations in an integrated manner and functions for managing a global space and its resources. However, there was a problem that the response was not sufficient, and the requirements were not sufficiently satisfied. For example, CORBA (The Common Object Request Broker: A
rchitecture and Specification, Wiley, New York (19
91)) is a platform with a paradigm that specifies the location of objects in a uniform space, but is not suitable for wide-area network calculations, and reduces the computational efficiency due to hiding the characteristics of distributed processing. There is a problem with that. In addition, there is a problem that the calling interface of the object function must be defined, and the programming flexibility is lacking.

[0004] WWW (World Wide Web) (Berners-Lee, T.
et.al .: The World-Wide Web, Comm.ACM, Vol. 37, N
o. 8, pp. 76-81 (1994)) and the Java platform (Kramer, D .: The Java Platform: A White Paper, S
un Microsystems, MountainView (1995)), which downloads data and programs on the network based on the specification of resource descriptors and proceeds with the calculation, realizes the interactivity and the development of the functions of the system. There is a problem that there is a limit.

[0005] "A Distributed Object Model for the J
ava System '' (Wollrath, A., Riggs, R., and Waldo,
J., 2nd Conf.Object-Oriented Technologies and Sys
temsProc., pp. 219-231, USENIX, Berkeley (1996))
And "A Portable ORB Construction Method for Distributed Java Execution" (Satoshi Hirano, Koji Tsukamoto: Information Processing Society of Japan Research Report OS73-1)
0, pp. 55-60 (1996)), a wide-area distributed processing is realized, but it is limited to a specific language, and the space for calculation execution is also managed. There is no problem. `` A Users' Guide to PVM (Paralle
l Virtual Machine) ”(Beguelin, A. et.al .: ORNL / TM-
11826, Oak Ridge National Laboratory, Oak Ridge (1
991)) and `` MPI: The Complete Reference '' (Snir, Mee
t. al .: MIT Press, Cambridge (1996)), the distributed system construction functions such as PVM and MPI are designed for more tightly coupled systems.
It is not suitable for wider, loosely coupled systems.

"Widely Distributed Parallel Computing by Ninf" (Hideki Nakada et al .: Parallel Processing Symposium JSPP'97 Transactions, pp. 28
1-288, Information Processing Society of Japan (1997)) realizes efficient resource utilization in a wide-area distributed environment, but does not support global parallel computing. "Distributed Coor
dination Models for Client / Server Computing '' (Adl
er, RM: IEEE Computer, Vol. 28, No. 4, pp. 14-2
2 (1995)), the client-server method is a computational method in which the functions and specifications are fixed rather than the purpose of dynamically changing the function or connection form or the use of multiple modules interacting with each other. Suitable for

Therefore, the inventors of the present application have filed Japanese Patent Application Nos. 9-49033 and 8-278364, which are related to the present applicant.
Network systems and parallel distributed processing systems that can utilize various computational resources flexibly in various aspects of network wide, and treat the network as one integrated computing environment and perform parallel computation on it as shown in Has already been proposed.

[0008]

By the way, such a system is used for interactive wide-area multimedia processing such as VOD (Video On Demand) and video shopping.
Or, when trying to apply to problem areas such as intelligent distributed signal analysis such as inter-site cooperative tracking in radar networks, real-time processing in a wide-area distributed environment must be performed reliably and appropriately. Element.

However, in the above-mentioned application area, there are many uncertainties due to the characteristics of network response and time sharing, or the dynamic characteristics of the problem itself, and there is a problem that scheduling based on deterministic prediction is difficult. . Also, as a method of real-time processing in a distributed environment,
Methods using global management of tasks, analytical control of message chains, and hierarchical task allocation management have been proposed, but they do not cover computation and nondeterministic processing in a global environment. There is a need for an appropriate method. On the other hand, load balancing methods to be considered in real-time realization and concurrent object language systems with real-time control functions have been proposed. There is a request to use it in

Accordingly, an object of the present invention is to provide a distributed processing method capable of appropriately performing real-time processing on a wide-area distributed system. It is another object of the present invention to provide a network system capable of appropriately performing real-time processing by global parallel computation. Still another object of the present invention is to provide a node device which is suitable for being applied to a node of such a wide area distributed system and which can appropriately perform real-time processing on the distributed system in a coordinated manner. .

[0011]

In order to solve the above-mentioned problems, the present inventor performs local control for controlling execution of evaluation of an inter-object message in each node in an open network, and transmits the local information to a wide area. By linking, real-time processing on a distributed system is performed, and a global real-time system is realized.

[0012] In the distributed processing method according to the first invention, a plurality of processes having objects related to real-time processing are arranged on a plurality of nodes based on appropriately updated first information related to a network system. in a network system, a method for performing pre-you-time processing by a plurality of tasks in the plurality of objects,
In each of the above processes, for the input task,
A first priority based on a first scheduling policy is detected based on information indicating a priority attribute of a message related to the input task, and the input task is identified by the detected first priority. The task is registered and held in the task holding unit according to the priority, and the task having the first higher priority is selected from the tasks registered and held in the task holding unit, and the selected task is Detecting, based on the first priority, a second priority based on a second scheduling policy, and using the selected task as an execution thread in accordance with the detected second priority. Registering and holding the thread in the thread holding means, and selecting the execution thread having the second highest priority among the execution threads registered and held in the thread holding means, Executing the selected execution thread.

In a network system according to a second aspect of the present invention, a plurality of processes having objects related to real-time processing are appropriately updated according to a first system related to the network system.
A network system that is arranged on a plurality of nodes based on the information and performs the real-time processing by a plurality of tasks on the plurality of objects. A first scheduling policy based on information indicating a priority attribute of a message related to the task
Task registration means for detecting the priority of the input task and registering the input task in a task holding means; and task holding means for holding the registered task in accordance with the detected first priority. A task selecting unit that selects the task having the first higher priority among the tasks registered and held in the task holding unit; and a task selecting unit that selects, based on the first priority, the selected task. Detecting a second priority based on a second scheduling policy, and registering the second execution priority in the thread holding unit as an execution thread, according to the detected second priority. A thread holding unit for holding the thread, and an execution thread having the second higher priority among the execution threads registered and held in the thread holding unit. With that a thread selection device, and a thread execution means for executing the selected execution thread.

[0014] node device of the third invention is connected to a network system in which a plurality of nodes are connected, the process comprising an object according to the performed Ru real-time processing in the network system is arranged, the processing in the object A node device that executes a task related to the first scheduling policy based on information indicating a predetermined priority attribute of a message related to the input task with respect to an input task. A task registration unit for detecting a first priority based on the first priority and registering the task in a task holding unit; a task storage unit for storing the registered task according to the detected first priority; Among the tasks registered and held in the task holding means, the task with the first highest priority Task selecting means for selecting a task; detecting a second priority based on a second scheduling policy for the selected task based on the first priority; A thread registration unit that registers the registered execution thread in accordance with the detected second priority, and a thread registration unit that registers the execution thread in the thread storage unit. And thread selecting means for selecting the second higher-priority execution thread, and thread executing means for executing the selected execution thread.

[0015]

[0016]

[0017]

[0018]

[0019]

[0020]

[0021]

[0022]

[0023]

[0024]

[0025]

DESCRIPTION OF THE PREFERRED EMBODIMENTS One embodiment of the present invention will be described with reference to FIGS. In the present embodiment, a description will be given of a case where global real-time processing is performed on a network in which distributed resources are combined as one integrated computing environment on the network.

The method of global concurrent computations will be described first global concurrent computations performed in this embodiment. FIG. 1 is a diagram showing a conceptual configuration of global calculation according to the present embodiment. Global Computation is computation on a wide area network, in which distributed resources are logically integrated and executed on it. Here, a wide area network is a mixture of various communication media such as the Internet, a CATV network, and satellite communication. Distributed resources include a database and a high-performance network in addition to hardware such as computer nodes. Calculation server, WWW
It provides a calculation potential such as an information source such as a page. The calculation includes execution of various processes in a wide range.

Basic Paradigm of Parallel Computation In such a basic scheme of global computation, a distributed module executes parallel computation by asynchronous message exchange, and progresses computation globally by chaining the messages. In consideration of suitability for wide-area distributed / cooperative calculation, it is desirable to provide a calculation framework with less synchronization.

The distributed module that executes the global calculation is called a concurrent object. This concurrent object is managed by a global reference represented on a certain global computation space. Therefore, the global computation space is a set of a set of concurrent objects and a relation between objects indicated by using a global reference. A concurrent object is a computational entity in a computation space, and is a distributed object, a distributed function, or a global shared variable that can be remotely called. With these, distributed object-oriented computation, distributed procedure (function) call, and parallel computation having a paradigm of global shared variables are performed.

Communication between concurrent objects, such as calling a distributed object method or a distributed function and accessing a global shared variable, for performing such a calculation is performed by asynchronous message transmission (one-way communication with no return value), delay. It is performed by three types of methods: an evaluation-type synchronous call (block when a return value is accessed) and a fully synchronous call (the caller blocks until a return value arrives). These communications are collectively called messages.

On the message, between concurrent objects,
Any data structure can be sent. To handle data structures in messages between concurrent object must process a data structure in the logical format. Therefore, the message communication has a function of tracing the data structure of an argument to be transmitted and formatting the structure element in a logical form, and a function of generating the same structure as the original data from the logical form. Realizes transmission and reception of structures. If the partial structure is shared, the shared part is duplicated on the receiving side.

In execution of a process based on a message (hereinafter, this may be referred to as evaluation), the computation of a distributed object method and the access of a global shared variable are executed exclusively and atomically (indivisibly) on the object. I do. Therefore, when it is desired to evaluate a plurality of messages in parallel on the same object or to perform a delay process in a method, they are described in the form of being divided into asynchronous messages and processed. If a method belongs to an object depending on the programming language actually operated, the execution is performed on the object. If the method is derived from a functional, the execution is performed at the location of the method. It should be noted that the scope of the calculation target is inside the concurrent object, and the operand of the remote object cannot be directly viewed.

Object management and message passing
Concurrent objects placed in the functional global computing space generate and manage processes in network nodes. A plurality of computing spaces can be individually formed and managed on the same network environment. A process is a computing environment for concurrent objects. FIG. 2A shows the relationship between the concurrent object and the process, and FIG. 2B shows the internal state configuration of the concurrent object.

The process provides the function of global reference and its management, and the mechanism of message passing between concurrent objects. The message passing mechanism includes an application language interface (API) and a system interface to the OS and hardware. Objects and processes can move dynamically in the computation space. Note that these APIs
The movement of objects and processes will be described later in detail. These features are available in programming languages and O
It can operate according to the difference of the execution environment such as S, hardware and network. The message can be transmitted between different languages, and as described above, an arbitrary data structure can be handled as an argument. An execution environment obtained as a set of processes functions as a common virtual computing environment in the global space.

Message Passing Architecture The message passing described above will be described in more detail. FIG. 3 shows a message passing mechanism for realizing global calculation according to the present embodiment. This mechanism provides the ability to execute concurrent objects in a process. The message transmission / reception is performed by the message communication unit of the process 300.
(Message Passing Operator) 310. The calculation entity involved in the transmission / reception is the reference table 321 and the reference resolution function 320
Identify by. The execution of the received message is controlled by the scheduler 400. The application programming function 330 provides an API (Application Programming Interface) related to message transmission. Hereinafter, these functions will be described in detail.

Management and Resolution of Global References Global references are managed by a remote reference table and a local reference table in a process. The remote reference table is a management table for obtaining a network node, a process, and a remote identifier from a global reference when transmitting a message. The local reference table is a correspondence table between a remote identifier and a local identifier, and is used to specify a calculation entity in a process. Global references across different communication media are made to correspond to yet another global reference from the remote identifier in a relay process sharing them. FIG. 4 shows an example of a scheme of object reference at the time of message transmission and their correspondence in a reference table.

The reference table is initialized when a process is generated, based on the reference relationship between program modules. Further, when a distributed object is generated or when a new program module is arranged, a new reference is registered. Conversion from a global reference to the information to be referred to is referred to as reference resolution. The conversion obtains information to an object, domain, or external system from a global reference or its descriptive name. Reference resolution works recursively until the identity of the object can be identified. FIG. 5 shows the structure of the reference solution and the function.

Message Transmission The message transmission function is shown in detail in FIG. In the message transmission, by calling a message transmission function on the API, as described later, the structure of the argument is recognized and converted into a logical form that can be transmitted, the reference of the destination object is resolved, and the transmission processing is performed. . RP between nodes via communication media interface depending on the location of destination
C, the intra-node IPC, or the in-process communication is selected and transmitted. The reason for using RPC between nodes is to grasp the arrival of a message. If the transmission destination is a domain or an object cluster, multicast is performed for each process. The communication media interface is prepared for each corresponding medium, and can specify the type to be used according to the type of data and the content of control.

FIG. 7 shows the details of the message receiving and evaluation activation message receiving function. Upon receiving the message, the message dispatcher identifies the receiving object from the received remote identifier, and generates a function descriptor for performing the processing. Message arguments are expanded from a logical format into a data structure. The function descriptor holds information for invoking an object method and a distributed function or access to a shared variable, a time attribute and a priority of a message, and information for calling a message transmission source object. This function descriptor is passed to a scheduler described later and processed. When the message transmission is performed by synchronous calling, the evaluation value obtained by the execution by the scheduler is similarly converted into a logical form and transmitted to the calling side by the same message transmission function. If the reference is being relayed, a new global reference is obtained from the remote identifier, and the message dispatcher calls the message transmission function as it is.

Message Evaluation Scheduling As described above, computations are performed by chaining messages between objects. Therefore, the scheduling of the calculation is performed by controlling the execution of the evaluation of the message transmitted between the parallel objects based on the attribute indicating the time constraint and the priority.

FIG. 8 shows a functional configuration of the message evaluation scheduling method. Scheduling is
Calling long-term scheduling and short-term scheduling 2
It is realized in two processes. Long-term scheduling is
The order of message evaluation is controlled independently from system functions such as the OS from the measures of temporal long-term and spatial wideness. Short-term scheduling performs ordered message evaluation locally on a short-term time scale, while taking advantage of system capabilities. Hereinafter, the method and function of the message evaluation scheduling will be described.

Global Scheduling Scheme Scheduling that deals with real-time processing provides a norm for "time" based calculations. However, in the case of computations caused by a chain of messages, "time" only needs to be consistent in the chain. That is, each of the local fields that perform scheduling need not share a globally consistent time. Therefore, a time constraint in the evaluation is described as an attribute in the message as needed.

The task unit to be scheduled is the evaluation of messages transmitted between objects. The scheduling process is performed locally for each process. A meta function that supports global load distribution is provided between processes. The task is executed by long-term scheduling and short-term scheduling as described above. In the long-term scheduling, a message to be evaluated is selected based on a time attribute and a priority attached to the message and is made executable. Global time constraints are resolved with long-term scheduling. In the short-term scheduling, control for processing a plurality of message evaluations in a movable state in parallel is performed.

The message has attributes as time attributes and priorities. The time attribute includes a scheduling policy, a data time, a message transmission time, a permissible evaluation time (deadline), a periodicity of a message, a strictness of real time, and a permissible inaccuracy of calculation. Here, the data time refers to globally treating a time locally given to data to be processed, such as an occurrence time or an external time.

In order to perform real-time processing, uniformity of load between processes or between nodes is important for improving the real-time performance of the system. In the long-term scheduling, load balancing among nodes is adopted, and in the short-term scheduling, load sharing in a space to which processing resources are allocated is adopted in the scheduling method. Processing of load balancing
That is, the processing after dynamically grasping the load is not realized as a system function, but is provided as a meta function that supports realization of load distribution in execution of an application.

Executing a task as a message evaluation
This is performed by the thread function of the OS. In many distributed object computing systems, each object has a thread for executing a method. In our method, a thread is dynamically allocated to a message evaluation task. Thereby, thread resources can be effectively used.

Configuration of Scheduler The configuration and operation of a scheduler that performs such scheduling will be specifically described with reference to FIG. FIG. 9 is a diagram showing a part of the message receiving function in the message passing mechanism and the configuration of the scheduler.

As described above, the message dispatcher 311 generates, from the received message, a function descriptor having execution information and attributes of the evaluation. The registration of the function or the method calling function indicated by the function descriptor generated by the message dispatcher 311 in the scheduler 400 is performed by a pre-invoke 331 of the application programming function (Application Prog. Features) 330.

The plain voice 331 is a function that makes the execution of a function a management target of the scheduler 400 and gives an operation timing to the scheduler 400. The plain voice 331 executes the method or function of the specified object on the scheduler 40.
A function descriptor (FunctionDescriptor) having a structure as shown in (1) is generated and registered in the process queue in order to register it in 0. And the long-term scheduler 41
0 is passed to the registration function (RegistFunction) 411.

[0049]

## EQU1 ## FunctionDescriptor * prevTimeQ Forward pointer for priority slot queue or pool. FunctionDescriptor * nextTimeQ Backward pointer for priority slot queue or pool. ThreadID threadID Thread for method or function execution long priority Priority TimeVal * timeVal Transmission time TimeVal * arrival_timeVal Receiving time TimeVal * queue_timeVal Queue entry time TimeVal * pool _timeVal Pool entry time TimeVal * method _start _timeVal User method start time TimeVal * method _end _TimeVal User method end time void * param Logical pointer to the argument storage area unsigned long id1 Reference to the object to which the method belongs unsigned long id2 Method or function identifier int call_mode Transmission mode recvInfo * recv_info Data area from CMIrecv char * instName Object instance name (valid only when calling the method) Args * args Pointer to the execution format argument storage area int argc Number of execution format arguments void * obj this pointer of the object (valid only when calling the method) MessageAttributes * ma Message attribute (scheduling strategy and its parameters) storage area ... (1)

When the function of the function or the method of calling the function is completed in the scheduler 400, a Post-Invoke 332 is started. The post-invoking 332 excludes the function from the management target of the scheduler 400 and gives the scheduler 400 an operation timing. Moreover, if you need to return a return value, it performs the processing. Specifically, the post-invoking 332 removes the function that has finished processing from the process queue, and deletes the function (D
eleteFunction) 422, Pool (Functions Poo
l) Function descriptor from 424 (FunctionDescrip)
tor).

Scheduler (Message Evaluation Schedu)
ler) 400 is a long-term scheduling (Long-Term Sched
uling) (Long-Term Scheduler)
410 and Short-Term Scheduli
ng) Short-Term Scheduler 4
20 and a function descriptor (FunctionDescrip).
tor) as a task and control its execution.

The long- term scheduler 410 has a function descriptor (Fun
ctionDescriptor) is managed according to its priority, and the highest priority is sent to the short-term scheduler 420 as appropriate. The registration function 411 has a function descriptor (Funct
The conversion priority is calculated based on the scheduling strategy from the priority attribute described in (ionDescriptor), and a function descriptor (FunctionDescriptor) is placed in the slot of the corresponding priority according to the conversion priority. If there is no corresponding priority slot, the slot is generated. The registration function 411 calls a schedule function (ScheduleFunctions) 413.

[0053] Delete function (DeleteFunction) 41
2 removes the function or method from the management target of the scheduler. The deletion function 412 calls the deletion function 422 and the schedule function 413 of the short-term scheduler 420. The schedule function 413 selects and executes an executable function or method. That is, a selection function (SelectFunction) 415 is called, a function descriptor (FunctionDescriptor) of a function and a method is selected according to a scheduling strategy, and those threads are made executable.

The functions queue 414 is
It is configured as a set of instances of the class TimeSlot as shown in (2), and manages functions or methods waiting to be executed. Specifically, the function descriptor (Functio
nDescriptor) is held for each priority slot classified by the conversion priority calculated based on the priority attribute of the message based on the scheduling strategy.

[0055]

[Equation 2] TimeVal * tvStart Priority of current priority slot TimeVal * tvEnd Priority next to current priority slot TimeSlot * prev Priority slot before current priority slot TimeSlot * next Next to current priority slot Priority slot FunctionDescriptor * fd List of current priority slots (priority slots are FunctionDescriptor lists)… (2)

FIG. 10 shows the structure of the functions queue 414. As shown in FIG. 10, the instances generated by the class TimeSlot as shown in (2) constitute each priority slot. As shown in FIG. 10, the second priority slot is the current slot (curr
ent). The slot immediately before the current is used as a priority slot (prior). The priority slot manages a slot having a higher conversion priority than the current one, such as a slot that is temporally older than the current priority due to, for example, passing of a message that occurs because message communication is performed asynchronously. The function descriptor (Funct) held in each priority slot
When ionDescriptor is exhausted, the priority slot is deleted and its reference is sequentially updated. When a new function descriptor (FunctionDescriptor) is registered in time, a new priority slot (new) is added.

The selection function 415 selects a function or a method having a high conversion priority. The selection function 415 selects an executable function descriptor (FunctionDescriptor) from the old priority slot if the old priority slot of the functions queue 414 is not empty, and from the current priority slot if the old priority slot is empty. Executable function descriptor (FunctionD
Escriptor) is a function, or a method in the absence of those running in the other on the object. The state of whether or not the object is being executed is managed by the “in-execution” slot of the object.

The selected function descriptor (FunctionD
escriptor), except for the Functions Queue 414, the registration function (Reg
istFunction) 421 and calls the pool (Functions P
ool) 424. Functions Queue 414
When the current priority slot becomes empty, the current priority slot and the old priority slot are advanced by one. Discard old old slots.

As described above, the long-term scheduler 410
The received task (function descriptor) is queued (F
stored in the unctions Queue) 414, selected based tasks should be activated evaluate the message attribute, the selected task is removed from the queue, short scheduler 42 0
Send to.

In this operation, the long-term scheduler 410 controls the evaluation order of the target tasks on a global scale. The evaluation order is represented by a task priority calculated based on the scheduling policy based on the message priority, the time attribute, and the current time in the process. In the long-term scheduling, the chronological policy is more important. Also, in Functions Queue 414,
Tasks are managed according to the priority that reflects the process time at the time of calculation, and the order dynamically changes over time. Especially in long-term scheduling, this priority is
By obtaining from a global time element such as the data time of the time attribute, management with priority on globality is performed.

When the priority is calculated only from the local time, the accuracy of the order is stochastically the order of the relative difference of the local time between the nodes, and the difference of the local time between the nodes is It is possible to recognize in the order of the minimum time of message transmission. Also, in long-term scheduling, message evaluation on the same distributed object is performed exclusively. Therefore, the distributed object holds a message execution state and selects a function descriptor based on the state.

The short- term scheduler 420 has a function descriptor (Fun
ctionDescriptor)
It manages the priority of (thread) and controls its execution by the OS. The registration function 421 executes the execution of the function or method input from the selection function 415 of the long-term scheduler 410 by the short-term scheduler 420.
To be managed. At this time, the registration function 421
Converts the conversion priority of the function descriptor (FunctionDescriptor) into the thread priority of the OS based on a relative value to the current priority of the pool (Functions Pool) 424.

The delete function 422 removes a function or a method from the management target of the short-term scheduler 420. At this time, the schedule function (ScheduleF
unctions) 423. The schedule function 423 receives a new function or method from the long-term scheduler 410 or, based on the end of the function or method being executed, based on the manipulation function priorities (MFP).
lateFunctionPriorities) 425 is called and the pool (F
The function and thread priority registered in the unctions pool 424 are updated. Pool (Functions Pool) 42
4 is the same as the Functions Queue 414,
It is configured as a set of instances of the class TimeSlot as shown in (2), and manages the function or method being executed. The specific structure and operation of the
ion Queue) The same as 414.

The MFP 425 has a function pool.
The thread priority of the method or function registered in 424 is operated. That is, the conversion priority is set to OS
Convert to thread priority and manage. The thread priority is appropriately changed according to the deadline satisfaction prediction rate, priority inheritance due to resource lock, and upper limit processing.
Here, the priority of the thread is calculated and set in consideration of all the threads.

As described above, in the short-term scheduler 420, the tasks sent from the long-term scheduler are allocated to the execution threads and held in the pool (Functions Pool) 424. The execution thread is a process that calls and processes an actual function or method based on the information of the function descriptor. Then, the execution of the evaluation of the function descriptor in the movable state on the pool is controlled using the thread function of the OS. The thread priority is calculated based on the short-term scale again from the time attribute and the priority of the message. That is, the short-term scheduler performs processing such as dynamically changing the priority according to the margin up to the deadline.

The execution of the thread by the OS function is performed, for example, in real-time processing of tasks other than message evaluation, such as a domain task in a process for locally controlling continuous media processing, and in view of adaptability to an execution environment. Valid from. When the OS performs processing such as priority inheritance due to resource locking or the like, the operation of the thread priority is temporary, and the operation of the priority by the short-term scheduler can be performed without interference. If there are multiple PE (Processing element) on the node, splitting or PE space based on the process and object placement, like assignment to threads PE is Ju <br/> Ningu I by the short-term scheduler.

Load distribution Load distribution in such scheduling will be described. Load distribution is roughly classified into load balancing and load sharing methods, and furthermore, there are a spread type and a task filling type. The diffusion type is a method of distributing the load to each node so that the load on each node becomes uniform, as shown in FIG. 11A, for example. The task filling type is shown in FIG.
As shown in (b), this method packs the load within a range close to the processing capacity of each node and sequentially loads each node. The diffusion type is effective for terminating a predetermined load in a short time. However, for example, when a load 1 is newly applied, if the task filling type can be used, processing can be performed immediately. Each has its own characteristics.

In this embodiment, such a method of load distribution is adopted for long-term and short-term scheduling, respectively, based on its characteristics. In long-term scheduling, it is necessary to suppress the occurrence of asynchrony and increase the responsiveness of the entire system by balancing the load between processes and between nodes. In order to perform load balancing in a wide-area distributed environment, it is preferable to perform load-balancing control, and this is also employed in the global parallel computing system of the present embodiment. That is, the diffusion-type load balancing provides an application with a function of distributing messages among replicated objects and a function of determining an arrangement when generating a new object and a process. At the same time, the application can also perform the migration processing of the object and the process by the domain knowledge, thereby promoting the load balancing.

In the short-term scheduling, the generated message evaluation task must be executed without delay. In the load sharing in the real-time processing, a task filling type process is performed to cope with an aperiodic task input. In addition,
This processing is performed only when one process is shared by a plurality of PEs from the viewpoint of the load monitoring cost.

API (Application Programming)
Interface) In the global computing environment described in this embodiment, what is provided as a programming interface are the basic definition and generation functions of concurrent objects and the message transmission function as described above. The message sending function supports Send, Call, and SyncCall in accordance with the message method described above.
Kind. Object methods and functions can be called by messages by making global public declarations in the program. No special call interface need be specified. By specifying the destination by global reference and processing by the logical form of the argument, it is possible to transmit a message between different languages. Message processing in the C ++ API is illustrated in (3).

[0071]

RemoteClass rc ("fee: foo"); RemoteMethod rm ("fee: foo :: bar"); RemoteInstance ri = CreateObject (rc, 7, "A", "process"); Bee bee;… Send (ri, rm, 1, "abc", bee);… ------ PACKAGE fee class foo: DistributedObject ｛public: foo (int i, char * s); PUBLIC int bar (int i, char * s , Bee bee);｝… (3)

In (3), the class reference r
By generating c, generating a method reference rm, generating an instance object ri of class foo, generating a local object called bee (as an argument), and calling a method rm (bar) of ri by message communication with the remote instance ri. I have. In the latter half, the definition of class foo and the method bar in foo
Is defined. "process" is a process indicated by the arrangement information, and PACKAGE is a unit of a program constituting a program module. Then, for global reference, necessary items are automatically generated from the relationship between the arrangement information and PACKAGE. At this time, rc, rm, and ri are indices to the global reference.

Dynamic Management of Objects As described above, concurrent objects and processes can move in a computation space. In that case, the global reference of the object is kept as it is. Also,
The reference to the object causes an indirect reference to exist for a while in the source process, and switches to a new reference when the original reference is accessed. Concurrent objects are the subject of global garbage collection. Global garbage collection is performed by determining the presence or absence of a global reference to a concurrent object. Weights and counters are added as system tags to the global reference and the parallel object, respectively, and an immediate collection based on the weighted reference counting method is performed. Resources in the process that depend on the execution environment are subject to local collection or processing by the application programmer.

Evaluation of Real-Time Characteristics A specific example of a global parallel computing system having such a configuration is shown in FIG.
/ AT compatible machine, 10Base-T Ethernet / 156Mbps ATM In the environment where C ++ and Java are operating as API language, time response of message propagation evaluated as preliminary verification of system real-time characteristic evaluation The basic performance is shown. In this verification, in the following problem, the responsiveness near the processing capacity upper limit value was observed by changing the number of nodes and the scheduling policy. The actual experiment was conducted in C ++ / Solaris / SpacStation (HyperSarc / 12
5MHz) / 10BaseT Performed on Ethernet.

An experimental problem is that eight messages are input in parallel to a system of 64 distributed objects at a constant frequency, and messages are propagated between the objects 32 stages in accordance with the input.
The responsiveness is observed. All messages were asynchronous and the computational granularity of the evaluation was uniform. In the case of multiple nodes, the destination of the message is distributed Gaussian around a node different from the source. In the deadline, a time obtained by equally dividing the response time of the entire system at the upper limit of the processing capacity by 32 is given equally to each message. The scheduling policy was the same for the entire system. Perform only long-term scheduling,
In short-term scheduling, thread priorities were made uniform.

The processing capacity was measured by a Sustainable Data Rate (SDR), which is the upper limit frequency of message (data) input. The SDR is a transmission frequency of a message or data, and is a maximum value at which a predetermined observation latency is stable and does not increase over time. That S
FIG. 12 shows an example of the DR measurement result. Figure 12 is a graph showing changes in latency when the deadline priority at node number 4, (a) a data rate of 1 / 4.3 [sec]
FIG. 7B is a diagram showing a change in latency at the time of (1), and (b) is a diagram showing a change of latency at a data rate of 1/4 [sec]. From FIG. 12, it can be observed that the SDR when the number of nodes is 4 is 4.3.

FIG. 13 shows the result of observing the response of the system by changing the number of nodes. In FIG. 13, (a) is a deadline satisfaction rate in SDR for each scheduling policy,
(B) is the SDR at each observation in (a). As shown in the figure, at the processing limit (SDR), disturbance of internal processing due to the network communication load is recognized, but the response capability of the entire system increases almost linearly with the number of nodes. FIG. 14 shows the SDR increase ratio with respect to the number of nodes when the message evaluation granularity is changed. FIG. 13 (a)
Was based on SDR. Meanwhile, regarding the scheduling policy of the data time priority, a diagram of the deadline satisfaction rate when the data rate was changed around SDR is shown in FIG. 15 as a diagram showing the responsiveness of the system. Show. In the distributed processing, if the control is performed asynchronously and homogeneously as in this experiment, the ideal number of units and the responsiveness can be obtained. Therefore, it can be said that the global parallel computing method according to the present embodiment also has basic performance utilizing characteristics of distributed processing.

As described above, according to the global computing method of the present embodiment, a wide area network can be regarded as one integrated computing environment, and global parallel computing can be performed on it. Further, according to this method, a message passing function can be provided by adapting to differences in execution environments such as a programming language and a network. Further, it is possible to provide a flexible distributed parallel programming function that does not require an interface definition or the like. Also, since calculation objects are managed by global reference,
Thereby, efficient space management and message transmission between objects can be realized.

In particular, according to the global calculation method of the present embodiment, global calculation scheduling can be performed in a network environment. Specifically, calculation scheduling is performed by long-term scheduling in which a message to be evaluated is selected according to its time attribute and priority, and short-term scheduling in which the selected evaluation is processed in parallel. In this process, in the long-term scheduling, load balancing is performed to improve responsiveness of the entire system, and in the short-term scheduling, load sharing is performed to satisfy real-time performance. ing. By realizing local control over a wide area, real-time processing in a distributed system that secures global real-time performance is realized.

Further, the long-term scheduler functions as a task generator, and the short-term scheduler functions as a task executor. These effective task processes enable effective use of computational execution resources. In addition, the long-term scheduling can be positioned as an OS-independent middleware function for real-time control, and the short-term scheduling can be positioned as an OS function interface for executing calculations. Can be provided.

[0081]

As described above, according to the present invention,
A distributed processing method capable of appropriately performing real-time processing on a wide-area distributed system can be provided. Further, it is possible to provide a network system capable of appropriately performing real-time processing by global parallel calculation. Further, it is possible to provide a node device which is suitable for being applied to a node of such a wide area distributed system and which can appropriately perform real-time processing on the distributed system in a coordinated manner.

[Brief description of the drawings]

FIG. 1 is a conceptual configuration diagram of global calculation according to an embodiment of the present invention.

FIGS. 2A and 2B are diagrams illustrating a concurrent object; FIG. 2A is a diagram illustrating a relationship between a concurrent object and a process; FIG. 2B is a diagram illustrating an internal state configuration of the concurrent object;

FIG. 3 is a diagram illustrating a message passing mechanism for realizing the global calculation illustrated in FIG. 1;

FIG. 4 is a diagram illustrating an example of a remote reference table and a local reference table that manage global references, and is a diagram illustrating a scheme of object reference at the time of transmitting a message;

FIG. 5 is a diagram showing a configuration of a reference solution method and a function;

FIG. 6 is a diagram illustrating details of a message transmission function.

FIG. 7 is a diagram illustrating details of a message receiving function;

FIG. 8 is a diagram illustrating a functional configuration of a message evaluation scheduling method.

FIG. 9 is a diagram illustrating a part of a message receiving function in a message passing mechanism and a configuration of a scheduler;

FIG. 10 is a diagram for explaining a structure of a function queue in the scheduler shown in FIG. 9;

FIGS. 11A and 11B are diagrams for explaining a load distribution method; FIG. 11A is a diagram showing a spread type load distribution method; FIG. 11B is a diagram showing a task filling type load distribution method; is there.

12A and 12B are diagrams showing SDR measurement results, FIG. 12A is a diagram showing a change in latency when the data rate is 1 / 4.3 [sec], and FIG. FIG. 9 is a diagram showing a change in latency when the rate is 1/4 [sec].

FIG. 13 is a diagram showing a result of observing the responsiveness of the system while changing the number of nodes in the global computing system according to the present embodiment, and FIG. 13 (a) shows a deadline in SDR for each scheduling policy; FIG. 6 is a diagram showing a filling rate,
(B) is the SDR at each observation in (a).

FIG. 14 is a diagram illustrating an SDR increase ratio with respect to the number of nodes when the message evaluation granularity is changed.

FIG. 15 is a diagram of a deadline satisfaction rate when a data rate is changed with a focus on SDR for a scheduling policy giving priority to data time.

[Explanation of symbols]

300: Process, 310: Message communication unit, 311 ...
Message dispatcher 320, reference resolution function, 3
21: Reference table, 330: Application programming function, 331: Pre-invoked, 332: Post-invoked, 333: Function invoked, 4
00: scheduler, 411: registration function, 4
12: Delete function, 413: Schedule function, 414: Queue, 415: Select function, 420: Short-term scheduler, 421: Register function, 422: Delete function, 423: Schedule function, 424: Pool, 425: Manipulate function priorities ( MF
P)

──────────────────────────────────────────────────続 き Continuation of the front page (56) References JP-A-7-219787 (JP, A) Hirotoshi Maekawa, 2 others, Global Computing Architecture-Comprehensive realization of parallel computing and multimedia processing in a global environment, Information Processing Society Transactions, Japan, February 15, 1998, Vol. 39 No. 2, 267-282 Yuichi Kobayakawa, et al., Network scalable distributed object space management method, IPSJ research report, Japan, January 31, 1997, Vol. 97 No. 13 (97-DPS-80, 97-GW-21), 211-216 Hirotoshi Maekawa, and two others, global parallel computation and its message evaluation scheduling, Information Processing Society of Japan Research Report, Japan, 1998 March 26, Vol. 98 No. 15 (98-OS-77, 98-DPS-87), 97-102 (58) Fields studied (Int. Cl. ⁷ , DB name) G06F 15/16-15/177 G06F 9/46

Claims (27)

(57) [Claims] In a network system in which a plurality of processes having objects related to real-time processing are arranged on a plurality of nodes based on appropriately updated first information related to a network system, a method of performing pre-you-time processing by a plurality of tasks in, in each process, for the input task based on the information indicating the priority attributes message relating to the input task has, Detecting a first priority based on a first scheduling policy; registering and holding the input task in a task holding unit according to the detected first priority; Selecting the first higher priority task from the registered and retained tasks; Detecting, based on the first priority, a second priority based on a second scheduling policy, using the selected task as an execution thread for the detected second priority. Registering and holding the thread in the thread holding means according to the order; selecting the second highest-priority execution thread from among the execution threads registered and held in the thread holding means; Distributed processing method to execute. 2. Every time a new task is registered and held as an execution thread in the thread holding unit, the second priority of the execution thread registered and held in the thread holding unit is updated, 2. The distributed processing according to claim 1, wherein the updated second higher-priority execution thread is selected from among the execution threads registered and held in the thread holding unit, and the selected execution thread is executed. 3. Method. 3. The first priority is a conversion priority calculated based on the first scheduling policy based on information indicating a predetermined priority attribute of a message relating to the task, 3. The thread priority according to claim 1, wherein the second priority is a thread priority calculated for the selected task based on the second scheduling policy based on the conversion priority. Distributed processing method. 4. The plurality of objects are parallel objects including distributed objects, distributed functions, and shared variables that can be remotely called between nodes in the network system. Based, including calling distributed object methods, calling distributed functions, and performing access to shared variables,
Wherein an execution of a predetermined processing in parallel object distributed processing method according to claim 3 for pre you time processing through linkage of the message. 5. The message includes information on scheduling policy, information on data time, information on message transmission time, information on allowable time for evaluation, information on periodicity of message generation, and information on strictness of real-timeness. And, any one of the information of the degree of tolerance of the inaccuracy of the calculation, or information of a time attribute including a plurality or all, and information indicating a priority attribute, and, with reference to the information, 5. The distributed processing method according to claim 4, wherein the conversion priority of the task based on a message is obtained. 6. The deployed process and the object based on at least an appropriately updated first information relating to the network system and a second information relating to the node at which the process is disposed. as <br/> securable real-time of the time processing, distributed processing method according to claim 1 which is copied or relocated to another of said nodes. 7. The first information includes information on a configuration of the network system, information on the arrangement of the processes in the network system, information on duplication and relocation of the processes and the objects, and
7. The distributed processing according to claim 1, wherein the information includes at least one of the information of the management location of the first information and the information of the location of the first information. Method. 8. The task registered and held in the task holding means, wherein the selected task is based on the same object as the task already registered and held in the thread holding means. The distributed processing method according to any one of claims 1 to 7, wherein in a case where the task is registered, the task waits for registration of the task in the thread holding unit. 9. The process and the object are exchanged between the nodes based on first information appropriately updated regarding the network system and second information regarding the node where the process is arranged. 7. The distributed processing method according to claim 6, wherein the data is copied or relocated to another node so that a load is balanced. 10. A plurality of processes having objects related to real-time processing are arranged on a plurality of nodes based on appropriately updated first information related to a network system. A network system for performing the real-time processing, wherein each of the processes is based on information indicating a priority attribute of a message related to the input task, based on information indicating a priority attribute. Task registration means for detecting a first priority based on the first task and registering the input task in a task holding means; and a task for holding the registered task in accordance with the detected first priority. Holding means; and a task having a high first priority among tasks registered and held in the task holding means. Task selecting means for selecting a new task, detecting a second priority based on a second scheduling policy for the selected task based on the first priority, and holding a thread as an execution thread A thread registration unit for registering the execution thread, a thread holding unit for holding the registered execution thread according to the detected second priority, and an execution thread registered and held by the thread holding unit. A network system comprising: a thread selecting unit that selects the second higher-priority execution thread; and a thread execution unit that executes the selected execution thread. 11. Every time a new task is registered as an execution thread in said thread holding means by said thread registration means, said second priority of said execution thread held in said thread holding means is updated. The thread executing means further comprises priority updating means, wherein the thread selecting means selects the updated second higher-priority executing thread from among the executing threads held in the thread holding means, 11. The network system according to claim 10, wherein said network executes said selected execution thread. 12. The first priority is a conversion priority calculated based on the first scheduling policy based on information indicating a predetermined priority attribute of a message related to the task, The network system according to claim 10, wherein the second priority is a thread priority calculated for the selected task based on the second scheduling policy based on the conversion priority. . 13. The plurality of objects are concurrent objects including distributed objects, distributed functions, and shared variables that can be remotely called between nodes in the network system. Based, including calling distributed object methods, calling distributed functions, and performing access to shared variables,
Wherein an execution of a predetermined process in concurrent object, network system according to claim 12 for pre-you time processing through linkage of the message. 14. The message includes information indicating the information of the scheduling policy of the data time information, information of the message transmission time, the time allowed for information evaluation, information related to the periodicity of message generation, the real time of stringency And, any one of the information of the degree of tolerance of the inaccuracy of the calculation, or information of a time attribute including a plurality or all, and information indicating a priority attribute, and, with reference to the information, 14. The network system according to claim 13, wherein the conversion priority of the task based on a message is obtained. 15. The arranged process and object are at least updated based on first information appropriately updated regarding the network system and second information concerning the node where the process is arranged. Record
15. The network system according to claim 10, wherein the network system is copied or relocated to another node so that real- time processing of real- time processing can be ensured. 16. The first information includes information on a configuration of the network system, information on the arrangement of the processes in the network system, information on duplication and relocation of the processes and the objects, and information on the first The network system according to any one of claims 10 to 15, wherein the information includes one, a plurality, or all of the information on the management location of the information and the information on the location of the first information. 17. If the task selected by the task holding means is based on the same object as a task already registered in the thread holding means, the task is registered in the thread holding means. 10. A thread waiting means for waiting for a thread.
7. The network system according to any one of 6. 18. The process and the object are exchanged between the nodes based on the first information appropriately updated regarding the network system and the second information regarding the node where the process is arranged. The network system according to claim 15, wherein the network system is copied or relocated to another node so that a load is balanced. 19. plurality of nodes are connected to the connection network system is arranged process comprising an object according to the performed Ru real-time processing in the network system, node to perform tasks relating to the processing in the object An apparatus, wherein each of the processes, for an input task, based on information indicating a predetermined priority attribute included in a message related to the task,
A task registration unit for detecting a first priority based on a first scheduling policy and registering the task in a task holding unit; and holding the registered task in accordance with the detected first priority. Task holding means for performing the task, task selecting means for selecting the task having the first higher priority among the tasks registered and held in the task holding means, and the first task for the selected task. Thread registration means for detecting a second priority based on a second scheduling policy on the basis of the priority of the second thread, and registering the second priority in the thread holding means as an execution thread; A thread holding unit that holds the threads according to the priority order of the second thread; and the second thread among the execution threads registered and held in the thread holding unit. Node device has a thread selection means for selecting a high previous ranking execution thread, and a thread execution means for executing the selected execution thread. 20. Each time a new task is registered as an execution thread in the thread holding means by the thread registration means, the second priority of the execution thread held in the thread holding means is updated. The thread executing means further comprises priority updating means, wherein the thread selecting means selects the updated second higher-priority executing thread from among the executing threads held in the thread holding means, 20. The node device according to claim 19, wherein the node device executes the selected execution thread. 21. The first priority is a conversion priority calculated based on the first scheduling policy based on information indicating a predetermined priority attribute of a message related to the task, 21. The thread priority according to claim 19, wherein the second priority is a thread priority calculated for the selected task based on the second scheduling policy based on the conversion priority. Node device. 22. The plurality of objects are concurrent objects including distributed objects, distributed functions, and shared variables that can be remotely called between nodes in the network system. Based, including calling distributed object methods, calling distributed functions, and performing access to shared variables,
The parallel is an execution of a predetermined process in an object, the node device according to claim 19 to 21 for performing a pre-you time processing through linkage of the message. 23. The message includes information on scheduling policy, information on data time, information on message transmission time, information on allowable time for evaluation, information on periodicity of message generation, and information on strictness of real-timeness. And, any one of the information of the degree of tolerance of the inaccuracy of the calculation, or information of a time attribute including a plurality or all, and information indicating a priority attribute, and, with reference to the information, 23. The node device according to claim 22, wherein the conversion priority of the task based on a message is obtained. 24. The arranged processes and objects are at least updated based on first information that is appropriately updated concerning the network system and second information concerning the nodes where the processes are arranged. Record
The node device according to any one of claims 19 to 23, wherein the node device is copied or rearranged to another node so that real- time processing of real- time processing can be ensured. 25. The first information includes information on the configuration of the network system, information on the arrangement of the processes in the network system, information on duplication and relocation of the processes and the objects, and information on the first The node device according to any one of claims 19 to 24, wherein the node device is information including one, a plurality, or all of the information on the management location of the first information and the information on the location of the first information. 26. If the task selected by the task holding means is based on the same object as a task already registered in the thread holding means, the task is registered in the thread holding means. 19-2, further comprising a thread waiting means for waiting for a thread.
5. The node device according to any one of 5. 27. The process and the object are exchanged between the nodes on the basis of appropriately updated first information on the network system and second information on the node where the process is arranged. The node device according to claim 24, wherein the node device is copied or relocated to another node so that a load is balanced.