On Load Shedding in Complex Event Processing

Transcription

1 On Load Shedding in Comlex Event Processing Yeye He icrosoft Research Redmond, WA, Siddharth Barman California Institute of Technology Pasadena, CA, 906 Jeffrey F. Naughton University of Wisconsin-adison adison, WI, ABSTRACT Comlex Event Processing (CEP) is a stream rocessing model that focuses on detecting event atterns in continuous event streams. While the CEP model has gained oularity in the research communities and commercial technologies, the roblem of gracefully degrading erformance under heavy load in the resence of resource constraints, or load shedding, has been largely overlooed. CEP is similar to classical stream data management, but addresses a substantially different class of queries. This unfortunately renders the load shedding algorithms develoed for stream data rocessing inalicable. In this aer we study CEP load shedding under various resource constraints. We formalize broad classes of CEP load-shedding scenarios as different otimization roblems. We demonstrate an array of comlexity results that reveal the hardness of these roblems and construct shedding algorithms with erformance guarantees. Our results shed some light on the difficulty of develoing load-shedding algorithms that maximize utility.. INTRODUCTION The comlex event rocessing or CEP model has received significant attention from the research community [6, 29, 37, 38, 5, 53], and has been adoted by a number of commercial systems including icrosoft StreamInsight [], Sybase Aleri [3], and StreamBase [2]. A wide range of alications, including inventory management [4], behavior monitoring [48], financial trading [5], and fraud detection [8, 52], are now owered by CEP technologies. A reader who is familiar with the extensive stream data rocessing literature may wonder if there is anything new here, or if CEP is just another name for stream data management. While both inds of system evaluate queries over data streams, the imortant difference is the class of queries uon which each system focuses. In the traditional stream rocessing literature, the focus is almost exclusively on aggregate queries or binary equi-joins. By contrast, in CEP, the focus is on detecting certain atterns, which can be viewed as multi-relational non-equi-joins on the time dimension, ossibly with temoral ordering constraints. The class of queries addressed by CEP systems requires different evaluation algorithms and different load-shedding algorithms than the class reviously considered in the context of stream data management. As an examle of a CEP-owered system, consider the health care monitoring system, HyReminder [48], currently deloyed at the University of assachusetts emorial Hosital. The HyReminder system tracs and monitors the hygiene comliance of health-care worers. In this hosital setting, each doctor wears an RFID badge that can be read by sensors installed throughout the hosital. As doctors wal around the hosital, the RFID badges they wear trigger event data, which is transmitted to a central CEP engine. The CEP engine in turn loos for atterns to chec for hygiene comliance. As one examle, according to the US Center for Disease Control (CDC) [3], a doctor who enters or exits a atient room (which is catured by sensors installed in the doorway and encoded as an Enter-Patient-Room event or Exit-Patient-Room event) should cleanse her hands (encoded by a Sanitize event) within a short eriod of time. This hygiene regulation can be traced and enforced using the following CEP queries. Q: SEQ(Sanitize, Enter-Patient-Room) within min Q2: SEQ(Exit-Patient-Room, Sanitize) within min In the HyReminder system, these two CEP queries monitor the event sequence to trac sanitization behavior and ensure hygiene comliance. As another examle consider CIS [4], which is a system also owered by CEP and deloyed in the same University of assachusetts hosital. CIS is used for inventory management and asset tracing uroses. It catures RFID events triggered by tags attached to medical equiment and exensive medicines, and uses CEP technology to trac suly usage and reduce inventory cost [5]. While the emergence of CEP model has sawned a wide variety of alications, so far research efforts have focused almost exclusively on imroving CEP query join efficiency [6, 29, 37, 38, 5, 53]. Load shedding, an imortant issue that has been extensively studied in traditional stream rocessing [0, 20, 26, 27, 44, 45, 49, 50, 54], has been largely overlooed in the new context of CEP. Lie other stream systems, CEP systems often face bursty inut data. Since over-rovisioning the system to the oint where it can handle any such burst may be uneconomical

2 or imossible, during ea loads a CEP system may need to shed ortions of the load. The ey technical challenge herein is to selectively shed wor so as to eliminate the less imortant query results, thereby reserve the more useful query results as defined by some utility function. ore secifically, the roblem we consider is the following. Consider a CEP system that has a number of attern queries, each of which consists of a number of events and is associated with a utility function. During ea loads, memory and/or CPU resources may not be sufficient. A utilitymaximizing load shedding scheme should then determine which events should be reserved in memory and which query results should be rocessed by the CPU, so that not only are resource constraints resected, but also the overall utility of the query results generated is maximized. We note that, in addition to utility-maximization in a single CEP alication, the load-shedding framewor may also be relevant to cloud oerators that need to otimize across multile CEP alications. Secifically, stream rocessing alications are gradually shifting to the cloud [35]. In cloud scenarios, the cloud oerator in general cannot afford to rovision for the aggregate ea load across all tenants, which would defeat the urose of consolidation. Consequently, when the load exceeds caacity, cloud oerators are forced to shed load. They have a financial incentive to judiciously shed wor from queries that are associated with a low enalty cost as secified in Service Level Agreements (SLAs), so that their rofits can be maximized (similar roblems have been called rofit maximization in a cloud and have been considered in the Database-as-a-Service literature [8, 9]). Note that this roblem is naturally a utility-maximizing CEP load shedding roblem, where utility essentially becomes the financial rewards and enalties secified in SLAs. While load shedding has been extensively studied in the context of general stream rocessing [0, 20, 26, 27, 44, 45, 49, 50, 54], the focus there is aggregate queries or tworelation equi-join queries, which are imortant for traditional stream joins. The emerging CEP model, however, demands multi-relational joins that redominantly use non-equi-join redicates on timestam. As we will discuss in more detail in Section 4, the CEP load shedding roblem is significantly different and considerably harder than the roblems reviously studied in the context of general stream load shedding. We show in this wor that variants of the utility maximizing load shedding roblems can be abstracted as different otimization roblems. For examle, deending on which resource is constrained, we can have three roblem variants, namely CPU-bound load shedding, memory-bound load shedding, and dual-bound load shedding (with both CPU- and memory-bound). In addition we can have integral load shedding, where event instances of each tye are either all reserved in memory or all shedded; and fractional load shedding, where a samling oerator exists such that a fraction of event instances of each tye can be samled according to a redetermined samling ratio. Table summarizes emory-bound CPU-bound Dual-bound Integral ILS ICLS IDLS Fractional FLS FCLS FDLS Table : Problem variants for CEP load shedding the six variants of CEP load shedding studied in this aer: ILS (integral memory-bound load shedding), FLS (fractional memory-bound load shedding), ICLS (integral CPUbound load shedding), FCLS (fractional CPU-bound load shedding), IDLS (integral dual-bound load shedding), and FDLS (fractional dual-bound load shedding). We analyze the hardness of these six variants, and study efficient algorithms with erformance guarantees. We demonstrate an array of comlexity results. In articular, we show that CPU-bound load shedding is the easiest to solve: FCLS is solvable in olynomial time, while ICLS admits a FPTAS aroximation. For memory-bound roblems, we show that ILS is in general NP-hard and hard to aroximate. We then identify two secial cases in which ILS can be efficiently aroximated or even solved exactly, and describe a general rounding algorithm that achieves a bi-criteria aroximation. As for the fractional FLS, we show it is hard to solve in general, but has aroximable secial cases. Finally, for dual-bound load shedding IDLS and FDLS, we show that they generalize memory-bound roblems, and the hardness results from memory-bound roblems naturally hold. On the ositive side, we describe a tri-criteria aroximation algorithm and an aroximable secial case for the IDLS roblem. The rest of the aer is organized as follows. We first describe necessary bacground of CEP in Section 2, and introduce the load shedding roblem in Section 3. We describe related wor in Section 4. In Section 5, Section 6 and Section 7 we discuss the memory-bound, CPU-bound and dualbound load-shedding roblems, resectively. We conclude in Section BACKGROUND: COPLE EVENT PRO- CESSING The CEP model has been roosed and develoed by a number of seminal aers (see [6] and [53] as examles). To mae this aer self-contained, we briefly describe the CEP model and its query language in this section. 2. The data model Let the domain of ossible event tyes be the alhabet of fixed size ={E i }, where E i reresents a tye of event. The event stream is modeled as an event sequence as follows. DEFINITION. An event sequence is a sequence S = (e,e 2,...,e N ), where each event instance e j belongs to an event tye E i 2, and has a unique time stam t j. The sequence S is temorally ordered, that is t j <t, 8j <. EAPLE. Suose there are five event tyes denoted by uer-case characters ={A, B, C, D, E}. Each character reresents a certain tye of event. For examle, for the 2

3 hosital hygiene monitoring alication HyReminder, event tye A reresents all event instances where doctors enter ICU, B denotes the tye of events where doctors washing hands at sanitization dess, etc. A ossible event sequence is S =(A,B 2,C 3,D 4,E 5, A 6,B 7,C 8,D 9,E 0 ), where each character is an instance of the corresonding event tye occurring at time stam given by the subscrit. So A denotes that at time-stam, a doctor enters ICU. B 2 shows that at time 2, the doctor sanitizes his hands. At time-stam 6, there is another enter-icu event A 6, so on and so forth. Following the standard ractice of the CEP literature [6, 7, 38, 53], we assume events are temorally ordered by their timestams. Out-of-order events can be handled using techniques from [6, 37]. DEFINITION 2. Given an event sequence S =(e,e 2,..., e N ), a sequence S 0 =(e i,e i2,..., e im ) is a subsequence of S, if ale i <i 2... < i m ale N. Note that the temoral ordering in the original sequence is reserved in subsequences. Also observe that a subsequence does not have to be a contiguous subart of a sequence. 2.2 The query model Unlie relational databases, where queries are tyically ad-hoc and constructed by users at query time, CEP systems are more lie other stream rocessing systems, where queries are submitted ahead of time and run for an extended eriod of time (thus are also nown as long-standing queries). The fact that CEP queries are nown a riori is a ey roerty that allows queries to be analyzed and otimized for roblems lie utility maximizing load shedding. Denote by Q = {Q i } the set of CEP queries, where each query Q i is a sequence query defined as follows. DEFINITION 3. A CEP sequence query Q is of the form Q = SEQ(q,q 2,...q n ), where q 2 are event tyes. Each query Q is associated with a time based sliding window of size T (Q) 2 R +, over which Q will be evaluated. We then define query match under the semantics si-tillany-match. DEFINITION 4. In si-till-any-match, a subsequence S 0 = (e i,e i2,...,e in ) of S is considered a query match of Q =(q,q 2,...,q n ) over time window T (Q) if: () Pattern matches: Event e il in S 0 is of tye q l for all l 2 [,n], (2) Within window: t in t i ale T (Q). We illustrate query matches using Examle 2. EAPLE 2. We continue with Examle, where the event sequence S =(A,B 2,C 3,D 4,E 5,A 6,B 7,C 8,D 9,E 0 ). Suose there are a total of three queries: Q = SEQ(A, C), Q 2 = SEQ(C, E), Q 3 = SEQ(A, B, C, D), all having the same window size T (Q ) = T (Q 2 ) =T (Q 3 )=5. Both sequences (A,C 3 ) and (A 6,C 8 ) are matches for Q, because they match atterns secified in Q, and are within the time window 5. However, (A,C 8 ) is not a match even though it matches the attern in Q, because the time difference between C 8 and A exceeds the window limit 5. Similarly, (C 3,E 5 ) and (C 8,E 0 ) are matches of Q 2 ; (A, B 2,C 3,D 4 ) and (A 6,B 7,C 8,D 9 ) are matches of Q 3. A query with the si-till-any-match semantics essentially loos for the conjunction of occurrences of event tyes in a secified order within a time window. Observe that in si-till-any-match a subsequence does not have to be contiguous in the original sequence to be considered as a match (thus the word si in its name). Such queries are widely studied [2, 6, 29, 37, 38, 5, 53] and used in CEP systems. We note that there are three additional join semantics defined in [6], namely, si-till-next-match, artition-contiguity and contiguity. In the interest of sace and also to better focus on the toic of load shedding, the details of these join semantics are described in Aendix A. The load shedding roblem formulated in this wor is agnostic of the join semantics used. We also observe that although there are CEP language extensions lie negation [29] and Kleene closure [23], in this wor we only focus on the core language constructs that use conjunctive ositive event occurrences. Studying query extensions for load shedding is an interesting area for future research. 3. CEP LOAD SHEDDING It is well nown that continuously arriving stream data is often bursty [20, 44, 50]. During times of ea loads not all data items can be rocessed in a timely manner under resource constraints. As a result, art of the inut load may have to be discarded (shedded), resulting in the system retaining only a subset of data items. The question that naturally arises is which queries should be reserved while others shedded? To answer this question, we introduce the notion of utility to quantify the usefulness of different queries. 3. A definition of utility In CEP systems, different queries naturally have different real-world imortance, where some query outut may be more imortant than others. For examle, in the inventory management alication [4, 5], it is naturally more imortant to roduce real-time query results that trac exensive medicine/equiment than less exensive ones. Similarly, in the hosital hygiene comliance alication [48], it is more imortant to roduce real-time query results reorting a serious hygiene violation with grave health consequences than the ones merely reorting routine hygiene comliance. We define utility weight for each query to measure its imortance. DEFINITION 5. Let Q = {Q i } be the set of queries. Define the utility weight of query Q i, denoted by w i 2 R +, as the erceived usefulness of reorting one instance of match of Q i. 3

4 A user or an administrator familiar with the alication can tyically determine utility weights. Alternatively, in a cloud environment, oerators of multi-tenancy clouds may resort to service-level-agreements (SLAs) to determine utility weights. In this wor we simly treat utility weights as nown constants. We note that the notion of query-level weights has been used in other arts of data management literature (e.g., query scheduling [40]). The total utility of a system is then defined as follows. DEFINITION 6. Let C(Q i,s) be the number of distinct matches for query Q i in S. The utility generated for query Q i is U(Q i,s)=w i C(Q i,s) () The sum of the utility generated over Q = {Q i } is U(Q,S)= U(Q i,s). (2) Our definition of utility generalizes revious metrics lie the max-subset [20] used in traditional stream load shedding literature. ax-subset aims to maximize the number of outut tules, and thus can be viewed as a secial case of our definition in which each query has unit-weight. We also note that although it is natural to define utility as a linear function of query matches for many CEP alications (e.g., [4, 48]), there may exist alications where utility can be best defined differently (e.g. a submodular function to model diminishing returns). Considering alternative utility functions for CEP load shedding is an area for future wor. EAPLE 3. We continue with Examle 2 using the event sequence S and queries Q, Q 2 and Q 3 to illustrate utility. Suose the utility weight w for Q is, w 2 is 2, and w 3 is 3. Since there are 2 matches of Q, Q 2 and Q 3, resectively, in S, the total utility is = Tyes of resource constraints In this wor, we study constraints on two common tyes of comuting resources: CPU and memory. emory-bound load shedding. In this first scenario, memory is the limiting resource. Normally, arriving event data are et in main memory for windowed joins until timestam exiry (i.e., when they are out of active windows). During ea loads, however, event arrival rates may be so high that the amount of memory needed to store all event data might exceed the available caacity. In such a case not every arriving event can be held in memory for join rocessing and some events may have to be discarded. EAPLE 4. In our running examle the event sequence S =(A,B 2,C 3,D 4,E 5,A 6,B 7,C 8,D 9,E 0...), with queries Q = SEQ(A, C), Q 2 = SEQ(C, E) and Q 3 = SEQ(A, B,C, D). Because the sliding window of each query is 5, we now each event needs to be et in memory for 5 units of time. Given that one event arrives in each time unit, a total of 5 events need to be simultaneously et in memory. Suose a memory-constrained system only has memory caacity for 3 events. In this case shedding all events of tye B and D will sacrifice the results of Q 3 but reserves A, C and E and meets the memory constraint. In addition, results for Q and Q 2 can be roduced using available events in memory, which amounts to a total utility of =6. This maximizes utility, for shedding any other two event tyes yields lower utility. CPU-bound load shedding. In the second scenario, memory may be abundant, but CPU becomes the bottlenec. As a result, again only a subset of query results can be rocessed. EAPLE 5. We revisit Examle 4, but now suose we have a CPU constrained system. Assume for simlicity that roducing each query match costs unit of CPU. Suose there are 2 unit of CPU available er 5 units of time, so only 2 matches can be roduced every 5 time units. In this setu, roducing results for Q 2 and Q 3 while shedding others yields a utility of = 0 given the events in S. This is utility maximizing because Q 2 and Q 3 have the highest utility weights. Dual-bound load shedding. Suose now the system is both CPU bound and memory bound (dual-bound). EAPLE 6. We continue with Examle 5. Suose now due to memory constraints 3 events can be et in memory er 5 time units, and in addition 2 query matches can be roduced every 5 time units due to CPU constraints. As can be verified, the otimal decision is to ee events A, C and E while roducing results for Q and Q 2, which yields a utility of =6given the events in S. Note that results for Q 3 cannot be roduced because it needs four events in memory while only three can fit in memory simultaneously. 3.3 Tyes of shedding mechanisms In this aer, we consider two tyes of shedding mechanisms, an integral load shedding, in which certain tyes of events or query matches are discarded altogether; and a fractional load shedding, in which a uniform samling is used, such that a ortion of event tyes or query matches is randomly selected and reserved. Note that both mechanisms we consider are online load shedding. That is, a shedding decision is made for the current event before the next arriving event is rocessed. This is in contrast to offline load shedding, where decisions are made after the whole event sequence has arrived. In this aer we only focus on online CEP load shedding, given the fact that most stream alications demand realtime resonsiveness. In addition, offline load shedding requires the entire event sequence to be buffered, which is not liely to be ractical in real systems. Performance of online algorithms is oftentimes measured against their offline counterarts to develo quality guarantees lie cometitive ratios [2]. However, we show in the 4

5 following that meaningful cometitive ratios cannot be derived for any online CEP load shedding algorithms. PROPOSITION. No online CEP load shedding algorithm, deterministic or randomized, can have cometitive ratio better than (n), where n is the length of the event sequence. The full roof of this roosition can be found in Aendix B. Intuitively, to see why it is hard to bound the cometitive ratio, consider the following adversarial scenario. Suose we have a universe of 2m event tyes, ={E i }[ {Ei 0}, i 2 [,m]. Let there be m queries SEQ(E i,ei 0), 8i 2 [,m], all with unit utility weight. The stream is nown to be (e,e 2,...,e m,), where e i is of tye E i, and is drawn from a uniform distribution on {Ei 0 : i 2 [,m]}. Lastly, suose the system only has enough memory to hold two events. The otimal offline algorithm can loo at the tye of event, denoted by El 0, and ee the corresonding event e l of tye E l that arrived reviously, to roduce a match (E l,el 0 ) of utility of. In comarison, an online algorithm needs to select one event into memory before the event tye of is revealed. Thus, the robability of roducing a match is m, and the exected utility is also m. This result essentially suggests that we cannot hoe to devise online algorithms with good cometitive ratios. Consequently, in what follows, we will focus on otimizing the exected utility of online algorithms without further discussing cometitive ratio bounds. 3.4 odeling CEP systems At a high level, the decision of which event or query to shed should deend on a number of factors, including utility weights, memory/cpu costs, and event arrival rates. Intuitively, the more imortant a query is, the more desirable it is to ee constituent events in memory and roduce results of this query. Similarly the higher the cost is to ee an event or to roduce a query match, the less desirable it is to ee that event or roduce that result. The rate at which events arrive is also imortant, as it determines CPU/memory costs of a query as well as utility it can roduce. In order to study these trade-offs in a rinciled way, we consider the following factors in a CEP system. First, we assume that the utility weight, w i, which measures the imortance of query Q i installed in a CEP system, is rovided as a constant. We also assume that the CPU cost of roducing each result of Q i is a nown constant c i, and the memory cost of storing each event instance of tye E j is also a fixed constant m j. Note that we do not assume uniform memory/cpu costs across different events/queries, because in ractice event tules can be of different sizes. Furthermore, the arrival rate of each event tye E j, denoted by j, is assumed to be nown. This is tyically obtained by samling the arriving stream [7, 42]. Note that characteristics of the underlying stream may change eriodically, so the samling rocedure may be invoed at regular intervals to obtain an u-to-date estimate of event arrival rates. The set of all ossible event tyes E j Event of tye j j The number of arrived events E j in a unit time (event arrival rate) m j The memory cost of eeing each event of tye E j Q The set of query atterns Q i Query attern i Q i The number of event tyes in Q i w i The utility weight associated with Q i n i The number of matches of Q i in a unit time c i The CPU cost of roducing each result for Q i C The total CPU budget The total memory budget x j The binary selection decision of event E j x j The fractional samling decision of event E j y i The selection decision of query Q i y i The fractional samling decision of query Q i The max number of queries that one event tye articiates in f The fraction of memory budget that the largest query consumes d The maximum number of event tyes in any one query Table 2: Summary of the symbols used Aroximation Ratio ILS /( f) [Theorem 4] ILS m (, ) bi-criteria aroximation, for any 2 (loss minimization) (0, ) [Theorem 3] ICLS +, for >0 [Theorem 0] IDLS /( f) [Theorem 2] IDLS m (,, ) tri-criteria aroximation, for (loss minimization) any 2 (0, ) [Theorem ] Relative Aroximation Ratio (see Definition 8) d 2 O 2 (t 2 d +) 2 where t = FLS min min Ej { j m j }, [Theorem 7] FLS (under some assumtions) O! where >d[theorem 8] ( d)! d Absolute Aroximation Ratio (see Definition 7)! ( ( ( d)!d ))-aroximation, where = n o FLS j m min min j d, j, and >dcontrols aroximation accuracy [Theorem 9]. Table 3: Summary of aroximation results Furthermore, we assume that the exected number of matches of Q i over a unit time, denoted by n i, can also be estimated. A simle but inefficient way to estimate n i is to samle the arriving event stream and count the number of matches of Q i in a fixed time eriod. Less exensive alternatives also exist. For examle, in Aendix C, we discuss an analytical way to estimate n i, assuming an indeendent Poisson arrival rocess, which is a standard assumtion in the erformance modeling literature [36]. In this wor we will simly treat n i as nown constants without further studying the orthogonal issue of estimating n i. Lastly, note that since n i here is the exected number of query matches, the utility we maximize is also otimized in an exected sense. In articular, it is not otimized under arbitrary arrival event strings (e.g., an adversarial inut). While considering load shedding in such settings is interesting, Proosition already shows that we cannot hoe to get any meaningful bounds against certain adversarial inuts. The symbols used in this aer are summarized in Table 2, and our main aroximation results are listed in Table 3. 5

6 4. RELATED WORK Load shedding has been recognized as an imortant roblem, and a large body of wor in the stream rocessing literature (e.g., [9, 0, 20, 27, 33, 44, 45, 49, 50]) has been devoted to this roblem. However, existing wor in the context of traditional stream rocessing redominantly considers the equi-join of two streaming relations. This is not directly alicable to CEP joins, where each join oerator tyically involves multi-relational non-equi-join (on time-stams). For examle, the authors in [33] are among the first to study load shedding for equi-joins oerators. They roosed strategies to allocate memory and CPU resources to two joining relations based on arrival rates, so that the number of outut tules roduced can be maximized. Similarly, the wor [20] also studies the roblem of load shedding while maximizing the number of outut tules. It utilizes value distribution of the join columns from the two relations to roduce otimized shedding decisions for tules with different join attribute values. However, the canonical two-relation equi-join studied in traditional stream systems is only a secial case of the multirelational, non-equi-join that dominates CEP systems. In articular, if we view all tules from R (res. S) that have the same join-attribute value v i as a virtual CEP event tye R i (res. S i ), then the traditional stream load shedding roblem is catured as a very secial case of CEP load shedding we consider, where each query has exactly two event tyes (R i and S i ), and there are no overlaing event tyes between queries. Because of this equi-join nature, shedding one event has limited ramification and is intuitively easy to solve (in fact, it is shown to be solvable in [20]). In CEP queries, however, each event tye can join with an arbitrary number of other events, and different queries use overlaing events. This significantly comlicates the otimization roblem and maes CEP load shedding hard. In [0], samling mechanisms are roosed to imlement load shedding for aggregate stream queries (e.g., SU), where the ey technical challenge is to determine, in a given oerator tree, where to lace samling oerators and what samling rates to use, so that query accuracy can be maximized. The wor [45] studies the similar roblem of strategically lacing dro oerator in the oerator tree to otimize utility as defined by QoS grahs. The authors in [44] also consider load shedding by random samling, and roose techniques to allocate memory among multile oerators. The wors described above study load shedding in traditional stream systems. The growing oularity of the new CEP model that focuses on multi-relational non-equi-join calls for another careful loo at the load-shedding roblem in the new context of CEP. 5. EORY-BOUND LOAD SHEDDING Recall that in the memory-bound load shedding, we are given a fixed memory budget, which may be insufficient to hold all data items in memory. The roblem is to select a subset of events to ee in memory, such that the overall utility can be maximized. 5. The integral variant (ILS) In the integral variant of the memory-bound load shedding roblem, a binary decision, denoted by x j, is made for each event tye E j, such that event instances of tye E j are either all selected and et in memory (x j =), or all discarded (x j =0). The event selection decisions in turn determine whether query Q i can be selected (denoted by y i ), because outut of Q i can be roduced only if all constituent event tyes are selected in memory. We formulate the resulting roblem as an otimization roblem as follows. (ILS) max n i w i y i (3) s.t. y i = x j ale (4) Y x j (5) y i,x j 2{0, } (6) The objective function in Equation (3) says that if each query Q i is selected (y i = ), then it yields an exected utility of n i w i (recall that as discussed in Section 3, n i models the exected number of query matches of Q i in a unit time, while w i is the utility weight of each query match). Equation (4) secifies the memory constraint. Since selecting event tye E j into memory consumes memory, where j is the arrival rate of E j and m j is the memory cost of each event instance of E j, Equation (4) guarantees that total memory consumtion does not exceed the memory budget. Equation (5) ensures that Q i can be roduced if and only if all articiating events E j are selected and reserved in memory (x j =, for all E j 2 Q i ). 5.. A general comlexity analysis We first give a general comlexity analysis. We show that this shedding roblem is NP-hard and hard to aroximate by a reduction from the Densest -Sub-Hyergrah (DKSH). THEORE. The roblem of utility maximizing integral memory-bound load shedding (ILS) is NP-hard. The roof of the theorem can be found in Aendix D. We show in the following that ILS is also hard to aroximate. THEORE 2. The roblem of ILS with n event tyes cannot be aroximated within a factor of 2 (log n), for some >0, unless 3SAT 2 DTIE(2 n3/4+ ). This result is obtained by observing that the reduction from DKSH is aroximation-reserving. Utilizing an inaroximability result in [30], we obtain the theorem above (the roof is in Aendix E). It is worth noting that DKSH and related roblems are conjectured to be very hard roblems with even stronger inaroximability than what was roved in [30]. For examle, authors in [24] conjectured that aximum Balanced 6

7 Comlete Biartite Subgrah (BCBS) is n hard to aroximate. If this is the case, utilizing a reduction from BCBS to DKSH [30], DKSH would be at least n hard to aroximate, which in turn renders ILS n hard to aroximate given our reduction from DKSH. While it is hard to solve or aroximate ILS efficiently in general, in the following sections we loo at constraints that may aly to real-world CEP systems, and investigate secial cases that enable us to aroximate or even solve ILS efficiently A general bi-criteria aroximation We reformulate the integral memory-bound roblem into an alternative otimization roblem (ILS l ) with linear constraints as follows. (ILS l ) max n i w i y i (7) s.t. x j ale y i ale x j, 8E j 2 Q i (8) y i,x j 2{0, } Observing that Equation (5) in ILS is essentially morhed into an equivalent Equation (8). These two constraints are equivalent because y i,x j are all binary variables, y i will be forced to 0 if there exists x j =0with E j 2 Q i. Instead of maximizing utility, we consider the alternative objective of minimizing utility loss as follows. Set ŷ i = y i be the comlement of y i, which indicates whether query Q i is un-selected. We can change the utility gain maximization ILS l into a utility loss minimization roblem ILS m. Note that utility gain is maximized if and only if utility loss is minimized. (ILS m ) min n i w i ŷ i (9) s.t. x j ale ŷ i x j, 8E j 2 Q i (0) ŷ i,x j 2{0, } () In ILS m Equation (0) is obtained by using ŷ i = y i and Equation (8). Using this new minimization roblem with linear structure, we rove a bi-criteria aroximation result. Let OPT be the otimal loss with budget in a loss minimization roblem, then an (, )-bi-criteria aroximation guarantees that its solution has at most OPT loss, while uses no more than budget. Bicriteria aroximations have been extensively used in the context of resource augmentation (e.g., see [43] and references therein), where the algorithm is augmented with extra resources and the benchmar is an otimal solution without augmentation. THEORE 3. The roblem of ILS m admits a (, ) bi-criteria-aroximation, for any 2 [0, ]. For concreteness, suose we set = 2. Then this result states that we can efficiently find a strategy that incurs at most 2 times the otimal utility loss with budget, while using no more than 2 memory budget. PROOF. Given a arameter, we construct an event selection strategy as follows. First we dro the integrality constraint of ILS m to obtain its LP-relaxation. We solve the relaxed roblem to get an otimal fractional solutions x j and ŷi Ẇe can then divide queries Q into two sets, Q a = {Q i 2 Q ŷi ale } and Qr = {Q i 2Q ŷi > }. Since ŷ i denotes whether query Q i is un-selected, intuitively a smaller value means the query is more liely to be acceted. We can accordingly view Q a as the set of romising queries, and Q r as unromising queries. The algorithm wors as follows. It reserves every query with ŷi ale, by selecting constituent events of Q i into memory. So the set of query in Q a is all acceted, while Q r is all rejected. We first show that the memory consumtion is no more than. From Equation (0), we now the fractional solutions must satisfy x j ŷ i, 8E j 2 Q i (2) In addition, we have ŷ i ale,8q i 2Q a. So we conclude x j,8q i 2Q a,e j 2 Q i (3) Since we now x j are fractional solutions to ILSm, we have m j j x j ale m j j x j = (4) E j2q a E j2q a [Q r Here we slightly abuse the notation and use E j 2Q a to denote that there exists a query Q 2Q a such that E j 2 Q. Combining (3) and (4), we have E j2q a m j j ( ) ale Notice that P E m j2q a j j is the total memory consumtion of our rounding algorithm, we have m j j ale E j2q a Thus total memory consumtion cannot exceed. We then need to show that the utility loss is bounded by a factor of. Denote the otimal loss of ILSm as l, and the otimal loss with LP-relaxation as l. We then have l ale l because any feasible solution to ILS m is also feasible to the LP-relaxation of ILS m. In addition, we now n i w i ŷi ale n i w i ŷi = l ale l r a [Q r So we can obtain r n i w i ŷ i ale l (5) 7

8 Based on the way queries are selected, we now for every rejected query ŷ i,8q i 2Q r (6) Combining (5) and (6), we get r n i w i ale l Observing that P Q n i2q iw r i is the utility loss of the algorithm, we conclude that n i w i ale l r This bounds the utility loss from otimal l by a factor of, thus comleting the roof. Note that since our roof is constructive, this gives an LPrelaxation based algorithm to achieve (, ) bi-criteriaaroximation of utility loss An aroximable secial case Given that memory is tyically reasonably abundant in today s hardware setu, in this section we will assume that the available memory caacity is large enough such that it can hold at least a few number of queries. If we set f = max Qi PE j 2Q i m j j to be the ratio between the memory requirement of the largest query and available memory. We now if is large enough, then each query uses no more than f memory, for some f<. In addition, denote by = max j {Q i E j 2 Q i,q i 2 Q} as the maximum number of queries that one event tye articiates in. We note that in ractice there are roblems in which each event articiates in a limited number of queries. In such cases will be limited to a small constant. Assuming both and f are some fixed constants, we obtain the following aroximation result. THEORE 4. Let be the maximum number of queries that one event can articiate in, and f be the ratio between the size of the largest query and the memory budget defined above, ILS admits a f -aroximation. The idea here is to leverage the fact that the maximum query-articiation is a constant to simlify the memory consumtion constraint, so that a nasac heuristic yields utility guarantees. In the interest of sace we resent the full roof of this theorem in Aendix F A seudo-olynomial-time solvable secial case We further consider the multi-tenant case where multile CEP alications are consolidated into one single server or into one cloud infrastructure where the same set of underlying comuting resources is shared across alications. In this multi-tenancy scenario, since different CEP alications are interested in different asects of real-world event occurrences, there tyically is no or very limited sharing of events across different alications (the hosital hygiene system HyReminder and hosital inventory management system CIS as mentioned in the Introduction, for examle, have no event tyes in common. So do a networ intrusion detection alication and a financial alication co-located in the same cloud). Using a hyer-grah model, a multi-tenant CEP system can be reresented as a hyer-grah H, where each event tye is reresented as a vertex and each query as a hyer-edge. If there is no sharing of event tyes among CEP alications, then each connected comonent of H corresonds to one CEP alication. Let be the size of the largest connected comonent of H, then is essentially the maximum number of event tyes used in any one CEP alication, which may be limited to a small constant (the total number of event tyes across multile CEP alications is not limited). Assuming this is the case, we have the following secial case that is seudoolynomial time solvable. THEORE 5. In a multi-tenant CEP system where each CEP tenant uses a disjoint set of event tyes, if each CEP tenant uses no more than event tyes, the roblem of ILS can be solved in time O( Q 2 2 ). Our roof utilizes a dynamic rogramming aroach develoed for Set-union Knasac roblem [28]. The full roof of this theorem can be found in Aendix G. We note that we do not assume the total number of event tyes across multile CEP tenants to be limited. In fact, the running time grows linearly with the total number of event tyes and queries across all CEP tenants. Lastly, we observe that the requirement that events in each CEP tenant are disjoint can be relaxed. As long as the sharing of event tyes between different CEP tenants are limited, such that the size of the largest comonent of H mentioned above is bounded by, the result in Theorem 5 holds. 5.2 The fractional variant (FLS) In this section, we consider the fractional variant of the memory-bound load shedding roblem. In this variant, instead of taing an all-or-nothing aroach to either include or exclude all event instances of certain tyes in memory, we use a random samling oerator [32], which samles some arriving events uniformly at random into the memory. Denote by x j 2 [0, ] the samling robability for each event tye E j. The fractional variant memory-bound load shedding (FLS) can be written as follows. (FLS) max n i w i y i (7) s.t. y i = x j ale (8) Y x j (9) 0 ale x j ale (20) 8

9 The integrality constraints are essentially droed from the integral version of the roblem, and are relaced by constraints in (20). We use fractional samling variables x j and y i to differentiate from binary variables x j,y i. Note that Equation (9) states that the robability that a query result is roduced, y i, is the cross-roduct of samling rates of constituent events since each event is samled randomly and indeendently of each other A general comlexity analysis In the FLS formulation, if we fold Equation (9) into the objective function in (7), we obtain max Y n i w i x j (2) This maes FLS a olynomial otimization roblem subject to a nasac constraint (8). Since we are maximizing the objective function in Equation (2), it is well nown that if the function is concave, then convex otimization techniques [4] can be used to solve such roblems otimally. However, we show that excet the trivial case where each query has exactly one event (i.e., (2) becomes linear), in general Equation (2) is not concave. LEA. If the objective function in Equation (2) is non-trivial (that is, at least one query has more than one event), then (2) is non-concave. We show the full roof of Lemma in Aendix H in the interest of sace. Given this non-concavity result, it is unliely that we can hoe to exloit secial structures of the Hessian matrix to solve FLS. In articular, convex otimization techniques lie KKT conditions or gradient descent [4] can only rovide local otimal solutions, which may be far away from the global otimal. On the other hand, while the general olynomial rogram is nown to be hard to solve [, 46], FLS is a secial case where all coefficients are ositive, and the constraint is a simle nasac constraint. Thus the hardness results in [, 46] do not aly to FLS. We show the hardness of FLS by using the otzin-straus theorem [39] and a reduction from the Clique roblem. THEORE 6. The roblem of fractional memory-bound load shedding (FLS) is NP-hard. FLS remains NP-hard even if each query has exactly two events. The full roof of this theorem can be found in Aendix I. So desite the continuous relaxation of the decision variables of ILS, FLS is still hard to solve. However, in the following we show that FLS has secial structure that allows it to be solved aroximately under fairly general assumtions Definitions of aroximation We will first describe two definitions of aroximation commonly used in the numerical otimization literature. The first definition is similar to the aroximation ratio used in combinatorial otimization. DEFINITION 7. [3] Given a maximization roblem P that has maximum value v max (P ) > 0. We say a olynomial time algorithm has an absolute aroximation ratio 2 [0, ], if the value found by the algorithm, v(p ), satisfies v max (P ) v(p ) ale v max (P ). The second notion of relative aroximation ratio is widely used in the otimization literature [22, 3, 4, 46]. DEFINITION 8. [3] Given a maximization roblem P that has maximum value v max (P ) and minimum value v min (P ). We say a olynomial time algorithm has a relative aroximation ratio 2 [0, ], if the value found by the algorithm, v(p ), satisfies v max (P ) v(p ) ale (v max (P ) v min (P )). Relative aroximation ratio is used to bound the quality of solutions relative to the ossible value range of the function. We refer to this as -relative-aroximation to differentiate from -aroximation used Definition 7. Note that in both cases, indicates the size of the ga between an aroximate solution and the otimal value. So smaller values are desirable in both definitions Results for relative aroximation bound In general, the feasible region secified in FLS is the intersection of a unit hyer-cube, and the region below a scaled simlex. We first normalize (8) in FLS using a change of variables. Let x 0 j = jmjxj be the scaled variables. We can obtain the following formulation FLS. (FLS ) max Y n i w i s.t. x 0 j (22) x 0 j = (23) 0 ale x 0 j ale j m j (24) Note that the inequality constraint (8) in FLS is now relaced by an equality constraint (23) in FLS. This will not change the otimal value of FLS as long as P E j (otherwise, although P x0 j =is unattainable, the memory budget becomes sufficient and the otimal solution is trivial). This is because all coefficients in (7) are ositive, ushing any x i to a larger value will not hurt the objective value. Since the constraint (8) is active for at least one global otimal oint in FLS, changing the inequality in the nasac constraint to an equality in (23) will not change the otimal value. Denote by d = max{ Q i } the maximum number of event tyes in a query. We will assume in this section that d is a fixed constant. Note that this is a fairly realistic assumtion, as d tends to be very small in ractice (in HyReminder [48], for examle, the longest query has 6 event tyes, so d =6). Observe that d essentially corresonds to the degree of the olynomial in the objective function (22). 9

10 An aroximation using co-centric balls. Using a randomized rocedure from the otimization literature [3], we show that FLS can be aroximated by bounding the feasible region using two co-centric balls to obtain a (loose) relative-aroximation ratio as follows. THEORE 7. The roblem of FLS admits a relative d 2 O 2 (t 2 + ) d 2 aroximation-ratio, where = and t =min min Ej,. The roof of this result can be found in Aendix J. Note that this is a general result that only rovides a loose relative aroximation bound, which is a function of the degree of the olynomial d, the number of event tyes, and jmj, and cannot be adjusted to a desirable level of accuracy. An aroximation using simlex. We observe that the feasible region defined in FLS has secial structure. It is a subset of a simlex, which is the intersection between a standard simlex (Equation (23)) and box constraints (Equation (24)). There exists techniques that roduces relative aroximations for olynomials defined over simlex. For examle, [22] uses a grid-based aroximation technique, where the idea is to fit a uniform grid into the simlex, so that values on all nodes of the grid are comuted and the best value is iced as an aroximate solution. Let n be an n dimensional simlex, then (x 2 n x 2 Z+) n is defined as a -grid over the simlex. The quality of aroximation is determined by the granularity the uniform grid: the finer the grid, the tighter the aroximation bound is. The result in [22], however, does not aly here because the feasible region of FLS reresents a subset of the standard simlex. We note that there exist a secial case where if, 8j (that is, if the memory requirement of a single event tye exceeds the memory caacity), the feasible region degenerates to a simlex, such that we can use grid-based technique for aroximation. THEORE 8. In FLS, if for all j we have then the roblem admits a relative aroximation ratio of, where! = O ( d)! d for any 2 Z + such that > d. Here reresents the number of grid oints along one dimension. Note that as!, aroximation ratio! 0. The full roof of this result can be found in Aendix K. This result can rovide increasingly accurate relative aroximation bound for a larger. It can be shown that for a given, a total of + number of evaluations of the objective function is needed Results for absolute aroximation bound Results obtained so far use the notion of relative aroximation (Definition 8). In this section we discuss a secial case in which FLS can be aroximated relative to the otimal value (Definition 7). We consider a secial case in which queries are regular with no reeated events. That is, in each query, no events of the same tye occur more than once (e.g., query SEQ(A,B,C) is a query without reeated events while SEQ(A,B,A) is not because event A aears twice). This may be a fairly general assumtion, as queries tyically detect events of different tyes. HyReminder [48] queries, for instance, use no reeated events in the same query (two such examle Q and Q2 are given in the Introduction). In addition, we require that each query has the same length as measured by the number of events. With the assumtion above, the objective function Equation (22) becomes a homogeneous multi-linear olynomial, while the feasible region is defined over a sub-simlex that is the intersection of a cube and a standard simlex. We extend a random-wal based argument in [4] from standard simlex to the sub-simlex, and show an (absolute) aroximation bound. THEORE 9. In FLS, if s are fixed constants, in addition if every query has no reeated event tyes and is of same query length, d, then a constant-factor aroximation can be obtained for FLS in olynomial time. In articular, we can achieve a ( ( ))-aroximation,! ( d)! d + by evaluating Equation (2) at most times, where jm =min min j d, j, and >dis a arameter that controls aroximation accuracy. A roof of Theorem 9 can be found in Aendix L. We use a scaling method to extend the random-wal argument to the sub-simlex in order to get the desirable constant factor aroximation. Note that, by selecting = O(d 2 ) we can! jm get close to. Also note that if j ( d)! d for all j, =and we can get an aroximation arbitrarily close to the otimal value by using large. 6. CPU-BOUND LOAD SHEDDING In this section we consider the scenario where memory is abundant, while CPU becomes the limiting resource that needs to be budgeted aroriately. CPU-bound roblems turn out to be easy to solve. 6. The integral variant (ICLS) In the integral variant CPU load shedding, we again use binary variables y i to denote whether results of Q i can be generated. For each query Q i, at most n i number of query matches can be roduced. Assuming the utility weight of each result is w i, and the CPU cost of roducing each result is c i, when Q i is selected (y i =) a total of n i w i utility can be roduced, at the same time a total of n i c i CPU resources are consumed. That yields the following ICLS roblem. 0