JPH11175359A - Event monitoring part integration method between different kinds of platforms - Google Patents

Abstract

PROBLEM TO BE SOLVED: To eliminate the delay of event detection, to reduce the work amount of protocol definition, to eliminate the delay by the streaming of data and to integrate platforms not corresponding to MT. SOLUTION: In threads 1 and 2 managed by an operating system, the platforms PFA and PFB and an application AP are respectively prepared. The event processing part of the thread 2 stores the data in a queue and sends activation signals to the event monitoring part of the thread through a pipe. The event processing of the thread 1 is executed.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to each event executed on a first and a second platform having an application program interface (API) capable of linking a file descriptor (FD) with an event processing function. A method for integrating a monitoring unit.

[0002]

2. Description of the Related Art In other programs and programs (communication programs) that communicate with other devices, "when there is no event, wait without using the CPU, and when an event comes in, an event corresponding to the event occurs. In the processing section, the processing of an event is immediately started, and when the processing of the event is completed, the process is again waited for. " Wait until an event enters, and when an event enters, call the corresponding event processing unit, and when the processing ends, call the event monitoring unit a place that implements the function to wait again.

A communication program can be efficiently created by using a function (communication platform) provided as a library with functions such as a protocol processing function and an event monitoring function. Communication platforms are often offered as products. Information inside the product platform is often not disclosed, and it is impossible to change the internal functions.

On platforms that do not incorporate the concept of threads, the event monitor monitors the select () system call (or po) for monitoring multiple IDs of UNIX or similar operating systems (OS).
ll () system call). The event is transmitted by input / output to / from a file descriptor (FD), and event monitoring is performed by monitoring a plurality of FDs in select (). When an event comes in, the corresponding event processing unit is called. When the processing of the event processing unit is completed, the control returns to the event monitoring unit again, and the process waits for an event. Such a platform is called a select platform. Library functions on this type of platform are often not MT safe (the number of times they may be called in parallel). Conversely, platforms that are not MT-safe are mostly select-type platforms.

[0005] Some platforms that incorporate the concept of threads have an event monitoring mechanism in which an event monitoring unit operates simultaneously on a plurality of threads or an event processing unit is performed by another thread. Such a platform is called a thread type platform. Library functions for this type of platform are generally MT-safe.

In recent years, with the diversification of protocols, a protocol converter has been required. Since the implementation of the protocol function involves a lot of work, it is desired to efficiently create a protocol converter by combining a plurality of existing communication platforms.

In order to communicate between the application AP _A having a function of communicating with the protocol _A and the application AP _B having a function of communicating with the protocol B,
A protocol converter having the functions of protocol A and protocol B is required. FIG. 11 shows a mechanism for performing the protocol conversion. When the application AP _A issues a request R ₁ to the protocol converter with the protocol A,
The protocol converter converts a protocol A to the protocol B, delivers the request R ₂ towards the application AP _B. Application AP _A performs processing for request received, and returns to the protocol converter processing result as a response R _3. The protocol converter makes a response R ₄ from the result of the response R _3, through the protocol B, and returns to the application AP _B.

[0008] Since with a lot of work to implement the protocol stack, to create a protocol converter by combining existing communication platform PF _B to support existing communications platform PF _A and protocol B that supports the protocol A Is efficient.

Up to now, there are three methods of integrating the event monitoring units.

There are the following three methods (methods 1, 2, 3) for integrating a non-MT safe select type platform and a non-MT safe select type platform.

The following method 2 can be used as a method for integrating a select type platform which is not MT safe and a thread type platform.

[0012] Consider the case of integrating (method 1 Integration the select ()) platform PF _A and platform PF _B. Each platform has its own sele
Contains the part that calls the ct () system call.
_A set of file descriptors that monitor the platform PF _A is F _A, and a set of file descriptors that monitor the platform PF _B is F _B. F _C = F
Introducing a select () system call to monitor the _A UF _B, and an event monitoring unit The select ().

The method used in the method 1 can be further classified into the following three methods.

[0014] (1-1) Platform PF _A also monitors FD relating to event processing of the platform PF _B in select () method platform PF _A to integrate the event monitoring unit.

[0015] (1-2) platform PF FD which in select () method platform PF _B to integrate the event monitoring unit related to the event processing section of the platform PF _A and _B also monitors.

