Algorithm Design for an Online Berth Allocation Problem

Abstract

In this paper, we investigate an online berth allocation problem, where vessels arrive one by one and their information is revealed upon arrival. Our objective is to design online algorithms to minimize the maximum load of all berths (makespan). We first demonstrate that the widely used Greedy algorithm has a very poor theoretical guarantee; specifically, the competitive ratio of the Greedy algorithm for this problem is lower bounded by $\mathsf{\Omega }(\log m/\log \log m)$, which increases with the number of berths $m$. On account of this, we borrow an idea from algorithms for the online strip packing problem and provide a comprehensive theoretical analysis of the Revised Shelf (RS) algorithm as applied to our berth allocation problem. We prove that the competitive ratio of RS for our problem is 5, improving on the original competitive ratio of 6.66 for the online strip packing problem. Through numerical studies, we examine the RS algorithm and Greedy algorithm in an average case. The numerical simulation of competitive ratios reveals distinct advantages for different algorithms depending on job size. For smaller job sizes, the Greedy algorithm emerges as the most efficient, while for medium-sized jobs, the RS algorithm proves to be the most effective.

1. Introduction

Establishing an efficient, reliable, and flexible maritime logistics system has been a focal point for numerous scholars, as maritime transportation plays a crucial role in global trade and supply chain networks. Within this domain, the berth allocation problem (BAP) is a key challenge, as it directly impacts the operational efficiency of ports, which are critical nodes in maritime logistics. As an essential component of synchromodal logistics [1,2], the BAP has garnered significant attention due to its potential to optimize port resource utilization, enhance overall supply chain performance, and contribute to more sustainable operations. Efficient berth allocation not only reduces vessel waiting times and port congestion but also helps lower fuel consumption and emissions, making it a critical factor in minimizing the carbon footprint of maritime logistics. Given the global focus on reducing greenhouse gas emissions and achieving sustainability goals, optimizing berth allocation has become even more pertinent in supporting environmentally friendly maritime transport systems.

Specifically, the BAP deals with the assignment of quay space and service times to vessels arriving at the terminal for operations like loading and unloading containers, with the ultimate aim of optimizing various objectives, such as minimizing ports’ operational costs, reducing vessel turnaround times, and improving resource utilization. Traditionally, the BAP has been approached using offline optimization techniques, where complete information about vessel arrivals and cargo volumes is known in advance. In these settings, algorithms can generate optimized schedules by considering all the relevant parameters. Some studies have relaxed this assumption by incorporating partial information, such as probabilistic distributions of vessel arrivals [3,4]. However, real-world maritime logistics are often characterized by dynamic and uncertain environments. Factors such as sudden shifts in market demand, extreme weather events, or port congestion introduce unpredictability into vessel arrival times and the volume of cargo to be handled. In many practical cases, the distribution of information regarding vessel arrivals, including factors such as arrival times, cargo volumes, and vessel sizes, is difficult to ascertain, further complicating the berth allocation process.

Given these challenges, this paper addresses the BAP in relation to online optimization settings, where no prior knowledge of vessel information is available. In this scenario, an online algorithm is employed, where the scheduler receives information about a vessel only upon its arrival at the port. The algorithm must immediately allocate the vessel to a berth, and this decision cannot be changed once made, even as more vessels arrive. This introduces a significant level of complexity, as future vessels’ information remains unknown at the time of decision making, necessitating a strategy that balances current efficiency with future uncertainties.

In this study, we focus on a hybrid berth layout, where vessels can either share berths or occupy multiple berths simultaneously, depending on their size and operational requirements. This variant of the BAP bears resemblance to the well-known multiprocessor task scheduling problem, where multiple processors (berths) are allocated to complete tasks (vessels). Additionally, the problem shares similarities with two-dimensional bin packing problems, although the objective function in our case is to minimize the makespan, ensuring that all vessels are serviced in the shortest possible time. To assess the effectiveness of the proposed online algorithm, we use the competitive ratio, comparing the performance of the online approach with that of an offline optimal solution. This analysis offers valuable insights into the potential of online methods to address dynamic and uncertain conditions in maritime logistics while promoting operational efficiency and sustainability.

The BAP has been extensively studied in related works. Bierwirth and Meisel [5] and Rodrigues and Agra [6] categorized the BAP into three types: discrete, continuous, and hybrid. In the discrete case, only one vessel can be served at each berth at a time. In the continuous case, vessels can berth at arbitrary positions within the quay boundaries. In the hybrid case, multiple vessels may share a berth, or a single vessel may occupy more than one berth. Our study focuses on the hybrid case.

Most of the literature investigates offline versions of the BAP, where the scheduler has complete information about all vessels at the beginning. Cheong et al. [7] explored a dynamic hybrid BAP using a multi-objective programming method, optimizing objectives such as ship stay time, total waiting time, actual service priority of ships, and schedule deviation. They designed a multi-objective evolutionary algorithm for solving this problem. Guan and Yang [8] used simulation methods to explore various berth allocation methods for the static hybrid BAP, providing relevant research conclusions. Pan et al. [9] studied the hybrid BAP from a game-theoretic perspective, analyzing the price of anarchy for different vessel sizes and considering the makespan as the social cost, where the makespan is the maximum load over all berths. Our problem is similar to the model presented by Pan et al. [9].

To the best of our knowledge, there is limited research on the online version of the BAP. Online scheduling problems have been studied since the 1960s, and the algorithms for solving those problems are called online algorithms. In particular, Graham [10] first presented the LS (list scheduling) algorithm, which has had a profound impact on the online scheduling problem and proves the $(2-1/m)$ competitive ratio. Currently, when the number of machines approaches infinity, the best known upper bound and best lower bound are $1.9102$ and $1.85358$, according to [11] and [12], respectively. However, most research on online scheduling problems focuses on parallel machine scheduling, where each task needs only to be processed by only one machine, which is more similar to the discrete case in the BAP. More directly related studies include Zheng et al. [13] and Pan and Xu [14], who investigated the online version of the BAP with quality-of-service and capacity constraints (BAP-QCAP), providing optimal online algorithms for specific scenarios.

