## 中 華 大 學 碩 士 論 文

**中文題目：OVSF-CDMA 系統上無碼阻斷的管理機制 **

**Code-Blocking Free Management Schemes in ** **OVSF-CDMA Systems **

### 系 所 別：資 訊 工 程 學 系 碩 士 班

### 學號姓名： M09102018 劉孟迪 指導教授： 俞 征 武 博士

^{ }

### 中華民國 九十三 年 六 月

**Code-Blocking Free Management Schemes in ** **OVSF-CDMA Systems **

### By

**Meng-Ti Liu **

### Advisor: Prof. Chang Wu Yu

### Department of Computer Science and Information Engineering Chung-Hua University

### Hsin-Chu, 30067, Taiwan

### June 2004

**謝詞 **

每每在回憶的時候才發現時光飛逝。回想碩一的情景，與同學在實驗室挑燈 夜戰的事好像才剛發生過。但兩年的碩士求學生涯就要結束了，心中充滿著不 捨。這兩年從摸索研究方向到最後完成論文，讓我深刻體驗到做研究的挑戰與無 窮的樂趣，深刻的期望自己未來能秉持做研究的態度精神來做每件事。

這兩年的碩士生涯，給予我最大幫助的莫過於指導教授俞征武老師；從老 師身上我瞭解對問題敏感度的重要性，平時認為極為平常之處，卻可能隱藏著極 為有趣的問題等待深入研究。而老師對於研究精神之著重，也讓我養成獨立、確 實的正確學習態度，也讓我學會如何去做研究以及面對一個問題的態度。在平日 與老師溝通、相處時，更是感受到老師平易近人且時時刻刻關心學生，真是我的 良師益友。

最後，也要感謝平行分散實驗室的所有老師給予我的指導與協助，讓我的 論文內容能更加充實、完整；還有平行分散實驗室的諸位成員，感謝各位在每次 討論中所給予我的寶貴建議與鼓勵。最重要的，還要感謝我的家人，讓我無後顧 之憂，使我能專心致力於研究上，並且完成論文。最後再一次感謝大家！

劉孟迪 謹識 于 中華大學資訊工程研究所 九十三年六月

**摘要 **

在3G 服務中，OVSF-CDMA 系統可以提供可變傳輸速率的服務，以及可以

彈性地滿足多媒體應用時之不同傳輸速度的需求。分碼多重擷取技術經由使用正 交展頻波形使得許多使用者可以在同一媒介上同時傳輸多組不同的通訊資料而

不會發生巨大的電磁干擾。在 OVSF-CDMA 系統中，主要的問題就是碼阻斷。

碼阻斷對於系統頻寬使用率有很重大的影響。大部分的論文都是提出碼配置和碼 重新配置的方法來解決，但都只是經驗法(heuristic)。因此，我們提出了整合式 OVSF 碼管理方法同時去解決碼配置和碼重新配置問題。根據圖論，我們重新定 義一個新的支配問題並稱此新問題為有限制的獨立支配問題。藉由有限制的獨立 支配問題，我們解決了碼阻斷問題。

本論文以有限制的獨立支配問題為基礎，提出混合式碼管理方法可以完全消 除碼阻斷。另一方面，我們也盡可能降低因為碼重新配置所造成的成本。最後，

實驗結果證實重新配置所需的換碼次數不會因為流量負載變大而暴增。

關鍵詞：碼阻斷、碼配置、碼重新配置、OVSF-CDMA、3G、獨立支配問 題、有限制的獨立支配問題。

**Abstract **

In the 3G services, OVSF-CDMA systems has offered opportunities to provide
variable user data rates and flexibly support applications with different bandwidth
requirements. Code-Division Multiple-Access (CDMA) techniques allow many users
to transmit simultaneously in the same band without substantial interference by using
*approximately orthogonal spread-spectrum waveforms. The main issue is Code *
*Blocking in OVSF-CDMA systems. It may have significant impact on the bandwidth *
utilization of the systems. Most papers proposed code assignment and reassignment
schemes to resolve the problem, but they were heuristic. Therefore, we propose the
*Unified Code Management Schemes (UCMS) to resolve code assignment and *
reassignment problems simultaneously. According to graph theory, we define a new
*dominating problem and call it the Constrained Independent Dominating Problem *
(CIDP). We solve the code blocking problem by means of using Constrained
Independent Dominating Problem.

This paper presents the Unified Code Management Schemes to eliminate code blocking completely based on CIDP. On the other hand, we also reduce the cost of reassigned codes as far as possible. Finally, simulation results demonstrate that the number of reassignment codes do not significant increase with traffic load rising.

*Keyword：Code blocking, Code assignment, Code reassignment, OVSF-CDMA, *
*3G, Independent dominating problem, *

**Contents **

1. INTRODUCTION ...1

2. PRELIMINARIES ...6

2.1 OVSF Code tree...6

2.2 Code Blocking Problem...8

2.3 Independent Dominating Problem ...10

2.4 Constrained Independent Dominating Problem...11

3. RELATED WORK...14

3.1 Code Placement and Replacement Strategies for Wideband CDMA OVSF Code Tree Management...15

3.2 Dynamic Assignment of Orthogonal Variable-Spreading-Factor Codes in W-CDMA...18

4. UNIFIED CODES MANAGEMENT SCHEMES...27

4.1 Code Assignment Scheme ...27

4.2 Code Reassignment Scheme ...29

*4.3 Minimum Independent Dominating Set W ...*33

4.4 Reducing Internal Fragmentation by Multiple Codes...36

4.5 Transforming CIDP to IDP ...38

5. SIMULATION RESULTS ...40

6. CONCLUSION...44

REFERENCE...46

**Figures **

Figure 1. Orthogonal Variable Spreading Factor Code Tree...8

Figure 2. OVSF Code Blocking...9

Figure 3. G = ( V , E ) with Independent Dominating Set...11

Figure 4. Constrained Independent Dominating Problem. ...12

Figure 5. OVSF Code Tree transforms into CIDP. ...13

Figure 6. Code placement example...16

Figure 7. Code replacement example...18

*Figure 8. Code patterns for 8R branches...19 *

*Figure 9. Extended code pattern description for 8R branches. ...19 *

Figure 10. Branches described in grid pattern. ...20

*Figure 11. Code pattern for 4R branches. ...22 *

*Figure 12. Code patterns for 8R branches...23 *

Figure 13. Unified Code Management Schemes example1...30

Figure 14. Unified Code Management Schemes example2...31

Figure 15. Multiple codes example...37

Figure 16. The CIDP with Combinatorial Mathematics ...39

Figure 17. Distributional scheme of locks and keys...39

Figure 18. Blocking probability at different traffic load with max SF=16. ...42

Figure 19. Number of reassigned codes at different traffic load with max SF=16...42

Figure 20. Blocking probability at different traffic load with max SF=16. (Modified version) ...43