(1-3) Integration with a new event monitoring unit
A new function is prepared and the platform PF_A When
Platform PF _B Monitor both FDs
Call ().

(Method 2 Introduction of Local Protocol) Platforms PF _A and PF _B are executed on process A and process B, respectively. Event processing part of platform PF _A and platform PF
When the user defines a local protocol with the event processing unit of the _B, taking the cooperation with the platform PF _A and platform PF _B method.

Both the platform PF _A and the platform PF _B require an FD and an API for the event monitoring unit to add a callback function corresponding to the FD. Without this API, method 2 cannot be used.

(Method 3 A method for calling a function for checking the presence / absence of an event every time select () on one side times out)
API to check whether an event has entered one platform (PF1) without blocking
(Check ()), and executes one event processing function that can be processed (API (function for executing an event)
do event (). ) Is prepared. Select on the other platform (PF ₂ )
It is assumed that there is an API that can set a timeout in () and set a callback function.

When a timeout occurs in select () of the platform PF ₂ , a callback function set by the user is called. Among them, check of PF1
() Call to examine whether the come event in PF1, do the API of PF ₁ for executing processing function corresponding to the event if Re is coming events event ()
Call. Then, exit the callback function and again
In F ₂ enters the event waiting by the select ().

As described above, mainly the platform PF
_This is a method of monitoring the event _{No. 2} and monitoring the event of the PF ₁ every time a timeout occurs.

[0022]

The above three conventional methods have the following problems.

Platforms that do not support MT
In the case of a cow connection First, a conventional configuration in which two types of protocols are separately provided
Will be described. FIG. 12 is used for this description. Platform
PF_A And PF_B Is a different protocol. Both plastics
The platform is not connected. Each platform
Mu PF_A , PF _B The application part (A
P) And each platform PF_A , PF_B To
Has a communication processing unit and an event monitoring unit, which are connected
You. In addition, the application part AP includes a plurality of events.
Event processing unit, which is connected to the previous event monitoring unit.
You.

[0024] (need for method 1 API, or disclosure of the program code) case (1-1), API platform PF _B returns a set of FD to be monitored, when there is an event to the platform PF _B, the event corresponding API to perform event processing section of the containing the FD information based platform PF _B a is required. The platform PF _B is an event monitoring unit, and the FD
If you want to monitor other information, API to check the information
And an API for calling the corresponding event processing unit.

FIG. 13 shows a configuration diagram of the method 1-1. In one process, the platform P from the event monitoring unit platform PF _A in FIG. 13 to FIG. 12
Line connecting the communication process F _B indicates that the event monitor platform PF _A is monitoring the communication processor platform PF _B. Further, the platform P from the event monitoring unit platform PF _A in FIG. 13
Line connecting the event processing unit of the F _B the platform P
If necessary event monitoring unit of F _A, select the event processing unit of the platform PF _B, indicating that the run.

In the case of (1-2), the platform PF
_An API for returning a set of FDs to be monitored by _A , and an API for executing an event processing unit corresponding to PA _A on the platform based on information of the FD including the event when an event is present on the platform PFA is required. . Also,
The platform PF _A event monitoring unit, to monitor the information other than the FD, the API to call the event processing section and a corresponding API to examine the information needed.

FIG. 14 shows a configuration diagram of the method 1-2. FIG.
The platform is reversed from the case described in 3, and the event monitoring unit of the platform PF _{A is provided to} the event monitoring unit of the platform PF _B by the platform PF
The communication processing unit of the _B is the communication center of the platform PF _A, event processing platform PF _B is in event processing platform PF _A.

In the case of (1-3), the platform PF
_A, PF _B together, AP that returns a set of to be monitored FD
I, when there is an event in platform PF _A , platform PF
API to perform the corresponding event processing unit of the _A, it is necessary corresponding API to perform event processing section of the platform PF _B platform PF _B based on the information of the FD containing the event when there is an event.

FIG. 15 shows a configuration diagram of the method 1-3. In this case, the event monitoring unit sets each platform PF _A , P
It not in the F _B, has its own event monitoring unit made as AP. This event monitoring unit is
F _A, and monitors and controls the communication processing unit of the PF _B, and each platform PF _A, suitably through a respective platform PF event processing unit of the PF _B, selecting and executing.

The platform PF _A is the event monitoring unit, to monitor the information other than the FD, calls the event processing section and a corresponding API to examine the information A
PI is required.

