Grid Resource Allocation with Genetic Algorithm Using Population Based on Multisets

1 Introduction

The problem of selecting and allocating grid computing resources that are distributed across geographical locations to user applications is very complex, especially when the network capacities linking each of the execution sites vary. Most often, the information regarding user application resource requirement demands is often not fully provided. In other words, job resource requirement information is not fine grained such that the scheduler is unable to make decision as per which resources are best suited for executing a specific grid application.

Generally, equipping the scheduler with sufficient information, either on the side of the resource provider with regard to the available resource configuration information or on the side of the grid user with regard to the resource requirement demands of the application, can drastically improve the performance of the scheduling tasks positively, while the lack of it will affect the process negatively. Resource allocation in grid environments is significantly complicated by the heterogeneous and dynamic nature of grids. In general, the resource information is an important part of the input data to the performance model. More so, it is usually very difficult to obtain performance model of each resource across multiple sites due to these uncertainties.

In Ref. [24], grid computing is said to have a layered architecture that is divided into two-level hierarchy of scheduling. In the first level, the global scheduler assigns submitted user applications to remote resources, after which the local schedulers would generate schedules for the local resources that they manage. The global scheduler has limited knowledge of the potential capacity of the available local resources and likewise has no control over them. On the other hand, the local scheduler seems to be unaware of other resources available to the user applications and has also no knowledge of other submitted applications that subsequently require the services of these available resources.

The essence of the above paragraph is to emphasize the difference that exists between resource allocation and scheduling. Resource allocation here simply means the assignment of jobs (tasks) to the corresponding resources. Resource allocation may involve data staging and binary code transferring before the job starts execution. On the other hand, scheduling is the allocation of jobs to a resource over a period of time [24]. It is also interesting to note that grid scheduling procedure roughly comprises four phases: information collection, resource selection, job mapping, and resource allocation [8, 35]. These concepts will be explained in detail in the subsequent section.

In this paper, a proposal is made to apply the concept of a multiset genetic algorithm (MGA) [16] to address the problem of resource allocation in the grid computing environments. The essence of this hybridization is to enhance genetic algorithm (GA) performance to solve combinatorial optimization problem, specifically grid resource allocation. Another advantage of the proposed hybridization is the use of population-based multiset to control the growing population pool of individuals that are maintained by GA. Relevant discussions on GA and their applications are presented in Refs. [12, 13, 14, 30, 34].

In this work, a computational grid is considered to be made up of clusters of computing nodes. A cluster is said to consist of multiplicities of execution points or machines that are either homogeneous or heterogeneous in terms of system and performance configurations. Based on this assumption of the grid properties, the proposed resource allocation model is addressed in this paper.

The remainder of the paper is organized as follows. In Section 2, we present the related work. In Section 3, we present the research problem formulation. Section 4 describes the proposed system. Sections 5 and 6 present the proposed approach to solve the resource allocation problem: MGA, resource matching model, and indexed-based search procedure. Section 7 reports on the experimental configuration and computational results. Section 8 presents concluding remark and future direction.

2 Related Work

Resource matching and allocation using hybrid GAs are well-studied areas of research [6, 8, 17, 19, 22, 25, 32] and still are the subject of many studies. In Ref. [3], scheduling heuristics for dynamic job scheduling on large-scale distributed systems was addressed. The heuristics comprised of hybridization of GA, simulated annealing (SA), and Tabu Search (TS). In these hybridizations, a population-based heuristic, such as GA, is combined with two other local search heuristics, such as TS and SA, which deal with only one solution at a time. In Ref. [23], a hybrid GA and variable neighborhood searches (VNS) named GA-VNS are presented for static scheduling of independent tasks within grid environments. The main objective of the proposed algorithm is to reduce the overall cost of task executions without any significant increment in system makespan.

GAs for scheduling are addressed in several works [1, 2, 9, 10, 15, 18, 33, 38]. Some hybrid heuristic approaches have also been reported for the problem. Thus, Abraham et al. [3] addressed the hybridization of GA, SA, and TS heuristics for dynamic job scheduling on large-scale distributed systems. In these hybridizations, a population-based heuristic such as GAs is combined with two other local search heuristics, such as TS and SA, which deal with only one solution at a time.

