Browsing by Author "Mishra, Abhishek"

Now showing 1 - 20 of 23

Benchmarking the contention aware nature inspired metaheuristic task scheduling algorithms
(Springer, 2019-05) Mishra, Abhishek
In this paper, we consider the contention aware task scheduling problem on a grid topology of processors. By contention awareness, we mean that simultaneous communication on a link has to be serialized. To solve this problem, we propose several nature inspired metaheuristic algorithms: Simulated Annealing (SA), Genetic Algorithm (GA), Differential Evolution (DE), Particle Swarm Optimization (PSO), Bat Algorithm (BA), Cuckoo Search (CS), and Firefly Algorithm (FA). We perform benchmark evaluation of these algorithms for the Normalized Schedule Length (NSL) parameter. The benchmark task graphs that we consider are: random task graphs, peer set task graphs, systolic array task graphs, Gaussian elimination task graphs, divide and conquer task graphs, and fast Fourier transform task graphs.
A Clustering Heuristic for Multiprocessor Environments Using Computation and Communication Loads of Modules
(AIRCC, 2010-10) Mishra, Abhishek
In this paper, we have developed a heuristic for the task allocation problem on a fully connected homogeneous multiprocessor environment. Our heuristic is based on a value associated with the modules called the Computation-Communication-Load (CCLoad). This value is dependent on the computation and the communication times associated with the module. Using the concept of CCLoad, we propose a clustering algorithm of complexity O(|V|2(|V|+|E|)log(|V|+|E|)), and demonstrate its superiority over a generic version of Sarkar's algorithm.
A compact formulation for the mdmsop: theoretical and computational time analysis
(Springer, 2023-11) Mishra, Abhishek
The multi-Depot multiple Set Orienteering Problem (mDmSOP) is one of the recently proposed variants of the Set Orienteering Problem (SOP), which has applicability in different real-life applications such as delivering products and mobile crowd-sensing. The objective of the problem is to collect maximum profit from clusters within a given budget. In this paper, we propose an improved integer linear programming (ILP) formulation of the mDmSOP and conduct a time analysis of the results. We solved it using GAMS 39.2.0 and found that we can reduce a large number of constraints while changing sub-tour elimination constraints only. In the case of small instances, the improved mathematical formulation gives better results in all of the test cases for small instances up to 76 vertices except one instance of 16eil76 when , and it gives better results in 93.33% of cases for small instances and 88.23% of cases while simulating on mid-size instances up to 198 nodes when .
Complexity of a problem of energy efficient real-time task scheduling on a multicore processor
(Wiley, 2014-06) Mishra, Abhishek
The problem of scheduling independent tasks with a common deadline for a multicore processor is investigated. The speed of cores can be varied (from a finite set of core speeds) using software controlled Dynamic Voltage Scaling. The energy consumption is to be minimized. This problem was called the Energy Efficient Task Scheduling Problem (EETSP) in a previous work in which a Monte Carlo algorithm was proposed for solving it. This work investigates the complexity of the EETSP problem. The EETSP problem is proved to be NP-Complete. Under the assumption of urn:x-wiley:10762787:media:cplx21561:cplx21561-math-0001, the EETSP problem is also proved to be inapproximable
An edge priority-based clustering algorithm for multiprocessor environments
(Wiley, 2018-12) Mishra, Abhishek
In multiprocessor environments, the scheduling algorithms play a significant role in maximizing system performance. In this paper, we propose a clustering-based task scheduling algorithm called Edge Priority Scheduling (EPS) for multiprocessor environments. The proposed algorithm extends the idea of edge zeroing heuristic and uses the concept of edge priority to minimize the makespan of the task graph. The complexity of the EPS algorithm is O(|V||E|(|V| + |E|)), where |E| represents the number of edges and |V| denotes the number of nodes in the task graph. The experiments are performed for random task graphs and the task graphs generated from some representative real-world applications such as Gaussian Elimination and Fast Fourier Transform. The performance of the EPS algorithm is compared with six well-known algorithms such as EZ (Edge Zeroing), LC (Linear Clustering), CPPS (Cluster Pair Priority Scheduling), DCCL (Dynamic Computation Communication Load), RDCC (Randomized Dynamic Computation Communication), and LOCAL. The results show that the EPS algorithm outperforms the compared algorithms in terms of the normalized schedule length and speedup.
Energy Efficient Task Scheduling of Sendreceive Task Graphs on Distributed Multicore Processors with Software Controlled Dynamic Voltage Scaling
(AIRCC, 2011-04) Mishra, Abhishek
Energy efficient voltage scheduling for multi-core processors is an important issue in the context of parallel and distributed computing. Dynamic voltage scaling (DVS) is used to reduce the energy consumption of cores. Nowadays processor vendors are providing software for DVS. We consider a system using a single multi-core processor with software controlled DVS having a finite set of discretely available core speeds. Our contribution to this work is solving a well-known energy efficient voltage scheduling problem on the considered system. The problem that we consider is to find a minimum energy voltage scheduling for a given computational load that has to be completed within a given deadline. First we show that the existing methods to solve this problem on other processor models fail to apply on our processor model. Then we formulate an Integer Program (IP) for the problem.
(Elsevier, 2012-12) Mishra, Abhishek
In this paper we give some extensive benchmark results for some dynamic priority clustering algorithms for homogeneous multiprocessor environments. By dynamic priority we mean a priority function that can change with every step of the algorithm. Using dynamic priority can give us more flexibility as compared to static priority algorithms. Our objective in this paper is to compare the dynamic priority algorithms with some well known algorithms from the literature and discuss their strengths and weaknesses. For our study we have selected two recently proposed dynamic priority algorithms: CPPS (Cluster Pair Priority Scheduling algorithm) having complexity and DCCL (Dynamic Computation Communication Load scheduling algorithm) having complexity where is the number of nodes in the task graph, and is the number of edges in the task graph. We have selected a recently proposed randomized algorithm with static priority (RCCL: Randomized Computation Communication Load scheduling algorithm) and converted it into a dynamic priority algorithm: RDCC (Randomized Dynamic Computation Communication load scheduling algorithm) having complexity where a is the number of randomization steps, and b is a limit on the number of clusters formed. We have also selected three well known algorithms from literature: DSC (Dominant Sequence Clustering algorithm) having complexity , EZ (Edge Zeroing algorithm) having complexity , and LC (Linear Clustering algorithm) having complexity . We have compared these algorithms using various comparison parameters including some statistical parameters, and also using various types of task graphs including some synthetic and real task graphs. Our results show that the dynamic priority algorithms give best results for the case of random task graphs, and for the case when the number of available processors are small.
Energy efficient voltage scheduling for multi-core processors with software controlled dynamic voltage scaling
(Elsevier, 2014-07) Mishra, Abhishek
Energy efficient voltage scheduling for multi-core processors is an important issue in the context of parallel and distributed computing. Dynamic voltage scaling (DVS) is used to reduce the energy consumption of cores. Nowadays processor vendors are providing software for DVS. We consider a system using a single multi-core processor with software controlled DVS having a finite set of discretely available core speeds. Our contribution to this work is solving a well-known energy efficient voltage scheduling problem on the considered system. The problem that we consider is to find a minimum energy voltage scheduling for a given computational load that has to be completed within a given deadline. First we show that the existing methods to solve this problem on other processor models fail to apply on our processor model. Then we formulate an Integer Program (IP) for the problem.
Exploring the performance of genetic algorithm and variable neighborhood search for solving the single depot multiple set orienteering problem: a comparative study
(2024-11) Mishra, Abhishek
This article discusses the single Depot multiple Set Orienteering Problem (sDmSOP), a recently suggested generalization of the Set Orienteering Problem (SOP). This problem aims to discover a path for each traveler over a subset of vertices, where each vertex is associated with only one cluster, and the total profit made from the clusters visited is maximized while still fitting within the available budget constraints. The profit can be collected only by visiting at least one cluster vertex. According to the SOP, each vertex cluster must have at least one of its visits counted towards the profit for that cluster. Like to the SOP, the sDmSOP restricts the number of clusters visited based on the budget for tour expenses. To address this problem, we employ the Genetic Algorithm (GA) and Variable Neighborhood Search (VNS) meta-heuristic. The optimal solution for small-sized problems is also suggested by solving the Integer Linear Programming (ILP) formulation using the General Algebraic Modeling System (GAMS) 37.1.0 with CPLEX for the sDmSOP. Promising computational results are presented that demonstrate the practicability of the proposed GA, VNS meta-heuristic, and ILP formulation by demonstrating substantial improvements to the solutions generated by VNS than GA while simultaneously needing much less time to compute than CPLEX
An extention of edge zeroing heuristic for scheduling precedence constrained task graphs on parallel systems using cluster dependent priority scheme
(IEEE, 2010-09) Mishra, Abhishek
Sarkar's edge zeroing heuristic for scheduling precedence constrained task graphs on parallel systems can be viewed as a priority based algorithm in which the priority is assigned to edges. In this algorithm, the priority is taken as the edge weight. This can also be viewed as a module dependent priority function that is defined for pairs of modules. We have extended this idea in which the priority is a cluster dependent function of pairs of clusters (of modules). Using this idea we propose an algorithm of complexity O(|V||E|(|V|+|E|)) and compare it with some well known algorithms.
Hardness amplification via group theory
(2024-11) Mishra, Abhishek
We employ techniques from group theory to show that, in many cases, counting problems on graphs are almost as hard to solve in a small number of instances as they are in all instances. Specifically, we show the following results. 1. Goldreich (2020) asks if, for every constant δ<1/2, there is an O~(n2)-time randomized reduction from computing the number of k-cliques modulo 2 with a success probability of greater than 2/3 to computing the number of k-cliques modulo 2 with an error probability of at most δ. In this work, we show that for almost all choices of the δ2(n2) corrupt answers within the average-case solver, we have a reduction taking O~(n2)-time and tolerating an error probability of δ in the average-case solver for any constant δ<1/2. By "almost all", we mean that if we choose, with equal probability, any subset S⊂{0,1}(n2) with |S|=δ2(n2), then with a probability of 1−2−Ω(n2), we can use an average-case solver corrupt on S to obtain a probabilistic algorithm. 2. Inspired by the work of Goldreich and Rothblum in FOCS 2018 to take the weighted versions of the graph counting problems, we prove that if the RETH is true, then for a prime p=Θ(2n), the problem of counting the number of unique Hamiltonian cycles modulo p on n-vertex directed multigraphs and the problem of counting the number of unique half-cliques modulo p on n-vertex undirected multigraphs, both require exponential time to compute correctly on even a 1/2n/logn-fraction of instances. Meanwhile, simply printing 0 on all inputs is correct on at least a Ω(1/2n)-fraction of instances.
A Monte Carlo algorithm for real time task scheduling on multi-core processors with software controlled dynamic voltage scaling
(Elsevier, 2014-04) Mishra, Abhishek
The task scheduling problem for multi-core processors is an important algorithm design issue. Dynamic voltage scaling (DVS) is used to reduce the energy consumption of cores. We ponder the problem of task scheduling on a multi-core processor with software controlled DVS where the objective is to reduce the energy consumption. We consider a system with a single multi-core processor with software controlled DVS having a finite set of core speeds and discuss a task scheduling problem associated with it. The problem that we address is to find a minimum energy task schedule for a given set of independent tasks that have to be completed within a given common deadline. We propose a Monte Carlo algorithm of complexity for solving the task scheduling problem and compare it with the optimal algorithm. Here t is the number of tasks, p is the number of cores, q is the number of core speeds, m is an integer parameter that is the number of iterations we should try to get a feasible solution before declaring that no solution is possible, n is an integer parameter that is the number of iterations we should try to reduce the energy consumption when we get a feasible solution, and D is the common deadline of the tasks.
The multi-depot multiple set orienteering problem: an integer linear programming formulation
(Scitepress, 2024) Mishra, Abhishek
In this article, we introduce a novel variant of the single Depot multiple Set Orienteering Problem (sDmSOP), which we refer to as the multi-Depot multiple Set Orienteering Problem (mDmSOP). We suggest the integer linear program (ILP) of the mDmSOP also, and analyze the impact of the Sub-tour Elimination Constraints (SECs) based on the Miller–Tucker–Zemlin (MTZ) and the Gavish-Graves (GG) model on it. The mDmSOP is most frequently encountered in distribution logistics. In mDmSOP, a fleet of travelers is utilized to serve a set of customers from a number of depots, with each traveler associated with a specific depot. The challenge is to choose the routes for each traveler to maximize the profit within a specific budget, while the profit can be earned from a set of customers only once by visiting exactly one customer. We show the simulation results conducted on the General Algebraic Modeling System (GAMS) 39.0.2, which is used to model and analyze linear, non-linear, mixed-integer, and other complex optimization problems. The Generalized Traveling Salesman Problem (GTSP) instances of up to 200 vertices are taken as the input data set for the simulations. The results show that the MTZ-based formulation takes less time than the GG-based formulation to converge to the optimal solution for the mDmSOP.
New techniques for constructing rare-case hard functions
(2025-02) Mishra, Abhishek
We say that a function is rare-case hard against a given class of algorithms (the adversary) if all algorithms in the class can compute the function only on an o(1)-fraction of instances of size n for large enough n. Starting from any NP-complete language, for each α>0, we construct a function that cannot be computed correctly even on a 1/nα-fraction of instances for polynomial-sized circuit families if NP ⊄ P/POLY and by polynomial-time algorithms if NP ⊄ BPP - functions that are rare-case hard against polynomial-sized circuits and polynomial-time randomized algorithms. The constructed function is a number-theoretic polynomial evaluated over specific finite fields. For NP-complete languages that admit parsimonious reductions from all of NP (for example, SAT), the constructed functions are hard to compute even on a 1/nα-fraction of instances by polynomial-time randomized algorithms and polynomial-sized circuit families simply if P# ⊄ BPP and P# ⊄ P/POLY, respectively. We also show that if the Randomized Exponential Time Hypothesis (RETH) is true, none of these constructed functions can be computed even on a 1/nα-fraction of instances in subexponential time. These functions are very hard, almost always. While one may not be able to efficiently compute the values of these constructed functions themselves, in polynomial time, one can verify that the evaluation of a function, s=f(x), is correct simply by asking a prover to compute f(y) on targeted queries. We have extended our work to give an alternative proof of a variant of Lipton's theorem (Lipton, 1989). We also compare our techniques for constructing rare-case hard functions with two other existing methods in the literature (Sudan et al., 2001; Feige and Lund, 1996).
On Spectra of Corona Graphs
(Springer, 2015) Mishra, Abhishek
Product graphs have been gainfully used in literature to generate mathematical models of complex networks which inherit properties of real networks. Realizing the duplication phenomena imbibed in the definition of corona product of two graphs, we define corona graphs. Given a small simple connected graph which we call basic graph, corona graphs are defined by taking corona product of the basic graph iteratively. We calculate the possibility of having a node of degree k in any corona graph which lead to obtain degree distribution of corona graphs. We determine explicit formulae of eigenvalues, Laplacian eigenvalues and signless Laplacian eigenvalues of corona graphs when the basic graph is regular. Computable expressions of eigenvalues and signless Laplacian eigenvalues are also obtained when the basic graph is a star graph.
The Orienteering Problem: A Review of Variants and Solution Approaches
(WMSCI, 2022) Mishra, Abhishek
Orienteering Problem (OP) fetched great attention in recent years because apart from the NP-hard routing problems, it is applicable in various applications like mobile crowd-sensing, manufacturing, etc. OP intends to maximize the overall price collected from the places covered in the itinerary within a timebound. In this paper, the latest improvements in NP-hard routing problems are discussed. Some variations of the traveling salesman problem (TSP), OP, and their recent solutions based on nature-inspired algorithms are explored. Finally, we present the future scope of the OP and its variants.
Performance Evaluation of Simulated Annealing-Based Task Scheduling Algorithms
(Springer, 2020-09) Mishra, Abhishek
The performance of simulated annealing (SA)-based task scheduling algorithms is evaluated. First, various parameters of SA are varied, and it is seen how it affects the schedule length (SL). The parameters that are varied are initial temperature, number of iterations, initial clustering, and cooling schedule. Then, one SA-based task scheduling algorithm is selected and compared with other task scheduling algorithms. The algorithms selected for comparison are cluster pair priority scheduling (CPPS), dominant sequence clustering (DSC), edge zeroing (EZ), and linear clustering (LC). Random task graphs are used for comparison
A Randomized Scheduling Algorithm For Multiprocessor Environments
(World Scientific, 2012) Mishra, Abhishek
In this paper, we propose a randomized scheduling algorithm on a fully connected homogeneous multiprocessor environment. This is a randomized version of our earlier algorithm in which we used priority of modules that was dependent on the computation and the communication times associated with the modules. First we propose a generalization of our earlier scheduling algorithm with restricted number of clusters to reduce the time complexity. Then we apply randomization to the generalized algorithm and demonstrate its superiority over our previous work. We show the complexity of our proposed algorithm as O(ab |V| (|V|+|E|) log (|V|+|E|)). Here a is the number of randomization steps, and b is a limit on the number of clusters formed. If we use a and b as constants, then this gives a better complexity in comparison with the complexity of our previous algorithm that was O(|V|2(|V|+|E|) log (|V|+|E|)). In comparison with our previous work we get a performance improvement of up to 6.63% and a performance improvement of up to 12.56% when compared with Sarkar's Edge Zeroing algorithm.
A Randomized Scheduling Algorithm for Multiprocessor Environments Using Local Search
(World Scientific, 2016) Mishra, Abhishek
The LOCAL(A, B) randomized task scheduling algorithm is proposed for fully connected multiprocessors. It combines two given task scheduling algorithms (A, and B) using local neighborhood search to give a hybrid of the two given algorithms. Objective is to show that such type of hybridization can give much better performance results in terms of parallel execution times. Two task scheduling algorithms are selected: DSC (Dominant Sequence Clustering as algorithm A), and CPPS (Cluster Pair Priority Scheduling as algorithm B) and a hybrid is created (the LOCAL(DSC, CPPS) or simply the LOCAL task scheduling algorithm). The LOCAL task scheduling algorithm has time complexity O(|V||E|(|V |+|E|)), where V is the set of vertices, and E is the set of edges in the task graph. The LOCAL task scheduling algorithm is compared with six other algorithms: CPPS, DCCL (Dynamic Computation Communication Load), DSC, EZ (Edge Zeroing), LC (Linear Clustering), and RDCC (Randomized Dynamic Computation Communication). Performance evaluation of the LOCAL task scheduling algorithm shows that it gives up to 80.47 % improvement of NSL (Normalized Schedule Length) over other algorithms.
A Simulated Annealing based Energy Efﬁcient Task Scheduling Algorithm for Multi-core Processors
(IJCCI, 2021) Mishra, Abhishek
In this paper we propose a Simulated Annealing (SA) based energy-efﬁcient task scheduling algorithm for multi-core processors, the Simulated Annealing Energy Efﬁcient Task Scheduling Algorithm (SAEETSA), and compare it with another algorithm, the Energy Efﬁcient Task Scheduling Algorithm (EETSA). Our results show that for dual-core processors the SAEETSA algorithm is taking up to 16.78% less energy as compared to the EETSA algorithm, and for tri-core processors, the SAEETSA algorithm is taking up to 26.97% less energy as compared to the EETSA algorithm. 1 I