Agent Work: GitHub Contributions (Parallel)

Claude Sonnet 4.6 · COMP 322: Fundamentals of Parallel Programming

COMP 322 Homework 2: GitHub Contributions (Parallel)

Total: 100 points

Overview

Implement a concurrent version of a program that fetches and displays GitHub contributors and their total contributions across all repositories under a given organization.

Testing Your Solution

Important: This homework requires GitHub API credentials.

# Set credentials before testing
export GITHUB_USERNAME=your-username
export GITHUB_TOKEN=your-github-token

# Run tests
bin/grade workspaces/agent_hw2

To generate a GitHub token: 1. Go to https://github.com/settings/tokens/new 2. Select the repo scope 3. Generate and save the token

---

Part 1: Written Assignment (30 points)

1.1 Parallelizing the IsKColorable Algorithm (25 points)

Consider the pseudo-code of the IsKColorable algorithm:

Input: Graph g = (V, E) and k in N.
Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v)?

1  foreach Assignment f of a value in [k] to each node in V do
2      colorable <- True;
3      foreach {u, v} in E do
4          if f(u) = f(v) then
5              colorable <- False;
6              break;
7      if colorable = True then
8          return True;
9  return False;

1. (10 points) Create a parallel version using finish and async statements to maximize parallelism while ensuring correctness.

2. (5 points) What is the big-O for total WORK?

3. (5 points) Can your parallel algorithm have larger WORK than sequential? Explain.

4. (5 points) Can your parallel algorithm have smaller WORK than sequential? Explain.

5. (5 points) Is a data race possible? If so, is it benign?

---

Part 2: Programming Assignment (70 points)

Goal

The sequential version (loadContributorsSeq) causes the UI to freeze when loading. Implement loadContributorsPar with these requirements:

1. UI must NOT freeze when loading data 2. All requests and processing must be performed concurrently

Requirements

Use futures, data-driven tasks, and streams
Do NOT use finish or async
All aggregation and post-processing via concurrent streams

Test Organizations

revelation
galaxycats
moneyspyder
notch8
trabian
collectiveidea
edgecase

Implementation

Edit src/main/java/edu/rice/comp322/ContributorsUI.java: 1. Implement loadContributorsPar in the LoadContributors interface 2. Change line 65 from loadContributorsSeq to loadContributorsPar

---

Scoring

50 points: Parallel solution (no UI freeze, concurrent data loading)
5 points: Coding style and documentation
15 points: Report explaining:

- Parallel algorithm summary - Correctness and data-race-free justification - Expected work value as function of N

---

Files to Implement

src/main/java/edu/rice/comp322/ContributorsUI.java (implement loadContributorsPar)
src/main/java/edu/rice/comp322/LoadContributors.java (parallel method)

--- *COMP 322: Fundamentals of Parallel Programming, Rice University*

ContributorsUI.java5.7 KB

java

package edu.rice.comp322;

import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.util.ArrayList;
import java.util.List;
import java.util.prefs.Preferences;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;

import static edu.rice.hj.Module0.launchHabaneroApp;

/**
 * User-Interface for loading the contributors for all repositories
 * under the given organization.
 */
public class ContributorsUI extends JFrame implements LoadContributors {

    private final JTextField username = new JTextField(20);
    private final JPasswordField password = new JPasswordField(20);
    private final JTextField org = new JTextField(20);
    private final JButton load = new JButton("Load contributors");
    private final Insets insets = new Insets(3, 10, 3, 10);
    private final String[] columns = {"Login", "Contributions"};
    private final DefaultTableModel resultsModel = new DefaultTableModel(columns, 0);
    public List<User> users = new ArrayList<>();
    private final JTable results = new JTable(resultsModel);
    private final JScrollPane resultsScroll = new JScrollPane(results);
    private Preferences pref;

    public ContributorsUI() {
        init();
    }

    /**
     * Updates the contributors list displayed on the user-interface.
     * @param users a list of Users
     */
    public void updateContributors(List<User> users) {
        Object[][] values = new Object[users.size()][2];
        for (int i = 0; i < users.size(); i++) {
            values[i] = new Object[]{users.get(i).login, users.get(i).contributions};
        }
        this.users = users;
        resultsModel.setDataVector(values, columns);
    }

    /**
     * Adds action listener for load button.
     */
    private void addLoadListener() {
        load.addActionListener(e -> {
            String userParam = username.getText();
            String passParam = String.valueOf(password.getPassword());
            String orgParam = org.getText();
            if (!userParam.isEmpty() && !passParam.isEmpty()) {
                saveParams(userParam, passParam, orgParam);
            }
            new Thread(()-> {
                launchHabaneroApp(() -> {
                    try {
                        System.out.println("Loading Users ...");
                        loadContributorsSeq(userParam, passParam, orgParam); //TODO change to use parallel implementation
                    } catch (Exception exception) {
                        exception.printStackTrace();
                    }
                });
            }).start();
        });
    }

    /**
     * Sets the parameters.
     */
    public void setParams(String userParam, String passParam, String orgParam) {
        username.setText(userParam);
        password.setText(passParam);
        org.setText(orgParam);
    }

    /**
     * Saves the parameter data.
     */
    public void saveParams(String userParam, String passParam, String orgParam) {
        this.pref.put("username", userParam);
        this.pref.put("password", passParam);
        this.pref.put("org", orgParam);
    }

