# Patent

## Title
Method for signaling of resource allocation to adjust granularity in cellular multi-carrier system

## Abstract

A method for adjusting a granularity of resource allocation in a wireless mobile communication system supporting a compact scheduling is discussed. A resource indication value (RIV) corresponds to a start index (S) of one set of consecutive virtual resource blocks (VRBs) and a length of the VRBs. The start index (S) is selected from among ‘s’ values (where s=P+mT<NRB), and the length (L) is selected from among ‘l’ values (where l=K+nG≦NRB). Here, P is a predetermined integer of 0 or higher, T or G is a predetermined natural number, m is an integer of 0 or higher, and n is a natural number.

## Background
CROSS-REFERENCE TO RELATED APPLICATIONS
This application is a continuation of co-pending U.S. application Ser. No. 12/987,911, filed on Jan. 10, 2011, which is a continuation of U.S. application Ser. No. 12/421,877 (now U.S. Pat. No. 7,885,221), filed on Apr. 10, 2009, which claims the benefit of U.S. Provisional Application No. 61/075,010, filed on Jun. 24, 2008, and U.S. Provisional Application No. 61/074,131, filed on Jun. 19, 2008, and Korean Patent Application No. 10-2008-0136669, filed on Dec. 30, 2008, all of which are hereby incorporated by reference as if fully set forth herein.


BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates to a broadband wireless mobile communication system, and more particularly, to radio resource scheduling for uplink/downlink packet data transmission in a cellular orthogonal frequency division multiplexing (OFDM) wireless packet communication system.
2. Discussion of the Related Art
In a cellular orthogonal frequency division multiplex (OFDM) wireless packet communication system, uplink/downlink data packet transmission is made on a subframe basis and one subframe is defined by a certain time interval including a plurality of OFDM symbols.
The 3rd Generation Partnership Project (3GPP) supports a type 1 radio frame structure applicable to frequency division duplex (FDD), and a type 2 radio frame structure applicable to time division duplex (TDD). The structure of a type 1 radio frame is shown in FIG. 1. The type 1 radio frame includes ten subframes, each of which consists of two slots. The structure of a type 2 radio frame is shown in FIG. 2. The type 2 radio frame includes two half-frames, each of which is made up of five subframes, a downlink piloting time slot (DwPTS), a gap period (GP), and an uplink piloting time slot (UpPTS), in which one subframe consists of two slots. That is, one subframe is composed of two slots irrespective of the radio frame type.
A signal transmitted from each slot can be described by a resource grid including NRBDLNSCRB subcarriers and NsymbDL OFDM symbols. Here, NRBDL represents the number of resource blocks (RBs) in a downlink, NSCRB represents the number of subcarriers constituting one RB, and NsymbDL represents the number of OFDM symbols in one downlink slot. The structure of this resource grid is shown in FIG. 3.
RBs are used to describe a mapping relationship between certain physical channels and resource elements. The RBs can be divided into physical resource blocks (PRBs) and virtual resource blocks (VRBs). A mapping relationship between the VRBs and the PRBs can be described on a subframe basis. In more detail, it can be described in units of a slot constituting one subframe. Also, the mapping relationship between the VRBs and the PRBs can be described using a mapping relationship between indexes of the VRBs and indexes of PRBs. A detailed description of this will be further given in embodiments of the present invention.
A PRB is defined by NsymbDL consecutive OFDM symbols in a time domain and NSCRB consecutive subcarriers in a frequency domain. One PRB is therefore composed of NsymbDLNSCRB resource elements. The PRBs are assigned numbers from 0 to NRBDL−1 in the frequency domain.
A VRB can have the same size as that of the PRB. There are two types of VRBs defined, the first one being a localized type and the second one being a distributed type. For each VRB type, a pair of VRBs have a single VRB index (may hereinafter be referred to as a ‘VRB number’) and are allocated over two slots of one subframe. In other words, NRBDL VRBs belonging to a first one of two slots constituting one subframe are each assigned any one index of 0 to NRRBDL−1, and NRRBDL VRBs belonging to a second one of the two slots are likewise each assigned any one index of 0 to NRBDL−1.
The index of a VRB corresponding to a specific virtual frequency band of the first slot has the same value as that of the index of a VRB corresponding to the specific virtual frequency band of the second slot. That is, assuming that a VRB corresponding to an ith virtual frequency band of the first slot is denoted by VRB1(i), a VRB corresponding to a jth virtual frequency band of the second slot is denoted by VRB2(j) and index numbers of the VRB1(i) and VRB2(j) are denoted by index(VRB1(i)) and index(VRB2(j)), respectively, a relationship of index(VRB1(k))=index(VRB2(k)) is established (see FIG. 4A).
Likewise, the index of a PRB corresponding to a specific frequency band of the first slot has the same value as that of the index of a PRB corresponding to the specific frequency band of the second slot. That is, assuming that a PRB corresponding to an ith frequency band of the first slot is denoted by PRB1(i), a PRB corresponding to a jth frequency band of the second slot is denoted by PRB2(j) and index numbers of the PRB1(i) and PRB2(j) are denoted by index(PRB1(i)) and index(PRB2(j)), respectively, a relationship of index(PRB1(k))=index(PRB2(k)) is established (see FIG. 4B).
Some of the aforementioned VRBs are allocated as the localized type and the others are allocated as the distributed type. Hereinafter, the VRBs allocated as the localized type will be referred to as ‘localized virtual resource blocks (LVRBs)’ and the VRBs allocated as the distributed type will be referred to as ‘distributed virtual resource blocks (DVRBs)’.
The localized VRBs (LVRBs) are directly mapped to PRBs and the indexes of the LVRBs correspond to the indexes of the PRBs. Also, LVRBs of an index i correspond to PRBs of the index i. That is, an LVRB1 having the index i corresponds to a PRB1 having the index i, and an LVRB2 having the index i corresponds to a PRB2 having the index i (see FIG. 5). In this case, it is assumed that the VRBs of FIG. 5 are all allocated as LVRBs.
The distributed VRBs (DVRBs) may not be directly mapped to PRBs. That is, the indexes of the DVRBs can be mapped to the PRBs after being subjected to a series of processes.
First, the order of a sequence of consecutive indexes of the DVRBs can be reversed by a block interleaver. Here, the sequence of consecutive indexes means that the index number is sequentially incremented by one beginning with 0. A sequence of indexes outputted from the block interleaver is sequentially mapped to a sequence of consecutive indexes of PRB1s (see FIG. 6). It is assumed that the VRBs of FIG. 6 are all allocated as DVRBs. Thereafter, the sequence of indexes outputted from the block interleaver is cyclically shifted by a predetermined number and the cyclically shifted index sequence is sequentially mapped to a sequence of consecutive indexes of PRB2s (see FIG. 7). It is assumed that the VRBs of FIG. 7 are all allocated as DVRBs. In this manner, PRB indexes and DVRB indexes can be mapped over two slots.
On the other hand, in the above processes, a sequence of consecutive indexes of the DVRBs, not passed through the interleaver, may be sequentially mapped to the sequence of consecutive indexes of the PRB1s. Also, the sequence of consecutive indexes of the DVRBs, not passed through the interleaver, may be cyclically shifted by the predetermined number and the cyclically shifted index sequence may be sequentially mapped to the sequence of consecutive indexes of the PRB2s.
According to the above-mentioned processes of mapping DVRBs to PRBs, a PRB1(i) and a PRB2(i) having the same index i can be mapped to a DVRB1(m) having an index ‘m’ and a DVRB2(n) having an index ‘n’, respectively. For example, referring to FIGS. 6 and 7, a PRB1(1) and a PRB2(1) are mapped to a DVRB1(6) and a DVRB2(9) having different indexes, respectively. A frequency diversity effect can be obtained based on the DVRB mapping scheme.
A variety of methods for allocating such VRBs may be used, for example, a bitmap method and a compact method. According to this bitmap method, resources can be freely allocated all over the system band, and non-consecutive RBs can also be allocated. However, the above-mentioned bitmap method has a disadvantage in that it unavoidably increases the number of bits requested for allocation of RBs as the number of the RBs increases. According to the compact method, only one set of consecutive RBs can be assigned all over the system band. In order to represent the consecutive RBs, a resource indication value (RIV) may be defined. This RIV may represent a combination of a start point (S) of the series of allocated RBs among all RBs and a length (L) of the series of allocated RBs. According to the number of generable combinations of the start point (S) and the length (L), the number of bits representing a certain RIV for indicating a specific combination is decided by the above compact method. Assuming that the number of bits representing this RIV can be reduced, the remaining bits may be used to transmit other information.
SUMMARY OF THE INVENTION
An object of the present invention devised to solve the problem lies on a method for reducing an amount of control information representing a range of allocated resources in a resource allocation scheme based on the compact method.
The object of the present invention can be achieved by providing, in a wireless mobile communication system supporting a compact scheduling scheme, which supports a downlink control information format and allocates one set of consecutive virtual resource blocks (VRBs) to one codeword, a method for detecting a resource indication value (RIV) indicating a start index (S) and length (L) of the one set of consecutive virtual resource blocks (VRBs) allocated by the compact scheduling scheme, the method including: receiving downlink control information including resource block allocation information; and, if the downlink control information format of the received downlink block allocation information is used for the compact scheduling scheme, detecting the resource individual value (RIV) from the resource block allocation information, wherein the start point (S) is any one of elements of a first set {s: s=P+mT<NRB} (where P is a predetermined integer of 0 or higher, T is a predetermined natural number, m is an integer of 0 or higher, and NRB is the number of resource blocks (RBs) available in the wireless mobile communication system), and the length (L) is any one of elements of a second set {l: 1=K+nG≦NRB} (where K is a predetermined integer of 0 or higher, G is a predetermined natural number, and n is a natural number).
NRB may be limited to NVRB. NVRB may be the number of virtual resource blocks (VRBs) available in the wireless mobile communication system.
T may be equal to G.
P may be zero (P=0), and K may be zero (K=0).
NRB may be denoted by NRB=└NVRB/G┘·G, where NVRB is the number of virtual resource blocks (VRBs) available in the wireless mobile communication system.
The l value may be equal to or less than a predetermined value Llimit, where Llimit may be equal to or higher than K and may be lower than the NRB value.
In another aspect of the present invention, there is provided, in a wireless mobile communication system supporting the compact scheduling scheme, a method for detecting a resource indication value (RIV) indicating a start index (S) and length (L) of one set of consecutive virtual resource blocks (VRBs) allocated by the compact scheduling scheme, the method including: receiving downlink control information including resource block allocation information; and, if a downlink control information format of the received downlink control information indicates the use of the compact scheduling scheme, detecting the resource indication value (RIV) from the resource block allocation information, wherein, if Y−1≦└X/2┘ is given, the resource indication value (RIV) is denoted by RIV=X(Y−1)+Z, or else the resource indication value (RIV) is denoted by RIV=X(X−Y+1)+(X−1−Z), where X is denoted by X=└NRB/G┘, Y is denoted by Y=L/G, and Z is denoted by Z=S/G, in which, L is the length of the one set of the consecutive virtual resource blocks (VRBs), S is the start index of the one set of the consecutive virtual resource blocks (VRBs), NVRB is the number of virtual resource blocks (RBs) available in the wireless mobile communication system, each of L and S is a multiple of G, and G is a predetermined natural number.
NRB may be denoted by NRB=└NVRB/G┘·G, where NVRB is the number of virtual resource blocks (VRBs) available in the wireless mobile communication system.
Nbit—required of a bit field used for transmitting the resource indication value (RIV) may be denoted by Nbit—required=┌ log2(RIVmax+1)┐, where RIVmax is denoted by RIVmax=└NRB/G┘·(└NRB/G┘+1)/2−1.
The present invention provides a radio resource scheduling scheme, a structure of scheduling information, and a transmission scheme, such that it can more efficiently implement a resource allocation scheme for common signaling.



