JP7603628B2 - Distributed computing control system, method and program - Google Patents

Description

The present invention relates to a distributed computing control system, method, and program that performs distributed processing of target jobs using an unspecified number of devices connected to a network, and in particular to a system, method, and program in which multiple worker devices equipped with a web browser work together with a management server to perform distributed processing of jobs.

As one of the architectures for next-generation wireless infrastructure, MEC (Multi-access Edge Computing), which implements edge computing mechanisms in mobile networks, is attracting attention. MEC enables low-latency, high-bandwidth mobile communications by placing part of the data processing function not in the cloud but as an edge server within the mobile network (for example, in a wireless base station) closer to the user.

However, due to spatial and power constraints of wireless base stations, there is an issue that the capacity of the edge servers that can be placed at each wireless base station is not sufficient for the number of devices that the wireless base station can accommodate. In response to this technical issue, distributed computing systems that distribute the processing of target jobs to the group of devices accommodated by the wireless base station have attracted attention.

Patent Document 1 discloses a technology that provides computing services to users through cloud computing using virtual machines, eliminating the need to install and update computation programs on devices that perform computation.

JP 2014-130591 A

According to Patent Document 1, it becomes unnecessary for a user to install an arithmetic processing program every time he or she requests a computing service, which reduces the time and resources required for updates. However, this method requires an environment in which a virtual machine can be executed on the device that provides the computing service, and a function for managing the virtual machine.

On the other hand, in volunteer computing, where multiple users provide their own devices as devices that perform the calculations of a computing service to realize distributed computing, it is assumed that there will be a large number of heterogeneous devices, such as user terminals such as smartphones and PCs, or IoT (Internet of Things) devices. In order to provide distributed computing services using these devices, the following challenges exist.

First, because unspecified devices are used to provide computing services, it is difficult to uniformly install the virtual machine execution environment and management functions required for the computing services in advance.

Secondly, devices that provide computing services are assumed to be devices owned by other users or IoT devices. In this case, since each device will have a different processor architecture, OS (Operating System), and applications, it will be essential for each device to have the function of executing distributed processing using a common program.

The object of the present invention is to provide a distributed computing control system, method, and program that solves the above technical problems and enables distributed processing of target jobs among devices using a common agent function and distributed processing program, even if the processor architecture, OS, etc. of each device are different.

To achieve the above objective, the present invention is characterized in that a distributed computing control system in which multiple worker devices equipped with a web browser work together with a management server to perform distributed processing of jobs has the following configuration.

(1) Each worker device is provided with a means for accessing a management server with a web browser to obtain an agent function, a means for starting the agent function using the web browser as an execution platform, a means for the agent function to obtain a distributed processing program from the management server, a means for starting the distributed processing program using the web browser as an execution platform, and a means for responding to the management server with the results of distributed processing.

(2) Distributed processing programs are now launched in a sandbox execution environment in a web browser.

(3) The distributed processing program is a program module including program code and interface code that provides an interface to the program code, the program code is launched in a sandbox execution environment, and the interface code provides the program code with an interface to a web browser and agent functions.

(4) The agent function launches the interface code by using the program execution function that is standard in web browsers.

(5) The agent function uses the file acquisition function that is standard in web browsers to obtain distributed processing programs from the management server.

(6) Program code is written using an instruction set that can be executed in the sandbox execution environment.

(7) The agent function is implemented in the web browser of each worker device in the standard language of that web browser.

(8) The agent function now registers its own worker device to the management server after launching in a web browser.

The present invention achieves the following effects:

(1) The agent function runs within the web browser of each worker device, eliminating the need to install the agent function.

(2) Because the agent function runs within the web browser of each worker device, there is no need to prepare an agent function for each processor architecture or OS, even in environments where the processor architecture or OS of each device is different.

(3) Because the program code that performs distributed processing is executed within a web browser, there is no need to prepare program code for each processor architecture or OS, even in environments with different device processor architectures or OSs.

(4) By accessing the management server with a web browser, the agent function is launched within the web browser and the worker device is simultaneously registered with the management server, eliminating the need for user operations such as registering device information with the management server.

