Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

[scheduling] implement backtracking of intermediate results #640

Closed
wants to merge 2 commits into from

Conversation

mxm
Copy link
Contributor

@mxm mxm commented Apr 29, 2015

For batch programs, we currently schedule all tasks which are sources
and let them kick off the execution of the connected tasks. This
approach bears some problems when executing large dataflows with many
branches. With backtracking, we traverse the execution graph
output-centrically (from the sinks) in a depth-first manner. This
enables us to use resources differently.

In the course of backtracking, only tasks will be executed that are
required to supply inputs to the current task. When a job is newly
submitted, this means that the backtracking will reach the
sources. When the job has been previously executed and intermediate
results are available, old ResultPartitions to resume from can be
requested while backtracking.

Backtracking is disabled by default. It can be enabled by setting the
ScheduleMode in JobGraph to BACKTRACKING.

CHANGELOG

  • new scheduling mode: backtracking
  • backtracks from the sinks of an ExecutionGraph
  • checks the availability of IntermediatePartitionResults
  • marks ExecutionVertex to be scheduled
  • caches ResultPartitions and reloads them
  • resumes from intermediate results
  • test for general behavior of backtracking (BacktrackingTest)
  • test for resuming from an intermediate result (ResumeITCase)
  • test for releasing of cached ResultPartitions (ResultPartitionManagerTest)
  • allow multiple consumers per blocking intermediate result (batch)

if (visitedPartition) {
availableInputs++;
}
pendingInputs.remove(ir);
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

As far as I know, it's unsafe to modify a collection while iterating over it if you don't use the remove method of the iterator directly.

Quote from JavaDoc: Iterator.remove() "The behavior of an iterator is unspecified if the underlying collection is modified while the iteration is in progress in any way other than by calling this method."

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

You're right, that's not good practice. I changed that.

@mxm mxm force-pushed the backtracking-scheduling-dev branch 2 times, most recently from 4d17eff to c036c1a Compare April 30, 2015 14:05
);