The platform PF _B is the event monitoring unit, to monitor the information other than the FD, calls the event processing section and a corresponding API to examine the information A
PI is required.

If there is no API described above, the source code must be disclosed in order to integrate in this manner.

[0033] (exchange scheme 2 data, mediation creation protocol) is necessary to define scheme 2, the platform PF _A and platform PF local protocol which mediates _B (user independently selected protocol) at the user level. This requires a lot of work. A delay occurs because data to be handled is converted into stream-type data and transmitted and received between processes.

In the conventional method, as shown in FIGS. 13 to 15, in one process, the platform P
F _A, was to connect the PF _B. Method 2 is shown in FIG.
As shown in Fig. 6, each platform PF
_A, PF _B has a separate process. When the process of the platform PF _A performs the processing in the event processing unit of the platform PF _B , the process is executed via the communication processing unit of the two processes on the local protocol as shown in FIG.

(Method 3 Delay in select (poll) System Call) When the timeout time is set to a finite time, it is apparent that a delay occurs in the detection of the non-main event.

With reference to FIG. 17, a description will be given of the occurrence of a delay in the method 3 of the prior art. The horizontal axis to the right indicates the time axis, and the lower side indicates the main event monitoring state and the upper side indicates the secondary event monitoring state. Select () is executed on the lower side, and it moves to upper side check () by timeout. Here, even if an event occurs during the execution of select (), that is, before the timeout,
Move to (), event is detected, do There will be a delay until it is executed in event ().

In order to eliminate the delay in the method 3, sele
If the timeout time of ct () is set to 0, the CPU is occupied.

Referring to FIG. 18, the CPU according to the prior art method 3 is used.
Occupancy will be described. As in FIG. 17, the status of each event monitoring is shown on the time axis. The difference from FIG. 17 is that the timeout period of select () of the main event monitoring is extremely shortened. In this case, check immediately after the event occurs
() And do The delay before execution by event () becomes shorter. But secondary event monitoring, ie chec
k () is performed frequently, resulting in the CPU being occupied with check ().

Platform P not supporting MT
When F _A is Connected to Platform PF _B Corresponding to MT Generally, a function that cannot be MT cannot be called from a thread other than the main thread (the thread created first). Platform communication processor and event handling PF _A is often multithreading is (single-process multiple programming paradigms that can have execution. Process can be performed multiple jobs in parallel) are not allowed. Based on this, in the case of a platform that creates a thread each time an event enters and executes the event on it, and a platform of the event monitoring unit that waits for events in multiple threads, the platform PF _B The event processing function is executed by a thread other than the main thread. for that reason,
From the event processing functions of platform PF _B ,
It can not be called an event handling function and a communication processor platform PF _A. Therefore, the methods (method 1), (method 2), and (method 3) cannot be used. Although it can be used in the case of (method 2), the same problem as described above occurs.

It is an object of the present invention to provide an event-cross-platform event that has no delay in event detection, a small amount of work for protocol definition, no data delay due to data streaming, and integration of non-MT compatible platforms. An object of the present invention is to provide a monitoring unit integration method.

[0041]

According to the present invention, there is provided a method for integrating an event monitor between heterogeneous platforms, comprising first and second platforms having an application program interface capable of linking a file descriptor with an event processing function. A method of integrating each event monitor to be executed, by creating threads managed by the operating system, executing different event monitors on the platform on each thread, and selecting and waiting. Write () through the pipe or socket to the existing event monitor
By writing in the system call, the event generation from the event monitoring unit on the first platform
To the event monitoring unit on the platform, and a structure composed of a pointer of a function to be called, an argument of the function to be called, and a semaphore structure is connected to the queue, and is passed between threads.

In the present invention, the threads on which the OS on the two platforms performs scheduling are created, and two event monitoring units are executed on each thread.

Also, by sending a write to the FD monitored by select () through a pipe or a socket, a function (corresponding to F2 in the embodiment) can be started from the first event monitoring unit.

A structure is introduced in which a structure including a pointer of a function to be called, an argument, and a semaphore structure is connected to a queue and transferred between threads. Since the part that operates the queue is operated exclusively using the mutex, it is possible to access the queue from multiple threads. As a result, an event monitoring unit that creates a thread for each FD to be monitored, a platform PF _B
Wakes up a new thread each time an event enters, and executes an event monitoring unit that executes a function (corresponding to F4 in the embodiment) on that thread.