(5) Because the program code is executed in a sandbox execution environment within the web browser, it is possible to prevent the program code from affecting the operation of other programs executed within the web browser or the device, or from gaining unauthorized access to memory information of the web browser or other programs executed within the web browser.

(6) Because the program code that executes distributed processing accesses input/output functions via interface code, the implementation of input/output functions in distributed processing can be changed simply by changing the interface code without modifying the program code.

(7) Because the program code that executes distributed processing accesses the input/output functions via the interface code, the interface code can verify the data that is passed to the program code or output from the program code and control the access range.

(8) Since the implementation of input/output functions can be changed by switching the interface code, if there is a sandbox execution environment with a common instruction set even in environments outside of a web browser, the interface code can be changed to use input/output functions outside of a web browser, allowing the program to be executed without changing the program code.

1 is a diagram illustrating a configuration of a network infrastructure to which a distributed computing control mechanism according to an embodiment of the present invention is applied. FIG. 2 is a functional block diagram showing the configuration of a management server and a worker device. FIG. 2 is a functional block diagram of a Web browser in a worker device. FIG. 2 is a functional block diagram of a worker device that performs distributed processing of a plurality of jobs. 1 is a sequence flow (part 1) illustrating a procedure for executing program code on a worker device. 13 is a sequence flow (part 2) illustrating a procedure for executing program code on a worker device. 13 is a sequence flow (part 3) illustrating a procedure for executing program code on a worker device. 13 is a diagram illustrating an example in which a user of a worker device, as a job requester, requests 3D processing related to the playback of 3D video images to a plurality of worker devices. FIG. FIG. 13 is a diagram illustrating an example of distributed processing, by a plurality of worker devices, of a job for machine learning a model for predicting traffic volume and weather based on camera images.

The following describes in detail an embodiment of the present invention with reference to the drawings. Figure 1 is a diagram showing a schematic configuration of a network infrastructure to which the distributed computing control mechanism of the present invention is applied. An edge server 1 accommodates a large number of worker devices 10 via a network, and each worker device 10 works in conjunction with the edge server 1 to perform distributed processing of target jobs.

In this embodiment, we will explain an example in which the server function that manages the distributed processing in each worker device 10 is implemented in the edge server 1 as the management server 20, but the management server 20 may also be configured as a dedicated server independent of the edge server 1.

The management server 20 has a web server function 21 and a management function 22, which will be described in detail later, and holds a program module 30 that executes the target job of distributed processing. The management server 20 distributes the program module 30 to each worker device 10, executes it in a web browser, and obtains the processing results from each worker device 10.

The worker devices 10 are general-purpose devices such as a personal computer (PC) 10a, a smartphone 10b, a wearable terminal 10c, or a robot 10d, and each worker device 10 is equipped with a web browser.

Figure 2 is a functional block diagram showing the configuration of the management server 20 and the worker device 10, and Figure 3 is a block diagram showing the functions of the web browser 11 in the worker device 10. The management server 20 manages multiple worker devices 10, but the following explanation focuses on one of them.

The management server 20 mainly comprises a web server function 21 and a management function 22, and holds a program module 30 for distributed processing. The management function 22 manages the worker devices 10 and their distributed processing. The web server function 21 functions as an access interface for the worker devices 10 to access the management server 20, and distributes the agent function 12 and the program module 30 to each worker device 10.

The agent function 12 is implemented by combining languages such as HTML (Hypertext Markup Language), CSS (Cascading Style Sheets), and JavaScript that have been adopted as web standards so that it can be executed by the execution engine 14 within the web browser 11 of the worker device 10.

The agent function 12 exchanges worker device information by connecting to the management function 22 of the management server 20 in response to a web browser operation. When the management function 22 assigns a job to be processed to the worker device 10, the agent function 12 obtains the program module 30 corresponding to the job from the web server function 21.

The program module 30 is composed of a program code 31 that describes the contents of the distributed processing, and an interface code 32 that describes the input/output processing required for the operation of the program code 31.

As shown in FIG. 3, the program code 31 is launched and executed in the sandbox execution environment 13 within the Web browser 11, and the interface code 32 is launched and executed by the Web browser 11. Therefore, the program code 31 is written in an instruction set that can be executed in the sandbox execution environment 13. The interface code 32 is loaded into the execution engine 14 of the Web browser 11 by the agent function 12.