    /**
     * Initializes the user interface.
     */
    private void init() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 500, 350);
        resultsScroll.setPreferredSize(new Dimension(200, 200));
        JPanel contentPane = new JPanel(new GridBagLayout());
        setContentPane(contentPane);
        addLabeled("GitHub Username", username);
        addLabeled("Password/Token", password);
        addWideSeparator();
        addLabeled("Organization", org);
        addWideSeparator();
        addLoad();
        addResultsScroll();
        this.pref = Preferences.userRoot().node("edu.rice.comp322.ContributorsUI");
        setParams(pref.get("username", ""), pref.get("password", ""), pref.get("org", ""));
        addLoadListener();
        updateContributors(new ArrayList<>());
    }


    /**
     * Adds labeled components.
     */
    private void addLabeled(String label, JComponent component) {
        GridBagConstraints constraintslbl =  new GridBagConstraints();
        constraintslbl.gridx = 0;
        constraintslbl.insets = insets;
        add(new JLabel(label), constraintslbl);
        GridBagConstraints constraintsComponent = new GridBagConstraints();
        constraintsComponent.gridx = 1;
        constraintsComponent.insets = insets;
        constraintsComponent.anchor = GridBagConstraints.WEST;
        constraintsComponent.fill = GridBagConstraints.HORIZONTAL;
        constraintsComponent.weightx = 1.0;
        add(component, constraintsComponent);
    }

    /**
     * Adds separator.
     */
    private void addWideSeparator() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        constraints.fill = GridBagConstraints.HORIZONTAL;
        add(new JSeparator(), constraints);
    }

    /**
     * Adds load button.
     */
    private void addLoad() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        add(load, constraints);
    }

    /**
     * Add scrollbar for results.
     */
    private void addResultsScroll() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        constraints.weightx = 1.0;
        constraints.weighty = 1.0;
        constraints.fill = GridBagConstraints.BOTH;
        add(resultsScroll, constraints);
    }

    public void start() {
        this.setVisible(true);
    }

}

ContributorsUI.java5.7 KB

java

package edu.rice.comp322;

import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.util.ArrayList;
import java.util.List;
import java.util.prefs.Preferences;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;

import static edu.rice.hj.Module0.launchHabaneroApp;

/**
 * User-Interface for loading the contributors for all repositories
 * under the given organization.
 */
public class ContributorsUI extends JFrame implements LoadContributors {

    private final JTextField username = new JTextField(20);
    private final JPasswordField password = new JPasswordField(20);
    private final JTextField org = new JTextField(20);
    private final JButton load = new JButton("Load contributors");
    private final Insets insets = new Insets(3, 10, 3, 10);
    private final String[] columns = {"Login", "Contributions"};
    private final DefaultTableModel resultsModel = new DefaultTableModel(columns, 0);
    public List<User> users = new ArrayList<>();
    private final JTable results = new JTable(resultsModel);
    private final JScrollPane resultsScroll = new JScrollPane(results);
    private Preferences pref;

    public ContributorsUI() {
        init();
    }

    /**
     * Updates the contributors list displayed on the user-interface.
     * @param users a list of Users
     */
    public void updateContributors(List<User> users) {
        Object[][] values = new Object[users.size()][2];
        for (int i = 0; i < users.size(); i++) {
            values[i] = new Object[]{users.get(i).login, users.get(i).contributions};
        }
        this.users = users;
        resultsModel.setDataVector(values, columns);
    }

    /**
     * Adds action listener for load button.
     */
    private void addLoadListener() {
        load.addActionListener(e -> {
            String userParam = username.getText();
            String passParam = String.valueOf(password.getPassword());
            String orgParam = org.getText();
            if (!userParam.isEmpty() && !passParam.isEmpty()) {
                saveParams(userParam, passParam, orgParam);
            }
            new Thread(()-> {
                launchHabaneroApp(() -> {
                    try {
                        System.out.println("Loading Users ...");
                        loadContributorsSeq(userParam, passParam, orgParam); //TODO change to use parallel implementation
                    } catch (Exception exception) {
                        exception.printStackTrace();
                    }
                });
            }).start();
        });
    }

    /**
     * Sets the parameters.
     */
    public void setParams(String userParam, String passParam, String orgParam) {
        username.setText(userParam);
        password.setText(passParam);
        org.setText(orgParam);
    }

    /**
     * Saves the parameter data.
     */
    public void saveParams(String userParam, String passParam, String orgParam) {
        this.pref.put("username", userParam);
        this.pref.put("password", passParam);
        this.pref.put("org", orgParam);
    }

    /**
     * Initializes the user interface.
     */
    private void init() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 500, 350);
        resultsScroll.setPreferredSize(new Dimension(200, 200));
        JPanel contentPane = new JPanel(new GridBagLayout());
        setContentPane(contentPane);
        addLabeled("GitHub Username", username);
        addLabeled("Password/Token", password);
        addWideSeparator();
        addLabeled("Organization", org);
        addWideSeparator();
        addLoad();
        addResultsScroll();
        this.pref = Preferences.userRoot().node("edu.rice.comp322.ContributorsUI");
        setParams(pref.get("username", ""), pref.get("password", ""), pref.get("org", ""));
        addLoadListener();
        updateContributors(new ArrayList<>());
    }


    /**
     * Adds labeled components.
     */
    private void addLabeled(String label, JComponent component) {
        GridBagConstraints constraintslbl =  new GridBagConstraints();
        constraintslbl.gridx = 0;
        constraintslbl.insets = insets;
        add(new JLabel(label), constraintslbl);
        GridBagConstraints constraintsComponent = new GridBagConstraints();
        constraintsComponent.gridx = 1;
        constraintsComponent.insets = insets;
        constraintsComponent.anchor = GridBagConstraints.WEST;
        constraintsComponent.fill = GridBagConstraints.HORIZONTAL;
        constraintsComponent.weightx = 1.0;
        add(component, constraintsComponent);
    }

    /**
     * Adds separator.
     */
    private void addWideSeparator() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        constraints.fill = GridBagConstraints.HORIZONTAL;
        add(new JSeparator(), constraints);
    }

    /**
     * Adds load button.
     */
    private void addLoad() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        add(load, constraints);
    }

    /**
     * Add scrollbar for results.
     */
    private void addResultsScroll() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        constraints.weightx = 1.0;
        constraints.weighty = 1.0;
        constraints.fill = GridBagConstraints.BOTH;
        add(resultsScroll, constraints);
    }

    public void start() {
        this.setVisible(true);
    }

}

