US9391851B2 - System and method for determining total processing time for executing a plurality of jobs - Google Patents

Abstract

Method and system for determining the total processing time required for executing a plurality of jobs. In certain aspects, a set of jobs along with a mean processing time and a queue length are received. The set of jobs are distributed across computing resources based upon the queue length. A set of priority jobs is received when the execution of a subset of jobs from the set of jobs has been executed in a first processing time (T_F). Further, the set of priority jobs is distributed for execution across the plurality of computing resources. A second processing time (T_S) required for the execution of the set of priority jobs is computed. Further, a third processing time (T_T) required for the execution of the set of remaining jobs from the set of jobs is determined. Finally, the total processing time is determined by summing T_F, T_S, and T_T.

Description

CROSS-REFERENCE TO RELATED APPLICATIONS AND PRIORITY

The present application claims priority from Indian Patent Application No. 454/MUM/2014 filed on Feb. 7, 2014.

TECHNICAL FIELD

The present disclosure relates in general to systems and methods for determining total processing time required for executing multiple jobs received in real time.

BACKGROUND

In a computing network environment, multiple computing resources are deployed at different geographical locations in order to execute jobs associated with software applications of different technologies. The execution of the jobs is managed through a service level agreement (SLA) between a service provider and a customer. The service provider facilitates the execution of the jobs belonging to the customer. The customer may prescribe its requirements regarding the execution of the jobs through the SLA. In one example, the customer may set a pre-defined time limit for the execution of the jobs. Based on the requirements of the customer, the service provider may have to accordingly plan and execute the jobs, so that the SLA is complied.

In order to comply with the SLA, the service provider may have to effectively analyze supply and demand of the computing resources, such that the jobs are executed within the pre-defined time limit set as per the SLA. Further, some of the jobs (priority jobs) may have to be executed with higher priority. The priority jobs may have distinct characteristics than the other jobs, and may be arriving in real time. Since the arrival of the priority jobs is dynamic and the priority jobs have distinct characteristics, it becomes a technical challenge to effectively plan and allocate the computing resources, such that the overall jobs including the priority jobs are executed as per the SLA.

In view of lack of the effective planning and the allocation of the computing resources, it may be observed that few of the computing resources are overloaded with more jobs while the other computing resources may be receiving fewer jobs or may be idle. This may lead to ineffective utilization of the computing resources and hence may affect the completion of the execution of the jobs including the priority jobs as per the SLA.

SUMMARY

Without limiting scope, disclosed are exemplary systems and methods for determining a total processing time for executing a plurality of jobs and the aspects are further described below in the detailed description.

In one implementation, a system for determining a total processing time (T) for executing a plurality of jobs (n) including a set of jobs (z) and a set of priority jobs (x) is disclosed. The system may include a processor and a memory coupled to the processor for executing a plurality of modules stored in the memory. The plurality of modules may include a receiving module, a distributing module, and a determining module. The receiving module may be configured to receive the set of jobs (z), a mean processing time (μ), and a queue length (k). In one aspect, the mean processing time (μ) may be indicative of average time required for executing a job of the plurality of jobs (n). Further, the queue length (k) may be indicative of a maximum number of jobs capable of being executed by a single computing resource in a predefined time period. The distributing module may be configured to distribute the plurality of jobs (n) for execution across a plurality of computing resources (p) based upon the queue length (k). Further, the distributing module may be configured to receive the set of priority jobs (x) when a subset of jobs (z−y) from the set of jobs (z) have been executed in a first processing time (T_F). The distributing module may be configured to defer an execution of a set of remaining jobs (y) from the set of jobs (z) on receipt of the set of priority jobs (x). Further, the distributing module may be configured to distribute the set of priority jobs (x) for execution based on a probability distribution function [Q(t)]^x. In one embodiment, the probability distribution function [Q(t)]^x may be indicative of distribution of time for the execution of the priority jobs (x). The determining module may be configured to compute a second processing time (T_S) required for the execution of the priority jobs (x). In one embodiment, the second processing time (T_S)=Σx (μe^−μx/x!) [Q(t)]^x. The determining module may be further configured to determine a third processing time (T_T) required for the execution of the set of remaining jobs (y) based upon the first processing time (T_F). Furthermore, the determining module may be configured to sum the first processing time (T_F), the second processing time (T_S), and the third processing time (T_T) in order to determine the total processing time (T).

In another implementation, a method for determining a total processing time (T) for executing a plurality of jobs (n) comprising a set of jobs (z) and a set of priority jobs (x) is disclosed. The method may include receiving the set of jobs (z), a mean processing time (μ), and a queue length (k). In one aspect, the mean processing time (μ) may be indicative of average time required for executing a job of the plurality of jobs (n). Further, the queue length (k) may be indicative of a maximum number of jobs capable of being executed by a single computing resource in a predefined time period. The method may further include distributing the set of jobs (z) for execution across a plurality of computing resources (p) based upon the queue length (k). Further, the method may include receiving the set of priority jobs (x) when a subset of jobs (z−y) from the set of jobs (z) have been executed in a first processing time (T_F). The method may further include deferring an execution of a set of remaining jobs (y) from the set of jobs (z) on receipt of the set of priority jobs (x). Further, the method may include distributing the set of priority jobs (x) for execution based on a probability distribution function [Q(t)]^x. In one embodiment, the probability distribution function [Q(t)]^x may be indicative of distribution of time for the execution of the set of priority jobs (x). The method may further include computing a second processing time (T_S) required for the execution of the set of priority jobs (x). In one embodiment, the second processing time (T_S)=Σx (μe^−μx/x!) [Q(t)]^x. The method may further include determining a third processing time (T_T) required for the execution of the set of remaining jobs (y) based upon the first processing time (T_F). Furthermore, the method may include summing the first processing time (T_F), the second processing time (T_S), and the third processing time (T_T) in order to determine the total processing time (T). In an aspect, at least one of the receiving, the distributing the set of jobs (z), the deferring, the distributing the set of priority jobs (x), the computing, the determining, and the summing are performed by a processor using a set of instructions stored in a memory.