The motivation behind this paper came from the concept of using population based on multisets to address the problem of traditional representation of population that is often used in evolutionary algorithms [26]. The two main problems identified are the loss of genetic diversity during evolutionary process and the evaluation of redundant individuals [26, 36]. In this paper, the authors proposed a computational representation of populations based on multisets and the adaptation of a GA, referred to as MGA, to deal with this type of representations. Similar work that minimizes the problem of traditional representation of populations used in evolutionary algorithms can be seen in Refs. [4, 5]. Each of this related work presented new formal models for multiset representation of individuals and their populations, which addresses the aforementioned problem. Also, a valuable reference for multisets and their multi-faceted applications can be seen in Refs. [7, 21, 35, 37].

3 Problem Formulation

In this paper, the problem of allocating jobs to highly ranked grid resources is considered. This is achieved by taking into consideration user job resource requirements, job priorities, job-specific preferences, resource capabilities, resource utilization, and resource throughput. Two types of jobs are considered in this paper, CPU-bound (or compute-intensive) jobs and memory-bound (or data-intensive) jobs. Usually, jobs are submitted alongside with their requirements. A job is considered as a single unit of work within a grid application, which is typically allocated to be executed on available resource. In essence, a job consists of an executable statement, a request, and some input data. A job requirement specifies the resource requirements and preferences to execute the job.

The grid resource types considered in this paper are basically computational systems, storage servers, and network servers. Each of these set of resource types is associated with one or more attributes with specific values. Examples of associated attributes for a typical computational resource include processing speed “ps”, available memory size “ms”, associated I/O bandwidths “bw”, and so on. For the storage and network resources, varying or fixed memory capacities and network bandwidth strengths are the essential attributes considered as most relevant.

For every job submitted for execution in the grid, there is an associated job requirement that depends on some corresponding dependencies and constraints associated with each dependency on a resource instance of a particular resource type. One main dependency considered in this paper is the number of resource type that a job may require, with varying constraints on the selected resource capacities. For example, a job resource requirement with dependencies on two computational nodes may specify minimum CPU speed of 1.33 MHz, 300 MB available memory, and 200 MBps of link bandwidth for the first node and CPU speed of 3.33 MHz, 500 MB available memory, and 400 MBps of link bandwidth for the second node as constraints.

The above problem formulation can be summarized using the following parameterized steps:

1. Let J={j₁, j₂, …, j_i }, i=1, 2, …, m be the set of jobs to be matched to suitable candidate resources.

2. Let R={r₁, r₂, …, r_j }, j=1, 2, …, n be the set of available candidate resources.

3. Every job J_i ∈J is assigned a priority, which depends on the capacity of the required resources attributes t={ps, ms, bw}.

4. H_{(rj, tk)} defines the capacities of the resource attributes of type t_k for resource r_j ∈R. Therefore, H(rj, tk) =  ∑j = 1kt, where t={ps, ms, bw}∈ℝ.

5. Γ_{(ji, tk)} defines the equivalent resource capacity required by the user job i for each J_i ∈J.

The variable S_i,j =0, 1 for each job J_i ∈, defines the probability (in terms of success or failure) of matching a job to a specific resource, where S_i,j =1 if J_i is matched to the required resource r_j ∈R, and S_{i, j} =0, if otherwise.

These lists of parameters are applied to the adaptive resource matching model described in Section 6. Similarly, the model is introduced as an additional adaptive matching operator to the proposed GA resource allocation system described in this paper.

Nevertheless, the paper proposes an alternative resource allocation mechanism that efficiently addresses the general resource selection problem in a typical grid computing environment. An adaptation to a GA-based multiset population is introduced. The proposed job resource allocation mechanism uses the multiset-based population indexing to group and coordinate the allocation of available related resources that satisfy the resource requirements of a specific user job. In this paper, a grid node is expressed as a collection of resources in which those resources have multiple occurrences. Therefore, the cardinality property and other related operation on multiset are exploited to maximize utilization of grid resource. In the next section, a description of the proposed system is presented and discussed.