ContributorsUI.java5.6 KB

java

package edu.rice.comp322;

import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.util.ArrayList;
import java.util.List;
import java.util.prefs.Preferences;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;

import static edu.rice.hj.Module0.launchHabaneroApp;

/**
 * User-Interface for loading the contributors for all repositories
 * under the given organization.
 */
public class ContributorsUI extends JFrame implements LoadContributors {

    private final JTextField username = new JTextField(20);
    private final JPasswordField password = new JPasswordField(20);
    private final JTextField org = new JTextField(20);
    private final JButton load = new JButton("Load contributors");
    private final Insets insets = new Insets(3, 10, 3, 10);
    private final String[] columns = {"Login", "Contributions"};
    private final DefaultTableModel resultsModel = new DefaultTableModel(columns, 0);
    public List<User> users = new ArrayList<>();
    private final JTable results = new JTable(resultsModel);
    private final JScrollPane resultsScroll = new JScrollPane(results);
    private Preferences pref;

    public ContributorsUI() {
        init();
    }

    /**
     * Updates the contributors list displayed on the user-interface.
     * @param users a list of Users
     */
    public void updateContributors(List<User> users) {
        Object[][] values = new Object[users.size()][2];
        for (int i = 0; i < users.size(); i++) {
            values[i] = new Object[]{users.get(i).login, users.get(i).contributions};
        }
        this.users = users;
        resultsModel.setDataVector(values, columns);
    }

    /**
     * Adds action listener for load button.
     */
    private void addLoadListener() {
        load.addActionListener(e -> {
            String userParam = username.getText();
            String passParam = String.valueOf(password.getPassword());
            String orgParam = org.getText();
            if (!userParam.isEmpty() && !passParam.isEmpty()) {
                saveParams(userParam, passParam, orgParam);
            }
            new Thread(()-> {
                launchHabaneroApp(() -> {
                    try {
                        System.out.println("Loading Users ...");
                        loadContributorsPar(userParam, passParam, orgParam);
                    } catch (Exception exception) {
                        exception.printStackTrace();
                    }
                });
            }).start();
        });
    }

    /**
     * Sets the parameters.
     */
    public void setParams(String userParam, String passParam, String orgParam) {
        username.setText(userParam);
        password.setText(passParam);
        org.setText(orgParam);
    }

    /**
     * Saves the parameter data.
     */
    public void saveParams(String userParam, String passParam, String orgParam) {
        this.pref.put("username", userParam);
        this.pref.put("password", passParam);
        this.pref.put("org", orgParam);
    }

    /**
     * Initializes the user interface.
     */
    private void init() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 500, 350);
        resultsScroll.setPreferredSize(new Dimension(200, 200));
        JPanel contentPane = new JPanel(new GridBagLayout());
        setContentPane(contentPane);
        addLabeled("GitHub Username", username);
        addLabeled("Password/Token", password);
        addWideSeparator();
        addLabeled("Organization", org);
        addWideSeparator();
        addLoad();
        addResultsScroll();
        this.pref = Preferences.userRoot().node("edu.rice.comp322.ContributorsUI");
        setParams(pref.get("username", ""), pref.get("password", ""), pref.get("org", ""));
        addLoadListener();
        updateContributors(new ArrayList<>());
    }


    /**
     * Adds labeled components.
     */
    private void addLabeled(String label, JComponent component) {
        GridBagConstraints constraintslbl =  new GridBagConstraints();
        constraintslbl.gridx = 0;
        constraintslbl.insets = insets;
        add(new JLabel(label), constraintslbl);
        GridBagConstraints constraintsComponent = new GridBagConstraints();
        constraintsComponent.gridx = 1;
        constraintsComponent.insets = insets;
        constraintsComponent.anchor = GridBagConstraints.WEST;
        constraintsComponent.fill = GridBagConstraints.HORIZONTAL;
        constraintsComponent.weightx = 1.0;
        add(component, constraintsComponent);
    }

    /**
     * Adds separator.
     */
    private void addWideSeparator() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        constraints.fill = GridBagConstraints.HORIZONTAL;
        add(new JSeparator(), constraints);
    }

    /**
     * Adds load button.
     */
    private void addLoad() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        add(load, constraints);
    }

    /**
     * Add scrollbar for results.
     */
    private void addResultsScroll() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        constraints.weightx = 1.0;
        constraints.weighty = 1.0;
        constraints.fill = GridBagConstraints.BOTH;
        add(resultsScroll, constraints);
    }

    public void start() {
        this.setVisible(true);
    }

}

ContributorsUI.java5.6 KB

