Genetic-based algorithms for resource management in virtualized IVR applications
© Kara et al.; licensee Springer. 2014
Received: 22 May 2014
Accepted: 01 October 2014
Published: 15 October 2014
Interactive Voice Response (IVR) is a technology that allows automatic human-computer interactions, via a telephone keypad or voice commands. The systems are widely used in many industries, including telecommunications and banking. Virtualization is a potential technology that can enable the easy development of IVR applications and their deployment on the cloud. IVR virtualization will enable efficient resource usage by allowing IVR applications to share different IVR substrate components such as the key detector, the voice recorder and the dialog manager. Resource management is part and parcel of IVR virtualization and poses a challenge in virtualized environments where both processing and network constraints must be considered. Considering several objectives to optimize the resource usage makes it even more challenging. This paper proposes IVR virtualization task scheduling and computational resource sharing (among different IVR applications) strategies based on genetic algorithms, in which different objectives are optimized. The algorithms used by both strategies are simulated and the performance measured and analyzed.
KeywordsResource management Cloud computing Virtualization IVR applications Genetic algorithms
Interactive Voice Response (IVR) is a technology that allows automatic human-computer interactions, via a telephone keypad or voice commands. Its key function is to provide end-users with self-service voice information . IVR systems are widely used in many industries, including telecommunications and banking, to improve customer satisfaction, reduce cost, and ensure uninterrupted service. Examples of IVR applications include automated attendants, automated meter readers and IVR banking. The automated attendant transfers callers to the appropriate extensions automatically, without intervention by a receptionist; using automated meter readers, utilities customers can remotely enter their meter readings, while IVR banking allows end-users to consult their bank balance or last transactions, for instance.
Virtualization is a potential technology that can enable the easy development of IVR applications and their deployment on the cloud. It allows the abstraction and sharing of computer and network resources, as well as the co-existence of entities on the same substrates . Cloud computing is a multi-facet paradigm, which enables the easy introduction of new services, scalability and efficient resource usage. The main facets of cloud computing are Infrastructure as a Service (IaaS), Platform as a Service (PaaS), and Software as a Service (SaaS) . IaaS provides the pool of virtualized resources that are used by applications provisioned (to end-users or other applications) as SaaS. The development and management of such applications are made easier through PaaS which adds one or more levels of abstraction to the infrastructures offered by IaaS providers.
IVR virtualization will enable efficient resource usage by allowing IVR applications to share different IVR substrate components such as key detectors, voice recorders and dialog managers. It will also ease the development and the management of IVR applications that can be offered as cloud-based services.
The three layers communicate via three planes: service, composition and management. The service plane handles the service execution, including coordinating the execution of services that involve several substrates; the composition plane intervenes in the composition of the appropriate substrates to create a given IVR application and the management plane is responsible for the actual control and management of substrate resources. It allows the instantiation of IVR applications and related substrates, enables fault and performance monitoring, and performs accounting for charging purposes. Each layer includes one functional entity at each plane, and one key entity that coordinates the operation of the layer entities at the three planes. At the substrate layer for instance we have a substrate service, composition and management engines that are coordinated by the substrate IVR engine.
This paper focuses on the management plane, and more precisely on resource management at the substrate layer. Before a service provider can make an IVR application available to its end-users, he should develop such an application by discovering and (eventually) composing existing substrates. It then activates the application, a phase which includes the instantiation of the substrates required to run the application. It is only after this that the end-users can interact with the application.
To instantiate new substrates, the substrate management engine should identify the resources needed, verify resource availability and then allocate the appropriate resources. We focus on two issues: computational resources sharing and task scheduling. In computational resource sharing, we examine the sharing of existing computational resources (e.g., virtual machines, processors) between different IVR applications optimally. Task sch\eduling relates to the assignment of the instantiation requests received.
Computational resource sharing and task scheduling in virtualized environments where both processing and network constraints must be considered are challenging issues. Considering several objectives to optimize the resource scheduling and usage makes them even more challenging.
Several research studies have focused on load balancing across processors or computers in both non-virtualized  and virtualized environments . This paper proposes to address these issues for a specific application: IVR. It defines task scheduling and computational resource sharing strategies based on genetic algorithms, in which different objectives are optimized. We chose genetic algorithms because their robustness and efficiency for the design of efficient schedulers have been largely proven in the literature ,. More specifically, we identify task assignments that guarantee maximum utilization of resources while minimizing the execution time of tasks. Moreover, we propose a resource allocation strategy that minimizes substrate resource utilization and the resource allocation time. We also simulated the algorithms used by the proposed strategies and measured and analyzed their performance.
The rest of the paper is organized as follows. Section "Assumptions and problems statement" presents the assumptions and the problem statement. Section "Resource management algorithms" discusses the proposed resource management algorithms. Sections "Computational resource sharing algorithm" and "Task scheduling" describe the computational resource sharing and instantiation request scheduling algorithms respectively. Section "Performance results and analysis" presents the main performance analysis. The state of the art review and the conclusion are given in sections "State of the art review" and "Conclusion" respectively.
Assumptions and problems statement
The substrate management engine (Figure 1) has two entities: the IVR resource manager and the IVR instance manager. The resource manager maintains and monitors the current state of resources and allocates resources for new IVR service substrates (ISSs). An ISS is the set of IVR substrate instances used by a single IVR application. Each ISS is managed by a separate IVR instance manager, which coordinates the process of ISS instantiation (i.e., ISS creation, configuration and activation).
We assume that each virtualization machine (i.e. a machine that hosts the substrate layer) has a fixed number of processors that are dedicated to the processing of the incoming instantiation requests, and a fixed amount of computational resources (e.g. virtual machines, processors, CPU, memory, disk space) that are used to run the different ISSs. The computational resources are shared among a set of ISSs, each having specific resource requirements evaluated in terms of CPU, memory, disk space and bandwidth. We assume that the virtualization machine capabilities are known in advance, while the ISSs' resource requirements are estimated at run time. In our case, the latter are estimated using a set of functions derived from observed measurements performed using a prototype of a virtualized infrastructure for IVR applications in the cloud .
When a resource manager receives an instantiation request, it verifies the availability of the substrate resources according to the ISS requirements. It then creates a new ISS and allocates the necessary resources. If no more substrate resources are available, the resource manager will reject all incoming instantiation requests.
We further assume that the service quality parameters required by each ISS are described by the IVR application provider using a service level agreement (SLA). In this work, we only consider as one SLA parameter; i.e. the satisfactory factor of the IVR application. This satisfactory factor is defined as the resources employed by a certain number of users over the allocated ISS resources. This parameter allows the control of the application status, such as ensuring that no ISS is under or over loaded and therefore guarantees pay-as-you-use access. To guarantee this quality parameter, the instantiation requests should specify the expected number of users as well as the users' arrival rate.
The IVR substrate management engine also allows the resizing of computing and network capacities, using the monitored ISS resource usage. If an ISS is over or under loaded for a certain interval of time, the resource control entity will notify the resource negotiation entity and the ISS computing and network resources are resized. The resource control and negotiation entities are out of the scope of this paper.
N is the expected number of users for a given IVR application.
? is the expected call arrival rate for an ISS. We should mention that ? is used in this paper only to determine the resources needed by an ISS, depending on the number of request/min that it is expected to support.
t n is the size in unit of time for the execution of a given instantiation request (task size). It is the time needed to instantiate, configure, and activate a new ISS.
t r is the time needed to compute the required resources for a given instantiation request. It is the time difference between the end of resource computation for task j and the arrival time of task j in processor queue.
t v is the time needed for the creation, configuration and activation of the appropriate virtual machine that will host a given ISS (t n = t v + t r ).
m is the number of processors that can be used to handle the instantiation requests.
(CPU r , M r , B r , D r ) represents the required resources for a given ISS, in terms of CPU, memory, bandwidth and disk space, respectively.
(CPU c , M c , B c , D c ) represents the available capacities (i.e., the capabilities of the virtualization machine), in terms of CPU, memory, bandwidth and disk space, respectively.
(tcpu, tM, tB, tD) represent the percentage of resource usage for a given ISS:
○ tcpu is the ratio of CPU r over CPU c .
○ tM is the ratio of M r over M c .
○ tB is the ratio of B r over B c .
○ tD is the ratio D r over D c .
Our objective is to propose two algorithms: computational resource sharing and task scheduling. These algorithms will be used by the IVR instance manager and the substrate IVR engine, respectively. The computational resource sharing algorithm should allow the selection of the required resources (CPUr, Mr, Br, Dr) for each ISS, while minimizing the amount of resources used as well as the resource allocation time, and maximizing the satisfactory factor of the ISS using a specific amount of resources. The task scheduling algorithm should minimize the execution time for the instantiation requests (i.e., t n ), by sharing the instantiation requests among the available processors as equally as possible. No processor should be underused while others are overloaded.
Both algorithms are executed during the ISS instantiation, meaning before the IVR application is ready to receive end-users' requests. The task scheduling is first performed by the substrate IVR engine to assign the set of instantiation tasks to a given number of processors, and then each processor will run the computational resource sharing algorithm to select the resources that should be assigned to each ISS to be created. These two algorithms are described in the next section.
Resource management algorithms
Our computational resource sharing and task scheduling algorithms are based on Genetic Algorithm (GA) . In GA, a population of strings randomly generated from a set of potential solutions (represented by chromosomes) is used to create new populations, based on the fitness of each individual in the population and by applying different GA operators, such as selection, crossover and mutation. The algorithm ends when a targeted fitness level is reached for the population.
In this paper, GA is used to optimize 1) the computational resource sharing, and 2) the assignment of instantiation requests to different processors provided by the virtualization machine. For each algorithm, a specific fitness function and specific GA operators are used. In the computational resource sharing algorithm, a population is represented by the resources required by each ISS to instantiate. This population is of limited size (e.g., CPU, memory, bandwidth, disk space). In the task scheduling algorithm, a population is represented by the instantiation requests. The size of the population depends on the number of instantiation requests received by the substrate provider.
We first discuss the computational resource sharing, followed by the task scheduling.
Computational resource sharing algorithm
Each processor performs resource computation for the instantiation request that is assigned to it. As a first step in the definition of the computational resource sharing algorithm for IVR applications, we performed a set of experimental measurements to quantify the resources used by a given number of ISSs. This was done using the prototype from our previous work . The measurements were then used as input to define the load measurement mathematical models and the resource computation algorithm to calculate the required resources for each instantiation request since we don't have access to real arrival rate data from IVR providers. We also defined a resource computation fitness function.
Resource computation allows the computation of the resources to be allocated for each ISS, in terms of CPU, memory, bandwidth, and disc space. It is performed using a GA-based method with the sliding window technique where two dimensional strings are used to represent the resource computation for each task in each processor.
Two dimensional strings are used to represent the resource computation for each task in each processor. One string identifies the resource combination types provided by the virtualization machine and the second identifies the required resources for each task. A resource combination type represents a possible configuration of a virtual machine that could be created by the virtualization machine. These resources can be selected separately to configure a virtual machine that will host an ISS.
Example of resource combination types
Disk space (GB)
Figure 6 shows an example of two-dimensional strings, where each resource in the second string is identified by the resource values , where i is the type of resource (CPU (1), memory (2), bandwidth (3) or disk space (4) and j is the resources allocated to the instantiation request. The resources to be allocated to each instantiation request are identified using the resource computation selection, crossover and mutation methods described in section 5.4.
Resource computation crossover and mutation
Required resources according to the call arrival rate
y CPU (GHz)
y M (MB)
y B (Gbps)
y D (GB)
As a second example, let's consider the case of an instantiation request where λ = 160. This request requires 3.6 GHZ of CPU, 420 MB of memory, 1.05 Gbps of bandwidth and 0.3 GB of disk space. For this request, a virtual machine with resource type R6 will be selected to host the new ISS. The memory, bandwidth and disk space of string R6 are swapped with that of strings R2 (512 MB), R9 (1 Gbps) and R1 (1 GB) respectively, with satisfactory factors τCPU ≌ 1, τM = 0.82, τB ≌ 1 and τD = 0.3.
The substrate IVR engine receives a set of instantiation tasks that should be assigned to a number of processors. We propose to adapt the task scheduling algorithm proposed in  for this purpose. Therefore, we propose to use a GA-based method to perform load balancing and a sliding window technique to initialize a population of tasks on which the GA will be applied . This new algorithm is called ISI GA (Instantiation request scheduling for IVR based on GA). At each time, the tasks that are within the window are reordered using the GA selection, crossover and mutation methods described in Section Task representation selection, crossover and mutation and then assigned to the processors for execution. The window is dragged to the next group, for a repeat of the assignment process, when the tasks within the window are placed in processor queues . We first introduce how the set of available processors and tasks are represented; we then describe our task scheduling fitness function, and end with the task scheduling algorithm.
Processor and task representation
From the experimental measurements we carried out using the implemented prototype and 8 processors, we noticed that the t v value is the same for all ISSs. However, the t r differs from one ISS to another. This is one of the differences between the original scheduling and the adapted algorithms. In the original algorithm (proposed in  and ), the t n value for each individual in a GA population is supposed to be known in advance and is the same for each individual in the population. For the ISS instantiation scheduling, the t v is known in advance but t r should be computed using our proposed computational resource sharing algorithm. This may result in a different t n value for each individual in the same population.
Task representation fitness function
The fitness function allows the evaluation of the task scheduling performance according to specific objectives. The main goal here is to identify task assignments that guarantee maximum processors utilization, to balance the traffic load across processors and to guarantee minimum execution time of tasks.
In , the following objectives apply: 1) a minimization of the largest task completion time (i.e., Maxspan) across processors to guarantee that assignment tasks will be executed in the shortest time possible ; 2) increase of the average processor utilization based on the Maxspan value, and 3) optimization of the number of tasks in each processor queue, in order to ensure proper load balancing across the processors.
We propose to use the difference between the largest and the smallest task completion times rather than the MaxSpan value (as used in  and ) because guaranteeing a minimum TaskSpan value not only ensures a shorter task completion time but also a proper load balancing between all processors.
The utilization factor is then equal to 0.31, but the average utilization value as defined in  will remain unchanged 0.76. Therefore, the greater the utilization factor, the better the load balancing.
The higher the fitness function, the better is the task scheduling. The single objective function f derived from this multi-criterion optimization problem reduces the problem's complexity while satisfying the multiple objectives predefined. Using a single objective function also helps in meeting our requirement on minimizing the execution time for the instantiation requests, as multi-objective functions are known to require a longer processing time.
Task representation selection, crossover and mutation
We propose to reuse the selection, the crossover and the mutation methods described in . The selection operator is based on the roulette wheel method . In this method, the selection of strings in a population is based on their fitness values. These values are used to assign a probability of being selected to each string. These probabilities are computed by dividing the fitness of each string by the sum of the fitness values of the current set of strings in the population. The slots of the roulette wheel are created by adding the probability of the current string to the probability of the previous string. The probabilities are then assigned until the value of 1 is reached. Then, the strings are selected randomly by generating a random number between 0 and 1. To perform the crossover operation, the selected strings are then converted from two dimensions to one. We use this two dimensions string to balance the number of tasks across the processors. For instance, for 12 tasks and 8 processors, this procedure ensures that each processor will have at least one task, and no more than 2 tasks. Hence, 8 tasks are allocated to 8 processors and 4 tasks are randomly assigned to 4 processors. This will allow the GA to converge for a fixed number of generation cycles.
The crossover operator is based on the cycle crossover method . In this case, two one dimension strings S 1 and S 2 are selected. The crossover operation begins by selecting a random starting point between 1 and the length of the strings S 1 and S 2 . Let us assume that this starting point is S 1,n which denotes the task at the position n in string 1. This task is marked as finished, and its corresponding task at S 2,n is then also marked off as finished. The task in S1whose position is the value of S 2,n is marked as finished and its corresponding task in S 2 is then marked off as finished as well. This process ends when the starting point S 1,n is reached once again. Then, the remaining tasks S 1,n that were not marked off are swapped with their corresponding tasks in S 2 (e.g., S 1,4 is swapped with S 2,4 ). When all tasks in the two strings are crossed over, they are reordered and converted to a two-dimensional form to compute their new fitness values.
The third GA operator is based on swap mutation. It randomly selects and then swaps two tasks. Each task is taken on randomly selected processors which should be different in order to ensure that the two selected tasks are not the same. New fitness values are then computed using the population derived from this swapping mutation process.
Performance results and analysis
For the computational resource sharing algorithm, we propose to compare the required resources (CPU r , M r , B r , D r ) with the allocated ones. The required resources are estimated based on Equations (1-2), whereas the allocated ones are estimated using the proposed GA computational resource sharing algorithm. The comparison will allow us to see if the example of resource combination types given in Table 2 and which is usually used in cloud computing environment is suitable to well manage the available resources (CPU c , M c , B c , D c ).
For the instantiation request scheduling algorithm, we compute the total completion times and average processors utilization in order to compare the resource usage efficiency of the proposed fitness function with those analyzed in  (dynamic and random algorithms). We choose to compare with the dynamic algorithm because it is the basis of our algorithm which we enhanced; and with the random algorithm because the dynamic one was compared to it. The different proposed algorithms were simulated using Matlab and the results were measured via the same simulator.
Computational resource sharing
The required and allocated CPU, memory and bandwidth were computed according to the call arrival rate. As described in Table 2, the required resources for call arrival rates less than 60 requests/min are less than 1 GHZ of CPU, 256 MB of memory, 350 Mbps of bandwidth and 1GB of disk space. Because the performance measurements are too small for a small-sized IVR, we computed the required and allocated resources for a large-sized IVR (i.e., for ? ?60 requests/min).
For instance, for λ = 60 requests/min, the required CPU was almost 1.2 GHz and the estimated resource was 1.5 GHZ which represents a typical resource combination type provided by the virtualization machine. The required memory was almost 131 MB and the estimated resource was 256 MB. The required bandwidth was almost 350 Mbps and the estimated resource was 350 Mbps. For its part the required disk space was very small even for higher call arrival rates (e.g., λ = 600 requests/min) always staying under 1GB. This is due to the nature of the IVR applications, which need little disk space. The disk space measurements were therefore not included in this section because the estimated value was the same (i.e. 1 GB).
For λ greater than 350 requests/min, this percentage was more than 95%. The required and the allocated bandwidth were almost the same and the bandwidth usage was almost 100% (Figure 12). The required and allocated memory measurements were different due to the fact that the sizes of the resource combination types were predefined 256, 512, 1024, etc. For instance, for λ = 60 requests/min the required memory was almost 131 MB while the allocated memory was 256. Only half the capacity memory was therefore used. For λ = 100 requests/min, the required memory was almost 500 MB and the allocated memory was 512 MB, representing 97% memory usage. Therefore, for a large-sized IVR, the higher the instantiation request arrival rate, the higher the percentage of CPU and Bandwidth resource usage. Unlike the CPU and bandwidth performance improvement in terms of resource usage, Figures 11 and 12 show that the memory usage was efficient.
Time required allocating resources
Number of IVR instantiation requests
Required time (seconds)
As a conclusion, the resource combination types usually used in cloud environments do not allow for efficient resource usage. New combination types are therefore needed.
Instantiation request scheduling
We computed the total completion times and average processor utilization according to the number of tasks, the sizes of window and number of generation cycles. These performances were compared to dynamic GA as well as to random allocation strategies that were analyzed in .The dynamic algorithm is based on the selection, crossover and mutation methods described in 5.3.
A set of tests were performed using the following default values: 100 instantiation requests, 8 processors, window size of 10 requests, generation cycles of 10 and population size of 10. As instantiation requests' length (t n ) we used 20 units of time for the following three reasons. First, this is the average time measured using the implemented IVR prototype: t v = 6 ms and t r = 14 ms in average given the prototype setup. The second reason is that we wanted to compare our algorithm to those of reference  which use the same task size for all of the individuals in the population. Third, using a fixed t n value will not affect the performance of our algorithm. We have also tested the proposed algorithm for different numbers of generation cycles (10, 20, and 30) and we noticed very slight changes.
Default simulation values
Variation of number of tasks
Variation of window size
Variation of generation size
Number of processors
10 to 60
10 to 60
Number of tasks
0 to 1500
0 to 1500
0 to 1500
The total completion time decreased as the window size was increased and the average processor utilization improved as the window size increased for instantiation request and dynamic algorithms. Moreover, the instantiation request scheduling algorithm outperformed the dynamic scheduling and random algorithms. This performance improvement shows that the increasing number of tasks to be scheduled was well handled by the 8 processors.
However, through the simulation we noticed that after a certain number of generation cycles (~25 cycles), the average processor utilization results are slightly different. This finding can be used to configure an upper limit for the generation cycles, in order to meet our requirement on minimizing the algorithm execution time. Moreover, the instantiation request scheduling performed better than the dynamic and random algorithms. As a conclusion, the proposed instantiation request scheduling algorithm outperforms the dynamic and random algorithms in almost all of the taken measurements. Furthermore, the algorithm performances are enhanced when the windows size is increased and the number of generation cycles increases.
State of the art review
This work joins many efforts devoted to task scheduling and load balancing across processors or computers in non-virtualized and virtualized environments. It complements them by defining new task scheduling and computational resource sharing strategies based on genetic algorithms for virtualized IVR application. Moreover, it proposes new task assignment that guarantees maximum utilization of resources while minimizing the execution time of tasks for virtualized IVR applications. We also propose a resource allocation strategy that minimizes substrate resource utilization and the resource allocation time.
The issue of load balancing based on genetic algorithm in non-virtualized environments has been addressed in -. It has been addressed by Y. Albert Zomaya et al. in  to propose a framework for using genetic algorithm to solve scheduling problem for parallel processor systems and to highlight the condition under which this algorithm outperform the ones based on heuristics. The genetic algorithms proposed in this paper are based on this framework.
In , authors propose task scheduling algorithm to achieve minimum execution time, maximum processor utilization and optimal load balancing across different processors by defining tree objective functions. In this work, we have demonstrated how two of these objective functions did not guarantee minimum execution time and maximum processor utilization and this independently of the virtualized application to which the scheduled tasks belong. We have proposed new objective functions that maximize resource utilization while minimizing task execution time. Several task scheduling methods based on modified genetic algorithm have been proposed -. In ,, authors propose to modify GA to control the task duplication and reduce the length of the processor queues. In , a modified genetic algorithm is proposed to handle task scheduling in parallel multiprocessor systems. Unfortunately, these modified algorithms yield to task scheduling time greater than that obtained with non-modified GA.
In , genetic-based algorithm has been proposed where a dedicated processor has been used to schedule tasks across processors. This paper has shown that this algorithm outperforms a genetic algorithm based on first-in first-out scheduling approach. However, these performances depend on the number and the distribution of tasks being executed. Moreover, it uses the same objective function as defined in . We believe that this objective function that allows minimization of the largest task completion time does not guarantee the minimum execution time.
The load balancing issue based on genetic algorithm has also been addressed in virtualized computing environments ,,. In  and , authors propose to minimize task execution time by using an objective function that minimizes the largest task completion time as defined in  and .
In , author proposes task scheduling algorithm for Hadoop MapReduce framework. This framework is used to satisfy the data-processing needs in environments where high parallel computing and huge data storage are needed. The proposed genetic algorithm is based on statistical prediction model KCCA (Kenel Canonical Correlation Analysis) to identify the expect task execution time ,. However, this paper neither describes how KCCA is used to predict the task execution time nor gives performance analysis of such algorithm. In , authors have described a non-genetic scheduling algorithm based KCCA and demonstrated that KCCA could be a good prediction mechanism. They stress the need for the task scheduling in Hadoop but not for optimizing resource usage in cloud environment (ex., CPU, memory, etc.). In our work, we have addressed this issue too. This issue has been also neglected by some research projects on grid computing ,. Several research projects tackle the task scheduling issue in cloud for many applications like workflow and e-learning applications -, but no resource optimization mechanism is provided in order to guarantee both efficient task scheduling and resource usage. Finally to the best of our knowledge, these two issues have been recently addressed in .
Our work is similar to this effort in that it considers the optimization of each required resource (CPU, memory, disk space, Bandwidth) according to specific applications needs: IVR application.
This paper proposes two resource management-related algorithms for virtualized IVR applications. The first algorithm concerns computational resource sharing, whereas the second relates to the scheduling of IVR application instantiation requests. Both algorithms are GA-based and they both consider several objectives regarding the optimization of resource usage and sharing at the substrate layer. The scheduling algorithm maximizes resources utilization while minimizing task execution time. The computational resource sharing algorithm minimizes the substrate resource utilization and the resource allocation time while maximizing the satisfactory factor of IVR applications.
The performance measurements conducted showed that the proposed algorithms are promising. Indeed, compared to dynamic and random algorithms, the proposed instantiation request task scheduling GA outperformed in terms of total completion time and average processors utilization. The computational resource sharing algorithm allows efficient CPU and bandwidth usage. However, due to the resource combination types used and because the memory resource needs are small for IVR applications, the memory resource usage was not that efficient.
NK developed the proposed algorithms for computational resource sharing and task scheduling of virtualized IVR application, analyzed the obtained results and helped in the design of a virtualized IVR platform and wrote and reviewed this manuscript. MS implemented and tested the proposed algorithms and helped in the development of a virtualized IVR platform. FB designed a virtualized IVR platform and helped in the development of this platform and in reviewing this manuscript. CA helped in the development of a virtualized IVR platform and in the implementation and the testing of the proposed algorithms. RG helped in the design of virtualized IVR platform and reviewing this manuscript. All authors approved the final manuscript.
NK would like to thank the research funding organization NSERC which helped us by giving us financial support to conduct this research.
- Xu S, Gao W, Li Z, Zhang S, Zhao J (2010) Design of Hierarchical and Configurable IVR System. Second International Conference on Computational Intelligence and Natural Computing Proceedings (CINC), pp 205-208Google Scholar
- Khan A, Zugenmaier A, Jurca D, Kellerer W: Network Virtualization: A Hypervisor for the Internet? IEEE Commun Mag 2012, 50(1):136–143.View ArticleGoogle Scholar
- Vaquero LM, Rodero-Merino L, Caceres J, Lindner M: A break in the clouds: towards a cloud definition. ACM SIGCOMM Comp Commun Rev 2009, 39(1):50–55.View ArticleGoogle Scholar
- Belqasmi F, Azar C, Soualhia M, Kara N, Glitho R (2011) A Virtualized Infrastructure for Interactive Voice Response Applications in the Cloud. ITU-T Kaleidoscope the Fully Networked Human - Innovations for Future Networks and Services, pp 1-7Google Scholar
- Belqasmi F, Azar C, Soualhia M, Kara N, Glitho R: A case study of Virtualized Infrastructure and its accompanying platform for IVR Applications in Clouds. IEEE Network Mag 2013, 28(1):33–41.View ArticleGoogle Scholar
- Zomaya YA, The YH: Observation on using genetic algorithms for dynamic load-balancing. IEEE Trans Parallel Distributed Syst 2001, 12(9):899–911.View ArticleGoogle Scholar
- Xhafa F, Carretero J, Abraham A: Genetic Algorithm Based Schedulers for Grid Computing Systems. Int J Innovative Comput, Inf Control 2008, 3(5):1–19.Google Scholar
- Kidwell MD, Cook DJ (1994) Genetic Algorithm for Dynamic Task scheduling. Proc. IEEE 14th Annual International Phoenix conference on Computers and communications, pp 61-67Google Scholar
- Carretero J, Xhafa F: Genetic algorithm based schedulers for grid computing systems. Int J Innovative Comput, Inf Control 2007, 3(6):1–19.Google Scholar
- Goldberg DE (1989) Genetic algorithms in search, optimization, and machine learning", Reading, Mass. Addison-Wesley. ISBN 0201157675Google Scholar
- Zomaya AY, Ward C, Macey B: Genetic Scheduling for parallel processor systems: Comparative studies and performance issues. IEEE Trans Parallel Distributed Syst 1999, 10(8):795–812.View ArticleGoogle Scholar
- Kaur K, Chhabra A, Singh G: Heuristics based genetic algorithm for scheduling static tasks in homogeneous parallel system. Int J Comput Sci Secur 2010, 4(2):149–264.Google Scholar
- Omara FA, Arafa MM: Genetic algorithms for task scheduling problem. J Parallel Distributed Comput 2010, 70(1):13–22.View ArticleMATHGoogle Scholar
- Probir R, Mejbah Ul Alam MD, Nishita D: Heuristic based task scheduling in multiprocessor systems with genetic algorithm by choosing the eligible processor. Int J Distributed Parallel Syst (IJDPS) 2012, 3(4):111–121.View ArticleGoogle Scholar
- Prabhu S: Multi-Objective Optimization based on genetic algorithm in Grid Scheduling. Int J Advanc Res Technol 2011, 1(1):54–58.Google Scholar
- Tayal S: Tasks scheduling optimization for the cloud computing systems. Int J Advanc Eng Sci Technol 2011, 5(2):111–115.MathSciNetGoogle Scholar
- Bach FR, Jordan MI: Kernel independent component analysis. J Mach Learn Res 2003, 3: 1–48.MathSciNetMATHGoogle Scholar
- Ganapathi A, Kuno H, Daval U, Wiener J, Fox A, Jordan M, Patterson D: Proceedings of IEEE International Conference on Data Engineering. 2009.Google Scholar
- Ganapathi A, Chen Y, Fox A, Katz R, Katz R, Patterson D (2010) Statistics-driven workload modeling for the cloud. 26th IEEE International Conference on Data Engineering, pp 87-92Google Scholar
- Gao Y, Rong H, Huang JZ: Adaptive grid job scheduling with genetic algorithms. Elsevier J Future Generation Comp Syst 2005, 21(1):151–161.View ArticleGoogle Scholar
- Kim S, Weissman JB (2004) A genetic algorithm based approach for scheduling decomposable data grid applications. International Conference on Parallel Processing, pp 406-413Google Scholar
- Barrett E, Howley E, Duggan J: A learning architecture for scheduling workflow applications in the cloud. 9th IEEE European Conference on Web Services, 83; 2011.View ArticleGoogle Scholar
- Yu J, Buyya R: Scheduling scientific workflow applications with deadline and budget constraints using genetic algorithms. Sci Programming J 2006, 14(3):217–230.View ArticleGoogle Scholar
- Morariu O, Morariu C, Borangiu T: A genetic algorithm for workload scheduling in cloud based e-learning. Proceedings of the 2th International Worshop on Cloud Computing Platforms 2012, 1–6.View ArticleGoogle Scholar
- Zhong H, Tao K, Zhang X (2010) An approach to optimized Resource scheduling algorithm for Open-Source Cloud Systems. The 5th Annual China Grid Conference, pp 124-129Google Scholar
This article is published under license to BioMed Central Ltd. This is an Open Access article distributed under the terms of the Creative Commons Attribution License (http://creativecommons.org/licenses/by/4.0), which permits unrestricted use, distribution, and reproduction in any medium, provided the original work is properly credited.