4 System Description

The proposed efficient resource selection model is presented and described in this section. The model comprises of three major phases of scheduling tasks. The first phase is the job analysis and requirement gathering phase, the second phase is the resource selection and allocation phase, while the third phase is the job execution phase. Figure 1 gives the detailed description of the schematic flow of the resource allocation model. Next are the explanations of each of the three main phases aforementioned.

Figure 1:

Optimization Algorithm Operators.

5 GA Parameters

Algorithm: The GA starts with a population that is made up of individuals, representing basic solution to the problem usually in the form of a bit vector {P₀, P₁, …, P_max}, where each population comprises of m entries {R₁, R₂, …, R_m } and each entry R_i ={r_k , s, t, 1≤k≤n and r_k ={0, 1}}. Let {r₁, r₂, …, r_n } represents the set of unique resources that are available. The selection probability={0, 1}, where the selected resources are represented by the value 1 and the unselected resources are represented by the value 0. The chromosome fitness values in a given population are evaluated based on the computational capability (or processing power) associated with the specific resource (see equation 4). Subsequently, the fitness function fitness(R*) defined later in this section is used to compute and store the best-fit chromosome generated from a given population.

In dealing with the GA, the outlined solutions are only possible where the minimum attribute specification requirement of each resource has been chosen to be allocated. The solutions are generated using the best-fit heuristics from the bin-packing problem. The heuristic is strictly deterministic; it starts by considering the first resource to see whether it can be allocated to the user job, and if not, it moves on to the second resource and so on. In order to generate more different solutions, the crossover rate, mutation rate, and the resource selection scheme are changed by doing a random permutation. To avoid population flooding, a rescaling operator is introduced as part of the genetic operator to control the number of copies of the individuals. After this initialization step, an iterative process (each cycle of it is called a generation) that involves the following pseudocode is performed (Figure 2).

Figure 2:

Pseudo-code of the Genetic Algorithm Scheduling Steps.

The essence of introducing the repair operator is to ensure that all bits of the chromosomes do not exceed 1, when the fitness exceeds the desired capacity. The repair operator achieves this by making all the bit of the chromosome equal to 0 at the point when the fitness operator exceeds the desired capacity. These steps are all tunable by some parameters, resulting in different instances of the same GA. We discuss each of these steps in the following paragraphs.

6 Adaptive Selection Operator

In general, there is a need to overcome the problem of premature convergence associated with GAs, that is, the situation where a population under consideration reaches a suboptimal state, in which case the offspring is often observed to be inferior to the parent individual. In this paper, some string matching and scheduling operators of computing resources have been introduced to overcome this problem. These operators include the mutation operator explained earlier in Section 5 and two other main additional operators, the adaptive selection operator and the indexing operator. The last two operators are afterward explained in details.

6.2 Indexed-Based Resource Searching Operator

The resource indexing method involves storing records in sequential order and incorporating a file indexing mechanism along with the sorted resource list. A file index is a list of key/block pairs arranged with the keys in a specific order.

Resources are sorted based on the following linear inequalities (see equation 10). Two resource nodes R₁ and R₂ are said to be unequal if R₁≠R₂; similarly, the following conditions follow if, for any resource component r,

(10)∑ri ∈ R1mR1(ri, ti) > ∑rj ∈ R2mR2(rj, tj), if R1 > R2 and R1 ≠ R2∑ri ∈ R1mR1(ri, ti) < ∑rj ∈ R2mR2(rj, tj), if R1 < R2 and R1 ≠ R2,∑ri ∈ R1mR1(ri, ti) ≤ ∑rj ∈ R2mR2(rj, tj), if R1 ≤ R2

where the multiplicity of r in R is denoted by m_R (r) and t represents the attribute capacities of r∈R, expressed as t={ps, ms, bw}.