[0045]

Next, embodiments of the present invention will be described with reference to the drawings.

FIG. 3 is a diagram showing the first embodiment viewed from a thread point of view. The horizontal axis shows the flow of time to the right. The T1 platform PF _B, T2 indicates the thread platform PF _A. A narrow function indicates a waiting state, and a thick function indicates execution. F1,
F2, F3,..., F6 indicate functions.

F1 and F4 are different functions according to the type of event, and are defined by the user. On the other hand, F2 and F3 are functions that include write () and read () processing and queue operations by the pipe of the present invention, and are common regardless of the type of event.

The event monitoring units of the two platforms PF _A and PF _B were allocated to the OS, and each event monitoring unit was operated by each thread. These event monitoring units are executed simultaneously.

The platform PF _A in the F6,
Waiting for event at F5 on platform PF _B. When platform event from the communication processing unit of the PF _B comes in at F5, the event processing unit F4 corresponding to the event is activated.

In the event processing, the platform P
F _A function (communication processing section and the platform PF _A, MT Call library functions) portion used for the function F1
Write down.

In F4, F3 is called using the pointer of F1 and the argument for calling F1 as arguments.

Inside F3, first, a semaphore is created.
Lock the semaphore. That is, the number of semaphore counters
Set to 0 and another sled tries to access the semaphore
Then block. Semaphore, F1 pointer and F
Queue structure with argument information when calling 1
Connect to Then, for a pipe or socket, wr
Write using the ite () system call. afterwards,
Wait without consuming CPU until the semaphore is released,
In other words, the function sema that does not hinder the execution of other processes wait
Call (). Here, F3 is temporarily stopped.

[0053] Since the write to the platform PF _A event monitoring unit F6 pipe or socket running on is made, the event processing section F2 corresponding to the FD of the pipe is called.

In F2, one structure is removed from the queue and data is read. Since the pointer of F1 and the argument for reading F1 are obtained, F1 is called using this.

[0055] In F1 performs processing, which is written in F1 (function the use processing of the platform PF _A).

When F1 ends, execution returns to F2. F
In 2, release the semaphore written in the structure (semaphore Call post (). ). F2 is over,
Execution returns to the event monitoring unit F6.

At time t2, since the semaphore has been released, the temporarily stopped F3 starts to move again. F3 returns execution of F4.

Although the exchange of the event monitoring unit has been described with the passage of time, this will be described with reference to the operation flow of each platform.

[0059] FIG. 1 of the platform PF _A (selec
The operation flow on the t) side is shown in FIG.
FIG. 1B shows the operation flow of FIG. The operation flow of 1) is shown.

The main (loop) shown in FIG. 1) First,
Is there a vent? Is always determined by the select () function.
You. If there is an event, proceed to the next event,
Event 1_Two, ..., Event 1_n-1 Whether or not
to decide. If these judgments are all different, the event
1_nHit. When you distinguish which event, the event
Sub operation flow corresponding to 1₁, Sub 1_Two, Sub
1_n-1, Sub 1_n Processing is thrown. FIG. 1 (b) shows the sub
sub 1_xIt is an example of the operation flow of (x = 1-n). This sub
When the operation flow process is completed, it is again determined whether or not there is an event.
It is returned to the initial state to judge.

In the sub-operation flow shown in FIG.
call ad (), and one function and parameter pair (func, param1, param2, ..., para)
mn) and executes the extracted function func. The part that operates the queue operates exclusively using a mutex (mutual exclusion lock, a mutual exclusion lock (a synchronization variable used to protect the code part)). Finally, the semaphore that increments the semaphore variable Execute post () and sub Exit 2 Also, sema post () sema at the end of execution wait () also exits. At this time, the sub on the platform PF _B Sema in 2 wait
Also notify (). After finishing the above, loop Return to the first state of 1.

