cubecl-std 0.8.1

CubeCL Standard Library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use super::*;
use crate::tensor::{View, ViewExpand};
use crate::{CubeOptionExpand, tensor::layout::Coordinates};
use cubecl::prelude::*;
use cubecl_core::{self as cubecl, prelude::barrier::BarrierExpand};

impl<T: CubePrimitive, C: Coordinates, IO: Clone> Lined for View<T, C, IO> {}
impl<T: CubePrimitive, C: Coordinates, IO: Clone> LinedExpand for ViewExpand<T, C, IO> {
    fn line_size(&self) -> u32 {
        ViewExpand::line_size(self)
    }
}

impl<T: CubePrimitive, C: Coordinates, IO: Clone> ViewOperations<T, C> for View<T, C, IO> {}
impl<T: CubePrimitive, C: Coordinates, IO: Clone> ViewOperationsExpand<T, C>
    for ViewExpand<T, C, IO>
{
    fn __expand_read_method(&self, scope: &mut Scope, pos: <C>::ExpandType) -> <T>::ExpandType {
        ViewExpand::__expand_read_method(self.clone(), scope, pos)
    }

    fn __expand_read_checked_method(
        &self,
        scope: &mut Scope,
        pos: <C>::ExpandType,
    ) -> <T>::ExpandType {
        ViewExpand::__expand_read_checked_method(self.clone(), scope, pos)
    }

    fn __expand_read_masked_method(
        &self,
        scope: &mut Scope,
        pos: <C>::ExpandType,
        mask_value: <T>::ExpandType,
    ) -> <T>::ExpandType {
        ViewExpand::__expand_read_masked_method(self.clone(), scope, pos, mask_value)
    }

    fn __expand_read_unchecked_method(
        &self,
        scope: &mut Scope,
        pos: <C>::ExpandType,
    ) -> <T>::ExpandType {
        ViewExpand::__expand_read_unchecked_method(self.clone(), scope, pos)
    }

    fn __expand_to_linear_slice_method(
        &self,
        scope: &mut Scope,
        pos: <C>::ExpandType,
        end: <C>::ExpandType,
    ) -> SliceExpand<T, ReadOnly> {
        ViewExpand::__expand_to_linear_slice_inner_method(self.clone(), scope, pos, end)
    }

    fn __expand_as_tensor_map_method(&self, scope: &mut Scope) -> CubeOptionExpand<TensorMap<T>> {
        ViewExpand::__expand_as_tensor_map_method(self.clone(), scope)
    }

    fn __expand_shape_method(&self, scope: &mut Scope) -> <C>::ExpandType {
        ViewExpand::__expand_shape_method(self, scope)
    }

    fn __expand_is_in_bounds_method(
        &self,
        scope: &mut Scope,
        pos: <C>::ExpandType,
    ) -> ExpandElementTyped<bool> {
        ViewExpand::__expand_is_in_bounds_method(self, scope, pos)
    }

    fn __expand_tensor_map_load_method(
        &self,
        scope: &mut Scope,
        barrier: BarrierExpand,
        shared_memory: SliceExpand<T, ReadWrite>,
        pos: C::ExpandType,
    ) {
        ViewExpand::__expand_tensor_map_load_method(
            self.clone(),
            scope,
            barrier,
            shared_memory,
            pos,
        )
    }
}

impl<T: CubePrimitive, C: Coordinates> ViewOperationsMut<T, C> for View<T, C, ReadWrite> {}
impl<T: CubePrimitive, C: Coordinates> ViewOperationsMutExpand<T, C>
    for ViewExpand<T, C, ReadWrite>
{
    fn __expand_write_method(
        &self,
        scope: &mut Scope,
        pos: <C>::ExpandType,
        value: <T>::ExpandType,
    ) {
        ViewExpand::__expand_write_method(self.clone(), scope, pos, value);
    }

    fn __expand_write_checked_method(
        &self,
        scope: &mut Scope,
        pos: <C>::ExpandType,
        value: <T>::ExpandType,
    ) {
        ViewExpand::__expand_write_checked_method(self.clone(), scope, pos, value);
    }

    fn __expand_to_linear_slice_mut_method(
        &self,
        scope: &mut Scope,
        pos: <C>::ExpandType,
        end: <C>::ExpandType,
    ) -> SliceExpand<T, ReadWrite> {
        ViewExpand::__expand_to_linear_slice_mut_inner_method(self.clone(), scope, pos, end)
    }

    fn __expand_tensor_map_store_method(
        &self,
        scope: &mut Scope,
        shared_memory: SliceExpand<T, ReadOnly>,
        pos: C::ExpandType,
    ) {
        ViewExpand::__expand_tensor_map_store_method(self.clone(), scope, shared_memory, pos)
    }
}