Introduce a parallel queue for running Jobs

[jungkees]

This change defines a parallel queue called the service worker manager
where the instances of Run Job steps are queued and run in order.

Fixes#1224.

---

Preview | Diff

[jakearchibald]

Does this need to be scoped to the whole user agent, or is per-origin enough?

[jakearchibald]

By the way, totally happy for this to merge if there's a reason the queue needs to be across the whole browser.

[jungkees]

This intentionally suggests to be a parallel execution context across the user agent. This matches pretty much what the implementations do (at least Chromium). We can think of the parallel execution context of the parallel queue as a thread in a browser process in Chromium for instance.

[jakearchibald]

Is there any reason the registration of a service worker on origin A should block the registration of a service worker on origin B?

[jungkees]

No. They are independent. Per-origin parallel queues would work and provide better concurrency conceptually. In this change, I just tried to match the current implementation, especially Chromium.

[jakearchibald]

I think the spec should allow for maximum concurrency while maintaining the behaviour we want. Implementations are welcome to be less concurrent, but the spec shouldn't reflect this unless developers come to rely on a particular lack of concurrency.

@annevk is that fair?

[annevk]

For shared workers I went with a note after requiring a single one for the user agent:

Each user agent has a single shared worker manager for simplicity. Implementations could use one per origin; that would not be observably different and enables more concurrency.

[jungkees]

Implementers' feedback would also be great.

/cc @mattto, @wanderview, @mkruisselbrink, @aliams, @hober

[jakearchibald]

This is a good step. Eventually I'd like to get rid of the "job" concept entirely, and replace it with appending steps to the appropriate parallel queue.

[jungkees]

That'd mean the implementations should create and maintain a separate thread for each scope. That may be an ideal design which allows parallel register/update/unregister even, but a single (off-the-main) thread executing the jobs from all the job queues is what we currently have. I also would like to hear what implementers think on this.

[jungkees]

One thing I'd thought of and didn't put in the change was run the Schedule Job's steps in the parallel queue as well. That'd make it more congruent to what Chromium does (with IPC). But I thought it would add somewhat unnecessary complexity to the spec.

For now, I think using a separate (off-the-main) thread running jobs without breaking the order in each job queue would be good enough.

[jungkees]

This change defines a parallel queue called the service worker manager
where the instances of Run Job steps are queued and run in order.

Fixes#1224.

---

Preview | Diff

[jakearchibald]

Does this need to be scoped to the whole user agent, or is per-origin enough?

[jakearchibald]

By the way, totally happy for this to merge if there's a reason the queue needs to be across the whole browser.

[jungkees]

This intentionally suggests to be a parallel execution context across the user agent. This matches pretty much what the implementations do (at least Chromium). We can think of the parallel execution context of the parallel queue as a thread in a browser process in Chromium for instance.

[jakearchibald]

Is there any reason the registration of a service worker on origin A should block the registration of a service worker on origin B?

[jungkees]

No. They are independent. Per-origin parallel queues would work and provide better concurrency conceptually. In this change, I just tried to match the current implementation, especially Chromium.

[jakearchibald]

I think the spec should allow for maximum concurrency while maintaining the behaviour we want. Implementations are welcome to be less concurrent, but the spec shouldn't reflect this unless developers come to rely on a particular lack of concurrency.

@annevk is that fair?

[annevk]

For shared workers I went with a note after requiring a single one for the user agent:

Each user agent has a single shared worker manager for simplicity. Implementations could use one per origin; that would not be observably different and enables more concurrency.

[jungkees]

Implementers' feedback would also be great.

/cc @mattto, @wanderview, @mkruisselbrink, @aliams, @hober

[jakearchibald]

This is a good step. Eventually I'd like to get rid of the "job" concept entirely, and replace it with appending steps to the appropriate parallel queue.

[jungkees]

That'd mean the implementations should create and maintain a separate thread for each scope. That may be an ideal design which allows parallel register/update/unregister even, but a single (off-the-main) thread executing the jobs from all the job queues is what we currently have. I also would like to hear what implementers think on this.

[jungkees]

One thing I'd thought of and didn't put in the change was run the Schedule Job's steps in the parallel queue as well. That'd make it more congruent to what Chromium does (with IPC). But I thought it would add somewhat unnecessary complexity to the spec.

For now, I think using a separate (off-the-main) thread running jobs without breaking the order in each job queue would be good enough.