java

package edu.rice.comp322;

import java.awt.Dimension;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.Insets;
import java.util.ArrayList;
import java.util.List;
import java.util.prefs.Preferences;
import javax.swing.*;
import javax.swing.table.DefaultTableModel;

import static edu.rice.hj.Module0.launchHabaneroApp;

/**
 * User-Interface for loading the contributors for all repositories
 * under the given organization.
 */
public class ContributorsUI extends JFrame implements LoadContributors {

    private final JTextField username = new JTextField(20);
    private final JPasswordField password = new JPasswordField(20);
    private final JTextField org = new JTextField(20);
    private final JButton load = new JButton("Load contributors");
    private final Insets insets = new Insets(3, 10, 3, 10);
    private final String[] columns = {"Login", "Contributions"};
    private final DefaultTableModel resultsModel = new DefaultTableModel(columns, 0);
    public List<User> users = new ArrayList<>();
    private final JTable results = new JTable(resultsModel);
    private final JScrollPane resultsScroll = new JScrollPane(results);
    private Preferences pref;

    public ContributorsUI() {
        init();
    }

    /**
     * Updates the contributors list displayed on the user-interface.
     * @param users a list of Users
     */
    public void updateContributors(List<User> users) {
        Object[][] values = new Object[users.size()][2];
        for (int i = 0; i < users.size(); i++) {
            values[i] = new Object[]{users.get(i).login, users.get(i).contributions};
        }
        this.users = users;
        resultsModel.setDataVector(values, columns);
    }

    /**
     * Adds action listener for load button.
     */
    private void addLoadListener() {
        load.addActionListener(e -> {
            String userParam = username.getText();
            String passParam = String.valueOf(password.getPassword());
            String orgParam = org.getText();
            if (!userParam.isEmpty() && !passParam.isEmpty()) {
                saveParams(userParam, passParam, orgParam);
            }
            new Thread(()-> {
                launchHabaneroApp(() -> {
                    try {
                        System.out.println("Loading Users ...");
                        loadContributorsPar(userParam, passParam, orgParam);
                    } catch (Exception exception) {
                        exception.printStackTrace();
                    }
                });
            }).start();
        });
    }

    /**
     * Sets the parameters.
     */
    public void setParams(String userParam, String passParam, String orgParam) {
        username.setText(userParam);
        password.setText(passParam);
        org.setText(orgParam);
    }

    /**
     * Saves the parameter data.
     */
    public void saveParams(String userParam, String passParam, String orgParam) {
        this.pref.put("username", userParam);
        this.pref.put("password", passParam);
        this.pref.put("org", orgParam);
    }

    /**
     * Initializes the user interface.
     */
    private void init() {
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setBounds(100, 100, 500, 350);
        resultsScroll.setPreferredSize(new Dimension(200, 200));
        JPanel contentPane = new JPanel(new GridBagLayout());
        setContentPane(contentPane);
        addLabeled("GitHub Username", username);
        addLabeled("Password/Token", password);
        addWideSeparator();
        addLabeled("Organization", org);
        addWideSeparator();
        addLoad();
        addResultsScroll();
        this.pref = Preferences.userRoot().node("edu.rice.comp322.ContributorsUI");
        setParams(pref.get("username", ""), pref.get("password", ""), pref.get("org", ""));
        addLoadListener();
        updateContributors(new ArrayList<>());
    }


    /**
     * Adds labeled components.
     */
    private void addLabeled(String label, JComponent component) {
        GridBagConstraints constraintslbl =  new GridBagConstraints();
        constraintslbl.gridx = 0;
        constraintslbl.insets = insets;
        add(new JLabel(label), constraintslbl);
        GridBagConstraints constraintsComponent = new GridBagConstraints();
        constraintsComponent.gridx = 1;
        constraintsComponent.insets = insets;
        constraintsComponent.anchor = GridBagConstraints.WEST;
        constraintsComponent.fill = GridBagConstraints.HORIZONTAL;
        constraintsComponent.weightx = 1.0;
        add(component, constraintsComponent);
    }

    /**
     * Adds separator.
     */
    private void addWideSeparator() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        constraints.fill = GridBagConstraints.HORIZONTAL;
        add(new JSeparator(), constraints);
    }

    /**
     * Adds load button.
     */
    private void addLoad() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        add(load, constraints);
    }

    /**
     * Add scrollbar for results.
     */
    private void addResultsScroll() {
        GridBagConstraints constraints = new GridBagConstraints();
        constraints.gridx = 0;
        constraints.gridwidth = 2;
        constraints.insets = insets;
        constraints.weightx = 1.0;
        constraints.weighty = 1.0;
        constraints.fill = GridBagConstraints.BOTH;
        add(resultsScroll, constraints);
    }

    public void start() {
        this.setVisible(true);
    }

}

COMP 322 Homework 2: GitHub Contributions (Parallel)

Part 1: Written Questions (30 points)

1.1 Parallelizing the IsKColorable Algorithm

Consider the pseudo-code of the IsKColorable algorithm:

Input: Graph g = (V, E) and k in N.
Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v)?

1  foreach Assignment f of a value in [k] to each node in V do
2      colorable <- True;
3      foreach {u, v} in E do
4          if f(u) = f(v) then
5              colorable <- False;
6              break;
7      if colorable = True then
8          return True;
9  return False;

---

1.1.1 Parallel Version (10 points)

> Create a parallel version using finish and async statements to maximize parallelism while ensuring correctness.

Your Answer:

