Combinatorial Challenges and Algorithms in New Energy Aware Scheduling Problems

We consider a scheduling problem that abstracts a model of demand response management in a smart grid. We investigate the problem with a set of unrelated machines, and each job j (representing a client demand) is characterized by its release date, and its power request function expressing its request demand at specific times. Each machine has an energy power function, and the energy cost incurred at a time depends on the load of the machine at that time. The goal is to find a non-migrative schedule that minimizes the total energy. We give a competitive algorithm for the problem in the online setting where the competitive ratio depends (only) on the power functions of machines. In the setting with typical energy function $$P(z) = z^{\nu }$$ , the algorithm is $$\varTheta (\nu ^{\nu })$$ -competitive, which is optimal up to a constant factor. Our algorithm is robust in the sense that the guarantee holds for arbitrary request demands of clients. This enables flexibility on the choices of clients in shaping their demands—a desired property in a smart grid. We also consider a particular case in the offline setting in which jobs have unit processing time, constant power request, and identical machines with energy function $$P(z) = z^{\nu }$$ . We present a $$2^{\nu }$$ -approximation algorithm for this case.

We investigate the power of migration in online scheduling for parallel identical machines. Our objective is to maximize the total processing time of accepted jobs. Once we decide to accept a job, we have to complete it before its deadline d that satisfies d >= (1+epsilon)p + r, where p is the processing time, r the submission time and the slack epsilon > 0 a system parameter. Typically, the hard case arises for small slack epsilon << 1, i.e. for near-tight deadlines. Without migration, a greedy acceptance policy is known to be an optimal deterministic online algorithm with a competitive factor of (1+epsilon)/epsilon (DasGupta and Palis, APPROX 2000). Our first contribution is to show that migrations do not improve the competitive ratio of the greedy acceptance policy, i.e. the competitive ratio remains (1+epsilon)/epsilon for any number of machines. Our main contribution is a deterministic online algorithm with almost tight competitive ratio on any number of machines. For a single machine, the competitive factor matches the optimal bound of (1+epsilon)/epsilon of the greedy acceptance policy. The competitive ratio improves with an increasing number of machines. It approaches (1+epsilon) ln((1+epsilon)/epsilon) as the number of machines converges to infinity. This is an exponential improvement over the greedy acceptance policy for small epsilon. Moreover, we show a matching lower bound on the competitive ratio for deterministic algorithms on any number of machines.

In global supply chain, the scheduling problems of large products such as ships, airplanes, space shuttles, assembled constructions, and/or automobiles are complicated by nature. New scheduling systems are often developed in order to reduce inherent computational complexity. As a result, a problem can be decomposed into small sub-problems, problems that contain independently small scheduling systems integrating into the initial problem. As one of the authors experienced, DAS (Daewoo Shipbuilding Scheduling System) has adopted a two-layered hierarchical architecture. In the hierarchical architecture, individual scheduling systems composed of a high-level dock scheduler, DAS-ERECT and low-level assembly plant schedulers, DAS-PBS, DAS-3DS, DAS-NPS, and DAS-A7 try to search the best schedules under their own constraints. Moreover, the steep growth of communication technology and logistics enables it to introduce distributed multi-nation production plants by which different parts are produced by designated plants. Therefore vertical and lateral coordination among decomposed scheduling systems is necessary. No standard coordination mechanism of multiple scheduling systems exists, even though there are various scheduling systems existing in the area of scheduling research. Previous research regarding the coordination mechanism has mainly focused on external conversation without capacity model. Prior research has heavily focuses on agent-based coordination in the area of agent research. Yet, no scheduling domain has been developed. Previous research regarding the agent-based scheduling has paid its ample attention to internal coordination of scheduling process, a process that has not been efficient. In this study, we suggest a general framework for agent-based coordination of multiple scheduling systems in global supply chain. The purpose of this study was to design a standard coordination mechanism. To do so, we first define an individual scheduling agent responsible for their own plants and a meta-level coordination agent involved with each individual scheduling agent. We then suggest variables and values describing the individual scheduling agent and meta-level coordination agent. These variables and values are represented by Backus-Naur Form. Second, we suggest scheduling agent communication protocols for each scheduling agent topology classified into the system architectures, existence or nonexistence of coordinator, and directions of coordination. If there was a coordinating agent, an individual scheduling agent could communicate with another individual agent indirectly through the coordinator. On the other hand, if there was not any coordinating agent existing, an individual scheduling agent should communicate with another individual agent directly. To apply agent communication language specifically to the scheduling coordination domain, we had to additionally define an inner language, a language that suitably expresses scheduling coordination. A scheduling agent communication language is devised for the communication among agents independent of domain. We adopt three message layers which are ACL layer, scheduling coordination layer, and industry-specific layer. The ACL layer is a domain independent outer language layer. The scheduling coordination layer has terms necessary for scheduling coordination. The industry-specific layer expresses the industry specification. Third, in order to improve the efficiency of communication among scheduling agents and avoid possible infinite loops, we suggest a look-ahead load balancing model which supports to monitor participating agents and to analyze the status of the agents. To build the look-ahead load balancing model, the status of participating agents should be monitored. Most of all, the amount of sharing information should be considered. If complete information is collected, updating and maintenance cost of sharing information will be increasing although the frequency of communication will be decreasing. Therefore the level of detail and updating period of sharing information should be decided contingently. By means of this standard coordination mechanism, we can easily model coordination processes of multiple scheduling systems into supply chain. Finally, we apply this mechanism to shipbuilding domain and develop a prototype system which consists of a dock-scheduling agent, four assembly- plant-scheduling agents, and a meta-level coordination agent. A series of experiments using the real world data are used to empirically examine this mechanism. The results of this study show that the effect of agent-based platform on coordinated scheduling is evident in terms of the number of tardy jobs, tardiness, and makespan.