In yet another implementation, a computer program product having embodied thereon a computer program for determining a total processing time (T) for executing a plurality of jobs (n) including a set of jobs (z) and a set of priority jobs (x) is disclosed. The computer program product may include an instruction for receiving the set of jobs (z), a mean processing time (μ), and a queue length (k). In one aspect, the mean processing time (μ) may be indicative of average time required for executing a job of the plurality of jobs (n). Further, the queue length (k) may be indicative of a maximum number of jobs capable of being executed by a single computing resource in a predefined time period. The computer program product may include an instruction for distributing the set of jobs (z) for execution across a plurality of computing resources (p) based upon the queue length (k). Further, the computer program product may include an instruction for receiving the set of priority jobs (x) when a subset of jobs (z−y) from the set of jobs (z) have been executed in a first processing time (T_F). The computer program product may further include an instruction for deferring an execution of a set of remaining jobs (y) from the set of jobs (z) on receipt of the set of priority jobs (x). Further, the computer program product may comprise an instruction for distributing the set of priority jobs (x) for execution based on a probability distribution function [Q(t)]^x. In one embodiment, the probability distribution function [Q(t)]^x may be indicative of distribution of time for the execution of the priority jobs (x). The computer program product may include an instruction for computing a second processing time (T_S) required for the execution of the set of priority jobs (x). In one embodiment, the second processing time (T_S)=Σx (μe^−μx/x!) [Q(t)]^x. The computer program product may further include an instruction for determining a third processing time (T_T) required for the execution of the set of remaining jobs (y) based upon the first processing time (T_F). Furthermore, the computer program product may include an instruction for summing the first processing time (T_F), the second processing time (T_S), and the third processing time (T_T) in order to determine the total processing time (T).

BRIEF DESCRIPTION OF THE DRAWINGS

These and other features, aspects and advantages of the present invention are better understood when the following detailed description of the invention is read with reference to the accompanying drawings, in which:

FIG. 1 illustrates a network implementation of a system for determining a total processing time (T) for executing a plurality of jobs (n), in accordance with an embodiment of the present disclosure;

FIG. 2 illustrates the system, in accordance with an embodiment of the present disclosure; and

FIG. 3 illustrates a method for determining a total processing time (T) for executing a plurality of jobs (n), in accordance with an embodiment of the present disclosure.

DETAILED DESCRIPTION

The present invention will now be described more fully hereinafter with reference to the accompanying drawings in which exemplary embodiments of the invention are shown. However, the invention may be embodied in many different forms and should not be construed as limited to the representative embodiments set forth herein. The exemplary embodiments are provided so that this disclosure will be both thorough and complete, and will fully convey the scope of the invention and enable one of ordinary skill in the art to make, use and practice the invention. Like reference numbers refer to like elements throughout the various drawings. Disclosed are systems and methods for determining a total processing time (T) for executing a plurality of jobs (n) comprising a set of jobs (z) and a set of priority jobs (x) are described. The systems and methods enable effective and efficient technique of determining the determining a total processing time (T) for executing the plurality of jobs (n).

In order to determine the total processing time (T), at first, the system may receive the set of jobs (z) along with a mean processing time (μ), and a queue length (k). In one aspect, the mean processing time (μ) may be indicative of average time required for executing a job of the plurality of jobs (n). Further, the queue length (k) may be indicative of a maximum number of jobs capable of being executed by a single computing resource in a predefined time period. After the receipt of the set of jobs (z), the system may distribute the set of jobs (z) for execution across a plurality of computing resources (p) based upon the queue length (k).

While executing the set of jobs (z), the system may receive the set of priority jobs (x). The set of priority jobs (x) may be received when a subset of jobs (z−y) from the set of jobs (z) have been executed in a first processing time (T_F). Therefore, the system may preempt execution of a set of remaining jobs (y) from the set of jobs (z) in order to first process the execution of the set of priority jobs (x). In order to process the execution of the set of priority jobs (x), the system may distribute the set of priority jobs (x) based on a probability distribution function [Q(t)]^x. In one embodiment, the probability distribution function [Q(t)]^x may be indicative of distribution of time for the execution of the priority jobs (x).

Based upon the distribution of the set of the priority jobs (x), the system may compute a second processing time (T_S) required for the execution of the set of priority jobs (x). In one embodiment, the second processing time (T_S)=Σx (μe^−μx/x!) [Q(t)]^x. After the computation of the second processing time (T_S), the system may determine a third processing time (T_T) required for the execution of the set of remaining jobs (y) based upon the first processing time (T_F). Finally, the system may determine the total processing time (T) by summing the first processing time (T_F), the second processing time (T_S), and the third processing time (T_T).

While aspects of described system and method for determining a total processing time (T) for executing a plurality of jobs (n) may be implemented in any number of different computing systems, environments, and/or configurations, the embodiments are described in the context of the following exemplary system.

Referring now to FIG. 1, a network implementation 100 of a system 102 for determining a total processing time (T) for executing a plurality of jobs (n) comprising a set of jobs (z) and a set of priority jobs (x) is illustrated, in accordance with an embodiment of the present disclosure. In one embodiment, the system 102 may be configured to receive the set of jobs (z), a mean processing time (μ), and a queue length (k). In one aspect, the mean processing time (pt) may be indicative of average time required for executing a job of the plurality of jobs (n). Further, the queue length (k) may be indicative of a maximum number of jobs capable of being executed by a single computing resource in a predefined time period. The system 102 may be configured to distribute the set of jobs (z) for execution across a plurality of computing resources (p) based upon the queue length (k). Further, the system 102 may be configured to receive the set of priority jobs (x) when a subset of jobs (z−y) from the set of jobs (n) have been executed in a first processing time (T_F). The system 102 may be configured to defer an execution of a set of remaining jobs (y) from the set of jobs (z) on receipt of the set of priority jobs (x). Further, the system 102 may be configured to distribute the set of priority jobs (x) for execution based on a probability distribution function [Q(t)]^x. In one embodiment, the probability distribution function [Q(t)]^x may be indicative of distribution of time for the execution of the priority jobs (x). The system 102 may be configured to compute a second processing time (T_S) required for the execution of the set of priority jobs (x). In one embodiment, the second processing time (T_S)=Σx (μe^−μx/x!) [Q(t)]^x. The system 102 may be further configured to determine a third processing time (T_T) required for the execution of the set of remaining jobs (y) based upon the first processing time (T_F). Furthermore, the system 102 may be configured to sum the first processing time (T_F), the second processing time (T_S), and the third processing time (T_T) in order to determine the total processing time (T).