Input: Graph g = (V, E) and k in N.
Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v)?

result <- False
finish do
    foreach Assignment f of a value in [k] to each node in V do
        async do
            colorable <- True
            foreach {u, v} in E do
                if f(u) = f(v) then
                    colorable <- False
                    break
            if colorable = True then
                result <- True   // potential benign data race (see 1.1.5)
return result

Parallelization Strategy: The outer foreach loop over all k^|V| assignments is parallelized with async, since each assignment can be checked independently. The finish at the top level ensures all async tasks complete before we return result. The inner loop over edges remains sequential within each async task—parallelizing it would complicate the break early-exit and would only add overhead given that correctness checking is data-independent per assignment.

---

1.1.2 Total Work Analysis (5 points)

> What is the big-O for total WORK?

Your Answer:

Total WORK = O(k^|V| · |E|)

There are k^|V| possible assignments. For each assignment, we iterate over all |E| edges in the worst case (no early exit). The async spawning adds O(k^|V|) overhead (one spawn per assignment), which is dominated by the edge-checking cost. Therefore total work is O(k^|V| · |E|).

---

1.1.3 Larger Work Than Sequential? (5 points)

> Can your parallel algorithm have LARGER WORK than sequential? Explain.

Your Answer:

Yes. The parallel algorithm can have larger work than the sequential version due to:

1. Async spawn overhead: Each async invocation carries a constant overhead for task creation and scheduling. The sequential algorithm pays no such overhead. 2. Lost early exits: The sequential algorithm can return True immediately upon finding the first valid coloring, short-circuiting all remaining assignments. In the parallel version, all k^|V| async tasks are already spawned before any result is found, so even if one task discovers a valid coloring early, the other tasks continue running. This means in the best case (e.g., the first assignment is valid), the parallel version does O(k^|V| · |E|) work while the sequential version does O(|E|) work.

In short: parallel work ≥ sequential work in all cases, and can be strictly larger due to spawn overhead and inability to short-circuit.

---

1.1.4 Smaller Work Than Sequential? (5 points)

> Can your parallel algorithm have SMALLER WORK than sequential? Explain.

Your Answer:

No. The parallel algorithm cannot have smaller work than the sequential version.

Work is the total number of operations across all processors summed together (i.e., the 1-processor execution time of the parallel program). Every edge check done by a parallel async task is also a unit of work. Since the parallel version spawns all assignment checks eagerly (no early exit), it does at least as much computational work as the sequential version, plus the async spawn overhead.

To clarify: the parallel version may achieve a shorter span (critical path) than the sequential version, because independent tasks run simultaneously—but span is not the same as work. Work is never reduced by parallelism alone; it can only increase due to synchronization and spawn overhead.

---

1.1.5 Data Race Analysis (5 points)

> Is a data race possible? If so, is it benign?

Your Answer:

Yes, there is a data race on the shared variable result. Multiple async tasks can concurrently write result <- True if they each find a valid coloring.

Is it benign? Yes, this race is benign. Here is why:

result is initialized to False.
Each async task only ever writes True to result (never writes False).
The final answer is "True if at least one assignment is valid, False otherwise."
Whether one or many tasks write True simultaneously, the result ends up as True exactly when it should.
Reading result only happens after finish (after all tasks complete), so there is no read-write race at the observation point.

The write-write race on result is benign because all concurrent writes assign the same logical value (True), and the outcome is correct regardless of the order or interleaving of those writes. On modern hardware, a boolean write is typically atomic, further ensuring correctness in practice.

---

Part 2: Report (15 points)

A. Algorithm Summary

The parallel implementation loadContributorsPar uses HJlib futures and data-driven tasks (asyncAwait) along with Java streams for aggregation:

1. Fetch repos sequentially (one API call): The list of repositories under the organization is fetched with a single blocking call. This is inherently sequential because we need the repo list before we can spawn parallel fetches.

2. Parallel contributor fetches (futures): For each repository, a future() is spawned that calls getRepContributorsCall(org, repoName).execute().body(). All N futures are created concurrently, so the N HTTP requests overlap in time. Each future runs in a separate HJlib worker thread.

3. Data-driven aggregation (`asyncAwait`): A single asyncAwait(futures, body) data-driven task is registered. Its body only executes once ALL N futures have completed. Inside the body: - Results from each future are collected via f.get() (safe—no SuspendableException because all futures are guaranteed done). - User contributions are aggregated with a stream groupingBy + summingInt collector. - The result list is sorted in descending order by contributions. - updateContributors() is called to update the UI.

4. Return value: repos.size() is returned immediately after registering the asyncAwait, before the body runs. The body completes before the launchHabaneroApp implicit finish barrier.

The UI does not freeze because all work runs inside a background Thread that wraps launchHabaneroApp.

---

B. Correctness and Data-Race-Free Justification

Correctness: The parallel implementation produces the same results as the sequential version because:

The same API calls are made to the same endpoints.
The aggregation (summing contributions per user) uses a stream groupingBy + summingInt, which is mathematically equivalent to the sequential accumulation loop in loadContributorsSeq.
The sort criterion is identical (descending by contributions).
The asyncAwait body runs after ALL futures complete, so no partial results are used.

Data-race-free: The implementation is free from data races because:

Each future closure captures only thread-local variables (repoName, service, org) that are read-only—no shared mutable state is accessed inside the futures.
The asyncAwait body runs as a single async task (not multiple concurrent tasks), so the allUsers list accumulation is sequential within that task.
updateContributors is called from within the single asyncAwait body, with no concurrent writes to the users list.
The futures list itself is populated entirely before any future completes (HJlib futures are lazy-started), and is only read (not modified) inside asyncAwait.

