Dynamic Grouping in RFID Systems
Feng Zhu∗† , Bin Xiao† , Jia Liu∗ , Yanyan Wang∗ , Li-jun Chen∗
∗ Department of Computer Science and Technology, Nanjing University, Nanjing, China
† Department of Computing, The Hong Kong Polytechnic University, Hong Kong
Abstract—Radio Frequency Identification (RFID) technology
brings a revolutionary change in warehouse management by
automatically monitoring and tracking products. The grouping
problem is to efficiently inform all tags which groups they belong
to, such that tags in the same group have the same group ID.
With this information, the reader can transmit data through
efficient multicast rather than tedious unicast. However in the
dynamic RFID system, where the group IDs change frequently,
existing works suffer from low time-efficiency. In light of this, this
paper proposes the binary grouping (BIG) protocol to improve
the grouping performance in the dynamic RFID system. BIG
follows three design principles. First, for the to-be-grouped tags,
BIG separates them from the entire tag set before grouping,
so that the not-to-be-grouped tags will not participate in the
following grouping, reducing the running delay. Second, for the
update of group ID, BIG flips only the bits of group ID which
differ from the previous ones, instead of updating all bits of the
group ID, saving the communication overhead. Third, BIG adopts
a Huffman coding based grouping scheme, which classifies tags
into different groups in an efficient way. The extensive simulations
show BIG outperforms the existing promising works.
I. I NTRODUCTION
Radio Frequency Identification (RFID) is developing rapidly
in a range of applications such as inventory control, supply
chain logistics and object tracking [1]–[12]. The grouping
problem is to efficiently inform all tags which groups they
belong to, such that tags in the same group will have the same
group ID. With this information, the reader can transmit data
in multicast way that simultaneously transmits the data to the
tags in a group, by carrying the group ID as the destination
address. This greatly reduces the communication overhead
in comparison with the traditional unicast transmission. For
example, consider an RFID system, in which we want to write
data 𝐷1 to the first 50 tags, and 𝐷2 to the left 50 tags. By
traditional means, the reader sends each tag the corresponding
data individually; 100 data transmissions are needed. On the
contrary, with the tags being grouped, the reader is able
to send 𝐷1 to the first 50 tags by one transmission. Only
two transmissions are needed in total, reducing the overhead
by a factor of 50. Hence, grouping plays a crucial role
in improving the management efficiency of up-layer RFID-
enabled applications.
In recent years, some advanced protocols (e.g., FIG and
CCG [13]) have been proposed to solve the grouping problem
in an efficient way. However, they cannot work well in
dynamic RFID system, where group IDs change frequently.
There are two reasons for this. First, existing works take the
entire tags into consideration at each grouping. In some cases
of dynamic RFID system, however, only a small number of
978-1-5090-6599-8/17/$31.00 ©2017 IEEE
Original Groups Target Groups
7
1 2
5 8 5 9
3 6
4 4
Changed Unchanged
group group
Fig. 1. An example for dynamic grouping problem.
tags need to be grouped. It is a waste to group left tags that
would not be grouped. To further clarify the grouping problem
and understand its practical significance, consider an example
as shown in Fig 1, the tags from Group 4 and 5 still stay in
previous group; no group ID update is needed. Therefore, the
reader only needs to re-group the tags from Group 1, 2 and 3,
instead of all tags. Second, for the tags to be grouped, existing
works change the group ID by overwriting all the bits. In most
cases, however, a tag only needs to flip a few bits of the group
ID. Overwriting all the bits is the waste of the communication
overhead. As shown in Fig 1, the target group ID of some tags
from Group 2 is 7. The group ID of 2, 9 in binary are ’0010’
and ’0111’ respectively. Existing protocols would overwrite
all 4 bits in the tag memory. But actually, only the 1𝑠𝑡 and
3𝑟𝑑 bit need to change from the original group ID to the target
group ID.
In this paper, we propose binary grouping (BIG) protocol to
improve the grouping efficiency in the dynamic RFID system.
In BIG, three novel design ideas are proposed to make a
fundamental improvement on the protocol performance. First,
for the to-be-grouped tags, BIG separates them from the entire
tag set before grouping, so that the not-to-be-grouped tags
will not participate in the following grouping, reducing the
grouping delay. Second, for the update of group ID, BIG flips
only the bits of group ID which differ from the previous
ones, instead of updating all bits of the group ID, saving
the communication overhead. To achieve this goal, the reader
groups the tags from the perspective of each bit of the group
ID. For a bit, BIG tells the tags whether or not they should
flip the bit. Therefore, only log2 𝑘 groupings are needed for
BIG in total, producing a great performance boost compared
with 𝑘 groupings of existing works, where 𝑘 is the number of
groups. Third, BIG tries to use the binary-tree-based grouping
that groups tags into two groups at each time, which can
silence the most of tags in initial phase, and greatly reduce
the number of tags that participated in the following grouping.
Besides, Huffman coding is used to reduce the communication
overhead for labeling tags. The extensive simulations show
BIG outperforms the existing promising works.
The rest of this paper is organized as follows. In Section
II, we describe the system model and the problem definition.
In Section III, we propose the Separation Technique with
Huffman coding (STH) and analyze the efficiency. In Section
IV, we propose the BInary Grouping (BIG) protocol. Section
V evaluates the efficiency of our protocol comparing with other
state-of-the-art protocols. Section VI introduces the related
work. Section V concludes the paper.
II. P RELIMINARY
A. System Model
We consider a large-scale RFID system with a reader, a
massive number of tags and a back-end server. The tags
attached to items are under the surveillance region covered
by the reader. After communicating with the tags, the reader
transmits tag information to a back-end server, which provides
powerful computation ability to process such data. The back-
end server connects the reader via wired or wireless links, and
sends orders to schedule working. The server also stores all
IDs of the known tags. As the new tagged objects move in,
the unknown tags will also exist in the system.
Similar to prior work [14], [15], the communication mode
between tags and the reader is slotted frame as defined in
C1G2 standard [16]. The tag talks only if receiving the reader’s
commands. A reader initializes each round of our protocol by
sending a request. On receiving the order, tags then backscatter
signals. The reader initiates the communication with a high
power continuous RF waveform (CW) which energizes RFID
tags. The tags transmit their signals by reflecting back the CW
using on-off keying modulation: a binary ’1’ or ’0’ represents
the presence or absence of CW [17]–[19].
The protocols proposed in this paper can also be applied to
RFID systems containing multiple readers. In such cases, the
reader collision will occur when two or more readers attempt
to communicate with a tag concurrently, since the mixed
signals cannot be correctly decoded at the tag side. Many
existing reader-collision against schemes [20], [21] have been
proposed to achieve dynamical reader schedule. We can resort
to these works to avoid the communication collision among
multiple readers. When multiple readers are synchronized,
we can logically treat them as a whole. To simplify the
description, our protocol is presented for a single reader,
but they can be easily modified for multiple readers when
the collision-free transmission schedule among the readers is
established.
t1 t2 t3 t4 t5 t6 t7 t8 t9 t10
Tags from A
Type-1 Type-3 Type-2 Type-3 Type-3 Type-2
Tags from B
Fig. 2. An example for different kinds of slots in an array.
B. Problem Definition
Consider a large RFID system with a massive number of
tags, denoted as the set 𝑇 = {𝑡1 , 𝑡2 , 𝑡3 , ..., 𝑡𝑛 }. The cardinality
of set 𝑇 is 𝑛. The original partition of the set 𝑇 is a family of
disjoint sets 𝑃 = {𝑃1 , 𝑃2 , ..., 𝑃𝑘 }. But the original partition
set 𝑃 can be dynamically change to a new partition 𝑄 =
{𝑄1 , 𝑄2 , .., 𝑄𝑠 }. We refer to 𝑃𝑖 or 𝑄𝑗 as a group, and each
tag only belongs to one group. We denote the original partition
𝑃𝑖 (𝑖 ∈ [1, 𝑘]) as the original group and the new partition 𝑄𝑗
(𝑗 ∈ [1, 𝑠]) as the target group. As shown in Fig. 1, The set
of original groups is 𝑃 = {1, 2, 3, 4, 5} and the set of target
groups is 𝑄 = {5, 6, 7, 8, 9}.
The objective of dynamic grouping in this paper is to fast
re-label the tags from the original partition 𝑃 to the target
partition 𝑄. If the tag is newly added in the system, we can
treat the original group ID as 0. The reader can still adopt our
protocols to assign the target group ID to the new tag. To meet
the requirements, the protocol should reduce the transmitted
bits and efficiently re-group all tags.
III. STH: S EPARATION T ECHNIQUE WITH H UFFMAN
C ODING
Before proposing our main grouping protocol (BIG), we first
introduce a Separation Technique with Huffman coding (STH).
BIG tries to use the binary-tree-based grouping that group tags
into two groups at each time, which can silence the most of
tags in initial phase, and greatly reduce the number of tags
that participated in the following grouping. In this section, we
propose Separation Technique with Huffman coding (STH),
which can efficiently separate two disjoint sets.
A. Separation Technique
Consider two exclusive sets of tags, denoted as 𝐴 =
{𝑎1 , 𝑎2 , ..., 𝑎𝑥 } and 𝐵 = {𝑏1 , 𝑏2 , ..., 𝑏𝑦 }. Thus, 𝐴 ∩ 𝐵 = ∅.
When the set A and B are mixed together, how to separate
the set A from the set B completely and efficiently is im-
portant in some RFID applications. For the simplifications,
we denoted the mixed set of A and B as 𝑀 = 𝐴 + 𝐵 =
{𝑎1 , 𝑎2 , ..., 𝑎𝑥 , 𝑏1 , 𝑏2 , ..., 𝑏𝑦 }.
Consider a slot array of length 𝑙, to encode the tags from
𝑀 , we use a hash function 𝐻(⋅) to map the tags randomly to
a slot in the array. Therefore, there are four types of slots as
shown in Fig. 2. The first type of slot is which only the tags
 TABLE I
F OUR D IFFERENT E NCODED V ECTORS
Code for Slot Type
Encoded Vector Length
Type-1 Slot Type-2 Slot Type-3 Slot
01 10 11 001110111110 12
0 11 10 01011101011 11
10 0 11 1011011110 10
11 10 0 110100010 9
from the set 𝐴 select, such as the first slot. The second type of
slot is which only the tags from the set 𝐵 select, such as the
third and sixth slots. The third type of slot is which the tags
from both the set 𝐴 and the set 𝐵 select, such as the forth
and fifth slots. The forth type of slot is which no tag selects,
such as the second slot.
If we let the reader broadcast a vector to notify each tag
which types of slot it selects, we should use two bits (log2 4 =
2) to encode the four kinds of slot. Here, we denote the first
type of slot as Type-1 slot, the second type of slot as Type-2
slot, the third type of slot as mixed slot and the forth type of
slot as empty slot. But note the mixed slot and the empty slot
are useless to separate the set A tags from the set B tags. Thus
we combine the mixed slot and the empty slot as Type-3 slot.
After the reader broadcasts the encoded vector, the tags from
the set M can know whether they belong to set A or set B. As
illustrated in Fig. 2, after receiving the vector from the reader,
𝑡1 and 𝑡3 will know they are from set A, 𝑡4 , 𝑡5 , 𝑡6 and 𝑡9 will
know they are from set B. But note the tags (i.e., 𝑡2 , 𝑡7 , 𝑡8
and 𝑡10 ) from Type-3 slots are still unconscious about which
set they belong to. Therefore, they cannot decide whether they
are from set A or from set B.
Then the reader will reconstruct another vector based on
the un-separated tags and head to the next round. Only these
un-separated tags participate in the next round, and repeat the
operation as described above. Until all the tags know which set
they belong to, the reader stops and tags from A are completely
separated from tags from B.
B. Vector Encoding
To encode the three types of slot, we can still use two
bits, such as the first encoded vector shown in Table I. We
take ’01’⇒Type-1, ’10’⇒Type-2 and ’11’⇒Type-3. There-
fore, the reader can broadcast vector ’011110111110’ to make
separation for set 𝑀 . The length of the vector will be 12-
bit long. But it will cost redundancy space to transmit the
vector. As we know, variable-length codes can allow sources
to be compressed and decompressed with zero error. We then
list three possible variable-length coding strategies to encode
the three types of slots. As shown in Table I, the most
efficient encoding strategy is the last one, when ’11’⇒Type-
1, ’10’⇒Type-2 and ’0’⇒Type-3. The length of this vector
is 9-bit long, which decreases 25% bits needed to encode a
vector.
0.5 0.33 0.17 0.5 0.5 1.0
Type-3 Type-2 Type-1 Type-3
0 1 0 1
Type-2 Type-1 Type-3
0 1
Type-2 Type-1
Fig. 3. The basic principle of constructing a Huffman tree.
Here, we adopt Huffman coding to efficiently encode a
vector to make separation for set M. Huffman coding is a
compression technique used to reduce the number of bits
needed to send or store a message [22]. The output from
Huffman coding can be viewed as a variable-length code
table for encoding each type of slot. Thus we can use the
coding algorithm to derive the code table from the estimated
frequency for each type of slot.
Given the inputs, which are the set of slot type 𝑆 = {Type-1,
Type-2, Type-3}, and the set of the weights of each type 𝑊 =
{𝑤1 , 𝑤2 , 𝑤3 }. The weights of each slot type are calculated as
the frequency for each type. Therefore, we can have
𝑤1 + 𝑤2 + 𝑤3 = 1. (1)
The target is to find a binary prefix code 𝐶(𝑆, 𝑊 ) =
(𝑐1 , 𝑐2 , 𝑐3 ), where 𝑐𝑖 is the codeword for each type of slot,
that minimizes the number of bits as follows:
3
∑
𝐿(𝐶) = 𝑤𝑖 × 𝐿(𝑐𝑖 ), (2)
𝑖=1
where 𝐿(𝑐𝑖 ) represents the length of 𝑐𝑖 .
Here we take an example for encoding the vector in Fig.2.
We can easily calculate the weight for each type of slot as
𝑤1 = 1/6, 𝑤2 = 1/3 and 𝑤3 = 1/2. Sort these slots by
frequency and make the two-lowest elements into leaves, then
we can create a parent node with a frequency that is the sum of
the two lower element’s frequencies. As shown in Fig.3, we
combine the Type-2 and Type-1 slots to a new parent node
with a frequency 𝑤2 + 𝑤1 = 1/2. The Type-2 and Type-1
slots are removed and the new node with frequency 1/2 is
added to be sorted with Type-3 slot. To generate a Huffman
code, we can traverse the tree to the type of slot, selecting a
0 every time we take a lefthand branch, and a 1 every time
we take a righthand branch. Then we can obtain an encoding
strategy, that is ’11’⇒Type-1, ’10’⇒Type-2 and ’0’⇒Type-3
as the same with Table I.
C. Parameter Setting
We define the efficiency of separation (𝜃), as the ratio of
the total expected number of tags from Type-1 and Type-2 slot
(𝜈) to the total expected vector length (𝜑):
𝜈 𝜈1 + 𝜈2
𝜃= = , (3)
𝜑 𝜏1 𝐿(𝑐1 ) + 𝜏2 𝐿(𝑐2 ) + 𝜏3 𝐿(𝑐3 )
Where 𝜈1 represents the number of tags select the Type-1 slot,
𝜈2 represents the number of tags select the Type-2 slot, 𝜏1
 TABLE II
T HE VALUE OF 𝛼, 𝛽 AND 𝛾, WHEN GIVEN L(𝑐1 ), L(𝑐2 ) AND L(𝑐3 ) 1.6

1.4
θ1
θ2
L(𝑐1 ) L(𝑐2 ) L(𝑐3 ) 𝛼 𝛽 𝛾 1.2
θ3
𝜃1 2 2 1 1 1 1 1

𝜃2 0.8

θ
2 1 2 0 -1 2
𝜃3 1 2 2 -1 0 2 0.6

0.4

0.2
represents the total number of Type-1 slots, 𝜏2 represents the
total number of Type-2 slots and 𝜏3 represents the total number 0
0 1000 2000 3000 4000 5000
of Type-3 slots. l
Obviously, the larger the value of 𝜃 is, the more the tags
will be separated each unit of vector size. As presented below, Fig. 4. Efficiency of separation 𝜃 with respect to different parameters.
both 𝜈 and 𝜑 are related to 𝑙. Note 𝑙 represents the length of
an array, not the length of a vector (𝜑). Thus, we should find
the optimal 𝑙 that maximizes 𝜃. According to the definition of Type-1 slot, no tag from 𝐵
We first consider the total expected number of Type-1 slots. selects the same slot, that is (1 − 1𝑙 )𝑦 . The probability that the
Given fixed 𝑖 tags, the probability that a slot is mapped by slot is Type-1 is (1 − (1 − 1𝑙 )𝑥 )(1 − 1𝑙 )𝑦 . As we know, there
these tags in 𝐴 is are 𝑙 slots, the expected number of Type-1 slots is:
( )𝑖 ( )𝑥−𝑖 ( )𝑦 ( ( )𝑥 ) ( )𝑦
1 1 ( 𝑥) 𝑦
1 1 1 𝜏1 = 𝑙 1 − 1 − 1− ≈ 𝑙 1 − 𝑒− 𝑙 𝑒− 𝑙 .
1− 1− , (4) 𝑙 𝑙
𝑙 𝑙 𝑙 (11)
where ( 1𝑙 )𝑖 (1 − 1𝑙 )𝑥−𝑖 means the probability that 𝑖 tags from As the same, we can also have the expected number of Type-2
A select this slot, and (1 − 1𝑙 )𝑦 means the probability that 𝑦 slots is:
𝑦 𝑥
tags from B do ( )not select this slot. 𝜏2 = 𝑙(1 − 𝑒− 𝑙 )𝑒− 𝑙 . (12)
There are 𝑥𝑖 kinds of possible combinations for 𝑖 tags,
therefore the probability that a slot is mapped by 𝑖 tags is Therefore, we obtain the expected number of Type-3 slots is:
( ) ( )𝑖 ( )𝑥−𝑖 ( )𝑦 𝑥 𝑦
𝜏3 = 𝑙(1 − (1 − 𝑒− 𝑙 )𝑒− 𝑙 − (1 − 𝑒− 𝑙 )𝑒− 𝑙 ).
𝑦 𝑥
(13)
𝑥 1 1 1
1− 1− . (5)
𝑖 𝑙 𝑙 𝑙 Substituting 𝜈 and 𝜑, we have the efficiency of separation:
When 𝑖 ranges from 0 to 𝑥, the expected number of tags in 𝑦 𝑥
(𝑥𝑒− 𝑙 + 𝑦𝑒− 𝑙 )𝑙−1
𝐴 select this slot is 𝜃= 𝑥 𝑦 𝑦 𝑥 , (14)
𝑥 ( ) ( )𝑖 ( )𝑥−𝑖 ( )𝑦 ( )𝑦 𝛼(1 − 𝑒− 𝑙 )𝑒− 𝑙 + 𝛽(1 − 𝑒− 𝑙 )𝑒− 𝑙 + 𝛾
∑ 𝑥 1 1 1 𝑥 1
𝑖 1− 1− = 1− . where 𝛼 = 𝐿(𝑐1 ) − 𝐿(𝑐3 ), 𝛽 = 𝐿(𝑐2 ) − 𝐿(𝑐3 ) and 𝛾 = 𝐿(𝑐3 ).
𝑖 𝑙 𝑙 𝑙 𝑙 𝑙
𝑖=0 With fixed 𝛼, 𝛽 and 𝛾, to compute the maximum value of 𝜃,
(6)
we let the first derivative of 𝜃 be zero ∂𝜃 ∂𝑙 = 0. Solving the
Due to the length of the array is 𝑙, we can easily obtain the
equation numerically, we can find the optimal 𝑙 maximizes 𝜃.
expected number of tags from Type-1 slot as
( )𝑦 Because the length of the vector is not foreknown,
𝑥 1 𝑦 we cannot calculate the weights for each slot types. But
𝜈1 = 𝑙 × 1− ≈ 𝑥𝑒− 𝑙 . (7)
𝑙 𝑙 {𝐿(𝑐1 ), (𝑐2 ), 𝐿(𝑐3 )} has three possible values, which are
As the same method of calculation, we can also know the {2, 2, 1}, {2, 1, 2} or {1, 2, 2}. As shown in Table II, the
expected number of tags from Type-2 slot is parameters 𝛼, 𝛽 and 𝛾 have only three possible values with
𝑥
respect to the values of 𝐿(𝑐1 ), 𝐿(𝑐2 ) and 𝐿(𝑐3 ). We define the
𝜈2 = 𝑦𝑒− 𝑙 . (8) three outcomes as 𝜃1 , 𝜃2 and 𝜃3 respectively. Therefore, we
Therefore, we obtain the expected number of tags from can compute the optimal length 𝑙 for each 𝜃. On comparing the
Type-1 and Type-2 slot: maximum value among 𝜃1 , 𝜃2 and 𝜃3 , we can decide which
𝑦 𝑥
encoding strategy is supposed to select and the optimal length
𝜈 = 𝑥𝑒− 𝑙 + 𝑦𝑒− 𝑙 . (9) 𝑙 for the specified encoding strategy.
Here we take an example to illustrate the process, as shown
We then calculate 𝜏1 . Consider the tags from set A. The
in Fig. 4. Consider ∣𝐴∣ = 2, 500 and ∣𝐵∣ = 500, we can
probability that 𝑥 tags from set A do not select a slot is (1 −
1 𝑥 calculate three 𝜃s with respect to different 𝛼, 𝛽 and 𝛾. The
𝑙 ) . Therefore, the probability that at least one tag in 𝐴 selects maximum values for 𝜃1 , 𝜃2 and 𝜃3 are 1.39, 0.93, 1.17.
this slot is ( )𝑥
1 Therefore, we can select the length 𝑙 = 390 to obtain the
1− 1− . (10) maximum value of 𝜃1 .
𝑙
 TABLE III in Table III. In the table, ’𝐺𝐼𝐷10 ’ is short for decimal group
S IMPLE CASE OF GROUPING PROCESS ID, ’𝐺𝐼𝐷2 ’ is short for binary group ID and ’Diff’ is short
for difference. The set of total tags in the system is 𝑇 =
Orignial Original Target Target
Bit index {𝑡1 , 𝑡2 , 𝑡3 , ..., 𝑡11 , 𝑡12 }. Each tag has already been assigned a
𝑇 𝐼𝐷 Diff needed group ID, which is called as the original group ID. Then the
𝐺𝐼𝐷10 𝐺𝐼𝐷2 𝐺𝐼𝐷10 𝐺𝐼𝐷2
to change reader wants to assign a new group ID for each tag. The target
of our protocols is to fast assign the target group ID to each
𝑡1 6 0110 2 0010 0100 3
tag. If the tag is newly added in the system, we can treat the
𝑡2 13 1101 15 1111 0010 2 original group ID as 0. The reader can still adopt our protocols
𝑡3 5 0101 2 0010 0111 1,2,3 to assign the target group ID to the new tag.
𝑡4 15 1111 12 1100 0011 1,2 We denote the identifier of an arbitrary group 𝑃𝑖 as (𝑃𝑖 )𝑋 ,
𝑡5 3 0011 9 1001 1010 2,4 where the subscript 𝑋 is 10 or 2. If 𝑋 = 10, the identifier of a
𝑡6 9 1001 4 0100 1101 1,3,4 group will be presented in decimal mode. Otherwise, if 𝑋 = 2,
𝑡7 6 0110 1 0001 0111 1,2,3 the identifier of a group will be presented in binary mode. For
example, if the decimal ID of group 𝑃𝑖 is 192, the binary ID
𝑡8 4 0100 14 1110 1010 2,4
of group 𝑃𝑖 is 11000000, which is (192)10 = (11000000)2 .
𝑡9 7 0111 8 1000 1111 1,2,3,4
For an arbitrary tag 𝑡𝑎 , it belongs to an original group 𝑃𝑖 . If
𝑡10 13 1101 14 1110 0011 1,2 the system wants to change its group to 𝑄𝑗 , we can easily
𝑡11 7 0111 4 0100 0011 1,2 calculate which bits are needed to change. For example, the
𝑡12 14 1110 9 1001 0111 1,2,3 original group ID of 𝑃𝑖 is (11000000)2 , and the new group
ID of 𝑄𝑗 is (10010100)2 . The differences between 𝑃𝑖 and 𝑄𝑗
can be calculated as follows:
Since we calculate the optimal length 𝑙 based on probability, (11000000)2 (decimal 192)
when fixing 𝑙 and varying the random number for each hash
XOR (10010100)2 (decimal 148) (15)
function, the actual weights 𝑤1 , 𝑤2 and 𝑤3 will fluctuate
around its expected value. Therefore, the case that the calcu- =(01010100)2 ,
lated encoding strategy based on the actual weights is different where XOR is bitwise operation which takes two bit patterns of
from the selected encoding strategy based on optimal length 𝑙 equal length and performs the logical exclusive OR operation
exists. In this case, we select the encoding strategy based on on each pair of corresponding bits. The result in each position
the actual weights. is 1 if only the first bit is 1 or only the second bit is 1, but
will be 0 if both are 0 or both are 1. In this we perform the
IV. BIG: B INARY G ROUPING P ROTOCOL
comparison of two bits, being 1 if the two bits are different,
In this section, we first use a simple case to present a and 0 if they are the same. Therefore, only the 3rd, 5th and
high level overview of the proposed BInary Grouping (BIG) 7th bits are needed to change from the original group 𝑃𝑖 to
protocol, and then we explain its operations in detail. the new group 𝑄𝑗 .
For example in Table III, the original group ID of 𝑡8 is 4.
A. Basic Idea
If the reader wants to assign the target group ID 14 to 𝑡8 , the
Binary grouping protocol (BIG) follows three guidelines to tag 𝑡8 only needs to change the 2𝑛𝑑 and 4𝑡ℎ bits.
achieve high time efficiency. First, BIG only re-groups the
tags when these tags need to change their group ID. BIG B. Phase 1: Initialization
filters any tag which does not need to change their group Before broadcasting the request to all tags, the reader
ID in its bit-based execution, so that no tedious group ID initializes BIG with the parameters which are needed in the
transmission is needed, improving the grouping efficiency. following phases. The reader first precalculates what grouping
Second, BIG only reverses the bit of tag group ID, which operations each tag needs to execute, and then determines the
needs to be changed, instead of changing all bits of a tag order of the grouping operations.
group ID. Each tag has already been assigned with a group 1) Calculating required grouping operations: In our sys-
ID. If the reader needs to assign a new group ID for the tags, tem, the reader adopts two kinds of operations to assign the
BIG can only reverse few bits instead of all bits to change the target group ID to each tag. The first kind of operations is
original group ID to the target group ID. Third, we adopt the ROBn (reversal of one bit), which means the tag will reverse
Separation Technique with Huffman coding (STH), which can the n-th bit of the group ID. For example, the group ID of 𝑡6
efficiently separate one set of tags from the other set of tags. is (1001)2 . If the tag executes ROB2 operation on its group
The above mechanisms greatly reduce transmission overhead ID (1001)2 , which is
during the grouping process and overcome the drawbacks of
ROB2[(1001)2 ] = (1011)2 . (16)
existing solutions.
For ease of presentation, we present a high level overview The second kind of operation is RAB (reversal of all bits),
of BIG based on a toy example. Consider the system provided which means the tag will reverse all the bits of the group ID.
 Original
Group ID
ROB4 ROB3 ROB1
1 0 0 1 0 0 0 1 0 1 0 1
Original Target
Group ID Group ID
ROB2 RAB
1 0 0 1 1 0 1 1 0 1 0 0
Fig. 5. Two approaches to change the group ID of 𝑡6 .
For example, the group ID of 𝑡9 is (0111)2 . If the tag executes
RAB operation on its group ID (0111)2 , which is
RAB[(0111)2 ] = (1000)2 .
Fig. 5 shows two approaches to change the group ID of 𝑡6
from (1001)2 to (0100)2 . The first approach is that the tag can
only use ROBn operations on the original group ID, which are
ROB4, ROB3 and ROB1. But the tag needs to execute three
operations on the original group ID. The second approach is
that the tag uses both ROBn and RAB operations on the original
group ID, which are ROB2 and RAB. In this way, the tag only
needs to execute two operations on the original group ID,
which is one round less than the first approach.
The reader will decide what the the operations are needed
for each tag. Here we denote the original group ID string
as 𝑆𝑂 and the target group ID string as 𝑆𝑇 . The reader first
calculates the differences between the binary original group ID
and the binary target group ID, as 𝑆𝑂 XOR 𝑆𝑇 . We denote
the difference string as 𝑆𝐷 , that is
𝑆𝐷 = 𝑆𝑂 XOR 𝑆𝑇 .
The index 𝑖 of ’1’ in 𝑆𝐷 indicates the operation ROBi will
be executed on this original group ID. If the reader count the
number of ’1’ in the differences, it will also know the total
number of execution operations. We denoted the total number
as 𝑠. Then the reader calculates the differences (denoted as
′
𝑆𝐷 ) between the reversal value of the binary original group
ID and the binary target group ID, which is as follows:
′
𝑆𝐷 = (NOT 𝑆𝑂 ) XOR 𝑆𝑇 ,
where NOT is bitwise operation let 0 become 1, and 1 become
0. The index 𝑖 of ’1’ in the differences also indicates the
operation ROBi will be executed on this original group ID.
Upon adding one round execution of the operation RAB, the
reader will also know the total number of needed execution
operations. We denoted the total number as 𝑘. Comparing
𝑠 with 𝑘, we can easily obtain the operations needed to be
executed for a tag.
For example, the original group ID of 𝑡6 is (1001)2 , and the
target group ID is (0100)2 . The differences between (1001)2
and (0100)2 can be calculated as follows:
(1001)2 XOR (0100)2 = (1101)2 .
Therefore, the 1st, 3rd and 4th bits are needed to change from
the original group ID to the target group ID. The reader needs
Target to execute ROB1, ROB3 and ROB4 on the original group ID,
Group ID
and 𝑠 = 3. The differences between the reversal value of
0 1 0 0
(1001)2 and (0100)2 can be calculated as follows:
(NOT (1001)2 ) XOR (0100)2
=(0110)2 XOR (0100)2 (21)
=(0010)2 .
Therefore, only the 2nd bit is needed to change from the
original group ID to the target group ID. The reader needs to
execute ROB2 and RAB on the original group ID, and 𝑘 = 2.
Comparing 𝑠 with 𝑘, we can easily obtain the operations,
which are needed to be executed for the tag, are ROB2 and
(17) RAB.
2) Sorting the order of grouping operations: The order
of each grouping operation will have impact on the total
execution time. The less number of tags participate in the
following phase, the less time grouping operations execute.
We denote the function that gets the number of tags which
needs a specific grouping operation (e.g. ROBn or RAB) as
LEN[⋅]. As shown in Table IV, three tags (𝑡4 , 𝑡10 and 𝑡11 ) need
ROB1 operation, which is LEN[ROB1] = 3. If the maximum
length of the group ID is 𝑚, the set of grouping operations will
be {ROB1, ROB2, ..., ROBm, RAB}. The reader then calculates
the number of tags which needs each grouping operation. For
example in Table IV, we have
LEN[ROB1] = 3, LEN[ROB2] = 7,
LEN[ROB3] = 1, LEN[ROB4] = 5, (22)
LEN[RAB] = 5.
(18) To determine which grouping operation will be executed, the
reader sorts above result. Therefore, we can easily have two
execution orders, which are
ROB2 → RAB → ROB4 → ROB1 → ROB3
(23)
ROB2 → ROB4 → RAB → ROB1 → ROB3.
C. Phase 2: Registration
In this registration phase, the reader will acknowledge each
tag with its execution round number. The tag will take this
(19) execution round number into the next phase (Grouping Phase).
In grouping phase, after the assigned execution round number,
the tag will exactly know it finishes grouping and then stop
executing the following grouping operations, such as ROBn
and RAB.
To initialize the registration phase, the counter in each tag
will be set to 0. In an arbitrary round 𝑖 of the registration
phase, the reader adopts STH to separate tags into two sets,
which determine whether tags from each set will continue to
add the counter or not. We denote the two set as 𝐴𝑖 and 𝐵𝑖
respectively. If the counter of the tag still needs to add ’1’,
the reader will pick it into set 𝐴𝑖 . Otherwise, If the counter
of a tag does not need to add ’1’, the reader will pick it into
(20) set 𝐵𝑖 . The tags from 𝐴𝑖 will participate in the next round
of separation. In the meantime, the tags from 𝐵𝑖 will not
participate in the next round of separation. Until no tag needs
to add ’1’, the registration phase ends and each tag is assigned
 Counter = 0 Counter = 1 Counter = 2 TABLE IV
+0 +0 +0 E XECUTION OF BIG P ROTOCOL

Original
Initial Counter = 0 Counter = 3
𝑇 𝐼𝐷 ROB2 RAB ROB4 ROB1 ROB3
𝐺𝐼𝐷2
+1 +1 +1
𝑡1 01101 ∗1 ∗1 ∗1 ∗1 00100
𝑡2 11011 11110
Fig. 6. Example of registration phase. 𝑡3 01012 ∗2 10101 00100
𝑡4 11112 11011 ∗1 ∗1 11000
with a execution round number. After the registration phase, 𝑡5 00112 00011 ∗1 10010
tags in the system will know the exact total number of rounds 𝑡6 10012 10111 01000
they will participate in the grouping phase. 𝑡7 01102 ∗2 10011 00010
As shown in Fig. 6, The initial counter of each tag is set 𝑡8 01002 01101 ∗1 11100
to 0. After the first round, some tags stop participating in 𝑡9 01111 ∗1 10000
the following rounds with counter number 0. The other tags
𝑡10 11012 11111 ∗1 ∗1 11100
participate in the second round with the counter number 1.
𝑡11 01112 01011 ∗1 ∗1 01000
After 3 rounds, 4 sets of tags are generated. Each tag knows
the total number of operations they will participate in the next 𝑡12 11102 ∗2 00011 10010
phase.
D. Phase 3: Grouping these tags still need to participate in the following rounds. For
In this grouping phase, the reader let the tags execute the example, after the second round, the counter of 𝑡8 equals ’1’.
grouping operations in the order which is precalculated in the The tag 𝑡8 will participate the third round. Only after the third
initilization phase. When following the precalculated order, round, 𝑡8 will not participate the next round.
the reader executes the order one round by one round. If the 2) Executing the grouping operation: In each round, the
maximum length of the group ID is 𝑚, the set of grouping selected tags execute the grouping operation. As shown in
operations will be {ROB1, ROB2, ..., ROBm, RAB}. Therefore, Table III, the reader executes the grouping operations follows
we can easily know the number of total rounds is 𝑚 + 1. the order ROB2 → RAB → ROB4 → ROB1 → ROB3. The
Before letting the tags execute each grouping operation, the blank cell means this tag will not participate the current round.
reader will adopt STH protocol to pick the tags which will For example, 𝑡1 finishes the grouping operations in the last
execute the grouping operation from the tags which will not round. 𝑡3 finishes the grouping operations in the third round.
execute the grouping operation. After executing all the grouping operations, the reader is
1) Picking up the tags execute the operation: Consider an able to assign all the tags with the target grouping ID.
arbitrary round, the reader utilizes STH protocol to separate
the tags which need to be executed the grouping operation V. E VALUATION
from the tags which do not need to be executed the grouping In this section, we evaluate the performance of BIG by
operation. Therefore, after executing the STH protocol, the simulations. We first verify the efficiency of our protocol BIG
tags fall into two parts. The one part of tags would execute and the derived execution time of BIG. We then compare the
the grouping operation. The other part of tags would not execution time of our protocols with FIG, CCG.
execute the grouping operation. As shown in Table IV, all tags
participate in the first round. But these tags fall into two sets. A. Simulation Settings
The set of tags, which would execute the grouping operation, We implement a simulator with Python to evaluate the per-
include 𝑡2 , 𝑡4 , 𝑡5 , 𝑡6 , 𝑡8 , 𝑡10 and 𝑡11 . The other set of tags, formance of our protocol in large-scale systems. Our protocol
which would not execute the grouping operation, include 𝑡1 , is compared with the state-of-the-art protocols FIG and CCG
𝑡3 , 𝑡7 , 𝑡9 and 𝑡12 . [13]. For fair comparison, we adopt the timing scheme defined
If the tag is in the set of tags which will execute the grouping in the EPCglobal C1G2 UHF tags [16] as the unit of the
operation, it minuses the counter with ’1’. Otherwise, the tag execution time for all protocols. The transmission rate of the
keeps the counter unchanged. If the counter of a tag equals to tag is 53𝐾𝑏/𝑠. It takes 18.88𝜇𝑠 to transmit a bit from a tag
’0’, this tag will not participate in the following rounds. As to a reader, i.e. 𝑡𝑏 = 18.88𝜇𝑠. The transmission rate of the
shown in Table IV, the superscript of each bit string means the reader is 26.5𝐾𝑏/𝑠. Any two consecutive transmissions are
counter of each tag in each round. For example, in the second separated by a time interval of 302𝜇𝑠. Based on this we can
round, 𝑡6 executes RAB operation, and minuses its counter calculate that the time for the reader to transmit an ID or a
with ’1’. After this second round, the counter of this tag is segment of allocation vectors is 3, 927𝜇𝑠. The group ID in
’0’, and this tag will not participate in the following round. our simulation is set to the corresponding index 𝑖, which is
But there are also some counters of tags is not equal to ’0’, ⌈log2 𝑘⌉ bits long. Each simulation experiment was conducted
 20 20 6
8 β=1
β=2 5
β=3
Exectution Time (s)

Exectution Time (s)

Exectution Time (s)

Exectution Time (s)
15 15
FIG
CCG 6 4
BIG
10 10 3
4
2
5 FIG
5 2
CCG 1
BIG
0 0 0 0
0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 2 4 6 8 10 24 2 5
26
2 7
28
2 9
2 10
1k 2k 3k 4k 5k 6k 7k 8k 9k 10k
The portion α of tags The total number (β) of changing bits The maximum group ID Total tag number

(a) (b) (a) (b)

Fig. 7. Performance comparison. (a) Total execution time to label all tags, Fig. 8. Performance investigation. (a) Total execution time to label all tags,
when varying the portion (𝛼) of tags which remains the same group ID from when varying group ID length from 24 to 210 . (b) Total execution time to
0% to 90%. (b) Total execution time to label all tags, when varying the total label all tags, when varying the total number of tags from 1,000 to 10,000.
number (𝛽) of ’1’ in the calculated difference from 1 bit to 9 bits.

FIG. In the same time, the execution time of either CCG or

for 100 times and then we report the averaged results of the
FIG still remains the same. For example, when 𝛽 is 2, the
independent trials.
execution time of CCG is 9.09𝑠. In the meantime, BIG only
B. Performance Comparison needs 5.88𝑠 finishes grouping, which is 3.21𝑠 less than CCG.
When 𝛽 is 7, the execution time of CCG is 9.12𝑠. In the
We evaluate the performance of our protocol under various
meantime, BIG only needs 8.24𝑠 finishes grouping, which is
parameter settings. We set the total number of tags in the
0.88𝑠 less than CCG. Because, the reader needs to assign a
system to 214 = 16, 384. The total bit length of the group
new group ID for each tag, BIG only needs to change the bit
ID is 10. Thus the maximum group ID is 210 = 1, 024. We
without changing all bits of the group ID, which leads to the
compare our protocol BIG with the state-of-the-art FIG and
high performance of our protocol BIG over both CCG and
CCG protocols. We first evaluate the performance with varying
FIG under most scenarios.
the portion of tags which remain the same group ID. We denote
the portion of tags as 𝛼 = 𝑚𝑛 , where 𝑚 is the number of tags
which remain the same groups ID and 𝑛 is the total number C. Performance Investigation
of tags in the system. We then evaluate the performance with
varying the total number of ’1’ in 𝑆𝐷 . As discussed previously, Next we study in greater details the impact of different
the reader will calculate the difference (𝑆𝐷 ) of the original parameters, including the number of groups, and the total
group ID (𝑆𝑂 ) and the target group ID (𝑆𝑇 ). We denote the number of tags in the system.
total number of ’1’ in 𝑆𝐷 as 𝛽. 1) Impact of group ID length: As we described previously,
1) Impact of 𝛼: In Fig. 7(a), we first evaluate the perfor- the reader adopts two kinds of operations to assign the target
mance with varying the portion (𝛼) of tags which remains group ID to each tag. The first kind of operations is ROBn.
the same group ID from 0% to 90%, that is 𝛼 ∈ [0%, 90%]. The second kind of operation is RAB. If the maximum length
The figure shows that BIG outperforms CCG and FIG in the of the group ID is 𝑘, the set of grouping operations will
most cases. As the portion 𝛼 grows, the total execution time be {ROB1, ROB2, ..., ROBk, RAB}. Therefore, we can easily
of BIG decreases sharply. In the same time, the execution know the number of total rounds is 𝑘 + 1. Therefore, the total
time of either CCG or FIG remains the same. For example, length of the group ID has the impact on the total execution
when the portion 𝛼 of tags is 20%, the execution time of time. We investigate the impact of the total number of groups
CCG is 9.11𝑠. In the meantime, BIG only needs 8.04𝑠 finishes on the execution time. In Fig. 8(a), we set the total number
grouping, which is 1.07𝑠 less than CCG. When the portion 𝛼 of tags in the system to 214 = 16, 384, vary the number of
of tags is 80%, the execution time of CCG is 9.07𝑠. In the total groups from 24 to 210 and 𝛽 from 1 to 3. Generally, our
meantime, BIG only needs 2.98𝑠 finishes grouping, which is protocol with 𝛽 = 1, 2 or 3 the number of groups increases as
6.09𝑠 less than CCG. Because, BIG only re-groups the tags the number of grouping operations increases, leading to more
when these tags need to change their group ID. BIG filters execution time. For example, when 𝛽 = 2 and the number of
any tag which does not need to change their group ID in its groups is 26 , the execution time is 4.30𝑠. When 𝛽 = 2 and
bit-based execution, so that no tedious group ID transmission the number of groups is 28 , the execution time is 5.19𝑠.
is needed, which leads to the high performance of our protocol 2) Impact of total tag number: We then evaluate the impact
BIG over both CCG and FIG under most scenarios. of total tag number on the total execution time. In Fig. 8(b),
2) Impact of 𝛽: In Fig. 7(b), we then evaluate the per- we vary the total number of tags in the system from 1, 000 to
formance with varying the total number (𝛽) of ’1’ in the 10, 000 and fix 𝛽 = 3. Generally, the execution time of our
calculated difference from 1 bit to 10 bits. The figure also protocol increases as the total number of tags increases. For
shows that BIG outperforms CCG and FIG in the most cases. example, when the total tag number is 2, 000, the execution
As 𝛽 grows, the total execution time of BIG first increases time is 1.12𝑠. When the total tag number is 5, 000, the
and then decreases. But BIG always outperforms CCG and execution time is 2.74𝑠.
 VI. R ELATED W ORK
Existing tag identification protocols fall into two categories:
Tree-based protocols [23], [24] and Aloha-based protocols
[25], [26]. In Tree-based protocols, the reader applies a dy-
namic ID prefix of tag IDs to progressively split a tag set
into smaller subsets until only one tag is left. This process is
iteratively executed until all tags are successfully identified. In
Aloha-based identification protocols, the reader carries out a
slotted frame and each tag individually picks a slot to reply.
A tag can successfully transmit its ID only when its slot has
no other tags. The left tags which fail to report their IDs will
move to the next slotted frame.
There are also some work on the tag grouping problem.
Filter Grouping (FIG) protocol [13] that uses Bloom filters
to remove the costly ID transmissions. The authors point
out the limitation of the Bloom-filter based solution due
to its intrinsic false positive problem, which leads to the
ConCurrent Grouping (CCG) protocol. With a different design,
CCG is able to outperform FIG by exploiting collisions to
inform multiple tags of their group ID simultaneously and by
removing any wasteful slots in its frame-based execution.
VII. C ONCLUSION
This paper studies a problem of how to fast group tags
dynamically in RFID systems. Fast grouping RFID tags ac-
cording to a given partition in a large-scale RFID system is of
practical importance for those applications. The reader can si-
multaneously transmit the same data to the tags have the same
group ID, which greatly reduces the communication overhead
in comparison with the traditional unicast transmission. Unlike
existing efforts, we present a sophisticated protocol BIG to
address the dynamical grouping problem in an efficient way.
BIG only reverses the bit of tag group ID, which needs to be
changed, instead of changing all bits of a tag group ID. From
conducting extensive simulations, the evaluation results show
that BIG outperforms the state-of-the-art protocols.
ACKNOWLEDGMENT
This research is financially supported by the National Nat-
ural Science Foundation of China (No.61272418, 61373181),
the National Science and Technology Support Program of
China (No.2012BAK26B02), the Future Network Prospective
Research Program of Jiangsu Province (No.BY2013095-5-02),
the Lianyungang City Science and Technology Project (Indus-
try Development) (No.CG1420), the Fundamental Research
Funds for the Central Universities and HK PolyU G-SB40.
R EFERENCES
[1] L. Xie, Q. Li, X. Chen, S. Lu, and D. Chen, “Continuous scanning
with mobile reader in rfid systems: an experimental study,” in Proc. of
MOBIHOC, 2013.
[2] J. Liu, B. Xiao, K. Bu, and L. Chen, “Efficient distributed query
processing in large rfid-enabled supply chains,” in Proc. of IEEE
INFOCOM, 2014.
[3] C. Wang, L. Xie, W. Wang, and S. Lu, “Moving tag detection via
physical layer analysis for large-scale rfid systems,” Proc. of IEEE
INFOCOM, 2016.
[4] R. Krigslund, S. Dosen, P. Popovski, J. L. Dideriksen, G. F. Pedersen,
and D. Farina, “A novel technology for motion capture using passive
uhf rfid tags,” IEEE Transactions on Biomedical Engineering, 2013.
[5] X. Liu, K. Li, G. Min, Y. Shen, A. X. Liu, and W. Qu, “Completely
pinpointing the missing rfid tags in a time-efficient way,” IEEE Trans-
actions on Computers (TOC), 2015.
[6] K. Bu, B. Xiao, Q. Xiao, and S. Chen, “Efficient misplaced-tag pin-
pointing in large RFID systems,” IEEE Transactions on Parallel and
Distributed Systems (TPDS), 2012.
[7] J. Han, C. Qian, X. Wang, D. Ma, J. Zhao, P. Zhang, W. Xi, and Z. Jiang,
“Twins: Device-free object tracking using passive tags,” in Proc. of IEEE
INFOCOM, 2014.
[8] F. Zhu, J. Liu, and L. Chen, “Fast physical-layer unknown tag identi-
fication in large-scale RFIDsystems,” in Proc. of IEEE GLOBECOM,
2014.
[9] X. Liu, S. Zhang, K. Bu, and B. Xiao, “Complete and fast unknown tag
identification in large rfid systems,” in Proc. of IEEE MASS, 2012.
[10] J. Liu, M. Chen, S. Chen, Q. Pan, and L. Chen, “Tag-Compass:
Determining the spatial direction of an object with small dimensions,”
in Proc. of IEEE INFOCOM, 2017.
[11] L. Xie, J. Sun, Q. Cai, C. Wang, J. Wu, and S. Lu, “Tell me what i see:
Recognize rfid tagged objects in augmented reality systems,” in Proc.
of ACM UbiComp, 2016, pp. 916–927.
[12] M. Chen and S. Chen, “Etap: Enable lightweight anonymous RFID
authentication with O(1) overhead,” in Proc. of IEEE ICNP, 2015, pp.
267–278.
[13] J. Liu, B. Xiao, S. Chen, F. Zhu, and L. Chen, “Fast rfid grouping
protocols,” in Proc. of IEEE INFOCOM, 2015.
[14] W. Luo, Y. Qiao, and S. Chen, “An efficient protocol for rfid multigroup
threshold-based classification,” in INFOCOM, 2013 Proceedings IEEE,
2013.
[15] S. Chen, M. Zhang, and B. Xiao, “Efficient information collection
protocols for sensor-augmented RFID networks,” in Proc. of IEEE
INFOCOM, 2011.
[16] Epcglobal. epc radio-frequency identity protocols class-1 generation-2
uhf rfid protocol for communications at 860 mhz-960mhz version 1.2.0,
Tech. Rep., 2008.
[17] K. Finkenzeller, RFID Handbook: Fundamentals and Applications in
Contactless Smart Cards and Identification, 2003.
[18] J. Wang, H. Hassanieh, D. Katabi, and P. Indyk, “Efficient and reliable
low-power backscatter networks,” in Proc. of ACM SIGCOMM, 2012.
[19] Y. Zheng and M. Li, “P-mti: Physical-layer missing tag identification
via compressive sensing,” in Proc. of IEEE INFOCOM, 2013.
[20] J. Waldrop, D. W. Engels, and S. E. Sarma, “Colorwave: an anticollision
algorithm for the reader collision problem,” in Proc. of IEEE ICC, 2003.
[21] L. Yang, J. Han, Y. Qi, C. Wang, T. Gu, and Y. Liu, “Season: Shelving
interference and joint identification in large-scale rfid systems,” in Proc.
of IEEE INFOCOM, 2011.
[22] D. A. Huffman, “A method for the construction of minimum-redundancy
codes,” Proc. of IRE, pp. 1098–1101, 1952.
[23] J. Myung, W. Lee, J. Srivastava, and T. Shih, “Tag-splitting: Adaptive
collision arbitration protocols for rfid tag identification,” IEEE Transac-
tions on Parallel and Distributed Systems (TPDS), 2007.
[24] M. Shahzad and A. X. Liu, “Probabilistic optimal tree hopping for rfid
identification,” in ACM SIGMETRICS Performance Evaluation Review,
2013.
[25] V. Namboodiri and L. Gao, “Energy-aware tag anticollision protocols for
rfid systems,” IEEE Transactions on Mobile Computing (TMC), 2010.
[26] B. Zhen, M. Kobayashi, and M. Shimizu, “Framed aloha for multiple rfid
objects identification,” IEICE Transactions on Communications, 2005.