Virtual Implementation of Data Parallelism and Task Parallelism with Multicore Processing Unit

Project Description

This project demonstrates how modern multicore processors execute multiple tasks simultaneously using parallel programming techniques.

Two parallel models are implemented:

1. Data Parallelism
2. Task Parallelism

The project is implemented in Java using the Concurrency Framework including:

• ExecutorService
• Thread Pools
• Future Interface

The goal is to show how parallel computing improves performance and responsiveness compared to sequential execution.

---

Technologies Used

Java
Multithreading
ExecutorService
Java Concurrency API
GitHub

---

Project Structure

OS-Parallelism-Project
│
├── DataParallelismSum.java
├── TaskParallelismMusicDemo.java
└── README.md

---

Data Parallelism

Data Parallelism divides a large dataset into smaller segments.
Each segment is processed simultaneously by separate threads.

The partial results from each thread are combined to produce the final output.

Example in this project:

Array summation using multiple threads.

---

Data Parallelism Code

import java.util.concurrent.*;

class DataParallelismSum {

    public static int parallelSum(int[] data, int numThreads) throws InterruptedException, ExecutionException {

        ExecutorService executor = Executors.newFixedThreadPool(numThreads);

        int chunkSize = data.length / numThreads;
        Future<Integer>[] results = new Future[numThreads];

        for (int i = 0; i < numThreads; i++) {

            int start = i * chunkSize;
            int end = (i == numThreads - 1) ? data.length : start + chunkSize;

            final int s = start, e = end;

            results[i] = executor.submit(() -> {
                int sum = 0;
                for (int j = s; j < e; j++)
                    sum += data[j];
                return sum;
            });
        }

        int total = 0;

        for (Future<Integer> fut : results)
            total += fut.get();

        executor.shutdown();

        return total;
    }

    public static void main(String[] args) throws Exception {

        int[] data = {1,2,3,4,5,6,7,8};

        int numThreads = 3;

        int result = parallelSum(data, numThreads);

        System.out.println("Parallel Sum: " + result);
    }
}

---

Task Parallelism

Task Parallelism executes multiple independent tasks simultaneously.

Each thread performs a different operation.

Example in this project:

• Downloading a file from internet
• Playing a music file

Both operations run concurrently.

---

Task Parallelism Code

import java.io.*;
import java.net.*;
import java.util.concurrent.*;

public class TaskParallelismMusicDemo {

    static class DriveOperations {

        public void downloadFile(String fileUrl, String outputPath) {

            try {

                URL url = new URL(fileUrl);
                HttpURLConnection conn = (HttpURLConnection) url.openConnection();

                InputStream in = conn.getInputStream();
                FileOutputStream fos = new FileOutputStream(outputPath);

                byte[] buffer = new byte[8192];
                int bytesRead;

                while ((bytesRead = in.read(buffer)) != -1) {
                    fos.write(buffer,0,bytesRead);
                }

                fos.close();
                in.close();

                System.out.println("Download Completed");

            } catch(Exception e){
                e.printStackTrace();
            }
        }
    }

    public static void playMusic(String musicPath){

        try{

            File soundFile = new File(musicPath);

            if(soundFile.exists()){
                java.awt.Desktop.getDesktop().open(soundFile);
                System.out.println("Music Playing...");
            }

        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws InterruptedException {

        ExecutorService executor = Executors.newFixedThreadPool(2);

        DriveOperations driveOps = new DriveOperations();

        Runnable downloadTask =
                () -> driveOps.downloadFile("imageURL","image.jpg");

        Runnable musicTask =
                () -> playMusic("music.mpeg");

        executor.submit(downloadTask);
        executor.submit(musicTask);

        executor.shutdown();

        executor.awaitTermination(5,TimeUnit.MINUTES);

        System.out.println("All Tasks Completed");
    }
}

---

How to Run

Compile programs

javac DataParallelismSum.java
javac TaskParallelismMusicDemo.java

Run programs

java DataParallelismSum

java TaskParallelismMusicDemo

---

Expected Output

Data Parallelism

Parallel Sum: 36

Task Parallelism

Download Completed
Music Playing...
All Tasks Completed

---