Although the present disclosure is explained considering that the system 102 is implemented as a server, it may be understood that the system 102 may also be implemented in a variety of computing systems, such as a laptop computer, a desktop computer, a notebook, a workstation, a mainframe computer, a network server, and the like. In one implementation, the system 102 may be implemented in a cloud-based environment. It will be understood that the system 102 may be accessed by multiple users through one or more user devices 104-1, 104-1, 104-2, 104-3, and 104-N collectively also referred to as a user device 104 hereinafter, or applications residing on the user devices 104. Examples of the user devices 104 may include, but are not limited to, a portable computer, a personal digital assistant, a handheld device, and a workstation. The user devices 104 are communicatively coupled to the system 102 through a network 106.

In one implementation, the network 106 may be a wireless network, a wired network or a combination thereof. The network 106 can be implemented as one of the different types of networks, such as intranet, local area network (LAN), wide area network (WAN), the internet, and the like. The network 106 may either be a dedicated network or a shared network. The shared network represents an association of the different types of networks that use a variety of protocols, for example, Hypertext Transfer Protocol (HTTP), Transmission Control Protocol/Internet Protocol (TCP/IP), Wireless Application Protocol (WAP), and the like, to communicate with one another. Further the network 106 may include a variety of network devices, including routers, bridges, servers, computing devices, storage devices, and the like.

Referring now to FIG. 2, the system 102 is illustrated in accordance with an embodiment of the present disclosure. In one embodiment, the system 102 may include at least one processor 202, an input/output (I/O) interface 204, and a memory 206. The at least one processor 202 may be implemented as one or more microprocessors, microcomputers, microcontrollers, digital signal processors, central processing units, state machines, logic circuitries, and/or any devices that manipulate signals based on operational instructions. Among other capabilities, the at least one processor 202 is configured to fetch and execute computer-readable instructions stored in the memory 206.

The I/O interface 204 may include a variety of software and hardware interfaces, for example, a web interface, a graphical user interface, and the like. The I/O interface 204 may allow the system 102 to interact with a user directly or through the user device 104. Further, the I/O interface 204 may enable the system 102 to communicate with other computing devices, such as web servers and external data servers (not shown). The I/O interface 204 can facilitate multiple communications within a wide variety of networks and protocol types, including wired networks, for example, LAN, cable, etc., and wireless networks, such as WLAN, cellular, or satellite. The I/O interface 204 may include one or more ports for connecting a number of devices to one another or to another server.

The memory 206 may include any computer-readable medium known in the art including, for example, volatile memory, such as static random access memory (SRAM) and dynamic random access memory (DRAM), and/or non-volatile memory, such as read only memory (ROM), erasable programmable ROM, flash memories, hard disks, optical disks, and magnetic tapes. The memory 206 may include modules 208 and data 210.

The modules 208 include routines, programs, objects, components, data structures, etc., which perform particular tasks, functions or implement particular abstract data types. In one implementation, the modules 208 may include a receiving module 212, a distributing module 214, a determining module 216, and other module 218. The other module 218 may include programs or coded instructions that supplement applications and functions of the system 102.

The data 210, amongst other things, serves as a repository for storing data processed, received, and generated by one or more of the modules 208. The data 210 may also other data 220. The other data 220 may include data generated as a result of the execution of one or more modules in the other module 218.

In one implementation, at first, a user may use the user device 104 to access the system 102 via the I/O interface 204. The user may register themselves using the I/O interface 204 in order to use the system 102. The working of the system 102 using the plurality of modules 208 is explained in detail referring to FIGS. 2 and 3 as explained below. In order to understand the working of the disclosure, consider an outsourcing entity has outsourced execution of a plurality of jobs, to an outsourcee entity. The outsourcee may have to allocate desired number of computing resources such as servers, hardware and/or software components, and the like in order to execute the plurality of jobs, as per the requirements of the outsourcing entity. The plurality of jobs may be continuously arriving for the execution at the outsourcee entity location, and hence need to be executed appropriately, satisfying the requirements of the outsourcing entity. The present system 102 enables the outsourcee entity to determine sufficient number of the computing resources to execute the plurality of jobs, the details of which is further explained as below.

Receiving Module 212

In an embodiment, the receiving module 212, as shown in FIG. 2 2, may be configured to receive a plurality of requirements of the outsourcing entity. The plurality of requirements may be associated to the execution of the plurality of jobs. In one embodiment, the receiving module 212 may be configured to receive the plurality of jobs (n) comprising a set of jobs (z) and a set of priority jobs (x). The plurality of jobs (n) has to be executed by one or more software applications belonging to the outsourcee entity. In one embodiment, the plurality of jobs (n) may be of similar or diverse skill types, and may be distributed across one or more geographical locations belonging to the outsourcee entity. In one example, the plurality of jobs (n) may be of the skill types comprising software development, software maintenance, Business Process Outsourcing (BPO), and the like. In one embodiment, the one or more software applications may require effective number of the computing resources in order to execute the plurality of jobs (n) as per the plurality of requirements. The plurality of requirements further comprises receiving by the receiving module 212, a mean processing time (μ), and a queue length (k). In one embodiment, the mean processing time (μ) may be indicative of average time required for executing a job of the plurality of jobs (n). Further, the queue length (k) may be indicative of a maximum number of jobs capable of being executed by a single computing resource in a predefined time period. In addition to the mean processing time (μ) and the queue length (k), the receiving module 212 may be configured to receive a plurality of parameters comprising a reference processing time (T_R), a standard deviation (σ), a tolerance level (α) agreed upon in a service level agreement (SLA), and a confidence level (1-α). In one embodiment, the reference processing time (T_R), the mean processing time (μ), and the plurality of parameters are predefined in a service level agreement (SLA).