Figure 21. Number of reassigned codes at different traffic load with max SF=16. (Modified version) ...43

**Tables **

*Table I. Cost comparison of 4R branches. ...22 *
*Table II. Cost comparison of 8R branches...24 *
*Table II. (Continued) Cost comparison of 8R branches. ...25 *

**1. INTRODUCTION **

Recently, mobile communication services have became part of everyone’s life and come into our society at a tremendous growth rate over the past decade. In existing second-generation (2G) personal communication systems have adopted a digital technology and the services offered to users are typically limited to voice, facsimile, SMS, and low-bit-rate. In order to provide users with the necessary quality of service (Qos) for multimedia services, like high-rate service, internet access, large file transfer, image transmission and video streaming. In emerging third generation (3G) wireless standards UMTS/IMT2000 [1, 11] use wide-band CDMA (W-CDMA) to provide higher and variable rate requirements of multimedia applications. The 3G associate high-speed mobile access with Internet Protocol (IP) based services. This doesn’t just mean fast mobile connection to the World Wide Web (WWW) – by liberating us form slow connections, heavy equipment and immovable access points.

By 3G services, people can closely establish contact no matter where they are located in the world. It will enable new way to communicate, access information, conduct business and learning. The challenge of third generation (3G) cellular communication systems is to specify a new skill to provide services similar to fixed networks.

The 3G is a generic term covering a range of future wireless network technologies, including WCDMA, CDMA2000, UMTS and EDGE. The main technology of 3G is an extension of Code-Division Multiple-Access (CDMA). 3G is an ITU specification for the third generation of mobile communications technology (analog cellular was the first generation, digital PCS was the second generation), the mobile telephone can provide not only voice communication but also data transmission. Thus, a capacity target has been defined between 384 Kbps and 2 Mbps, 384 Kbps when a device is immovable or moving at pedestrian speed, 128 Kbps in a

car, and 2 Mbps in fixed applications, with the possibility to transmit variable-bit-rate
real-time streams as well as best effort files. The work was later taken over by the
3GPP (3^{rd} Generation Partnership Project) [3GPP], which is now the WCDMA
specification body with delegates from all over the world. The specification of 3G can
probably be divided into three kinds: WCDMA (ETSI), CDMA2000 (ANSI and
Korea), and TD-SCDMA (China). This paper will focus on WCDMA.

WCDMA is the dominating 3G technology, providing higher capacity for voice and data and high-data-rate. WCDMA is a kind of wireless at a high speed transmission specification and mainly used for offering several devices (such as cell-phone, PDA, Notebook) that can conveniently access multimedia. It can carry out many kinds of jobs simultaneously, for example the cell-phone subscriber can dial the telephone, download MP3 and browses through internet at the same time. It also uses a new spectrum with a 5 MHz carrier, providing 50 times higher data rate than in present GSM system and 10 times higher data rate than in present GPRS system. Data rates handles up to 2 Mbps for local area access and 384 Kbps for wide area access. A coming release will contain enhancements up to more than 10 Mbps. Because WCDMA can be compatible with present GSM core network, so the operator can gradually evolve from GSM to WCDMA, protecting investments by reusing GSM core network and 2G/2.5G services.

WCDMA adopts the encoding of direct-sequence code-division multiple-access (DS-CDMA) wireless transmission technology [26]. Each multiple-access user is assigned a unique code sequence, and the assigned codes are mutually orthogonal.

DS-CDMA utilizes the property of orthogonal encoding, and therefore the mutually orthogonal codes can be assigned for different mobile devices in the same band simultaneously. Three different schemes of DS-CDMA transmission were proposed:

single orthogonal variable-spreading-factor code (OVSF-CDMA) [1], multi-code

CDMA (MC-CDMA) [8, 11], and the hybrid method [9]. Single-Code transmission scheme means that every mobile device is only assigned one channelization code to transmit data, and Multi-Code transmission scheme is that every mobile device can be assigned multiple channelization code in the same time. In the case of hybrid method, the combination of multi-code and single-code schemes was given above. Single-code transmission scheme is for the requests of lower bandwidth, and multi-code transmission scheme is for the requests of higher bandwidth. MC-CDMA requires multiple transceiver units to support higher bandwidth, thus leading to increase hardware complexity. However, using OVSF-CDMA, only a single transceiver unit is needed per user. Therefore, in terms of hardware complexity for mobile devices, OVSF-CDMA is preferred over MC-CDMA for higher bandwidth. Several important issues must be resolved in an OVSF-CDMA system. Especially, the code-blocking problem (to be explained later in Chapter 2) results in a higher call-blocking rate for higher data rate users and a reduction in spectral efficiency. Thus the OVSF code management becomes very important design consideration in future wireless networks, and has got many concerns [7, 8, 15, 18].

In an OVSF-CDMA system, the different code lengths are represented different
transmission data rate. Total OVSF codes can be depicted as nodes in a complete
*binary tree called the OVSF code tree (to be explained later in Chapter 2) [2]. Mobile *
device requires the request with Base Station, and then it maybe assigned one
available OVSF code. Hence, it is very important that how to choose a suitable OVSF
code from the OVSF code tree to avoid the code tree becoming too fragmented and
maintains the code tree in the scarce bandwidth of wireless environment. The main
cause of code blocking problem is that the code tree becomes too fragmented to
support a new call and leads to reduce the code utilization of the OVSF-CDMA
*system. So, two addressed issues on such wireless environment are the code *

*assignment problem and code reassignment problem. The preceding addresses how to *
place a new call in the OVSF code tree to avoid the tree growing too fragmented. The
latter addresses how to reassign codes if a new call can not find proper place to supply
it. This can eliminate the code blocking problem, but code reassignment costs will
occur simultaneously. At the moment, some code assignment algorithms were
proposed in the literature [7, 8, 18] and code blocking of system was really reduced.

Moreover, some papers [15, 18] also focused the research on how to reassign codes
with minimum cost in order to eliminate the code blocking. But, so far as we known,
their schemes were not optimal. For this reason, the graph theory will be used as a
basic step in our proposed schemes. In this paper, we define a new dominating
*problem and call it the Constrained Independent Dominating Problem (CIDP) (to be *
*explained later in Chapter 2) based on graph theory. We also propose a Unified Code *
*Management Schemes to eliminate code blocking completely and the reassignment *
cost will be reduced as far as possible based on CIDP. Our schemes will achieve
optimal result by graph theory. Subsequently, we will describe cause between CIDP
and code assignment / reassignment in OVSF-CDMA systems.

In this thesis, our objective is to resolve code blocking problem resulting in enhancement of code utilization by the skill of graph theory. If OVSF code tree is fragmented seriously, the code blocking is easy incurred. So, the major goal is to make the OVSF code tree as compact as possible in order to avoid the tree becoming too fragmented. In fact, simulation results show that the code blocking is eliminated completely indeed. On the other hand, the numbers of code reassignment is also reduced as far as possible.

