accelforge 0.0.1__py3-none-any.whl

examples/mappings/unfused_matmuls_to_simple.yaml

@@ -0,0 +1,33 @@
+mapping:
+  nodes:
+  {% for i in range(N_EINSUMS+1) %}
+  - !Storage
+    tensors: [T{{i}}]
+    component: MainMemory
+  {% endfor %}
+  {% for i in range(N_EINSUMS) %}
+  - !Storage
+    tensors: [W{{i}}]
+    component: MainMemory
+  {% endfor %}
+  - !Temporal
+    rank_variable: m
+    tile_shape: 1
+  - !Sequential
+    nodes:
+    {% for i in range(N_EINSUMS) %}
+    - !Nested
+      nodes:
+      - !Storage
+        tensors: [T{{i}}, W{{i}}, T{{i+1}}]
+        component: GlobalBuffer
+      - !Temporal
+        rank_variable: n{{i}}
+        tile_shape: 1
+      - !Temporal
+        rank_variable: n{{i+1}}
+        tile_shape: 1
+      - !Compute
+        einsum: Matmul{{i}}
+        component: MAC
+    {% endfor %}

examples/misc/component_annotated.yaml

@@ -0,0 +1,33 @@
+# The YAML tag at the beginning of the component tells the parser what type of component
+# it is.
+!Memory
+
+name: GlobalBuffer
+
+# This component_class invokes the hwcomponents_library.SmartBufferSRAM model. The
+# component is a SRAM buffer with an address register that is updated on every
+# access to queue up the next data.
+component_class: SmartBufferSRAM
+
+# Fields can be parsed as expressions. The size field is given in bits, and we write
+# here that it is 512 × 32 bits.
+size: 512 * 32
+
+# Sometimes, hwcomponents models require additional attributes that are not part of the
+# accelforge spec. These can be passed to the component models through the
+# extra_attributes_for_component_model field.
+extra_attributes_for_component_model:
+  depth: 512
+  width: size // depth
+  n_banks: 32
+  tech_node: 65e-9
+
+# Actions that the hwcomponents_library model must support. All action attributes that
+# can are passed to the model's appropriate method (in this case, `read` or `write`).
+# The `bits_per_action` argument is special because it determines how many bits are
+# transferred by each read or write. Additionally, to pass extra attributes to the
+# component model as arguments, actions also have a extra_attributes_for_component_model
+# field.
+actions:
+- {name: read, bits_per_action: 64}
+- {name: write, bits_per_action: 64}

examples/workloads/gpt3_6.7B.yaml