The resource list entries and the index are arranged sequentially according to the resource rank values. The original records on the resource list can be arranged in any convenient order based on the initial sorting criteria. This usually means that new records are simply appended to the end of the file, so the records are ordered by the time of insertion. The index mechanism, however, provides direct access to the sorted resource list instead of relying on the traditional sequential access method often used by schedulers to locate candidate resources.

One main advantage of the indexing mechanism is that multiple indices, each with a different key, can be created for the same record file. In one index, the key can be the resource processing speed value; in another, it can be the resource memory size value or even the required communication network bandwidth value. Because the indices are small compared with the resource file itself, therefore, they do not increase the total data storage of the overall system memory.

The resource indexing approach is based on the following steps:

1. Start with the resource with rank R₁ in the indexed list to the resource whose rank value is less than the targeted rank by 1. Next, get the summation of all the resource(s) pair numbers.

2. The “block number” gives the summation of all the rank pair positions, which represent the index of the first resource having the required rank value equal to or greater than the job resource requirement rank value.

An indexing example: From the illustration depicted in Figure 3, in finding a candidate resource that matches the job resource request of rank 4 (R₄), the process is done in such a way that the summation=4+2=6 fetches the index of the targeted resource rank. As shown in the illustration below, index 6 is the index of the first resource with rank 4 because there is no resource for rank 3. Similarly, to find a suitable resource for a job with request for a resource of rank 6(R₆), the summation=4+2+3+6=15 gives index 15, which points to the index of the first resource with rank 6.

Figure 3:

Resource Searching With Indexer.

To insert a new ranked resource item in an indexed file, two steps are necessary:

1. First step is to insert its full record into the main file.

2. Second step is to insert an entry, consisting of the key and the block number where the new record is stored, into the index.

7 Experimental Configuration

Simulation and evaluation of environment are constructed to evaluate the MGA resource allocation technique. The simulation process was performed on the MATLAB platform with several resource state repositories. One type of resource was considered for this experiment, which is the compute server (with the following attributes: processing speed, memory size, and associated bandwidth). Six of the compute server resource instances were defined. The resource instances belonging to the same resource type differ in their total and available capacities that can be consumed by a user-submitted job. The user job somewhat consists of request log that includes certain specified resource requirement attributes such as resource processing speed, memory size, and associated i/o bandwidth.

The arrival of jobs at a time interval is modeled as Poisson random process given by

where λ is the average number of jobs that have arrived in a given time interval, the random variable t represents the number of jobs arriving in a given time interval (0, 1, 2, …), and e=2.71828.

The number of jobs submitted was varied at a time in a batch. The time between the submission of a batch of jobs and the return of matched results was measured. The simulation was performed for ten batches of jobs evaluated for 20 iterations. The fitness function returns the best available resource that matches the user job. An individual resource in the population pool of resources is randomly selected, and any two jobs in that chromosome are randomly selected and swapped. This approach ensures that all the solutions in the search space are more thoroughly examined. The evaluation is determined by taking the average over the 20 iterations. Figure 4 shows the comparative evaluation result obtained on resource selection using classical GA (CGA), mGA, GA-simulated annealing (GA-SA) and GA-Tabu Search (GA-TS) scheduling heuristics.

Figure 4:

Comparison of Resource Scheduling Time for CGA, MGA, GA-TS, and GA-SA.

In a related simulation experiment conducted, the new scheduling heuristic is compared with the performance of a CGA and two other hybrid heuristic algorithms, GA-SA and GA-TS, as presented in Ref. [31]. The simulation has been executed for three randomly generated grid jobs, which appear in batches of 20, 60, and 100, respectively. The gird resource environment consists of 30 resources (processors) from cluster of computational nodes. The three search heuristics were subjected to the same number of resources, iteration, and execution time epoch for each of the problem sets, and the average execution time taken to converge is computed