The rest of the paper is organized as follows. In the next chapter, the backgrounds knowledge and problem statement are introduced. In Chapter 3, we briefly survey related work. In Chapter 4, our unified code management schemes are

presented. Simulation results are described and discussed in Chapter 5. Finally, Chapter 6 concludes the paper.

**2. PRELIMINARIES **

In this chapter, the OVSF code tree, code blocking problem, is presented first.

Then independent dominating problem (IDP) is discussed. At last, we describe the constrained independent dominating problem (CIDP).

**2.1 OVSF Code tree **

The OVSF codes are used as the channelization codes in the UMTS terrestrial
radio access (UTRA). Spectrum spreading is achieved by mapping each data bit (1 or
-1) into an assigned code sequence. The length of the code sequence per data bit is
*called the spreading factor. Adachi, Sawahashi, and Okawa had proposed a *
tree-structured method of generating orthogonal spreading codes with different
lengths [2]. The possible OVSF codes can be represented as nodes in a complete
*binary tree called the OVSF code tree. These variable spreading factor codes support *
different data rates in an OVSF-CDMA system with only one spreading code per user.

The codes at each layer of the tree have different spreading factors, allowing users to
transmit at different data rates. In order to identify the codes in the tree without
*ambiguity, each code can be denoted as C**SF,k**, where SF is the spreading factor and k *
is the branch number, 1 ≦ k ≦ SF. The branches in each code layer are numbered
sequentially form left to right, starting from 1. Some features of the OVSF code tree
*are listed as follows. Suppose C**i** is the father of C** _{j}* in the tree.

*(1) Every node C**j** except root node C**1** (={1}) can be generated from its father C**i*.
*Suppose the code sequence of C**i** is [x], then we have C**j**=[x, x] if C**j* is the left
*child of C**i**. Or we have C**j**=[x, -x] if C**j* is the right child of C*i**. Where [-x] is the *
*bitwise complement of [x]. A complete tree of codes is generated by recursively *
applying Equation 1. It is illustrated in Figure 1 for a three-level OVSF code tree

with seven spreading codes.

*(2) IF the spreading factor of C**i** is 2k, the spreading factor of C**j** is 2k+1. *

*Furthermore, if the data rate of C**i** is 2r, then the data rate of C**j** is 2r-1. The data *
rate is halved whenever we go down one layer in the tree. Hence leaf nodes have
the minimum data rate and root node has the maximum data rate.

(3) An important property of OVSF codes is that two codes are orthogonal if and only if none is an ancestor of the other. That is to say, they mutually haven’t a direct relative. Only a mutually orthogonal set of codes can be used simultaneously; otherwise, their encoded sequences are indistinguishable. If a code is used, then simultaneous use of its ancestors or descendants can’t be allowed because they are not orthogonal.

An OVSF code tree example is shown in Fig. 1, each node in the tree
corresponds to an OVSF code, and all codes have identical encoded sequence length
and are mutually orthogonal at the same layer. Codes at different layers of the tree are
orthogonal, except in the case where a path can be tracked through a particular code to
*the root. For example, in Fig. 1, C**4,1** is orthogonal to C**4,2**, C**4,3**, C**4,4**, and C**2,2*, but it is
*not orthogonal to either C**2,1** or C**1,1**. The top layer code, called the root code as C**1,1* in
*Fig. 1, has a code length of 1 by convention. The children codes as C**2,1** and C**2,2* in Fig.

*1, which are first generated from parent code (in this case, the root code C**1,1*), have a

Figure 1. Orthogonal Variable Spreading Factor Code Tree.

*code length of 2. Then, codes (C**4,1**, ．．．C**4,4**) are generated form codes (C**2,1**, C**2,2*),
have a code length of 4, etc. The bottom layer codes are called the leaf codes or
*simply leaves as C**4,1**, C**4,2**, C**4,3** and C**4,4* in Fig. 1. An immediate inference is that the
aggregate data rate of OVSF-CDMA system is at most equal to the rate of root code.

**2.2 Code Blocking Problem **

*The code blocking problem in an OVSF-CDMA system was raised by Minn and *
*Siu [15], and they also proposed Dynamic Code Assignment (DCA) scheme [15] to *
eliminate the code blocking. We will introduce the DCA scheme in Chapter 3, and
quote the definition of code blocking in [15] as follows.

*Definition 1： We define OVSF code blocking as the condition that a new call cannot *
be supported although the system has excess capacity to support the rate requirement
of the call.

Because of the orthogonal property in OVSF-CDMA system results in constraint of code assignment. It is possible that a new call can’t be served even though the total

available system capacity can fulfill the acquired transmission rate of the call.

Therefore, the code blocking has significant impact on the code utilization leading to reduce utilization of system capacity. In general, code blocking in an OVSF-CDMA

Figure 2. OVSF Code Blocking.

system may usually result from the fragmentation of available. However, code
blocking may cause such a case when a high-rate call can’t be supported because all
supported codes for this data rate are not orthogonal to assigned codes. Next we will
briefly describe code blocking using an example shown in Fig. 2. Suppose two leaf
*codes C**4,2** and C**4,3**, each of rate 1R Kbps, are already assigned. The system has *
*capacity to serve two additional rate 1R using C**4,1** and C**4,4*. However, when a new call
*requires rate 2R, neither C**2,1** nor C**2,2* can be assigned for it because of blocking by
*their respective descendants C**4,2** and C**4,3*.

According to our study, two reasons of fragmentation in the code tree can be induced. In the first reason, poor code assignment scheme results in bad location of assigned code. In the second reason, assigned codes must be released during a process.

Hence, there are two methods to resolve this problem. On the one hand we present a good code assignment scheme, and on the other we adjust the bad location of assigned codes to suitable location by code reassignment scheme. We will show that our

*unified code management scheme (both of code assignment and code reassignment *
are considered) in Chapter 4.

**2.3 Independent Dominating Problem **

In graph theory, it has a lot of similar type with independent dominating problem,
*and for example: Domination Proble*m、Connected Domination Problem、Total
Domination Problem、Dominating Clique Problem [23]. Recent year, pay much attention
to these different kinds problem of dominating set. Hence, have much research results
on these problems [23, 24]. Because it has important applications to design or analyze
on Communication Networks 、 Social Sciences 、 Computational Complexity, and
Algorithm devise. Now we will introduce the independent dominating problem.

*Arbitrarily, given a graph G = (V, E), the vertex set S is included in V, if a *
*element of V doesn’t belong to vertex set S, it must be linked together one element *
*among vertex set S, and calls S the Dominating Set. An independent dominating set is *
also a dominating set, and each other elements of independent dominating set do not
link. The so-called independent dominating problem is whether find the independent
*dominating set for size is smaller or equal than k in an input graph. This problem was *
proved NP-complete [22], even input graph is bipartite graphs [10] or comparability
graphs [10] or line graphs [19], is still NP-complete.