In an embodiment, the mean processing time (μ) may indicate average time required for executing each job. In one example, assume the number of jobs (n) is ten, out of which four jobs require 50 minutes for the execution. Similarly, assume that the remaining jobs (i.e. six out of 10) require 60 minutes for the execution, then the mean processing time (μ) required for the execution of all ten jobs will be 44 minutes. Similarly, based on the skill type of the number of jobs (n) and their continuous arrival in batches, the mean processing time (μ) indicating the execution of each job corresponding to a batch of jobs may be received. Based on the requirements of the outsourcing entity, there may be a feasibility to allow a variance in the mean processing time (μ). The standard deviation (σ) indicates such variance in the mean processing time (μ). More particularly, the standard deviation (σ) indicates a variance in the mean processing time (μ). In one example, assume that the mean processing time (μ) is 50 minutes, and the standard deviation (σ) is also 50 minutes, then the variance allowable in the mean processing time (μ) will be square of the standard deviation (σ), i.e. σ², which will be 2500, in the aforementioned scenario.

In one embodiment, along with the mean processing time (μ), and the standard deviation (σ), the outsourcee entity may also have to execute the plurality of jobs (n) based on the tolerance level (α). The tolerance level (α) may be indicative of a maximum time allowable in addition to the reference processing time (T_R) for executing the plurality of jobs (n). In one embodiment, the reference processing time (T_R) may indicate a processing time agreed upon in the SLA for executing the plurality of jobs (n). In one implementation, reference processing time (T_R) may indicate the total time limit prescribed by the outsourcing entity to the outsourcee entity in order to complete the execution of the plurality of jobs (n). As per the service level agreement (SLA), the outsourcee entity may be allowed to execute the plurality of jobs (n) with the maximum time allowable in addition to the reference processing time (T_R). In one example, assuming the reference processing time (T_R) as 100 minutes, and the tolerance level as 5%, then the outsourcee entity may be allowed to execute the plurality of jobs (n) in 105 minutes with the maximum allowable time of 5 minutes. It is to be understood that, though the outsourcee entity may be allowed to execute the plurality of jobs (n) as per the tolerance level (α) predefined in the SLA, the outsourcee entity may, depending on the number of computing resources and their configuration, execute the plurality of jobs (n) even before the expiry of the reference processing time (T_R). For example, considering the present scenario of the reference processing time (T_R) as 100 minutes and the tolerance level (α) as 5%, the outsourcee entity may complete the execution of the plurality of jobs (n) in less than 100 minutes, for example, 90 minutes, 85 minutes, and the like. However, the outsourcee entity may not be allowed to complete the execution of plurality of jobs (n) by taking a reference processing time (T_R) of greater than 105 minutes.

In one embodiment, the confidence level (1−α) depends on the tolerance level (α). In one embodiment, the confidence level (1−α) indicates maximum percentage of the plurality of jobs that is required to be executed in the reference processing time (T_R), and as per the service level agreement (SLA). Hence, the outsourcee entity may have to accordingly provide the sufficient and effective number of the computing resources in order to execute the plurality of jobs (n) in the reference processing time (T_R) and in accordance with the service level agreement (SLA). In one implementation, the reference processing time (T_R), the mean processing time (μ), and the plurality of parameters may be processed in order to compute the queue length (k). The queue length (k) is indicative of ‘k’ jobs out of the plurality of jobs (n) to be executed by a single computing resource. The computation of the queue length (k) is further explained in detail as below.

