Both changes address the same bottleneck

Change B, because it eliminates the unnecessary retrieval and processing of 49,800 irrelevant rows at the source

Change A, because sorting is the most computationally expensive operation

Neither change is effective because network transfer dominates the energy cost

Partitioning compresses the data, reducing the total storage size

Partitioning moves older data to slower storage, freeing faster storage for recent queries

Partitioning creates an automatic index on the date column, speeding up all queries

Partitioning allows the database to skip entire segments whose date range does not match the query filter, reading only the relevant partition

Read energy increases because the Students table becomes larger, and write energy decreases because updates affect fewer tables

Both read and write energy decrease because the database has fewer tables to manage

Read energy decreases because no joins are needed, but write energy increases because changing a department name requires updating every student row in that department

Energy consumption remains the same because the total amount of data is unchanged

Service C, because payment processing is the most critical business function

Service D, because it has the lowest total energy consumption and would be easiest to rewrite

Service A, because 92% of its time is spent on CPU processing, where language overhead is the dominant energy cost

Service B, because it handles the most requests per second

Push notifications use a more efficient network protocol than polling requests

The push design eliminates the repeated requests that return empty results, performing work only when data exists to deliver

The push design compresses messages before sending them, reducing data volume

The push design uses the processor’s cache more effectively than the polling approach

8

10

1

2

The extra columns cause the query to run slower because the database must sort more data

The database creates an index on all 20 columns, which increases write energy

The database must perform additional joins to retrieve the extra columns from related tables

All 20 columns are read from disk and transferred through memory for every matching row, even though 17 columns are discarded by the application

Disk I/O overhead from loading the interpreter into memory

Network overhead from communicating between the interpreter and the operating system

Interpreter dispatch overhead, where each application instruction requires many processor instructions to execute

Memory allocation overhead from creating temporary objects

The index compresses the table data so fewer pages are needed overall

The index reorganises the table on disk so that students in the same major are stored on consecutive pages

The index caches frequently accessed rows in memory so disk reads are avoided

The index stores a sorted copy of the major column with pointers to the corresponding rows, allowing the database to navigate directly to matching entries

The sorted order means each comparison reveals which half contains the target, making the other half irrelevant

The data is stored in contiguous memory, allowing the processor to prefetch adjacent records

The dataset fits entirely in the processor’s cache, eliminating memory access delays

The records are stored with pointers that connect each record to the next in sequence