Next we show an example of independent dominating set in Fig. 3. From Fig. 3,
*the two black vertexes are independent dominating set (V’), and they don’t connect *
*each other. Additionally, the remaining (white) vertexes (V-V’) must link together one *
*vertex among V’. *

Hence, we use the concept of independent dominating set applying to code assignment in OVSF-CDMA system. Because of we want to make the OVSF code tree as compact as possible. If we find minimum independent dominating set, that is

* Figure 3. G = ( V , E ) with Independent Dominating Set. *

*to say, avoid the fragmentation in OVSF code tree. We define Constrained *
*Independent Dominating Problem (CIDP) by modifying independent dominating *
*problem (IDP) and will be introduced in next section. *

**2.4 Constrained Independent Dominating Problem **

*First, we give a definition for Constrained Independent Dominating Problem *
(CIDP) as follows.

*Definition 2： Three input data is given. *

*(1) A graph G = ( V, E ). *

*(2) The dominating partition P in a vertex set V divides the vertex set V into k *
*disjoint independent dominating set, is P**1**, P**2**, …, P**k**. In other words, V= P**1* ∪
*P**2** ∪…∪ P**k**, for any i and j , P**i** ∩ P**j** =ψ; and each P**i* is a dominating set (the
*size is not sure minimum) of G. *

*(3) A condition (integer) vector of k dimension R= (r**1**, r**2**, …, r**3*).

The objective of Constrained Independent Dominating Problem is that finds a
*minimum independent dominating set (calls as W) and the numbers of vertex in each *
*partitions P**i** must be greater or equal than r**i**. If R is zero vector (i.e. R= (0, 0, ‧‧‧, 0)), *

Figure 4. Constrained Independent Dominating Problem.

the constrained independent dominating problem becomes original independent
dominating problem which we introduce previously. Before describe the mapping
relation between constrained independent dominating problem and OVSF code tree,
we show an example for constrained independent dominating problem in Fig. 4. For
*example, P= (P*1,* P*2*, P*3*) is an independent dominating partition and R= (0, 2, 0), one *
of solutions in the constrained independent dominating problem is the set (4, 5, 9).

Next we will illustrate the process which OVSF code tree transforms into CIDP
*(G) with Fig. 5. In OVSF code tree, if any two nodes have a direct relative (the two *
*codes collides each other), pull an edge for them. Because G is a comparability graph *
*of rooted tree posets, we can say the G is also a trivial perfect graph [20]. The *
*partition P is which utilizes the original layers in OVSF code tree, and any two nodes *
in each layer are just independent and orthogonal. Therefore, all nodes in each layer just
form an independent dominating set. *So P is an independent dominating partition. *

*Additionally, R= (r*1*, r*2*, r*3*), r**i** means the numbers of assigned code at the i layer in *
original OVSF code tree. Finally, we complete the transformation between OVSF
code tree and CIDP successfully.

It is a very important key point that any combination of code assignment
*(non-collision) is an independent dominating set in G. The R means bandwidth *

Figure 5. OVSF Code Tree transforms into CIDP.

*requests of being assigned code. The independent dominating set which satisfies the R *
condition and with minimum size, and it is a kind of code assignment which satisfies
the bandwidth requests and concentrates remaining bandwidth on minimum nodes.

Briefly, we resolve the constrained independent dominating problem and can get the best results indirectly in OVSF-CDMA system.

**3. RELATED WORK **

In this chapter, we will discuss some of code assignment and reassignment schemes which had been surveyed [3, 4, 6, 7, 8, 12, 13, 14, 15, 16, 17, 18]. Two sections are as follows, we will especially describe two papers [15, 18] .

In [4], they had proposed the scheme RDA that reduces the code blocking. It divides the OVSF code tree into different regions beforehand and each region corresponds to the requests effectively. The RDA is separated into two parts, OVSF code reservation and OVSF code assignment. The former part initializes the OVSF code tree by means of dividing the code tree into different rate regions. The latter part deals with the code assignment job.

In [8], code channel assignment deals with the problem that how different codes are allocated to different connections. They proposed a code channel assignment method for User Equipment (UE) that has the capability to support multi-rate services using multi-code transmission. Additionally, a single table is used to allocate codes to a UE according to its requested data rate. Therefore, the allocation and releasing procedures, which can be accomplished in a very short period of time, are efficient.

The objective of this paper is to find a code channel assignment method to support as many users as possible with less complexity.

In [7], the dynamic code assignment scheme had been proposed for boost utilization of codes. The grouping mechanism divides the OVSF code tree into two groups and each group provides the traffics with various quality-of-service (QoS) requirements. The proposed scheme implemented in the radio network controller (RNC) dynamically assigns and reassigns codes to traffics classified by UMTS.

*In [16], they define the weight of a candidate code C**k,l*, as the number of its
ancestor codes that will be blocked and are not already blocked due to other existing

*code assignment in the sibling subbranch of C**k,l*, ot the sibling subbranch of some
*ancestor of C**k,l**. Their weighted scheme always selects the code with the lower weight. *

In addition, the code reassignment adopts a reactive mechanism.

**3.1 Code Placement and Replacement Strategies for ** **Wideband CDMA OVSF Code Tree Management **

*In [18], Tseng had proposed three simple strategies: random, leftmost, and *
*crowded-first, in order to reduce the code blocking by code assignment scheme. *

Among them the crowded-first strategy has most promising. When there is one or more code with the desired rate in the code tree, the strategy will pick the one whose ancestor code has the least free capacity to accommodate the new call. Next we describe the code placement schemes and replacement schemes respectively in this paper [18].

A. Placement Schemes

*When a call requesting kR arrives, it need to find a code to accommodate this call. *

Assuming that no code reassignment will be conducted, [18] proposes three strategies below.

*Random: If there is one or more than one code in the code tree with a rate kR, *
randomly pick anyone and assign it to the call. Otherwise, the call is rejected.

*Leftmost: If there is one or more than one code in the code tree with a rate kR, *
pick the leftmost one in the code tree and assign it to the call. Otherwise, the call is
rejected. The intuition is to always vacate a larger capacity in the right-hand side of
the code tree so as to accommodate higher-rate calls in the future.

Figure 6. Code placement example.

*Crowded-first: If there is one or more than one code in the tree with a rate kR, *
pick the one whose ancestor code has the least free capacity. More specifically,
*suppose codes x and x’ are both of rate kR. It will compare the free capacities in their *
*ancestors, say y and y’, respectively. The one with less free capacity (i.e., more *
crowded) will be picked to accommodate the new call. When there are ties, it will go
*one level upper by comparing y and y’s ancestors. This is repeated until the sub-tree *
*with the least free capacity is found. One special case is that y may represent the same *
*sub-tree as y’. If so, it will follow the leftmost rule to pick the code on the left-hand *
side.