An efficient assignment and scheduling of tasks of a multiprocessor program is one of the key elements in the effective utilization of multiprocessor systems. This problem being hard to solve exactly, is the reason that so many heuristic methods for finding a suboptimal schedule exist (Hou et al., 1994; Tsuchiya et al., 1997). This paper addresses the problem of multiprocessor scheduling represented as a directed acyclic task graph (DAG) without communication costs to fully connected multiprocessors. We proposed an algorithm, called PGA/SPF (Priority-based Genetic Algorithm/Shortest Processor First schedule) where a priority-based genetic algorithm is improved with the introduction of some knowledge about the scheduling problem, which is represented by the use of genetic operators as crossover and mutation operators. And, a new mapping method, shortest processor first schedule, assigns the selected task to a processor that can minimize a task execution time efficiently. The proposed algorithms generate similar or even better solutions than the previous algorithms in terms of the completion times of the resulting schedules.

In job shop scheduling problems, the previously used nonpreemptive schedules are semiactive, active, and non-delay schedules, and they are initially designed for traditional scheduling performances and do not take energy efficiency into consideration. To fill the gap, this article presents a novel class of nonpreemptive schedules by investigating the special properties of job shop scheduling problems. Then, an energy-efficient generation procedure of the novel nonpreemptive schedules and the standby policy are proposed. An improved genetic algorithm is introduced with three superior features, including the elitist selection, the improved generation alternation model, and the operator decision mechanism. The Friedman test and the Holm multiple comparison test are conducted on experimental results to determine the appropriate parameter for the proposed genetic algorithm. Finally, the computation results and two-sample t-tests show that both energy-efficient generation procedure and standby policy help to reduce energy consumption without worsening production efficiency.

The work undertaken in this thesis is about the integration of two well-known methodologies: Petri net (PN) model Ii ng/analysis of industrial production processes and Artificial Intelligence (AI) optimisation search techniques. The objective of this integration is to demonstrate its potential in solving a difficult and widely studied problem, the scheduling of Flexible Manufacturing Systems (FIVIS). This work builds on existing results that clearly show the convenience of PNs as a modelling tool for FIVIS. It addresses the problem of the integration of PN and Al based search methods. Whilst this is recognised as a potentially important approach to the scheduling of FIVIS there is a lack of any clear evidence that practical systems might be built. This thesis presents a novel scheduling methodology that takes forward the current state of the art in the area by: Firstly presenting a novel modelling procedure based on a new class of PN (cb-NETS) and a language to define the essential features of basic FIVIS, demonstrating that the inclusion of high level FIVIS constraints is straight forward. Secondly, we demonstrate that PN analysis is useful in reducing search complexity and presents two main results: a novel heuristic function based on PN analysis that is more efficient than existing methods and a novel reachability scheme that avoids futile exploration of candidate schedules. Thirdly a novel scheduling algorithm that overcomes the efficiency drawbacks of previous algorithms is presented. This algorithm satisfactorily overcomes the complexity issue while achieving very promising results in terms of optimality. Finally, this thesis presents a novel hybrid scheduler that demonstrates the convenience of the use of PN as a representation paradigm to support hybridisation between traditional OR methods, Al systematic search and stochastic optimisation algorithms. Initial results show that the approach is promising.

