WaterSplit: Coordinated On-Site and Off-Site Water Allocation For Sustainable Datacenter Cooling

Paper is published at 2026 41st IEEE International Parallel & Distributed Processing Symposium (IPDPS'26)

Description

WaterSplit is a hybrid-cooling data-center simulator and scheduler that jointly manages cooling allocation and workload scheduling to minimize a data center's water footprint under a limited water budget.

WaterSplit consists of three parts:

1. Hybrid cooling system model (hybrid_model.py) — a physics-based model of a data center that runs wet and dry cooling subsystems in parallel (water-cooled and air-cooled chillers, cooling towers, pumps, fans, UPS, lighting, power distribution). Given the wet-cooling fraction ρ and the ambient wet-bulb temperature, it estimates PUE and on-site WUE.
2. Cooling Allocation Optimizer (help_function.py:solver) — a Gurobi MILP that picks the wet-cooling fraction ρ that maximizes energy throughput under a given water budget, using the regional energy mix and embodied water intensity factor (EWIF).
3. Water-aware Job Scheduler (main.py / simulation.py) — dynamically assigns queued jobs to compute nodes using a priority mechanism that combines normalized water footprint and job waiting time, to maximize throughput while respecting the water budget.

Repository layout

main.py               CLI entry point: parses flags into a SimulationConfig and runs the simulation
config.py              SimulationConfig: run parameters + derived output paths
simulation.py          Minute-by-minute simulation loop tying the pieces below together
cooling_policy.py      Per-hour choice of wet-cooling fraction (dry / wet / half / dynamic / WaterSplit)
node_pool.py           Tracks node occupancy and job-to-node assignment
water_budget.py        Per-hour water budget accounting + water-intensity cost model
job_priority.py        Job queue priority scoring (water footprint vs. waiting time)
hybrid_model.py        Hybrid cooling model: PUE / on-site WUE given wet-bulb temp and wet-cooling fraction
help_function.py       Data loading utilities + Gurobi MILP Cooling Allocation Optimizer (solver())

EMaps/                 Hourly regional energy-mix breakdowns (source: Electricity Maps), one CSV per region
ewif/                  Derived hourly EWIF series per region
wet_bulb/              Hourly wet-bulb temperature traces per region
source_ewif.json       Per-fuel-type EWIF constants
borg_trace/            Workload arrival traces, one CSV per application
profile_data/          Per-application energy/runtime profiles (populate before running — see below)

Output produced by a run (not checked in):

methodology<M>_results/<region>/<cooling>_node<node_size>_budget<water_budget>.json   Per-job simulation log
alpha_log_<region>_<cooling>_node<node_size>_budget<water_budget>.txt                 Chosen wet-cooling fraction per hour

Requirements

Python 3.10, with dependencies listed in requirements.txt. A Gurobi license is required to solve the Cooling Allocation Optimizer's MILP (free academic licenses: https://www.gurobi.com/academia/).

pip install -r requirements.txt

Set up a Gurobi license following https://www.gurobi.com/academia/, then verify gurobipy can find it (python -c "import gurobipy; gurobipy.Model()").

Input data

EMaps/, ewif/, wet_bulb/, source_ewif.json, and borg_trace/ are already populated for the included regions.

profile_data/ must be populated before running: for each application name referenced in help_function.py:profile(), provide <app>_energy.json and <app>_time.json — parallel JSON arrays of per-invocation energy (Joules) and runtime (seconds) samples.

Running the simulation

python main.py --region IT-NO --water_budget 400 --cooling WaterSplit --node_size 300

• cooling: dry, wet, half, dynamic, or WaterSplit (the MILP-optimized policy)
• methodology: 1 or 2 — selects the on-site WUE formula used by hybrid_model.py
• Output: a per-job log at methodology<methodology>_results/<region>/<cooling>_node<node_size>_budget<water_budget>.json, and — when cooling=WaterSplit — the chosen wet-cooling fraction per hour in alpha_log_<region>_<cooling>_node<node_size>_budget<water_budget>.txt.

Job log format

Each entry in a results log corresponds to one completed job and records:

Field	Meaning
job_name	Application name + job id
invoke_min	Arrival time (minutes)
start_min	Scheduled start time (minutes)
end_time	Completion time (minutes)
planned_water	Total water footprint for the job
off_site_water	Off-site (embodied-in-electricity) water footprint
on_site_water	On-site (evaporative cooling) water footprint
embodied_water	Embodied hardware water footprint

Citation

If you use WaterSplit, please cite the accompanying paper.

@inproceedings{jiang2026watersplit,
  title={WaterSplit: Coordinated On-Site and Off-Site Water Allocation For Sustainable Datacenter Cooling},
  author={Jiang, Yankai and Kanakagiri, Raghavendra and Roy, Rohan Basu and Tiwari, Devesh},
  booktitle={2026 IEEE International Parallel and Distributed Processing Symposium (IPDPS)},
  pages={1388--1402},
  year={2026},
  organization={IEEE}
}