~ /phase-2 /work-log
Phase II · Work log

Who did what, and in what order.

This log follows the task ownership and dependency flow from the Phase II plan dashboard. Every item was completed.

5 owners28 tasks4 milestones · all complete
Phase II plan dashboard

Dependency chain#

Work passed from one owner to the next in this order:

Danah · code→ Shoug · measure→ Aryam · metrics→ Layan · graphs→ Rana · report

Danah finalized the code. Shoug ran the official measurements. Aryam turned the measurements into tables and metrics. Layan created graphs and the interpretation from the final table. Rana integrated everything into the report and the submission package.

Milestones#

Milestone Description Status
M1 Code modification complete Completed
M2 Official benchmark dataset complete Completed
M3 Tables, graphs and report content integrated Completed
M4 Final submission folder and ZIP packaging Completed

Ownership#

Owner Role Main responsibility Status
Danah Code modification Modify the Java code, verify correctness, comment it and freeze the final version Completed
Shoug Measurement & system Run the official benchmarks, record raw times, compute averages and capture machine specs Completed
Aryam Metrics & tables Compute speedup and % improvement and prepare the formatted results tables Completed
Layan Graphs & analysis Create graphs, identify the performance decrease point and write the interpretation Completed
Rana Report & integration Integrate tables and graphs, write the report, organize the submission and create the ZIP Completed

Step-by-step log#

Danah · Code modification
  1. Opened the existing Java program.
  2. Changed the computation to calculate x^3.
  3. Kept generated values below 100.
  4. Made the thread count configurable.
  5. Added correctness checks against the single-thread result.
  6. Compiled and tested before official timing.
  7. Cleaned up and commented the code.
  8. Delivered the final version before benchmarking.

Deliverable: the final Java benchmark code.

Shoug · Measurement & system
  1. Received the final Java version after the code freeze.
  2. Compiled the program on the official machine.
  3. Ran the 1, 2, 4, 6 and 8 thread configurations.
  4. Recorded raw execution times and computed averages.
  5. Documented the CPU model, core count, RAM, OS and Java version.
  6. Exported the dataset and shared it with Aryam and Rana.

Deliverables: the raw timing dataset, the averaged timing table and the machine specifications.

Aryam · Metrics & tables
  1. Imported the final timing dataset from Shoug.
  2. Verified the averages and benchmark values.
  3. Built the main table: Threads | Avg Time | Speedup | % Improvement.
  4. Applied Speedup = T(1) / T(n) and % Improvement = ((T1 - Tn) / T1) * 100.
  5. Prepared supporting tables for the results pages and the report.
  6. Formatted the final tables for insertion and export.

Deliverable: the final formatted results tables.

Layan · Graphs & performance analysis
  1. Imported the final results table from Aryam.
  2. Created the Threads vs Avg Execution Time graph.
  3. Created the Threads vs Speedup graph.
  4. Added labels and prepared the graph exports.
  5. Identified the point where overhead outweighed the benefit.
  6. Wrote a short explanation of the speedup trend, overhead causes and scaling.
  7. Delivered the graph images for report integration.

Deliverable: graph images and a short performance interpretation.

Rana · Report & integration
  1. Drafted the report structure: objective, methodology, experimental setup, results, discussion and conclusion.
  2. Inserted the tables, graphs and machine specifications.
  3. Wrote the discussion of thread division, synchronization, scalability and the performance decrease.
  4. Expanded the HTML report so the implementation and analysis are easier to follow.
  5. Organized the final submission structure and completed the packaging.
  6. Verified all final files and ran the final validation pass.

Deliverable: the final report package and submission ZIP.

Full task matrix#

Work item Owner Status Notes
Modify program to compute sum of cubes Danah Completed Computation changed to x^3
Keep array values below 100 Danah Completed Random values limited to the required range
Make thread count configurable (1, 2, 4, 6, 8) Danah Completed Required thread set implemented
Verify correctness against single-thread result Danah Completed Parallel output checked against the baseline
Clean and comment code Danah Completed Comments added for readability
Freeze final version before benchmarking Danah Completed Delivered before official timing
Compile and run the final Java file Shoug Completed Official benchmark machine used
Run 1, 2, 4, 6, 8 thread configurations Shoug Completed All required configurations run
Repeat runs and record raw times Shoug Completed Final dataset recorded in the results evidence
Compute the average for each configuration Shoug Completed Averages entered into the Phase II results
Record full machine specifications Shoug Completed CPU, RAM, OS and Java version documented
Export dataset to Excel/CSV Shoug Completed Spreadsheet included in the Phase II files
Deliver dataset and specs to Aryam and Rana Shoug Completed Handed off for tables and report writing
Compute speedup Aryam Completed From the final timing dataset
Compute % improvement Aryam Completed Against the 1-thread baseline
Create formatted results tables Aryam Completed Main and supporting tables prepared
Prepare tables for the report Aryam Completed Ready for integration
Create required graphs Layan Completed Time, speedup and % improvement graphs
Identify the performance decrease point Layan Completed Overhead identified at lower thread counts
Write a short technical interpretation Layan Completed Graph explanation and trend summary
Draft report structure Rana Completed Objective → conclusion
Insert tables, graphs and machine specs Rana Completed Final figures and context added
Explain thread division, synchronization and scalability Rana Completed Expanded in the Markdown and HTML report
Keep the report within the formal requirements Rana Completed Wording and structure finalized
Organize the submission folder Rana Completed Assets arranged in the final structure
Verify all files open correctly Rana Completed Final files reviewed
Create the final ZIP Rana Completed Submission package completed
Final validation check Rana Completed Phase II submission checked

Shared agreements#

  • One fixed array size throughout benchmarking.
  • Only the required thread set: 1, 2, 4, 6, 8.
  • All times in milliseconds.
  • Consistent file naming across submission assets.
  • One official machine for all benchmark timing.
  • Peer review and packaging at the end of the workflow.