@@ -0,0 +1,124 @@
+# Each tensor is shaped by a set of ranks, denoted by capital letters
+# For example: Q is shaped by (B, M, H, E)
+# We'll use lower-case letters to index into the ranks
+# For example: Q[b, m, h, e] is the tensor Q at index (b, m, h, e)
+
+# When making a projection list, it's equivalent to the Einsum subscript notation, so:
+# Q projection [b, m, h, e] means that b indexes into B, m indexes into M...
+# When making a projection dict, it's equivalent to the Einsum subscript/superscript notation, so:
+# K projection { B: b, M: p, H: h, E: e } means that b indexes into B, p indexes into M...
+
+# Renames take a tensor name and turn them into a canonical name that we can use in
+# architecture constraints. For example, we want to use the words "input", "weight", and
+# "output" to refer to the tensors of an Einsum, but the Einsum QK has no clear "weight"
+# or "input" because both Q and K are inputs. So we rename K to be weight.
+
+
+workload:
+  rank_sizes:
+    {% set BATCH_SIZE = BATCH_SIZE | default(1) %}
+    {% set N_TOKENS = N_TOKENS | default(8192) %}
+    B: {{BATCH_SIZE}}
+    P: {{N_TOKENS}}
+    M: {{N_TOKENS}}
+    H: 32
+    E: 128
+    F: 128
+    D: 4096 # = e * h
+    C: 16384
+    J: 4096
+    G: 4096
+
+  bits_per_value: {All: 8}
+
+  einsums:
+  - name: I
+    # Copy operation means that we move the input tensor from one place to another
+    # without doing computation. This lets us copy the input tensor onto the accelerator
+    # once and then use it in the Q, K, and V operations.
+    is_copy_operation: True    # no longer needed with `map` and `reduce` support
+    tensor_accesses:
+    - {name: I_in, projection: [b, m, d]}
+    - {name: I, projection: [b, m, d], output: True}
+
+    # operations:
+    #   map: {operation} if output = f(inputs), None if output = inputs
+    #   reduce: {operation} if output = reduce(partial_outputA, partial_outputB, ...), None if not supported
+    #   populate: {operation} if initial_output = populate, None if initial_output = first-generated partial output
+
+    # operations:
+    #   map: None    # Alternatives: "mul", "relu", etc.
+    #   reduce: None # Alternatives: "max", etc. Note: None means "give me whatever is the last value (mapping dependent)"
+    #   # reduce: None  with strict checking: if there is a reduce, an error is thrown.
+    #   populate: None
+    renames: {weight: Nothing, input: Inputs, output: Outputs}
+
+  - name: V
+    tensor_accesses:
+    - {name: I, projection: [b, m, d]}
+    - {name: WV, projection: [h, e, d], persistent: True}
+    - {name: V, projection: [b, m, h, e], output: True}
+
+  - name: K
+    tensor_accesses:
+    - {name: I, projection: [b, m, d]}
+    - {name: WK, projection: [h, e, d], persistent: True}
+    - {name: K, projection: [b, m, h, e], output: True}
+
+  - name: Q
+    tensor_accesses:
+    - {name: I, projection: [b, m, d]}
+    - {name: WQ, projection: [h, e, d], persistent: True}
+    - {name: Q, projection: [b, m, h, e], output: True}
+
+  - name: QK
+    tensor_accesses:
+    - {name: Q, projection: [b, m, h, e]}
+    - {name: K, projection: { B: b, M: p, H: h, E: e }}
+    - {name: QK, projection: [b, m, p, h], output: True}
+    renames: {weight: K, input: Q, output: QK}
+
+  - name: QK_softmax
+    tensor_accesses:
+    - {name: QK, projection: [b, m, p, h]}
+    - {name: QK_softmax, projection: [b, m, p, h], output: True}
+    renames: {weight: Nothing}
+
+  - name: AV
+    tensor_accesses:
+    - {name: QK_softmax, projection: [b, m, p, h]}
+    - {name: V, projection: { B: b, M: p, H: h, E: f}}
+    - {name: AV, projection: [b, m, h, f], output: True}
+    renames: {weight: V, input: QK_softmax}
+
+  - name: Z
+    tensor_accesses:
+    - {name: AV, projection: [b, m, h, f]}
+    - {name: WZ, projection: [h, f, g], persistent: True}
+    - {name: Z, projection: [b, m, g], output: True}
+
+  - name: FFA
+    tensor_accesses:
+    - {name: Z, projection: [b, m, g]}
+    - {name: WFFA, projection: [g, c], persistent: True}
+    - {name: FFA, projection: [b, m, c], output: True}
+
+  - name: FFB
+    tensor_accesses:
+    - {name: FFA, projection: [b, m, c]}
+    - {name: WFFB, projection: [c, j], persistent: True}
+    - {name: FFB, projection: [b, m, j], output: True}
+
+renames:
+  einsums:
+  - name: default
+    tensor_accesses:
+    - name: input
+      source: Inputs & Intermediates
+      expected_count: 1
+    - name: output
+      source: Outputs
+      expected_count: 1
+    - name: weight
+      source: ~(input | output)
+      expected_count: 1

examples/workloads/matmuls.yaml

@@ -0,0 +1,20 @@
+workload:
+  iteration_space_shape:
+    {% set M = M | default(128) %}
+    {% set KN = KN | default(128) %}
+    m:  0 <= m  < {{M}}
+    {% for i in range(N_EINSUMS+1) %}
+    n{{i}}: 0 <= n{{i}} < {{KN}}
+    {% endfor %}
+
+  bits_per_value: {All: 8}
+
+  einsums:
+  {% for i in range(N_EINSUMS) %}
+  - name: Matmul{{i}}
+    tensor_accesses:
+    - {name: T{{i}}, projection: [m, n{{i}}]}
+    - {name: W{{i}}, projection: [n{{i}}, n{{i+1}}]}
+    - {name: T{{i+1}}, projection: [m, n{{i+1}}], output: True}
+    renames: {weight: W{{i}}, input: T{{i}}, output: T{{i+1}}}
+  {% endfor %}

examples/workloads/mobilenet_28.yaml

