Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Programming challenges in multicore systems
The trend towards multicore systems continues to place pressure on system designers and application programmers to create higher use of the multiple computing cores. Designers of operational systems should write programing algorithms that use multiple process cores to permit the parallel execution shown in below Figure −
Figure: Parallel execution on a multicore system
For application programmers, the challenge is to switch existing programs with its style new programs that are multithreaded. In general, 5 areas of challenges are there in programming for multicore systems −
Identifying tasks − This involves examining applications to seek out areas that may be divided into separate, concurrent tasks. Ideally, tasks are independent of one another and therefore will run in parallel on individual cores.
Balance − Whereas distinctive tasks that may run in parallel, programmers should make sure that the tasks perform equal work of equal worth. In some instances, a definite task might not contribute the maximum amount worth to the method as different tasks. employing a separate execution core to run that task might not be well worth the cost.
Data splitting − Even as applications are divided into separate tasks, the data accessed and manipulated by the tasks should be divided to run on separate cores.
Data dependency − The data accessed by the tasks should be examined for dependencies between 2 or additional tasks. once one task depends on data from another, programmers should make sure that the execution of the tasks is synchronal to accommodate the data dependency.
Testing and debugging − Once a program is running in parallel on multiple cores, many alternative execution paths are attainable. Testing and debugging such concurrent programs is inherently tougher than testing and debugging single-threaded applications.
Because of these challenges, several software system developers argue that the arrival of multicore systems would require an entirely new approach to coming up with software system systems within the future.
912 Views
