A SCHEDULING METHOD FOR VIRTUAL PROCESSORS BASED ON THE AFFINITY OF NUMA HIGH-PERFORMANCE NETWORK BUFFER RESOURCES

[0001] The present invention relates to the field of the computer system virtualization, and more particularly to a scheduling method for virtual processors based on the affinity of NUMA high-performance network buffer resources.

[0002] Virtualization technology usually integrates the functions of calculation or storage achieved by multiple physical devices into one physical server with relatively greater functionality, thereby achieving the integration and reallocation of hardware resources, improving the utilization ratio of hardware devices, and playing a very important role in building the cloud computing and data centers.

[0003] A virtual machine monitor refers to a software management layer between the hardware and traditional operating system, and the main function thereof is to manage real physical devices, such as physical CPU, memory, etc, and to abstract the underlying hardware to the corresponding virtual device interface, which enables multiple operating systems to get the required virtual hardware respectively, so that they can run simultaneously on the same physical device.

[0004] The feature of NUMA (Non Uniform Memory Access Architecture) is that the shared memories are distributed physically, and the collection of all these memories is global address space. Therefore, the time that the processors spend in accessing these memories is different; apparently the speed of accessing the local memories (high affinity) is a little more than that of accessing global shared memories or remotely accessing other memories (low affinity). FIG. 1 illustrates a schematic diagram of Non Uniform Memory Access (NUMA) architecture in the physical platform. Referring to FIG. 1, the schematic diagram is a schematic diagram of a NUMA architecture server with eight NUMA nodes. Since the distances between the processors located at different positions and each memory are different, and the distances between each processor are also different, the time that the different processors spend in accessing each memory is also different.

[0005] SR-IOV (Single-Root I/O Virtualization) technology is a virtualization solution based on hardware, which can improve performance and scalability. The SR-IOV standard allows PCIe (Peripheral Component Interconnect Express) devices to be shared efficiently between virtual machines, which is implemented in hardware, so as to be able to obtain the I/O performance comparable to the native performance.

[0006] SR-IOV is divided into Physical Function (PF) and Virtual Function (VF), wherein PF is a full-function PCIe function, which can implement discovery, management and processing as any other PCIe devices. PF has fully configured resources used to configure or control PCIe devices. VF is a lightweight PCIe function, which can share one or more physical resources with Physical Function and other VF associated with the same Physical Function. VF is only allowed to have the configured resources used for its own behavior.

[0007] FIG. 2 illustrates a schematic diagram of the operation of the network interface card with the SR-IOV function. Referring to FIG. 2, Physical Function (PF) of SR-IOV network interface card can virtualize multiple Virtual Functions (VFs), and then allocate Virtual Functions (VFs) to virtual machines. When virtual machines start, packets are sent to the corresponding receiving buffer/transmitting buffer (Rx/Tx). Virtual machines can directly access to the buffers of their own network interface cards through the support that hardware, such as IOMMU (input/output memory management unit) and the like, assists virtualization, so as to achieve the network processing speed close to the native performance.

[0008] Virtual machine monitors are introduced as a middle layer between physical devices and virtual machines, inevitably causing some effects on the performance of virtual machines, one of which is the effect on virtual machine memory. In fully virtualized environment, virtual machines with SR-IOV virtual function make virtual machines get the physical address of the buffer without the intervention of Virtual machine monitor, by means of the support of hardware, such as IOMMU and the like, which improves network performance significantly. However, in the NUMA environment, the buffer of the network interface card of the virtual machine is allocated to multiple nodes in most cases, thereby causing uncertainty of the buffer distribution, which certainly affects the speed of virtual machines processing network packets.

[0009] The existing research in academia is focused on non-virtualized aspect, which mainly takes into account that the memory distribution of tasks in NUMA is controlled by means of some libraries similar to NUMACTL and the like in NUMA, thereby making CPU and memory which process the corresponding tasks get better affinity, and improving the speed of processing tasks.

[0010] The existing Xen kernel provides several configuration methods for NUMA, wherein including that the memory is fully localized (NUMA aware placement), and the memory is configured to several nodes, then the virtual processor (VCPU) is scheduled to the allocated nodes (NUMA aware scheduling), however, which does not fully analyze the memory resources of virtual machines from the perspective of the distribution of the memory, so that the affinity between VCPU and memory does not achieve optimal effect, which inevitably affects the speed of VCPU processing the memory.