Our study focuses on the BAP with a hybrid berth layout, which is a special form of the general multiprocessor task scheduling problem [10,15]. In the context of multiprocessor task scheduling, both non-preemptive and preemptive independent job scenarios have been studied. Dorota and Smutnicki [16] designed a $(2-1/m)$ competitive algorithm and a $(1/(1-{(1-1/m)}^m\left)\right)$ competitive algorithm for these scenarios, respectively. The BAP with a hybrid berth layout also shares similarities with the two-dimensional packing problem [15]. Specifically, our research closely relates to the online strip packing problem [17,18], which aims to minimize the total height of the shelf—a different objective from ours. For online strip packing, Baker and Schwarz [18] developed the First Fit Shelf (FFS) algorithm with an absolute competitive ratio of 6.99. Ye et al. [17] improved this competitive ratio to 6.6623 using the Revised Shelf (RS) algorithm, which is the best-known bound to date. Despite the differences in objectives, the online algorithms from Ye et al. [17] can be adapted to our problem. Therefore, we further analyze the competitive ratio of these algorithms in the context of our specific BAP and validate their effectiveness through numerical simulations.

In the current contribution, Section 2 provides the necessary mathematical formulations and notations for this study. In Section 3, we first prove that the Greedy algorithm provides a poor theoretical guarantee for our problem, with a competitive ratio lower bounded by $\mathsf{\Omega }(\log m/\log \log m)$, which worsens with the number of berths $m$. We then provide a comprehensive theoretical analysis of the Revised Shelf (RS) algorithm in Section 4, proving its competitive ratio to be 5, thus improving on the previous bound of 6.66 for online strip packing. Our results advance the theoretical understanding of algorithms in the context of berth allocation. Additionally, we also perform extensive numerical simulations to complement our theoretical analysis in Section 5. The numerical simulation of competitive ratios reveals distinct advantages for different algorithms depending on job size. For smaller job sizes, the Greedy algorithm emerges as the most efficient, while for medium-sized jobs, the RS algorithm proves to be the most effective. Finally, we give a conclusion in Section 6.

2. Preliminaries

There are $n$ jobs (vessels) that need to be processed on $m$ identical servers (berths), which means every server has the same speed. We denote the set of servers as $M=\{1,2,3,\dots ,m\}$, and the set of jobs as $N=\{1,2,3,\dots ,n\}$. Each job arrives online, and the scheduler has no prior knowledge of future job arrivals. Each job $j$ is denoted by a tuple $(s_j,p_j)$, where “size” $s_j$ is the number of consecutive servers occupied by job $j$, and $p_j$ denote the processing time of job $j$. We define the weight $w_j$ of job $j$ as $w_j=p_j{s}_j$.

When all the jobs are scheduled on the servers, the allocation scheme of all the jobs is referred to as $\sigma =\left\{{\sigma }_1,{\sigma }_2,{\sigma }_3,\dots ,{\sigma }_n\right\}$, where ${\sigma }_j$ denotes the set of consecutive servers to which job $j$ is assigned. For example, ${\sigma }_1=\left\{2,3,4,5\right\}$ means job $1$ is assigned to server $\left\{2,3,4,5\right\}.$ We define the load ${\mathcal{l}}_i$ as the total processing time of all the jobs scheduled on server $i$, i.e., ${\mathcal{l}}_i={\sum }_{j:i\in {\sigma }_j}{p}_j$. Our objective is to minimize the makespan, namely, the maximum load over all servers ${\mathrm{m}\mathrm{a}\mathrm{x}}_i{\mathcal{l}}_i$. Here is an example to illustrate the definition of ${\mathcal{l}}_i$. We consider that four jobs arrive in the order of $\{\left(3,1\right),\left(3,2\right),\left(4,1\right),\left(1,3\right)\}$ and need to be assigned on five servers. Their final allocation scheme is $\sigma =\left\{\right\{1,2,3\},\{3,4,5\},\{1,2,3,4\},\{5\left\}\right\}$ as shown in Figure 1a. The first server is selected only for job $1$ and job $3$, thus, ${\mathcal{l}}_1=p_1+p_3=2$. In the same way, we can know ${\mathcal{l}}_2,{\mathcal{l}}_3,{\mathcal{l}}_4,{\mathcal{l}}_5=2,4,3,5$. The makespan of allocation $\sigma$ is the maximum load of all the servers, i.e., $c\left(\sigma \right)={\max }_i{\mathcal{l}}_i$. Obviously, the makespan of allocation scheme in Figure 1a is $5$. Figure 1b shows the optimal allocation scheme ${\sigma }^{\mathrm{*}}$, and the makespan of the ${\sigma }^{\mathrm{*}}$ is $4$.

The competitive ratio of an algorithm $A$ is defined as ${\rho }_A :={\sup }_N{\displaystyle \frac{C_A\left(N\right)}{opt\left(N\right)}}$, where $N$ is taken over all possible sets of jobs, $C_A\left(N\right)$ is the cost (makespan) of algorithm $A$ on job set $N$, and $opt\left(N\right)$ is the optimal makespan.

3. A Lower Bound of the Greedy Algorithm

In this section, we present a lower bound for the Greedy algorithm in the context of the online berth allocation problem. We demonstrate that the competitive ratio of the Greedy algorithm is not constant, but instead grows slowly with the number of servers $m$.

First, we give a pseudocode for the Greedy algorithm (see Algorithm 1):

Algorithm 1: Greedy Algorithm

Input: $m$: number of servers; tasks: list of jobs, where each job $j$ is represented as $(s_j, p_j)$ with $s_j$ being the number of consecutive servers required and $p_j$ the processing time. Output: Allocation scheme $\sigma$, describing the assignment of jobs to servers; Makespan, defined as the maximum load across all servers. Procedure: For each job $j$ in tasks: 1. Evaluate possible server ranges: For each possible starting position, consider the range of consecutive servers that can accommodate job $j$, from server 1 to $m-s_j+1$; 2. Compute the maximum load: For each potential range, calculate the maximum load that would result if job $j$ were assigned to that range; 3. Select the optimal range and update: Choose the range that minimizes the maximum load. In the case of ties, select the range with the smallest starting index. Assign job $j$ to the selected range, update the server loads by adding $p_j$ to the servers in that range, and recalculate the makespan as the maximum load across all servers.