BRIEF DESCRIPTION OF THE DRAWINGS
The accompanying drawings, which are included to provide a further understanding of the invention, illustrate embodiments of the invention and together with the description serve to explain the principle of the invention.
In the drawings:
FIG. 1 is a view showing an example of a radio frame structure applicable to FDD.
FIG. 2 is a view showing an example of a radio frame structure applicable to TDD.
FIG. 3 is a view showing an example of a resource grid structure constituting a 3GPP transmission slot.
FIG. 4A is a view showing an example of the structure of VRBs in one subframe.
FIG. 4B is a view showing an example of the structure of PRBs in one subframe.
FIG. 5 is a view illustrating an example of a method for mapping LVRBs to PRBs.
FIG. 6 is a view illustrating an example of a method for mapping DVRBs in a first slot to PRBs.
FIG. 7 is a view illustrating an example of a method for mapping DVRBs in a second slot to PRBs.
FIG. 8 is a view illustrating an example of a method for mapping DVRBs and LVRBs to PRBs.
FIG. 9 is a view illustrating an example of a method for allocating resource blocks by a compact scheme.
FIG. 10 is a view illustrating an example of a method for mapping two DVRBs having consecutive indexes to a plurality of contiguous PRBs.
FIG. 11 is a view illustrating an example of a method for mapping two DVRBs having consecutive indexes to a plurality of spaced PRBs.
FIG. 12 is a view illustrating an example of RIVs when NRB=20.
FIGS. 13 to 19 are views illustrating RIVs of generable combinations of S and L values according to one embodiment of the present invention.