[0011] Therefore, those skilled in the art devote to developing a scheduling method for virtual processors based on the affinity of NUMA high-performance network buffer resources, so as to solve the problem that the speed of VCPU processing network packets is not optimal.

[0012] In view of the above disadvantages in the prior art, the technical problem to be solved by the present invention is that the affinity between the VCPU of the virtual machine and the buffer of the network interface card is not optimal in the NUMA architecture, so that the speed at which the network interface card of the virtual machine processes network packets is not high.

[0013] In order to realize the above objects, the present invention provides a scheduling method for virtual processors based on the affinity of NUMA high-performance network buffer resources, including the following steps:

[0014] (1) in a NUMA architecture, when a network interface card of a virtual machine is started, getting the distribution of the buffer of the network interface card on each NUMA node;

[0015] (2) getting affinities of each NUMA node for the buffer of the network interface card on the basis of an affinity relationship between each NUMA node;

[0016] (3) determining a target NUMA node in combination with the distribution of the buffer of the network interface card on each NUMA node and affinities of each NUMA node for the buffer of the network interface card;

[0017] (4) scheduling the virtual processor to a CPU on the target NUMA node.

[0018] Further, in the step (3), CPU load balance on each NUMA node is further combined to determine the target NUMA node.

[0019] Further, in the step (1), getting the distribution of the buffer of the network interface card on each NUMA node includes the following steps:

[0020] (11) when a driver of a virtual function of the virtual machine is started, detecting a virtual address on which Direct Memory Access allocates the buffer in the driver, as well as getting the size of the buffer of the virtual function;

[0021] (12) sending the virtual address to a specified domain;

[0022] (13) the specified domain making a request to a virtual machine monitor for getting a physical address corresponding to the virtual address by a hypercall;

[0023] (14) determining the distribution of the buffer of the network interface card on each NUMA node on the basis of the analysis of the distribution of the buffer on the NUMA node corresponding to the physical address.

[0024] Further, in the step (11), the size of the buffer of the virtual function is gotten by a network interface card performance testing tool.

[0025] Further, the specified domain is Domain0 in the virtual machine monitor.

[0026] Further, in the step (2), getting affinities of each NUMA node for the buffer of the network interface card on the basis of an affinity relationship between each NUMA node includes the following step:

[0027] (21) getting the affinities of each NUMA node for the buffer of the network interface card according to information of distances between each NUMA node.

[0028] Further, the scheduling method also includes the following step after the step (4) is executed:

[0029] (5) continuing to monitor running condition of the network interface card of the virtual machine.

[0030] Further, the virtual machine has a SR-IOV virtual function.

[0031] Compared with the prior art, the present technical solutions include at least the following beneficial technical results:

[0032] According to the scheduling method for virtual processors provided by the present invention, it is by getting distribution of the buffer of the network interface card on each NUMA node and affinities of each NUMA node for the buffer of the network interface card, to determine an optimal scheduling method for virtual processors (which is determining target NUMA node), which makes the virtual processor run up to the status that the affinity between the virtual processor and the buffer of the network interface card is optimal, so as to improve the processing speed of virtual network packets.

[0033] Further, it is on the basis of the analysis of the buffer of the network interface card of the current virtual machine, to ensure an optimal affinity between the virtual processor and the target memory, so that the virtual machine more fully utilizes the features of the NUMA architecture.

[0034] Further, during the course of determining the target NUMA node, CPU load balance on each NUMA node is also taken into consideration, so as to schedule VCPUs to multiple CPU cores, which still retains the original load scheduling method, on the target NUMA node, and reduces the effect on the system.

[0035] Further, the precise configuration of VCPU resources on the Xen platform is controlled effectively, thereby ensuring that the VCPU has the optimal network processing speed for network interface card packets of the virtual machine with the SR-IOV virtual function.

[0036] Below in conjunction with the accompanying drawings, the ideas, structures and technical results of the present invention will be further described so as to fully understand the objective, characteristics and effects of the present invention.

[0041] Below in conjunction with the accompanying drawings, the embodiment of the present invention will be further described. The embodiment is implemented on the premise of the technical solution of the present invention, and provides detail implementation and specific operation, but the scope of the present invention is not limited to the following embodiment.

[0042] FIG. 3 illustrates a flow diagram of a scheduling method for virtual processors based on the affinity of NUMA high-performance network buffer resources of the present invention. Referring to FIG. 3, the scheduling method includes the following steps:

[0043] Step S1: in a NUMA architecture, when a network interface card of a virtual machine is started, getting the distribution of the buffer of the network interface card on each NUMA node;

[0044] Step S2: getting affinities of each NUMA node for the buffer of the network interface card on the basis of an affinity relationship between each NUMA node;

[0045] Step S3: determining a target NUMA node in combination with the distribution of the buffer of the network interface card on each NUMA node and affinities of each NUMA node for the buffer of the network interface card;

[0046] Step S4: scheduling the virtual processor to a CPU on the target NUMA node.

[0047] It is noted that the scheduling method for virtual processors provided by the embodiment of the present invention is applied to the virtual machine with the SR-IOV virtual function. In the NUMA architecture, the buffer of the network interface card of the virtual machine is distributed to multiple NUMA nodes, thereby causing uncertainty of the buffer distribution, which affects the speed of virtual machines processing network packets.

[0048] Specifically, in the present embodiment, whenever the virtual machine with the SR-IOV virtual function is started and enables the buffer of the network interface card, the buffer is used to receive network packets. When a driver of a virtual function of the virtual machine is started, a virtual address on which Direct Memory Access (DMA) allocates the buffer in the driver is detected, and the size of the buffer of the virtual function is gotten by a network interface card performance testing tool (such as Ethtool), and the virtual address is sent to a specified domain, wherein the specified domain is Domain0 in the virtual machine monitor (such as Xen).

[0049] Then, the specified domain makes a request to a virtual machine monitor (VMM) for getting a physical address corresponding to the virtual address by a hypercall, and the distribution of the buffer of the network interface card on each NUMA node is determined on the basis of the analysis of the distribution of the buffer on the NUMA node corresponding to the physical address.

[0050] The core codes used to determine the distribution of the buffer of the network interface card on each NUMA node are as follows:

[0051] Add the following variables to store virtual machine parameters of the calling interface.

	struct p2m_domain *myp2m[10];
	p2m_type_t *myt[10];
	p2m_access_t *mya[10];
	p2m_query_t myq[10];
	unsigned int *mypo[10];
	int count = 0;

[0052] Get information of the parameters by adding detecting codes to the following initialization call.

	mfn_t ——get_gfn_type_access(struct p2m_domain *p2m,
unsigned long gfn,p2m_type_t *t, p2m_access_t *a, p2m_query_t q,
unsigned int *page_order, bool_t locked)
{
	int dom_count;
	...
	for(dom_count =0; dom_count <count; dom_count ++) {
	if(p2m−>domain−>domain_id==
	myp2m[dom_count]−>domain−>domain_id)
break;
	}
	if(dom_count == count) {
	myp2m[count] = p2m; myt[count] = t;
	mya[count] = a; myq[count] = q;
	mypo[count] = page_order; count++;
	}
	...
}

[0053] Get the physical page tables corresponding to the virtual page tables of the virtual machine by using the new function, unsigned long int doprint_mfn(unsigned long ,int), to hypercall VMM.

	unsigned long int do_print_mfn(unsigned long gfn, int domid)
	{
	int i;
	mfn_t mfn;
	for(i=0; i<count; i++)
	if(myp2m[i]−>domain−>domain_id == domid) break;
	if(i==count){
	printk(“Not found %d\n”,count);
	return 0;
	}
	mfn = myp2m[i]−>get_entry(myp2m[i], gfn, myt[i], mya[i],
myq[i], mypo[i]);
	return mfn;
	}

[0054] Then, get affinities of each NUMA node for the buffer of the network interface card on the basis of affinities between each NUMA node.

[0055] Specifically, in the NUMA architecture, affinities of each NUMA node for the buffer of the network interface card are determined according to information of distances between each NUMA node, namely, the closer the distance between two NUMA nodes is, the higher the affinity between them is. Therefore, in the present embodiment, the information of distances between each NUMA node can be used to determine the affinities of each NUMA node for the buffer of the network interface card.

[0056] Then, a target NUMA node is determined in combination with the distribution of the buffer of the network interface card on each NUMA node and affinities of each NUMA node for the buffer of the network interface card. In practice, CPU load balance on each NUMA node is taken into consideration, so as to schedule VCPUs to multiple CPU cores, which still retains the original load scheduling method, on the target NUMA node, and reduces the effect on the system.

