CS 330 Project Plan Dashboard

Aryam - Setup & Environment Preparation
VirtualBox, Ubuntu VM, Build Tools, C Program Compilation
VirtualBox، Ubuntu VM، أدوات البناء، تجميع برنامج C
Phase 1-7
VirtualBox, Ubuntu
C, gcc
Phase 1-2 - VirtualBox & Ubuntu Setup
Setup
Install VirtualBox and create Ubuntu virtual machine with proper configuration.
  • Download and install VirtualBox from official website
  • Create new Linux VM with allocated CPU cores and RAM
  • Install Ubuntu fully with default settings
  • Do not change VM settings after installation
Tools Needed
  • VirtualBox installer from official website
  • Ubuntu ISO file
  • System with virtualization support enabled
  • Sufficient disk space for VM (min. 20GB)
Steps to Complete
  1. Download VirtualBox from the official website (virtualbox.org)
  2. Install using default settings - do not customize installation
  3. Open VirtualBox to confirm it runs correctly without errors
  4. Create a new virtual machine with Type: Linux, Version: Ubuntu (64-bit)
  5. Allocate CPU cores and RAM as agreed by the group (recommended: 2 cores, 4GB RAM)
  6. Install Ubuntu fully using the ISO file - complete all installation steps
  7. Once installed, open Ubuntu VM to verify it works properly
  8. Take screenshot of VirtualBox showing Ubuntu running successfully
Phase 3-4 - Build Tools & C Program
Development
Install build tools, compile the provided C program, and verify successful compilation.
  • Update Ubuntu package list and install build-essential
  • Verify gcc installation with version check
  • Navigate to directory containing C program file
  • Compile using gcc and verify no errors
Tools Needed
  • Ubuntu Terminal
  • build-essential package (includes gcc, make, etc.)
  • Provided C program file
  • gcc compiler
Steps to Complete
  1. Open Ubuntu Terminal from the applications menu or using Ctrl+Alt+T
  2. Update package list: sudo apt update
  3. Install build tools: sudo apt install build-essential
  4. Verify gcc installation: gcc --version (should show version number)
  5. Navigate to directory containing the C program file using cd command
  6. Compile the C program: gcc -o program program.c (adjust filenames as needed)
  7. Verify compilation was successful (no error messages)
  8. Take screenshot of terminal showing successful compilation
  9. Run the compiled program once with default values to verify it works
Phase 5-7 - Documentation & Handoff
Documentation
Run base execution, document system specifications, and prepare VM access for Layan.
  • Run program with default values and capture output
  • Document CPU model, cores, RAM, Ubuntu version
  • Prepare VM access via .ova export or in-person session
  • Do not modify VM after handoff preparation
Tools Needed
  • Screenshot tool
  • Text editor for documentation
  • VirtualBox export feature (.ova)
  • System information commands
Steps to Complete
  1. Run the compiled program once using default values: ./program
  2. Capture terminal output showing program execution
  3. Record execution time if program displays it
  4. Take screenshot of program execution output
  5. Document system specifications: CPU model, number of cores allocated to VM, RAM allocated to VM, Ubuntu version
  6. Save this information in a text file for Shoug (report writer)
  7. Prepare VM access for Layan using one method: In-person session on Aryam's laptop, OR Export the VM as an .ova file and share it via cloud storage
  8. If exporting as .ova: In VirtualBox, select VM → File → Export Appliance → Choose .ova format
  9. Do not modify the VM after this point to ensure consistency for Layan's experiments
  10. Deliverables: Screenshots (VirtualBox running Ubuntu, successful compilation, program output), written system specifications, VM access for Layan
Layan - Experiment Runner
Uses Aryam's VM setup, runs timing experiments, collects data
يستخدم إعداد جهاز أريام الافتراضي، يجري تجارب التوقيت، يجمع البيانات
Phase 1-7
Uses Aryam's VM
Data Collection
Phase 1-3 - VM Access & Environment Verification
Setup
Access Aryam's VM, verify environment consistency, and ensure no modifications to settings.
  • Access VM via .ova import or in-person session
  • Verify same Ubuntu version, CPU & RAM allocation
  • Confirm same compiled program is present
  • Do not alter VM settings or install anything
Tools Needed
  • VirtualBox .ova import capability
  • Access to Aryam's laptop (if in-person)
  • Ubuntu Terminal for verification
  • System information commands
