Question

Need some help on homework practice problems, Thank you in advance!

Problem 1:

Write a method, parallelSum(), that uses the fork-join framework to compute the sum of the elements of an array. Its skeleton as well as its Javadoc is provided in the file ParallelSum.java. Simple code for testing and timing your method is also provided in the main method.

This problem is essentially the same as ParallelMax in structure. Therefore, follow the code for ParallelMax to complete ParallelSum.


Problem 2:

We again revisit the vote count problem you saw in Homework Assignments 1 and 8 as well as in the lecture. This time you are not required to sort the players by votes, but will count the votes in parallel using the fork-join framework and thread synchronization with a lock.

For the NBA All-Star Game, the fans vote for their favorite players. All the votes are stored in an array list, in which the name of a player appears once every time he receives a vote. A software expert, you are hired by the Commissioner to write an app that helps decide the starting lineups of the game. Write a method parallelVoteCount() that on the input array list of votes, returns a hash map that counts the number of votes each player receives. That is, each key of the map is the name of a player, and its associated value is the number of votes the player receives. The skeleton of parallelVoteCount() as well as its Javadoc, and the code for sequentialVoteCount(), the sequential method for counting votes, are provided in the file CountVotesInParallel.java. Simple code for testing and timing your method is also provided in the main method.

Even though this problem is different from other problems you have seen in this unit, except for thread synchronization the structure of the code for this problem is similar to that of RandomAssign and ParallelMergeSort. I therefore suggest that you reference their code while completing the code for this problem. For your convenience and the ease of my grading, I outline below the steps for the code. You must follow these steps to complete the method:

1. Create a RecursiveAction class CountTask to support parallelVoteCount().

2. Create the following private instance variables for the CountTask class:

2

 globalMap: A static hash map1 instance variable mapping strings to integers. This map will eventually contain the vote counts for all players.

 lock: A static reentrant lock instance variable

 THRESHOLD: A final static int instance variable. If the assigned sublist of votes has length below the threshold, then the task is to be executed sequentially.

 votes: An array list of strings that holds the votes

 low: The inclusive low index of the sublist assigned to the task

 high: The exclusive high index of the sublist assigned to the task

3. Write a constructor for CountTask that takes a list of votes, a low index and a high index as parameters and sets the corresponding instance variables properly.

4. Override the compute() method for CountTask as follows.

 If the sublist of votes assigned to the task as determined by low and high has length below THRESHOLD, then i. Use a local hash map localMap to count the votes in the sublist ii. Acquire the lock iii. Iterate through the entry set of localMap. For each key in the entry set, increment its value in globalMap by its value in localMap. iv. Release the lock

 Otherwise i. Divide the sublist into two (almost) equal halves ii. Recurse on the two halves in parallel using the invokeAll() method

5. Now complete the parallelVoteCount() method as follows:  Create a CountTask object representing the main task to solve  Create a fork-join pool of threads to execute the main task  Have the pool execute the main task by using the invoke() method  Finally return CountTask.globalMap

Sample code:

package hw9;

import java.util.*;
import java.util.concurrent.*;
import java.util.concurrent.locks.*;

public class CountVotesInParallel {

   public static void main(String[] args) {
       ArrayList<String> fav = new ArrayList<>();
       fav.add("LeBron");
       fav.add("Steph");
       fav.add("Luka");
       fav.add("Anthony");
       fav.add("Kawhi");
       fav.add("Giannis");
      
       int n = 10;
       ArrayList<String> votes = new ArrayList<>();
       for (int i = 0; i < n; i++) {
           int j = (int) (Math.random() * fav.size());
           votes.add(fav.get(j));
       }
       System.out.println(votes);
       System.out.println();
      
       long tic = System.currentTimeMillis();
       System.out.println("Sequential Count: " + sequentialVoteCount(votes));
       long toc = System.currentTimeMillis();
       System.out.println("Sequential time: " + (toc - tic) + " milliseconds");
       System.out.println();
      
       tic = System.currentTimeMillis();
       System.out.println("Parallel Count: " + parallelVoteCount(votes));
       toc = System.currentTimeMillis();
       System.out.printf("Parallel time with %d processors: %d milliseconds\n", Runtime.getRuntime().availableProcessors(), toc - tic);
       System.out.println();
      
   }
  
  
   /**
   * Sequential method for counting the number of votes for each player
   *
   * @param votes an array list of strings representing the names of players receiving votes
   * @return a hash map that counts the number of votes each player receives;
   * each key is the name of a player receiving votes, and its associated value
   * is the number of votes the player receives
   */
   public static HashMap<String, Integer> sequentialVoteCount(ArrayList<String> votes) {
       HashMap<String, Integer> map = new HashMap<>();
       for (String p : votes) {
           int count = map.getOrDefault(p, 0);
           map.put(p, count+1);
       }
      
       return map;
   }
  
  
   /**
   * Graded method for HW9 Problem 2
   *
   * Parallel method for counting the number of votes for each player
   * using fork-join and thread synchronization
   *
   * @param votes an array list of strings representing the names of players receiving votes
   * @return a hash map that counts the number of votes each player receives;
   * each key is the name of a player receiving votes, and its associated value
   * is the number of votes the player receives
   */
   public static HashMap<String, Integer> parallelVoteCount(ArrayList<String> votes) {
      
       // Replace this line with your return statement
       return null;
   }
  
  
   /*
   * Your static RecursiveAction class to support parallelVoteCount()
   * Name it CountTask
   */
  

}