Theorem 1. 

The competitive ratio of the Greedy algorithm is at least $\Omega \left(\mathit{log}m/\mathit{log}\mathit{log}m\right)$.

Proof. 

To facilitate the proof, we assume the number of servers $m$ is $k^k$, where k is a positive integer. If the number of servers lies between $k^k$ and ${\left(k+1\right)}^{k+1}$ for some value of $k$, we can simply fill the additional servers using the job construction method for the first $k^k$ servers. We show that for $k^k$ servers, one can construct a schedule such that the Greedy algorithm has a makespan of exactly k, while the optimal schedule has a makespan of 1. The lists of jobs to construct the lower bound are as follows.

In the first list, we alternate between job (1, 1) and job ($k$ − 1, $ϵ$) (where $ϵ$ is a very small positive number). Each type of job is repeated $k^{k-1}$ times. The list of jobs is structured as follows: (1, 1), ($k-1$, ϵ), (1, 1), ($k-1$, ϵ), …, iterated $k^{k-1}$ times. The Greedy algorithm places these jobs side by side on the $k^k$ servers, as shown in Figure 2a. Consequently, the makespan after the first list is 1.

In the second list, we alternate between job ($k$, 1) and job ($k^2-k$,$ϵ$). Each type of job is repeated $k^{k-2}$ times. After the first list of jobs, every k servers will have a server with a load of 1. The jobs in this list, due to their sizes being exactly k, will also be placed side by side on the $k^k$ servers, as shown in Figure 2a. As a result, the makespan after the second list is 2.

In the u-th list ($u\le k$), we alternate between job ($k^{u-1}, 1$) and job $(k^u-k^{u-1}, ϵ)$. Each type of job is repeated $k^{k-u}$ times. After this list of jobs, the makespan is u.

This process continues until $u=k$, yielding a makespan of $k$.

The optimal schedule places all jobs with height 1 side by side, followed by all jobs with height ϵ. As $ϵ\to 0$, the optimal makespan is 1.

Therefore, the competitive ratio’s lower bound is k. Given that $k^k=m$, we have k = $\mathsf{\Theta }\left(\log m/\log \log m\right)$. Consequently, the lower bound on the competitive ratio of the Greedy algorithm is $\mathsf{\Omega } \left(\log m/\log \log m\right)$. □

4. Revised Shelf Algorithm

In this section, we introduce the Revised Shelf algorithm for the BAP and prove that the competitive ratio is 5. The RS algorithm was originally designed for the online strip packing problem, with a competitive ratio of 6.66 [17]. We apply the RS algorithm to BAP and improve the competitive ratio to 5.

Intuitively, the RS algorithm is to allocate jobs to virtual shelves of different heights. These virtual shelves are defined with heights of $2^k$, where $k$ is an integer that can be negative. A shelf with a height of $2^k$ is referred to as a $k$-shelf. Specifically, for each job $j$ with processing time $p_j$, the algorithm identifies the integer $k$ such that $2^{k-1}<p_j\le 2^k$, and assigns job $j$ to a $k$-shelf. Each $k$-shelf has a height of $2^k$ and a width equivalent to the number of servers $m$. Since the heights of jobs within a $k$-shelf are all greater than half the shelf’s height, jobs are placed adjacent to each other following the leftmost principle. When the current $k$-shelf cannot accommodate a new job, a new $k$-shelf is initiated. This process continues, adhering to the first-fit principle to use the minimum number of shelves possible. Consequently, on arrival, each online job is allocated a specific position on a shelf, forming the job allocation scheme of the algorithm. Next, we give the formal definition of the Revised Shelf algorithm.

• Revised Shelf (RS) algorithm:

When a new job $(s_j,p_j)$ arrives, we assign it as follows:

1. If job $j$ is a large job (i.e., $s_j>{\displaystyle \frac{1}{2}}m$)$,$ we assign it to machines ${\sigma }_j=\left\{1,2,3,\dots ,s_j\right\}$;

2. If job $j$ is a small job (i.e., $s_j\le {\displaystyle \frac{1}{2}}m$), we assign it to a $k$-shelf following the first-fit principle, where the integer $k$ satisfies $2^{k-1}<p_j\le 2^k$. Specifically, the algorithm first attempts to place the job $j$ on the first available $k$-shelf that has sufficient remaining width with the leftmost principle. If the current $k$-shelf cannot accommodate the job, the algorithm initiates a new $k$-shelf and places the job there. The algorithm continues this process following the first-fit principle.

In the following we show the pseudocode for the RS algorithm (see Algorithm 2):

Algorithm 2: Revised-Shelf algorithm

Input: $m$: number of servers; tasks: list of jobs, where each job $j$ is represented as $(s_j, p_j)$ with $s_j$ being the number of consecutive servers required and $p_j$ the processing time. Output: Allocation scheme $\sigma$, describing the assignment of jobs to servers; Makespan, defined as the maximum load across all servers. Procedure: 1. For each job $j$ in tasks:  1.1. If $s_j>{\displaystyle \frac{1}{2}}m$: Assign job $j$ to machines ${\sigma }_j=\left\{1, 2, \dots , s_j\right\};$  1.2. If $s_j \le {\displaystyle \frac{1}{2}}m$:   1.2.1. Determine $k$ such that $2^{k-1}<p_j \le 2^k$;   1.2.2. Attempt to place job $j$ on an existing $k$-shelf. If a $k$-shelf has enough remaining width $(\ge s_j)$, assign job $j$ to that shelf, and update both the remaining width and the server loads accordingly;   1.2.3. If no existing $k$-shelf can accommodate job $j$, create a new $k$-shelf, assign job $j$ to the first $s_j$ consecutive servers on this shelf and update the remaining width and server loads; 2. Compute the makespan as the maximum load across all servers after all jobs are processed and output the allocation scheme σ, which lists the server assignments for each job, along with the makespan.

4.1. The Upper Bound of the Competitive Ratio

Next, we present a detailed proof of the upper bound of the competitive ratio for the RS algorithm. After all the jobs have been assigned by the RS algorithm, certain shelves have been created. We group these shelves into three classes:

• Full Shelves: Shelves created for large jobs are called full shelves;
• Sparse Shelves: For each $k$, the last $k$-shelf created for small jobs is called a sparse shelf;
• Dense Shelves: The remaining $k$-shelves created for small jobs are called dense shelves.

Let $W_F$ denote the total weight of the jobs on the full shelves and $H_F$ denote the maximum load resulting from these jobs. Similarly, let $W_S$ denote the total weight of the jobs on the sparse shelves and $H_S$ denote the maximum load resulting from these jobs. Finally, let $W_D$ denote the total weight of the jobs on the dense shelves and $H_D$ denote the maximum load resulting from these jobs.

Lemma 1. 

$W_F>{\displaystyle \frac{m}{2}}{H}_F$.

Proof. 

For the jobs on the full shelves, each job $j$ has a size $s_j>{\displaystyle \frac{1}{2}}m$. Therefore, it is evident that $W_F>{\displaystyle \frac{m}{2}}{H}_F$. □

Lemma 2. 

$W_S+W_D>{\displaystyle \frac{m}{2}}{H}_D$.

Proof. 

For any $k$, let $v$ be the number of $k$-shelves. By definition, the first $v-1$ shelves are dense and the $v$-th shelf is sparse. Let $W_S\left(k\right)$ denote the total weight of the jobs on the sparse $k$-shelf (i.e., the $v$-th shelf), $W_D\left(k\right)$ denote the total weight of the jobs on the dense $k$-shelves (i.e., the first $v-1$ shelves), and $H_D\left(k\right)$ denote the maximum load resulting from the jobs on the dense $k$-shelves. We show that $W_S(k)+W_D(k)>{\displaystyle \frac{m}{2}}{H}_D(k)$ holds for any $k$, thereby proving the lemma. We discuss three cases based on the value of $v$.

• Case 1: $v=1.$ This case means there is only one $k$-shelf, which is a sparse shelf. Therefore, $H_D(k)$ is 0, and $W_S(k)+W_D(k)>{\displaystyle \frac{m}{2}}{H}_D\left(k\right)$ is obviously true.
• Case 2: $v=2.$ There is one sparse shelf and one dense shelf. According to the first-fit principle, we know that the total size of jobs is greater than $m$; otherwise, there would be only one shelf. Since the jobs have processing times greater than $2^{k-1}$, we have $W_S\left(k\right)+W_D\left(k\right)>2^{k-1}m$. Given that there is only one dense shelf, it follows that $H_D\le 2^k$, yielding $W_S(k)+W_D(k)>{\displaystyle \frac{m}{2}}{H}_D\left(k\right)$.
• Case 3: $v\ge 3.$ Let $j_u$ denote the job with the largest processing time on the $u$-th shelf for $u=1,2,\dots ,v$. We show that for each $u\in \{1,2,\dots ,v-1\}$, it holds that the total weight $w_u$ of jobs in the $u$-th shelf is at least

  $$w_u\ge s_{j_u}\cdot p_{j_u}+\left(m-s_{j_u}-s_{j_{u+1}}\right)2^{k-1}.$$

For $u=v$, it holds that $w_v\ge s_{j_v}\cdot p_{j_v}\ge s_{j_v}\cdot 2^{k-1}$.

The reason that the above inequalities are true is as follows. Since job $j_{u+1}$ cannot be accommodated in the $u$-th shelf, there are at least $m-s_{j_{u+1}}$ servers on the $u$-th shelf which are occupied. Due to any job in the $u$-th shelf having a processing time at least $2^{k-1}$, the above inequalities hold. According to the inequalities, we can obtain the following:

$$\begin{array}{cc}\hfill {\displaystyle \sum _{u=1}^v}{w}_u& \ge {\displaystyle \sum _{u=1}^{v-1}}{s}_{j_u}\cdot p_{j_u}+{\displaystyle \sum _{u=1}^{v-1}}\left(m-s_{j_u}-s_{j_{u+1}}\right)2^{k-1}+s_{j_v}\cdot 2^{k-1}\hfill \\ & ={\displaystyle \sum _{u=1}^{v-1}}{s}_{j_u}\cdot p_{j_u}+{\displaystyle \sum _{u=1}^{v-1}}\left(m-2s_{j_u}\right)2^{k-1}+s_{j_1}\cdot 2^{k-1}\hfill \\ & ={\displaystyle \sum _{u=1}^{v-1}}{s}_{j_u}\left(p_{j_u}-2^k\right)+\left(v-1\right)m{2}^{k-1}+s_{j_1}\cdot 2^{k-1}\hfill \\ & \ge {\displaystyle \frac{m}{2}}{\displaystyle \sum _{u=1}^{v-1}}\left(p_{j_u}-2^k\right)+\left(v-1\right)m{2}^{k-1}+s_{j_1}\cdot 2^{k-1} \hfill & by (s_{j_u}\le {\displaystyle \frac{1}{2}}m) and (p_{j_u}\le 2^k) \\ & ={\displaystyle \frac{m}{2}}{\displaystyle \sum _{u=1}^{v-1}}{p}_{j_u}+s_{j_1}\cdot 2^{k-1}\hfill \\ & >{\displaystyle \frac{m}{2}}{\displaystyle \sum _{u=1}^{v-1}}{p}_{j_u}\hfill \\ & ={\displaystyle \frac{m}{2}}{H}_D(k)\hfill \end{array}$$

Therefore, we conclude that $W_S(k)+W_D(k)>{\displaystyle \frac{m}{2}}{H}_D\left(k\right)$. □

Lemma 3. 

$H_S\le 3opt$, where $opt$ is the optimal makespan.

Proof. 

According to the definition, for any integer $k$, there is only one sparse $k$-shelf. Let $k^{*}$ be the largest integer $k$ for which a $k$-shelf exists. Denote the job with the longest processing time on the $k^{*}$-shelf by $\beta$. We know that $2^{k^{*}-1}\le p_{\beta }\le 2^{k^{*}}$ and $p_{\beta }\le opt$. The total height of all other sparse shelves (excluding the $k^{*}$-shelf) is at most

$${\displaystyle \sum _{i=-\infty }^{k^{*}-1}}{2}^i=2^{k^{*}}$$

Therefore, the maximum load on the sparse shelves, $H_S$, is given as follows:

$$H_S\le 2^{k^{*}}+p_{\beta }\le 3p_{\beta }\le 3opt.$$

This completes the proof. □

Based on the above three lemmas, we can prove the following theorem:

Theorem 2. 

The upper bound of the competitive ratio of RS algorithm is 5.

Proof. 

In the allocation scheme generated by the algorithm, the weight of all the jobs is $W=W_F+W_D+W_S$. A lower bound on the optimal solution, $opt$, can be obtained by distributing all the jobs equally among $m$ servers. According to Lemmas 1 and 2, we have

$$opt\ge {\displaystyle \frac{1}{m}}(W_F+W_D+W_S)>{\displaystyle \frac{1}{2}}(H_F+H_D)$$

Therefore, we can state that the makespan of RS algorithm is upper bounded by

$$C_{RS}=H_F+H_D+H_S<5opt$$

Therefore, the upper bound of the competitive ratio of algorithm is 5. □

4.2. The Lower Bound of the Competitive Ratio

Theorem 3. 

The lower bound of the competitive ratio of RS algorithm is 5.

Proof. 

To establish the lower bound of the competitive ratio of the RS algorithm, we construct a specific instance where the RS algorithm incurs a makespan of 5, while the optimal solution incur a makespan of only 1. This proves that the competitive ratio of the RS algorithm has a lower bound of 5.

First, we release $u$ jobs $\{\left(1, 1+ϵ\right), \left(1, 1\right), \left(1, 1/2\right), \left(1, 1/2^2\right), \dots , \left(1, 1/2^{u-2}\right)\}$, where each job has a size of 1, meaning it occupies one machine. According to the RS algorithm, each of these $u$ jobs opens a new shelf, and every job is assigned to the first machine (leftmost) on its respective shelf. After allocating these jobs, the load on machine 1 will be

$${\mathcal{l}}_1=2+ϵ+\sum _{i=1}^{u-2}{\displaystyle \frac{1}{2^i}}=3+ϵ-{\displaystyle \frac{1}{2^{u-2}}}$$

Next, we release a sequence of $m$ jobs, denoted as $J^{*}$. The first job in this sequence is $(1,{\displaystyle \frac{1}{2^{u-1}}})$, while each of the remaining $m-1$ jobs is $(1, {\displaystyle \frac{1}{2^u}}+ϵ)$. According to the RS algorithm, none of these $m$ jobs can be placed in any of the previously created $u$ shelves. Therefore, they are all scheduled on a new shelf.

In this newly created shelf, the load on the first machine (where the first job is placed) is ${\displaystyle \frac{1}{2^{u-1}}}$, while the load on all other machines in the shelf is ${\displaystyle \frac{1}{2^u}}+ϵ$.

We then repeat this sequence $J^{*}$ a total of $2^u$ times. Each repetition opens a new shelf, and the jobs are placed in a similar manner. Thus, after $2^u$ repetitions, there are $2^u$ new shelves, with the maximum load occurring on machine 1. The total load for these $2^u$ shelves on machine 1 is ${\displaystyle \frac{1}{2^{u-1}}}\times 2^u=2$.

Thus, considering both the initial $u$ jobs and the subsequent jobs from the $J^{*}$ sequence, the final load on machine 1 is

$${\mathcal{l}}_1=5+ϵ-{\displaystyle \frac{1}{2^{u-2}}}$$

However, the optimal solution (denoted as $opt$) is close to 1. The optimal strategy for scheduling the jobs can be arranged as follows.

First, from the initial $u$ jobs, place $\left(1, 1+ϵ\right)$ on machine 1 and $\left(1, 1\right)$ on machine 2. Then, schedule the remaining jobs $\{\left(1, 1/2\right), \left(1, 1/2^2\right), \dots , \left(1, 1/2^{u-2}\right)\}$ onto machine 3. The largest load among these three machines will be on machine 1, which has a load of $1+ϵ$.

Next, we schedule the first job from each repetition of $J^{*}$, i.e., the $2^u$ jobs $(1,{\displaystyle \frac{1}{2^{u-1}}})$. These jobs are evenly distributed across machines 3 and 4, resulting in each of these machines having a load of 1.

Finally, the remaining $(m-1)2^u$ jobs $(1, {\displaystyle \frac{1}{2^u}}+ϵ)$ are evenly distributed across the remaining machines, from machine 5 to machine $m$. After distribution, the load on these machines becomes $\left({\displaystyle \frac{1}{2^u}}+ϵ\right){\displaystyle \frac{(m-1)2^u}{m-4}}=\left(1+2^uϵ\right){\displaystyle \frac{m-1}{m-4}}$. Thus, $opt=\left(1+2^uϵ\right){\displaystyle \frac{m-1}{m-4}}$.

If we let $ϵ$ approach 0 and allow $u$ and $m$ to approach infinity, the makespan of the RS algorithm converges to 5, while the makespan of the optimal solution converges to 1. Thus, the competitive ratio of the RS algorithm is lower bounded by 5. This establishes that the lower bound of the competitive ratio for the RS algorithm is 5. □

5. Numerical Simulation

In this section, we describe a numerical simulation conducted to validate the effectiveness of the Revised Shelf (RS) algorithm. We compare it against the Greedy algorithm, which, despite its theoretical shortcomings, is widely used in practice. By examining the average performance of the algorithms under random job scenarios, we aim to provide a comprehensive evaluation of their practical efficiency. This comparison helps us understand how the RS algorithm’s theoretical competitive ratio aligns with real-world performance and how the Greedy algorithm, which lacks a constant competitive ratio, measures up in various conditions.

The algorithms compared in our simulation were as follows:

• Greedy algorithm: This algorithm assigns each job to the server that minimizes the current makespan. If there are multiple optimal choices, the tie is broken arbitrarily;
• Leftmost Greedy (FF-Greedy) algorithm: Similar to the Greedy algorithm, FF-Greedy assigns each job to the server that minimizes the current makespan. However, when multiple choices are optimal, it assigns the job to the leftmost available space;
• Revised Shelf (RS) algorithm: this algorithm has previously been introduced in this paper;
• Dynamic-RS (D-RS) algorithm: To enhance the RS algorithm’s performance in practical applications and numerical simulations, we propose the D-RS algorithm, which includes a more effective tie-breaking rule. Unlike the original RS algorithm, where jobs are always placed starting from the leftmost available servers, the D-RS algorithm employs a dynamic tie-breaking rule. This rule allows jobs to be placed either at the leftmost or rightmost available servers within each shelf, depending on which placement allows the job to be completed earlier. Note that the D-RS shares the same theoretical upper bound of the competitive ratio.