The other platform PF_B (sushi
FIG. 2 shows an operation flow on the memory card side. Figure in this Figure 2
2 (a) is the main (loop It is the operation flow of 2).
(B) is a sub This is the operation flow of 2). FIG. 2 (a)
Has the same operation flow as that of FIG.
Always check the liveness and what events have occurred
You. Then, according to the event that has occurred, the service shown in FIG.
Sub Move to the operation flow of 2). In FIG.
Connect the argument from the issuing function to the queue. Loop Monitor 1
Write () to the file descriptor (fd)
You. Figure 1 (b) above post () With the end of execution
To sema When exiting wait (), sema in Figure 2 (b) w
When ait () is performed, it is processed sequentially. Loop in this 1
When write () is performed on fd that is monitoring 1 size
Are there any interruptions / events? > Becomes “Yes”. like this
Figure 1 (b) sub When the processing of step 2 is completed, FIG.
Loop Return to the first state of 2.

The structure of the first embodiment shown in FIG.
The different platforms shown here are separate configurations with queues and pipes. Platform PF
_A, PF _B thread 1, which corresponds to thread 2.
With this configuration, the operation described with reference to FIGS. 1 and 2 is performed. First, the event processing unit of thread 2 stores the data in the queue, and then sends an activation signal to the event monitoring unit of thread 1 via a pipe. Then, the event processing unit of the thread 1 is executed.

The method of integrating the event monitoring units of the two platforms according to the present invention has been described above. Therefore, how the conventional example differs from the present invention will be described with reference to Table 1.

[0065]

[Table 1] Table 1 shows that (1) event detection delay, (2) workload to twist on protocol definition, (3) data streaming delay, (4) the need to maintain coding or API,
(5) The point is MT correspondence.

The first point is a delay in event detection. In the method 3, as described above, it takes time to detect an event of a platform that has arrived at a platform other than the main event monitoring unit.

The second point is the amount of work for defining the protocol. In the method 2, a new protocol must be defined. In the present invention, the amount of work is relatively small because it is not a protocol definition but a program call.

The third point is a delay in data due to data streaming. In the present invention, since the platform PF _A and the platform PF _B operate in the same process, they share the same memory space, so that the speed is high.

As described above, the fourth point of the present invention can be realized if the select type platform has an API that can set an FD and a callback function corresponding to the FD, as described above. Other methods require other APIs, or require disclosure and modification of source code.

The fifth point is for MT. As described above, the present system can integrate an MT-compatible platform and a non-MT-compatible platform.

[0071] Platform PF _A creates a new thread the event enters, so as to perform the event processing unit thereon, are connected in the same manner also in the first embodiment if it has an event monitoring unit.

FIG. 4 is a view of the second embodiment from the viewpoint of threads, and the nest is the same as that of FIG. Figure 4 Platform PF _B multithreaded state, that is, shows a case where there is T1, T3. An event occurs at T1, and T1 is waiting at F5. Then, T3 is created, and F4 and F3 are executed thereon. Thereafter, the process is the same as in FIG. Finally, when F4 ends, T3 is erased.

[0073] In this case, it is that the difference from the first embodiment is able to accept events platform PF _A simultaneously. FIG. 5 shows this.

[0074] When time t1 platform PF event enters _B, new thread (T3) is made, F4 are callback on that thread. F4 is F1
Is passed to F3. 1 inside the pipe inside F3
FG2 in more of the platform PF _A is called back by writing a byte of dummy data in the write (). F1 is called from the information connected to the queue. Now, T1 creates a new thread (T3),
Start waiting for the next event. When a new event arrives at time t2, a new thread (T4) is created, and a callback function F4 'is called on that thread. F4 passes the pointer argument of F1 'to F3. Here, at time t3, the two structures are connected to the queue. When F3 of T3 performs write (), F2 is called back. 1-byte data is read from the monitoring FD by read (). Take structure from queue, F1
Get F1 and call F1. F1 is over,
When F2 ends, T2 temporarily returns to the event monitoring unit. At this time, since one byte of data remains in the FD, select () is exited and F2 is called back again. Thereafter, F1 'is similarly called.

As described above, even if the next event comes before the processing of one event ends, the method used in the first embodiment can be used.

FIG. 8 shows a configuration diagram of the second embodiment. Figure 7 differs from the configuration of the first embodiment processor event platform PF _B is run on a separate thread for each event. The operation of the event processing there is the same as in the case of FIG.

FIG. 6 is a diagram showing the third embodiment viewed from a thread point of view. Here, T1 and T3 indicate that different FD arguments are being executed. Platform PF _B is to make a thread for each FD, can be connected in the second embodiment the same way even when moving the event monitoring unit on each thread.