For example, consider code tree in Fig. 6. Suppose a new call arriving requesting
*a rate 2R. By the random strategy, any of the codes C**16, 1**, C**16, 5**, C**16, 6**, C**16, 7**, C**16, 8**, C**16, *
*15** may be picked to serve the new call. By the leftmost strategy, C**16, 1 *will be chosen.

*By the crowded-first strategy, it will compare these codes’ ancestors. Among them, *
*both C**8, 1** and C**8, 8** will be fully occupied if C**16, 1** and C**16, 15* are chosen, respectively.

*So it further compares their ancestors, C**4, 1** and C**4, 4*, but again this is a tie. After going
*one level upper, it will find that C**2, 2** is more crowded than C**2, 1**, so C**16, 15* will be
selected to serve the new call.

B. Replacement Schemes

The replacement strategy is in fact built on top of the DCA algorithm proposed

*in [15]. A new call arriving requesting for a rate kR but there is no free code of such *
rate exists, the following steps are taken:

*(1) If the total amount of free capacity in the code tree is ≧ kR, apply the DCA *
*algorithm in [15] to find the minimum-cost branch with rate kR. Otherwise, the *
call is rejected.

(2) For the busy codes in the branch found above, it relocates them one-by-one starting from those with higher rates. For each busy code being relocated, it is replaced based on any of earlier strategies (random, leftmost, or crowded-first).

Note that it is possible that no free code exists to accommodate the relocated call.

If so, this will trigger another round of DCA algorithm and thus another round of relocation. This is repeated recursively until all busy codes are relocated. Such a process is guaranteed to complete because there is sufficient free capacity in the code tree. Also, note that for each relocated call, it should stick with the same placement strategy consistently.

For example, in the code tree in Fig. 7, suppose a new call arriving requesting a
*rate 8R. Code C**4, 1* is the minimum-cost branch because it contains only two busy
codes, C*8, 1* and C*32, 7**. When relocating C**8, 1*, another reassignment will be triggered.

*This time, C**8, 8 *is selected as the minimum-cost branch because it contains only one
*busy code C**32, 29**. Based on crowded-first strategy, C**32, 29** will be replaced to C**32, 12*.
*Then C**8, 1** can be replaced to C**8, 8**. Lastly, C**32, 7** will be replaced to C**32, 22**. Now, C**4, 1* is
*vacated to accommodate the new 8R-call. *

Although the crowded-first strategy has good performance, the replacement strategy is based on DCA algorithm. Hence, it still needs to establish all kinds of code pattern table and cost comparison table. Next chapter we will introduce our unified code management schemes to resolve this problem.

Figure 7. Code replacement example.

**3.2 Dynamic Assignment of Orthogonal **

**Variable-Spreading-Factor Codes in W-CDMA **

In [15], Min and Siu proposed an algorithm to minimize the number of OVSF codes that must be reassigned to support a new call. Their algorithm is based on the concept of giving a cost function to each candidate branch in the OVSF code tree, and identifying a branch with a minimum cost by using an efficient search. However, their algorithm does not consider the code assignment problem. Before we introduce their efficient search algorithm for a minimum-cost branch, we first describe the steps in the execution of their optimal Dynamic Code Assignment (DCA) algorithm. In fact, the DCA algorithm is a code reassignment scheme.

*(1) Check if the new call with rate kR b/s can be supported, i.e., its requested rate is *
within the system capacity. If so, go to Step2.If not, block the call.

*(2) Find a minimum-cost branch where the root code supports rate kR b/s. This step *
can be achieved by using, for example, an optimal topology search algorithm
described later in this section.

(3) Once a minimum-cost branch is found, the root code of the branch is assigned to the new call. If the branch is empty, the root code is assigned to the call and the

process is complete. Otherwise, it is necessary to reassign the (occupied) descendant codes of the branch as described in Step4.

(4) Reassign to another branch the code with the highest data rate among the descendant codes first. If there is more than one descendant code with the highest data rate, it can be chosen arbitrarily among them.

(5) To reassign a code (with the highest data rate among the descendant codes), go back to Step2 by treating it as a new call requesting its rate.

The above algorithm guarantees that a code is assigned to minimum-cost branch in each iteration and resulting total number of code reassignment is always minimum.

Next we discuss several algorithms [15] that search for a minimum-cost branch.

*Figure 8. Code patterns for 8R branches. *

*Figure 9. Extended code pattern description for 8R branches. *

Figure 10. Branches described in grid pattern.

*(1) Exhaustive Search: In an exhaustive search algorithm, the cost of every *
candidate branch is computed. This would require computing the cost of
reassigning every (occupied) descendant code in this branch. Since reassigning a
code to another branch would involve reassigning codes of that branch and other
*branches, a chain reaction-type reassignments occur. The cost function must be *
computed recursively. However, the complexity of such recursive computations
can increase exponentially with the number of codes reassigned. Next two
search methods are far more efficient.

*(2) Code Pattern Search: In a majority of cases, branches with more descendant *
codes and/or occupied capacity will have a higher cost. This property is
*exploited in the code-pattern search algorithm. First, define the code pattern A/B *
*of a branch, which is defined in terms of A, the total number of occupied *
*descendant codes and B, their occupied capacity. For example, the code patterns *
*of 8R branches in Fig. 8 are denoted as 1/1 and 2/5, respectively. In most cases, *
*a branch with code pattern A/B has a smaller cost than a branch with code *
*pattern C/D if a) A < C, or b) A = C and B < D. Since the code pattern of each *
branch is very easy to compute, an efficient heuristic search algorithm is simply
to pick the branch with the smallest code pattern (based on lexicographical
*order). All possible code patterns for candidate 8R and 4R branches are listed in *
Fig. 11 and Fig. 12. The code pattern description for branches with higher code

rate factors can be obtained similarly, see in Table I and Table II. Determining
*the cost of a branch 2R is trivial; if a root code in another branch is available *
with no further reassignment, the cost is 1. Otherwise, the cost is 2 since a leaf
code must be reassigned.

The above code pattern search does not always yield a minimum-cost branch.

This is mainly because the code pattern does not uniquely characterize the locations and the composition of the codes within a branch. In the following, describe an optimal search algorithm that makes use of the code pattern of a branch as well as the code structure within a branch.

*(3) Topology Search: In order to describe the code structure, it would extend the *
code pattern description of a branch. Using an example to illustrate this. When
two branches (say, 3/6) have the same code pattern but different descendant
codes, an extension such as 3/6(114) or 3/6(222), describing the descendant code
composition, is used. This is illustrated in Fig. 9. An extension to a code pattern
is crucial in the search for a minimum-cost branch because two branches with
the same code pattern but different code composition do not necessarily have the
same cost (see Table II).