[jungkees]

This change defines a parallel queue called the service worker manager
where the instances of Run Job steps are queued and run in order.

Fixes#1224.

---

Preview | Diff

[jakearchibald]

Does this need to be scoped to the whole user agent, or is per-origin enough?

[jakearchibald]

By the way, totally happy for this to merge if there's a reason the queue needs to be across the whole browser.

[jungkees]

This intentionally suggests to be a parallel execution context across the user agent. This matches pretty much what the implementations do (at least Chromium). We can think of the parallel execution context of the parallel queue as a thread in a browser process in Chromium for instance.

[jakearchibald]

Is there any reason the registration of a service worker on origin A should block the registration of a service worker on origin B?

[jungkees]

No. They are independent. Per-origin parallel queues would work and provide better concurrency conceptually. In this change, I just tried to match the current implementation, especially Chromium.

[jakearchibald]

I think the spec should allow for maximum concurrency while maintaining the behaviour we want. Implementations are welcome to be less concurrent, but the spec shouldn't reflect this unless developers come to rely on a particular lack of concurrency.

@annevk is that fair?

[annevk]

For shared workers I went with a note after requiring a single one for the user agent:

Each user agent has a single shared worker manager for simplicity. Implementations could use one per origin; that would not be observably different and enables more concurrency.

[jungkees]

Implementers' feedback would also be great.

/cc @mattto, @wanderview, @mkruisselbrink, @aliams, @hober

[jakearchibald]

This is a good step. Eventually I'd like to get rid of the "job" concept entirely, and replace it with appending steps to the appropriate parallel queue.

[jungkees]

That'd mean the implementations should create and maintain a separate thread for each scope. That may be an ideal design which allows parallel register/update/unregister even, but a single (off-the-main) thread executing the jobs from all the job queues is what we currently have. I also would like to hear what implementers think on this.

[jungkees]

One thing I'd thought of and didn't put in the change was run the Schedule Job's steps in the parallel queue as well. That'd make it more congruent to what Chromium does (with IPC). But I thought it would add somewhat unnecessary complexity to the spec.

For now, I think using a separate (off-the-main) thread running jobs without breaking the order in each job queue would be good enough.

[jungkees]

This change defines a parallel queue called the service worker manager
where the instances of Run Job steps are queued and run in order.

Fixes#1224.

---

Preview | Diff

[jakearchibald]

Does this need to be scoped to the whole user agent, or is per-origin enough?

[jakearchibald]

By the way, totally happy for this to merge if there's a reason the queue needs to be across the whole browser.

[jungkees]

This intentionally suggests to be a parallel execution context across the user agent. This matches pretty much what the implementations do (at least Chromium). We can think of the parallel execution context of the parallel queue as a thread in a browser process in Chromium for instance.

[jakearchibald]

Is there any reason the registration of a service worker on origin A should block the registration of a service worker on origin B?

[jungkees]

No. They are independent. Per-origin parallel queues would work and provide better concurrency conceptually. In this change, I just tried to match the current implementation, especially Chromium.

[jakearchibald]

I think the spec should allow for maximum concurrency while maintaining the behaviour we want. Implementations are welcome to be less concurrent, but the spec shouldn't reflect this unless developers come to rely on a particular lack of concurrency.

@annevk is that fair?

[annevk]

For shared workers I went with a note after requiring a single one for the user agent:

Each user agent has a single shared worker manager for simplicity. Implementations could use one per origin; that would not be observably different and enables more concurrency.

[jungkees]

Implementers' feedback would also be great.

/cc @mattto, @wanderview, @mkruisselbrink, @aliams, @hober

[jakearchibald]

This is a good step. Eventually I'd like to get rid of the "job" concept entirely, and replace it with appending steps to the appropriate parallel queue.

[jungkees]

That'd mean the implementations should create and maintain a separate thread for each scope. That may be an ideal design which allows parallel register/update/unregister even, but a single (off-the-main) thread executing the jobs from all the job queues is what we currently have. I also would like to hear what implementers think on this.

[jungkees]

One thing I'd thought of and didn't put in the change was run the Schedule Job's steps in the parallel queue as well. That'd make it more congruent to what Chromium does (with IPC). But I thought it would add somewhat unnecessary complexity to the spec.

For now, I think using a separate (off-the-main) thread running jobs without breaking the order in each job queue would be good enough.