[0057] The core codes used to determine the target NUMA node are as follows:

• • [0058] Add the following variables:

	int Numa_Node_dis[Max_size+1][Max_size+1];
	int Numa_Info[Max_size+1];
	int Numa_Node_Affi[Max_size+1];
	int main( ){
	...
	init_Numa_dis( );
	memset(Numa_Node_Affi,0,sizeof(Numa_Node_Affi));
	for(int Numa_Node=0; Numa_Node<Max_size;
	Numa_Node++) {
	for(int Numa_Else=0; Numa_Else<Max_size;
	Numa_Else++) {
	Numa_Node_Affi[Numa_Node]+=
Numa_Info[Numa_Else]*Numa_Node_dis[Numa_Node][Numa_Else];
	}
	}
	for(int Numa_Node=0; Numa_Node<Max size;
	Numa_Node++) {
	if(Numa_Node_Affi[Numa_Node] < Affinity_Min)
	Affinity_Min = Numa_Node_Affi[Numa_Node];
	}
	for(int Numa_Node=0; Numa_Node<Max_size;
	Numa_Node++) {
	if(Numa_Node_Affi[Numa_Node] == Affinity_Min)
Opt_Affinity.push_back(Numa_Node);
	}
...
}

[0059] Here, the affinity formula can be summarized as follows:

$\mathrm{Numa\_Node}\mathrm{\_Aff}\left[i\right]=\sum _{k=0}^n\mathrm{Numa\_Info}\left[k\right]*\mathrm{Numa\_Node}\mathrm{\_dis}\left[i\right]\left[k\right]$

[0060] wherein, i represents the i-th NUMA node, and i starts counting from 0;

[0061] the range of k is from 0 to n, and (n+1) represents the total number of NUMA nodes;

[0062] NUMA_Node_Aff[i] is the affinity of the i-th NUMA node for the buffer of the network interface card;

[0063] NUMA_Info[k] is the size of the buffer on the k-th node;

[0064] NUMA_Node_dis[i][k] represents the distance between the processor on the i-th node and the memory on the k-th node.

[0065] Finally, the virtual processor is scheduled to the CPU on the target NUMA node, wherein the CPU on the target NUMA node is a single-core CPU or a multi-core CPU. Then, the system continues to monitor running condition of the network interface card of the virtual machine.

[0066] The core codes used to schedule the virtual processor to the CPU on the target NUMA node are as follows:

string Des_Range[Max_size];
int main(int argc, char *argv[ ]){
	...
	freopen(“Numa_Map”,“r”,stdin);
	for(int Numa_Node=0; Numa_Node<Max_size; Numa_Node++)
	cin>>Des_Range[Numa_Node];
	freopen(“Numa_Opt”,“r”,stdin);
	int Des_Node;
	cin>>Des_Node;
	string Dom = argv[1];
	string Command = vcpu_migrate+Dom+“ all
	”+Des_Range[Des_Node];
	const char* arg = Command.c_str( );
	system(arg);
	...
}

[0067] In summary, the present technical solution includes at least the following beneficial technical results: it is by getting the distribution of the buffer of the network interface card on each NUMA node and affinities of each NUMA node for the buffer of the network interface card, to determine an optimal scheduling method for virtual processors (which is determining target NUMA node), which makes the virtual processor run up to the status that the affinity between the virtual processor and the buffer of the network interface card is optimal, so as to improve the processing speed of virtual network packets. Further, it is on the basis of the analysis of the buffer of the network interface card of the current virtual machine, to ensure an optimal affinity between the virtual processor and the target memory, so that the virtual machine fully utilizes the features of the NUMA architecture. Further, during the course of determining the target NUMA node, CPU load balance on each NUMA node is also taken into consideration, so as to schedule VCPUs to multiple CPU cores, which still retains the original load scheduling method, on the target NUMA node, and reduces the effect on the system. Further, the precise configuration of VCPU resources on the Xen platform is controlled effectively, thereby ensuring that the VCPU has the optimal network processing speed for network interface card packets of the virtual machine with the SR-IOV virtual function.

[0068] The invention has been exemplified above with reference to specific embodiments. However, it should be understood that a multitude of modifications and varieties can be made by a common person skilled in the art based on the conception of the present invention. Therefore, any technical schemes, acquired by the person skilled in the art based on the conception of the present invention through logical analyses, deductions or limited experiments, fall within the scope of the invention as specified in the claims.