US20200210241A1 - Method and system for gpu virtualization based on container - Google Patents
Method and system for gpu virtualization based on container Download PDFInfo
- Publication number
- US20200210241A1 US20200210241A1 US16/366,303 US201916366303A US2020210241A1 US 20200210241 A1 US20200210241 A1 US 20200210241A1 US 201916366303 A US201916366303 A US 201916366303A US 2020210241 A1 US2020210241 A1 US 2020210241A1
- Authority
- US
- United States
- Prior art keywords
- container
- gpu
- call
- controller
- event
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Abandoned
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
- G06F9/5055—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering software capabilities, i.e. software resources associated or available to the machine
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5061—Partitioning or combining of resources
- G06F9/5077—Logical partitioning of resources; Management or configuration of virtualized resources
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06T—IMAGE DATA PROCESSING OR GENERATION, IN GENERAL
- G06T1/00—General purpose image data processing
- G06T1/20—Processor architectures; Processor configuration, e.g. pipelining
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45562—Creating, deleting, cloning virtual machine instances
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/4557—Distribution of virtual machine instances; Migration and load balancing
Abstract
A GPU virtualization method based on a container comprises the steps of: transmitting, if the container is created, a configuration file including GPU resource constraint information and an API profile to the container, by a node controller; and implementing a virtual GPU, when the container is executed, by intercepting a library call and changing an argument related to a GPU resource amount by a library controller provided in the container, and by intercepting a system call and changing argument and return values by a system call controller.
Description
- The present invention relates to a method and a system for GPU virtualization based on a container, and particularly, to a method and a system for GPU virtualization based on a container, which implements the GPU virtualization by changing argument values or the like related to GPU resources, by a library controller and a system controller in the container.
- Recently, virtualization techniques are used much to improve efficiency, security and compatibility of large-scale computing for multiple users. Representatively, there is a virtual machine, which is applied in various fields such as applications, servers, storages, networks and the like. However, although the level of compatibility and isolation is the highest since the virtual machine virtualizes all physical hardware components from CPUs to disks, networks and even I/O devices, there is a disadvantage in that additional consumption (overheads) of computing resources is large.
- Meanwhile, containers emerge as a virtualization technique which overcomes the disadvantage of virtual machines by using an isolation technique of an operating system level, not virtualization. The container is implemented in a method of using a virtualized name space of resource elements provided by a completely isolated file system and a kernel as a user level execution environment, while sharing an operating system kernel of a host as a kernel level execution environment. The content of the isolated file system is configured by combining, in one package, an application and all dependencies, libraries, other binaries, configuration files and the like needed for driving the application. The resource elements of the kernel divided in a virtualized name space and provided to the container include a process ID, a network socket, a user account, shared memory for inter-process communication (IPC) and the like. Since the other hardware accesses are processed in the same manner as that of a case not a container, performance of host hardware can be completely used without an overhead. Here, the operating system provides an option for limiting a maximum amount of hardware resources available for each container.
- Recently, as deep learning techniques are developed and demands for large-scale computing increase, techniques for optimally sharing and managing computing resources are requested. To improve performance, accelerated processing hardware optimized for characteristics of deep learning operation appears, and a GPU is also one of them. However, a virtualization technique based on a container provided by an existing operating system supports only sharing and limitation of resources for the CPU, memory, disk, and file system of each container, and a technique for simultaneously sharing the accelerated processing hardware like GPU among several containers is not provided. Accordingly, there is a difficulty in efficiently sharing and managing the GPU.
- Therefore, the present invention has been made in view of the above problems, and it is an object of the present invention to provide a method and a system for GPU virtualization based on a container, which can dynamically allocate and share GPU resources through virtualization of an operating system level, not physical virtualization, using the container.
- A GPU virtualization method based on a container according to an embodiment of the present invention includes the steps of: transmitting, if the container is created, a configuration file including GPU resource constraint information and an API profile to the container, by a node controller; and implementing a virtual GPU, when the container is executed, by intercepting a library call and changing an argument related to a GPU resource amount by a library controller provided in the container, and by intercepting a system call and changing argument and return values by a system call controller.
- A GPU virtualization system based on a container according to an embodiment of the present invention includes: an operating system including a node controller for transferring a configuration file including resource constraint information and a system call/API profile to the container; and the container configured of a library controller for determining, when a library function call event of a user application is received, whether the event is an API call related to inquiry and allocation of GPU resources, changing at least one among an argument, a structure field and a return value related to GPU resource amounts, and calling an original library function, and a system controller determining, when a system call event of the user program is received, whether the event is a system call of at least one among permission, block and change according to a predefined API profile, and changing argument and return values before and after a call of original system call according to rules of the API profile.
- According to the present invention, a GPU computing system, in which a single GPU is allocated to a single container, multiple GPUs are allocated to a single container, a single GPU is shared by multiple containers, or multiple GPUs are shared by multiple containers, can be implemented by expanding a container virtualization technique.
- In addition, as the GPU computing system is implemented using a container, compared with a virtual machine, there is an effect in that system resources can be used more efficiently, and update is easy as applications can be moved and the scaling is simple.
-
FIG. 1 is a view showing the software structure of a GPU virtualization system based on a container according to an embodiment of the present invention. -
FIG. 2 is a flowchart illustrating a GPU virtualization method based on a container according to an embodiment of the present invention. -
FIG. 3 is a flowchart illustrating an operation method of a node controller according to an embodiment of the present invention. -
FIG. 4 is a flowchart illustrating an operation method of a library controller according to an embodiment of the present invention. -
FIG. 5 is a flowchart illustrating an operation method of a system controller according to an embodiment of the present invention. - Examples of specific structural or functional descriptions on the embodiments according to the concept of the present invention disclosed in this specification are only to explain the embodiments according to the concept of the present invention, and the embodiments according to the concept of the present invention may be embodied in a variety of forms and are not limited to the embodiments described in this specification.
- Since the embodiments according to the concept of the present invention may make diverse changes and have various forms, the embodiments will be shown in the figures and described in detail in the specification. However, this is not intended to limit the embodiments according to the concept of the present invention to specific disclosed forms, and the embodiments include all changes, equivalents and substitutions included in the spirit and scope of the present invention.
- The terms used in this specification are used to describe only particular embodiments and are not intended to limit the present invention. A singular expression includes a plural expression unless the context clearly indicates otherwise. In this specification, the terms such as “include” or “have” are to specify the presence of features, integers, steps, operations, components, parts or combinations of these stated in this specification, but do not preclude in advance the presence or addition of one or more of other features, integers, steps, operations, components, parts or combinations of these.
- Hereinafter, the embodiments of the present invention will be described in detail with reference to the figures attached in this specification.
-
FIG. 1 is a view showing the software structure of a GPU virtualization system based on a container according to an embodiment of the present invention. - Referring to
FIG. 1 , the software structure of aGPU virtualization system 100 is configured of aphysical GPU 110, anoperating system 120, and a plurality ofcontainers 130. - The
operating system 120 is configured of anode controller 121, acontainer engine 123, and anoperating system kernel 125. Theoperating system 120 communicates with thephysical GPU 110 through aGPU driver 127 installed in theoperating system kernel 125. - The
node controller 121 may transfer a configuration file including resource constraint information and a system call/API profile to thecontainer 130 and store them in the container. Thenode controller 121 may confirm GPU resource availability and initialize resource information of the node controller. The GPU resources may be GPU processing units and GPU memory, but they are not limited thereto. Thenode controller 121 may report the confirmed GPU resource availability to a manager and may receive a job assigned by the manager. Thenode controller 121 may update information on the GPU resource availability, and at this point, it may subtract the resources as much as a requested amount. If a container is created, thenode controller 121 may transfer the configuration file including the resource constraint information to the container, and if the end of executing the container is sensed, thenode controller 121 may collect the resources as much as a requested amount and update the resource availability information of the node controller. Thenode controller 121 may execute a code execution request of a user in the container. - The
container engine 123 creates and distributes thecontainer 130 and allocates GPU resources so that eachcontainer 130 may execute a corresponding application program. Thecontainer engine 123 may execute and terminate the container. - The
container 130 is a space including an image which combines various programs, source codes and libraries needed for driving a user program. Driving of a user program is practically accomplished in theoperating system 120. That is, theoperating system 120 may access eachcontainer 130 through thecontainer engine 123 and execute and process a corresponding user program. - The
container 130 is configured of auser program 131, aGPU library 133, aGPU runtime 135, alibrary controller 137 and asystem call controller 139. - The
user program 131 may operate to execute a code execution request of a user of the node controller in the container. - The
GPU library 133 may include a library so that a deep learning framework may operate, and for example, at least one of deep learning frameworks such as TensorFlow, Caffe, Pytorch, CNTK and Chainer may operate. - CUDA, OpenCL or ROCM, which are parallel processing algorithms executed in a GPU, may be installed and used in the
GPU runtime 135. The CUDA is a GPU middleware utilized in the machine learning field and may operate in the GPU runtime. The OpenCL may operate as parallel processing and a cross platform utilized in the field of machine learning and in high-performance computing (HPC). - When a library function call event of a user program is received, the
library controller 137 may determine whether the event is an API call related to inquiry and allocation of GPU resources, change at least one among an argument, a structure field and a return value related to GPU resource amounts, and call an original library function. If the event is not an API call related to inquiry and allocation of GPU resources, thelibrary controller 137 may call the original library function without changing an argument and return the return value as is. - When a system call event of a user program is received, the
system call controller 139 determines whether the event is a system call of at least one among permission, block and change according to a predefined API profile, and may change argument and return values before and after the call of an original system call according to rules of the API profile. If the event is not a system call of at least one among permission, block and change according to the predefined API profile, thesystem call controller 139 may call the original system call without changing an argument and return the return value as is. - That is, as the
library controller 137 in the container intercepts the library call and changes arguments related to the GPU resource amounts and thesystem call controller 139 intercepts the system call and changes argument and return values, a virtual GPU can be implemented. -
FIG. 2 is a flowchart illustrating a container virtualization method according to an embodiment of the present invention. - Referring to
FIG. 2 , if a container is created (step S201), thenode controller 121 transmits a configuration file including GPU resource constraint information and a system call/API profile to the container (step S203). The library controller and the system call controller in the container may receive and store the configuration file including the resource constraint information. - When the container is executed, as the
library controller 137 provided in the container intercepts the library call and changes an argument related to the GPU resource amounts, and thesystem call controller 139 intercepts the system call and changes the argument and return values, the virtual GPU is implemented (step S205). At this point, thelibrary controller 137 may change structure fields and return values, as well as the arguments related to the GPU resource amounts, and call the original library function. -
FIG. 3 is a flowchart illustrating an operation method of a node controller according to an embodiment of the present invention. - Referring to
FIG. 3 , the node controller first confirms GPU resource availability (step S301). Then, the node controller initializes resource information (step S303). - Hereinafter, the process described below may be repeatedly performed by a server execution loop (step S305). The node controller reports the confirmed GPU resource availability to the manager (step S307). The node controller receives a job assigned by the manager (job specification) (step S309). The
node controller 121 updates resource availability information (step S311). At this point, the resources may be subtracted as much as a requested amount. Then, a container is created (step S313), and the configuration file including the resource constraint information, which will be read by the library controller and the system controller, is transmitted to the container and stored in the container (step S315). Then, the container is executed (step S317), and the resource availability information of the node controller is updated (step S319) if the end of executing the container is sensed. At this point, the node controller may collect the resources as much as a requested amount. -
FIG. 4 is a flowchart illustrating an operation method of a library controller according to an embodiment of the present invention. - Referring to
FIG. 4 , the library controller receives a library function call event of a user program (step S401). Then, the library controller determines whether the event is an API call related to inquiry and allocation of GPU resources (step S403). - If the event is an API call related to inquiry and allocation of GPU resources as a result of the determination, the library controller changes at least one among an argument, a structure field and a return value related to GPU resource amounts (step S405). At this point, they may be changed on the basis of an embedded API profile and the configuration file of the container.
- Then, after at least one among an argument, a structure field and a return value is changed, the library controller calls the original library function (step S407).
- If the event is not an API call related to inquiry and allocation of GPU resources as a result of the determination, the library controller calls the original library function without changing an argument and returns the return value as is (step S409).
-
FIG. 5 is a flowchart illustrating an operation method of a system controller according to an embodiment of the present invention. - Referring to
FIG. 5 , the system controller receives a system call event of a user program (step S501). The system controller determines whether the event is a system call which needs a change in a predefined API profile (step S503). At this point, the system controller may determine whether it is a case which needs a permission or a block, as well as a change. If the event is a system call which needs a permission, a block or a change as a result of the determination, the system controller changes the argument and return values before and after the call of original system call according to rules of the API profile (step S505). - If the system call does not need a permission, a block or a change as a result of the determination, the system controller calls the original library function without changing an argument and returns the return value as is (step S507).
- While the present invention has been described with reference to the embodiments shown in the figures, this is only an example, and those skilled in the art may understand that various modifications and equivalent other embodiments are possible from the description. Therefore, the true scope of the present invention should be defined by the technical spirit of the appended claims.
Claims (6)
1. A GPU virtualization method based on a container, the method comprising the steps of:
transmitting, if the container is created, a configuration file including GPU resource constraint information and an API profile to the container, by a node controller; and
implementing a virtual GPU, when the container is executed, by intercepting a library call and changing an argument related to a GPU resource amount by a library controller provided in the container, and by intercepting a system call and changing argument and return values by a system call controller.
2. The method according to claim 1 , wherein the node controller confirms GPU resource availability, initializes resource information of the node controller, reports the resource availability to a manager, receives a job assigned by the manager, and updates resource availability information of the node controller by subtracting the resources as much as a requested amount.
3. The method according to claim 2 , wherein the node controller stores the configuration file including resource constraint information in the container when the container is created, and collects the resources as much as a requested amount and updates the resource availability information of the node controller if an end of executing the container is sensed.
4. The method according to claim 1 , wherein when a library function call event of a user program is received, the library controller determines whether the event is an API call related to inquiry and allocation of GPU resources, changes at least one among an argument, a structure field and a return value related to GPU resource amounts, and calls an original library function.
5. The method according to claim 1 , wherein when a system call event of a user program is received, the system call controller 139 determines whether the event is a system call of at least one among permission, block and change according to a predefined API profile, and changes argument and return values before and after the call of original system call according to rules of the API profile.
6. A GPU virtualization system based on a container, the system comprising:
an operating system including a node controller for transferring a configuration file including resource constraint information and a system call/API profile to the container; and
the container configured of a library controller for determining, when a library function call event of a user application is received, whether the event is an API call related to inquiry and allocation of GPU resources, changing at least one among an argument, a structure field and a return value related to GPU resource amounts, and calling an original library function, and a system controller determining, when a system call event of the user program is received, whether the event is a system call of at least one among permission, block and change according to a predefined API profile, and changing argument and return values before and after a call of original system call according to rules of the API profile.
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US16/426,335 US20200210242A1 (en) | 2018-12-26 | 2019-05-30 | Method and system for gpu virtualization based on container |
US16/859,167 US11221888B2 (en) | 2018-12-26 | 2020-04-27 | Method and system for GPU virtualization based on container |
Applications Claiming Priority (3)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
KR1020180169620A KR102032521B1 (en) | 2018-12-26 | 2018-12-26 | Method and system for GPU virtualization based on container |
KR10-2018-0169620 | 2018-12-26 | ||
PCT/KR2018/016810 WO2020075919A1 (en) | 2018-12-26 | 2018-12-28 | Container-based gpu virtualization method and system |
Related Parent Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/KR2018/016810 Continuation WO2020075919A1 (en) | 2018-12-26 | 2018-12-28 | Container-based gpu virtualization method and system |
Related Child Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US16/426,335 Continuation US20200210242A1 (en) | 2018-12-26 | 2019-05-30 | Method and system for gpu virtualization based on container |
Publications (1)
Publication Number | Publication Date |
---|---|
US20200210241A1 true US20200210241A1 (en) | 2020-07-02 |
Family
ID=67437200
Family Applications (3)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US16/366,303 Abandoned US20200210241A1 (en) | 2018-12-26 | 2019-03-27 | Method and system for gpu virtualization based on container |
US16/426,335 Abandoned US20200210242A1 (en) | 2018-12-26 | 2019-05-30 | Method and system for gpu virtualization based on container |
US16/859,167 Active 2039-04-29 US11221888B2 (en) | 2018-12-26 | 2020-04-27 | Method and system for GPU virtualization based on container |
Family Applications After (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US16/426,335 Abandoned US20200210242A1 (en) | 2018-12-26 | 2019-05-30 | Method and system for gpu virtualization based on container |
US16/859,167 Active 2039-04-29 US11221888B2 (en) | 2018-12-26 | 2020-04-27 | Method and system for GPU virtualization based on container |
Country Status (5)
Country | Link |
---|---|
US (3) | US20200210241A1 (en) |
EP (1) | EP3657328A1 (en) |
JP (1) | JP6943954B2 (en) |
KR (1) | KR102032521B1 (en) |
WO (1) | WO2020075919A1 (en) |
Cited By (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
JP2021099879A (en) * | 2020-09-30 | 2021-07-01 | 北京百度網訊科技有限公司 | Development machine operation task processing method, electronic apparatus, computer-readable storage medium, and computer program |
KR102488537B1 (en) * | 2022-09-21 | 2023-01-13 | (주)글루시스 | Method for scheduling gpu resource in virtual environment based on container |
US11762685B2 (en) | 2019-12-22 | 2023-09-19 | Samsung Electronics Co., Ltd. | Method and apparatus for scaling resources of graphics processing unit in cloud computing system |
Families Citing this family (7)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
KR102297576B1 (en) * | 2019-11-12 | 2021-09-03 | 건국대학교 산학협력단 | Method of managing automatically a deep learning library and apparatuses performing the same |
CN111913794A (en) * | 2020-08-04 | 2020-11-10 | 北京百度网讯科技有限公司 | Method and device for sharing GPU, electronic equipment and readable storage medium |
CN112162856A (en) * | 2020-09-23 | 2021-01-01 | 武汉联影医疗科技有限公司 | GPU virtual resource allocation method and device, computer equipment and storage medium |
CN113296946B (en) * | 2021-05-24 | 2023-11-17 | 南京大学 | Processing method and equipment for concurrent real-time streaming data analysis tasks with coordinated side ends |
CN113296950B (en) * | 2021-05-28 | 2022-08-19 | 重庆紫光华山智安科技有限公司 | Processing method, processing device, electronic equipment and readable storage medium |
WO2023023555A1 (en) * | 2021-08-19 | 2023-02-23 | Pepperdata, Inc. | Systems, methods, and devices for capacity optimization in a cluster system |
KR102488390B1 (en) * | 2021-12-09 | 2023-01-13 | 래블업 주식회사 | Method and system for automatic scaling of multi-container-based computational sessions on a cluster |
Family Cites Families (23)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US6809736B1 (en) * | 2002-01-08 | 2004-10-26 | Apple Computer, Inc. | Virtualization of graphics resources |
US8274518B2 (en) * | 2004-12-30 | 2012-09-25 | Microsoft Corporation | Systems and methods for virtualizing graphics subsystems |
US8949826B2 (en) * | 2006-10-17 | 2015-02-03 | Managelq, Inc. | Control and management of virtual systems |
KR100928866B1 (en) * | 2007-09-10 | 2009-11-30 | 주식회사 안철수연구소 | Apparatus and method for running an application in a virtual environment |
US8346854B2 (en) * | 2010-06-30 | 2013-01-01 | Deskstream, Inc. | Method and system of operating system independence |
US9514507B2 (en) * | 2011-11-29 | 2016-12-06 | Citrix Systems, Inc. | Methods and systems for maintaining state in a virtual machine when disconnected from graphics hardware |
WO2014085717A1 (en) * | 2012-11-28 | 2014-06-05 | Nvidia Corporation | Method and system for cloud based virtualized graphics processing for remote displays |
US9142004B2 (en) * | 2012-12-20 | 2015-09-22 | Vmware, Inc. | Dynamic allocation of physical graphics processing units to virtual machines |
US9417929B2 (en) * | 2012-12-20 | 2016-08-16 | Vmware, Inc. | Runtime profile determinations of virtual machines for graphics processing unit (GPU) allocation |
US9268588B2 (en) * | 2013-05-20 | 2016-02-23 | Citrix Systems, Inc. | Optimizing virtual machine migration via identification and treatment of virtual memory swap file |
US9680772B2 (en) * | 2013-09-09 | 2017-06-13 | Vmware, Inc. | System and method for managing configuration of virtual switches in a virtual machine network |
US9420007B1 (en) * | 2013-12-04 | 2016-08-16 | Amazon Technologies, Inc. | Access control using impersonization |
US9256467B1 (en) * | 2014-11-11 | 2016-02-09 | Amazon Technologies, Inc. | System for managing and scheduling containers |
CN105988874B (en) * | 2015-02-10 | 2020-08-28 | 阿里巴巴集团控股有限公司 | Resource processing method and device |
US9904975B2 (en) * | 2015-11-11 | 2018-02-27 | Amazon Technologies, Inc. | Scaling for virtualized graphics processing |
US10758185B2 (en) * | 2015-11-25 | 2020-09-01 | Texas Instruments Incorporated | Heart rate estimation apparatus using digital automatic gain control |
US9898354B2 (en) * | 2016-03-21 | 2018-02-20 | Microsoft Technology Licensing, Llc | Operating system layering |
US10606660B1 (en) * | 2016-04-29 | 2020-03-31 | Architecture Technology Corporation | Planned cloud resource management |
US11119824B2 (en) * | 2016-06-30 | 2021-09-14 | Intel Corporation | Technologies for implementing consolidated device infrastructure systems |
KR20180045347A (en) * | 2016-10-25 | 2018-05-04 | 에스케이텔레콤 주식회사 | Method for resource management of virtual environment |
KR101716715B1 (en) * | 2016-12-27 | 2017-03-15 | 주식회사 티맥스클라우드 | Method and apparatus for handling network I/O apparatus virtualization |
KR101848450B1 (en) | 2017-02-06 | 2018-04-12 | 국민대학교산학협력단 | Method for managing many-core based on docker and apparatus managing the same |
US10795974B2 (en) * | 2018-05-31 | 2020-10-06 | Microsoft Technology Licensing, Llc | Memory assignment for guest operating systems |
-
2018
- 2018-12-26 KR KR1020180169620A patent/KR102032521B1/en active IP Right Grant
- 2018-12-28 JP JP2019518972A patent/JP6943954B2/en active Active
- 2018-12-28 WO PCT/KR2018/016810 patent/WO2020075919A1/en unknown
- 2018-12-28 EP EP18863794.6A patent/EP3657328A1/en not_active Withdrawn
-
2019
- 2019-03-27 US US16/366,303 patent/US20200210241A1/en not_active Abandoned
- 2019-05-30 US US16/426,335 patent/US20200210242A1/en not_active Abandoned
-
2020
- 2020-04-27 US US16/859,167 patent/US11221888B2/en active Active
Cited By (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US11762685B2 (en) | 2019-12-22 | 2023-09-19 | Samsung Electronics Co., Ltd. | Method and apparatus for scaling resources of graphics processing unit in cloud computing system |
JP2021099879A (en) * | 2020-09-30 | 2021-07-01 | 北京百度網訊科技有限公司 | Development machine operation task processing method, electronic apparatus, computer-readable storage medium, and computer program |
JP7170768B2 (en) | 2020-09-30 | 2022-11-14 | ベイジン バイドゥ ネットコム サイエンス テクノロジー カンパニー リミテッド | Development machine operation task processing method, electronic device, computer readable storage medium and computer program |
KR102488537B1 (en) * | 2022-09-21 | 2023-01-13 | (주)글루시스 | Method for scheduling gpu resource in virtual environment based on container |
Also Published As
Publication number | Publication date |
---|---|
JP2020537197A (en) | 2020-12-17 |
WO2020075919A1 (en) | 2020-04-16 |
EP3657328A4 (en) | 2020-05-27 |
US11221888B2 (en) | 2022-01-11 |
EP3657328A1 (en) | 2020-05-27 |
US20200257565A1 (en) | 2020-08-13 |
JP6943954B2 (en) | 2021-10-06 |
US20200210242A1 (en) | 2020-07-02 |
KR102032521B1 (en) | 2019-10-15 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US11221888B2 (en) | Method and system for GPU virtualization based on container | |
RU2569805C2 (en) | Virtual non-uniform memory architecture for virtual machines | |
US20190377604A1 (en) | Scalable function as a service platform | |
US9063783B2 (en) | Coordinating parallel execution of processes using agents | |
US7533385B1 (en) | Virtualization and server imaging system for allocation of computer hardware and software | |
US10897428B2 (en) | Method, server system and computer program product for managing resources | |
KR20060004919A (en) | Concurrent access of shared resources | |
US11334477B2 (en) | Virtualization of multiple coprocessor memory | |
US20190213062A1 (en) | System and Method for Coordinating Use of Multiple Coprocessors | |
US11461120B2 (en) | Methods and apparatus for rack nesting in virtualized server systems | |
CN113778612A (en) | Embedded virtualization system implementation method based on microkernel mechanism | |
Diab et al. | Dynamic sharing of GPUs in cloud systems | |
US20190310874A1 (en) | Driver management method and host | |
US11907589B2 (en) | Unified host memory for coprocessors | |
KR101620896B1 (en) | Executing performance enhancement method, executing performance enhancement apparatus and executing performance enhancement system for map-reduce programming model considering different processing type | |
US11720388B2 (en) | Management of dynamic sharing of central processing units | |
CN113986466A (en) | Cloud computing-oriented GPU virtualization system and method | |
US9547522B2 (en) | Method and system for reconfigurable virtual single processor programming model | |
US11762672B2 (en) | Dynamic linker for loading and running an application over a plurality of nodes | |
KR102417882B1 (en) | Method for managing gpu resources and computing device for executing the method | |
US11144343B1 (en) | Method of providing session container mounted with plurality of libraries requested by user | |
Agut et al. | High-throughput Computation through Efficient Resource Management | |
KR20210074218A (en) | Edge framework system | |
KR20230034195A (en) | System and operation method of hybrid virtual machine managers |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: LABLUP INC., KOREA, REPUBLIC OF Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:KIM, JOON GI;SHIN, JEONG KYU;PARK, JONG HYUN;REEL/FRAME:048715/0489 Effective date: 20190327 |
|
STPP | Information on status: patent application and granting procedure in general |
Free format text: NON FINAL ACTION MAILED |
|
STCB | Information on status: application discontinuation |
Free format text: ABANDONED -- FAILURE TO RESPOND TO AN OFFICE ACTION |