In 2005 Li~et~al. gave a \(\phi\)-competitive deterministic online algorithm for scheduling of packets with agreeable deadlines~\cite{DBLP:conf/soda/LiSS05} with a very interesting analysis. This is known to be optimal due to a lower bound by Hajek~\cite{Hajek-det-lb}. We claim that the algorithm by Li~et~al. can be slightly simplified, while retaining its competitive ratio. Then we introduce randomness to the modified algorithm and argue that the competitive ratio against oblivious adversary is at most (\frac{4}{3}\). Note that this still leaves a gap between the best known lower bound of \(\frac{5}{4}\) by Chin~et~al.~\cite{DBLP:journals/algorithmica/ChinF03} for randomized algorithms against oblivious adversary.

As a main distributed computing system, Spark has been used to solve problems with more and more complex tasks. However, the native scheduling strategy of Spark assumes it works on a homogenized cluster, which is not so effective when it comes to heterogeneous cluster. The aim of this study is looking for a more effective strategy to schedule tasks and adding it to the source code of Spark. After investigating Spark scheduling principles and mechanisms, we developed a stratifying algorithm and a node scheduling algorithm are proposed in this paper to optimize the native scheduling strategy of Spark. In this new strategy, the static level of nodes is calculated, the dynamic factors such as the length of running tasks, and CPU usage of work nodes are considered comprehensively. And through a series of comparative experiments in alienation cluster, the new strategy costs less running time and lower CPU usage rate than the original Spark strategy, which verifies that the new schedule strategy is more effective one.

This paper presents the Tempus real-time middleware, which supports real-time CORBA 2.0's distributable threads (DTs) as an end-to-end programming abstraction for distributed real-time systems. DTs in Tempus can have time constraints, including time/utility functions (TUFs), can have resource constraints, including mutual exclusion, and can be scheduled according to utility accrual (UA) disciplines. Tempus propagates the scheduling parameters of DT's as they transit objects and hence perhaps node boundaries. Node-local instances of a UA scheduling algorithm use the propagated parameters to construct local schedules and resolve resource dependencies for local timeliness optimization, toward approximate, system-wide timeliness optimality. Tempus uses an application-level scheduling framework for node-local TUF/UA scheduling on real-time POSIX-compliant operating systems. Our experimental measurements demonstrate the effectiveness of the middleware in scheduling DTs.

We consider a model for online computation in which the online algorithm receives, together with each request, some information regarding the future, referred to as advice . The advice provided to the online algorithm may allow an improvement in its performance, compared to the classical model of complete lack of information regarding the future. We are interested in the impact of such advice on the competitive ratio, and in particular, in the relation between the size b of the advice, measured in terms of bits of information per request, and the (improved) competitive ratio. Since b = 0 corresponds to the classical online model, and $ b = \lceil \log |\mathcal{A}| \rceil $, where $\mathcal{A}$ is the algorithm's action space, corresponds to the optimal (offline) one, our model spans a spectrum of settings ranging from classical online algorithms to offline ones. In this paper we propose the above model and illustrate its applicability by considering two of the most extensively studied online problems, namely, metrical task systems (MTS) and the k-server problem. For MTS we establish tight (up to constant factors) upper and lower bounds on the competitive ratio of deterministic and randomized online algorithms with advice for any choice of 1 ≤ b ≤ *** (logn ) , where n is the number of states in the system: we prove that any randomized online algorithm for MTS has competitive ratio *** ( log(n ) / b ) and we present a deterministic online algorithm for MTS with competitive ratio O (log(n ) / b ) . For the k -server problem we construct a deterministic online algorithm for general metric spaces with competitive ratio k O (1 / b ) for any choice of *** (1) ≤ b ≤ logk .