A branch can be characterized completely using a grid pattern. A grid pattern is a sequence of numbers and X’s, where the numbers represent the code rate factor of assigned codes in a branch and X’s show the locations of vacant R codes. Examples of grid patterns are shown in Fig. 10. Note the significance of grid patterns. Fig. 10 shows two branches with the same code pattern (and code composition), but the cost of reassigning a 2R code into the 1X1X branch is twice that of the 11XX branch.

The topology search is considered to be an extension to the code pattern search because it still uses the extended code pattern A/B of a branch to first locate a possible minimum-cost branch. Afterwards, a cost comparison table, such as Table I or II is

used to check if further testing of the branch is required. Tables I and II outline a list of comparison tests of cost for all possible and branches. The key idea is that given two branches, one can determine which one has a smaller cost without actually measuring the exact cost of each one. Branches that require further tests are marked by # in the tables. The required tests for each branch are also marked by *. The tables are computed by searching for all possible branches with unique extended code patterns, and comparing the costs of these branches in each case.

Note that the topology search method is very efficient since the tables can be computed off-line. Although this has only described the method for the cases of 4R and 8R codes, it can be easily generalized to include branches of higher code rate factors. Thus, the topology search method is not only optimal, but also computationally efficient for moderately high code rate factors.

*Figure 11. Code pattern for 4R branches. *

*Table I. Cost comparison of 4R branches. *

*Figure 12. Code patterns for 8R branches. *

*Table II. Cost comparison of 8R branches. *

*Table II. (Continued) Cost comparison of 8R branches. *

Although the DCA algorithm eliminates code blocking problem, it does not consider the code assignment problem and must establish all kinds of code pattern table, cost comparison table. However, most papers propose code assignment schemes or code reassignment schemes respectively to deal with code blocking problem.

Hence, we propose a scheme that it can handle code assignment and code reassignment simultaneously. The most important thing is that our schemes not only eliminate code blocking problem completely but also needn’t establish any tables. In addition, our data structures are not complex.

**4. UNIFIED CODES MANAGEMENT ** **SCHEMES **

*In this chapter, we will present our Unified Code Management Scheme and *
separate it into two parts code assignment and code reassignment to describe. We also
*have proved the W that is a Minimum Independent Dominating Set. The part of *
reducing internal fragmentation has simple described in section 4.4. At last, we will
introduce another skill to resolve CIDP.

**4.1 Code Assignment Scheme **

The steps in the execution of our code assignment scheme describes as follows.

Additionally, the part of code reassignment scheme is presented in next section.

*(1) Check if the new call with rate kR b/s can be accepted, i.e., its requested rate is *
within the system capacity. If so, go to Step 2. If not, reject (block) the new call.

(2) In the beginning, if the OVSF code tree is not empty, go to Step 3. Start at the root code (starting point) searching to lower layer (using Depth First Search).

Until the available code is found it will be assigned for new call. The remaining
*codes will be marked as reserving code and as far as possible the reserving code *
with higher data rate dominates the remaining capacity. Once the condition
vector is satisfied, the algorithm is completed. Otherwise, go to Step3.

(3) First, go to the layer with new call requesting rate to find the reserving code and assign it for new call. If reserving code with requesting rate does not find, goes one layer upper until finding it. When reserving code is found at upper layer, treats as starting point. The process is similar to Step 2.

Before our unified code management scheme is executed, it is necessary to check

first whether the system can support the requirement of a new call. If the system does
not have extra capacity to accept it, the new call will be rejected (blocked). Otherwise,
the new call will be accepted and add it into condition vector according to its rate
requirement. Next it adopts the execution above Step 1- Step 3. It is efficient to find
available codes by Depth First Search. Moreover, we propose an idea of reserving
code in order to enhance speed of code assignment. Especially, there is one reserving
*code at the same layer for avoiding fragmentations. The merge mechanism is another *
idea to maintain that one reserving code at the same layer (to be explained later in
next section). Whenever the new call is accepted, system finds the reserving code first
according to its rate requirement (code tree is not empty). If reserving code with its
rate does not find, it will go upper layer to keep on finding. When the higher reserving
code is found, it must be treated as start point to re-start finding the available code
with new call rate requirement. Hence, we don’t need to use complexity algorithms
and waste more time. It also makes the code tree as compacted as possible. In addition,
the combination of assigned codes and reserving codes are the minimum independent
*dominating set W. In other words, the set W not only satisfies the condition but also *
dominates the remaining capacity with minimum codes. If the minimum independent
*dominating set W is found, that is to say, we can get an optimal solution for code *
*assignment in the OVSF-CDMA system. In Section 4.3, we will prove the set W is *
minimum independent dominating set.

In the following, we illustrate the difference between leftmost scheme and
Unified Code Management Schemes with an example. For example, suppose code
*C*_{2,1}* and C**4,3** is busy in Fig. 13. This time, C**2,1* is released and a new call arriving
*requesting a rate 1R. By the leftmost scheme, the C**8,1* will be chosen. By our schemes,
*the C**8,7** will be chosen. From the results, the C**8,1* will make the OVSF code tree to
become fragmented. Therefore, the goal of our schemes is different from leftmost

scheme.

**4.2 Code Reassignment Scheme **

The steps in the execution of our code reassignment scheme describes first. The attribution of our scheme will be discussed in detail later. At last, an example of unified code management schemes is shown in Fig.13.

(1) Once the assigned code is released, marks it as reserving code and go to Step 2.

(2) Check if two reserving code exist at the layer, they will be merged into one code with higher rate and continue recursively at upper layer. The process of checking will be stopped until it just has one (or no) reserving code at each layer.

(3) If the code reassignment is triggered, we will select the reserving code with lower cost to reassign. Comparing their ancestors with sibling relative, and then select the one which has less assigned codes (descendants). If there are ties, it can relocate one of them arbitrarily. But, we trend to relocate the code with higher rate.

In order to maintaining operation of unified code management schemes, the
releasing code is marked as reserving code directly. Next step we must check whether
two reserving codes exist at the layer. Because two reserving codes exist at the same
*layer, it means the code tree becoming fragmented. Hence, we start the merge *
*mechanism to merge two reserving codes into one code with higher data rate. The *
merge mechanism implies key point of code reassignment. Two cases will occur when
the same layer has two reserving codes. One has the same parent, and the other
doesn’t. The former can merge into one (parent) code directly, and the later must
relocate some assigned codes first. To our mind, we adjust the topology of code tree to
avoid becoming too fragmented in advance. If it does not adopt the code reassignment
scheme in advance, it is inevitable that the code tree may become too fragmented to

C_{1,1}

C_{2,1} C_{2,2}

C_{4,1} C_{4,2} C_{4,3} C_{4,4}

C_{8,1} C_{8,2} C_{8,3} C_{8,4} C_{8,5} C_{8,6} C_{8,7} C_{8,8}
Data Rate

8R

4R