In order to evaluate the performance of each algorithm based on their competitive ratios, it was necessary to compute the optimal solution for each instance, corresponding to the best possible scheduling outcome when all job information is fully known in advance. Given that finding the optimal solution for scheduling problems is NP-hard, even for the case of two machines, we formulated a mixed-integer linear programming (MILP) model to solve this problem. The purpose of using the MILP model here was solely to compute the optimal solution as a benchmark for comparing the performance of our online algorithms. The computational speed or efficiency of solving this MILP model is not the focus of this study, as the model serves only as a reference for evaluating the competitive ratio.

We acknowledge that there are various more efficient MILP formulations for the berth allocation problem, such as those by Imai et al. [19] and Iris et al. [20]. However, for the purpose of our study, we adopted a straightforward MILP formulation to ensure clarity and simplicity in implementation, focusing on obtaining the exact optimal makespan for the given job set and available machines. We did not specifically optimize the MILP formulation for computational efficiency, as its sole purpose was to provide an accurate benchmark for assessing the online algorithms.

The MILP model we used is described as follows:

Given data: The set of tasks is denoted by $J=\left\{1,2,\dots ,n\right\}$, where each task $i\in J$ has two parameters: size $s_i$ and processing time $p_i$. The number of servers is m;

Decision variables: For each task $i\in J$, we define decision variables $\left(x_i,y_i\right)$, where $x_i$ represents the starting time of task $i$, and $y_i$ denotes the first server occupied by task $i$ in a set of consecutive servers. Hence, during the time interval $\left[x_i,x_i+p_i\right]$, task $i$ occupies the server set $\left\{y_i,\dots ,y_i+s_i-1\right\}$;

Objective Function:

$$\mathrm{M}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{m}\mathrm{i}\mathrm{z}\mathrm{e} \underset{i\in J}{\mathrm{m}\mathrm{a}\mathrm{x}} \left(x_i+p_i\right)$$

Constraints:

Non-overlapping tasks constraint: For any pair of tasks $i,i^{\prime }\in J$ with $i\ne i^{\prime }$:

$$(x_i+p_i\le x_{i^{\prime }}\mathrm{or} x_{i^{\prime }}+p_{i^{\prime }}\le x_i) \mathrm{or} (y_i+s_i\le y_{i^{\prime }}\mathrm{or} y_{i^{\prime }}+s_{i^{\prime }}\le y_i)$$

This ensures that tasks do not overlap in terms of time or server usage.

Server range constraint:

$$\begin{gathered} y_i\ge 1, \forall i\in J \\ {y}_i+s_i-1\le m, \forall i\in J \end{gathered}$$

Variable constraints:

$$\begin{gathered} x_i\in R^{+}, \forall i\in J \\ {y}_i\in N^{+}, \forall i\in J \end{gathered}$$

In the original optimization model, the objective function involving a min–max expression and the “or” constraints are nonlinear. To solve this using Gurobi, it was necessary to linearize both the objective function and the constraints.

Objective Function Linearization: We introduce a new decision variable Z and enforce the linear constraint:

$$Z\ge x_i+p_i, \forall i\in J$$

The new objective function becomes:

$$\mathrm{M}\mathrm{i}\mathrm{n}\mathrm{i}\mathrm{m}\mathrm{i}\mathrm{z}\mathrm{e} Z$$

Linearized Constraints:

Linearized non-overlapping tasks constraint: For any $i,i^{\prime }\in J$ with $i\ne i^{\prime }$ (where $M$ is a sufficiently large constant):

$$\begin{gathered} x_i+p_i\le x_{i^{\prime }}+M\ast a_{i,i^{\prime }}+M\ast c_{i,i^{\prime }} \\ {x}_{i^{\prime }}+p_{i^{\prime }}\le x_i+M\ast \left(1-a_{i,i^{\prime }}\right)+M\ast c_{i,i^{\prime }} \\ {y}_i+s_i\le y_{i^{\prime }}+M\ast b_{i,i^{\prime }}+M\ast \left(1-c_{i,i^{\prime }}\right) \\ {y}_{i^{\prime }}+s_{i^{\prime }}\le y_i+M\ast \left(1-b_{i,i^{\prime }}\right)+M\ast \left(1-c_{i,i^{\prime }}\right) \end{gathered}$$

where $a_{i,i^{\prime }},b_{i,i^{\prime }},c_{i,i^{\prime }}\in \left\{0,1\right\}$ are binary variables indicating whether tasks overlap in terms of time or server allocation.

Server range constraints:

$$\begin{gathered} y_i\ge 1, \forall i\in J \\ {y}_i+s_i-1\le m, \forall i\in J \end{gathered}$$

Variable Constraints:

$$\begin{gathered} x_i\in R^{+}, \forall i\in J \\ {y}_i\in N^{+}, \forall i\in J \\ {a}_{i,i^{\prime }},b_{i,i^{\prime }},c_{i,i^{\prime }}\in \left\{0,1\right\}, \forall i,i^{\prime }\in J \mathrm{and} i\ne i^{\prime } \end{gathered}$$

The transformed model is now a mixed-integer linear programming (MILP) problem. As both the number of constraints and the number of variables increase approximately quadratically with the number of tasks $n$, solving for the optimal solution in large-scale problems becomes computationally prohibitive within acceptable time limits. Therefore, in the numerical simulations, we limited the problem size to reasonable scales, sufficient to demonstrate the algorithm’s average-case performance.

Next, we outline the parameters, simulation steps, and results of the simulation. The detailed parameters of the numerical simulation were as follows:

Number of Servers: Fixed at 20 servers for all simulations;

Number of Jobs: The number of jobs varies and takes values of 20, 40, 60, 80, and 100;