In this manner, in this embodiment, the program code 31 is executed in the sandbox execution environment 13 within the web browser 11, which prevents the program code 31 from affecting the operation of other programs executed within the web browser 11 or the device 10, or from gaining unauthorized access to memory information of the web browser or other programs executed within the web browser.

The program code 31 uses the input/output functions of the web browser 11 on a function basis via the interface code 32. The start() function is a function for starting a program. The proc1() function executes processes that do not require input/output functions, and the proc2() function executes processes that require input/output functions.

The interface code 32 provides necessary input/output functions to the program code 31 isolated in the sandbox execution environment 13 by creating instances 131 and calling various functions via the API. Examples of input information include camera images and sensor information provided by the worker device 10, and parameters provided by the agent function 12. Examples of output information include the results of calculations performed by the program code 31, log information, etc.

Specific processing for accessing information required by program code 31 is implemented in interface code 32. As an example, processing for accessing sensor information via web browser 11 using JavaScript can be implemented.

The interface code 32 further has the ability to access the instance 131 to cooperate with the program code 31 and to call functions in both directions with the program code 31, such as the main() function and the sensor() function.

The main() function is executed automatically when the agent function 12 calls the interface code 32, and passes the corresponding program code 31 to the sandbox execution environment 13 to create an instance 131. This makes it possible to pass input information to the program code 31 and obtain output information from the program code 31. The sensor() function is called by the proc2() function, and provides the input/output functions of the web browser 11 to the program code 31.

WebAssembly technology or the like can be adopted as such a sandbox execution environment 13. In this embodiment, as shown in FIG. 3, when program code 31 is loaded into the sandbox execution environment 13, a corresponding instance 131 is created, and execution resources 134 such as a memory area 132 and a program counter 133 used by the program code 31 are secured within the instance. This allows the program code 31 to be executed in an environment isolated from the agent function 12 and programs of other web pages opened in the web browser 11.

Each worker device 10 may execute multiple distributed processing jobs. In this case, as shown in FIG. 4, the worker device 10 acquires multiple program modules 30 (30a, 30b) from the Web server function 21 of the management server 20, and executes the respective program codes 31a, 31b and interface codes 32a, 32b simultaneously within the Web browser 11.

Next, the procedure for executing program code 31 on the worker device 10 will be described with reference to the sequence flows in Figures 5A, 5B, and 5C.

First, referring to FIG. 5A, at time t1, a user operates the worker device 10 to start the web browser 11 and connect to the management server 20, and the web browser 11 is started at time t2.

When the Web browser 11 connects to the Web server function 21 of the management server 20 at time t3, the Web server function 21 sends the agent function 12 to the Web browser 11 of the worker device 10 at time t4. The agent function 12 is downloaded to the worker device 10 using the execution engine 14 (file acquisition function) of the Web browser, and is imported into the execution engine 14.

At time t5, the agent function 12 is started on the web browser 11. When the agent function 12 has completed starting, at times t6 and t7, it registers the worker device 10 with the management function 22 via the web server function 21 as one of the worker devices responsible for distributed processing.

In this way, in this embodiment, by accessing the management server 20 with the web browser 11, the agent function 12 is started within the web browser, and at the same time, the worker device 10 is registered with the management server 20, eliminating the need for user operations such as registering device information with the management server 20.

After this, the agent function 12 periodically requests the management function 22 to obtain the target job. In this embodiment, at time t8, the agent function 12 requests the management function 22 to obtain the target job via the server function 21. At time t9, in response to the request, the web server function 21 requests the management function 22 to search for the target job.

At time t10, the management function 22 responds with the search results to the Web server function 21. If the search result is "no jobs to be processed," the Web server function 21 notifies the agent function 12 of this at time t11 and ends this periodic processing. After this, the processing from time t8 onwards is repeated at a predetermined cycle.

At time t12, when the agent function 12 is notified that the search result indicates that "a job to be processed is available," at time t13, the agent function 12 requests the Web server function 21 to send the program module 30 corresponding to the job. At time t14, in response to the request, the Web server function 21 transmits the corresponding program module 30 to the Web browser 11. The program module 30 is downloaded to the worker device 10 and loaded into the Web browser 11.

