Overheat Prevention Controller

Implement a controller that manages the temperature of a multicore processor. Workload changes are deferred until the next Tick. Each tick settles temperatures and shutdowns, applies pending loads, and then chooses active cooling for the next interval.

Core state and thermal rules

• At time 0, every core is running with temperature 20, load 0, and active cooling off. A running core is idle when active cooling is off and cooling when it is on.
• Each core has a passive-cooling demand of load + 2 watts. A shut-down core has load 0 and still receives passive cooling.
• Let k be the number of cores with active cooling on. Let F[1], F[2], ... = 1, 2, 3, 5, .... Effective shared passive capacity is pooledCooling * (1 - sum(0.1 / F[j], j = 1..k)).
• If that capacity meets the total demand, every core receives its full demand. Otherwise, distribute it proportionally: core i receives effectiveCapacity * demand[i] / totalDemand.
• An actively cooled core receives exactly activeCooling[i] additional watts of cooling.
• Temperature changes at 0.02 degrees per second per watt of net heat, where net heat is load - passiveCooling - activeCoolingIfOn. Temperature cannot fall below 20.
• For this exercise, use the loads and cooling choices from the preceding tick throughout the interval until the next tick. At that next tick, settle every temperature with these frozen rates, clamp to the ambient floor, and then shut down each running core whose observed temperature is at least 80. Clear its load and active cooling. Do not clamp its temperature to 80.

Deferred loads and restarts

The arrays operations and operationData form one finite call sequence. Every row begins with a timestamp in seconds. Timestamps are strictly increasing, starting at a nonnegative time.

• SetCoreLoad has data [timestamp, coreIndex, watts]. Queue a load change for the indexed core without advancing temperatures. Only the last queued change for a core is retained.
• Tick has data [timestamp]. First settle temperatures and shutdowns. Then apply the pending loads. A pending load restarts a shut-down core only if its just-observed temperature is strictly below 50. Restarting preserves that temperature. A failed restart leaves the core shut down and discards the pending change.
• Pending changes applied to a running core replace its load. Clear all pending changes after this phase.

Choosing active cooling

At every tick, recompute active cooling from scratch for running cores. Turn it on for every core with temperature strictly above 60. Also turn it on for every unengaged core whose resulting rise rate would be strictly above 0.5 degrees per second. Engaging cores reduces passive capacity through the Fibonacci penalty, which can force more cores to engage during the same tick.

Use the smallest closed engagement set: begin with the temperature-forced cores, recompute passive cooling, add all unengaged cores whose net heat without active cooling exceeds 25 watts, and repeat until no new core qualifies. A core already selected stays selected during this decision, even if its active cooling reduces its final rise rate. Shut-down cores never engage.

Change reports

After the tick is complete, compare each core's final status with its status after the previous tick; initially every status is idle. Return one row containing exactly the changed cores as coreId=status strings in lexicographic core-ID order. A core that shuts down and restarts within one tick is reported only if its final status differs. Return an empty row when no final status changes.

Return one row per Tick in call order. coreIndex is the zero-based index in coreIds, and activeCooling is aligned with that array. Complete simulateOverheatController.