Skip to content

Add Terminology section #47

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.

Sign up for GitHub

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

Open
wants to merge 2 commits into
base: master
Choose a base branch
from
+30 −0
Open

Add Terminology section #47

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
5a396cc
Add terminology section aligned with P0737 Execution Context.
hcedwar Apr 18, 2018
0de4d9f
Clarify that concurrency is an upper bound.
hcedwar Apr 24, 2018
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
30 changes: 30 additions & 0 deletions affinity/cpp-20/d0796r2.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -170,6 +170,32 @@ This feature could be easily scaled to heterogeneous and distributed systems, as

In this paper we propose an interface for querying and representing the execution resources within a system, queurying the relative affinity metric between those execution resources, and then using those execution resources to allocate memory and execute work with affinity to the underlying hardware. The interface described in this paper builds on the existing initerface for executors and execution contexts defined in the executors proposal [[22]][p0443r4].

### Terminology

An **execution agent** executes work, typically implemented by a *callable*,
Copy link
Contributor

Choose a reason for hiding this comment

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

I think we should expand on this to also include a definition for thread of execution and how they relate since we use both terms in the paper. We could say something to the effect of a thread of execution is a single flow of execution within the program and an execution agent represents the steps taken within a thread of execution during the lifetime of a (task | piece of work) executing a callable.

Copy link
Contributor

Choose a reason for hiding this comment

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

can we not refer this to the existing definitions on the Executors proposal?

Copy link
Collaborator

Choose a reason for hiding this comment

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

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0443r7.html

"An execution context is a program object that represents a specific collection of execution resources and the execution agents that exist within those resources. Execution agents are units of execution, and a 1-to-1 mapping exists between an execution agent and an invocation of a callable function object submitted via the executor."

P0443 is in flux, given P1055 and ongoing movement towards a compromise (see e.g., https://gist.github.com/ericniebler/69a3a632e1d13f7d8f16e0fbd598e42f ). Thus, it might be best simply to define these terms here, and later revise if needed to point to definitions in whatever compromise or new Executors paper shows up.

on an **execution resource** of a given **execution architecture**.
Copy link
Contributor

Choose a reason for hiding this comment

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

We should probably expand on what an execution architecture is, maybe with some examples, I assume this is the device which encapsulates a topology of resources such as a CPU, GPU, etc.

An **execution context** manages a set of execution agents on an
execution resource.
An **executor** submits work to an execution context.
More that one executor may submit work to an execution context.
More than on execution context may manage execution agents
on an execution resource.

> [*Note:* The execution context terminology used here
and in the Networking TS [[33]][networking-ts] deviate from the
traditional *context of execution* usage that refers
to the state of a single executing callable; *e.g.*,
program counter, registers, stack frame. *--end note*]

The **concurrency** of an execution resource is an upper bound of the
number of execution agents that could make concurrent forward progress
on that execution resource.
It is guaranteed that no more than **concurrency** execution agents
could make concurrent forward progress; it is not guaranteed that
**concurrency** execution agents will ever make concurrent forward progress.



### Execution resources

An `execution_resource` is a light weight structure which acts as an identifier to particular piece of hardware within a system. It can be queried for whether it can allocate memory via `can_place_memory` and whether it can execute work via `can_place_agents`, and for it's name via `name`. An `execution_resource` can also represent other `execution_resource`s, these are refered to as being *members of* that `execution_resource` and can be queried via `resources`. Additionally the `execution_resource` which another is a *member of* can be queried vis `member_of`. An `execution_resource` can also be queried for the concurrency it can provide; the total number of *threads of execution* supported by that *execution_resource* and all resources it represents.
Expand Down Expand Up @@ -647,3 +673,7 @@ The current proposal requires that all `execution_resource`s are initialised bef

[madness-journal]: http://dx.doi.org/10.1137/15M1026171
[[32]][madness-journal] MADNESS: A Multiresolution, Adaptive Numerical Environment for Scientific Simulation

[networking-ts]: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/n4734.pdf
[[33]][networking-ts] N4734 : Working Draft, C++ Extensions for Networking