@@ -0,0 +1,81 @@
+workload:
+  rank_sizes:
+    {% set BATCH_SIZE = BATCH_SIZE | default(1) %}
+    B: {{BATCH_SIZE}}
+    P0: 28
+    Q0: 28
+    N0: 24
+    T0: 192
+    N1: 24
+    P1: 28
+    Q1: 28
+    P2: 28
+    Q2: 28
+    T1: 192
+    N2: 24
+
+  bits_per_value: {All: 8}
+
+  einsums:
+  - name: PiecewiseA0
+    tensor_accesses:
+    - {name: T0, projection: [p0, q0, n0, b]}
+    - {name: WA0, projection: [n0, t0]}
+    - {name: TA0, projection: [p0, q0, t0, b], output: True}
+    renames: {input: T0, output: TA0, weight: WA0}
+
+  - name: Depthwise0
+    tensor_accesses:
+    - name: TA0
+      projection:
+        P0: p1 + r0
+        Q0: q1 + s0
+        T0: t0
+        B: b
+    - {name: WAB0, projection: [r0, s0, t0]}
+    - {name: TB0, projection: [p1, q1, t0, b], output: True}
+    shape: [0 <= r0 < 3, 0 <= s0 < 3]
+
+  - name: PiecewiseB0
+    tensor_accesses:
+    - {name: TB0, projection: [p1, q1, t0, b]}
+    - {name: WB0, projection: [t0, n1]}
+    - {name: T1, projection: [p1, q1, n1, b], output: True}
+
+  - name: PiecewiseA1
+    tensor_accesses:
+    - {name: T1, projection: [p1, q1, n1, b]}
+    - {name: WA1, projection: [n1, t1]}
+    - {name: TA1, projection: [p1, q1, t1, b], output: True}
+
+  - name: Depthwise1
+    tensor_accesses:
+    - name: TA1
+      projection:
+        P1: p2 + r1
+        Q1: q2 + s1
+        T1: t1
+        B: b
+    - {name: WAB1, projection: [r1, s1, t1]}
+    - {name: TB1, projection: [p2, q2, t1, b], output: True}
+    shape: [1 <= r1 < 3, 1 <= s1 < 3]
+
+  - name: PiecewiseB2
+    tensor_accesses:
+    - {name: TB1, projection: [p2, q2, t1, b]}
+    - {name: WB1, projection: [t1, n2]}
+    - {name: T2, projection: [p2, q2, n2, b], output: True}
+
+renames:
+  einsums:
+  - name: default
+    tensor_accesses:
+    - name: input
+      source: Inputs & Intermediates
+      expected_count: 1
+    - name: output
+      source: Outputs
+      expected_count: 1
+    - name: weight
+      source: ~(input | output)
+      expected_count: 1

examples/workloads/mobilenet_various_separate.yaml