DETAILED DESCRIPTION OF THE INVENTION
Reference will now be made in detail to the preferred embodiments of the present invention with reference to the accompanying drawings. The detailed description, which will be given below with reference to the accompanying drawings, is intended to explain exemplary embodiments of the present invention, rather than to show the only embodiments that can be implemented according to the invention. The following detailed description includes specific details in order to provide a thorough understanding of the present invention. However, it will be apparent to those skilled in the art that the present invention may be practiced without such specific details. For example, the following description will be given centering around specific terms, but the present invention is not limited thereto and any other terms may be used to represent the same meanings Also, wherever possible, the same reference numbers will be used throughout the drawings to refer to the same or like parts.
Hereinafter, terms used in the detailed description of this application are defined as follows.
A ‘resource element (RE)’ represents a smallest frequency-time unit in which data or a modulated symbol of a control channel is mapped. Provided that a signal is transmitted in one OFDM symbol over M subcarriers and N OFDM symbols are transmitted in one subframe, M×N REs are present in one subframe.
A ‘physical resource block (PRB)’ represents a unit frequency-time resource for data transmission. In general, one PRB includes a plurality of consecutive REs in a frequency-time domain, and a plurality of PRBs are defined in one subframe.
A ‘virtual resource block (VRB)’ represents a virtual unit resource for data transmission. In general, the number of REs included in one VRB is equal to that of REs included in one PRB, and, when data is transmitted, one VRB can be mapped to one PRB or some areas of a plurality of PRBs.
A ‘localized virtual resource block (LVRB)’ is one type of the VRB. One LVRB is mapped to one PRB, and PRBs to which different LVRBs are mapped are not duplicated. An LVRB may be interpreted just as a PRB.
A ‘distributed virtual resource block (DVRB)’ is another type of the VRB. One DVRB is mapped to some REs in a plurality of PRBs, and REs to which different DVRBs are mapped are not duplicated.
‘ND’=‘Nd’ represents the number of PRBs to which one DVRB is mapped. FIG. 8 illustrates an example of a method for mapping DVRBs and LVRBs to PRBs. In FIG. 8, ND=3. As can be seen from FIG. 8, an arbitrary DVRB can be divided into three parts and the divided parts can be mapped to different PRBs, respectively. At this time, the remaining part of each PRB, not mapped by the arbitrary DVRB, is mapped to a divided part of another DVRB.
‘NPRB’ represents the number of PRBs in a system. ‘NLVRB’ represents the number of LVRBs available in the system.
‘NLVRB’ represents the number of LVRBs available in the system.
‘NDVRB’ represents the number of DVRBs available in the system.
‘NLVRB—UE’ represents the maximum number of LVRBs allocable to one user equipment (UE).
‘NDVRB—UE’ represents the maximum number of DVRBs allocable to one UE.
‘Nsubset’ represents the number of subsets.
Here, the “number of RBs” means the number of RBs divided on a frequency axis. That is, even in the case where RBs can be divided by slots constituting a subframe, the “number of RBs” means the number of RBs divided on the frequency axis of the same slot.
FIG. 8 shows an example of definitions of LVRBs and DVRBs.
As can be seen from FIG. 8, each RE of one LVRB is one-to-one mapped to each RE of one PRB. For example, one LVRB is mapped to a PRB0 (801). In contrast, one DVRB is divided into three parts and the divided parts are mapped to different PRBs, respectively. For example, a DVRB0 is divided into three parts and the divided parts are mapped to a PRB1, PRB4 and PRB6, respectively. Likewise, a DVRB1 and a DVRB2 are each divided into three parts and the divided parts are mapped to the remaining resources of the PRB1, PRB4 and PRB6. Although each DVRB is divided into three parts in this example, the present invention is not limited thereto. For example, each DVRB may be divided into two parts.
Downlink data transmission from a base station to a specific terminal or uplink data transmission from the specific terminal to the base station is made through one or more VRBs in one subframe. When the base station transmits data to the specific terminal, it has to notify the terminal of which one of the VRBs through which the data will be transmitted. Also, in order to enable the specific terminal to transmit data, the base station has to notify the terminal of which one of the VRBs through which the data can be transmitted.
Data transmission schemes can be broadly classified into a frequency diversity scheduling (FDS) scheme and a frequency selective scheduling (FSS) scheme. The FDS scheme is a scheme that obtains a reception performance gain through frequency diversity, and the FSS scheme is a scheme that obtains a reception performance gain through frequency selective scheduling.
In the FDS scheme, a transmission stage transmits one data packet over subcarriers widely distributed in a system frequency domain so that symbols in the data packet can experience various radio channel fadings. Therefore, an improvement in reception performance is obtained by preventing the entire data packet from being subject to unfavorable fading. In contrast, in the FSS scheme, an improvement in reception performance is obtained by transmitting the data packet over one or more consecutive frequency areas in the system frequency domain which are in a favorable fading state. In a cellular OFDM wireless packet communication system, a plurality of terminals are present in one cell. At this time, because the radio channel conditions of the respective terminals have different characteristics, it is necessary to perform data transmission of the FDS scheme with respect to a certain terminal and data transmission of the FSS scheme with respect to a different terminal even within one subframe. As a result, a detailed FDS transmission scheme and a detailed FSS transmission scheme must be designed such that the two schemes can be efficiently multiplexed within one subframe. On the other hand, in the FSS scheme, a gain can be obtained by selectively using a band favorable to a UE among all available bands. In contrast, in the FDS scheme, a comparison is not made as to whether a specific band is good or bad, and, as long as a frequency interval capable of adequately obtaining a diversity is maintained, there is no need to select and transmit a specific frequency band. Accordingly, it is advantageous to an improvement in entire system performance to perform the frequency selective scheduling of the FSS scheme preferentially when scheduling.
In the FSS scheme, because data is transmitted using subcarriers consecutively contiguous in the frequency domain, it is preferable that the data is transmitted using LVRBs. At this time, provided that NPRB PRBs are present in one subframe and a maximum of NLVRB LVRBs are available within the system, the base station can transmit bitmap information of NLVRB bits to each terminal to notify the terminal of which one of the LVRBs through which downlink data will be transmitted or which one of the LVRBs through which uplink data can be transmitted. That is, each bit of the NLVRB-bit bitmap information, which is transmitted to each terminal as scheduling information, indicates whether data will or can be transmitted through an LVRB corresponding to this bit, among the NLVRB LVRBs. This scheme is disadvantageous in that, when the number NLVRB becomes larger, the number of bits to be transmitted to each terminal becomes larger in proportion thereto.
On the other hand, a physical downlink control channel DCI (PDCCH) transferred to a user equipment (UE) may have a plurality of formats. A resource allocation field transferred over the PDCCH may have different structures according to DCI formats. Thus, the user equipment (UE) may interpret the resource allocation field according to a format of the received DCI.
The resource allocation field may have two parts, i.e., resource block allocation information and a resource allocation header field. A plurality of resource allocation types may be defined. For example, according to a first-type resource allocation, the resource block allocation information may have a bitmap indicating one set of consecutive physical resource blocks (PRBs). In this case, one bit may be allocated to one resource block group (RBG). According to a second-type resource allocation, resource block allocation information may have a bitmap indicating subsets or RBs allocated to the UE. According to a third-type resource allocation, resource block allocation information may have a bitmap indicating consecutively-allocated VRBs. At this time, the resource allocation field may include a resource indication value (RIV) indicating a start resource block and the length of consecutively-allocated resource blocks (RBs). Examples of the above-mentioned resource allocation types have been disclosed in the 3GPP TS 36.213 document.
For example, a DCI format 1A prescribed in the 3GPP TS 36.213 may be used for compact scheduling of one physical downlink shared channel (PDSCH) codeword. This compact scheduling is a scheduling scheme for allocating one set of consecutive VRBs to a user equipment (UE), and corresponds to the above third-type resource allocation. Hereinafter, the above-mentioned compact scheduling in the present invention may be referred to as a compact scheme.
As described above, provided that a terminal (i.e., the UE) may be assigned only one set of contiguous RBs, information of the assigned RBs may be represented by the compact scheme denoted by both a start point of RBs and the number of the RBs.
FIG. 9 is a view illustrating an example of a method for allocating resource blocks by a compact scheme. If the number of available RBs is denoted by NRB=NVRB, the length of available RBs is different depending on respective start points as shown in FIG. 9, such that the number of combinations for RB allocation is NLVRB(NLVRB+1)/2 in the end. Accordingly, the number of bits required for the combinations is ‘ceiling(log 2(NLVRB(NLVRB+1)/2))’. Here, ceiling(x) means rounding “x” up to a nearest integer. This method is advantageous over the bitmap scheme in that the number of bits does not so significantly increase with the increase in the number NLVRB.
On the other hand, for a method for notifying a user equipment (UE) of DVRB allocation, it is necessary to previously promise the positions of respective divided parts of DVRBs distributively transmitted for a diversity gain. Alternatively, additional information may be required to directly notify the positions. Preferably, provided that the number of bits for signaling for the DVRBs is set to be equal to the number of bits in LVRB transmission of the above-stated compact scheme, it is possible to simplify a signaling bit format in a downlink. As a result, there are advantages that the same channel coding can be used, etc.
Here, in the case where one UE is allocated a plurality of DVRBs, this UE is notified of a DVRB index of a start point of the DVRBs, a length (=the number of the allocated DVRBs), and a relative position difference between divided parts of each DVRB (e.g., a gap between the divided parts).
FIG. 10 illustrates an example of a method for mapping two DVRBs having consecutive indexes to a plurality of contiguous PRBs.
As shown in FIG. 10, in the case where a plurality of DVRBs having consecutive indexes are mapped to a plurality of contiguous PRBs, first divided parts 1001 and 1002 and second divided parts 1003 and 1004 are spaced part from each other by a gap 1005, while divided parts belonging to each of the upper divided parts and lower divided parts are contiguous to each other, so that the diversity order becomes 2.
FIG. 11 illustrates an example of a method for mapping two DVRBs having consecutive indexes to a plurality of spaced PRBs.
In the method of FIG. 11, DVRB indexes are constructed as shown in FIG. 1. When allowing DVRBs to correspond to PRBs, consecutive DVRB indexes can be allowed to be distributed, not correspond to contiguous PRBs. For example, a DVRB index ‘0’ and a DVRB index ‘1’ are not arranged contiguous to each other. In other words, in FIG. 11, DVRB indexes are arranged in the order of 0, 8, 16, 4, 12, 20, . . . , and this arrangement can be obtained by inputting the consecutive indexes in FIG. 10 to, for example, a block interleaver. In this case, it is possible to obtain distribution within each of divided parts 1101 and 1102, as well as distribution by a gap 1103. Therefore, when a UE is allocated two DVRBs as shown in FIG. 11, the diversity order increases to 4, resulting in an advantage that the diversity gain can be obtained still more.
At this time, the value of the gap indicative of the relative position difference between the divided parts can be expressed in two ways. Firstly, the gap value can be expressed by a difference between DVRB indexes. Secondly, the gap value can be expressed by a difference between indexes of PRBs to which a DVRB is mapped. In the case of FIG. 11, Gap=1 in the first way, while Gap=3 in the second way. FIG. 12 shows the latter case 1103. Meanwhile, if the total number of RBs of the system is changed, the DVRB index arrangement may be changed accordingly. In this case, the use of the second way has the advantage of grasping a physical distance between the divided parts.
In order to perform signaling of DVRB allocation, the above-mentioned LVRB compact scheme may be used. In this case, a start point of consecutively-allocated RBs and length information of the RBs correspond to a start point of VRB indexes instead of PRB indexes and length information of them, respectively.
As described above, in the compact scheme, LVRB signaling includes a start point of RBs and length information of the RBs. In order to perform the DVRB signaling, gap information may be additionally required in some cases. In order to constantly maintain the number of bits required for the entire signaling, there is a need to limit the length information such that an amount of information must be reduced. For example, in case of using 50 RBs or more, one bit of the RIV field must be assigned for gap indication, such that there is a need to reduce the number of bits required for transferring the RIV with the limitation in the length information.
On the other hand, in case of using RBs to perform the common signaling for several users, a control signaling for notifying allocated RBs must allow all users present in a cell to read information of the allocated RBs. Thus, for this control signaling, a code rate may be reduced or a transmission power may be increased, such that the resultant control signaling information having a low code rate and a high transmission power may be transferred to several users. In order to reduce the code rate of the control signaling to which limited resources are allocated, an amount of control data must be reduced. In order to reduce the amount of control data, the number of bits required for RB allocation information must be reduced.
Likewise, control message data transferred to allocated RBs must allow all users present in the cell to read corresponding information, such that the control message data is transferred at a low code rate. Assuming that the code rate is 1/20, if an amount of data increases by 16 bits, an amount of codeword made after a channel coding increases by 320 bits. In the 3GPP Long Term Evolution (LTE), assuming that one TX antenna transmission (i.e., 1 Tx antenna transmission) is carried out and one OFDM symbol is used for a control signal, the number of symbols capable of transferring payload data within one RB (i.e., 1RB) is 148. Thus, assuming that a quadrature phase shift keying (QPSK) modulation is used, the number of transferable bits is 296. As a result, data increases by 16 bits, data of 320 bits increases, such that two RBs are additionally needed.
That is, in order to maintain a low code rate, although the size of data increases a little, the number of RBs required for transferring this data greatly increases, such that the necessity for RBs to be allocated with a granularity of one RB unit (i.e., a 1RB-based granularity).
Hereinafter, a resource allocation signaling structure for establishing a step for limiting a start position with a granularity of one-RB allocation (i.e., 1RB allocation) will be described in detail.
The following equation 1 shows an exemplary signaling method based on the compact scheme which notifies a start point (S) of RBs and the number (=Length, L) of allocated RBs.
In the following description, “mod(x,y)” means “x mod y”, and “mod” means a modulo operation. Also, “└•┘” means a descending operation, and represents a largest one of integers equal to or smaller than a numeral indicated in “└ ┘”. On the other hand, “┌•┐” means an ascending operation, and represents a smallest one of integers equal to or larger than a numeral indicated in “┌ ┐”. Also, “round(•)” represents an integer nearest to a numeral indicated in “( )”. “min(x,y)” represents a smaller value selected between x and y, whereas “max(x,y)” represents a larger value selected between x and y.

if

L−1≦└NRB/2┘

then

RIV=NRB(L−1)+S 

else

RIV=NRB(NRB−L+1)+(NRB−1−S)

End

Required bits

Nbit—required=┌ log2(RIVmax+1)┐

Without limitation

RIVmax=NRB·(NRB+1)/2−1

With limitation

LLimit 

RIVmax=min{NRB·(NRB+1)/2−1,NRB(Llimit−1)+NRB−Llimit}  [Equation 1]

Assuming that the total number of all available RBs is denoted by NRB and the beginning number of indexes to be assigned to the RBs is set to 0, indexes from 0 to NRB−1 are sequentially assigned to the RBs. In this case, NRB may be the total number of all RBs contained in a system band, the number of all RBs used as VRBs, or the number of RBs contained in any limited area.
Thus, the range of S may be 0≦S≦NRB−1, and the range of allocable ‘L’ value is changed according to this S value. In another view, the L value is in the range of 1≦L≦NRB, and the range of available S value is changed according to the L value. Namely, a certain S value is unable to be combined with a specific L value.
A maximum value of each of the S and L values may be represented by a binary number, regardless of such impossible combinations. A bit field for this binary number may be constructed for each of the S and L values. In case of transmitting each of the bit fields, if NRB is 20 (i.e., NRB=20), 20 is less than 25 (i.e., 20<25), so that 5 bits for the S value and 5 bits for the L values, namely, a total of 10 bits, are needed. However, overhead of unnecessary transmission bits is generated because these 10 bits include even information of useless combinations incapable of being actually generated. Thus, if each generable combination of S and L values is represented by ‘RIV’, this RIV is converted into a binary number according to binary representation, and the resultant RIV of the binary number is then transferred, the number of transmission bits can be reduced.
FIG. 12 is a view illustrating an example of RIVs when NRB=20.
As can be seen from FIG. 12, ‘RIV’ is decided according to S and L values. In case of calculating ‘RIV’ related to 0≦S≦NRB−1 in each of all L values using Equation 1, RIVs of FIG. 12 are made. The value of each element shown in FIG. 12 is ‘RIV’ indicating a combination of S and L values corresponding to the above element. Values contained in a left upper part covering the almost half of FIG. 12 correspond to generable combinations of S and L values when NRB=20, and values contained in a right lower part colored in gray, covering the other half of FIG. 12, correspond to combinations of S and L values incapable of being generated.
In this scheme, RIVs present in the gray-colored part under the condition of L−1≦└NRB/2┘, are mapped to RIVs under the other condition of L−1>└NRB/2┘, such that there are no RIVs to be wasted. For example, if N is set to 20 (i.e., NRB=20), RIVs present in a specific part corresponding to L<└NRB/2┘+1=└20/2┘+1=11 among the right lower part of FIG. 12 are reused in another part corresponding to L>└NRB/2┘+1=└20/2┘+1=11 among the left upper part of FIG. 12. In this case, a maximum value (i.e., a maximum RIV) among RIVs present in the left upper end is 209.
In this scheme, the maximum RIV may influence the number of transmission bits, RIVs below the maximum RIV may not be mapped to values incapable of being obtained by combinations of actual S and L values. That is, all values below the maximum RIV correspond to generable combinations of S and L values.
In case of separately transmitting the S value, a maximum S value is 19, such that 5 bits are needed to indicate this S value ‘19’ (where 0≦19<25). In case of separately transmitting the L value, a maximum L value is 20, such that 5 bits are needed to indicate this L value ‘20’ (where 0≦20<25). Therefore, in case of transmitting the S and L values independent of each other, 10 bits are needed in the end. However, the RIVs are in the range of 0≦RIV≦209<28, such that 8 bits are needed to indicate these RIVs, as denoted by Nbit—required=8. As a result, it can be recognized that 2 bits are saved as compared to the above case of transmitting the S and L values independent of each other.
In the meantime, in the above-mentioned RIV construction method, if a maximum value (=Llimit) of allocable RBs is limited, i.e., if the L value is limited to Llimit or less, the number of required bits may be reduced.
In FIG. 12, if Llimit is set to 6 (i.e., Llimit=6), the range of generable L values is given as 1≦L≦6, combinations having other L values having the range of 7≦L≦20 are not in use. At this time, it can be recognized that a maximum RIV among RIVs is 114. That is, the range of generable RIVs is given as 0≦RIV≦114<27, so that the number of required bits is 7 as denoted by Nbit—required—lim=7.
However, in case of using RBs for the common signalling as described above, there is a need to reduce the number of bits used for resource allocation. Thus, a method for limiting the S and L values according to the present invention will hereinafter be described in detail.
Embodiment 1
A method for limiting each of S and L values to a multiple of G (where G is a positive integer) according to a first embodiment of the present invention will hereinafter be described.
If each of the S and L values is limited to a multiple of G, a maximum RIV among RIVs represented by combinations of S and L values can be lowered. That is, an incremental step of the S value may be set to G, and an incremental granularity of the L value may be established in units of G.
FIG. 13 shows RIVs related to generable combinations of S and L values under the condition that NRB is 20 (NRB=20) and G is 2 (G=2) according to the first embodiment.
A gray-colored area of FIG. 13 corresponds to combinations of S and L values incapable of being generated under the condition that NRB is 20 (NRB=20) and G is 2 (G=2). The RIVs are in the range of 0≦RIV≦54<26, such that 6 bits are needed to indicate these RIVs, as denoted by Ncompact—bit=6.
If a step of the start point and its granularity are all set to G, the number of bits used for expressing RIVs becomes lower than that of the conventional scheme.
In this way, provided that Llimit may be fixed to limit a maximum value among available L values, the number of required bits may be further reduced. As can be seen from FIG. 13, if Llimit is set to 6, it can be recognized that a maximum RIV is 27. At this time, because combinations each having the L value within the range of 8≦L≦20 are not in use, RIVs are in the range of 0≦RIV≦27<25, such that the number of required bits is 5 as denoted by Nbit—required—lim=5.
The following equation 2 is used to obtain RIVs according to S and L values under the condition that NRB and G are given. In this case, the number of bits required for expressing the RIVs may be calculated in different ways according to the setting of Llimit. If a maximum length of RBs is needed, Llimit is denoted by Llimit=G·┌Lmax—required/G┐. If a maximum allowable amount of RBs is given, Llimit is denoted by Llimit=G·┌Lmax—allowed/G┐.
<T=G>
Step: T=G RBs
Granularity: G RBs

if

(L/G−1)≦└└NRB/G┘/2┘

then

RIV=└NRB/G┘·(L/G−1)+S/G 

else

RIV=└NRB/G┘·(└NRB/G┘−L/G+1)+(└NRB/G┘−1−S/G)

end

Required bits

Nbit—required=┌ log2(RIVmax+1)┐

Without limitation

RIVmax=└NRB/G┘·(└NRB/G┘+1)/2−1

With limitation

Llimit=G·┌Lmax—required/G┐ or G·└Lmax—allowed/G┘

RIVmax=min(└NRB/G┘(Llimit/G−1)+└NRB/G┘−Llimit/G, 

└NRB/G┘·(└NRB/G┘+1)/2−1}}  [Equation 2]

As can be seen from Equation 2, parameters of equations constructing the above Equation 1 are substituted into others in Equation 2, such that there is an advantage in that the existing equation can be used without any change. In more detail, Equation 1 showing a method for deciding a start point and a length on a basis of one RB may correspond to the following equation 3 under the condition that X=NRB, Y=L, and Z=S. Equation 2 showing a method for deciding a start point and a length in units of G RBs may correspond to the following equation 3 under the condition that X=└NRB/G┘, Y=L/G, and Z=S/G.

if

Y−1≦└X/2┘

RIV=X(Y−1)+Z 

else

RIV=X(X−Y+1)+(X−1−Z)

End  [Equation 3]

This relationship may also be represented by the following expression 1.
Method of deciding Start Point and Length in units of one RB (1 RB)

X=NRB,Y=1,Z=S 

if

Y−1≦└X/2┘

RIV=X(Y−1)+Z

else

RIV=X(X−Y+1)+(X−1−Z)

End

Method of deciding start point and length in units of G RBs

X=└NRB/G┘,Y=L/G ,Z=S/G 

if

Y−1≦└X/2

RIV=X(Y−1)+Z 

else

RIV=X(X−Y+1)+(X−1−Z)

End  [Expression 1]

On the other hand, assuming that NRB is a multiple of G, each RIV obtained by the above equation which has been made to calculate RIVs using combinations of S and L values in units of one RB (1 RB) is divided by G, such that the resultant RIV obtained by this division becomes any one of RIVs obtained by combinations of S and L values in units of G RBs. Therefore, assuming that N is a multiple of G, the RIV may be represented by the following expression 2.
Method for deciding Start Point and Length in units of G RBs in case that NRB is a multiple of G

if

L−1≦└NRB/2┘

then

RIV′═NRB(L−1)+S 

else

RIV′=NRB(NRB−L+1)+(NRB−1−S)

End

RIV=RIV′/G  [Expression 2]

If the total number of all RBs of the system is set to NPRB, NVRB indicating the number of VRBs used for allocating RB indexes or RB numbers may be equal to or less than NPRB. Because each of allocated RB indexes according to the method of Equation 2 proposed by the present invention is a multiple of G, the number of RBs used for this allocation may also be denoted by a multiple of G. Thus, if NRB for use in the above expression is not a multiple of G, RBs as many as a remainder made when NRB is divided by G may not be used for RB allocation. Therefore, it is preferable that NRB be set to NRB=└NVRB/G┘·G. Under this condition denoted by NRB=└NVRB/G┘·G, it can be recognized that X=└NRB/G┘=└└NVRB/G┘·G/G┘=└└NVRB/G┘┘=└NVRB/G┘ is made.
Assuming that the number of actually available RBs is NVRB, due to granularity restriction, RBs as many as a remainder made when NVRB is divided by G, i.e., NRBremain=NVRB−└NVRB/G┘·G remaining RBs, may not be allocated.
In order to allocate such remaining RBs, NRB may be set to NRB=┌NVRB/G┐·G. However, under this condition NRB=┌NVRB/G┐·G, if the remaining RBs are allocated, the L value may include the number of imaginary RBs, i.e., NRBimaginary=┌NVRB/G┐·G−NVRB. As a result, if the remaining RBs are allocated, the length of actually-allocated RBs becomes L−NRBimaginary.
Embodiment 2
According to this embodiment, an optimization method, under the condition that each of S and L values is limited to a multiple of G (where G is a positive integer) and Llimit is established, will hereinafter be described in detail.
FIG. 14 shows RIVs related to generable combinations of S and L values under the condition that NRB is 40 (NRB=40) and G is 2 (G=2) in the method disclosed in the first embodiment. In this case, it can be recognized that a maximum RIV among RIVs on the condition that Llimit is 14 (i.e., Llimit=14) is 133.
If Llimit is set to 14 (Llimit=14), 8 bits are needed due to 0≦RIV≦133<28. However, RIVs (=39, 58 ̃59, 77 ̃79, 96 ̃99, 115 ̃119) included in the gray-colored part (see FIG. 14) under the condition 4≦L≦12 may not be used as RIVs although the RIVs (=39, 58 ̃59, 77 ̃79, 96 ̃99, 115 ̃119) are less than the maximum RIV 133. That is, the number of bits required for transmitting RIVs may be wasted. In order to remove the wasted RIVs, under the condition that NRB, G and Llimit are limited, there is a need to construct a table for RIVs such that all numbers below the maximum RIV among RIVs corresponding to combinations of S and L values can be actually available. That is, all RIVs in the range from 0 to the maximum RIV must represent combinations of actually-generable S and L values.
FIG. 15 shows RIVs related to generable combinations of S and L values under the condition that NRB is 40 (NRB=40), G is 2 (G=2), and Llimit is 14 (Llimit=14) according to the second embodiment.
Due to 0≦RIV≦118<27, the number of required bits Nbit—required—lim is 7. In this case, it can be recognized that bits for representing generable combinations of S and L values are not wasted because RIVs included in the gray-colored part having L values in the range of 2≦L≦6 are used in generable combinations of S and L values under the condition 10≦L≦14. Thus, compared with the method of FIG. 14, signaling overhead is reduced by one bit when performing signaling of the same RB-allocation combinations as those of FIG. 14.
The following equation 4 is used to obtain RIVs using combinations of S and L values under the condition that NRB, G and Llimit are given in the method of FIG. 15. In this case, the number of required bits may also be calculated by equations included in Equation 4. If a maximum length of RBs is limited, Llimit is denoted by LLimit=G·┌Lmax—required/G┐. If a maximum allowable amount of RBs is given, Llimit is denoted by Llimit=G·└Lmax—allowed/G┘.
<T=G, Optimized for limitation Llimit>
Step: T=G RBs
Granularity: G RBs
Optimized for limitation

Llimit=G·┌Lmax—required/G┐ or G·└Lmax—allowed/G┘

if

L/G≦┌Llinit/G/2┐

then

RIV=(2·└NRB/G┘−Llinit/G+1)(L/G−1)+S/G 

else

RIV=(2·└NRB/G┘−Llinit/G+1)(Llinit/G−L/G+1)−(1+S/G)

end

Required bits

if

Llinit/G/2≦┌Llinit/G/2┐

then

RIVmax=(2·└NRB/G┘−Llinit/G+1)(LRIVmax/G−1)+└(NRB−LRIVmax)/G┘

else

RIVmax=(2·└NRB/G┘−Llinit/G+1)(LRIVmax/G)−1

end

where

LRIVmax=min(G·┌NRB/G/2┐,·Llinit)  [Equation 4]

Assuming that the number of actually available RBs is NVRB, due to the granularity restriction, RBs as many as a remainder made when NVRB is divided by G, i.e., NRBremain=NVRB−└NVRB/G┘·G remaining RBs, may not be allocated. In order to allocate such remaining RBs, NRB may be set to NRB=┌NVRB/G┐·G. However, under this condition NRB=┌NVRB/G┐·G, if the remaining RBs are contained and allocated, the L value may include the number of imaginary RBs, i.e., NRBimaginary=┌NVRB/G┐·G·G−NVRB. As a result, if the remaining RBs are contained and allocated, the length of actually-allocated RBs is denoted by L−NRBimaginary.
Embodiment 3
According to a third embodiment, a method of constructing an optimum table of RIVs, under the condition that S is limited to a multiple of T (where T is a positive integer) and L is limited to a multiple of G (where G is a positive integer), will hereinafter be described in detail.
In the above-mentioned first embodiment, it is assumed that the position of a start point of allocated RBs and the length of the RBs are each limited to a multiple of G (where G is a positive integer). However, in the third embodiment, the start point is limited to one of multiples of a first positive integer, and the length is limited to one of multiples of a second positive integer which is independent from the first positive integer, respectively. That is, S is limited to a multiple of T, and L is limited to a multiple of G.
FIG. 16 shows RIVs related to generable combinations of S and L values under the condition that NRB is 20 (NRB=20), S is a multiple of T(=4), and L is a multiple of G(=2) according to the third embodiment.
FIG. 17 shows RIVs related to generable combinations of S and L values under the condition that N is 20 (NRB=20), S is a multiple of T(=2), and L is a multiple of G(=4) according to the third embodiment.
In FIGS. 16 and 17, the gray-colored parts correspond to combinations of S and L values incapable of being generated under NRB=20.
If T=2 and G=4, RIVs are in the range of 0≦RIV≦26<25, such that 5 bits are needed to represent these RIVs, as denoted by Nbit—required=5. In this case, if Llimit is set to 8 (Llimit=8), RIVs are in the range of 0≦RIV≦15<24, such that 4 bits are needed to represent these RIVs, as denoted by Nbit—required—lim=4.
If T=4 and G=2, RIVs are in the range of 0≦RIV≦29<25, such that 5 bits are needed to represent these RIVs, as denoted by Nbit—required=5. In this case, if Llimit is set to 8 (Llimit=8), RIVs are in the range of 0≦RIV≦18<25, such that 5 bits are needed to represent these RIVs, as denoted by Nbit—required—lim=5.
The following equation 5 is made to calculate RIVs using combinations of S and L values under the condition that NRB, T, and G are given. In this case, the number of required bits may be calculated in different ways according to Llimit. Under this condition, it is assumed that T or G is an integer multiple of min(T, G). If the maximum length of RBs is limited, Llimit is denoted by Llinit=G·┌Lmax—required/G┐. A maximum allowable amount of RBs is given, Llimit is denoted by Llinit=G└Lmax—allowed/G┘.
<T and G are Independent>
Step: T RBs
Granularity: G RBs

if

(L/G−1)≦└NRB/G/2+mod(└NRB/G┘−1,T/G)/2┘

then

RIV=┌(NRB−G+1)/T┐(L/G−1)+S/T 

else

RIV=┌(NRB−G+1)/T┐(└NRB/G┘−L/G+1+mod(└NRB/G┘−1,T/G))+(┌(NRB−G+1)/T┐−1−S/T)

end

Required bits

Nbit—required┌ log2(RIVmax+1)┐

if

(LRIVmax/G−1)≦└NRB/2/G+mod(└NRB/G┘−1,T/G)/2┘

then

RIVmax=┌(NRB−G+1)/T┐(LRIVmax/G−1)+SRIVmax/T 

else

RIVmax=┌(NRB−G+1)/T┐(LRIVmax/G−1)−1

end

where,

SRIVmax=└(NRB−LRIVmax)/T┘T 

Without limitation

LRIVmax=G·[round(NRB/2/G+mod(└NRB/G┘−1,T/G)/2)+1]

With Limitation

Llinit=G·┌Lmax—required/G┐ or G·└Lmax—allowed/G┘

LRIVmax=min(G·[round(NRB/2/G+mod(└NRB/G┘−1,T/G)/2)+1],Llinit)

Assuming that the number of actually available RBs is NVRB, some RBs having large indexes may not be allocated due to the granularity restriction. In order to allocate such remaining RBs, NRB may be set to NRB=┌NVRB/max(T, G)┐·max(T, G). However, under this condition, if the remaining RBs are allocated, the L value may include the number of imaginary RBs, i.e., NRBimaginary=S+L−NVRB. As a result, if the remaining RBs are allocated, the length of actually-allocated RBs is denoted by L−NRBimaginary=NVRB−S.
Embodiment 4
According to a fourth embodiment, an optimization method, under the condition that S starts from P and then increases by a multiple of G, and L starts from K and then increases by a multiple of G, will hereinafter be described in detail.
In the first embodiment, it is assumed that the position of a start point of allocated RBs and the length of the RBs are each limited to a multiple of G (where G is a positive integer). In other words, the first embodiment assumes that the start point S of RBs start from 0 and then increases by G, and the length L of RBs starts from 1 and then increases by G.
The following fourth embodiment relates to a method for constructing RIVs under the condition that the start point S of RBs starts from an offset P and then increases by G, and the length L of RBs starts from another offset K and then increases by G That is, this fourth embodiment relates to a method for constructing RIVs under Sε{P, P+G, P+2G, P+3G, . . . } and Lε{K, K+G, K+2G, K+3G, . . . }.
FIG. 18 shows RIVs related to generable combinations of S and L values when NRB=20, G=2, P=1, and K=4 according to the fourth embodiment. The gray-colored part of FIG. 18 corresponds to combinations of S and L values incapable of being actually generated when NRB=20. RIVs are in the range of 0≦RIV≦35<26, such that 6 bits are needed to represent these RIVs.
If the range of available L values is limited by establishment of Llimit, the number of required bits may be reduced. Referring to FIG. 18, if Llimit is set to 8 (Llimit=8), it can be recognized that a maximum RIV among RIVs is 21. In this case, because combinations having L values in the range of 10≦L≦18 may not be used, the range of RIVs may be 0≦RIV≦21<25, such that 5 bits are needed to represent these RIVs as denoted by ‘Nbit—required—lim=5’.
The following equation 6 is made to calculate RIVs using combinations of S and L values under the condition that NRB, T, and G are given. Under this condition, it is assumed that T or G is an integer multiple of min(T, G). If the length of RBs is limited, Llimit is denoted by Llimit=G·┌(Lmax—required−K)/G┐+K. If a maximum allowable amount of RBs is given, Llimit is denoted by LLimit=G·└(Lmax—allowedK)/G┘+K.




  
    
      
        
          
            
              <
              T
            
            =
            
              G
              ⁢
              
                
              
              ⁢
              starting
              ⁢
              
                
              
              ⁢
              from
              ⁢
              
                
              
              ⁢
              offset
              ⁢
              
                
              
              ⁢
              P
              ⁢
              
                
              
              ⁢
              and
              ⁢
              
                
              
              ⁢
              K
            
          
          ,
          
            
              respectively
              >
              
                
              
              ⁢
              
                Step
                :
                
                  
                
                ⁢
                T
              
            
            =
            
              G
              ⁢
              
                
              
              ⁢
              RBs
              ⁢
              
                
              
              ⁢
              starting
              ⁢
              
                
              
              ⁢
              from
              ⁢
              
                
              
              ⁢
              P
            
          
        
        ⁢
        
          

        
        ⁢
        
          Granularity
          :
          
            
          
          ⁢
          
            G
            ⁢
            
              
            
            ⁢
            RBs
            ⁢
            
              
            
            ⁢
            starting
            ⁢
            
              
            
            ⁢
            from
            ⁢
            
              
            
            ⁢
            K
          
        
        ⁢
        
          

        
        ⁢
        
          
            if
            ⁢
            
              
            
            ⁢
            
              
                (
                
                  L
                  -
                  K
                
                )
              
              /
              G
            
          
          ≤
          
            
              ⌊
              
                
                  ⌊
                  
                    
                      
                        (
                        
                          
                            N
                            RB
                          
                          -
                          P
                          -
                          K
                        
                        )
                      
                      /
                      G
                    
                    +
                    1
                  
                  ⌋
                
                /
                2
              
              ⌋
            
            ⁢
            
              
            
            ⁢
            then
          
        
        ⁢
        
          

        
        ⁢
        
          
        
        ⁢
        
          RIV
          =
          
            
              
                ⌊
                
                  
                    
                      (
                      
                        
                          N
                          RB
                        
                        -
                        P
                        -
                        K
                      
                      )
                    
                    /
                    G
                  
                  +
                  1
                
                ⌋
              
              ·
              
                
                  (
                  
                    L
                    -
                    K
                  
                  )
                
                /
                G
              
            
            +
            
              
                (
                
                  S
                  -
                  P
                
                )
              
              /
              G
            
          
        
        ⁢
        
          

        
        ⁢
        else
        ⁢
        
          

        
        ⁢
        
          
        
        ⁢
        
          RIV
          =
          
            
          
          ⁢
          
            
              
                ⌊
                
                  
                    
                      (
                      
                        
                          N
                          RB
                        
                        -
                        P
                        -
                        K
                      
                      )
                    
                    /
                    G
                  
                  +
                  
                    
                  
                  ⁢
                  1
                
                ⌋
              
              ·
              
                
              
              ⁢
              
                (
                
                  
                    ⌊
                    
                      
                        
                          (
                          
                            
                              N
                              RB
                            
                            -
                            P
                            -
                            K
                          
                          )
                        
                        /
                        G
                      
                      +
                      1
                    
                    ⌋
                  
                  -
                  
                    
                      (
                      
                        L
                        -
                        K
                      
                      )
                    
                    /
                    G
                  
                
                )
              
            
            +
            
              (
              
                
                  ⌊
                  
                    
                      
                        (
                        
                          
                            N
                            RB
                          
                          -
                          P
                          -
                          K
                        
                        )
                      
                      /
                      G
                    
                    +
                    1
                  
                  ⌋
                
                -
                1
                -
                
                  
                    (
                    
                      S
                      -
                      P
                    
                    )
                  
                  /
                  G
                
              
              )
            
          
        
        ⁢
        
          

        
        ⁢
        end
        ⁢
        
          

        
        ⁢
        
          Required
          ⁢
          
            
              
            
            ⁢
            
              
            
          
          ⁢
          bits
        
        ⁢
        
          

        
        ⁢
        
          
            N
            bit_required
          
          =
          
            ⌈
            
              
                log
                2
              
              ⁡
              
                (
                
                  
                    RIV
                    max
                  
                  +
                  1
                
                )
              
            
            ⌉
          
        
        ⁢
        
          

        
        ⁢
        
          Without
          ⁢
          
            
          
          ⁢
          limitation
        
        ⁢
        
          
        
        ⁢
        
          
            RIV
            max
          
          =
          
            
              
                ⌊
                
                  
                    
                      (
                      
                        
                          N
                          RB
                        
                        -
                        P
                        -
                        K
                      
                      )
                    
                    /
                    G
                  
                  +
                  
                    
                  
                  ⁢
                  1
                
                ⌋
              
              ·
              
                
              
              ⁢
              
                
                  (
                  
                    
                      ⌊
                      
                        
                          
                            (
                            
                              
                                N
                                RB
                              
                              -
                              P
                              -
                              K
                            
                            )
                          
                          /
                          G
                        
                        +
                        1
                      
                      ⌋
                    
                    +
                    
                      
                    
                    ⁢
                    1
                  
                  )
                
                /
                
                  
                
                ⁢
                2
              
            
            -
            
              
            
            ⁢
            1
          
        
        ⁢
        
          

        
        ⁢
        
          With
          ⁢
          
            
          
          ⁢
          limitation
        
        ⁢
        
          

        
        ⁢
        
          
            L
            linit
          
          =
          
            
          
          ⁢
          
            
              G
              ·
              
                ⌈
                
                  
                    (
                    
                      
                        L
                        max_required
                      
                      -
                      K
                    
                    )
                  
                  /
                  G
                
                ⌉
              
            
            +
            
              
            
            ⁢
            
              K
              ⁢
              
                
              
              ⁢
              or
              ⁢
              
                
                  
                
                ⁢
                
                  
                
              
              ⁢
              
                
              
              ⁢
              
                
              
              ⁢
              
                
              
              ⁢
              
                
                  
                
                ⁢
                
                  
                
              
              ⁢
              
                 
                
                  

                
                ⁢
                
                  
                
                ⁢
                
                  
                    
                      G
                      ·
                      
                        ⌊
                        
                          
                            (
                            
                              
                                L
                                max_allowed
                              
                              ⁢
                              K
                            
                            )
                          
                          /
                          G
                        
                        ⌋
                      
                    
                    +
                    
                      K
                      ⁢
                      
                        
                      
                      ⁢
                      
                        

                      
                      ⁢
                      
                        RIV
                        max
                      
                    
                  
                  =
                  
                    
                  
                  ⁢
                  
                     
                    
                      
                         
                        
                           
                           
                        
                         
                      
                      ⁢
                      min
                      ⁢
                      
                        
                      
                      ⁢
                      
                        {
                        
                          
                            
                              
                                
                                  
                                    ⌊
                                    
                                      
                                        
                                          (
                                          
                                            
                                              N
                                              RB
                                            
                                            -
                                            P
                                            -
                                            K
                                          
                                          )
                                        
                                        /
                                        G
                                      
                                      +
                                      
                                        
                                      
                                      ⁢
                                      1
                                    
                                    ⌋
                                  
                                  ·
                                  
                                    
                                      (
                                      
                                        
                                          L
                                          linit
                                        
                                        -
                                        K
                                      
                                      )
                                    
                                    /
                                    G
                                  
                                
                                +
                              
                            
                          
                          
                            
                              
                                
                                  ⌊
                                  
                                    
                                      (
                                      
                                        
                                          N
                                          RB
                                        
                                        -
                                        
                                          L
                                          
                                            li
                                            ⁢
                                            
                                              
                                            
                                            ⁢
                                            nit
                                          
                                        
                                        -
                                        P
                                      
                                      )
                                    
                                    /
                                    G
                                  
                                  ⌋
                                
                                ,
                              
                            
                          
                          
                            
                              
                                
                                  ⌊
                                  
                                    
                                      
                                        (
                                        
                                          
                                            N
                                            RB
                                          
                                          -
                                          P
                                          -
                                          K
                                        
                                        )
                                      
                                      /
                                      G
                                    
                                    +
                                    
                                      
                                    
                                    ⁢
                                    1
                                  
                                  ⌋
                                
                                ·
                                
                                  (
                                  
                                    ⌊
                                    
                                      
                                        (
                                        
                                          
                                            N
                                            RB
                                          
                                          -
                                          P
                                          -
                                          K
                                        
                                        )
                                      
                                      /
                                    
                                  
                                
                              
                            
                          
                          
                            
                              
                                
                                  
                                    
                                      
                                        
                                          G
                                          +
                                          
                                            
                                          
                                          ⁢
                                          1
                                        
                                        ⌋
                                      
                                      +
                                      1
                                    
                                    )
                                  
                                  /
                                  2
                                
                                -
                                1
                              
                            
                          
                        
                        ⁢
                        
                          
                        
                        }
                      
                    
                  
                
              
            
          
        
      
    
    
      
        [
        
          Equation
          ⁢
          
            
          
          ⁢
          6
        
        ]
      
    
  




On the other hand, parameters of equations constructing the above Equation 1 are substituted into others in Equation 6, such that Equation 6 has an advantage in that it can use the existing equation without any change. In more detail, Equation 1 showing the method for deciding the start point and the length on a basis of one RB may correspond to Equation 3 under the condition that X=NRB, Y=L, and Z=S. Equation 6 shows the method for controlling the start point of RBs to start from P and then increase in units of G, and controlling the length of RBs to start from K and then increase in units of G. This Equation 6 may correspond to Equation 3 under the condition that X=└(NRB−P−K)/G┘, Y−1=(L−K)/G, and Z=(S−P)/G.
This relationship may also be represented by the following expression.
[Expression]
Method of deciding Start Point and Length in units of one RB

X=NRB,Y=L,Z=S 

if

Y−1≦└X/2┘

RIV=X(Y−1)+Z

else

RIV=X(X−Y+1)+(X−1−Z)

End

Method of controlling Start Point of RBs to start from P and then increase in units of G, and controlling Length of RBs to start from K and then increase in units of G

X=└(NRB−P−K)/G┘,Y−1=(L−K)/G,Z=(S−P)/G 

if

Y−1≦└X/2┘

RIV=X(Y−1)+Z 

else

RIV=X(X−Y+1)+(X−1−Z)

end

Assuming that the number of actually available RBs is NVRB, due to granularity restriction, RBs as many as a remainder made when NVRB is divided by G, i.e., NRBremain=└(NRB−K−P)/G┘·G+K+P−NVRB remaining RBs, may not be allocated.
In order to allocate such remaining RBs, NRB may be set to NRB=┌(NVRB−K−P)/G┐·G+K+P. However, under this condition, if the remaining RBs are allocated, the L value may include the number of imaginary RBs, i.e., NRBimaginary=┌(NVRB−K−P). As a result, if the remaining RBs are allocated, the length of actually-allocated RBs is denoted by L−NRBimaginary.
Embodiment 5
According to a fifth embodiment, an optimization method, under the condition that S starts from P and then increases by a multiple of T, and L starts from K and then increases by a multiple of G, will hereinafter be described in detail.
As can be seen from the fourth embodiment, it is assumed that the position of a start point of allocated RBs and a length of the RBs are each limited to a multiple of G (where G is a positive integer), the position of each start point is limited to start from P, and the length is limited to start from K.
The fifth embodiment relates to a method for constructing RIVs, under the condition that the start point ‘S’ of RBs starts from an offset P and increases by T, and the length ‘L’ of RBs starts from another offset K and increases by G. That is, the fifth embodiment describes a method for constructing RIVs under Sε{P, P+T, P+2T, P+3T, . . . }, Lε{K, K+G, K+2G, K+3G, . . . }.
FIG. 19 shows RIVs related to generable combinations of S and L values when NRB=30, T=4, G=2, P=1, and K=4 according to the fifth embodiment. The gray-colored part of FIG. 19 corresponds to combinations of S and L values incapable of being actually generated when NRB=30. RIVs are in the range of 0≦RIV≦48<26, such that 6 bits are needed to represent these RIVs.
If the range of available L values is limited by establishment of Llimit, the number of required bits may be reduced. Referring to FIG. 19, if Llimit is set to 10 (Llimit=10), it can be recognized that a maximum RIV among RIVs is 25. In this case, because combinations having L values in the range of 12≦L≦28 may not be used, the range of RIVs may be 0≦RIV≦21<25, such that 5 bits are needed to represent these RIVs as denoted by ‘Nbit—required—lim=5’ bits.
The following equation 7 is made to calculate RIVs using combinations of S and L values under the condition that NRB, T, G, P and K are given. In this case, the number of bits required for expressing the RIVs may be calculated in different ways according to Llimit. Referring to Equation 7, Lmax—required may represent the number of actually available RBs. At this time, if there are remaining RBs due to the granularity restriction, the number of the remaining RBs is subtracted from the number of actually available RBs, and the subtraction result value may be represented by Lmax—allowed In this case, in order to enable the actually-available RBs to be all allocated, Llimit is set to Llimit=G·┌(Lmax—required−K)/G┐+K. In order to prevent the remaining RBs among the actually-available RBs from being allocated, Llimit is set to Llimit=G·└(Lmax—allowed−K)/G┘+K.




  
    
      
        
          
            
              <
              
                T
                ⁢
                
                  
                
                ⁢
                and
                ⁢
                
                  
                
                ⁢
                G
                ⁢
                
                  
                
                ⁢
                are
                ⁢
                
                  
                
                ⁢
                Independent
                ⁢
                
                  
                
                ⁢
                starting
                ⁢
                
                  
                    
                  
                  ⁢
                  
                    
                  
                
                ⁢
                from
                ⁢
                
                  
                
                ⁢
                offset
                ⁢
                
                  
                    
                  
                  ⁢
                  
                    
                  
                
                ⁢
                values
                ⁢
                
                  
                
                ⁢
                P
                ⁢
                
                  
                
                ⁢
                and
                ⁢
                
                  
                
                ⁢
                K
              
            
            ,
            
              respectively
              >
              
                

              
              ⁢
              
                Step
                :
                
                  
                
                ⁢
                
                  T
                  ⁢
                  
                    
                  
                  ⁢
                  RBs
                  ⁢
                  
                    
                  
                  ⁢
                  starting
                  ⁢
                  
                    
                  
                  ⁢
                  from
                  ⁢
                  
                    
                  
                  ⁢
                  P
                
              
            
          
          ⁢
          
            

          
          ⁢
          
            Granularity
            :
            
              
            
            ⁢
            
              G
              ⁢
              
                
              
              ⁢
              RBs
              ⁢
              
                
              
              ⁢
              starting
              ⁢
              
                
              
              ⁢
              from
              ⁢
              
                
              
              ⁢
              K
            
          
          ⁢
          
            

          
          ⁢
          
            
              if
              ⁢
              
                
              
              ⁢
              
                
                  (
                  
                    L
                    -
                    K
                  
                  )
                
                /
                G
              
            
            ≤
            
              ⌊
              
                
                  
                    ⌈
                    
                      
                        (
                        
                          
                            N
                            RB
                          
                          -
                          P
                          -
                          K
                          +
                          1
                        
                        )
                      
                      /
                      G
                    
                    ⌉
                  
                  /
                  2
                
                +
                
                  
                    mod
                    ⁡
                    
                      (
                      
                        
                          
                            ⌈
                            
                              
                                (
                                
                                  
                                    N
                                    RB
                                  
                                  -
                                  P
                                  -
                                  K
                                  +
                                  1
                                
                                )
                              
                              /
                              G
                            
                            ⌉
                          
                          -
                          1
                        
                        ,
                        
                          T
                          /
                          G
                        
                      
                      )
                    
                  
                  /
                  2
                
              
              ⌋
            
          
          ⁢
          
            

          
          ⁢
          then
          ⁢
          
            

          
          ⁢
          
            
          
          ⁢
          
            RIV
            =
            
              
                
                  ⌈
                  
                    
                      (
                      
                        
                          N
                          RB
                        
                        -
                        P
                        -
                        K
                        +
                        1
                      
                      )
                    
                    /
                    T
                  
                  ⌉
                
                ·
                
                  
                    (
                    
                      L
                      -
                      K
                    
                    )
                  
                  /
                  G
                
              
              +
              
                
                  (
                  
                    S
                    -
                    P
                  
                  )
                
                /
                T
              
            
          
          ⁢
          
            

          
          ⁢
          else
          ⁢
          
            

          
          ⁢
          
            
          
          ⁢
          RIV
        
        =
        
          
            ⌈
            
              
                (
                
                  
                    N
                    RB
                  
                  -
                  P
                  -
                  K
                  +
                  1
                
                )
              
              /
              
                
              
              ⁢
              T
            
            ⌉
          
          ·
          
             
            
              
            
            ⁢
            
              
                
                  
                    {
                    
                      
                        ⌈
                        
                          
                            (
                            
                              
                                N
                                RB
                              
                              -
                              P
                              -
                              K
                              +
                              1
                            
                            )
                          
                          /
                          G
                        
                        ⌉
                      
                      -
                      
                        
                          (
                          
                            L
                            -
                            K
                          
                          )
                        
                        /
                        G
                      
                      +
                      
                        mod
                        ⁡
                        
                          (
                          
                            
                              
                                ⌈
                                
                                  
                                    (
                                    
                                      
                                        N
                                        RB
                                      
                                      -
                                      P
                                      -
                                      K
                                      +
                                      1
                                    
                                    )
                                  
                                  /
                                  G
                                
                                ⌉
                              
                              -
                              1
                            
                            ,
                            
                              T
                              /
                              G
                            
                          
                          )
                        
                      
                    
                    }
                  
                  +
                  
                    
                      (
                      
                        
                          ⌈
                          
                            
                              (
                              
                                
                                  N
                                  RB
                                
                                -
                                P
                                -
                                K
                                +
                                1
                              
                              )
                            
                            /
                            T
                          
                          ⌉
                        
                        -
                        1
                        -
                        
                          
                            (
                            
                              S
                              -
                              P
                            
                            )
                          
                          /
                          G
                        
                      
                      )
                    
                    ⁢
                    
                      

                    
                    ⁢
                    end
                    ⁢
                    
                      

                    
                    ⁢
                    Required
                    ⁢
                    
                      
                        
                      
                      ⁢
                      
                        
                      
                    
                    ⁢
                    bits
                    ⁢
                    
                      

                    
                    ⁢
                    
                      N
                      bit_required
                    
                  
                
                =
                
                  
                    
                      
                        ⌈
                        
                          
                            log
                            2
                          
                          ⁡
                          
                            (
                            
                              
                                RIV
                                max
                              
                              +
                              1
                            
                            )
                          
                        
                        ⌉
                      
                      ⁢
                      
                        

                      
                      ⁢
                      
                        if
                        ⁢
                        
                          
                        
                        ⁢
                        
                          
                            (
                            
                              
                                L
                                
                                  RIV
                                  max
                                
                              
                              -
                              K
                            
                            )
                          
                          /
                          G
                        
                      
                    
                    ≤
                    
                      

                    
                    ⁢
                    
                      
                    
                    ⁢
                    
                      
                        ⌊
                        
                          
                            
                              ⌈
                              
                                
                                  (
                                  
                                    
                                      N
                                      RB
                                    
                                    -
                                    P
                                    -
                                    K
                                    +
                                    1
                                  
                                  )
                                
                                /
                                G
                              
                              ⌉
                            
                            /
                            2
                          
                          +
                          
                            
                              mod
                              (
                              
                                
                                  
                                    ⌈
                                    
                                      
                                        (
                                        
                                          
                                            N
                                            RB
                                          
                                          -
                                          P
                                          -
                                          K
                                          +
                                          1
                                        
                                        )
                                      
                                      /
                                      G
                                    
                                    ⌉
                                  
                                  -
                                  1
                                
                                ,
                                
                                  T
                                  /
                                  G
                                
                              
                              )
                            
                            /
                            2
                          
                        
                        ⌋
                      
                      ⁢
                      
                        

                      
                      ⁢
                      then
                      ⁢
                      
                        

                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        RIV
                        max
                      
                    
                  
                  =
                  
                    
                      
                        
                          ⌈
                          
                            
                              (
                              
                                
                                  N
                                  RB
                                
                                -
                                P
                                -
                                K
                                +
                                1
                              
                              )
                            
                            /
                            T
                          
                          ⌉
                        
                        ·
                        
                          
                        
                        ⁢
                        
                          
                            (
                            
                              
                                L
                                
                                  RIV
                                  max
                                
                              
                              -
                              K
                            
                            )
                          
                          /
                          G
                        
                      
                      +
                      
                        
                      
                      ⁢
                      
                        
                          ⌊
                          
                            
                              (
                              
                                
                                  N
                                  RB
                                
                                -
                                
                                  L
                                  
                                    RIV
                                    max
                                  
                                
                                -
                                P
                              
                              )
                            
                            /
                            T
                          
                          ⌋
                        
                        ⁢
                        
                          

                        
                        ⁢
                        else
                        ⁢
                        
                          

                        
                        ⁢
                        
                          
                        
                        ⁢
                        
                          RIV
                          max
                        
                      
                    
                    =
                    
                      
                        
                          ⌈
                          
                            
                              (
                              
                                
                                  N
                                  RB
                                
                                -
                                P
                                -
                                K
                                +
                                1
                              
                              )
                            
                            /
                            T
                          
                          ⌉
                        
                        ·
                        
                          
                        
                        ⁢
                        
                          
                            (
                            
                              
                                L
                                
                                  RIV
                                  max
                                
                              
                              -
                              K
                            
                            )
                          
                          /
                          G
                        
                      
                      -
                      
                        1
                        ⁢
                        
                          

                        
                        ⁢
                        Where
                      
                    
                  
                
              
              ,
              
                

              
              ⁢
              
                
                  Without
                  ⁢
                  
                    
                  
                  ⁢
                  limitation
                  ⁢
                  
                    

                  
                  ⁢
                  
                    L
                    
                      RIV
                      max
                    
                  
                
                =
                
                  
                    
                      
                        G
                        ·
                        round
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        (
                        
                          
                            
                              ⌈
                              
                                
                                  (
                                  
                                    
                                      N
                                      RB
                                    
                                    -
                                    P
                                    -
                                    K
                                    +
                                    1
                                  
                                  )
                                
                                /
                                G
                              
                              ⌉
                            
                            /
                            2
                          
                          +
                          
                            
                              mod
                              ⁡
                              
                                (
                                
                                  
                                    
                                      ⌈
                                      
                                        
                                          (
                                          
                                            
                                              N
                                              RB
                                            
                                            -
                                            P
                                            -
                                            K
                                            +
                                            1
                                          
                                          )
                                        
                                        /
                                        G
                                      
                                      ⌉
                                    
                                    -
                                    1
                                  
                                  ,
                                  
                                    
                                  
                                  ⁢
                                  
                                    T
                                    /
                                    G
                                  
                                
                                )
                              
                            
                            /
                            
                              
                            
                            ⁢
                            2
                          
                        
                        )
                      
                    
                    +
                    
                      K
                      ⁢
                      
                        

                      
                      ⁢
                      With
                      ⁢
                      
                        
                      
                      ⁢
                      limitation
                      ⁢
                      
                        
                      
                      ⁢
                      
                        L
                        Limit
                      
                      ⁢
                      
                        

                      
                      ⁢
                      
                        L
                        
                          RIV
                          max
                        
                      
                    
                  
                  =
                  
                    min
                    ⁢
                    
                      
                    
                    ⁢
                    
                      {
                      
                        
                      
                      ⁢
                      
                        
                          
                            
                              
                                
                                  G
                                  ·
                                  round
                                
                                ⁢
                                
                                  
                                
                                ⁢
                                
                                  (
                                  
                                    
                                      
                                        ⌈
                                        
                                          
                                            (
                                            
                                              
                                                N
                                                RB
                                              
                                              -
                                              P
                                              -
                                              K
                                              +
                                              1
                                            
                                            )
                                          
                                          /
                                          G
                                        
                                        ⌉
                                      
                                      /
                                      2
                                    
                                    +
                                  
                                
                              
                            
                          
                          
                            
                              
                                
                                  
                                    mod
                                    ⁢
                                    
                                      
                                        (
                                        
                                          
                                            
                                              ⌈
                                              
                                                
                                                  (
                                                  
                                                    
                                                      N
                                                      RB
                                                    
                                                    -
                                                    P
                                                    -
                                                    K
                                                    +
                                                    1
                                                  
                                                  )
                                                
                                                /
                                                G
                                              
                                              ⌉
                                            
                                            -
                                            1
                                          
                                          ,
                                          
                                            T
                                            /
                                            G
                                          
                                        
                                        )
                                      
                                      /
                                      2
                                    
                                  
                                  )
                                
                                +
                                K
                              
                            
                          
                          
                            
                              
                                L
                                
                                  :
                                  Limit
                                
                              
                            
                          
                        
                        ,
                      
                      ⁢
                      
                        
                      
                      }
                    
                  
                
              
              ,
              
                

              
              ⁢
              
                
              
              ⁢
              
                
                  L
                  limit
                
                =
                
                  
                
                ⁢
                
                  
                    G
                    ·
                    
                      ⌈
                      
                        
                          (
                          
                            
                              L
                              max_required
                            
                            -
                            K
                          
                          )
                        
                        /
                        G
                      
                      ⌉
                    
                  
                  +
                  
                    
                  
                  ⁢
                  
                    K
                    ⁢
                    
                      
                    
                    ⁢
                    or
                  
                
              
              ,
              
                
              
              ⁢
              
                
              
              ⁢
              
                
                  L
                  limit
                
                =
                
                  
                    G
                    ·
                    
                      ⌈
                      
                        
                          (
                          
                            
                              L
                              max_allowed
                            
                            -
                            K
                          
                          )
                        
                        /
                        G
                      
                      ⌉
                    
                  
                  +
                  K
                
              
            
            ⁢
            
              
            
          
        
      
    
    
      
        [
        
          Equation
          ⁢
          
            
          
          ⁢
          7
        
        ]
      
    
  




In this case, because the above RBs are continuously allocated RBs, LLimit, Lmax—required, and Lmax—allowed, may be represented as LCRBsLimit, LCRBsmax—required, and LCRBsmax—allowed, respectively.
Assuming that the number of actually available RBs is set to NVRB, some RBs having large indexes may not be allocated due to the granularity restriction. In order to allocate such remaining RBs, NRB may be set to NRB=┌(NVRB−K−P)/max(T,G)┐·max(T,G)+K+P. However, under this condition, if the remaining RBs are contained and allocated, the L value may include the number of imaginary RBs, i.e., NRBimaginary=S+L−NVRB. As a result, if the remaining RBs are contained and allocated, the length of actually-allocated RBs is denoted by L−NRBimaginary=NVRB−S.
The exemplary embodiments described hereinabove are combinations of elements and features of the present invention. The elements or features may be considered selective unless otherwise mentioned. Each element or feature may be practiced without being combined with other elements or features. Further, the embodiments of the present invention may be constructed by combining parts of the elements and/or features. Operation orders described in the embodiments of the present invention may be rearranged. Some constructions of any one embodiment may be included in another embodiment and may be replaced with corresponding constructions of another embodiment. It is apparent that the present invention may be embodied by a combination of claims which do not have an explicit cited relation in the appended claims or may include new claims by amendment after application.
The embodiments of the present invention may be achieved by various means, for example, hardware, firmware, software, or a combination thereof. In a hardware configuration, the embodiments of the present invention may be implemented by one or more application specific integrated circuits (ASICs), digital signal processors (DSPs), digital signal processing devices (DSPDs), programmable logic devices (PLDs), field programmable gate arrays (FPGAs), processors, controllers, microcontrollers, microprocessors, etc.
In a firmware or software configuration, the embodiments of the present invention may be achieved by a module, a procedure, a function, etc. performing the above-described functions or operations. A software code may be stored in a memory unit and driven by a processor. The memory unit is located at the interior or exterior of the processor and may transmit data to and receive data from the processor via various known means.
The present invention is applicable to a transmitter and a receiver used in a broadband wireless mobile communication system.
It will be apparent to those skilled in the art that various modifications and variations can be made in the present invention without departing from the spirit or scope of the invention. Thus, it is intended that the present invention cover the modifications and variations of this invention provided they come within the scope of the appended claims and their equivalents.

## Claims

1. A method for detecting a resource indication value (RIV) indicating a start index (S) of consecutive virtual resource blocks (VRBs) and a length (L) of the consecutive VRBs in a wireless mobile communication system, the method comprising:
receiving downlink control information including resource block allocation information, wherein the downlink control information is common information for plural users; and
detecting the resource indication value (RIV) from the resource block allocation information,
wherein, if Y−1≦└X/2┘, the resource indication value (RIV) is denoted by RIV=X(Y−1)+Z, or else the resource indication value (RIV) is denoted by RIV=X(X−Y+1)+(X−1−Z),
where X is denoted by X=└NVRB/G┘, Y is denoted by Y=L/G, and Z is denoted by Z=S/G, in which, L is the length of the consecutive virtual resource blocks (VRBs), S is the start index of the consecutive virtual resource blocks (VRBs), NVRB is the number of virtual resource blocks (VRBs), L is a multiple of G, S is a multiple of G, and G is a natural number that is equal to or larger than 2.

2. The method according to claim 1, wherein a length (Nbit—required) of a bit field used for transmitting the resource indication value (RIV) is denoted by Nbit—required=┌ log2(RIVmax+1)┐ and the bit field is transmitted from a base station of the wireless mobile communication system to the mobile station of the wireless mobile communication system, where RIVmax is denoted by RIVmax=└NVRB/G┘·(└NVRB/G┘+1)/2−1.

3. The method according to claim 1, wherein G is 2 or 4 (G=2 or 4).

4. The method according to claim 1, wherein the start index (S) is any one of elements of a first set {s: s=mG<└NVRB/G┘·G} and the length (L) is any one of elements of a second set {l: l=nG≦└NVRB/G┘·G}, where m is an integer of 0 or higher, and n is a natural number.

5. The method according to claim 1, wherein the resource block allocation information indicates a set of distributed VRBs (DVRBs).

6. An apparatus of detecting a resource indication value (RIV) indicating a start index (S) of consecutive virtual resource blocks (VRBs) and a length (L) of the consecutive VRBs in a wireless mobile communication system, the apparatus comprising:
a receiver configured to receive downlink control information including resource block allocation information, wherein the downlink control information is common information for plural users; and
a processor configured to detect the resource indication value (RIV) from the resource block allocation information,
wherein, if Y−1≦└X/2┘, the resource indication value (RIV) is denoted by RIV=X(Y−1)+Z, or else the resource indication value (RIV) is denoted by RIV=X(X−Y+1)+(X−1−Z),
where X is denoted by X=└NVRB/G┘, Y is denoted by Y=L/G, and Z is denoted by Z=S/G, in which, L is the length of the consecutive virtual resource blocks (VRBs), S is the start index of the consecutive virtual resource blocks (VRBs), NVRB is the number of virtual resource blocks (VRBs), L is a multiple of G, S is a multiple of G, and G is a natural number that is equal to or larger than 2.

7. The apparatus according to claim 6, wherein G is 2 or 4 (G=2 or 4).

8. The apparatus according to claim 6, wherein a length (Nbit—required) of a bit field used for transmitting the resource indication value (RIV) is denoted by Nbit—required=┌ log2(RIVmax+1)┐, where RIVmax is denoted by RIVmax=└NVRB/G┘·(└NVRB/G┘+1)/2−1.

9. The apparatus according to claim 6, wherein the start index (S) is any one of elements of a first set {s: s=mG<└NVRB/G┘·G} and the length (L) is any one of elements of a second set {l: l=nG≦└NVRB/G┘·G}, where m is an integer of 0 or higher, and n is a natural number.

10. The apparatus according to claim 6, wherein the resource block allocation information indicates a set of distributed VRBs (DVRBs).