The simulation results for the four search heuristics execution for each of the three problem sets were computed and compared, as shown in Figure 5. Analysis of the four results shows that the CGA took more time to reach its best solution with fitness of 125 s, next is the GA-TS with an average execution time convergence of 121 s, followed by GA-SA with fitness of 116 s, while the MGA had its best solution at 110 s for the first problem. For the second problem with 60 job pool, the CGA is still outperformed by the remaining three hybrids GAs, with MGA having the least average execution time of 158 s. For the third problem with job pool of 100, CGA shows its convergence in best solution fitness of 219 s, whereas MGA achieved 173 s in the same interval and continues its reduction. Achieving better solutions by MGA is obvious when compared with the remaining two search heuristics. The additional cost of computation by MGA in the process of searching and selecting the best resources presents a drawback in terms of search speed of the proposed system. However, the general goal is to achieve high precision in the selection of most suitable resource for the user-submitted jobs.

Figure 5:

Average Convergence Time for Four Search Algorithm.

Additional empirical study was carried out for the purpose of evaluating the proposed resource selection scheme. This was intended to estimate the performance of varied number selected grid resources in the range of 50, 250, …, 3000 by the proposed model over 400 jobs. Three scheduling metrics were considered, and they include makespan (scheduling length), throughput, and turnaround time. Each of these metrics is computed as follows:

where the finish time of the job ji on resource rj can be defined as

where sizeOf(ji)fitness(rj) denotes the execution time of job j_i on resource r_j , startTime(j_i , r_j) denotes the start time of job j_i on resource r_j , and finishTime(j_i , r_j) denotes the completion time of job j_i on resource r_j .

In evaluating the performance of the system, two considerations are made. The first is by considering scheduling of selected resource using the proposed MGA with adaptive selection scheme (GA_AS), and the second, by considering the same process using GA with non-adaptive selection scheme (GA_NAS). The result is presented in Figure 6. Simulation result shows that both makespan and turnaround time were significantly reduced with the GA_AS as against the GA_NAS approach (Figure 6A,B). The makespan obtained by using the GA_AS has approximately 3.81% reduction in scheduling length, as compared to the GA_NAS, which has approximately 2.77% reduction. In the case of the turnaround time, the minimum simulation time recorded using GA_AS has approximately 2.86% reduction and 1.61% for GA_NAS. Also, the system throughput was maximized using the GA_AS as against the GA_NAS scheme (Figure 6C). For the GA_AS scheme, 10.45% was recorded as the optimal throughput, while 9.40% was recorded as the maximum throughput for the GA_NAS scheme.

Figure 6:

Performance Comparison of Resource Allocation by GA-AS and GA-NAS. (A) Makespan. (B) Turnaround time. (C) Throughput.

In summary, the MGA procedure is a heuristic search algorithm that attempts to optimize the resource allocation schedule. The proposed heuristic has been demonstrated via experiment to have some interesting characteristics, which include the following:

1. The heuristic attempts to improve upon the existing traditional GAs by integrating two optimization techniques, population-based multisets and adaptive resource matching techniques.

2. It considers user job resource requirement as a major priority for its GA search processor.

3. It applies efficient search procedure that arrives at solutions by searching only a small fraction of the total search space.

4. Procedures and objective functions depend upon the activities of a scheduling system and work with the system input data sets that are based on instantaneous access and, therefore, have costs implied by the calculated instants.

5. Performance efficiency depends upon the computational cost function (e.g. see operator-fitness function).

8 Conclusion and Future Work

A formal model for the selection and allocation of highly ranked grid resources in a distributed computing environment is proposed. Similarly, a search technique to find an approximate solution is also developed. In the simulation experiment carried out, the MGA search heuristics performed best compared to the classical GA, GA-SA, and GA-TS solution methods on the problems of optimal resource allocation with complex resource mix. The additional operators introduced into the system did not alter the GA performance. In fact, it made the problem easier for the GA to expand its search horizon within a limited time frame. This suggests that the MGA is well-suited for more complicated optimization problems, as the case may be with heterogeneous grid resource allocation. Future work will consider finding structure characterization of real distributed system to evaluate and fine-tune the additional genetic operators introduced in this paper and then compare it against the proposed heuristic. Furthermore, work that includes the consideration of more dynamic factors that will further improve the efficiency of the selection process is worth studying.