[jungkees]

This change defines a parallel queue called the service worker manager
where the instances of Run Job steps are queued and run in order.

Fixes#1224.

---

Preview | Diff

[jakearchibald]

Does this need to be scoped to the whole user agent, or is per-origin enough?

[jakearchibald]

By the way, totally happy for this to merge if there's a reason the queue needs to be across the whole browser.

[jungkees]

This intentionally suggests to be a parallel execution context across the user agent. This matches pretty much what the implementations do (at least Chromium). We can think of the parallel execution context of the parallel queue as a thread in a browser process in Chromium for instance.

[jakearchibald]

Is there any reason the registration of a service worker on origin A should block the registration of a service worker on origin B?

[jungkees]

No. They are independent. Per-origin parallel queues would work and provide better concurrency conceptually. In this change, I just tried to match the current implementation, especially Chromium.

[jakearchibald]

I think the spec should allow for maximum concurrency while maintaining the behaviour we want. Implementations are welcome to be less concurrent, but the spec shouldn't reflect this unless developers come to rely on a particular lack of concurrency.

@annevk is that fair?

[annevk]

For shared workers I went with a note after requiring a single one for the user agent:

Each user agent has a single shared worker manager for simplicity. Implementations could use one per origin; that would not be observably different and enables more concurrency.

[jungkees]

Implementers' feedback would also be great.

/cc @mattto, @wanderview, @mkruisselbrink, @aliams, @hober

[jakearchibald]

This is a good step. Eventually I'd like to get rid of the "job" concept entirely, and replace it with appending steps to the appropriate parallel queue.

[jungkees]

That'd mean the implementations should create and maintain a separate thread for each scope. That may be an ideal design which allows parallel register/update/unregister even, but a single (off-the-main) thread executing the jobs from all the job queues is what we currently have. I also would like to hear what implementers think on this.

[jungkees]

One thing I'd thought of and didn't put in the change was run the Schedule Job's steps in the parallel queue as well. That'd make it more congruent to what Chromium does (with IPC). But I thought it would add somewhat unnecessary complexity to the spec.

For now, I think using a separate (off-the-main) thread running jobs without breaking the order in each job queue would be good enough.

[jungkees]

This change defines a parallel queue called the service worker manager
where the instances of Run Job steps are queued and run in order.

Fixes#1224.

---

Preview | Diff

[jakearchibald]

Does this need to be scoped to the whole user agent, or is per-origin enough?

[jakearchibald]

By the way, totally happy for this to merge if there's a reason the queue needs to be across the whole browser.

[jungkees]

This intentionally suggests to be a parallel execution context across the user agent. This matches pretty much what the implementations do (at least Chromium). We can think of the parallel execution context of the parallel queue as a thread in a browser process in Chromium for instance.

[jakearchibald]

Is there any reason the registration of a service worker on origin A should block the registration of a service worker on origin B?

[jungkees]

No. They are independent. Per-origin parallel queues would work and provide better concurrency conceptually. In this change, I just tried to match the current implementation, especially Chromium.

[jakearchibald]

I think the spec should allow for maximum concurrency while maintaining the behaviour we want. Implementations are welcome to be less concurrent, but the spec shouldn't reflect this unless developers come to rely on a particular lack of concurrency.

@annevk is that fair?

[annevk]

For shared workers I went with a note after requiring a single one for the user agent:

Each user agent has a single shared worker manager for simplicity. Implementations could use one per origin; that would not be observably different and enables more concurrency.

[jungkees]

Implementers' feedback would also be great.

/cc @mattto, @wanderview, @mkruisselbrink, @aliams, @hober

[jakearchibald]

This is a good step. Eventually I'd like to get rid of the "job" concept entirely, and replace it with appending steps to the appropriate parallel queue.

[jungkees]

That'd mean the implementations should create and maintain a separate thread for each scope. That may be an ideal design which allows parallel register/update/unregister even, but a single (off-the-main) thread executing the jobs from all the job queues is what we currently have. I also would like to hear what implementers think on this.

[jungkees]

One thing I'd thought of and didn't put in the change was run the Schedule Job's steps in the parallel queue as well. That'd make it more congruent to what Chromium does (with IPC). But I thought it would add somewhat unnecessary complexity to the spec.

For now, I think using a separate (off-the-main) thread running jobs without breaking the order in each job queue would be good enough.