Steps to Complete
  1. Access Aryam's VM using one approved method: In-person session on Aryam's laptop, OR Import the exported .ova file into your own VirtualBox, OR Use shared VM folder (only if compatible and previously agreed)
  2. Do not alter VM settings - keep everything exactly as Aryam configured it
  3. Verify environment consistency: Check Ubuntu version matches Aryam's (lsb_release -a)
  4. Confirm same CPU & RAM allocation (check VirtualBox settings or use lscpu and free -h)
  5. Confirm same compiled program is present and executable
  6. If anything differs from Aryam's setup, stop immediately and inform Aryam
  7. Important rule: Layan does NOT install VirtualBox, Ubuntu, or build tools - use Aryam's setup only
  8. Once verified, the environment is ready for experiments
Phase 4-5 - Experiment Execution
Experimentation
Run experiments with different N and PROCS values, record execution times, and maintain clean data.
  • Change ONLY N and PROCS variables
  • Run each (N, PROCS) combination at least 3 times
  • Record execution time for each run
  • Do not discard slow or fast runs - keep all data
Tools Needed
  • Ubuntu Terminal
  • Time measurement (program output or time command)
  • Spreadsheet or text editor for data recording
  • Calculator for averages
Steps to Complete
  1. Modify ONLY allowed variables: N (problem size) and PROCS (number of processors/threads)
  2. Do NOT modify: Code logic, compiler flags, environment settings, VM configuration
  3. For each (N, PROCS) combination: Run the program at least 3 times to account for variability
  4. Record execution time for each run (use consistent units - seconds recommended)
  5. Do not discard slow or fast runs - all data points are valuable for analysis
  6. Maintain a single table with columns: N, PROCS, Run 1, Run 2, Run 3, Average execution time
  7. Calculate average execution time for each (N, PROCS) combination
  8. Use consistent formatting: same decimal places, same units throughout
  9. Example table structure: N | PROCS | Run 1 | Run 2 | Run 3 | Average 1000 | 2 | 1.23 | 1.25 | 1.22 | 1.233 1000 | 4 | 0.65 | 0.67 | 0.66 | 0.660
  10. Ensure data is clean and organized before proceeding to validation
Phase 6-7 - Data Validation & Handoff
Validation
Validate dataset for completeness and errors, then send final dataset to Danah and Shoug.
  • Check for missing values or obvious errors
  • Repeat runs if needed for consistency
  • Confirm dataset is final before handoff
  • Send to Danah (graphs) and Shoug (report)
Tools Needed
  • Data validation checklist
  • File sharing method (Google Drive, email, etc.)
  • CSV or spreadsheet format for data
  • Communication with team members
Steps to Complete
  1. Validate dataset: Check for missing values in any cell
  2. Look for obvious errors: Negative times, times that are orders of magnitude different from others
  3. Verify calculations: Ensure averages are correctly computed
  4. Check consistency: Same number of runs for each (N, PROCS) combination
  5. If inconsistencies found: Repeat runs for affected combinations to ensure data reliability
  6. Document any anomalies or observations about the data
  7. Once validation is complete, confirm dataset is final and ready for handoff
  8. Send final timing dataset table to Danah (for graphs) and Shoug (for report integration)
  9. Use appropriate format: CSV recommended for compatibility, or share Google Sheets link
  10. Include metadata: Brief description of experiment parameters, date conducted, any special notes
  11. Deliverables: Final timing dataset table (clean & complete), Notes on any data anomalies
  12. Important: Maintain only one shared dataset file to avoid confusion
Danah - Graphs & Visuals
Creates graphs from Layan's data, ensures clarity and labeling
تنشئ رسومًا بيانية من بيانات ليان، تضمن الوضوح والتوسيم
Phase 1-7
Data Visualization
PNG/PDF Export
Phase 1-3 - Data Preparation & Graph Selection
Preparation
Wait for final dataset from Layan, select appropriate graph types, and prepare data for visualization.
  • Wait until Layan confirms dataset is final
  • Select minimum graph types required
  • Choose appropriate visualization tool
  • Verify data format and completeness
Tools Needed
  • CSV/Excel data file from Layan
  • Visualization tool (Excel, Python/matplotlib, etc.)
  • Communication with Layan for confirmation
  • Graph requirements checklist