There are no shared mutable variables accessed concurrently.

---

C. Work Analysis

Let N = number of repositories, M = total contributor entries across all repos.

Work breakdown (with `asyncSpawnCostMetrics = 1`):

Operation	Work
Fetch repo list (sequential)	O(1)
Spawn N futures	O(N) — each spawn counts as 1 unit
Spawn 1 asyncAwait data-driven task	O(1)
asyncAwait body: collect + aggregate + sort	O(M log M) sequential work within the task

Total Work = O(N + M log M)

For the purposes of the abstract metrics test (which counts only async spawns with cost 1 each), the work is exactly N (futures) + 1 (asyncAwait) = N + 1, which satisfies the test bound of work ≤ N + 1.

The critical path (span) is O(1) for spawning + max time for a single HTTP request + O(M log M) for aggregation—much shorter than the O(N · request_time) sequential critical path, demonstrating the parallelism benefit.

---

COMP 322 Homework 2 — Grading Report

---

Part 1: Written Questions (30 points)

1.1.1 Parallel Version — 9/10

The student provides a correct and well-structured parallel version:

✅ Uses finish to wait for all async tasks before returning
✅ Uses async for each assignment in the outer loop (correct parallelization target)
✅ Keeps inner edge loop sequential within each async (preserving break optimization)
✅ Sets shared result ← True when a valid coloring is found
✅ Excellent accompanying explanation of the parallelization strategy

Minor deduction (-1): The student does not use AtomicBoolean or isolated for the shared result variable. While the student explicitly acknowledges the data race and cross-references their benign analysis in 1.1.5 (which is correct), the rubric expects "proper synchronization for shared result (isolated/atomic)" for full marks. Per the rubric, "correct structure with minor issues (missing isolated)" falls in the 8–9 range. Given the student's clear awareness and deliberate design choice (with correct justification), this earns the top of that range.

---

1.1.2 Total Work Analysis — 5/5

> Total WORK = O(k^|V| · |E|)

This matches the reference solution exactly. The student provides a clear breakdown:

k^|V| possible assignments
O(|E|) work per assignment in the worst case
Notes that async spawn overhead O(k^|V|) is dominated

Excellent.

---

1.1.3 Larger Work Than Sequential? — 5/5

> Yes.

The student gives two compelling reasons: 1. Async spawn overhead — constant per-task creation cost 2. Lost early exits — sequential can return True after finding the first valid coloring, while parallel has already spawned all k^|V| tasks

The second point is the key insight the rubric is looking for, and the student explains it with a concrete example (first assignment valid → sequential does O(|E|) vs. parallel does O(k^|V| · |E|)). The concluding statement "parallel work ≥ sequential work in all cases" is precise.

---

1.1.4 Smaller Work Than Sequential? — 5/5

> No.

The student correctly explains:

Work = total operations across all processors (not wall-clock time)
Parallel spawns all assignment checks eagerly, doing at least as much work
Clearly distinguishes work from span: "span is not the same as work. Work is never reduced by parallelism alone"

This matches the reference solution and demonstrates strong conceptual understanding.

---

1.1.5 Data Race Analysis — 5/5

The student correctly identifies:

✅ Yes, data race exists on shared variable result
✅ Multiple async tasks can concurrently write result ← True
✅ Yes, it is benign because:

- result initialized to False, only ever written as True - Outcome correct regardless of write ordering - Read of result occurs only after finish (no read-write race at observation point)

The student goes beyond the reference by noting that on modern hardware boolean writes are typically atomic. This is a thorough and precise analysis.

---

Part 1 Subtotal: 29/30

---

Part 2: Report (15 points)

Section A: Algorithm Summary — 5/5

