Optimal Algorithm for Profiling Dynamic Arrays with Finite Values

TL;DR

This paper introduces S-Profile, an optimal, constant-time algorithm for real-time profiling of dynamic arrays to identify most frequent objects, significantly outperforming existing methods in speed.

Contribution

The paper presents S-Profile, a novel algorithm that achieves constant-time updates and optimal complexity for profiling dynamic arrays with single-element modifications.

Findings

S-Profile outperforms heap-based methods with at least 2X speedup.

S-Profile outperforms balanced tree methods with 13X or more speedup.

The algorithm is proven to be optimal in computational complexity.

Abstract

How can one quickly answer the most and top popular objects at any time, given a large log stream in a system of billions of users? It is equivalent to find the mode and top-frequent elements in a dynamic array corresponding to the log stream. However, most existing work either restrain the dynamic array within a sliding window, or do not take advantages of only one element can be added or removed in a log stream. Therefore, we propose a profiling algorithm, named S-Profile, which is of $O(1)$ time complexity for every updating of the dynamic array, and optimal in terms of computational complexity. With the profiling results, answering the queries on the statistics of dynamic array becomes trivial and fast. With the experiments of various settings of dynamic arrays, our accurate S-Profile algorithm outperforms the well-known methods, showing at least 2X speedup to the heap based approach and 13X or larger speedup to the balanced tree based approach.

Equations

$$T_i=PtrB[i].f,\text{and}PtrB[i].l\le i\le PtrB[i].r.$$

Full text

Data structure, log stream, mode of an array, $O(1)$-complexity algorithm, profiling dynamic array.

1. Introduction

Many online systems, especially with billions of users, are generating a large stream of logs (Dietz and Pernul, 2018), recording users’ dynamics in the systems, e.g.  users (un)follow other users, “(dis)like” objects, enter (exit) live video channels, and click objects. Then, a question is raised:

How can we efficiently know the most popular objects (include users), i.e. mode, top-K popular ones, and even the distribution of frequency in a fast and large log stream at any time?

Mathematically, the questions converge to calculate and update the statistics of a dynamic array of finite values. Thus the existing fast algorithms on the statistics are as follows:

Mode of an array. The mode of an array and its corresponding frequency can be calculated by sorting the array (if it’s of numeric value) and scanning the sorted array in $O(n\log n)$ time, where $n$ is the length of array (Dobkin and Munro, 1980). Notice that through judging the frequency of mode we can solve the element distinctness problem, which was proven to have to be solved with $\Omega(n\log n)$ time complexity (Steele and Yao, 1982; Lubiw and Rácz, 1991). Therefore, calculating the mode of an array has the lower bound of $\Omega(n\log n)$ as well. If the elements of array can only take finite values, the complexity of calculating the mode can be reduced. Suppose they can only take $m$ values. One can use $m$ buckets to store the frequency of each distinct element. Then, the mode can be calculated in $O(n+m)$ time by scanning the $m$ buckets.

The problem of range mode query, which calculates the mode of a sub-array $A[i\dots j]$ for a given array $A$ and a pair of indices $(i,j)$, has also been investigated (Krizanc et al., 2005; Petersen and Grabowski, 2009; Chan et al., 2014). The array with finite values was considered. With a static data structure, the range mode query can be answered in $O(\sqrt{n/\log n})$ time (Chan et al., 2014).

Majority and frequency approximation. The majority is the element whose frequency is more than half of $n$. An algorithm was proposed to find majority in $O(n)$ time and $O(1)$ space (Boyer and Moore, 1991). Many work on the statistics like frequency count and quantiles, are under a setting of sliding window (Arasu and Manku, 2004; Datar et al., 2002; Babcock et al., 2002; Gibbons and Tirthapura, 2002; Lin et al., 2004). They consider the most recently observed data elements (within the window) and calculate the statistics. Space-efficient algorithms were proposed to maintain the statistics over the sliding window on a stream.

However, those existing work slow down their algorithms without considering that the increase and decrease of object frequency are always 1 at a time in log streams. Therefore, we propose an algorithm S-Profile to keep profiling the dynamic array. With such a profile, we can answer the queries of the statistics: mode, top-K and frequency distributions.

In summary, S-Profile has the following advantages:

Optimal efficiency: S-Profile needs $O(1)$ time complexity and $O(m)$ space complexity to profile dynamic arrays, where $m$ is the maximum number of objects.

• -

Querying Statistics: With the profiling, we have sorted frequency-object pairs, and can simply answer the queries on mode, top-K, majority and other statistics in $O(1)$.

• -

Applicable: Our S-Profile can be plugged into most of log streams in many systems, and profiling objects of interest.

In experiments, S-Profile compares with the existing methods in various settings of dynamic arrays, and shows its performance and robustness.

2. An $O(1)$-Complexity Algorithm for Updating the Mode and Statistics

We define tuples $(x_{i},c_{i})$ as a log stream, where $x_{i}$ and $c_{i}$ is the object id and action in the $i$-th tuple. Action $c_{i}$ can be either “add” or “remove”, which, for example, can indicate object $x_{i}$ is “liked” or “disliked”, or user $x_{i}$ is followed or unfollowed. Conceptually, we could imagine a dynamic array $A$ of objects associated with a log stream, by appending object $x_{i}$ into $A$ if $c_{i}$ is “add”, and deleting object $x_{i}$ from $A$ if $c_{i}$ is “remove”. Dynamic array $A$ is not necessarily generated and stored, which is defined for convenient description of our algorithm.

Therefore, our problem can be described as follows:

Problem 1 (Profiling dynamic array).

Given: a log stream of tuples $(x_{i},c_{i})$ adding and removing an object each time,

To find:* fast profiling of dynamic array $A$ of objects at any time,*

• -

Such that:* answering the queries on mode, top-K and other statistics of objects is trivial and fast.*

Let $m$ be the maximum number of distinct objects in a log stream or dynamic array $A$. Without loss of generality, we assume id $x_{i}\in[1,m]$, i.e. integers between 1 and $m$. For any $m$ distinct objects, we can map them into the integers from 1 to $m$ as ids.

We can use $m$ buckets to store the frequency of each distinct object. Let $F$ be such a frequency array with length $m$. $F[i]\in F$ is the frequency of object with id $i$. With $F$, most statistics of $A$ can be calculated without visiting $A$ itself. For example, the mode of $A$ refers to locations in $F$ where the element has the maximum value. Although updating $F$ with each tuple of a log stream trivial and costs $O(1)$, finding the maximum value in $F$ at each time is still time consuming.

Therefore, we first introduce a proposed data structure of a profile, named “block set”, which can answer the statistical queries in a trivial cost. And we show later that we can maintain such a profile in $O(1)$ time complexity and $O(m)$ space complexity.

2.1. Proposed data structure for profiling

In order to find the mode of $A$, we just need to care about the maximum in $F$. If only integers are added to $A$, the maximum element of $F$ can be easily updated. However, in Problem 1 removing integer is also allowed. This complicates the calculation of mode and other statistics of $A$. So, the sorted array $T$ must be employed and maintained. To facilitate the queries, $T$ can be implemented as a binary tree. The heap and balanced tree are two kinds of binary tree, and are widely used for efficiently maintaining an sorted array. Upon a modification on $A$, they both can be updated in $O(\log m)$ time. The root node of a heap is the array element with the extreme value. This means the heap is only suitable for producing the $A$’s elements with either maximum frequency (the mode) or the minimum frequency. The balanced tree is good at answering the query of median of $A$, and can also output the mode and top-K elements, etc. It should be pointed out, these general algorithms do not take the particularity of Problem 1 into account (the modification on $F$ is restricted to plus 1 or minus 1). By the way, no one can maintain the sorted array under an arbitrary modification with a time complexity below $O(\log m)$, because it can be regarded as a sorting problem which has been proven to have $\Omega(m\log m)$ time complexity.

We use Figure 1 as an example to illustrate the proposed data structure for maintaining $T$. Suppose $T$ has frequency values in ascending order. In order to locate the index of the $i$-th element of $T$ in $F$ and vice verse, two conversion arrays are defined: $TtoF$ and $FtoT$. In other words, we have $T[i]=F[TtoF_{i}]$ and $F[i]=T[FtoT_{i}]$. Here, we use both the subscript and bracket notation to specify an element of array. As shown in Figure 1(c), we can partition $T$ into nonoverlapped segments according to its elements. Each such segment is called block here and represented by an integer triple $(l,r,f)$, where $l$ and $r$ are starting and ending indices respectively, and $f$ is the element value (frequency). So, a block $b=(l,r,f)$ always satisfies:

• •

$1\leq l\leq r\leq m$

• •

$T_{i}=f$,        $\forall i\in[l,r]$

• •

$T_{l}>T_{l-1}$,    if $l>1$

• •

$T_{r}<T_{r+1}$,    if $r<m$

There are at most $m$ blocks, which form a block set. It fully captures the information in the sorted array $T$. An array of pointers called $PtrB$ is also needed to make a link from each element in $T$ to its relevant block. According to the definition of block, we always have:

[TABLE]

Here we use “$.l$” to denote the member $l$ of a block, and so on.

The block set $B$ represents the sorted frequency array $T$, while with arrays $FtoS$, $StoF$ and $PtrB$ we no longer need to store $F$ and $T$. These proposed new data structure well profile the dynamic array $A$. The remaining thing is to maintain them and answer the statistical queries on $A$ in an efficient manner.

2.2. S-Profile: the $O(1)$-Complexity Updating Algorithm

We first consider the situation where an integer is added to $A$. As shown in Figure 1(a) and 1(b), a brute-fore approach to update $T$ is swapping the updated frequency to its right-hand neighbor one by one, until $T$ is in the appropriate order again. Now, with the proposed $PtrB$ and the block it points to, we can easily determine the index of $T$ which is the destination of swapping the updated frequency. Then, we can update the relevant two blocks and pointer arrays (see Figure 1(d)).

Now, based on the situation shown as Figure 1(d), we assume a “4” is removed from $A$. As shown in Figure 2, we first locate the updated element in $T$.

Then, with the information in its corresponding block we know with which it should be swapped. We further check if the updated frequency exists in $T$ before. If it does not we need to create a new block (the case in Figure 2(b)), otherwise another block is modified.

The whole details of the algorithm for updating the data structure and returning the mode of $A$ is described as Algorithm 1. We assume the data structures ($B$, $FtoS$, $StoF$ and $PtrB$) have been initialized, while Algorithm 1 responds to an event in the log stream and returns the updated mode and frequency.

As the proposed data structure maintains the sorted frequency array, it can be utilized to calculate the object with the minimum frequency (maybe a negative number) as well. We just need to replace Step 29 and 30 in Algorithm 1 with the following steps.

[TABLE]

We can observe that the time complexity of the S-Profile algorithm is $O(1)$, as there is no iteration at all. The space complexity is $O(m)$, where $m$ is the maximum number of objects in the log stream. Precisely, it needs $3m$ integers to store the pointer arrays and an additional storage for $B$. In the worst case $B$ includes $m$ blocks, but usually this number is much smaller than $m$.

Other queries on statistics of objects can also be answered. For example, the top-K order element is that whose frequency is the K-th largest. We can just use $PtrB[m-K+1]$ to locate the block. Then, the frequency and object id can be obtained with block’s member and the $TtoF$ array. Especially, the median in frequency can be located with the K/2-th element of the $PtrB$ array.

2.3. Possible Applications

For some mission-critical tasks (e.g., fraud detection) in big graphs, the efficiency to make decisions and infer interesting patterns is crucial. As a result, recent years have witnessed an increasing interest in heuristic “shaving” algorithms with low computational complexity (Hooi et al., 2016; Shin et al., 2017). A critical step of them is to keep finding low-degree nodes at every time of shaving nodes from a graph. Thus, S-Profile can be plugged into such algorithms for further speedup, by treating a node as an object and its degree as frequency.

Furthermore, S-Profile can also deal with a sliding window on a log stream, by letting every tuple $(x_{i},c_{i})$ outdated from the window be a new incoming tuple $(x_{i},\bar{c}_{i})$, where $\bar{c}_{i}$ is the opposite action of $c_{i}$.

3. Experimental Results

We have implemented the proposed S-Profile algorithm and its counterparts in C++, and tested them with randomly generated log streams. The streams are produced with the following steps. We first randomly generate an "add" or "remove" action, with 70% and 30% probabilities respectively. Then, for each "add" action we randomly choose an object id according to a probability distribution (called posPDF). For each "remove" action another distribution (called negPDF) is used to randomly choose an object id. With this procedure, we obtained three test log streams:

• •

Stream1: both posPDF and negPDF are uniform random distribution on [1, m].

• •

Stream2: both posPDF and negPDF are normal distributions with $\mu=2m/3,m/3$ and $\sigma=m/6,m/6$, respectively.

• •

Stream3: posPDF is a normal distribution ($\mu=4m/5$, $\sigma=m$), while negPDF is a lognormal distribution ($\mu=3m/5$, $\sigma=m$).

In the following subsections, we first compare the proposed S-Profile with the heap based approach, for updating the mode and frequency. Then, the comparison with the balanced tree is presented for calculating the median. All experiments are carried out on a Linux machine with Intel Xeon E5-2630 CPUs (2.30 GHz). The CPU time (in second) of different algorithms are reported.

3.1. Comparison with the Heap

Heap is a kind of binary tree where the value in parent node must be larger or equal to the values in its children. Used to maintain the sorted frequency array, it is easy to obtain the mode (the root has the largest frequency). Noticed the balanced tree is inferior to the heap for calculating the mode. In Figure 3,

we show the CPU time consumed for updating the mode with the heap based method and our S-Profile. The x-axis means the number of processed tuples ($n$). From the results we see that our method is at least 2.2X faster than the heap based method. Another experiment is carried out to fix $n=10^{8}$ while varying $m$. The results shown in Figure 4 also reveal that our S-Profile is at least 2X faster.

For different kind of log stream, the performance of the heap based method varies a lot. For the worst case updating the heap needs $O(\log m)$ time, despite this rarely happens in our tested screams. On the contrary, S-Profile needs $O(1)$ time for updating the data structure. This advantage is verified by the rather flat trend shown in Figure 5.

It should be emphasized that, in addition to the speedup to the heap based method, our S-Profile possesses the advantage of wider applicability. Our method is not restricted to calculating the mode and corresponding frequency. As it well profiles the sorted frequency array, with it answering the queries on top-K and other statistics of objects is trivial and fast.

3.2. Comparison with the Balanced Tree

The proposed S-Profile can also calculate the median of the dynamic array. We compare it with the balanced tree based method implemented in the GNU C++ PBDS (Tavory et al., [n. d.]), which is more efficient than our implementation of balanced tree. The trends of CPU time are shown in Figure 6. They show that the runtime of the proposed S-Profile increases much less than that of the balanced tree based method when $m$ increases. We can observe that the time of S-Profile is linearly depends on $n$, the number of modifications on array $A$, and hardly varies with different $m$. On the contrary, the balanced tree based method exhibits superlinearly increase whether with $n$ or $m$. Overall, the test results show that S-Profile is from 13X to 452X faster than the balanced tree based method on updating the median of the dynamic array.

4. Conclusions

We propose an accurate algorithm, S-Profile, to fast keep profiling the dynamic array from online systems. It has the following advantages:

Optimal efficiency: S-Profile needs $O(1)$ time complexity for every updating of a dynamic array, and totally linear complexity in memory.

• -

Querying Statistics: With profiling, we can answer the statistical queries in a trivial and fast way.

• -

Applicable: S-Profile can be plugged into most of log streams, and heuristic graph mining algorithms.