## 4 System Model  
### Deep Learning Job Model  
We consider \(|\mathcal{I}|\) DL jobs invoked in the cluster. For the \(i\)-th DL job, the job description is represented by \(j_{i}=\{a_{i},d_{i},E_{i}\}\). Here, \(a_{i}\) denotes the arrival time (i.e., the index of the arrived time slot), \(d_{i}\) is the deadline as defined by the DL service user, and \(E_{i}\) represents the number of required epochs for training. Based on this, we present the following definition. **Definition 1** (Deep-Learning Job Requirement, DJR). : _Let \(E_{i}\), \(M_{i}\), and \(b_{i}\) denote the total epochs, the total number of mini-batches per epoch, and the associated data chunk size per iteration for the \(i\)-th DL job, respectively [16]. Then, we denote \(R_{i}=E_{i}M_{i}b_{i}\) as the Deep Learning Job Requirement, which represents the total required workload for training within the pre-established deadline \(d_{i}\)._  
Now, we present a GPU core frequency-based performance model for DL jobs, utilizing a statistical modeling approach. This model is grounded in the relationship \(t\propto\frac{1}{f}\) (time is inversely proportional to frequency), where \(t\) represents the DL job processing time and \(f\) denotes the frequency value, as discussed in [17; 18]. In this model, \(\lambda_{i}^{\text{F}}\) and \(\lambda_{i}^{\text{B}}\) are the performance model coefficients for feed-forward and back-propagation processes in DNN model training jobs, respectively. These coefficients are determined by the capability of the Streaming Multiprocessors (SMs) in the GPU devices. The coefficient \(\lambda_{i}^{\text{O}}\) is assigned for other sub-processes, excluding feed-forward and back-propagation. Let \(\lambda_{i}=\lambda_{i}^{\text{F}}+\lambda_{i}^{\text{B}}+\lambda_{i}^{\text{O}}\). Assuming the \(i\)-th DL job is running on a GPU worker at time slot \(k\), we can derive both the DNN model updating time \(t_{i}^{\text{up}}(k)\) and the training time \(t_{i}^{\text{tr}}(k)\) as follows:  
\[t_{i}^{\text{up}}(k)=t_{i}^{\text{tr}}(k)+\frac{2b_{i}}{\text{bw}_{i}} \tag{3}\]  
\[t_{i}^{\text{tr}}(k)=\frac{\lambda_{i}b_{i}}{f_{i}(k)} \tag{4}\]  
Here, \(f_{i}(k)\) represents the GPU core frequency value for the worker running the \(i\)-th DL job, and \(b_{i}\) refers to the associated data chunk size for each mini-batch. The term bw\({}_{i}\) denotes the bandwidth between the worker and the parameter server. The second term in (3) represents the communication time, during which GPU workers send gradients to and receive updated model parameters from the parameter server. Note that the frequency value \(f_{i}(k)\) does not influence this term. Furthermore, we assume that the parameter server is located on the same machine as the GPU worker. Consequently, the term \(\frac{2b_{i}}{\text{bw}_{i}}\) can be considered approximately zero, rendering it a negligible constant. Therefore, our focus primarily lies on (4). Building upon (4), we propose the following definition. **Definition 2** (Deep-Learning Job Completion per Slot, DJCS). : _We define \(\theta_{i}(k)\) as the Deep Learning Job Completion per Slot, which quantifies the workload processed in the \(i\)-th DL job at a given frequency value of the worker for time slot \(k\). Let \(\tau\) denote the duration of one time slot. Then, \(\theta_{i}(k)\) can be expressed as the reciprocal of \(t_{i}^{\text{tr}}(k)\), formulated as follows:_  
\[\theta_{i}(k)=\frac{\tau}{t_{i}^{\text{tr}}(k)}=\frac{\tau\cdot f_{i}(k)}{ \lambda_{i}b_{i}}. \tag{5}\]  
Clearly, for each DL job, the total DJCS across all time slots must meet the predetermined DJR. Let \(x_{i}(k)\) be the indicator that signifies whether the worker is allocated to the \(i\)-th DL job at time slot \(k\) (where \(x_{i}(k)=1\) indicates allocation and \(x_{i}(k)=0\) indicates non-allocation). Then, we propose the following constraints.