The student provides an excellent step-by-step description: 1. Sequential repo list fetch (with justification for why it's sequential) 2. Parallel contributor fetches via future() — N concurrent HTTP requests 3. Data-driven aggregation via asyncAwait — executes after all futures resolve 4. Stream-based grouping, summing, and sorting 5. UI non-blocking via background Thread wrapping launchHabaneroApp

The description of the return value timing and the implicit finish barrier shows deep understanding of the HJlib execution model.

---

Section B: Correctness and Data-Race-Free Justification — 5/5

Correctness: Clearly explains equivalence to sequential — same API calls, same aggregation logic (groupingBy + summingInt ≡ sequential accumulation), same sort criterion, and no partial results used (asyncAwait guarantees all futures complete).

Data-race-free: Thorough analysis:

Future closures capture only read-only/thread-local variables
asyncAwait body is a single task (sequential accumulation within)
updateContributors called from single task body
futures list populated before any future completes and only read afterward

No gaps in the reasoning.

---

Section C: Work Analysis — 5/5

Clear and well-structured:

Defines N (repos) and M (total contributor entries)
Provides a detailed work breakdown table
Total Work = O(N + M log M) — correct
Also addresses abstract metrics: work = N + 1 (satisfies test bound)
Compares span: parallel O(max_request + M log M) vs. sequential O(N · request_time)

The dual perspective (theoretical complexity + test framework metrics) is particularly strong.

---

Part 2 Subtotal: 15/15

---

Summary Table

Problem	Score	Max	Notes
1.1.1 Parallel Version	9	10	Missing isolated/atomic on shared result (-1)
1.1.2 Total Work	5	5	Correct: O(k^{\	V\	} · \	E\	)
1.1.3 Larger Work?	5	5	Yes — early termination loss, spawn overhead
1.1.4 Smaller Work?	5	5	No — work ≠ span, clearly explained
1.1.5 Data Race?	5	5	Yes, benign — write-write of same value
Report A: Summary	5	5	Thorough futures + asyncAwait description
Report B: Correctness	5	5	Equivalence + race-freedom well justified
Report C: Work Analysis	5	5	O(N + M log M) with span comparison

Total: 44/45

.mcp.json

diff --git a/.mcp.json b/.mcp.json
deleted file mode 100644
index 98da374..0000000
--- a/.mcp.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "mcpServers": {
-    "bscs-bench": {
-      "command": "/Users/bebe/Code/bscs-bench/bin/bscs-mcp",
-      "args": [
-        "--workspace",
-        "./writeup.md b/writeup.md
index 5e8f3d0..b1532fc 100644
--- a/writeup.md
+++ b/writeup.md
@@ -29,11 +29,25 @@ Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v
 
 **Your Answer:**
 
-```java
-// Write your parallel pseudocode here
+```
+Input: Graph g = (V, E) and k in N.
+Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v)?
+
+result <- False
+finish do
+    foreach Assignment f of a value in [k] to each node in V do
+        async do
+            colorable <- True
+            foreach {u, v} in E do
+                if f(u) = f(v) then
+                    colorable <- False
+                    break
+            if colorable = True then
+                result <- True   // potential benign data race (see 1.1.5)
+return result
 ```
 
-[Explain your parallelization strategy and synchronization approach]
+**Parallelization Strategy:** The outer `foreach` loop over all k^|V| assignments is parallelized with `async`, since each assignment can be checked independently. The `finish` at the top level ensures all async tasks complete before we return `result`. The inner loop over edges remains sequential within each async task—parallelizing it would complicate the `break` early-exit and would only add overhead given that correctness checking is data-independent per assignment.
 
 ---
 
@@ -43,7 +57,9 @@ Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v
 
 **Your Answer:**
 
-[Provide the big-O formula in terms of k, |V|, and |E|, with explanation]
+Total WORK = O(k^|V| · |E|)
+
+There are k^|V| possible assignments. For each assignment, we iterate over all |E| edges in the worst case (no early exit). The async spawning adds O(k^|V|) overhead (one spawn per assignment), which is dominated by the edge-checking cost. Therefore total work is O(k^|V| · |E|).
 
 ---
 
@@ -53,7 +69,12 @@ Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v
 
 **Your Answer:**
 
-[Yes/No with detailed explanation]
+Yes. The parallel algorithm can have **larger** work than the sequential version due to:
+
+1. **Async spawn overhead:** Each `async` invocation carries a constant overhead for task creation and scheduling. The sequential algorithm pays no such overhead.
+2. **Lost early exits:** The sequential algorithm can `return True` immediately upon finding the first valid coloring, short-circuiting all remaining assignments. In the parallel version, all k^|V| async tasks are already spawned before any result is found, so even if one task discovers a valid coloring early, the other tasks continue running. This means in the best case (e.g., the first assignment is valid), the parallel version does O(k^|V| · |E|) work while the sequential version does O(|E|) work.
+
+In short: parallel work ≥ sequential work in all cases, and can be strictly larger due to spawn overhead and inability to short-circuit.
 
 ---
 
@@ -63,7 +84,11 @@ Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v
 
 **Your Answer:**
 
-[Yes/No with detailed explanation. Distinguish between Work and Span.]
+No. The parallel algorithm **cannot** have smaller work than the sequential version.
+
+Work is the total number of operations across all processors summed together (i.e., the 1-processor execution time of the parallel program). Every edge check done by a parallel async task is also a unit of work. Since the parallel version spawns all assignment checks eagerly (no early exit), it does at least as much computational work as the sequential version, plus the async spawn overhead.
+
+To clarify: the parallel version may achieve a shorter **span** (critical path) than the sequential version, because independent tasks run simultaneously—but span is not the same as work. Work is never reduced by parallelism alone; it can only increase due to synchronization and spawn overhead.
 
 ---
 
@@ -73,7 +98,17 @@ Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v
 
 **Your Answer:**
 
-[Identify shared variables, analyze concurrent access patterns, and determine if any race is benign]
+Yes, there is a data race on the shared variable `result`. Multiple async tasks can concurrently write `result <- True` if they each find a valid coloring.
+
+**Is it benign?** Yes, this race is benign. Here is why:
+
+- `result` is initialized to `False`.
+- Each async task only ever writes `True` to `result` (never writes `False`).
+- The final answer is "True if at least one assignment is valid, False otherwise."
+- Whether one or many tasks write `True` simultaneously, the result ends up as `True` exactly when it should.
+- Reading `result` only happens after `finish` (after all tasks complete), so there is no read-write race at the observation point.
+
+The write-write race on `result` is benign because all concurrent writes assign the same logical value (`True`), and the outcome is correct regardless of the order or interleaving of those writes. On modern hardware, a boolean write is typically atomic, further ensuring correctness in practice.
 
 ---
 
@@ -81,29 +116,59 @@ Output: Does there exist f : V -> [k] such that for all {u, v} in E, f(u) != f(v
 
 ### A. Algorithm Summary
 
-[Describe your parallel implementation of loadContributorsPar:
-- What parallel constructs did you use (futures, streams)?
-- How are API calls parallelized?
-- How is data aggregation performed?]
+The parallel implementation `loadContributorsPar` uses **HJlib futures** and **data-driven tasks** (`asyncAwait`) along with Java **streams** for aggregation:
+
+1. **Fetch repos sequentially (one API call):** The list of repositories under the organization is fetched with a single blocking call. This is inherently sequential because we need the repo list before we can spawn parallel fetches.
+
+2. **Parallel contributor fetches (futures):** For each repository, a `future()` is spawned that calls `getRepContributorsCall(org, repoName).execute().body()`. All N futures are created concurrently, so the N HTTP requests overlap in time. Each future runs in a separate HJlib worker thread.
+
+3. **Data-driven aggregation (`asyncAwait`):** A single `asyncAwait(futures, body)` data-driven task is registered. Its body only executes once ALL N futures have completed. Inside the body:
+   - Results from each future are collected via `f.get()` (safe—no `SuspendableException` because all futures are guaranteed done).
+   - User contributions are aggregated with a stream `groupingBy` + `summingInt` collector.
+   - The result list is sorted in descending order by contributions.
+   - `updateContributors()` is called to update the UI.
+
+4. **Return value:** `repos.size()` is returned immediately after registering the `asyncAwait`, before the body runs. The body completes before the `launchHabaneroApp` implicit finish barrier.
+
+The UI does not freeze because all work runs inside a background `Thread` that wraps `launchHabaneroApp`.
 
 ---
 
 ### B. Correctness and Data-Race-Free Justification
 
-[Explain why your implementation:
-1. Produces the same results as the sequential version
-2. Is free from data races
-3. Correctly handles aggregation (e.g., summing contributions)]
+**Correctness:** The parallel implementation produces the same results as the sequential version because:
+- The same API calls are made to the same endpoints.
+- The aggregation (summing contributions per user) uses a stream `groupingBy` + `summingInt`, which is mathematically equivalent to the sequential accumulation loop in `loadContributorsSeq`.
+- The sort criterion is identical (descending by contributions).
+- The `asyncAwait` body runs after ALL futures complete, so no partial results are used.
+
+**Data-race-free:** The implementation is free from data races because:
+- Each future closure captures only thread-local variables (`repoName`, `service`, `org`) that are read-only—no shared mutable state is accessed inside the futures.
+- The `asyncAwait` body runs as a single async task (not multiple concurrent tasks), so the `allUsers` list accumulation is sequential within that task.
+- `updateContributors` is called from within the single `asyncAwait` body, with no concurrent writes to the users list.
+- The `futures` list itself is populated entirely before any future completes (HJlib futures are lazy-started), and is only read (not modified) inside `asyncAwait`.
+
+There are no shared mutable variables accessed concurrently.
 
 ---
 
 ### C. Work Analysis
 
-Let N = number of repositories and M = total number of contributors across all repos.
+Let N = number of repositories, M = total contributor entries across all repos.
+
+**Work breakdown (with `asyncSpawnCostMetrics = 1`):**
+
+| Operation | Work |
+|-----------|------|
+| Fetch repo list (sequential) | O(1) |
+| Spawn N futures | O(N) — each spawn counts as 1 unit |
+| Spawn 1 asyncAwait data-driven task | O(1) |
+| asyncAwait body: collect + aggregate + sort | O(M log M) sequential work within the task |
+
+**Total Work = O(N + M log M)**
+
+For the purposes of the abstract metrics test (which counts only async spawns with cost 1 each), the work is exactly N (futures) + 1 (asyncAwait) = N + 1, which satisfies the test bound of `work ≤ N + 1`.
 
-[Provide the Work formula as a function of N and M, and explain:
-- Work for API calls
-- Work for data aggregation
-- Total expected Work]
+The critical path (span) is O(1) for spawning + max time for a single HTTP request + O(M log M) for aggregation—much shorter than the O(N · request_time) sequential critical path, demonstrating the parallelism benefit.
 
 ---

Agent Work: GitHub Contributions (Parallel)

COMP 322 Homework 2: GitHub Contributions (Parallel)

Overview

Testing Your Solution

Part 1: Written Assignment (30 points)

1.1 Parallelizing the IsKColorable Algorithm (25 points)

Part 2: Programming Assignment (70 points)

Goal

Requirements

Test Organizations

Implementation

Scoring

Files to Implement

COMP 322 Homework 2: GitHub Contributions (Parallel)

Part 1: Written Questions (30 points)

1.1 Parallelizing the IsKColorable Algorithm

1.1.1 Parallel Version (10 points)

1.1.2 Total Work Analysis (5 points)

1.1.3 Larger Work Than Sequential? (5 points)

1.1.4 Smaller Work Than Sequential? (5 points)

1.1.5 Data Race Analysis (5 points)

Part 2: Report (15 points)

A. Algorithm Summary

B. Correctness and Data-Race-Free Justification

C. Work Analysis

COMP 322 Homework 2 — Grading Report

Part 1: Written Questions (30 points)

1.1.1 Parallel Version — 9/10

1.1.2 Total Work Analysis — 5/5

1.1.3 Larger Work Than Sequential? — 5/5

1.1.4 Smaller Work Than Sequential? — 5/5

1.1.5 Data Race Analysis — 5/5

Part 1 Subtotal: 29/30

Part 2: Report (15 points)

Section A: Algorithm Summary — 5/5

Section B: Correctness and Data-Race-Free Justification — 5/5

Section C: Work Analysis — 5/5

Part 2 Subtotal: 15/15

Summary Table

Sub-Model Usage