Steps to Complete
  1. Wait for final dataset from Layan - do NOT begin until Layan confirms the dataset is final and complete
  2. Once received, verify dataset: Check file format, ensure all required columns are present, verify no obvious data errors
  3. Select graph types - at minimum include: Execution Time vs. PROCS (for fixed N values), Execution Time vs. N (for selected PROCS values)
  4. Consider additional helpful graphs: Speedup vs. PROCS, Efficiency vs. PROCS, 3D surface plot of Time vs. N vs. PROCS (if appropriate)
  5. Choose appropriate tool based on team agreement and personal comfort: Excel (easiest for basic graphs), Python with matplotlib/seaborn (more flexible), Other (Google Sheets, R, etc.)
  6. Prepare data for visualization: Organize data by N and PROCS values, Calculate averages if not already provided, Identify key trends to highlight
  7. Ensure you have clear understanding of what each graph should show before creating it
Phase 4-6 - Graph Creation & Export
Visualization
Create clear, labeled graphs with proper formatting and export as high-quality images.
  • Create graphs with visual clarity and consistency
  • Label each graph properly with title and axis labels
  • Export as high-quality PNG or PDF images
  • Write 1-2 sentence figure captions
Tools Needed
  • Chosen graphing software (Excel, Python, etc.)
  • Export/save functionality for high-res images
  • Text editor for captions
  • Color scheme guidelines
Steps to Complete
  1. Create graphs using chosen tool: Start with basic required graphs, Ensure visual clarity: readable fonts, appropriate colors, good contrast
  2. Maintain consistency: Same color scheme across all graphs, Same font styles and sizes, Similar layout and formatting
  3. Label graphs properly - EACH graph must include: Descriptive title (e.g., "Execution Time vs. Number of Processors for N=1000"), X-axis label with units (e.g., "Number of Processors (PROCS)"), Y-axis label with units (e.g., "Execution Time (seconds)"), Legend if showing multiple data series
  4. Choose appropriate graph types: Line graphs for trends over PROCS or N, Bar charts for comparing discrete values, Scatter plots if showing individual data points
  5. Export graphs as high-quality images: Use PNG format for clarity, Or PDF for vector quality (better for printing), Minimum 300 DPI resolution for report quality
  6. Use consistent file naming: e.g., "Time_vs_PROCS_N1000.png", "Time_vs_N_PROCS4.png"
  7. Write figure captions (1-2 sentences each): Describe what the graph shows, Highlight main trend observed (e.g., "Execution time decreases as PROCS increases up to 8 processors, then plateaus"), Keep captions concise but informative
  8. Example caption: "Figure 1: Execution time versus number of processors for problem size N=1000. Shows strong scaling up to 8 processors with diminishing returns beyond."
Phase 7 - Final Delivery to Shoug
Delivery
Send completed graphs and captions to Shoug for report integration.
  • Package all graph files together
  • Include caption text in separate document
  • Ensure consistent formatting across all figures
  • Deliver to Shoug via agreed method
Tools Needed
  • Folder organization for graph files
  • Document for captions (Word, Google Docs)
  • File sharing platform (Google Drive, etc.)
  • Final quality check