Job Parameters: Each job has two parameters: size and processing time. The size of each job is a random integer from the range $[s, k]$, where $[s, k]$ takes values of $[1, 5]$, $\left[1, 10\right]$, $[1, 15]$, $[1, 20]$, $[5, 10]$, $[5, 15]$, $[5, 20]$, $[10, 15]$, $[10, 20]$, $[15, 20]$. This variability allows analysis of different job types and their impact on the algorithms. The processing time is a random integer from the range $[1, 10]$. Both parameters follow a discrete uniform distribution.

The specific steps of the numerical simulation were as follows:

Step 1. Randomly generate $n$ jobs based on the specified parameters, with $n$ taking values of 20, 40, 60, 80, and 100;

Step 2. Apply the basic Greedy algorithm, FF-Greedy algorithm, RS algorithm, and D-RS algorithm to distribute the jobs across the 20 servers. For each algorithm, compute the final completion time (makespan) of the job set and divide this by the makespan achieved by the optimal algorithm to calculate the competitive ratio;

Step 3. Repeat steps 1 and 2 for 50 iterations for each combination of job number and size range.

5.1. Simulation Discussion

Due to space limitations, we present the summarized average results of the 50 simulations in

Table 1. Average Competitive Ratios from 50 Simulations for Different Job Sizes and Quantities.

Rand Size	Num of Jobs	Greedy		FF-Greedy		RS		D-RS
		Mean	Std	Mean	Std	Mean	Std	Mean	Std
[1, 5]	20	1.269	0.093	1.256	0.113	1.439	0.153	1.388	0.152
	40	1.149	0.041	1.144	0.033	1.21	0.063	1.191	0.069
	60	1.097	0.027	1.094	0.028	1.159	0.048	1.147	0.044
	80	1.078	0.02	1.072	0.019	1.12	0.041	1.096	0.038
	100	1.063	0.019	1.054	0.022	1.111	0.029	1.082	0.03
[1, 10]	20	1.24	0.07	1.17	0.063	1.229	0.129	1.184	0.058
	40	1.126	0.047	1.098	0.04	1.155	0.048	1.126	0.037
	60	1.094	0.025	1.07	0.024	1.122	0.037	1.091	0.031
	80	1.076	0.021	1.049	0.018	1.102	0.031	1.075	0.019
	100	1.056	0.018	1.037	0.015	1.078	0.019	1.056	0.017
[1, 15]	20	1.178	0.095	1.124	0.081	1.198	0.088	1.138	0.092
	40	1.127	0.057	1.089	0.035	1.181	0.057	1.128	0.046
	60	1.131	0.038	1.068	0.031	1.144	0.038	1.088	0.036
	80	1.12	0.037	1.064	0.026	1.137	0.045	1.092	0.036
	100	1.115	0.039	1.054	0.021	1.124	0.031	1.081	0.026
[1, 20]	20	1.107	0.059	1.08	0.047	1.101	0.072	1.072	0.058
	40	1.1	0.034	1.057	0.035	1.106	0.046	1.062	0.031
	60	1.089	0.028	1.05	0.021	1.101	0.035	1.061	0.023
	80	1.088	0.029	1.046	0.021	1.099	0.027	1.064	0.021
	100	1.074	0.026	1.038	0.024	1.09	0.026	1.058	0.023
[5, 10]	20	1.234	0.072	1.151	0.055	1.203	0.076	1.162	0.063
	40	1.145	0.042	1.103	0.028	1.139	0.04	1.101	0.035
	60	1.147	0.029	1.1	0.021	1.146	0.029	1.102	0.034
	80	1.134	0.024	1.089	0.017	1.125	0.023	1.087	0.023
	100	1.131	0.026	1.092	0.015	1.119	0.023	1.092	0.022
[5, 15]	20	1.159	0.08	1.072	0.058	1.128	0.077	1.061	0.047
	40	1.161	0.059	1.086	0.049	1.159	0.051	1.076	0.045
	60	1.14	0.038	1.064	0.036	1.134	0.046	1.06	0.036
	80	1.156	0.037	1.061	0.032	1.133	0.038	1.052	0.03
	100	1.137	0.042	1.057	0.025	1.121	0.04	1.052	0.032
[5, 20]	20	1.099	0.054	1.056	0.044	1.077	0.045	1.047	0.032
	40	1.095	0.039	1.05	0.031	1.086	0.03	1.048	0.029
	60	1.074	0.031	1.034	0.022	1.074	0.032	1.038	0.022
	80	1.082	0.024	1.038	0.021	1.081	0.023	1.036	0.021
	100	1.067	0.025	1.026	0.018	1.064	0.022	1.03	0.017
[10, 15]	20	1.057	0.06	1.005	0.008	1.026	0.032	1.009	0.013
	40	1.057	0.034	1.006	0.007	1.014	0.012	1.008	0.008
	60	1.043	0.027	1.004	0.004	1.01	0.009	1.007	0.005
	80	1.046	0.033	1.004	0.003	1.01	0.007	1.006	0.004
	100	1.033	0.028	1.003	0.003	1.008	0.006	1.004	0.004
[10, 20]	20	1.039	0.043	1.003	0.008	1.011	0.018	1.002	0.006
	40	1.04	0.032	1.003	0.004	1.01	0.011	1.006	0.006
	60	1.028	0.019	1.004	0.005	1.009	0.008	1.005	0.005
	80	1.023	0.019	1.003	0.003	1.008	0.007	1.004	0.004
	100	1.025	0.016	1.003	0.003	1.007	0.005	1.004	0.003
[15, 20]	20	1	0	1	0	1	0	1	0
	40	1	0	1	0	1	0	1	0
	60	1	0	1	0	1	0	1	0
	80	1	0	1	0	1	0	1	0
	100	1	0	1	0	1	0	1	0

, below.

Based on Table 1, we observe that the performance of different algorithms varied significantly across different job size ranges. For smaller job sizes, such as [1, 5], the Greedy and FF-Greedy algorithms generally demonstrated superior performance. Despite their theoretically poor worst-case performance (lacking a constant competitive ratio), these algorithms perform quite well under more practical, randomized scenarios. On the other hand, for moderately sized jobs, such as those in the [5, 15] range, the D-RS algorithm outperformed all the others, with the FF-Greedy algorithm following closely.