We consider the problem of scheduling with renewable speed-up resources. Given m identical machines, n jobs and c different discrete resources, the task is to schedule each job non-preemptively onto one of the machines so as to minimize the makespan. In our problem, a job has its original processing time, which could be reduced by utilizing one of the resources. As resources are different, the amount of the time reduced for each job is different depending on the resource it uses. Once a resource is being used by one job, it can not be used simultaneously by any other job until this job is finished, hence the scheduler should take into account the job-to-machine assignment together with the resource-to-job assignment. We observe that, the classical unrelated machine scheduling problem is actually a special case of our problem when m=c, i.e., the number of resources equals the number of machines. Extending the techniques for the unrelated machine scheduling, we give a 2-approximation algorithm when both m and c are part of the input. We then consider two special cases for the problem, with m or c being a constant, and derive PTASes (Polynomial Time Approximation Schemes) respectively. We also establish the relationship between the two parameters m and c, through which we are able to transform the PTAS for the case when m is constant to the case when c is a constant. The relationship between the two parameters reveals the structure within the problem, and may be of independent interest.

Scheduling task graphs under hard (end-to-end) timing constraints is an extensively studied NP-hard problem of critical importance for predictable software mapping on Multiprocessor System-on-chip (MPSoC) platforms. In this work we focus on an off-line (design-time) version of this problem, where the target task graph is known before execution time. We address the issue of scheduling robustness, i.e. providing hard guarantees that the schedule will meet the end-to-end deadline in presence of bounded variations of task execution times expressed as min-max intervals known at design time. We present a robust scheduling algorithm that proactively inserts sequencing constraints when they are needed to ensure that execution will have no inserted idle times and will meet the deadline for any possible combination of task execution times within the specified intervals. The algorithm is complete, i.e. it will return a feasible graph augmentation if one exists. Moreover, we provide an optimization version of the algorithm that can compute the shortest deadline that can be met in a robust way.

We study an on-line scheduling problem that is motivated by applications such as car-sharing for trips between an airport and a group of hotels. Users submit ride requests, and the scheduler aims to accept requests of maximum total profit using k servers (cars). Each ride request specifies the pick-up time, the pick-up location, and the drop-off location, where one of the two locations must be the airport. A request must be submitted a fixed amount of time before the pick-up time. The scheduler has to decide whether or not to accept a request immediately at the time when the request is submitted (booking time). In the unit travel time variant, the travel time between the airport and any hotel is a fixed value t. We give a 2-competitive algorithm for the case in which the booking interval (pick-up time minus booking time) is at least t and the number of servers is even. In the arbitrary travel time variant, the travel time between the airport and a hotel may have arbitrary length between t and L t for some L >= 1. We give an algorithm with competitive ratio O(log L) if the number of servers is at least ceil[log L]. For both variants, we prove matching lower bounds on the competitive ratio of any deterministic on-line algorithm.

The authors describe two multiprocessor compiler techniques that generate synchronous multiprocessor schedules for multiple-rate algorithms represented by fully specified flow graphs (FSFGs) which contain up-samplers and down-samplers. The first scheduling technique is based on a modified multi-cyclic multiprocessor compiler that finds globally optimal solutions. The second technique generates near-optimal solutions by trading global optimality for a lower scheduling complexity. These scheduling techniques are illustrated with examples.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The General Scheduling Problem (GSP) generalizes scheduling problems with sum of cost objectives such as weighted flow time and weighted tardiness. Given a set of jobs with processing times, release dates, and job dependent cost functions, we seek to find a minimum cost preemptive schedule on a single machine. The best known algorithm for this problem and also for weighted flow time/tardiness is an O(loglog P)-approximation (where P denotes the range of the job processing times), while the best lower bound shows only strong NP-hardness. When release dates are identical there is also a gap: the problem remains strongly NP-hard and the best known approximation algorithm has a ratio of e+\epsilon (running in quasi-polynomial time). We reduce the latter gap by giving a QPTAS if the numbers in the input are quasi-polynomially bounded, ruling out the existence of an APX-hardness proof unless NP\subseteq DTIME(2^polylog(n)). Our techniques are based on the QPTAS known for the UFP-Cover problem, a particular case of GSP where we must pick a subset of intervals (jobs) on the real line with associated heights and costs. If an interval is selected, its height will help cover a given demand on any point contained within the interval. We reduce our problem to a generalization of UFP-Cover and use a sophisticated divide-and-conquer procedure with interdependent non-symmetric subproblems. We also present a pseudo-polynomial time approximation scheme for two variants of UFP-Cover. For the case of agreeable intervals we give an algorithm based on a new dynamic programming approach which might be useful for other problems of this type. The second one is a resource augmentation setting where we are allowed to slightly enlarge each interval.