/** BEGIN Asynchronous callback **/
future.onComplete(new OnComplete<Object>() {
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's an asynchronous callback but what we're effectively doing is to execute the LockResultPartition for each producer sequentially, right? This can take for large degrees of parallelism quite some time because it is dop * lockTime instead of lockTime if we executed the LockResultPartition in parallel.

Why not doing all the LockResultPartition calls in parallel?

Copy link
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The callback is asynchronous, to prevent the job manager from blocking or waiting in the dispatcher threads. You are right that the locking would be faster to execute in parallel. To not having to deal with the concurrency related issues, I chose not to implement it in parallel. If I think about it now, it is probably not too hard to change that.

@mxm mxm force-pushed the backtracking-scheduling-dev branch from c036c1a to 4b615b2 Compare April 30, 2015 14:19
@tillrohrmann
Copy link
Contributor

The backtracking looks good @mxm.

I have some remarks concerning the way the locking of the partition on the TMs works. At the moment this happens sequentially, meaning that for each IntermediateResultPartition a message is sent to the TM and then the response is awaited. Only after receiving the response of this TM, the next IntermediateResultPartition is processed. This can considerably slow down the scheduling if the degree of parallelism is high. I think we should make use of Akka's future composition to do that concurrently.

Furthermore, we could think about doing the backtracking in parallel. This could also speed up the scheduling process.

@mxm
Copy link
Contributor Author

mxm commented Apr 30, 2015

Thank you for your valuable comments @tillrohrmann. I haven't worked with Akka's future compositions but it seems a sophisticated way to parallelize and combine the actor replies.

@mxm mxm force-pushed the backtracking-scheduling-dev branch from 4b615b2 to d5f678d Compare April 30, 2015 16:40
@mxm mxm force-pushed the backtracking-scheduling-dev branch from d5f678d to 11e9b12 Compare May 11, 2015 11:41
@mxm mxm force-pushed the backtracking-scheduling-dev branch 2 times, most recently from 168e5d7 to bdd78e5 Compare May 12, 2015 12:48
For batch programs, we currently schedule all tasks which are sources
and let them kick off the execution of the connected tasks. This
approach bears some problems when executing large dataflows with many
branches. With backtracking, we traverse the execution graph
output-centrically (from the sinks) in a depth-first manner. This
enables us to use resources differently.

In the course of backtracking, only tasks will be executed that are
required to supply inputs to the current task. When a job is newly
submitted, this means that the backtracking will reach the
sources. When the job has been previously executed and intermediate
results are available, old ResultPartitions to resume from can be
requested while backtracking.

Backtracking is disabled by default. It can be enabled by setting the
ScheduleMode in JobGraph to BACKTRACKING.

CHANGELOG
- new scheduling mode: backtracking
- backtracks from the sinks of an ExecutionGraph
- checks the availability of IntermediatePartitionResults
- marks ExecutionVertex to be scheduled
- caches ResultPartitions and reloads them
- resumes from intermediate results
- test for general behavior of backtracking (BacktrackingTest)
- test for resuming from an intermediate result (ResumeITCase)
- test for releasing of cached ResultPartitions (ResultPartitionManagerTest)
- allow multiple consumers per blocking intermediate result (batch)
@mxm mxm force-pushed the backtracking-scheduling-dev branch from bdd78e5 to 81c0078 Compare May 12, 2015 12:51
mxm added a commit to mxm/flink that referenced this pull request May 15, 2015
This pull request implements a rudimentary session management. Together with the backtracking apache#640, this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

ExecutionGraphs are kept as long as
- no timeout occurred or
- the session has not been explicitly ended
mxm added a commit to mxm/flink that referenced this pull request May 16, 2015
This pull request implements a rudimentary session management. Together with the backtracking apache#640, this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

ExecutionGraphs are kept as long as
- no timeout occurred or
- the session has not been explicitly ended
mxm added a commit to mxm/flink that referenced this pull request May 16, 2015
This pull request implements a rudimentary session management. Together with the backtracking apache#640, this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

ExecutionGraphs are kept as long as
- no timeout occurred or
- the session has not been explicitly ended
mxm added a commit to mxm/flink that referenced this pull request May 18, 2015
This pull request implements a rudimentary session management. Together with the backtracking apache#640, this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

ExecutionGraphs are kept as long as
- no timeout occurred or
- the session has not been explicitly ended
mxm added a commit to mxm/flink that referenced this pull request May 21, 2015
This pull request implements a rudimentary session management. Together with the backtracking apache#640, this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

ExecutionGraphs are kept as long as
- no timeout occurred or
- the session has not been explicitly ended

session test

WIP
mxm added a commit to mxm/flink that referenced this pull request May 22, 2015
This pull request implements a rudimentary session management. Together with the backtracking apache#640, this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

ExecutionGraphs are kept as long as
- no timeout occurred or
- the session has not been explicitly ended

session test

WIP
mxm added a commit to mxm/flink that referenced this pull request May 22, 2015
This pull request implements a rudimentary session management. Together with the backtracking apache#640, this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

ExecutionGraphs are kept as long as
- no timeout occurred or
- the session has not been explicitly ended
public final Table<ExecutionAttemptID, IntermediateResultPartitionID, ResultPartition>
registeredPartitions = HashBasedTable.create();

/**
* Cached ResultPartitions which are used to resume/recover from
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Let's add a comment that the LinkedHashMap implements a LRU policy.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

There are two unused classes LRUCache and LRUCacheMap, which can be removed. I think this solution is fine. :)

mxm added a commit to mxm/flink that referenced this pull request Jun 19, 2015
Sessions make sure that the JobManager does not immediately discard a JobGraph after execution, but keeps it
around for further operations to be attached to the graph. That is the basis if interactive sessions.

This pull request implements a rudimentary session management. Together with the backtracking apache#640,
this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

ExecutionGraphs are kept as long as
- no timeout occurred or
- the session has not been explicitly ended
mxm added a commit to mxm/flink that referenced this pull request Jun 24, 2015
Sessions make sure that the JobManager does not immediately discard a JobGraph after execution, but keeps it
around for further operations to be attached to the graph. That is the basis if interactive sessions.

This pull request implements a rudimentary session management. Together with the backtracking apache#640,
this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

ExecutionGraphs are kept as long as
- no timeout occurred or
- the session has not been explicitly ended
mxm added a commit to mxm/flink that referenced this pull request Sep 7, 2015
commit ceb2d57
Author: Maximilian Michels <[email protected]>
Date:   Thu Jun 18 16:38:09 2015 +0200

    [FLINK-2097] [core] Finalize session management

commit 30f78f0
Author: Stephan Ewen <[email protected]>
Date:   Fri May 29 14:35:33 2015 +0200

    [FLINK-2097] [core] Improve session management.

     - The Client manages only connections to the JobManager, it is not job specific
     - Executors provide a more explicit life cycle and methods to start new sessions
     - Sessions are handled by the environments
     - The environments use reapers (local) and shutdown hooks (remote) to ensure session termination
       when the environment runs out of scope

commit b6bb34e
Author: Maximilian Michels <[email protected]>
Date:   Wed May 13 17:06:47 2015 +0200

    [FLINK-2097] [core] Implement job session management.

    Sessions make sure that the JobManager does not immediately discard a JobGraph after execution, but keeps it
    around for further operations to be attached to the graph. That is the basis if interactive sessions.

    This pull request implements a rudimentary session management. Together with the backtracking apache#640,
    this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

    ExecutionGraphs are kept as long as
    - no timeout occurred or
    - the session has not been explicitly ended
mxm added a commit to mxm/flink that referenced this pull request Sep 7, 2015
commit ceb2d57
Author: Maximilian Michels <[email protected]>
Date:   Thu Jun 18 16:38:09 2015 +0200

    [FLINK-2097] [core] Finalize session management

commit 30f78f0
Author: Stephan Ewen <[email protected]>
Date:   Fri May 29 14:35:33 2015 +0200

    [FLINK-2097] [core] Improve session management.

     - The Client manages only connections to the JobManager, it is not job specific
     - Executors provide a more explicit life cycle and methods to start new sessions
     - Sessions are handled by the environments
     - The environments use reapers (local) and shutdown hooks (remote) to ensure session termination
       when the environment runs out of scope

commit b6bb34e
Author: Maximilian Michels <[email protected]>
Date:   Wed May 13 17:06:47 2015 +0200

    [FLINK-2097] [core] Implement job session management.

    Sessions make sure that the JobManager does not immediately discard a JobGraph after execution, but keeps it
    around for further operations to be attached to the graph. That is the basis if interactive sessions.

    This pull request implements a rudimentary session management. Together with the backtracking apache#640,
    this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

    ExecutionGraphs are kept as long as
    - no timeout occurred or
    - the session has not been explicitly ended
mxm added a commit to mxm/flink that referenced this pull request Sep 8, 2015
ui

jo

commit ceb2d57
Author: Maximilian Michels <[email protected]>
Date:   Thu Jun 18 16:38:09 2015 +0200

    [FLINK-2097] [core] Finalize session management

commit 30f78f0
Author: Stephan Ewen <[email protected]>
Date:   Fri May 29 14:35:33 2015 +0200

    [FLINK-2097] [core] Improve session management.

     - The Client manages only connections to the JobManager, it is not job specific
     - Executors provide a more explicit life cycle and methods to start new sessions
     - Sessions are handled by the environments
     - The environments use reapers (local) and shutdown hooks (remote) to ensure session termination
       when the environment runs out of scope

commit b6bb34e
Author: Maximilian Michels <[email protected]>
Date:   Wed May 13 17:06:47 2015 +0200

    [FLINK-2097] [core] Implement job session management.

    Sessions make sure that the JobManager does not immediately discard a JobGraph after execution, but keeps it
    around for further operations to be attached to the graph. That is the basis if interactive sessions.

    This pull request implements a rudimentary session management. Together with the backtracking apache#640,
    this will enable users to submit jobs to the cluster and access intermediate results. Session handling ensures that the results are cleared eventually.

    ExecutionGraphs are kept as long as
    - no timeout occurred or
    - the session has not been explicitly ended

major

fix

next

ok

OK

ok

ok3

bla

ok
mxm added a commit to mxm/flink that referenced this pull request Sep 8, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 8, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 9, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 9, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 9, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 9, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 10, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 10, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 15, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 15, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 15, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 21, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 21, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
mxm added a commit to mxm/flink that referenced this pull request Sep 22, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
nikste pushed a commit to nikste/flink that referenced this pull request Sep 29, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
lofifnc pushed a commit to lofifnc/flink that referenced this pull request Oct 8, 2015
Sessions make sure that the JobManager does not immediately discard a
JobGraph after execution, but keeps it around for further operations to
be attached to the graph. That is the basis for interactive sessions.

This pull request implements a rudimentary session management. Together
with the backtracking apache#640, this will enable users to submit jobs to the
cluster and access intermediate results. Session handling ensures that
the results are cleared eventually.

ExecutionGraphs are kept as long as
  - no timeout occurred or
  - the session has not been explicitly ended

The following changes have also been made in this pull request:

- The Job ID is created through the ExecutionEnvironment and passed through

- Sessions can be termined by the ExecutionEnvironment or directly
  through the executor

- The environments use reapers (local) and shutdown hooks (remote) to
  ensure session termination when the environment runs out of scope

- The Client manages only connections to the JobManager, it is not job
  specific

This closes apache#858.
Shiti added a commit to Shiti/flink that referenced this pull request Oct 26, 2015
Shiti added a commit to Shiti/flink that referenced this pull request Nov 4, 2015
Shiti added a commit to Shiti/flink that referenced this pull request Nov 4, 2015
Shiti added a commit to Shiti/flink that referenced this pull request Nov 4, 2015
Shiti added a commit to Shiti/flink that referenced this pull request Nov 4, 2015
Shiti added a commit to Shiti/flink that referenced this pull request Nov 5, 2015
@mxm
Copy link
Contributor Author

mxm commented Sep 20, 2016

While this may provide some help for future implementations, the code is outdated and needs an overhaul. Closing for now.

@mxm mxm closed this Sep 20, 2016
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Labels
None yet
Projects
None yet
3 participants