To further visualize the performance of different algorithms from a statistical perspective, we calculated the mean competitive ratios for each rand size group by averaging the number of jobs. Figure 3 displays the performance across different rand sizes and algorithms, with error bars representing plus or minus one standard deviation. It is evident that there were some fluctuations. Although the D-RS algorithm performed poorly in the smallest job sizes, specifically [1, 5], it performed comparably to the FF-Greedy algorithm as the job sizes increased (e.g., [1, 10], [1, 15], [1, 20]). Notably, in the moderately sized jobs, such as [5, 15] and [5, 20], the D-RS algorithm showed exceptional performance. Additionally, the shorter error bars for the D-RS algorithm highlight its robustness, as they are significantly smaller compared to those of the other algorithms. This suggests that the D-RS algorithm was more consistent in its performance, indicating greater stability and reliability. As the job size continued to increase, both the D-RS and FF-Greedy algorithms exhibited the best performance.

5.2. Further Analysis

To provide a more comprehensive evaluation, we conducted a detailed graphical analysis of the algorithms’ performance across two representative job size ranges: [1, 5] and [5, 15].

For the [1, 5] job size range, Figure 4, Figure 5 and Figure 6 illustrate the average competitive ratio, standard deviation, and box plots over 50 simulations, respectively. The data clearly show that the Greedy and FF-Greedy algorithms outperformed the RS and D-RS algorithms in terms of both average performance and stability. As the number of jobs increased, the competitive ratios of all algorithms improved, indicating better efficiency with larger job sets. This trend suggests that simpler algorithms like Greedy and FF-Greedy are particularly effective for smaller, more uniform job sizes.

In contrast, for the [5, 15] job size range, Figure 7, Figure 8 and Figure 9 reveal a different pattern. The D-RS algorithm consistently exhibited the best performance, with the lowest average competitive ratios and standard deviations indicating both high efficiency and stability. The FF-Greedy algorithm also performed well, albeit slightly less so than the D-RS. The improved performance of the D-RS in this range can be attributed to its dynamic tie-breaking rule, which better accommodates the specific variability in this job size range.

The numerical simulation of competitive ratios revealed distinct advantages for different algorithms depending on job size. For smaller job sizes ([1, 5]), the FF-Greedy algorithm emerged as the most efficient, while for medium-sized jobs ([5, 15]), the D-RS algorithm proved to be the most effective. These findings underscore the importance of selecting the appropriate algorithm based on job characteristics to achieve optimal performance in server load distribution.

5.3. Scalability Analysis

We evaluated the scalability and computational efficiency of the four algorithms: Greedy, FF-Greedy, RS, and D-RS. The simulation was conducted on a system equipped with an Intel Core i7-12700F CPU running at 16 GB of RAM. All algorithms were implemented using Python 3.11. We randomly generated a total of six job sets, with job numbers of 100, 500, 1000, 3000, 5000, and 10,000, respectively. The number of servers was set to 20, and the job sizes were randomly selected from the range [5, 15]. The processing time of each job was randomly chosen from the interval [1, 10]. Due to the complexity of solving large-scale mixed-integer programming problems, we focus on comparing the makespan results obtained by each algorithm rather than their competitive ratios.

Table 2. Makespan and Computation Time for Different Numbers of Jobs.

Number of Jobs	Algorithm	Makespan	Time (s)
100	Greedy	323	0.001
100	FF-Greedy	302	0.001
100	RS	310	0.001
100	D-RS	293	0.001
500	Greedy	1577	0.005
500	FF-Greedy	1416	0.006
500	RS	1468	0.003
500	D-RS	1420	0.009
1000	Greedy	3111	0.011
1000	FF-Greedy	2857	0.010
1000	RS	2954	0.008
1000	D-RS	2851	0.031
3000	Greedy	9378	0.030
3000	FF-Greedy	8392	0.029
3000	RS	8604	0.051
3000	D-RS	8303	0.223
5000	Greedy	15,691	0.052
5000	FF-Greedy	14,125	0.050
5000	RS	14,387	0.140
5000	D-RS	14,075	0.614
10,000	Greedy	30,790	0.100
10,000	FF-Greedy	27,484	0.098
10,000	RS	27,904	0.534
10,000	D-RS	27,378	2.588

summarizes the makespan and computational times for each algorithm across different job sets. For smaller job sets (100 jobs), all algorithms exhibited minimal computational times, with most completing in approximately 0.001 s. As the problem size increased, the computational time grew, though all algorithms maintained reasonable performance. Notably, for the largest task set of 10,000 tasks, the Greedy, FF-Greedy, and RS algorithms solved the problem in 0.6 s, while the D-RS algorithm required 2.588 s. These results indicate that the algorithms are capable of solving large-scale problems efficiently within a short period, demonstrating high computational speed.

6. Conclusions

In this paper, we explore the berth allocation problem in an online setting, where vessels arrive online in sequence. Our key contributions include proving that the widely used Greedy algorithm has a poor theoretical guarantee for this problem, with a competitive ratio lower bounded by $\mathsf{\Omega }(\log m/\log \log m)$, which worsens as the number of berths $m$ increases. To address this, we introduce the Revised Shelf (RS) algorithm, drawing from the online strip packing problem, and demonstrate through comprehensive theoretical analysis that the RS algorithm has a competitive ratio of 5, an improvement over the original ratio of 6.66. Additionally, our extensive numerical simulations compare the RS and Greedy algorithms in average cases, revealing that the Greedy algorithm is most efficient for smaller jobs, while the RS algorithm is more effective for medium-sized jobs.

Beyond the theoretical and computational improvements, our work also carries significant implications for sustainability in maritime logistics. Efficient berth allocation, as demonstrated by the RS algorithm, can lead to reduced vessel waiting times, which in turn minimizes fuel consumption and idling at ports. By optimizing berth usage, fewer resources are wasted, and port operations can run more smoothly, reducing the emission of greenhouse gases such as CO₂. Thus, the adoption of better online algorithms like RS not only enhances operational efficiency but also contributes to more sustainable maritime logistics by lowering carbon footprints and supporting environmental goals. These findings underscore the importance of choosing the right algorithm based on vessel characteristics to ensure optimal performance and promote eco-friendly practices in port management.