@@ -0,0 +1,106 @@
+workload:
+  version: "0.5"
+  shape:
+    {% set BATCH_SIZE = BATCH_SIZE | default(1) %}
+    b: 0 <= b < {{BATCH_SIZE}}
+    pp0: 0 <= pp0 < 116
+    qp0: 0 <= qp0 < 116
+    cp0: 0 <= cp0 < 16
+    mp0: 0 <= mp0 < 16
+    pd0: 0 <= pd0 < 116
+    qd0: 0 <= qd0 < 116
+    cd0: 0 <= cd0 < 16
+    rd0: 0 <= rd0 < 3
+    sd0: 0 <= sd0 < 3
+
+    pp1: 0 <= pp1 < 56
+    qp1: 0 <= qp1 < 56
+    cp1: 0 <= cp1 < 24
+    mp1: 0 <= mp1 < 72
+    pd1: 0 <= pd1 < 56
+    qd1: 0 <= qd1 < 56
+    cd1: 0 <= cd1 < 72
+    rd1: 0 <= rd1 < 5
+    sd1: 0 <= sd1 < 5
+
+    pp2: 0 <= pp2 < 28
+    qp2: 0 <= qp2 < 28
+    cp2: 0 <= cp2 < 40
+    mp2: 0 <= mp2 < 120
+    pd2: 0 <= pd2 < 28
+    qd2: 0 <= qd2 < 28
+    cd2: 0 <= cd2 < 120
+    rd2: 0 <= rd2 < 3
+    sd2: 0 <= sd2 < 3
+
+  einsums:
+  - name: P0
+    tensor_accesses:
+    - {name: IP0, projection: [pp0, qp0, cp0, b]}
+    - {name: WP0, projection: [cp0, mp0]}
+    - {name: OP0, projection: [pp0, qp0, mp0, b], output: True}
+    renames: {input: IP0, output: OP0, weight: WP0}
+
+  - name: D0
+    tensor_accesses:
+    - name: ID0
+      projection:
+        PD0: pd0 + rd0
+        QD0: qd0 + sd0
+        CD0: cd0
+        B: b
+    - {name: WD0, projection: [rd0, sd0, cd0]}
+    - {name: OD0, projection: [pd0, qd0, cd0, b], output: True}
+    renames: {input: ID0, output: OD0, weight: WD0}
+
+  - name: P1
+    tensor_accesses:
+    - {name: IP1, projection: [pp1, qp1, cp1, b]}
+    - {name: WP1, projection: [cp1, mp1]}
+    - {name: OP1, projection: [pp1, qp1, mp1, b], output: True}
+    renames: {input: IP1, output: OP1, weight: WP1}
+
+  - name: D1
+    tensor_accesses:
+    - name: ID1
+      projection:
+        PD1: pd1 + rd1
+        QD1: qd1 + sd1
+        CD1: cd1
+        B: b
+    - {name: WD1, projection: [rd1, sd1, cd1]}
+    - {name: OD1, projection: [pd1, qd1, cd1, b], output: True}
+    renames: {input: ID1, output: OD1, weight: WD1}
+
+  - name: P2
+    tensor_accesses:
+    - {name: IP2, projection: [pp2, qp2, cp2, b]}
+    - {name: WP2, projection: [cp2, mp2]}
+    - {name: OP2, projection: [pp2, qp2, mp2, b], output: True}
+    renames: {input: IP2, output: OP2, weight: WP2}
+
+  - name: D2
+    tensor_accesses:
+    - name: ID2
+      projection:
+        PD2: pd2 + rd2
+        QD2: qd2 + sd2
+        CD2: cd2
+        B: b
+    - {name: WD2, projection: [rd2, sd2, cd2]}
+    - {name: OD2, projection: [pd2, qd2, cd2, b], output: True}
+    renames: {input: ID2, output: OD2, weight: WD2}
+
+renames:
+  einsums:
+  - name: default
+    tensor_accesses:
+    - name: input
+      source: Inputs() & Intermediates()
+      expected_count: 1
+    - name: output
+      source: Outputs()
+      expected_count: 1
+    - name: weight
+      source: ~(input | output)
+      expected_count: 1

examples/workloads/three_matmuls_annotated.yaml

@@ -0,0 +1,59 @@
+workload:
+  # These rank sizes define the shapes of the tensors in the Einsum. Shapes are assumed
+  # to go from [0, size-1]. Indexes into a rank are omitted if out of range.
+  rank_sizes:
+    M: 128
+    N0: 128
+    N1: 128
+    N2: 128
+    N3: 128
+
+  # Alternatively, we can constrain each of the rank variables to be within a range. The
+  # values in this dictionary are ISL expressions, and the constraints apply to all
+  # Einsums that use these rank variables.
+  iteration_space_shape:
+    m:  0 <= m  < 128
+    n0: 0 <= n0 < 128
+    n1: 0 <= n1 < 128
+    n2: 0 <= n2 < 128
+    n3: 0 <= n3 < 128
+
+  # Describe the number of bits of each value of each tensor. This is a dictionary of
+  # set expressions to bits per value for the tensors given by those expressions. They
+  # can be overridden by the bits_per_value attribute of any tensor access.
+  bits_per_value: {All: 8}
+
+  # The Einsums in the workload.
+  einsums:
+  - name: Matmul1
+    tensor_accesses:
+    - {name: T0, projection: [m, n0]}
+    - {name: W0, projection: [n0, n1]}
+    - {name: T1, projection: [m, n1], output: True}
+    renames: {input: T0}
+
+  - name: Matmul2
+    tensor_accesses:
+    - {name: T1, projection: [m, n1]}
+    - {name: W1, projection: [n1, n2]}
+    - {name: T2, projection: [m, n2], output: True}
+
+  - name: Matmul3
+    tensor_accesses:
+    - {name: T2, projection: [m, n2]}
+    - {name: W2, projection: [n2, n3]}
+    - {name: T3, projection: [m, n3], output: True}
+
+renames:
+  einsums:
+  - name: default
+    tensor_accesses:
+    - name: input
+      source: Inputs & Intermediates
+      expected_count: 1
+    - name: output
+      source: Outputs
+      expected_count: 1
+    - name: weight
+      source: ~(input | output)
+      expected_count: 1