Moving on to FIG. 5B, at time t15, the agent function 12 extracts the interface code 32 contained in the program module 30 and launches it by calling the web browser 11. At time t16, the interface code 32 requests the sandbox execution environment 13 to launch the program code 31.

At time t17, the sandbox execution environment 13 reads the program code 31 and creates an instance 131. That is, execution resources 134 such as a memory area 132 and a program counter 133 are secured in the sandbox execution environment 13.

At time t18, when the interface code 32 requests the sandbox execution environment 13 to call any startup function (here, the start() function) in the program code 31, the processing in the start() function is executed at time t19. At time t20, in order to enable execution of the program code 31 from the sandbox execution environment 13, a specific external function of the interface code 32 is called to access external input/output functions. Here, as an example of an external function, a flow for calling the sensor() function of the interface code 32 to obtain sensor information of the device is shown.

When the external function sensor() is called in the program code 31 at time t20, the function sensor() in the interface code 32 is called via the API of the sandbox execution environment 13 at time t21. The function sensor() describes information necessary to provide an input/output environment, such as processing for acquiring signals output by various sensors of the worker device 10.

At time t22, the interface code 32 requests sensor information from the Web browser 11. When the Web browser 11 acquires sensor information from the sensor of the worker device 10 at time t23, it responds to the interface code 32 at time t24.

At time t25, the interface code 32 returns the return value of the sensor() function to the sandbox execution environment 13. At time t26, the sandbox execution environment 13 returns the return value of the sensor() function to the program code 31. At time t27, the return value is processed according to the program code 31. When execution of the program code 31 is completed, the processing result is stored in the sandbox execution environment 13 at time t28.

In this way, according to this embodiment, the program code 31 that processes jobs in a distributed manner accesses the input/output functions via the interface code 32, so the implementation of the input/output functions in distributed processing can be changed simply by changing the interface code 32 without modifying the program code. Furthermore, the interface code 32 can verify the data passed to the program code 31 or output from the program code 31, and control the access range.

By using the above flow, program code 31 can use external function calls to access external information for processing.

Moving on to FIG. 5C, at times t29 and t30, the processing result is passed to the agent function 12 by the interface code 32. At time t31, the agent function 12 passes the processing result to the Web server function 21. At time t32, the Web server function 21 passes the processing result to the management function 22, completing the distributed processing. This enables the management function 22 to execute any distributed processing job on the worker device 10 and receive the processing result.

Figure 6 is a schematic diagram showing an example in which a user of a worker device (wearable device) 10c, as a job requester, requests 3D processing related to the playback of 3D video images to multiple worker devices 10.

The job requester registers the image collection module 30a and the 3D processing module 30b as the program modules 30 from his/her wearable device 10c to the management server 20.

Each job processor wishing to carry out distributed processing starts and operates the web browser on his/her own worker device 10 to access the management server 20, obtains the agent function 12, and starts it within the web browser.

Each agent function 12 obtains the corresponding 3D processing module 30b from the management server 20 and processes the program code 31 in the sandbox execution environment. The processing results are provided to the requesting wearable device 10c via the management server 20 and used to play the 3D video.

According to this embodiment, a job requester can achieve low-latency, wideband 3D video playback using a wearable device 10c whose processing power is insufficient for 3D video processing.

Figure 7 is a schematic diagram showing an example of distributed processing by multiple worker devices 10 of a job for machine learning a model for predicting traffic volume and weather based on camera images. Here, the explanation is given assuming that the program modules 30, which are the video collection module 30c, the image processing module 30d, and the machine learning module 30e, have already been registered in the management server 20.

Each job processor wishing to carry out distributed processing starts and operates a web browser on his/her own worker device 10, obtains an agent function 12 from the management server 20, and starts it within the web browser. The agent function 12 obtains the corresponding program module 30 from the management server 20, and executes the program code 31 to obtain the processing results.

The worker device 10 that has acquired the video collection module 30c collects captured video using its own sensor information (here, the camera function) and outputs this as the result of distributed processing. The worker device 10 that has acquired the image processing module 30d performs image processing such as feature extraction from the video processing results and outputs the processing results.