Steps to Complete
  1. Perform final quality check on all graphs: Verify all labels are present and correct, Check that colors are consistent across graphs, Ensure images are high resolution and clear
  2. Organize graph files: Create a dedicated folder for all graph images, Use consistent naming convention, Include both PNG and PDF versions if possible
  3. Prepare caption document: Create a Word or Google Doc with all figure captions, Number figures sequentially (Figure 1, Figure 2, etc.), Match caption numbers to file names
  4. Include metadata in caption document: Brief description of data source (Layan's dataset), Date of graph creation, Any notes about graphing choices
  5. Package deliverables: Graph images folder, Caption document, Any source code if using Python/other programming for graphs
  6. Send to Shoug via agreed method: Email with attachments, Google Drive shared folder, Other team-preferred method
  7. Notify Shoug that graphs are ready for integration into report
  8. Be available for questions from Shoug about the graphs during report integration
  9. Deliverables: Graph images ready for report (PNG/PDF), Short figure captions document, Optional: Source code for graph generation
  10. Confirm with Shoug that all materials have been received and are satisfactory
Shoug - Report Writer & Integrator
Assembles final report, integrates all contributions, ensures consistency
تجميع التقرير النهائي، دمج جميع المساهمات، ضمان الاتساق
Phase 1-7
Report Assembly
Integrates All Work
Phase 1-3 - Report Structure & Initial Integration
Structure
Create report structure early and begin integrating content from Aryam and team planning.
  • Create report structure with all required sections
  • Integrate Aryam's VM setup description
  • Add system specifications from Aryam
  • Begin writing parallel sections
Tools Needed
  • Word processor (Word, Google Docs, LaTeX)
  • Access to Aryam's documentation
  • Report outline/template
  • Requirements checklist
Steps to Complete
  1. Create report structure early - don't wait for all content: Title page with project title, team members, course, date; Table of contents; Introduction & objectives; Experimental setup; Methodology; Results; Discussion; Conclusion; Appendix (code, screenshots)
  2. Begin writing sections that don't require others' content: Introduction (project overview, objectives), Methodology (overall approach, experimental design)
  3. Integrate Aryam's content: VM setup description (how VirtualBox and Ubuntu were installed), System specifications (CPU model, cores, RAM, Ubuntu version)
  4. Add team coordination details: How the project was divided, Communication methods used, Timeline of work
  5. Set up proper formatting: Page margins, Font style and size, Heading hierarchy, Figure and table numbering
  6. Create placeholders for content that will come later: "[Layan's data table will be inserted here]", "[Danah's graphs will be inserted here]"
  7. Start reference list/bibliography if citing sources
  8. Share draft structure with team for feedback
  9. Write in parallel while others complete their work - don't wait until everything is ready
Phase 4-5 - Data & Graph Integration
Integration
Integrate Layan's dataset as tables and Danah's graphs into the Results section.
  • Convert Layan's dataset into formatted tables
  • Reference tables in text with analysis
  • Place Danah's graphs in Results section
  • Add captions directly below each figure
Tools Needed
  • Table formatting tools
  • Image insertion capability
  • Layan's dataset file
  • Danah's graph folder
Steps to Complete
  1. Receive Layan's final dataset and Danah's graphs
  2. Integrate Layan's dataset: Convert raw data into well-formatted tables, Choose key data to highlight (not necessarily all data), Add table numbers and descriptive titles, Include units in column headers
  3. Reference tables in text: Introduce each table before it appears, Explain what the table shows, Highlight key findings from the table data
  4. Example table reference: "Table 1 shows execution times for varying N values with PROCS=4. As N increases from 1000 to 10000, execution time grows linearly..."
  5. Integrate Danah's graphs: Insert graph images at appropriate points in Results section, Ensure images are properly scaled (not too small or pixelated), Maintain consistent image sizing throughout report
  6. Add figure captions: Use Danah's captions verbatim or adapt slightly for flow, Place caption directly below each figure, Include figure number (Figure 1, Figure 2, etc.)
  7. Reference figures in text: Discuss each figure in the text near where it appears, Explain what the graph demonstrates, Connect visual trends to quantitative data from tables
  8. Example figure reference: "Figure 1 illustrates the relationship between execution time and number of processors for N=1000. The curve shows strong scaling up to 8 processors..."
  9. Organize Results section logically: Typically by experiment type or variable studied, Use subheadings if multiple experiment types, Flow from data presentation (tables) to visualization (graphs) to analysis
  10. Ensure all visuals are properly cited if from external sources
Phase 6-7 - Discussion & Finalization
Finalization
Write discussion section, ensure consistent writing voice, and finalize report with appendix.
  • Analyze effects of PROCS and N on performance
  • Discuss task vs. data parallelism observations
  • Edit for consistent tone and style throughout
  • Finalize report with appendix containing code and screenshots
Tools Needed
  • Spelling/grammar checker
  • Proofreading tool
  • PDF export capability
  • Appendix materials from team
Steps to Complete
  1. Write the Discussion section: Analyze effect of PROCS on execution time (strong/weak scaling), Analyze effect of N on execution time (scalability), Discuss task vs. data parallelism observations from results, Identify performance trends and limitations (bottlenecks, overhead), Compare results with expected/theoretical performance, Explain any anomalies or unexpected results
  2. Write Conclusion section: Summarize key findings, Restate project objectives and how they were met, Suggest potential improvements or future work
  3. Ensure one consistent writing voice throughout: Edit all sections for consistent tone and style, Remove informal language, contractions, slang, Ensure technical terminology is used consistently, Check that verb tenses are consistent (usually past tense for methods/results, present for conclusions)
  4. Compile appendix: Include C code (provided program), Include screenshots from Aryam (VirtualBox, compilation, execution), Include any additional relevant materials, Label appendix sections clearly (Appendix A: Code, Appendix B: Screenshots)
  5. Finalize the report: Check formatting (margins, fonts, spacing), Ensure page limit compliance (5-7 pages as specified), Verify all figures and tables are properly numbered and referenced, Check that table of contents matches actual page numbers, Proofread entire document for spelling/grammar errors
  6. Export final PDF: Use high-quality PDF export settings, Ensure all images are embedded properly, Test PDF on different devices to ensure compatibility
  7. Share final report with team for final review before submission
  8. Make any final adjustments based on team feedback
  9. Deliverables: Final PDF report (5-7 pages), Appendix with C code and screenshots
  10. Ensure all team members have copy of final report for submission
Shared Work & Coordination Rules
Practical rules to ensure the project actually works
قواعد عملية لضمان عمل المشروع بالفعل
Critical Coordination Rules
  • Aryam & Layan must schedule at least one experiment session together
  • Layan maintains only one shared dataset file to avoid confusion
  • Danah begins work only after Layan confirms data is finalized
  • Shoug writes sections in parallel and integrates final content last
Work Dependencies
  • Aryam → Layan: VM setup must be complete before experiments
  • Layan → Danah: Final dataset must be validated before graphs
  • Danah → Shoug: Graphs must be complete before report integration
  • All → Shoug: All content must be delivered before final report
Communication Guidelines
  • Report issues immediately to the affected team member
  • Confirm receipt of deliverables when sent
  • Establish regular check-in times (weekly or as needed)
  • Ask for clarification early rather than making assumptions
Quality Standards
  • Screenshots must be clear and legible
  • Data tables must include units and proper formatting
  • Graphs must be properly labeled with titles and axis labels
  • Report must follow specified page limit (5-7 pages)
Project Notes & Important Points
Critical Success Factors
1. Environment Consistency: Layan must use Aryam's exact VM setup without modifications. Any changes could invalidate experiment results.

2. Data Integrity: Layan must run each (N, PROCS) combination at least 3 times and record all runs (not just averages). This accounts for system variability.

3. Sequential Workflow: The project follows a strict sequence: Aryam → Layan → Danah → Shoug. Each person must complete their work before the next can begin effectively.

4. Communication: Regular check-ins between Aryam and Layan are essential for VM handoff. Danah should not start until Layan confirms data is final.
Pro Tips & Best Practices
For Aryam: Take screenshots at each major step (VirtualBox running, Ubuntu installed, compilation successful). Document system specs accurately.

For Layan: Use a script to automate experiment runs if possible. Keep a backup of raw data before calculating averages.

For Danah: Create a consistent color scheme across all graphs. Use error bars if showing averages with standard deviation.

For Shoug: Start writing early - don't wait for all content. Use placeholder text and fill in as materials arrive. Proofread multiple times.

For All: Keep all files organized in a shared folder. Use clear file naming conventions. Communicate proactively about delays or issues.
Required Tools & Software
Virtualization & Operating System
  • VirtualBox - Virtualization software for running Ubuntu VM
  • Ubuntu ISO - Linux distribution for virtual machine
  • Ubuntu Terminal - Command-line interface for installation and execution
Development & Compilation
  • build-essential - Package containing gcc, make, and other build tools
  • gcc compiler - For compiling the provided C program
  • Text editor - For viewing/editing C code (nano, vim, gedit)
Data Collection & Analysis
  • Time measurement - Program output timing or Linux time command
  • Spreadsheet software - For recording and analyzing experimental data (Excel, Google Sheets)
  • Calculator - For computing averages and other statistics
Visualization & Reporting
  • Graphing software - For creating visualizations (Excel, Python/matplotlib, etc.)
  • Word processor - For report writing (Word, Google Docs, LaTeX)
  • Screenshot tool - For capturing VM setup, compilation, execution
  • PDF exporter - For final report submission