[jungkees]

This change defines a parallel queue called the service worker manager
where the instances of Run Job steps are queued and run in order.

Fixes#1224.

---

Preview | Diff

[jakearchibald]

Does this need to be scoped to the whole user agent, or is per-origin enough?

[jakearchibald]

By the way, totally happy for this to merge if there's a reason the queue needs to be across the whole browser.

[jungkees]

This intentionally suggests to be a parallel execution context across the user agent. This matches pretty much what the implementations do (at least Chromium). We can think of the parallel execution context of the parallel queue as a thread in a browser process in Chromium for instance.

[jakearchibald]

Is there any reason the registration of a service worker on origin A should block the registration of a service worker on origin B?

[jungkees]

No. They are independent. Per-origin parallel queues would work and provide better concurrency conceptually. In this change, I just tried to match the current implementation, especially Chromium.

[jakearchibald]

I think the spec should allow for maximum concurrency while maintaining the behaviour we want. Implementations are welcome to be less concurrent, but the spec shouldn't reflect this unless developers come to rely on a particular lack of concurrency.

@annevk is that fair?

[annevk]

For shared workers I went with a note after requiring a single one for the user agent:

Each user agent has a single shared worker manager for simplicity. Implementations could use one per origin; that would not be observably different and enables more concurrency.

[jungkees]

Implementers' feedback would also be great.

/cc @mattto, @wanderview, @mkruisselbrink, @aliams, @hober

[jakearchibald]

This is a good step. Eventually I'd like to get rid of the "job" concept entirely, and replace it with appending steps to the appropriate parallel queue.

[jungkees]

That'd mean the implementations should create and maintain a separate thread for each scope. That may be an ideal design which allows parallel register/update/unregister even, but a single (off-the-main) thread executing the jobs from all the job queues is what we currently have. I also would like to hear what implementers think on this.

[jungkees]

One thing I'd thought of and didn't put in the change was run the Schedule Job's steps in the parallel queue as well. That'd make it more congruent to what Chromium does (with IPC). But I thought it would add somewhat unnecessary complexity to the spec.

For now, I think using a separate (off-the-main) thread running jobs without breaking the order in each job queue would be good enough.

[jungkees]

This change defines a parallel queue called the service worker manager
where the instances of Run Job steps are queued and run in order.

Fixes#1224.

---

Preview | Diff

[jakearchibald]

Does this need to be scoped to the whole user agent, or is per-origin enough?

[jakearchibald]

By the way, totally happy for this to merge if there's a reason the queue needs to be across the whole browser.

[jungkees]

This intentionally suggests to be a parallel execution context across the user agent. This matches pretty much what the implementations do (at least Chromium). We can think of the parallel execution context of the parallel queue as a thread in a browser process in Chromium for instance.

[jakearchibald]

Is there any reason the registration of a service worker on origin A should block the registration of a service worker on origin B?

[jungkees]

No. They are independent. Per-origin parallel queues would work and provide better concurrency conceptually. In this change, I just tried to match the current implementation, especially Chromium.

[jakearchibald]

I think the spec should allow for maximum concurrency while maintaining the behaviour we want. Implementations are welcome to be less concurrent, but the spec shouldn't reflect this unless developers come to rely on a particular lack of concurrency.

@annevk is that fair?

[annevk]

For shared workers I went with a note after requiring a single one for the user agent:

Each user agent has a single shared worker manager for simplicity. Implementations could use one per origin; that would not be observably different and enables more concurrency.

[jungkees]

Implementers' feedback would also be great.

/cc @mattto, @wanderview, @mkruisselbrink, @aliams, @hober

[jakearchibald]

This is a good step. Eventually I'd like to get rid of the "job" concept entirely, and replace it with appending steps to the appropriate parallel queue.

[jungkees]

That'd mean the implementations should create and maintain a separate thread for each scope. That may be an ideal design which allows parallel register/update/unregister even, but a single (off-the-main) thread executing the jobs from all the job queues is what we currently have. I also would like to hear what implementers think on this.

[jungkees]

One thing I'd thought of and didn't put in the change was run the Schedule Job's steps in the parallel queue as well. That'd make it more congruent to what Chromium does (with IPC). But I thought it would add somewhat unnecessary complexity to the spec.

For now, I think using a separate (off-the-main) thread running jobs without breaking the order in each job queue would be good enough.