The worker device 10 that has acquired the machine learning module 30e acquires the results of the image processing from multiple worker devices 10, performs machine learning, and constructs a model that predicts traffic volume and weather from camera images. The prediction model is provided to the job requester.

According to this embodiment, in a job for constructing a predictive model based on camera images captured from multiple viewpoints, the collection of camera images and their image processing can be distributed to multiple worker devices 10. Therefore, machine learning, which generally involves a high processing load, can be performed in an environment with low latency and load distribution.

The above embodiment enables distributed processing of jobs across multiple worker devices in a low-latency, broadband mobile communication environment, making it possible to provide a wide range of services to many people regardless of geographic or economic disparities. As a result, it will be possible to contribute to Goal 9 "Build resilient infrastructure and promote inclusive and sustainable industrialization" and Goal 11 "Make cities inclusive, safe, resilient and sustainable" of the United Nations-led Sustainable Development Goals (SDGs).

1... Edge server, 10 (10a, 10b, 10c, 10d)... Worker device, 11... Web browser, 12... Agent function, 13... Sandbox execution environment, 14... Execution engine, 20... Management server, 21... Web server function, 22... Management function, 30 (30a, 30b, 30c, 30d, 30e)... Program module, 31 (31a, 31b)... Program code, 32 (32a, 32b)... Interface code, 131... Instance, 132... Memory area, 133... Program counter, 134... Execution resource

Claims (8)

In a distributed computing control system in which multiple worker devices each equipped with a web browser work together with a management server to perform distributed job processing,
The worker device,
A means to access the management server via a web browser and obtain agent functions;
A means for activating the agent function using a web browser as an execution platform;
A means for causing the agent function to acquire a distributed processing program from a management server;
A means for launching the distributed processing program using a web browser as an execution platform;
a means for responding to the management server with a result of the distributed processing ;
The distributed processing program is started in a sandbox execution environment of a web browser,
the distributed processing program is a program module including a program code and an interface code that provides an interface to the program code,
the program code is launched in the sandbox execution environment;
The interface code provides the program code with an interface to a web browser and agent functions . 2. The distributed computing control system according to claim 1 , wherein said agent function executes the interface code by utilizing an execution engine provided in a Web browser. 3. The distributed computing control system according to claim 1 , wherein said agent function acquires a distributed processing program from a management server by utilizing an execution engine provided in a Web browser. 4. The distributed computing control system according to claim 1, wherein the program code is written using an instruction set that is executable in the sandbox execution environment. 5. The distributed computing control system according to claim 1 , wherein the agent function is implemented in a web browser of each worker device in a language adopted as a web standard . 6. The distributed computing control system according to claim 1 , wherein said agent function registers its own worker device in a management server after being started in a Web browser. A distributed computing control method in which a plurality of worker devices each having a web browser implemented therein cooperate with a management server to perform distributed processing of a job, comprising:
The worker device accesses the management server via a web browser to acquire the agent function,
The agent function is started using a web browser on the worker device as an execution platform,
The agent function obtains the distributed processing program from the management server,
The distributed processing program is started using a web browser as an execution platform;
The results of the distributed processing are returned to the management server .
The distributed processing program is started in a sandbox execution environment of a web browser,
the distributed processing program is a program module including a program code and an interface code that provides an interface to the program code,
the program code is launched in the sandbox execution environment;
The method for controlling distributed computing, wherein the interface code provides the program code with an interface to a web browser and an agent function . In a distributed computing control program in which a plurality of worker devices each having a web browser installed thereon cooperate with a management server to perform distributed processing of jobs,
How to access the management server using a web browser and obtain agent functions.
A step of starting the agent function using a web browser as an execution platform;
A procedure for causing an agent function to obtain a distributed processing program from a management server;
A step of launching the distributed processing program using a web browser as an execution platform;
a procedure for responding to the management server with a result of the distributed processing ;
The distributed processing program is started in a sandbox execution environment of a web browser,
the distributed processing program is a program module including a program code and an interface code that provides an interface to the program code,
the program code is launched in the sandbox execution environment;
The interface code provides an interface to a web browser and an agent function for the program code .

Images