Sample code 2:

package hw9;

import java.util.*;

public class ParallelSum {

   public static void main(String[] args) {
       int n = 10;
       double[] A = new double[n];
       Random rand = new Random();
       for (int i = 0; i < n; i++) {
           A[i] = Math.round(rand.nextDouble() * 10) / 10.0;
       }
       System.out.println("A: " + Arrays.toString(A));
       System.out.println();
      
       long tic = System.currentTimeMillis();
       System.out.println("Sequential Sum: " + sequentialSum(A));
       long toc = System.currentTimeMillis();
       System.out.println("Sequential time: " + (toc - tic) + " milliseconds");
       System.out.println();
      
       tic = System.currentTimeMillis();
       System.out.println("Parallel Sum: " + parallelSum(A));
       toc = System.currentTimeMillis();
       System.out.printf("Parallel time with %d processors: %d milliseconds\n", Runtime.getRuntime().availableProcessors(), toc - tic);
       System.out.println();
      
   }
  
  
   /**
   * Computes and returns the sum of the elements of a given array
   *
   * @param A an array of doubles
   * @return the sum of the elements of A
   */
   public static double sequentialSum(double[] A) {
       double sum = 0;
       for (int i = 0; i < A.length; i++) {
           sum += A[i];
       }
       return sum;
   }
  
  
   /**
   * Graded method for HW9 Problem 1
   *
   * Computes in parallel the sum of the elements of a given array
   * using the fork-join framework
   *
   * @param A an array of doubles
   * @return the sum of the elements of A
   */
   public static double parallelSum(double[] A) {
      
       // Replace this line with your return statement
       return -1;
   }
  
  
   /**
   * Your static RecursiveTask class to support parallelSum()
   * Name it SumTask
   */

}

Answer 1

Hey, I have attached the code below. In the code I have added comments for explanation wherever necessary. If you have any doubts, let me know in the comment.

CountVotesInParallel.java:

package hw9;

import java.util.*;

import java.util.concurrent.*;

import java.util.concurrent.locks.*;

public class CountVotesInParallel {

public static void main(String[] args) {

ArrayList<String> fav = new ArrayList<>();

fav.add("LeBron");

fav.add("Steph");

fav.add("Luka");

fav.add("Anthony");

fav.add("Kawhi");

fav.add("Giannis");

int n = 10;

ArrayList<String> votes = new ArrayList<>();

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

int j = (int) (Math.random() * fav.size());

votes.add(fav.get(j));

}

System.out.println(votes);

System.out.println();

long tic = System.currentTimeMillis();

System.out.println("Sequential Count: " + sequentialVoteCount(votes));

long toc = System.currentTimeMillis();

System.out.println("Sequential time: " + (toc - tic) + " milliseconds");

System.out.println();

tic = System.currentTimeMillis();

System.out.println("Parallel Count: " + parallelVoteCount(votes));

toc = System.currentTimeMillis();

System.out.printf("Parallel time with %d processors: %d milliseconds\n", Runtime.getRuntime().availableProcessors(), toc - tic);

System.out.println();

}

/**

* Sequential method for counting the number of votes for each player

*

* @param votes an array list of strings representing the names of players receiving votes

* @return a hash map that counts the number of votes each player receives;

* each key is the name of a player receiving votes, and its associated value

* is the number of votes the player receives

*/

public static HashMap<String, Integer> sequentialVoteCount(ArrayList<String> votes) {

HashMap<String, Integer> map = new HashMap<>();

for (String p : votes) {

int count = map.getOrDefault(p, 0);

map.put(p, count+1);

}

return map;

}

/**

* Graded method for HW9 Problem 2

*

* Parallel method for counting the number of votes for each player

* using fork-join and thread synchronization

*

* @param votes an array list of strings representing the names of players receiving votes

* @return a hash map that counts the number of votes each player receives;

* each key is the name of a player receiving votes, and its associated value

* is the number of votes the player receives

*/

public static HashMap<String, Integer> parallelVoteCount(ArrayList<String> votes) {

//create a ForkJoinPool object. A ForkJoinPool is an ExecutorService for running ForkJoinTasks

//in our case Recurive Tasks.

ForkJoinPool pool = new ForkJoinPool();

//create a recursiveaction class object

CountTask task = new CountTask(votes, 0, votes.size() - 1);

//execute the task and wait till the task is finished

pool.invoke(task);

//return the result

return task.map;

}

/*

* Your static RecursiveAction class to support parallelVoteCount()

* Name it CountTask

*/

static class CountTask extends RecursiveAction{

//variables

ArrayList<String> votes;

static HashMap<String, Integer> map = new HashMap<>(); //stores the result

int start, end;

//constructor

CountTask(ArrayList<String> votes , int start , int end){

this.votes = votes;

this.start = start;

this.end = end;

}

@Override

protected void compute(){

//this block will execute

//if this is only element

if(start == end){

//get the string

String p = votes.get(start);

int count = map.getOrDefault(p, 0);

map.put(p, count+1);

}

else if(end > start){

//split the task in two partitions

int mid = (start + end) / 2;

CountTask left = new CountTask(votes , start , mid);

CountTask right = new CountTask(votes , mid + 1, end);

//execute task

left.fork();

right.fork();

//join the tasks

left.join();

right.join();

}

}

}

}

Code Screenshots:

Output: