telegraphcq n.
Skip this Video
Loading SlideShow in 5 Seconds..
TelegraphCQ PowerPoint Presentation
Download Presentation

Loading in 2 Seconds...

play fullscreen
1 / 31

TelegraphCQ - PowerPoint PPT Presentation

Download Presentation
An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. TelegraphCQ 49221052 施賀傑 69521041 何承恩

  2. Outline • Introduction • Data Movement Implies Adaptivity • Telegraph - an Ancestor of TelegraphCQ • Adaptive Building Blocks • Initial CQ Approaches • TelegraphCQ • Conclusion and Future Work

  3. TelegraphCQ • Window Semantics in TelegraphCQ • Windows for Input Streams • Effect of Window Semantics on System Design • TelegraphCQ Design Overview • Approach • The TelegraphCQ Executor • Ingress Operators • Using TelegraphCQ

  4. Window Semantics in TelegraphCQ • TelegraphCQ supports continuous queries over a combination of tables and data streams. To deal with data streams whose length is unbounded, certain operations, such as joins, can only be run over finite windows on these streams.

  5. Windows for Input Streams • Landmark – The older end of the window is fixed, while the newer end of the window moves forward with the arrival of new tuples in the stream • Sliding – Both the ends move forward in unison with the arrival of new tuples

  6. Windows for Input Streams • This isdone using a for-loop construct to declare the sequence ofwindows over which the user desires the answers to thequery: a variable “t” moves over the timeline as the forloopiterates, and the left and right ends (inclusive) of eachwindow in the sequence, and the stopping condition for thequery can be defined with respect to this variable "t".

  7. Windows for Input Streams • We assume that the stream starts with logicaltimestamp 1. There is one entry for every trading day forevery stock symbol. For simplicity, we assume thatMicrosoft (MSFT) has been trading since the beginning ofthe stream.

  8. Windows for Input Streams • Example of Landmark query • Select all the days after the hundredth trading day, on which the closing price of MSFT has been greater than $50. Keep this query standing in the system for a thousand trading days

  9. Windows for Input Streams • Example of Sliding query • On every fifth trading day starting today, calculate the average closing price of MSFT for the five most recent trading days. Keep the query standing for fifty trading days.(note: ST = the start time of the query.)

  10. Windows for Input Streams • Exercise • For the five most recent trading days starting today, select all stocks that closed higher than MSFT on a given day. Keep the query standing for twenty trading days.

  11. Effect of Window Semantics on System Design • Logical time vs. physical time(count VS clock) • the type of window used in a query(such as MAX) • “Hop” size(the distance between consecutive windows defined by the for loop)also have significant impact on query execution. • For instance, if the hop size of the window exceeds the size of the window itself, then some portions of the stream are never involved in the processing of the query.

  12. TelegraphCQ Design Overview • Approach • In the Telegraph project, we built a system for adaptive dataflow processing in Java . Although our research on adaptivity and sharing showed significant benefits, our experience in using Java in a systems development project was not positive . After considering a few alternatives, we decided to use the PostgreSQL open source database system as a starting point for our new implementation. • Building on these initial prototypes, we have embarked on a complete redesign and reimplementation of our system, with a focus on support for shared, continuous query processing over query and data streams.

  13. TelegraphCQ Design Overview

  14. TelegraphCQ Design Overview • Chief Challenge in using PostgreSQL is supporting the TelegraphCQ features it was not designed for: • Streaming data • Continuous queries • Shared processing • Adaptivity • Another major issue is that PostgreSQL’s process-per-connection model implementation is not thread-safe, while for performance reasons, multithreading is an important feature of the TelegraphCQ design.

  15. TelegraphCQ Design Overview

  16. TelegraphCQ Design Overview The TelegraphCQ Executor

  17. TelegraphCQ Design Overview • The TelegraphCQ Executor • A key challenge in designing the new executor is the mapping of our shared continuous processing model onto a thread structure that will allow for adaptivity while incurring minimal overhead. • We expect to support large numbers of active, standing queries, so we need to avoid the overhead associated with making each query a separate thread yet we need multiple threads in order to exploit SMP and cluster parallelism. • TelegraphCQ executor is being developed using a multi-threaded approach in which the threads provide execution context for multiple queries encoded using a non-preemptive, state machine-based programming model. • Execution Object • An EO consists of a scheduler, one or more event queues, and a set of non-preemptive Dispatch Units (DUs) that can be executed based on some scheduling policy.

  18. TelegraphCQ Design Overview • Dispatch Units • Unlike EOs, which are visible to the operating system, DUs are merely abstractions that represent entities that perform “work” in the system. • A DU can be run in one of the following modes: • 1. A single “traditional” PostgreSQL query plan with the standard query executor. • 2. A single-Eddy query plan with Fjord-style operators. • 3. A shared “continuous query” mode with an Eddy and Fjord-style operators.

  19. TelegraphCQ Design Overview • A key design decision in the executor is how to map queries onto the model of preemptively scheduled EO system threads containing non-preemptive DUs. • The goal is to separate queries into classes that have significant potential for sharing work. • This determination is made based on the set of streams and tables over which the queries are defined, which we call the query footprint.

  20. TelegraphCQ Design Overview Using s Q1:select * from s Q3:select * from s Q1:select * from s Q2:select * from t Q3:select * from s Using t Q2:select * from t

  21. TelegraphCQ Design Overview Ingress Operators

  22. TelegraphCQ Design Overview • Ingress Operators • Wrapper mechanism that allows data to be streamed into the system. • Two types of sources are supported • Pull sources, as found in “traditional” federated database systems. • Push sources, where connections can be initiated either by the Wrapper (Push-client) or by the data source itself (Push-server). • With pull and push-client sources the Wrapper connects to the source. In contrast, push-server sources connect to a well-known port served by the Wrapper process. • Tuples in buffer pool pages are accessed via a “scanner” operator, which is similar to the standard scan operators in classic systems, except that it is driven by window descriptors.

  23. Using TelegraphCQ • Creating archived and unarchived streams. • Creating sources that stream data to TelegraphCQ. • Creating user-defined wrappers. • Issuing continuous queries.

  24. Using TelegraphCQ • Creating streams • CREATE STREAM and DROP STREAM • A requirement in defining a stream is that there must exist exactly one column of a time type which serves as a timestamp for the stream. • Example: an archived stream of readings of average speeds measured by traffic sensor stations in freeways may

  25. Using TelegraphCQ • Creating sources • TelegraphCQ expects that a data source will initiate a network connection with it and advertise the name of the stream for which it undertakes to provide data.

  26. Using TelegraphCQ • Creating wrappers • Each wrapper consists of three user-defined functions (init, next and done) that are called by TelegraphCQ to process data from external sources. • The functions are registered in TelegraphCQ using the standard PostgreSQL CREATE FUNCTION statement. • For example: the init function of the measurements wrapper should be named measurements init and can be declared using the following DDL

  27. Using TelegraphCQ • Continuous queries • Once streams have been created in the system, users can issue long-running continuous queries over them. • The queries can be simple SQL queries (without subqueries) with an optional window clause. • The window clause serves to restrict the amount of data that participates in the query over time. • The query continually reports average speeds recorded by each station in a sliding 10 minute window

  28. Using TelegraphCQ • These queries can be submitted to TelegraphCQ using psql, the interactive client. • Other programmatic interfaces such ODBC and JDBC can also be used, but the applications using those must submit continuous queries by declaring named cursors.

  29. Conclusion and Future Work • In this paper we have described our ongoing implementation of the next generation Telegraph system, called TelegraphCQ. • TelegraphCQ differs from other data stream and CQ projects due to its focus on extreme adaptivity and the novel infrastructure required to support such adaptivity. • TelegraphCQ is very much a work in progress, and we are actively working on adding more features to the system. As part of this effort, we are addressing a number of open questions that have arisen.

  30. Conclusion and Future Work • Query Grouping and Sharing • An open issue is determining how much overlap is required to group a new query into an existing execution object. • Adaptive adaptivity • batching tuples & fixing operator • Storage system and QoS • Queries accessing data that spans memory and disk also raise significant Quality of Service issues, in terms of deciding what work to drop when the system is in danger of falling behind the incoming data stream.

  31. Conclusion and Future Work • Interactions between continuous and historical queries • In future we plan to support historical queries by running them separately, say in the TCQ Front End process. • Scalability and Availability • The Flux operator is designed to enhance TelegraphCQ with partitioned parallelism, adaptive load-balancing, high availability and fault tolerance. • Signal/noise streams • To handle overload situations, a number of research groups are considering schemes that downsample (drop) or synopsize (lossily compress) items in a stream.