To see the other types of publications on this topic, follow the link: Parallel execution of tasks.
Journal articles on the topic 'Parallel execution of tasks'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 journal articles for your research on the topic 'Parallel execution of tasks.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.
1
TAN, KIAN-LEE, and HONGJUN LU. "ON PROCESSING MULTI-JOINS IN PARALLEL SYSTEMS." Parallel Processing Letters 01, no. 02 (December 1991): 157–64. http://dx.doi.org/10.1142/s0129626491000112.
Full textAbstract:
In parallel systems, a number of joins from one or more queries can be executed either serially or in parallel. While serial execution assigns all processors to execute each join one after another, parallel execution distributes the joins to clusters formed by certain numbers of processors and executes them concurrently. However, data skew may result in load imbalance among processors executing the same join and some clusters may be overloaded with more expensive joins. As a result, the completion time will be much longer than what is expected. In this paper, we propose an algorithm to further minimize the completion time of concurrently executed multiple joins. For this algorithm, all the joins to be executed concurrently are decomposed into a set of tasks that are ordered according to decreasing task size. These tasks are dynamically acquired by available processors during execution. Our performance study shows that the proposed algorithm outperforms previously proposed approaches, especially when the number of processors increases, the relations are highly skewed and relation sizes are large.
2
ZOMAYA, ALBERT Y., and GERARD CHAN. "EFFICIENT CLUSTERING FOR PARALLEL TASKS EXECUTION IN DISTRIBUTED SYSTEMS." International Journal of Foundations of Computer Science 16, no. 02 (April 2005): 281–99. http://dx.doi.org/10.1142/s0129054105002991.
Full textAbstract:
The scheduling problem deals with the optimal assignment of a set of tasks to processing elements in a distributed system such that the total execution time is minimized. One approach for solving the scheduling problem is task clustering. This involves assigning tasks to clusters where each cluster is run on a single processor. This paper aims to show the feasibility of using Genetic Algorithms for task clustering to solve the scheduling problem. Genetic Algorithms are robust optimization and search techniques that are used in this work to solve the task-clustering problem. The proposed approach shows great promise to solve the clustering problem for a wide range of clustering instances.
3
Oz, Isil, Muhammad Khurram Bhatti, Konstantin Popov, and Mats Brorsson. "Regression-Based Prediction for Task-Based Program Performance." Journal of Circuits, Systems and Computers 28, no. 04 (March 31, 2019): 1950060. http://dx.doi.org/10.1142/s0218126619500609.
Full textAbstract:
As multicore systems evolve by increasing the number of parallel execution units, parallel programming models have been released to exploit parallelism in the applications. Task-based programming model uses task abstractions to specify parallel tasks and schedules tasks onto processors at runtime. In order to increase the efficiency and get the highest performance, it is required to identify which runtime configuration is needed and how processor cores must be shared among tasks. Exploring design space for all possible scheduling and runtime options, especially for large input data, becomes infeasible and requires statistical modeling. Regression-based modeling determines the effects of multiple factors on a response variable, and makes predictions based on statistical analysis. In this work, we propose a regression-based modeling approach to predict the task-based program performance for different scheduling parameters with variable data size. We execute a set of task-based programs by varying the runtime parameters, and conduct a systematic measurement for influencing factors on execution time. Our approach uses executions with different configurations for a set of input data, and derives different regression models to predict execution time for larger input data. Our results show that regression models provide accurate predictions for validation inputs with mean error rate as low as 6.3%, and 14% on average among four task-based programs.
4
Agrawal, Amrit, and Pranay Chaudhuri. "An Algorithm for Task Scheduling in Heterogeneous Distributed Systems Using Task Duplication." International Journal of Grid and High Performance Computing 3, no. 1 (January 2011): 89–97. http://dx.doi.org/10.4018/jghpc.2011010105.
Full textAbstract:
Task scheduling in heterogeneous parallel and distributed computing environment is a challenging problem. Applications identified by parallel tasks can be represented by directed-acyclic graphs (DAGs). Scheduling refers to the assignment of these parallel tasks on a set of bounded heterogeneous processors connected by high speed networks. Since task assignment is an NP-complete problem, instead of finding an exact solution, scheduling algorithms are developed based on heuristics, with the primary goal of minimizing the overall execution time of the application or schedule length. In this paper, the overall execution time (schedule length) of the tasks is reduced using task duplication on top of the Critical-Path-On-a-Processor (CPOP) algorithm.
5
Brecht, Timothy, Xiaotie Deng, and Nian Gu. "Competitive Dynamic Multiprocessor Allocation for Parallel Applications." Parallel Processing Letters 07, no. 01 (March 1997): 89–100. http://dx.doi.org/10.1142/s0129626497000115.
Full textAbstract:
We study dynamic multiprocessor allocation policies for parallel jobs, which allow the preemption and reallocation of processors to take place at any time. The objective is to minimize the completion time of the last job to finish executing (the makespan). We characterize a parallel job using two parameter. The job's parallelism, Pi, which is the number of tasks being executed in parallel by a job, and its execution time, li, when Pi processors are allocated to the job. The only information available to the scheduler is the parallelism of jobs. The job execution time is not known to the scheduler until the job's execution is completed. We apply the approach of competitive analysis to compare preemptive scheduling policies, and are interested in determining which policy achieves the best competitive ratio (i.e., is within the smallest constant factor of optimal). We devise an optimal competitive scheduling policy for scheduling two parallel jobs on P processors. Then, we apply the method to schedule N parallel jobs on P processors. Finally we extend our work to incorporate jobs for which the number of parallel tasks changes during execution (i.e., jobs with multiple phases of parallelism).
6
González, J. Solano, and D. I. Jonest. "Parallel computation of configuration space." Robotica 14, no. 2 (March 1996): 205–12. http://dx.doi.org/10.1017/s0263574700019111.
Full textAbstract:
SUMMARYMany motion planning methods use Configuration Space to represent a robot manipulator's range of motion and the obstacles which exist in its environment. The Cartesian to Configuration Space mapping is computationally intensive and this paper describes how the execution time can be decreased by using parallel processing. The natural tree structure of the algorithm is exploited to partition the computation into parallel tasks. An implementation programmed in the occam2 parallel computer language running on a network of INMOS transputers is described. The benefits of dynamically scheduling the tasks onto the processors are explained and verified by means of measured execution times on various processor network topologies. It is concluded that excellent speed-up and efficiency can be achieved provided that proper account is taken of the variable task lengths in the computation.
7
Hirata, Hiroaki, and Atsushi Nunome. "Decoupling Computation and Result Write-Back for Thread-Level Parallelization." International Journal of Software Innovation 8, no. 3 (July 2020): 19–34. http://dx.doi.org/10.4018/ijsi.2020070102.
Full textAbstract:
Thread-level speculation (TLS) is an approach to enhance the opportunity of parallelization of programs. A TLS system enables multiple threads to begin the execution of tasks in parallel even if there may be the dependency between tasks. When any dependency violation is detected, the TLS system enforces the violating thread to abort and re-execute the task. So, the frequency of aborts is one of the factors that damage the performance of the speculative execution. This article proposes a new technique named the code shelving, which enables threads not to need to abort. It is available not only for TLS but also as a flexible synchronization technique in conventional and non-speculatively parallel execution. The authors implemented the code shelving on their parallel execution system called Speculative Memory (SM) and verified the effectiveness of the code shelving.
8
Dümmler, Jörg, Thomas Rauber, and Gudula Rünger. "Combined Scheduling and Mapping for Scalable Computing with Parallel Tasks." Scientific Programming 20, no. 1 (2012): 45–67. http://dx.doi.org/10.1155/2012/514940.
Full textAbstract:
Recent and future parallel clusters and supercomputers use symmetric multiprocessors (SMPs) and multi-core processors as basic nodes, providing a huge amount of parallel resources. These systems often have hierarchically structured interconnection networks combining computing resources at different levels, starting with the interconnect within multi-core processors up to the interconnection network combining nodes of the cluster or supercomputer. The challenge for the programmer is that these computing resources should be utilized efficiently by exploiting the available degree of parallelism of the application program and by structuring the application in a way which is sensitive to the heterogeneous interconnect. In this article, we pursue a parallel programming method using parallel tasks to structure parallel implementations. A parallel task can be executed by multiple processors or cores and, for each activation of a parallel task, the actual number of executing cores can be adapted to the specific execution situation. In particular, we propose a new combined scheduling and mapping technique for parallel tasks with dependencies that takes the hierarchical structure of modern multi-core clusters into account. An experimental evaluation shows that the presented programming approach can lead to a significantly higher performance compared to standard data parallel implementations.
9
Zhang, Guo Quan, Guo Qing Shi, Hao Guang Zhao, and Yong Hong Chen. "A Parallel Test Task Scheduling of Integrated Avionics System Based on the Ant Colony Algorithm." Applied Mechanics and Materials 713-715 (January 2015): 2069–72. http://dx.doi.org/10.4028/www.scientific.net/amm.713-715.2069.
Full textAbstract:
Parallel testing is the key to achieving parallel test task scheduling, and its core is allocating resources fairly and reasonably to the test tasks, then rearrange the execution order of the test tasks in meeting the priority relationship between the resource constraints and the conditions of the test tasks, making the whole test mission of this system can be completed in the shortest possible time and improving the test efficiency. The basic ant colony algorithm has been improved in this paper to fit the parallel test task scheduling and to obtain the task scheduling sequence that complete all testing tasks in shortest test time.
10
Dhanesh, Lavanya, and P. Murugesan. "A Novel Approach in Scheduling Of the Real- Time Tasks In Heterogeneous Multicore Processor with Fuzzy Logic Technique For Micro-grid Power Management." International Journal of Power Electronics and Drive Systems (IJPEDS) 9, no. 1 (March 1, 2018): 80. http://dx.doi.org/10.11591/ijpeds.v9.i1.pp80-88.
Full textAbstract:
Scheduling of tasks based on real time requirement is a major issue in the heterogeneous multicore systemsfor micro-grid power management . Heterogeneous multicore processor schedules the serial tasks in the high performance core and parallel tasks are executed on the low performance cores. The aim of this paper is to implement a scheduling algorithm based on fuzzy logic for heterogeneous multicore processor for effective micro-grid application. Real – time tasks generally have different execution time and dead line. The main idea is to use two fuzzy logic based scheduling algorithm, first is to assign priority based on execution time and deadline of the task. Second , the task which has assigned higher priority get allotted for execution in high performance core and remaining tasks which are assigned low priority get allotted in low performance cores. The main objective of this scheduling algorithm is to increase the throughput and to improve CPU utilization there by reducing the overall power consumption of the micro-grid power management systems. Test cases with different task execution time and deadline were generated to evaluate the algorithms using MATLAB software.
11
Ali, H. Arafat, A. I. Saleh, Amany M. Sarhan, and Abdulrahman A. Azab. "Peer-to-Peer Desktop Grids Based on an Adaptive Decentralized Scheduling Mechanism." International Journal of Grid and High Performance Computing 2, no. 1 (January 2010): 1–20. http://dx.doi.org/10.4018/jghpc.2010092801.
Full textAbstract:
This article proposes an adaptive fuzzy logic based decentralized scheduling mechanism that will be suitable for dynamic computing environment in which matchmaking is achieved between resource requirements of outstanding tasks and resource capabilities of available workers. Feasibility of the proposed method is done via real time system. Experimental results show that implementing the proposed fuzzy matchmaking based scheduling mechanism maximized the resource utilization of executing workers without exceeding the maximum execution time of the task. It is concluded that the efficiency of FMA-based decentralized scheduling, in the case of parallel execution, is reduced by increasing the number of subtasks.
12
Bramas, Bérenger, and Alain Ketterlin. "Improving parallel executions by increasing task granularity in task-based runtime systems using acyclic DAG clustering." PeerJ Computer Science 6 (January 13, 2020): e247. http://dx.doi.org/10.7717/peerj-cs.247.
Full textAbstract:
The task-based approach is a parallelization paradigm in which an algorithm is transformed into a direct acyclic graph of tasks: the vertices are computational elements extracted from the original algorithm and the edges are dependencies between those. During the execution, the management of the dependencies adds an overhead that can become significant when the computational cost of the tasks is low. A possibility to reduce the makespan is to aggregate the tasks to make them heavier, while having fewer of them, with the objective of mitigating the importance of the overhead. In this paper, we study an existing clustering/partitioning strategy to speed up the parallel execution of a task-based application. We provide two additional heuristics to this algorithm and perform an in-depth study on a large graph set. In addition, we propose a new model to estimate the execution duration and use it to choose the proper granularity. We show that this strategy allows speeding up a real numerical application by a factor of 7 on a multi-core system.
13
Huang, Kai, Ming Jing, Xiaowen Jiang, Siheng Chen, Xiaobo Li, Wei Tao, Dongliang Xiong, and Zhili Liu. "Task-Level Aware Scheduling of Energy-Constrained Applications on Heterogeneous Multi-Core System." Electronics 9, no. 12 (December 5, 2020): 2077. http://dx.doi.org/10.3390/electronics9122077.
Full textAbstract:
Minimizing the schedule length of parallel applications, which run on a heterogeneous multi-core system and are subject to energy consumption constraints, has recently attracted much attention. The key point of this problem is the strategy to pre-allocate the energy consumption of unscheduled tasks. Previous articles used the minimum value, average value or a power consumption weight value as the pre-allocation energy consumption of tasks. However, they all ignored the different levels of tasks. The tasks in different task levels have different impact on the overall schedule length when they are allocated the same energy consumption. Considering the task levels, we designed a novel task energy consumption pre-allocation strategy that is conducive to minimizing the scheduling time and developed a novel task schedule algorithm based on it. After getting the preliminary scheduling results, we also proposed a task execution frequency re-adjustment mechanism that can re-adjust the execution frequency of tasks, to further reduce the overall schedule length. We carried out a considerable number of experiments with practical parallel application models. The results of the experiments show that our method can reach better performance compared with the existing algorithms.
14
Zhou, Quan, Jianjun Li, and Guohui Li. "Excluding Parallel Execution to Improve Global Fixed Priority Response Time Analysis." ACM Transactions on Embedded Computing Systems 20, no. 5s (October 31, 2021): 1–24. http://dx.doi.org/10.1145/3477035.
Full textAbstract:
Response Time Analysis (RTA) is an effective method for testing the schedulability of real-time tasks on multiprocessor platforms. Existing RTAs for global fixed priority scheduling calculate the upper bound of the worst case response time of each task. Given a target task, existing RTAs first calculate the workload upper bound of each higher priority task (than the target task), and then calculate the interference on the target task by each higher priority task according to the obtained workload upper bounds. The workload of a task consists of three parts: carry-in, body and carry-out. The interference from all these three parts may be overestimated in existing RTAs. However, although the overestimation of the interference from body is the major factor that causes the low accuracy of existing RTAs, all existing work only focuses on how to reduce the overestimation of the interference from carry-in, and there is no method to reduce the overestimation of the interference from body or carry-out. In this work, we propose a method to calculate the lower bound of the accumulative time in which the target task and higher priority tasks are executed in parallel. By excluding the parallel execution time from the interference, we derive a new RTA test that can reduce the overestimation of the interference from all three parts of the workload. Extensive experiments are conducted to verify the superior performance of the proposed RTA test.
15
Maity, Arka, Anuj Pathania, and Tulika Mitra. "PkMin: Peak Power Minimization for Multi-Threaded Many-Core Applications." Journal of Low Power Electronics and Applications 10, no. 4 (September 30, 2020): 31. http://dx.doi.org/10.3390/jlpea10040031.
Full textAbstract:
Multiple multi-threaded tasks constitute a modern many-core application. An accompanying generic Directed Acyclic Graph (DAG) represents the execution precedence relationship between the tasks. The application comes with a hard deadline and high peak power consumption. Parallel execution of multiple tasks on multiple cores results in a quicker execution, but higher peak power. Peak power single-handedly determines the involved cooling costs in many-cores, while its violations could induce performance-crippling execution uncertainties. Less task parallelization, on the other hand, results in lower peak power, but a more prolonged deadline violating execution. The problem of peak power minimization in many-cores is to determine task-to-core mapping configuration in the spatio-temporal domain that minimizes the peak power consumption of an application, but ensures application still meets the deadline. All previous works on peak power minimization for many-core applications (with or without DAG) assume only single-threaded tasks. We are the first to propose a framework, called PkMin, which minimizes the peak power of many-core applications with DAG that have multi-threaded tasks. PkMin leverages the inherent convexity in the execution characteristics of multi-threaded tasks to find a configuration that satisfies the deadline, as well as minimizes peak power. Evaluation on hundreds of applications shows PkMin on average results in 49.2% lower peak power than a similar state-of-the-art framework.
16
Sánchez, David, David Isern, Ángel Rodríguez-Rozas, and Antonio Moreno. "Agent-based platform to support the execution of parallel tasks." Expert Systems with Applications 38, no. 6 (June 2011): 6644–56. http://dx.doi.org/10.1016/j.eswa.2010.11.073.
Full text
17
Zhang, Jun, Zhixian Chen, Ying Hu, Jianwei Zhang, Zhenhua Luo, and Xuehui Dong. "Multitasking Planning and Executing of Intelligent Vehicles for Restaurant Service by Networking." International Journal of Distributed Sensor Networks 2015 (2015): 1–14. http://dx.doi.org/10.1155/2015/273825.
Full textAbstract:
Indoor intelligent vehicles have been applied widely in restaurant service, where they are usually demanded to work for long period for multiple tasks and face the challenges of uncertainty, efficiency, and working online. In this paper, we propose an approach of multitasking planning and executing by networking for intelligent vehicles working for restaurant service. As to increase the efficiency of accomplishing multiple tasks, traditional HTN model is adapted to present the property of executing in parallel for the plan. As working online, the new inserted task is decomposed to get its individual plan, which is then merged into the global plan by optimization modelled as a maximal weight clique problem through evaluating the relations among actions and optimizing based on maximal cost saving first. Additionally, the protected states and goal states of an action are monitored in execution monitoring while action executing. Once exception occurs, the replanning based on partially backtracking would repair it. Moreover, with the mechanism of cooperation by networking, vehicles can allocate tasks, share information, and cooperate for execution monitoring. Finally, the test and demonstration of the experiment for drink service in restaurant environment show the feasibility and the improvement on the efficiency of multitasking.
18
Smanchat, Sucha, and Suchon Sritawathon. "A scheduling algorithm for grid workflow using bottleneck detection and load balancing." International Journal of Web Information Systems 10, no. 3 (August 12, 2014): 263–74. http://dx.doi.org/10.1108/ijwis-02-2014-0002.
Full textAbstract:
Purpose – This paper aims to propose a scheduling technique for parameter sweep workflows, which are used in parametric study and optimization. When executed in multiple parallel instances in the grid environment, it is necessary to address bottleneck and load balancing to achieve an efficient execution. Design/methodology/approach – A bottleneck detection approach is based on commonly known performance metrics of grid resources. To address load balancing, a resource requirement similarity metric is introduced to determine the likelihood of the distribution of tasks across available grid resources, which is referred to as an execution context. The presence of a bottleneck and the execution context are used in the main algorithm, named ABeC, to schedule tasks selectively at run-time to achieve a better overall execution time or makespan. Findings – According to the results of the simulations against four existing algorithms using several scenarios, the proposed technique performs, at least, similarly to the existing four algorithms in most cases and achieves better performance when scheduling workflows have a parallel structure. Originality/value – The bottleneck detection and the load balancing proposed in this paper require only common resource and task information, rendering it applicable to most workflow systems. The proposed scheduling technique, through such selective behaviour, may help reduce the time required for the execution of multiple instances of a grid workflow that is to be executed in parallel.
19
MCAVANEY, CHRISTOPHER, and ANDRZEJ GOSCINSKI. "AUTOMATIC PARALLELISATION AND EXECUTION OF APPLICATIONS ON CLUSTERS." Journal of Interconnection Networks 02, no. 03 (September 2001): 331–43. http://dx.doi.org/10.1142/s0219265901000427.
Full textAbstract:
Parallel execution is a very efficient means of processing vast amounts of data in a small amount of time. Creating parallel applications has never been easy, and requires much knowledge of the task and the execution environment used to execute parallel processes. The process of creating parallel applications can be made easier through using a compiler that automatically parallelises a supplied application. Executing the parallel application is also simplified when a well designed execution environment is used. Such an execution environment provides very powerful operations to the programmer transparently. Combining both a parallelising compiler and execution environment and providing a fully automated parallelisation and execution tool is the aim of this research. The advantage of using such a fully automated tool is that the user does not need to provide any additional input to gain the benefits of parallel execution. This report shows the tool and how it transparently supports the programmer creating parallel applications and supports their execution.
20
Cantini, Riccardo, Fabrizio Marozzo, Alessio Orsino, Domenico Talia, and Paolo Trunfio. "Exploiting Machine Learning For Improving In-Memory Execution of Data-Intensive Workflows on Parallel Machines." Future Internet 13, no. 5 (May 5, 2021): 121. http://dx.doi.org/10.3390/fi13050121.
Full textAbstract:
Workflows are largely used to orchestrate complex sets of operations required to handle and process huge amounts of data. Parallel processing is often vital to reduce execution time when complex data-intensive workflows must be run efficiently, and at the same time, in-memory processing can bring important benefits to accelerate execution. However, optimization techniques are necessary to fully exploit in-memory processing, avoiding performance drops due to memory saturation events. This paper proposed a novel solution, called the Intelligent In-memory Workflow Manager (IIWM), for optimizing the in-memory execution of data-intensive workflows on parallel machines. IIWM is based on two complementary strategies: (1) a machine learning strategy for predicting the memory occupancy and execution time of workflow tasks; (2) a scheduling strategy that allocates tasks to a computing node, taking into account the (predicted) memory occupancy and execution time of each task and the memory available on that node. The effectiveness of the machine learning-based predictor and the scheduling strategy were demonstrated experimentally using as a testbed, Spark, a high-performance Big Data processing framework that exploits in-memory computing to speed up the execution of large-scale applications. In particular, two synthetic workflows were prepared for testing the robustness of the IIWM in scenarios characterized by a high level of parallelism and a limited amount of memory reserved for execution. Furthermore, a real data analysis workflow was used as a case study, for better assessing the benefits of the proposed approach. Thanks to high accuracy in predicting resources used at runtime, the IIWM was able to avoid disk writes caused by memory saturation, outperforming a traditional strategy in which only dependencies among tasks are taken into account. Specifically, the IIWM achieved up to a 31% and a 40% reduction of makespan and a performance improvement up to 1.45× and 1.66× on the synthetic workflows and the real case study, respectively.
21
Potluri, Sirisha, and Katta Subba Rao. "Optimization model for QoS based task scheduling in cloud computing environment." Indonesian Journal of Electrical Engineering and Computer Science 18, no. 2 (May 1, 2020): 1081. http://dx.doi.org/10.11591/ijeecs.v18.i2.pp1081-1088.
Full textAbstract:
Shortest job first task scheduling algorithm allocates task based on the length of the task, i.e the task that will have small execution time will be scheduled first and the longer tasks will be executed later based on system availability. Min- Min algorithm will schedule short tasks parallel and long tasks will follow them. Short tasks will be executed until the system is free to schedule and execute longer tasks. Task Particle optimization model can be used for allocating the tasks in the network of cloud computing network by applying Quality of Service (QoS) to satisfy user’s needs. The tasks are categorized into different groups. Every one group contains the tasks with attributes (types of users and tasks, size and latency of the task). Once the task is allocated to a particular group, scheduler starts assigning these tasks to accessible services. The proposed optimization model includes Resource and load balancing Optimization, Non-linear objective function, Resource allocation model, Queuing Cost Model, Cloud cost estimation model and Task Particle optimization model for task scheduling in cloud computing environement. The main objectives identified are as follows. To propose an efficient task scheduling algorithm which maps the tasks to resources by using a dynamic load based distributed queue for dependent tasks so as to reduce cost, execution and tardiness time and to improve resource utilization and fault tolerance. To develop a multi-objective optimization based VM consolidation technique by considering the precedence of tasks, load balancing and fault tolerance and to aim for efficient resource allocation and performance of data center operations. To achieve a better migration performance model to efficiently model the requirements of memory, networking and task scheduling. To propose a QoS based resource allocation model using fitness function to optimize execution cost, execution time, energy consumption and task rejection ratio and to increase the throughput. QoS parameters such as reliability, availability, degree of imbalance, performance and SLA violation and response time for cloud services can be used to deliver better cloud services.
22
Lei, Zhenyang, Xiangdong Lei, and Jun Long. "Memory-Aware Scheduling Parallel Real-Time Tasks for Multicore Systems." International Journal of Software Engineering and Knowledge Engineering 31, no. 04 (April 2021): 613–34. http://dx.doi.org/10.1142/s0218194021400106.
Full textAbstract:
Shared resources on the multicore chip, such as main memory, are increasingly becoming a point of contention. Traditional real-time task scheduling policies focus on solely on the CPU, and do not take in account memory access and cache effects. In this paper, we propose parallel real-time tasks scheduling (PRTTS) policy on multicore platforms. Each set of tasks is represented as a directed acyclic graph (DAG). The priorities of tasks are assigned according to task periods Rate Monotonic (RM). Each task is composed of three phases. The first phase is read memory stage, the second phase is execution phase and the third phase is write memory phase. The tasks use locks and critical sections to protect data access. The global scheduler maintains the task pool in which tasks are ready to be executed which can run on any core. PRTTS scheduling policy consists of two levels: the first level scheduling schedules ready real-time tasks in the task pool to cores, and the second level scheduling schedules real-time tasks on cores. Tasks can preempt the core on running tasks of low priority. The priorities of tasks which want to access memory are dynamically increased above all tasks that do not access memory. When the data accessed by a task is in the cache, the priority of the task is raised to the highest priority, and the task is scheduled immediately to preempt the core on running the task not accessing memory. After accessing memory, the priority of these tasks is restored to the original priority and these tasks are pended, the preempted task continues to run on the core. This paper analyzes the schedulability of PRTTS scheduling policy. We derive an upper-bound on the worst-case response-time for parallel real-time tasks. A series of extensive simulation experiments have been performed to evaluate the performance of proposed PRTTS scheduling policy. The results of simulation experiment show that PRTTS scheduling policy offers better performance in terms of core utilization and schedulability rate of tasks.
23
Brozovsky, Jiri, and Jiri Koktan. "Parallel Execution of Structural Mechanic Tasks with Use of Small Supercomputers." Procedia Engineering 190 (2017): 296–303. http://dx.doi.org/10.1016/j.proeng.2017.05.341.
Full text
24
Das, Rina, D. Q. M. Fay, and Pradip K. Das. "Allocation of precedence-constrained tasks to parallel processors for optimal execution." Microprocessing and Microprogramming 35, no. 1-5 (September 1992): 237–44. http://dx.doi.org/10.1016/0165-6074(92)90322-x.
Full text
25
Schierl, Andreas, Alwin Hoffmann, Ludwig Nägele, and Wolfgang Reif. "Integrating planning and reactive behavior by using semantically annotated robot tasks." Encyclopedia with Semantic Computing and Robotic Intelligence 02, no. 01 (June 2018): 1850005. http://dx.doi.org/10.1142/s2529737618500053.
Full textAbstract:
Tasks that change the physical state of a robot and its environment take a considerable amount of time to execute. However, many robot applications spend the execution time waiting, although the following tasks might require time to prepare. This paper proposes to amend robot tasks with a semantic description of their expected outcomes, which allows planning and preparing successive tasks based on this information. The suggested approach allows sequential and parallel compositions of tasks, as well as reactive behavior modeled as state machines. The paper describes the means of modeling and executing these tasks, details different possibilities of planning in state-machine tasks and evaluates the benefits achievable using the approach on two example scenarios.
26
Barish, G., and C. A. Knoblock. "An Expressive Language and Efficient Execution System for Software Agents." Journal of Artificial Intelligence Research 23 (June 1, 2005): 625–66. http://dx.doi.org/10.1613/jair.1548.
Full textAbstract:
Software agents can be used to automate many of the tedious, time-consuming information processing tasks that humans currently have to complete manually. However, to do so, agent plans must be capable of representing the myriad of actions and control flows required to perform those tasks. In addition, since these tasks can require integrating multiple sources of remote information ? typically, a slow, I/O-bound process ? it is desirable to make execution as efficient as possible. To address both of these needs, we present a flexible software agent plan language and a highly parallel execution system that enable the efficient execution of expressive agent plans. The plan language allows complex tasks to be more easily expressed by providing a variety of operators for flexibly processing the data as well as supporting subplans (for modularity) and recursion (for indeterminate looping). The executor is based on a streaming dataflow model of execution to maximize the amount of operator and data parallelism possible at runtime. We have implemented both the language and executor in a system called THESEUS. Our results from testing THESEUS show that streaming dataflow execution can yield significant speedups over both traditional serial (von Neumann) as well as non-streaming dataflow-style execution that existing software and robot agent execution systems currently support. In addition, we show how plans written in the language we present can represent certain types of subtasks that cannot be accomplished using the languages supported by network query engines. Finally, we demonstrate that the increased expressivity of our plan language does not hamper performance; specifically, we show how data can be integrated from multiple remote sources just as efficiently using our architecture as is possible with a state-of-the-art streaming-dataflow network query engine.
27
Stepanova, Maria V., and Oleg I. Eremin. "THE ASSIGNMENT OF TASKS TO THE NODES OF THE IOT DISTRIBUTED SYSTEM BASED ON REINFORCEMENT MACHINE LEARNING." АВТОМАТИЗАЦИЯ ПРОЦЕССОВ УПРАВЛЕНИЯ 63, no. 1 (2021): 27–33. http://dx.doi.org/10.35752/1991-2927-2021-1-63-27-33.
Full textAbstract:
The article describes issues of applying an adaptive approach based on reinforcement learning for assignment of the computing tasks to nodes of distributed Internet of Things (IoT) platform. The IoT platform consists of heterogeneous elements that are computing nodes. Classical approaches, methods, and algorithms for distributed and parallel systems are not suitable for task assignment in IoT systems due to its characteristics. The reinforcement learning method allows you to solve the problem of building a distributed system due to the adaptive formation of a sequence of computational nodes and the corresponding computational tasks. Thus, the article represents a method that makes IoT nodes capable of execution computing tasks, especially, which were previously designed for classical distributed and parallel systems.
28
ESMAEILDOUST, MOHAMMAD, and ALI ZAKEROLHOSSEINI. "ROUTING AWARE PLACEMENT ALGORITHM AND EFFICIENT FREE SPACE MANAGEMENT FOR RECONFIGURABLE SYSTEMS." Journal of Circuits, Systems and Computers 19, no. 06 (October 2010): 1217–34. http://dx.doi.org/10.1142/s0218126610006839.
Full textAbstract:
In partially reconfigurable devices like FPGA, logic resources and communication channels can be reconfigured without affecting other section of the device. This allows parallel execution of multiple tasks on a FPGA. Due to limited resources on a FPGA, an effective management for efficient execution of tasks is required. We present a new approach for management of FPGA logic resources and also communication channels in an online task placement. The approach creates communication channels between the tasks and also tasks with I/O elements without requiring extra computation overhead. We present a fast algorithm for searching MERs for management of FPGA space. Then, we present a exact routing algorithm to find distance and create exact path between two set of tasks. A new fitting strategy based on the rate of communication between the tasks is also presented. The results indicate the proposed strategy and also its combination with some other known strategies can improve the quality of placement.
29
KRISHNAMURTI, RAMESH, and BHAGIRATH NARAHARI. "OPTIMAL SUBCUBE ASSIGNMENT FOR PARTITIONABLE HYPERCUBES." Parallel Processing Letters 02, no. 01 (March 1992): 89–95. http://dx.doi.org/10.1142/s0129626492000210.
Full textAbstract:
This paper formulates and discusses a processor assignment problem arising in partitionable parallel architectures. A partitionable hypercube multiprocessor can simultaneously execute multiple tasks where each task is independently executed on a subcube. Given a p processor hypercube and n independent tasks, where a task can be assigned a subcube of any size, an assignment determines the size of the subcube — i.e., the number of processors — to be assigned to each task. The objective of our problem is to find the optimal assignment which minimizes the maximum execution time among all tasks. We present an O(n log p max { log log p, log n}) algorithm that determines an optimal assignment. This algorithm can be efficiently parallelized, on the p processor hypercube, to obtain an O((n/p) log p log 2(n log p)) parallel assignment algorithm.
30
Souza, Renan, Vitor Silva, Alexandre A. B. Lima, Daniel de Oliveira, Patrick Valduriez, and Marta Mattoso. "Distributed in-memory data management for workflow executions." PeerJ Computer Science 7 (May 7, 2021): e527. http://dx.doi.org/10.7717/peerj-cs.527.
Full textAbstract:
Complex scientific experiments from various domains are typically modeled as workflows and executed on large-scale machines using a Parallel Workflow Management System (WMS). Since such executions usually last for hours or days, some WMSs provide user steering support, i.e., they allow users to run data analyses and, depending on the results, adapt the workflows at runtime. A challenge in the parallel execution control design is to manage workflow data for efficient executions while enabling user steering support. Data access for high scalability is typically transaction-oriented, while for data analysis, it is online analytical-oriented so that managing such hybrid workloads makes the challenge even harder. In this work, we present SchalaDB, an architecture with a set of design principles and techniques based on distributed in-memory data management for efficient workflow execution control and user steering. We propose a distributed data design for scalable workflow task scheduling and high availability driven by a parallel and distributed in-memory DBMS. To evaluate our proposal, we develop d-Chiron, a WMS designed according to SchalaDB’s principles. We carry out an extensive experimental evaluation on an HPC cluster with up to 960 computing cores. Among other analyses, we show that even when running data analyses for user steering, SchalaDB’s overhead is negligible for workloads composed of hundreds of concurrent tasks on shared data. Our results encourage workflow engine developers to follow a parallel and distributed data-oriented approach not only for scheduling and monitoring but also for user steering.
31
Aharoni, Gad, Dror G. Feitelson, and Amnon Barak. "A run-time algorithm for managing the granularity of parallel functional programs." Journal of Functional Programming 2, no. 4 (October 1992): 387–405. http://dx.doi.org/10.1017/s0956796800000484.
Full textAbstract:
AbstractWe present an on-line (run-time) algorithm that manages the granularity of parallel functional programs. The algorithm exploits useful parallelism when it exists, and ignores ineffective parallelism in programs that produce many small tasks. The idea is to balance the amount of local work with the cost of distributing the work. This is achieved by ensuring that for every parallel task spawned, an amount of work that equals the cost of the spawn is performed locally. We analyse several cases and compare the algorithm to the optimal execution. In most cases the algorithm competes well with the optimal algorithm, even though the optimal algorithm has information about the future evolution of the computation that is not available to the on-line algorithm. This is quite remarkable considering we have chosen extreme cases that have contradicting optimal executions. Moreover, we show that no other on-line algorithm can be consistently better than it. We also present experimental results that demonstrate the effectiveness of the algorithm.
32
LI, KEQIN. "AVERAGE-CASE SCALABILITY ANALYSIS OF PARALLEL COMPUTATIONS ON k-ARY d-CUBES." Journal of Interconnection Networks 05, no. 01 (March 2004): 27–45. http://dx.doi.org/10.1142/s0219265904001015.
Full textAbstract:
We investigate the average-case scalability of parallel algorithms executing on multicomputer systems whose static networks are k-ary d-cubes. Our performance metrics are isoefficiency function and isospeed scalability. For the purpose of average-case performance analysis, we formally define the concepts of average-case isoefficiency function and average-case isospeed scalability. By modeling parallel algorithms on multicomputers using task interaction graphs, we are mainly interested in the effects of communication overhead and load imbalance on the performance of parallel computations. We focus on the topology of static networks whose limited connectivities are constraints to high performance. In our probabilistic model, task computation and communication times are treated as random variables, so that we can analyze the average-case performance of parallel computations. We derive the expected parallel execution time on symmetric static networks and apply the result to k-ary d-cubes. We characterize the maximum tolerable communication overhead such that constant average-case efficiency and average-case average-speed could be maintained and that the number of tasks has a growth rate Θ(P log P), where P is the number of processors. It is found that the scalability of a parallel computation is essentially determined by the topology of a static network, i.e., the architecture of a parallel computer system. We also argue that under our probabilistic model, the number of tasks should grow at least in the rate of Θ(P log P), so that constant average-case efficiency and average-speed can be maintained.
33
Alam, Mahfooz, and Ankur Kumar Varshney. "A New Approach of Dynamic Load Balancing Scheduling Algorithm for Homogeneous Multiprocessor System." International Journal of Applied Evolutionary Computation 7, no. 2 (April 2016): 61–75. http://dx.doi.org/10.4018/ijaec.2016040104.
Full textAbstract:
Load balancing of parallel tasks in homogeneous as well as heterogeneous systems are major trouble for researches of both industry and academia. Load balancing were broadly classified into two categories namely static load balancing and dynamic load balancing. Nowadays, numerous of researches focus towards dynamic load balancing schemes for multiprocessor system. In this paper, the authors propose a dynamic load balancing strategy for homogeneous multiprocessor system and apply on cube based interconnection network named as Folded Crossed Cube network. The performance of folded crossed cube network gives better result in terms of diameter. Experimental results show that lesser load imbalance factor has been achieved along with execution time. By this algorithm, parallel jobs are solved with largest number of tasks. The merit of this algorithm is that when the number of tasks increases, the execution time decreases with lesser load imbalance factor.
34
Kim, Doohyung, and Masaru Uchiyama. "Realization of Fast and Dexterous Tasks by a DD Parallel Robot Using Motor Back-drivability." Journal of Robotics and Mechatronics 13, no. 5 (October 20, 2001): 554–60. http://dx.doi.org/10.20965/jrm.2001.p0554.
Full textAbstract:
This paper presents the execution of very fast, complicated tasks with a high-speed accurate parallel robot we named HEXA. First, unified motion, force and compliance control scheme comprising several control algorithms are given. A key distinguishing feature of our model is control scheme, which does not use any force/torque sensors but uses the actuator backdrivability for this purpose. Hence we can ignore the weight and cost of the force/torque sensor. The motivation for this work is to show the usefulness of the versatile HEXA mechanism for applications in industry. Several experiments for complex, fast tasks, for example, the sequential peg-in-hole task on an inclined table, crank-turning, deburring and composite tasks, have been conducted using this control system to show its effectiveness.
35
Grigoryeva, Lyudmila, Julie Henriques, Laurent Larger, and Juan-Pablo Ortega. "Nonlinear Memory Capacity of Parallel Time-Delay Reservoir Computers in the Processing of Multidimensional Signals." Neural Computation 28, no. 7 (July 2016): 1411–51. http://dx.doi.org/10.1162/neco_a_00845.
Full textAbstract:
This letter addresses the reservoir design problem in the context of delay-based reservoir computers for multidimensional input signals, parallel architectures, and real-time multitasking. First, an approximating reservoir model is presented in those frameworks that provides an explicit functional link between the reservoir architecture and its performance in the execution of a specific task. Second, the inference properties of the ridge regression estimator in the multivariate context are used to assess the impact of finite sample training on the decrease of the reservoir capacity. Finally, an empirical study is conducted that shows the adequacy of the theoretical results with the empirical performances exhibited by various reservoir architectures in the execution of several nonlinear tasks with multidimensional inputs. Our results confirm the robustness properties of the parallel reservoir architecture with respect to task misspecification and parameter choice already documented in the literature.
36
Leeman, M. "A Resource-Aware Dynamic Load-Balancing Parallelization Algorithm in a Farmer-Worker Environment." International Journal of Adaptive, Resilient and Autonomic Systems 2, no. 1 (January 2011): 1–17. http://dx.doi.org/10.4018/jaras.2011010101.
Full textAbstract:
This paper describes an algorithm for dynamically assigning tasks to processing entities in a world where each task has a set of resource or service requirements and each processing entity a set of resources or service capabilities. A task needs to be assigned to a node that offers all required services and the set of tasks is finished within a minimal execution time frame. Dependability and adaptability are inherent to the algorithm so that it accounts for the varying execution time of each task or the failure of a processing node. The algorithm is based on a dependable technique for farmer-worker parallel programs and is enhanced for modeling the time constraints in combination with the required configuration set in a multidimensional resources model. This paper describes how the algorithm is used for dynamically load balancing and parallelizing the nightly tests of a digital television content-processing embedded device.
37
Heredia, Jorge David Figueroa, Shouhei Shirafuji, Hamdi M. Sahloul, Jose Ildefonso U. Rubrico, Taiki Ogata, Tatsunori Hara, and Jun Ota. "Refining Two Robots Task Execution Through Tuning Behavior Trajectory and Balancing the Communication." Journal of Robotics and Mechatronics 30, no. 4 (August 20, 2018): 613–23. http://dx.doi.org/10.20965/jrm.2018.p0613.
Full textAbstract:
A method for modifying robot behaviors is introduced to improve robot performance during the execution of object manipulation tasks. The purpose of this method is to minimize the execution time of tasks and prevent collision with obstacles, including objects to be manipulated and the robot itself, by considering two approaches. The first is to use the potential that robots can provide, considering that the programs are based on events that are subject to the response of sensors. The second is to determine the maximum rate at which commands can be sent, without affecting the responses from the sensors, and, based on that, to accelerate or decelerate the execution of the task. The proposed method focuses on the refinement of two approaches: (a) modifying the trajectory of some behaviors, so that they are not executed step by step, but are executed in parallel, and (b) increasing the rate of sending robotic commands. To validate the proposed method, four real-world tasks are presented, including the flipping of a briefcase, the flipping of a weighing scale, the lifting of a weighing scale, and the opening of a folding chair, performed by a set of small robots. The reduction in execution time of the tasks varied between 54.2% and 73.6%; the implications of the improvement are discussed based on experimental results.
38
Shang, Yizi, Guiming Lu, Ling Shang, and Guangqian Wang. "Parallel processing on block-based Gauss-Jordan algorithm for desktop grid." Computer Science and Information Systems 8, no. 3 (2011): 739–59. http://dx.doi.org/10.2298/csis100907026s.
Full textAbstract:
Two kinds of parallel possibilities exist in the block-based Gauss-Jordan (BbGJ) algorithm, which are intra-step and inter-steps based parallelism. But the existing parallel paradigm of BbGJ algorithm just aiming at the intra-step based parallelism, can?t meet the requirement of dispatching simultaneously as many tasks as possible to computing nodes of desktop grid platform exploiting thousands of volunteer computing resources. To overcome the problem described above, this paper presents a hybrid parallel paradigm for desktop grid platform, exploiting all the possible parallelizable parts of the BbGJ algorithm. As well known to us all, volatility is the key issue of desktop grid platform and faults are unavoidable during the process of program execution. So the adapted version of block BbGJ algorithm for desktop grid platform should take the volatility into consideration. To solve the problem presented above, the paper adopts multi-copy distribution strategy and multi-queue based task preemption method to ensure the key tasks can be executed on time, thus ensure the whole tasks can be finished in shorter period of time.
39
Huang, Li Qin, Li Qun Lin, and Yan Huang Liu. "Algorithm of Text Categorization Based on Cloud Computing." Applied Mechanics and Materials 311 (February 2013): 158–63. http://dx.doi.org/10.4028/www.scientific.net/amm.311.158.
Full textAbstract:
MapReduce framework of cloud computing has an effective way to achieve massive text categorization. In this paper a distributed parallel text training algorithm in cloud computing environment based on multi-class Support Vector Machines(SVM) is designed. In cloud computing environment Map tasks realize distributing various types of samples and Reduce tasks realize the specific SVM training. Experimental results show that the execution time of text training decreases with the number of Reduce tasks increasing. Also a parallel text classifying based on cloud computing is designed and implemented, which classify the unknown type texts. Experimental results show that the speed of text classifying increases with the number of Map tasks increasing.
40
Walker, John H. "Social Implications from Agricultural Taskscapes in the Southwestern Amazon." Latin American Antiquity 22, no. 3 (September 2011): 275–95. http://dx.doi.org/10.7183/1045-6635.22.3.275.
Full textAbstract:
AbstractAcross the Americas, but particularly in the Amazon Basin, precolumbian farmers invested their labor in features such as canals, causeways, and raised fields, creating agricultural landscapes. These landscapes required organized action in order to build and maintain them. Such actions can be usefully described as "tasks" to draw specific connections between communal work and landscape features (Ingold 1993). Using two parallel examples from the precolumbian Bolivian Amazon, this article presents landscape features as correlates of the variety and scale of tasks that compose the processes of creating and managing them. Data come from remote sensing and pedestrian survey. The execution of some tasks affects the execution of others, meaning that landscapes are the result of overlapping, interdependent communal tasks. This taskscape perspective allows landscapes to be compared with greater precision and shows that details of local spatial and task organization are important to understanding agricultural change. The comparison of two taskscapes reveals details of daily life and intensive agriculture that are obscured by the classification of societies as states or chiefdoms.
41
ZINDER, YAKOV, and GAURAV SINGH. "PREEMPTIVE SCHEDULING ON PARALLEL PROCESSORS WITH DUE DATES." Asia-Pacific Journal of Operational Research 22, no. 04 (December 2005): 445–62. http://dx.doi.org/10.1142/s0217595905000662.
Full textAbstract:
The paper presents a priority algorithm for the maximum lateness problem with parallel identical processors, precedence constraints, and preemptions. The presented algorithm calculates the priority of each task by constructing a schedule for the set of its successors. The algorithm is motivated by comparison of its nonpreemptive counterpart with other algorithms for the problem with unit execution time tasks. It is shown that the presented algorithm constructs an optimal schedule for the problem with two processors and arbitrary precedence constraints, and for the problem with an arbitrary number of processors and precedence constraints in the form of an in-tree. This proof also indicates that the presented algorithm allows the worst-case performance ratio previously established for the so-called Muntz–Coffman algorithm for a particular case of the considered problem where all due dates are zero.
42
Rodrigo S. Jamisola Jr. and Frank Ayo Ibikunle. "Investigating Task Prioritization and Holistic Coordination Using Relative Jacobian for Combined 3-Arm Cooperating Parallel Manipulators." Journal of Advanced Computational Intelligence and Intelligent Informatics 20, no. 1 (January 19, 2016): 117–23. http://dx.doi.org/10.20965/jaciii.2016.p0117.
Full textAbstract:
A new modular relative Jacobian formulation for single end-effector control of combined 3-arm cooperating parallel manipulators is derived. It is based on a previous method of derivation for dual-arm robots, with the same approach of modularity and single end-effector control for combined manipulators. This paper will present this new formulation, as well as investigate task prioritization scheme to verify the claim that a single end-effector controller of combined manipulators will indeed implement a strict task prioritization, by intentionally adding more tasks. In addition, this paper will investigate a claim that the holistic approach to control of combined manipulators affords easier control coordination of each of the stand-alone components. Switching control from an individual manipulator control in the null space to relative control in the tasks space is shown to investigate the smoothness of task execution during switching. Simulation results using Gazebo 2.2.5 running in Ubuntu 14.04 is shown.
43
Huang, Xiaobing, Tian Zhao, and Yu Cao. "PIR." International Journal of Multimedia Data Engineering and Management 5, no. 3 (July 2014): 1–27. http://dx.doi.org/10.4018/ijmdem.2014070101.
Full textAbstract:
Multimedia Information Retrieval (MIR) is a problem domain that includes programming tasks such as salient feature extraction, machine learning, indexing, and retrieval. There are a variety of implementations and algorithms for these tasks in different languages and frameworks, which are difficult to compose and reuse due to the interface and language incompatibility. Due to this low reusability, researchers often have to implement their experiments from scratch and the resulting programs cannot be easily adapted to parallel and distributed executions, which is important for handling large data sets. In this paper, we present Pipeline Information Retrieval (PIR), a Domain Specific Language (DSL) for multi-modal feature manipulation. The goal of PIR is to unify the MIR programming tasks by hiding the programming details under a flexible layer of domain specific interface. PIR optimizes the MIR tasks by compiling the DSL programs into pipeline graphs, which can be executed using a variety of strategies (e.g. sequential, parallel, or distributed execution). The authors evaluated the performance of PIR applications on single machine with multiple cores, local cluster, and Amazon Elastic Compute Cloud (EC2) platform. The result shows that the PIR programs can greatly help MIR researchers and developers perform fast prototyping on single machine environment and achieve nice scalability on distributed platforms.
44
Bambos, Nicholas, and Shou C. Chen. "Optimality Aspects of Greedy Schemes in Parallel Processing of Random Graph-Structured Jobs." Probability in the Engineering and Informational Sciences 8, no. 2 (April 1994): 229–43. http://dx.doi.org/10.1017/s0269964800003375.
Full textAbstract:
Parallel processing systems with jobs structured as random graphs, where the nodes correspond to executable tasks and the directed edges to precedence constraints, are studied from a queueing theoretic point of view under general stationarity assumptions on the job flows. Jobs need to have their tasks processed non-preemptively by a set of uniform processors. Simple, natural greedy schemes of allocating processors to tasks are shown to asymptotically minimize the long-term average execution time per job. The stability condition for this queueing system is specified, and greedy allocation schemes are shown to stabilize the system under the maximum possible job arrival rate. Some recurrence properties of the system state are also established.
45
Kyi, Lai Lai Win, and Nay Min Tun. "Performance Comparison of Parallel Sorting Algorithms on Homogeneous Cluster of Workstations." Advanced Materials Research 433-440 (January 2012): 3900–3904. http://dx.doi.org/10.4028/www.scientific.net/amr.433-440.3900.
Full textAbstract:
Sorting appears the most attention among all computational tasks over the past years because sorted data is at the heart of many computations. Sorting is of additional importance to parallel computing because of its close relation to the task of routing data among processes, which is an essential part of many parallel algorithms. Many parallel sorting algorithms have been investigated for a variety of parallel computer architectures. In this paper, three parallel sorting algorithms have been implemented and compared in terms of their overall execution time. The algorithms implemented are the odd-even transposition sort, parallel merge sort and parallel shell sort. Cluster of Workstations or Windows Compute Cluster has been used to compare the algorithms implemented. The C# programming language is used to develop the sorting algorithms. The MPI library has been selected to establish the communication and synchronization between processors. The time complexity for each parallel sorting algorithm will also be mentioned and analyzed.
46
Marrakchi, Sirine, and Mohamed Jemni. "Static Scheduling with Load Balancing for Solving Triangular Band Linear Systems on Multicore Processors." Fundamenta Informaticae 179, no. 1 (February 9, 2021): 35–58. http://dx.doi.org/10.3233/fi-2021-2012.
Full textAbstract:
A new approach for solving triangular band linear systems is established in this study to balance the load and obtain a high degree of parallelism. Our investigation consists to attribute both adequate start time and processor to each task and eliminate the useless dependencies which are not used in the parallel solve stage. Thereby, processors execute in parallel their related tasks taking account of the considered precedence constraints. The theoretical lower bounds for parallel execution time and the number of processors required to carry out the task graph in the shortest time are determined. Experimentations are realized on a shared-memory multicore processor. The experimental results are fitted to the values derived from the determined mathematical formulas. The comparison of results obtained by our contribution with those from triangular systems resolution routine belonging to the library PLASMA, Parallel Linear Algebra Software for Multicore Architectures, confirms the efficiency of the proposed approach.
47
Golosov, P. E., and I. M. Gostev. "Optimization of the Distribution of Hash Calculation Tasks Flow at a Priori Given Complexity." INFORMACIONNYE TEHNOLOGII 27, no. 5 (May 18, 2021): 242–48. http://dx.doi.org/10.17587/it.27.242-248.
Full textAbstract:
The increasing number of computationally intensive tasks induced by digital economy development (within the framework of implementing block-chain solutions, distributed ledgers, etc.) requires more and more computational resources. At the same time users tend to move the computational process to the cloud in order to minimize costs, and the owners of cloud services are forced to look for solutions to improve their efficiency. In this paper we consider approaches that allow optimize the use of parallel computing resources for incoming sets of resource-intensive tasks, analyze different approaches to the strategy of assigning tasks to computing resources. The results of modelling experiments are provided taking into account task distribution, parameterized by execution time limit within modeling the service level agreement with the user.
48
Garg, Akanksha, Navdeep S.Sethi, Nidhi Arora, and Amit Makkar. "BNP TASK SCHEDULING ALGORITHMS FOR PERFORMANCE EVALUATION IN PARALLEL SYSTEM." INTERNATIONAL JOURNAL OF COMPUTERS & TECHNOLOGY 12, no. 8 (February 20, 2014): 3768–77. http://dx.doi.org/10.24297/ijct.v12i8.3014.
Full textAbstract:
Scheduling is the process to minimize the schedule length by proper allocation of the tasks to the processors and arrangement of execution sequencing of the tasks. Multiprocessor Scheduling using Directed Acyclic Graph (DAG) is used in this research. Â An important implication of minimization of schedule length is that the system throughput is maximized. The objective of this survey is to describe various scheduling algorithms and their functionalities in a contrasting fashion as well as examine their relative merits in terms of performance and time-complexity. In this research, three BNP Scheduling Algorithms are considered namely HLFET Algorithm, MCP Algorithm and ETF Algorithm to calculate effective output by comparing the algorithms with eight test case scenarios with varying number of nodes and processors.
49
SMANCHAT, Sucha, and Kanchana VIRIYAPANT. "Scheduling Dynamic Parallel Loop Workflow in Cloud Environment." Walailak Journal of Science and Technology (WJST) 15, no. 1 (August 4, 2016): 19–27. http://dx.doi.org/10.48048/wjst.2018.2267.
Full textAbstract:
Scientific workflows have been employed to automate large scale scientific experiments by leveraging computational power provided on-demand by cloud computing platforms. Among these workflows, a parallel loop workflow is used for studying the effects of different input values of a scientific experiment. Because of its independent loop characteristic, a parallel loop workflow can be dynamically executed as parallel workflow instances to accelerate the execution. Such execution negates workflow traversal used in existing works to calculate execution time and cost during scheduling in order to maintain time and cost constraints. In this paper, we propose a novel scheduling technique that is able to handle dynamic parallel loop workflow execution through a new method for evaluating execution progress together with a workflow instance arrival control and a cloud resource adjustment mechanism. The proposed technique, which aims at maintaining a workflow deadline while reducing cost, is tested using 3 existing task scheduling heuristics as its task mapping strategies. The simulation results show that the proposed technique is practical and performs better when the time constraint is more relaxed. It also prefers task scheduling heuristics that allow for a more accurate progress evaluation.
50
Hamidi, Beqir, and Lindita Hamidi. "Synchronization Possibilities and Features in Java." European Journal of Interdisciplinary Studies 1, no. 1 (April 30, 2015): 75. http://dx.doi.org/10.26417/ejis.v1i1.p75-84.
Full textAbstract:
In this paper we have discussed one of the greatest features of the general purpose computer programming language –Java. This paper represents concepts of Synchronization possibilities and features in Java. Today's operating systems support concept of "Multitasking". Multitasking achieved by executing more than one task at a same time. Tasks runs on threads. Multitasking runs more than one task at a same time. Multitasking which means doing many things at the same time is one of the most fundamental concepts in computer engineering and computer science because the processor execute given tasks in parallel so it makes me think that are executing simultaneously. Multitasking is related to other fundamental concepts like processes and threads. A process is a computer program that is executing in a processor, while a thread is a part of a process that has a way of execution: it is a thread of execution. Every process has at least one thread of execution. There are two types of multitasking: process – based and thread – based. Process-based multitasking, means that on a given computer there can be more than one program or process that is executing, while thread-based multitasking, which is also known as multithreading, means that within a process, there can be more than one thread of execution, each of them doing a job and so accomplishing the job of their process. When there are many processes or many threads within processes, they may have to cooperate with each other or concurrently try to get access to some shared computer resources like: processor, memory and input/output devices. They may have to, for example: print a file in a printer or write and/or read to the same file. We need a way of setting an order, where processes and/or threads could do their jobs (user jobs) without any problem, we need to synchronize them. Java has built-in support for process and thread synchronization, there are some constructs that we can use when we need to do synchronization.This paper, a first phase discussed the concept of Parall Programming, threads, how to create a thread, using a thread, working with more than one thread. Second phase is about synchronization, what is in general and in the end we disscused the synchronization possibilities and feautures in Java.