This repo contains branches for a AI-datacenter simulation in MATLAB and python to calculate energy cost and server configuration.

A multi-technology simulation framework for modeling server rack power consumption, thermal behavior, and compute performance in data center environments.

This repository provides a physics-based simulation model for estimating the power, thermal, and performance characteristics of data center server racks. The simulation models individual processor components (CPUs and GPUs) and scales up to rack-level analysis, enabling:

• ⚡ Power Estimation — Active and leakage power based on processor utilization, core count, voltage, and frequency
• 🌡️ Thermal Equilibrium — Junction temperature (Tj) solving via sweep and bisection methods to find steady-state operating temperature
• ⏱️ Time-to-Completion — Compute time estimation based on instruction counts, core scaling, and frequency
• 🔄 DVFS Modeling — Dynamic Voltage and Frequency Scaling with multi-level operating point selection
• ❄️ Cooling Analysis — Air vs. water cooling thermal resistance modeling
• 💰 Financial Analysis — Data center operational cost and net profit calculations for retrofitted server configurations

This repository uses a branch-per-technology strategy. The simulation is implemented in two independent technology stacks, each on its own branch:

datacenter-server-model/
├── main                  ← You are here (overview + documentation)
├── matlab-simulink       ← MATLAB/Simulink implementation
└── python                ← Python implementation

The server model simulates a 3-phase compute workload on a configurable server rack:

┌─────────────────────────────────────────────────────────────┐
│                       SERVER RACK                           │
│                                                             │
│  ┌──────────┐  ┌──────────┐           ┌──────────┐         │
│  │  CPU #1  │  │  CPU #2  │    ...    │  CPU #N  │         │
│  └──────────┘  └──────────┘           └──────────┘         │
│  ┌──────────┐  ┌──────────┐           ┌──────────┐         │
│  │  GPU #1  │  │  GPU #2  │    ...    │  GPU #M  │         │
│  └──────────┘  └──────────┘           └──────────┘         │
│                                                             │
│  Phases:  1. Init  ──▶  2. Compute  ──▶  3. Result          │
│                                                             │
│  Outputs: Power (W) │ Temperature (°C) │ Time (s) │ Cost ($)│
└─────────────────────────────────────────────────────────────┘

Each compute job is broken into three sequential phases, each with independently configurable:

• Core count — Number of active parallel cores (software threads)
• Utilization — Fraction of active core capacity in use
• Instruction count — Total instructions to execute

P_active = C_sw × V² × f × (Load / Load_TDP) × (Active_Cores / Total_Cores) × num_chips

Where:

• C_sw — Switching capacitance (processor spec)
• V — Operating voltage (from DVFS table or nominal)
• f — Operating frequency (Hz, DVFS-selected)
• Load — Current utilization (0–1)
• Load_TDP — Utilization at TDP rating

Temperature-dependent leakage power scaled from TDP:

• Derived from ACT_pwr_split (active vs. leakage fraction)
• Scales with (V_operating / V_spec)²
• Temperature-dependent scaling between TDP_Tj and Tj_max

Steady-state Tj found where chip power equals cooling capacity:

P_total(Tj) = P_active + P_leakage(Tj) = (Tj - T_ambient) / θ_ja

Full specs for all models are available in the SDC Financial Model spreadsheet and can be dumped via the Python simulator's debug mode.

git checkout matlab-simulink

Open processor_ks.slx in Simulink. See the MATLAB branch README for detailed setup.

git checkout python
pip install -r requirements.txt
python simulator.py

See the Python branch README for the full interactive CLI guide.

This project was developed as part of EEE 498/591 — Data Center Systems Engineering coursework. The simulation addresses real-world scenarios including:

• Multi-customer workload profiling (AI inference, HPC, training)
• Server rack retrofitting and financial viability analysis
• Power and thermal envelope compliance
• DVFS optimization strategies
• Air vs. water cooling trade-offs

1. Fork this repository
2. Create a feature branch from the appropriate technology branch
3. Make your changes and test thoroughly
4. Submit a pull request with a clear description of changes

This project is licensed under the MIT License — see the LICENSE file for details.

Built with 🔧 MATLAB/Simulink and 🐍 Python