2R

R Data Rate

8R

4R

2R

R 8R

4R

2R

R

Figure 13. Unified Code Management Schemes example1.

support new call for long time. Besides, the more fragmentation, the more cost. We not only eliminate the code blocking completely but also reduce the cost of reassignment as far as possible.

Because of code reassignment will bring additional cost for system. In [15] had
defined the cost of reassigning an occupied code and the cost of a branch. Hence, we
*propose the idea of cost mechanism in our schemes for reducing additional cost. *

When code reassignment is incurred, we just need consider two branches of reserving code and relocate one of branches. The cost mechanism is that only compares their (two reserving codes) ancestors with sibling relative and selects the one which has less descendants to relocate. The less codes relocate, the less cost. Additionally, we needn’t establish any extra table to support us and the computational time is very fast.

*In Fig. 13, assuming a new call arriving requesting a rate R, the OVSF code tree *
*is empty and condition vector is R= (0, 0, 0, 1). First, root code C**1, 1* is the starting
point to begin, checking the condition vector is not satisfied, keeps on going one layer
*lower. C**2, 1** and C**2, 2** separate from C**1, 1*, checking the condition vector is not satisfied,
*and C**2, 1** is set as starting point, another C**2, 2** is set as reserving code. Finally, C**8, 1* will

C_{1,1}

C_{2,1} C_{2,2}

C_{4,1} C_{4,2} C_{4,3} C_{4,4}

C_{8,1} C_{8,2} C_{8,3} C_{8,4} C_{8,5} C_{8,6} C_{8,7} C_{8,8}
Data Rate

8R

4R

2R

R Data Rate

8R

4R

2R

R 8R

4R

2R

R

Figure 14. Unified Code Management Schemes example2.

*be assigned to new call, C**2, 2**, C**4, 2**, and C**8, 2* will be marked as reserving code. Hence,
*C**8, 1**, C**2, 2**, C**4, 2**, and C**8, 2** are the minimum independent dominating set W which *
*satisfy the present condition vector. Still assuming a new call of rate R arriving, the *
*condition vector becomes R= (0, 0, 0, 2). According to our schemes, the C**8, 2* will be
*selected for the new call. Then assuming a new call of rate R arriving, the condition *
*vector becomes R= (0, 0, 0, 3). Because there is no reserving code with rate R now, *
*we go one layer upper to find the reserving code C**4, 2* and look on as starting point.

*Therefore, C**8, 3** will be assigned for it and C**8, 4* is also marked as reserving code. At
*presently, the minimum independent dominating set W includes C**8, 1**, C**8, 2**, C**8, 3**, C**8, 4*,
*and C**2, 2** that satisfies the present condition vector R= (0, 0, 0, 3). If the C**8, 3* is
*released, condition vector becomes R= (0, 0, 0, 2), it will be marked as reserving code *
*and check whether two reserving code exist at the layer of rate R. This example, C**8, 3*

*and C**8, 4** are reserving code and then they will be merged into C**4, 2*.

For another example in Fig. 14, the white code is available, the assigned code is
*black and the reserving code is gray. Now the C**4, 2* is releasing and marks as reserving
*code. We detect the C**4, 2** and C**4, 4* do not have the same parent code. Therefore, the

*code reassignment is incurred. We define the weight of a code, as the number of its *
*descendant codes that are assigned. We compare the weight of their (C**4, 2** and C**4, 4*)
ancestors with sibling relative and select one with small weight of them. The weight
*of C**2, 1** and C**2, 2* is 1 and 2 respectively. That is to say, if we want to vacate the branch
*(root code is C**2, 2**), we must transform two codes C**8, 5** and C**8, 6** into C**8, 3** and C**8, 4*

*(Cost is 2). If we vacate the branch (root code is C**2, 1**), we just relocate the C**4, 1** to C**4, 4*

(Cost is 1). Consequently, consider reducing the cost of code reassignment, we will
*decide to transform the C**4, 1** into C**4, 4**. Finally, the C**4, 1** and C**4, 2* are vacant and merge
*into C**2, 1*. By our unified code management schemes, the code blocking problem is
eliminated completely and the cost of code reassignment is also decreased.

Although the merge mechanism is good, it may occur unnecessary reassignment
in some cases. Note that the example is above in Fig. 14. In order to avoid the code
*blocking, so we relocate a busy code C**4,1* to achieve. However, if the new call arriving
*requesting a rate 2R, the previous reassignment is in vain. For this reason, we modify *
our schemes to resolve this problem. That is to say that we just modify the part of
merge mechanism. When the two reserving codes don’t have same parent, we don’t
merge them provisionally. Next if the code blocking is incurred, the code
reassignment is also started up. In this way, our systems can provide more flexibility
to users. If users focus key point on the code blocking, the original schemes must be
used. Otherwise, they can select the modified version to reduce more cost (number of
reassigned codes). At later we also make a simulation to identify our modified
version.

**4.3 Minimum Independent Dominating Set W **

**4.3 Minimum Independent Dominating Set W**

*This section we will prove the W is a minimum independent dominating set by *
*transferring to the coin-change problem. The W set is minimum, that is to say, we will *
gain the optimal code assignment pattern. Because it dominates remaining system
capacity with minimum codes, the OVSF code tree is to make as compact as possible.

*In previous section we mention that the independent dominating set W includes *
assigned codes and reserving codes. As follows:

*W = assigned codes + reserving codes = total system capacity *
Assigned codes: For user’s requirement

Reserving codes: For dominating remaining system capacity

The part of assigned codes is fixed (just satisfies the condition vector), therefore
we just prove that another part of reserving codes is minimum. If the number of
*reserving codes is minimal, the W must be, too. We will transfer this part to *
coin-change problem for proving its optimal solution (minimum independent
dominating set). The coin-change problem is classical example in greedy algorithm.

In [5], it had mentioned the coin-change problem. It is given a finite set of coin types
*A**n* = {α^{1}, α^{2}, …, α^{n}}. Each type is available in unlimited quantity. The coin-change
*problem occurs when it is asked to make up exactly an amount n by combination of a *
minimal total number of coins. The corresponding relation is: data rate of each code
(2^{0}, 2^{1}, 2^{2}, 2^{3}, 2^{4}…, 2^{k}*; k: integer) is equal to the set of coin types and remaining *
*capacity is the amount n. In general, it could use a greedy algorithm to make change: *

first by taking the coin type of highest value as many times as possible, then by taking
the coin type of next highest value as many times as possible, etc. The [21] mentioned
*that (page 402): “Consider the problem of making change for n cents using the fewest *
number of coins. Assume that each coin’s value is an integer. Suppose that the