FIG. 9 shows a configuration diagram of the third embodiment. The difference from FIG. 8 is that a thread is assigned for each FD. At this time, the event processing unit is on the event monitoring unit, and the communication processing unit is on one thread. The operation of the event processing there is the same as in the case of FIG.

[0079]

According to the present invention, the protocol converter can be efficiently created by using the existing communication platform by using the event monitoring unit integration method of the present invention. Also, a platform that could not be connected unless the program code was disclosed in the conventional method can be connected by the present method.

Platform PF for more realistic applications
_A 's protocol is Common Management Infomati
on Protocol (CMIP). CMIP is a protocol standardized by ITU-T in the field of communication network operation system (OpS).

The platform PF _B is a Common Platform
Object Request Broker Architecture (CORBA) applies. CORBA has been determined by the Object Management Group (OMG) as a distributed object platform and has been receiving attention. From a management device that understands CORBA with a protocol converter according to the present invention,
It becomes possible to manage a managed device that understands CMIP.

Therefore, communication network control managed by CMIP can be easily performed from CORBA, which is the operation environment of the computer. This is shown in the conceptual diagram of the CORBA / CMIP connection in FIG.
The plurality of PCs shown in the upper part of FIG. 10 are a monitoring control unit that performs communication network control. The operating environment is CORBA corresponding to the platform PF _B described so far. The plurality of transmission apparatus shown in the lower figure, are managed using the CMIP corresponding to the platform PF _A described so far. The WS in the middle is the protocol converter that integrates both platforms.

According to the present invention, in addition to monitoring and controlling a transmission apparatus having a system as shown in FIG. 10, in other words, an existing control and monitoring (OpS) system, using a PC in an existing environment. , It is easy to integrate heterogeneous platforms. In this case, there is an advantage that the delay time generated in the exchange between the platforms is short, and it is not necessary to know the detailed source code of the platform.

[Brief description of the drawings]

FIG. 1 is a flowchart showing an operation of a platform PFA _A.

2 is a flowchart showing the operation of the platform PF _B.

FIG. 3 is a diagram of the first embodiment viewed from a thread point of view.

FIG. 4 is a diagram of the second embodiment viewed from a thread point of view.

FIG. 5 is a diagram showing the second embodiment (when a plurality of events come at the same time) from the viewpoint of a thread.

FIG. 6 is a diagram of the third embodiment viewed from a thread point of view.

FIG. 7 is a configuration diagram of the first embodiment.

FIG. 8 is a configuration diagram of a second embodiment.

FIG. 9 is a configuration diagram of a third embodiment.

FIG. 10 is a conceptual diagram of a CORBA / CMIP connection.

FIG. 11 is a block diagram showing the operation of the protocol converter.

FIG. 12 is a configuration diagram of a conventional example before platform connection.

FIG. 13 is a configuration diagram of a conventional example (method 1-1).

FIG. 14 is a configuration diagram of a conventional example (method 1-2).

FIG. 15 is a configuration diagram of a conventional example (method 1-3).

FIG. 16 is a configuration diagram of a conventional example (method 2).

FIG. 17 is an explanatory diagram of a defect of a conventional example (method 3).

FIG. 18 is an explanatory diagram of a defect of a conventional example (method 3).

Claims (5)

[Claims] 1. A method for integrating event monitoring units running on first and second platforms having an application program interface capable of linking a file descriptor with an event processing function, comprising: an operating system Creates the threads managed by, executes the different event monitoring units on each platform on each thread, and writes to the event monitoring unit waiting by select with the write () system call through a pipe or socket Thus, the occurrence of an event is notified from the event monitoring unit on the first platform to the event monitoring unit on the second platform. The queue The tether is passed between threads, event monitoring unit integration method between heterogeneous platforms. 2. The first platform and the second platform
2. The method of claim 1, wherein both platforms execute a select type event monitor. 3. The event monitoring unit according to claim 1, wherein the first platform executes a select type event monitoring unit, and the second platform executes a thread type event monitoring unit. Integration method. 4. The event monitoring unit integration between different platforms according to claim 1, wherein one event monitoring unit is executed on each of the first platform and the second platform. Method. 5. The system according to claim 1, wherein a plurality of event monitors are executed on the first platform and on the second platform, and the second platform has the same or different event monitor. 3. The method for integrating an event monitoring unit between heterogeneous platforms according to item 1.