Coalitional Game Model for SC Clustering Sub-game

In this subsection, we formulate the SC clustering sub-game where SC clusters are formed and dynamically updated based on spatio-temporal changes in the network and/or user profiles. Let C = {SC1, . . . , SCn} be the players of our

coalition game i.e. small cells in the network and assume that they are grouped into clusters C = {C1, . . . , Cs}. A coalition is defined as the groups of players

in the same cluster i.e. Ci = {SCi1, SCi2...SCiz} and a collection is defined as

the set of coalitions H = {H1, H2, ..., Hb}. A collection is called a partition

partition C is defined by the utility function v(Ci, C) and overall SC clustering

sub-game is defined by (C, v) pair. The utility function reflects the overall gain for cooperation including multiple objectives of CoMP deployment (e.g. like spectral efficiency and backhaul/RAN load balancing) and also the various cost factors of cooperation (e.g. like additional pilot requirement, signal processing complexity). An accurate utility function is key for better CoMP clustering to maximize the benefits expected from CoMP.

We utilize two utility functions we presented in Chapter 4. Firstly, we employ a load aware utility function which aims to shift load from highly loaded cells to lightly loaded cells and implicitly improve spectral efficiency as follows:

v1(SCm, Ci) =    −(ˆlim) 1−c(|Ci|)ˆuim ˆlim<1 −(ˆlim)3 1−c(|Ci|)ˆuim ˆlim≥1 (5.12) where c(|Ci|) = _1+e−(|Ci|−C1 n

max). c(|Ci|) is defined as the complexity function

which represents the additional overhead for CoMP such as precoding processing complexity, synchronization issues and additional backhaul capacity. As the ad- ditional overheads for CoMP increase when cluster size increase, the complexity function is designed to introduce a soft limit to maximum cluster size Cn

max based

on the requirements of the network for the right trade-off between additional spectral efficiency/load gain and CoMP overheads.

An spectral efficiency based utility is also employed in our work within a greedy algorithm for comparison. This utility does not consider cell load but aims to maximize spectral efficiency only. Spectral efficiency based utility function is defined as follows: v2(SCm, Ci) = X k∈Ubest im y_k(1 − c(|Ci|)) (5.13) where Ubest

im is the list of users where SCm is the best serving cell based on

average received signal power within Ci , i.e. a subset of the associated users

Uim at the SCm and yk is the spectral efficiency achieved at UEk i.e. yk = log2(1 +SIN Rˆ k).

To compare the utility of two different collections H = {H1, H2, ..., Hb} and G = {G1, G2, ..., Gz} of the same subset of players, we employ the utilitarian

comparison order where collection H is preferable to collection G if the overall utility of the collection is higher, even if the individual players may be worse off, i.e. H . G if Pb

i=1v(Hi) > Pzi=1v(Gi) [31,148].

SC coalitions are formed and adapted into changing network/user profile con- ditions by 3 different clustering actions:

• Merge: Players (SCs) in any two or more coalitions {G1, G2, ..., Gz} prefer

to merge into one coalition F = ∪z

i=1Gi i.e. ∪zi=1Gi . {G1, G2, ..., Gz}, if v(F) > (Pz

i=1v(Gi)) following the utilitarian order.

• Split: Players (SCs) prefer to split from any coalition Ci into smaller

coalitions {Ci1, Ci2, ..., Ciy} where Ci = ∪j=1y Cij i.e. {Ci1, Ci2, ..., Ciy} . Ci if

(Py

j=1v(Cij) > v(Ci) following utilitarian order.

• Transfer: Any player in Ci, i.e. SCix ⊆ Ci prefer to transfer from coalition

Ci to Cj i.e. {Ci\SCix, Cj ∪ SCix} . {Ci, Cj} if v({Ci\SCix) + v(Cj ∪ SCix) >

{v(Ci) + v(Cj)}.

Assume C = {C1, C2, ..., Cs} be any partition of C, i.e. the current network

clustering structure. We propose to start with split operation, followed by merge operation and then a transfer operation afterwards. Split/merge/transfer opera- tions are repeated until there is no more re-clustering action possible to improve overall utility.

Split operation checks possible split options for ∀Ci in C, and implements the

split operation when it finds a suitable split option based on utilitarian order i.e. (Py

j=1v(Cij) > v(Ci). Split operation is repeated iteratively until there is

no further split is possible as detailed in Algorithm 6. A new partition H is formed after the split operation. H is then subject to merge operation as detailed in Algorithm 7. Merge operation starts with coalition Hi with the maximum

absolute payoff value and looks for merge options to its neighbour coalitions. We avoid exhaustive search of possible merge with every other coalition in the network which reduces the algorithm complexity significantly. Merge operation is implemented for (Hi, Hj) coalition pair where Hj is the neighbour coalition for

Hi with maximum additional payoff in the case of a possible merge operation.

We adapt the neighbour coalition concept from Chapter 4 where we define them based on the reported average received signal power from the users. For any user

UEkwithin the serving area of SCm ⊆ Hm, a neighbour rank value is incremented

for {Hm, Hj} pair if pkj/pkm > P nei

∆ and pkj > P nei

min where pkm and pkj are the

average signal power values received from UEk for SCm ⊆ Hm and SCj ⊆ Hj

respectively. Merge operation continues for ∀Hi in H and is repeated for the

whole partition until no other merge is possible. Once the merge operation is finished, transfer operation starts with the new partition G formed after merge operation. For ∀Gi ∈ G, each SCix ∈ Gi are checked for a possible transfer to one

of the neighbour coalition Gj i.e. T (SCix, Gi, Gj). Within each coalition Gi, all

possible transfer operations are ranked and transfer operation T (SCix, Gi, Gj) is

continues for all ∀Gi ∈ Gand is repeated for the newly formed partition until there

is no further transfer possible with additional payoff, as detailed in Algorithm 8. Split, merge and transfer operations are then repeated until there is no further SC coalition actions possible.

Algorithm 6 Split Operation

For any given network clustering state C = {C1, C2, ..., Cs}, ∀Ci ∈ C, set

Ci.splitpossible=1

Split-ongoing=1

while Split-ongoing do

Split-ongoing=0

for all Ci where (Ci.split-possible=1 and |Ci| >1) do

Update Ci.Split-options

Ci.split-possible=0

for all Ci.Split-Options do

if Any split option is possible i.e. (Py

j=1v(Cij) > v(Ci) then

Split(Ci to {Ci1, Ci2, ..., Ciy}

Split-ongoing=1

∀Cij, set Cij.split-possible=1

Break for-loop and continue with next Ci

end if end for end for end while