*available coins are in the denominations that are powers of c, i.e., the denominations *
*are c*^{0}*, c*^{1}*, ..., c*^{k}* for some integers c > 1 and k ≧ 1. Show that the greedy algorithm *
always yields an optimal solution. (to be proved later) ” The OVSF codes can look on
as the available coins in the denominations that are powers of 2. Our scheme adopts
the trick of greedy algorithm, and we always try to reserve as many large OVSF codes
as possible before considering small codes. This will be achieved by merge
mechanism (we proposed in section 4.2), if the code is released. Because it has one
reserving code at most at the same layer base in terms of our scheme, the OVSF code
tree always keeps compactly. Thus it can be seen that we can easily transfer our
problem to the coin-change problem. Therefore, we can use minimum codes to
dominate remaining capacity by greedy algorithm. The optimal solution is obtained
*every time, and we prove the W set being a minimum independent dominating set. *

Next we will propose a simple proof to illustrate that the greedy algorithm
always yields an optimal solution in the coin-change problem. The denominations of
*available coins are c*^{0}*, c*^{1}*, ..., c*^{k}* for some integers c > 1 and k ≧ 1. The lowest *
*denomination will be 1, and the amount is n. *

The proof below depends on the fact that in the coin system picks each coin with
value less than or equal to half the next largest coin. For getting the optimal solution
using greedy algorithm it will always try to pick the highest denomination before
*considering small denomination. Besides, if c*^{k}* is not picked then there should be c *
*number of c*^{k-1}* denomination to replace. Suppose x**z**,…, x**k**, x**k-1**, x**k-2**, …, x**1**, x**0* to be the
*greedy solution for making changes n ≧ c*^{z}* (x**z* is the number of coins using
*denomination c** ^{z}*). Therefore, we can get the greedy solution in Equation 1 as follows.

*x**z***c*^{z}* +… + x**k***c*^{k}* + x**k-1***c*^{k-1}* + x**k-2***c*^{k-2}* +… + x**1***c*^{1}* + x**0***c*^{0}* = n…………Equation 1 *
*If the Equation 1 is an optimal solution, then the coefficients (x**z-1**,..., x**k**, x**k-1*,…,
*x**1**, x**0**) must be smaller than c. Because of we expect the number of coins to be *

*minimal. If their coefficients (x**z-1**,..., x**k**, x**k-1**,…, x**1**, x**0**) is greater than c, it implies that *
*the Equation 1 is not optimal. This is because if x**k* is not picked, it has to be
*compensated for adding c coins of x**k-1** denomination. Hence the coefficients x**z-1**,..., x**k*,
*x**k-1**,…, x**1**, x**0** < c. As follows: we will prove this solution to be optimal by *
Contradiction Method.

**Proof: **

If the greedy solution (Equation 1) is not optimal, that is to say, there is another
*solution, which is optimal. Let it be y**z**,…, y**k**, y**k-1**, y**k-2**, …, y**1**, y**0** (y**z* is the number of
*coins using denomination c** ^{z}*). Likewise, we also get the optimal solution in Equation
2 as follows.

*y*_{z}**c*^{z}* +… +y**k***c*^{k}* + y**k-1***c*^{k-1}* + y**k-2***c*^{k-2}* +… + y**1***c*^{1}* + y**0***c*^{0 }* = n……....….Equation 2 *
*The statement was as above that for optimal solution y**z-1**,..., y**k**, y**k-1**,…, y**1**, y**0** < c. *

*In Equations 1 and Equations 2, we compare their coefficients respectively from x**k** (y**k*)
*to x**0** (y**0**). If we find different coefficients (the first) in x**k** and y**k*, we obtain the
*Inference 1: x**k* ≧ y*k*. Because of the coefficient of optimal solution does not be
greater than it of greedy solution.

*On the other hand, we have assumed that y**z**,…, y**k**, y**k-1**, y**k-2**, …, y**1**, y**0* is the
*optimal solution. Hence the total y**k-1***c*^{k-1}* +y**k-2***c*^{k-2}* + … + y**1***c*^{1}* + y**0***c** ^{0 }*will be always

*smaller than c*

^{k}*. It can be verified such that we replace each coefficient with (c-1) in*equation. Then the equation will become:

*(c-1)*c*^{k-1}*+(c-1)*c*^{k-2}*+…+(c-1)*c*^{1}*+(c-1)*c*^{0 }

*= (c-1) (c*^{k-1}*+c*^{k-2}*+…+c*^{1}*+c** ^{0}*)

= ( 1) ) 1 ( ) 1 ( − − −

*c*
*ck*
*c*

*= c** ^{k}* – 1

*In this way, the total (y**k-1***c*^{k-1}* +y**k-2***c*^{k-2}* + … + y**1***c*^{1}* + y**0***c** ^{0}*) can not compensate

*for the amount of y**k***c*^{k}*. The coefficient y**k* can not be reduced so we obtain the
*Inference 2: x**k* ≦ y*k*.

*According to Inference 1 and 2, we get the result x**k* = y*k*, and so on. In other word,
the Equation 1 is equal to Equation 2. At last, the solution given by the greedy
algorithm is optimal. Q.E.D.

**4.4 Reducing Internal Fragmentation by Multiple ** **Codes **

*In [6], internal fragmentation and external fragmentation in an OVSF code tree *
were proposed. The cause of code blocking is affected by the external fragmentation.

Therefore, the external fragmentation is eliminated by our unified code management
schemes in previous section. When the allocated data rate to the call is larger than its
request, it will result in internal fragmentation. In the section, we mainly use multiple
codes to resolve internal fragmentation. It must be supported by the hardware of
mobile handsets when using multiple codes. Because of it requires multiple
transceiver units to distinguish varied OVSF codes, leading to increase hardware
complexity. Using multiple codes can more closely match new call’s request and then
reduce the internal fragmentation. Therefore, it is a tradeoff between bandwidth
utilization and hardware complexity with multiple codes. Suppose we ignore the
hardware complexity and then propose a simple idea. We can calculate the allowable
number of codes using coin-change problem. Because our CIDP also can deal with
multiple codes at a time, we just regard it as different request to handle. We can
assume that the system has a queue to store multiple codes and then assigns them
*together. Given an example in Fig. 15, system capacity has 5R (C**2,2**, C**8,2*) and then a
*request requires 3R. In general, it will be assigned for 4R (C**2,2**) and results in 1R *

C_{1,1}

C_{2,1} C_{2,2}

C_{4,1} C_{4,2} C_{4,3} C_{4,4}

C_{8,1} C_{8,2} C_{8,3} C_{8,4} C_{8,5} C_{8,6} C_{8,7} C_{8,8}
Data Rate

8R

4R

2R

R Data Rate

8R

4R

2R

R 8R

4R

2R

R

Figure 15. Multiple codes example.

*internal fragmentation. If we change to adopt the trick of multiple codes, the C**4,3 **(2R) *
*and C**8,2** (1R) will be assigned for the new request. Of course the problem of hardware *
complexity maybe will conquer in the future. Hence the internal fragmentation will be
resolved completely.