In order to compute the queue length (k), consider the plurality of jobs (n) is distributed in a normalized function F(x). In one implementation, the queue length (k) may be computed using the normal distribution function as follows:
N((T _R −kμ)/√kσ ²≧1−α  (I)
Applying normal inverse function on both sides of equation (I);
(T _R −kμ)/√kσ ²≧Normalinv(1−α;μ;σ²)  (II)
In one embodiment, assuming the mean processing time (μ), and the standard deviation (σ) are received in normalized state, values corresponding to the mean processing time (μ), and the standard deviation (σ) may be 0 and 1 respectively. Specifically, the mean processing time (μ), and the standard deviation (σ) may be having a numeric value of 0, and 1 respectively. Therefore, value of the variance in the normalized state may also be 1. Now, substituting the values of the mean processing time (μ), and the standard deviation (σ) in the normalized state, equation II may be modified as follows:
(T _R −kμ)√kσ ²≧Normalinv(1−α;0;1)  (III)
(T _R −kμ)√kσ ²≧γ  (IV)
Wherein, ‘γ’=Normalinv (1−α; 0; 1), and wherein ‘γ’ is an inverse parameter and ‘k’ indicates the queue length or ‘k’ jobs per queue or ‘k’ jobs being executed by the single resource. Further, ‘T_R’ indicates the reference processing time.

In one embodiment, the values of the mean processing time (μ) and the variance σ² is received in order to compute the queue length (k) of maximum value. In this scenario, the value of the inverse parameter γ (Normalinv (1−α; 0; 1) may be obtained from a normal inverse table 1 as shown below. The table below provides the value of the inverse parameter γ based on the standard normal distribution, i.e. assuming the values of the mean processing time (μ) and the variance (σ²) as 0 and 1 respectively.

TABLE 1
Normal distribution - Inverse cumulative distribution function

	Value of	Value of Inverse Parameter (γ) (assuming mean
	(1 − α)	processing time (μ) = 0; and variance (σ2) = 1)

	0.50	0.0000
	0.51	0.0251
	0.52	0.0502
	0.53	0.0753
	0.54	0.1004
	.
	.
	.
	0.95	1.6449
	0.96	1.7507
	0.97	1.8808
	0.98	2.0537
	0.99	2.3263

In one example, from the above table, it may be observed that, if the value of the confidence level (1−α) is 0.95 (assuming the tolerance level (α) as 5%), then the value of the inverse parameter γ will be 1.6449. Similarly, based on the tolerance level (α), the value of the inverse parameter γ may be determined using the above table 1. It is to be noted that the above table 1 depicting the normal distribution using the Inverse cumulative distribution function is known in the art. It must be noted to one skilled in the art that values of (1−α) and Inverse Parameter (γ) listed in the table 1 have been considered in order to explain an exemplary embodiment of the present disclosure and hence should not be limited to these values. Therefore, the value of inverse parameter γ may be determined corresponding to any value of (1−α) by referring to normal inverse tables available in the art. It must be understood that, in order to obtain the maximum value of the queue length (k), the above table 1 may be used for determining the inverse parameter γ only when the distribution is standard normal distribution. Alternatively, when the distribution is normal, expected values of the mean processing time (μ), and the standard deviation (σ) may be utilized for the determination of the inverse parameter γ. In one example, assuming the expected values of the mean processing time (μ), the standard deviation (σ) and the tolerance level (α) are 50 minutes, 50 minutes and 5% respectively, the inverse parameter may be determined as follows:
Inverse parameter γ=((Normalinv(1−α;0;1))*expected value of variance (σ²))+expected value of mean processing time (μ)  (V)
Now, substituting the expected values in equation V,
Inverse parameter γ=(1.6449*2500)+50
Thus, the value of the Inverse parameter γ in the above example will be 4162.

In one embodiment, after the determination of the inverse parameter γ, the queue length (k) may be computed based on the reference processing time (T_R), the mean processing time (μ), the standard deviation (σ), and the inverse parameter (γ) using the equation IV as follows:

According to the equation IV,
(T _R −kμ)/√kσ ²≧γ,
Therefore, (T _R −kμ)−γ/√kσ ²≧0  (VI),
From the above equation VI, the queue length (k) may computed using quadratic equation kμ+γσ√k≦T_R, wherein,
√k=(−γσ±√γ²σ²+4μT _R)/2μ  (VII)
Therefore, the queue length (k) may be computed using equation VII, as mentioned above. The queue length indicates executing of ‘k’ jobs per queue, or the maximum number of jobs (k) capable of being executed by the single computing resource.

In one embodiment, when the distribution of the plurality of jobs is exponential, and not the standard normal distribution as described above, the system 102 may be configured to compute the queue length (k) using Gamma Inverse Function. In one example, assuming F(x) indicates the exponential distribution of the plurality of jobs (n), then applying the Gamma Inverse Function on F, the queue length (k) may be computed using following relation:
F(T _R ;k;1/μ)=1−Σ(1/n!)e ^−T _R ^/μ(^T _R/μ)ⁿ≧1−α, wherein n=0 to k−1  (VII-A)

Therefore, the queue length (k) may also be computed using equation VII-A, when the distribution of the jobs is exponential. The queue length indicates executing of ‘k’ jobs per queue, or the maximum number of jobs (k) capable of being executed by the single computing resource.

Based upon the computation of the queue length (k), the number of computing resources required for the execution of the plurality of jobs (n) may be determined. In one embodiment, the number of computing resources may be determined based on processing of the queue length (k) and the number of jobs (n). In one implementation, the number of computing resources is determined based on a ceiling function of division of the plurality of jobs (n) and the queue length (k). Specifically, the number of computing resources (such as the servers, and the like) may be determined as follows,
m= _┌(n/k)_┐  (VIII)
wherein, ‘m’ indicates the number of computing resources, and
_┌(n/k)_┐ indicates the ceiling function of (n/k), and
Wherein n indicates the number of jobs, and k indicates the queue length.

It must be understood that, the ceiling function maps a real number to the smallest following integer. Specifically, ceiling (x)=_┌x_┐ is the smallest integer not less than x. In one example, if x=12/5=2.4, then the ceiling (x)=_┌2.4_┐ which will be equal to 3. Thus, according to the present disclosure, the number of computing resources (m) is determined based on the ceiling function of the division of the plurality of jobs (n) and the queue length, i.e. the ceiling function of (n/k).

After the number of computing resources is determined, the I/O interface 204 may be adapted to display the queue length (k) and the number of computing resources (m) determined on the user device 104. The I/O interface 204 may also export the queue length (k) and the number of the computing resources to an external display device associated to the outsourcing entity. Further, the system 102, based on the determination of the computing resources, may be configured to allocate the executing of the plurality of jobs (n) to the computing resources, such that each computing resource is capable of executing k jobs out of the n jobs in the total processing time (T), and hence the plurality of jobs (n) may be executed in the total processing time (T).

In an exemplary embodiment, assume that the number of jobs to be executed by the software application of the outsourcing entity is 75. Further, assume that each job requires the mean processing time (μ) of 50 minutes and the standard deviation (σ) of 50 minutes. Therefore, the variance (σ²) will be 2500 minutes. Consider the reference processing time (T_R) required for executing 75 jobs is 240 minutes, and the tolerance level (α) is 5%. Therefore, the confidence level (1−α) will be 0.95. Consider the distribution as the standard normal distribution. Therefore, from the table 1, the value of the inverse parameter γ will be approximately 1.64. Now, in this exemplary embodiment, the queue length (k) may be computed using the equation VII as follows:

As per the equation VII, √k=(−γσ±√γ²σ²+4μT_R)/2μ,
Therefore, √k=(−γσ+√γ²σ²+4μT _R)/2μ  (A)
OR
√k=(−γσ−√γ²σ²+4μT _R)/2μ  (B)
Substituting the values in equation (A),
√k={−1.64*50+√(1.64*1.64*2500+4×240×50)}/100
Therefore, √k=1.52  (C)
Alternatively, substituting the values in equation (B),
√k={−1.64*50−√(1.64*1.64*2500+4×240×50)}/100
Therefore, √k=−3.16  (D)

Thus, k can be computed from (C) and (D) as (1.52)²=2.31 and (−3.16)²=9.98 respectively. Assuming k=2.31 is possible, hence k=3 jobs may be executed in 240 minutes at the single computing resource (e.g. a single server). Further, each job may take 50 minutes on an average processing time. It must be noted that at least two jobs may be executed by the single server, based on above computation, wherein k=2.31. Further, the number of computing resources required for the executing of 75 jobs will be _┌75/3_┐=25 resources or 25 servers. Thus, in order to execute all the 75 jobs in the reference processing time of 240 minutes, 25 servers may be required. Thus, the queue length (k) enables determining the number of computing resources required for execution of the plurality of jobs (n). The queue length (k) thus computed, and the number of computed resources enables in distributing the execution of the plurality of jobs (n) along with the set of priority jobs (x), which is explained in detail as below.

Distributing Module 214

After the receipt of the set of jobs (z) along with the queue length (k), the mean processing time (μ), the reference processing time (T_R) via the receiving module 212, the distributing module 214 may be configured to distribute the set of jobs (z) for execution across the plurality of computing resources (p). In one implementation, the distributing module 214 may distribute the set of jobs (z) for the execution across the plurality of computing resources (p) based upon the queue length (k). The queue length (k) indicates maximum number of jobs capable of being executed by a single computing resource of the plurality of computing resources (p) in a predefined time period. Accordingly, depending on the number of set of jobs (z) and the value of the queue length (k), the distributing module 214 may be configured to distribute the set of jobs (z) across the plurality of computing resources (p). In one example, assume that the queue length (k) is three and the number of jobs (z) to be executed is 75. Then, the number of computing resources (p) required for executing 75 jobs would be 75/3=25. Therefore, the number of jobs (75) would be distributed across the number of computing resources (p=25), such that each computing resource of the number of computing resources (p=25) is capable of handling three jobs in a predefined time period and capable of executing all the jobs (n=75) in the reference processing time.

During the execution of the set of jobs (z), the distributing module 214 may be configured to receive the set of priority jobs (x). Specifically, the set of priority jobs (x) may be received when a subset of jobs (z−y) from the set of jobs (z) have been executed in a first processing time (T_F), while a set of remaining jobs (y) from the set of jobs (z) are yet to be executed. Specifically, the execution of the set of remaining jobs (y) is preempted by the receipt of the set of priority jobs (x) while the subset of jobs (z−y) have been executed in the first processing time (T_F). The first processing time (T_F) is obtained based upon the time elapsed for the execution of the subset of jobs (z−y) and the number of computing resources utilized for the execution of the subset of jobs (z−y). In one embodiment, the first processing time (T_F) is calculated using a formula,
T _F=Elapsed Time/Number of computing resources(p)  (VIII)

In one example, assuming the elapsed time for the execution of the subset of jobs (z−y) is 20 minutes, and the number of computing resources (p) are 10, then using the equation VIII, the first processing time (T_F) will be 20/10=2 minutes. After the expiry of the first processing time (T_F), the set of priority jobs (x) are received. The set of priority jobs (x) may be appearing in random and have distinct characteristics as compared to the set of jobs (z). Though, the set of remaining jobs (z−y) are yet to be executed, the execution of the set of priority jobs (x) is prioritized over the execution of remaining jobs (z−y). Specifically, the execution of the remaining jobs (z−y) is deferred in order to execute the set of priority jobs (x). It is to be noted that the plurality of jobs (n) is the summation of the subset of jobs (z−y), the set of remaining jobs (y), and the set of priority jobs (x). In one embodiment, the distributing module 214 may be configured to distribute the set of priority jobs (x) for execution across the plurality of computing resources (p). In one embodiment, the distribution of the set of priority jobs (x) for the execution is based on a probability distribution function [Q(t)]^x. The probability distribution function [Q(t)]^x is indicative of distribution of time for the execution of the set of priority jobs (x). In one implementation, the probability distribution function [Q(t)]^x represent a Compound Poisson Distribution time (CPDT). After the distribution of the set of priority jobs (x) across the computing resources (p), the determining module 216 may be configured to compute a second processing time (T_S), a third processing time (T_T), and the total processing time (T) as described in detail in subsequent paragraphs.

Determining Module 216

After the distribution of the set of priority jobs (x), the determining module 216 may be configured to compute the second processing time (T_S). The second processing time (T_S) indicates processing time required for the execution of the set of priority jobs (x). In one embodiment, the determining module 216 may compute the second processing time (T_S) based upon the probability distribution function [Q(t)]^x and the mean processing time (μ). Specifically, the determining module 216 may compute the second processing time using following formulation:
T _S=Σ_x(μe ^−μx /x!)[Q(t)]^x  (IX)

After the computation of the second processing time (T_S), the determining module 216 may be configured to determine the third processing time (T_T). The third processing time (T_T) indicates processing time required for the execution of the set of remaining jobs (n−y). In one embodiment, the determining module 216 may determine the third processing time (T_T) based upon the first processing time (T_F). Specifically, the determining module 216 may determine the third processing time using following formulation:

$\begin{array}{cc}{T}_T=\frac{T_F*\mathrm{Number}\mathrm{of}\mathrm{the}\mathrm{set}\mathrm{of}\mathrm{remaining}\mathrm{jobs}\left(y\right)}{\mathrm{Number}\mathrm{of}\mathrm{the}\mathrm{subset}\mathrm{of}\mathrm{jobs}\left(z\text{-}y\right)}& \left(X\right)\end{array}$

After the determination of the third processing time (T_T), the determining module 216 may be configured to determine the total processing time (T) required for the execution of the plurality of jobs (n) and the set of priority jobs (x). The determining module 216 may determine the total processing time by summing the first processing time (T_F), the second processing time (T_S), and the third processing time (T_T). In alternative embodiment, the total processing time (T) may be determined based on an integral function of Fx_z-y (T_T−y) and Fx_y (y), wherein (y) indicates the number of the set of remaining jobs. The determination of the total processing time (T) is further explained with an example as below.

In one embodiment, consider the receiving module 212 is configured to receive the plurality of jobs=200, the mean processing time (μ)=40 minutes, the reference processing time (T_R)=240 minutes, and the queue length (k)=3. Therefore, based upon the queue length (k) and using the equation VII, the number of computing resources (p)=_┌(200/3)_┐=67. In this embodiment, assume the number of jobs (n)=200 comprising the set of priority jobs (x)=2, and the number of set of jobs (z−y)=50, elapsed time for the execution of the set of jobs (z−y)=150 minutes. Therefore, the number of remaining jobs (y)=200−50−2=148. Consider the Compound Poisson Distribution time (CPDT)=1.14007e⁺²⁶.

In this embodiment, using the equation VIII, the first processing time (T_F) will be, T_F=elapsed time/Number of computing resources=150/67=2.238806 minutes. Further using the equation IX, the second processing time (Ts)=40*(exp (−40*1))/1!*(1.14007e⁺²⁶)+40*(exp (−40*2))/2!*(1.14007e⁺²⁶)²=4.707705e⁺¹⁸ minutes. In one embodiment, the second processing time (T_S) may be normalized or standardized using various statistical methods known in the art. In one example, the second processing time may be normalized based upon a natural logarithm of T_S obtained using the equation IX. Therefore, after normalization T_S=ln (4.707705e⁺¹⁸) which is equal to 43 minutes. Further, the third processing time (T_T) is determined using the equation X, which in this scenario will be T_T=(148*2.238806)/50=6.626866 minutes. Finally, the total processing time (T) required for the execution of the plurality of jobs (n=200) will be the summation of the first processing time (T_F=2.238806 minutes), the second processing time (T_S=43 minutes), and the third processing time (T_T=6.626866 minutes). Therefore, the total processing time in this scenario will be the summation of 2.238806 minutes, 43 minutes, and 6.626866 minutes, i.e. 51.865672 minutes.

Exemplary embodiments discussed above may provide certain advantages. Though not required to practice aspects of the disclosure, these advantages may include those provided by the following features.

Some embodiments of the present disclosure enable the computation of the queue length (k) indicating maximum number of jobs capable of being executed by a single server.

Some embodiments of the present disclosure enable the determination of the number of servers required for the executing of the number of jobs (n) arriving in real time.

Some embodiments of the present disclosure enable real time allocation of the number of servers for the execution of the number of jobs based on the queue length (k) and the number of jobs (n).

Some embodiments of the present disclosure enables computing processing time required for executing a set of priority jobs (x) arriving in between the execution of a set of jobs (z), wherein the set of jobs (z) and the set of priority jobs (x) collectively forms the number of jobs (n).

Some embodiments of the present disclosure enables determining total processing time required for the execution of the set of jobs and the set of priority jobs.

Referring now to FIG. 3, a method 300 for determining total processing time required for executing a plurality of jobs is shown, in accordance with an embodiment of the present disclosure. The method 300 may be described in the general context of computer executable instructions. Generally, computer executable instructions can include routines, programs, objects, components, data structures, procedures, modules, functions, etc., that perform particular functions or implement particular abstract data types. The method 300 may also be practiced in a distributed computing environment where functions are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, computer executable instructions may be located in both local and remote computer storage media, including memory storage devices.

The order in which the method 300 is described is not intended to be construed as a limitation, and any number of the described method blocks can be combined in any order to implement the method 300 or alternate methods. Additionally, individual blocks may be deleted from the method 300 without departing from the spirit and scope of the disclosure described herein. Furthermore, the method can be implemented in any suitable hardware, software, firmware, or combination thereof. However, for ease of explanation, in the embodiments described below, the method 300 may be considered to be implemented in the above described system 102.

At block 302, the set of jobs (z), the mean processing time (μ), and the queue length (k) may be received. In one implementation, the set of jobs (z), the mean processing time (μ), and the queue length (k) may be received by the receiving module 212. The set of jobs (z) may be received from the outsourcing entity. The mean processing time (μ) indicates average time required for executing a job. The queue length (k) indicates a maximum number of jobs capable of being executed by a single computing resource in a predefined time period. In one implementation, the number of set of jobs (z), the mean processing time (μ), and the queue length (k) may be stored in the data 210.

At block 304, the set of jobs (z) may be distributed for execution across a plurality of computing resources (p) based upon the queue length (k). In one implementation, the set of jobs (z) may be distributed by the distributing module 214.

At block 306, the set of priority jobs (x) may be received. In one implementation, the set of priority jobs (x) may be received by the distributing module 214. In one embodiment, the set of priority jobs (x) are received when a subset of jobs (z−y) from the set of jobs (z) has been executed. Further, the subset of jobs (z−y) is executed in a first processing time (T_F).

At block 308, the execution of a set of remaining jobs (y) from the set of jobs (z) may be deferred on receipt of the set of priority jobs (x). In one implementation, the execution of the set of remaining jobs (y) is deferred by the distributing module 214.

At block 310, the set of priority jobs (x) may be distributed for execution across the plurality of computing resources (p) based on a probability distribution function [Q(t)]^x. In one embodiment, the probability distribution function [Q(t)]^x is indicative of distribution of time for the execution of the priority jobs (x). In one implementation, the set of priority jobs (x) may be distributed by the distributing module 214.

At block 312, a second processing time (T_S) required for the execution of the set of priority jobs (x) may be computed. In one embodiment, the second processing time (T_S) may be computed based upon a formula, T_S=Σ_x(μe^−μx/x!) [Q(t)]^x. In one implementation, the second processing time (T_S) may be computed by the determining module 216.

At block 314, a third processing time (T_T) required for the execution of the set of remaining jobs (y) may be determined. In one embodiment, the third processing time (T_T) may be determined based upon the first processing time (T_F). In one implementation, the third processing time (T_T) may be determined by the determining module 216.

At block 316, a total processing time (T) required for the execution of the plurality of jobs (n) comprising the set of (z) and the set of priority jobs (x) may be determined. In one embodiment, the total processing time (T) may be determined by summing the first processing time (T_F), the second processing time (T_S), and the third processing time (T_T). In one implementation, the total processing time (T) may be determined by the determining module 216.

Although implementations for methods and systems for determining total processing time required for executing a plurality of jobs have been described in language specific to structural features and/or methods, it is to be understood that the appended claims are not necessarily limited to the specific features or methods described. Rather, the specific features and methods are disclosed as examples of implementations for determining total processing time required for executing a plurality of jobs.

Claims (8)

We claim:

1. A method for determining a total processing time (T) for executing a plurality of jobs (n) comprising a set of jobs (z) and a set of priority jobs (x), the method comprising:

receiving the set of jobs (z), a mean processing time (μ), and a queue length (k), wherein the mean processing time (μ) is indicative of average time required for executing a job of the plurality of jobs (n), and wherein the queue length (k) is indicative of a maximum number of jobs capable of being executed by a single computing resource in a predefined time period;

distributing the set of jobs (z) for execution across a plurality of computing resources (p) based upon the queue length (k);

receiving the set of priority jobs (x) when a subset of jobs (z−y) from the set of jobs (z) has been executed in a first processing time (T_F);

deferring an execution of a set of remaining jobs (y) from the set of jobs (z) on receipt of the set of priority jobs (x);

distributing the set of priority jobs (x) for execution based on a probability distribution function [Q(t)]^x, wherein the probability distribution function [Q(t)]^x is indicative of distribution of time for the execution of the priority jobs (x);

computing, via a processor, a second processing time (T_S) required for the execution of the priority jobs (x), and wherein the second processing time (T_S)=Σ_x (μe^−μx/x!)[Q(t)]^x; and

determining, via the processor, a third processing time (T_T) required for the execution of the remaining jobs (y) based upon the first processing time (T_F); and

summing the first processing time (T_F), the second processing time (T_S), and the third processing time (T_T) in order to determine the total processing time (T).

2. The method of claim 1, further comprising

receiving a plurality of parameters comprising a reference processing time (T_R), standard deviation (σ), a tolerance level (α) agreed upon in a service level agreement (SLA), and a confidence level (1−α),

wherein the reference processing time (T_R) indicates a processing time agreed upon in the SLA for executing the plurality of jobs (n), and

wherein the standard deviation (σ) indicates a variance in the mean processing time (μ), and

wherein the tolerance level (α) is indicative of a maximum time allowable in addition to the reference processing time (T_R) for executing the plurality of jobs (n).

3. The method of claim 2, wherein the queue length (k) is based upon the reference processing time (T_R), the mean processing time (μ), and the plurality of parameters, and wherein the reference processing time (T_R), the mean processing time (μ), and the plurality of parameters are predefined in the SLA.

4. The method of claim 1, wherein the first processing time (T_F) is obtained by dividing the elapsed time with the number of computing resources (p), wherein the elapsed time indicates processing time required for the execution of the subset of jobs (z−y) from the set of jobs (z).

5. The method of claim 1, wherein the total processing time (T) is an integral function of Fx_z-y (T_T−y) and Fx_y (y), wherein (y) indicates the number of the set of remaining jobs.

6. A system for determining a total processing time (T) for executing a plurality of jobs (n) comprising a set of jobs (z) and a set of priority jobs (x), the system comprising:

a processor; and

a memory coupled to the processor, wherein the processor is capable of executing a plurality of modules stored in the memory, and wherein the plurality of modules comprises:

a receiving module configured to receive the set of jobs (z), a mean processing time (μ), and a queue length (k), wherein the mean processing time (μ) is indicative of average time required for executing a job of the plurality of jobs (n), and wherein the queue length (k) is indicative of a maximum number of jobs capable of being executed by a single computing resource in a predefined time period;

a distributing module configured to,

distribute the set of jobs (z) for execution across a plurality of computing resources (p) based upon the queue length (k),

receive the set of priority jobs (x) when a subset of jobs (z−y) from the set of jobs (z) has been executed in a first processing time (T_F),

defer an execution of a set of remaining jobs (y) from the set of jobs (z) on receipt of the set of priority jobs (x), and

distribute the set of priority jobs (x) for execution based on a probability distribution function [Q(t)]^x, wherein the probability distribution function [Q(t)]^x is indicative of distribution of time for the execution of the priority jobs (x); and

a determining module configured to,

compute a second processing time (T_S) required for the execution of the priority jobs (x), and wherein the second processing time (T_S)=Σx (μe−μx/x!) [Q(t)]^x,

determine a third processing time (T_T) required for the execution of the remaining jobs (y) based upon the first processing time (T_F), and

sum the first processing time (T_F), the second processing time (T_S), and the third processing time (T_T) in order to determine the total processing time (T).

7. The system of claim 6, wherein the receiving module is further configured to receive a plurality of parameters comprising a reference processing time (T_R), standard deviation (σ), a tolerance level (α) agreed upon in a service level agreement (SLA), and a confidence level (1−α), wherein the reference processing time (T_R) indicates a processing time agreed upon in the SLA for executing the plurality of jobs (n), and wherein the standard deviation (σ) indicates a variance in the mean processing time (μ), and wherein the tolerance level (α) is indicative of a maximum time allowable in addition to the reference processing time (T_R) for executing the plurality of jobs (n).

8. A non-transitory computer program product having embodied thereon a computer program for determining a total processing time (T) for executing a plurality of jobs (n) comprising a set of jobs (z) and a set of priority jobs (x), the computer program product comprising a set of instructions, the set of instructions comprising instructions for:

receiving the set of jobs (z), a mean processing time (.mu.), and a queue length (k), wherein the mean processing time (.mu.) is indicative of average time required for executing a job of the plurality of jobs (n), and wherein the queue length (k) is indicative of a maximum number of jobs capable of being executed by a single computing resource in a predefined time period;

distributing the set of jobs (z) for execution across a plurality of computing resources (p) based upon the queue length (k);

receiving the set of priority jobs (x) when a subset of jobs (z−y) from the set of jobs (n) has been executed in a first processing time (T.sub.F);

deferring an execution of a set of remaining jobs (y) from the set of jobs (z) on receipt of the set of priority jobs (x);

distributing the set of priority jobs (x) for execution based on a probability distribution function [Q(t)].sup.x, wherein the probability distribution function [Q(t)].sup.x is indicative of distribution of time for the execution of the priority jobs (x);

computing a second processing time (T.sub.S) required for the execution of the priority jobs (x), and wherein the second processing time (T.sub.S)=.SIGMA.x (.mu.e−.mu.x/x!) [Q(t)].sup.x; and

determining a third processing time (T.sub.T) required for the execution of the remaining jobs (y) based upon the first processing time (T.sub.F); and

summing the first processing time (T.sub.F), the second processing time (T.sub.S), and the third processing time (T.sub.T) in order to determine the total processing time (T).

Images