Skip to content

Commit 6beec34

Browse files
cyyeverpytorchmergebot
cyyever
authored and
pytorchmergebot
committed
[structural binding][9/N] Replace std::tie with structural binding (#130404)
Follows #130544 Pull Request resolved: #130404 Approved by: https://github.com/janeyx99
1 parent ac28ae1 commit 6beec34

File tree

5 files changed

+24
-70
lines changed

5 files changed

+24
-70
lines changed

‎aten/src/ATen/native/cpu/FusedAdagradKernel.cpp‎

Lines changed: 6 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -28,20 +28,16 @@ typename std::enable_if<
2828
){
2929
using lpVec = at::vec::Vectorized<scalar_t>;
3030
using fVec = at::vec::Vectorized<opmath_t>;
31-
lpVec grad_vec_to_store;
32-
fVec param_vec1, param_vec2;
33-
fVec grad_vec1, grad_vec2;
34-
fVec state_sum_vec1, state_sum_vec2;
3531
int64_t d = 0;
3632
for (; d < size - (size % lpVec::size()); d += lpVec::size()) {
3733
lpVec param_lpvec = lpVec::loadu(param_ptr + d);
38-
std::tie(param_vec1, param_vec2) = vec::convert_to_float<scalar_t>(param_lpvec);
34+
auto [param_vec1, param_vec2] = vec::convert_to_float<scalar_t>(param_lpvec);
3935
lpVec grad_lpvec = lpVec::loadu(grad_ptr + d);
40-
std::tie(grad_vec1, grad_vec2) = vec::convert_to_float<scalar_t>(grad_lpvec);
36+
auto [grad_vec1, grad_vec2] = vec::convert_to_float<scalar_t>(grad_lpvec);
4137
if (grad_scale_ptr) {
4238
grad_vec1 = grad_vec1 / fVec(float(*grad_scale_ptr));
4339
grad_vec2 = grad_vec2 / fVec(float(*grad_scale_ptr));
44-
grad_vec_to_store = vec::convert_from_float<scalar_t>(grad_vec1, grad_vec2);
40+
lpVec grad_vec_to_store = vec::convert_from_float<scalar_t>(grad_vec1, grad_vec2);
4541
grad_vec_to_store.store(grad_ptr + d);
4642
}
4743
if (maximize){
@@ -52,7 +48,7 @@ typename std::enable_if<
5248
grad_vec1 += param_vec1 * fVec(scalar_t(weight_decay));
5349
grad_vec2 += param_vec2 * fVec(scalar_t(weight_decay));
5450
}
55-
std::tie(state_sum_vec1, state_sum_vec2) = vec::convert_to_float<scalar_t>(lpVec::loadu(state_sum_ptr + d));
51+
auto [state_sum_vec1, state_sum_vec2] = vec::convert_to_float<scalar_t>(lpVec::loadu(state_sum_ptr + d));
5652
state_sum_vec1 += grad_vec1 * grad_vec1;
5753
state_sum_vec2 += grad_vec2 * grad_vec2;
5854
vec::convert_from_float<scalar_t>(state_sum_vec1, state_sum_vec2).store(state_sum_ptr + d);
@@ -63,14 +59,12 @@ typename std::enable_if<
6359
param_vec2 = param_vec2 - fVec(scalar_t(clr)) * grad_vec2 / std_vec2;
6460
vec::convert_from_float<scalar_t>(param_vec1, param_vec2).store(param_ptr + d);
6561
}
66-
scalar_t grad_val_to_store;
6762
for (; d < size; d++) {
6863
opmath_t grad_val = grad_ptr[d];
6964
opmath_t param_val = param_ptr[d];
7065
if (grad_scale_ptr) {
7166
grad_val = grad_ptr[d] / opmath_t(*grad_scale_ptr);
72-
grad_val_to_store = grad_val;
73-
grad_ptr[d] = grad_val_to_store;
67+
grad_ptr[d] = grad_val;
7468
}
7569
if (maximize) grad_val = -grad_val;
7670
if (weight_decay != 0.0){
@@ -102,14 +96,13 @@ typename std::enable_if<
10296
int64_t size
10397
){
10498
using Vec = at::vec::Vectorized<scalar_t>;
105-
Vec grad_vec_to_store;
10699
int64_t d = 0;
107100
for (; d < size - (size % Vec::size()); d += Vec::size()) {
108101
Vec param_vec = Vec::loadu(param_ptr + d);
109102
Vec grad_vec = Vec::loadu(grad_ptr + d);
110103
if (grad_scale_ptr) {
111104
grad_vec = grad_vec / Vec(scalar_t(*grad_scale_ptr));
112-
grad_vec_to_store = grad_vec;
105+
Vec grad_vec_to_store = grad_vec;
113106
grad_vec_to_store.store(grad_ptr + d);
114107
}
115108
if (maximize) grad_vec = grad_vec * Vec(scalar_t(-1.0));

‎aten/src/ATen/native/cpu/FusedAdamKernel.cpp‎

Lines changed: 9 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -38,22 +38,16 @@ typename std::enable_if<
3838
double step_size = lr / bias_correction1;
3939
using lpVec = at::vec::Vectorized<scalar_t>;
4040
using fVec = at::vec::Vectorized<opmath_t>;
41-
lpVec grad_vec_to_store;
4241
int64_t d = 0;
43-
fVec param_vec1, param_vec2;
44-
fVec grad_vec1, grad_vec2;
45-
fVec exp_avg_vec1, exp_avg_vec2;
46-
fVec exp_avg_sq_vec1, exp_avg_sq_vec2;
47-
fVec max_exp_avg_sq_vec1, max_exp_avg_sq_vec2;
4842
for (; d < size - (size % lpVec::size()); d += lpVec::size()) {
4943
lpVec param_lpvec = lpVec::loadu(param_ptr + d);
50-
std::tie(param_vec1, param_vec2) = vec::convert_to_float<scalar_t>(param_lpvec);
44+
auto [param_vec1, param_vec2] = vec::convert_to_float<scalar_t>(param_lpvec);
5145
lpVec grad_lpvec = lpVec::loadu(grad_ptr + d);
52-
std::tie(grad_vec1, grad_vec2) = vec::convert_to_float<scalar_t>(grad_lpvec);
46+
auto [grad_vec1, grad_vec2] = vec::convert_to_float<scalar_t>(grad_lpvec);
5347
if (grad_scale_ptr) {
5448
grad_vec1 = grad_vec1 / fVec(float(*grad_scale_ptr));
5549
grad_vec2 = grad_vec2 / fVec(float(*grad_scale_ptr));
56-
grad_vec_to_store = vec::convert_from_float<scalar_t>(grad_vec1, grad_vec2);
50+
lpVec grad_vec_to_store = vec::convert_from_float<scalar_t>(grad_vec1, grad_vec2);
5751
grad_vec_to_store.store(grad_ptr + d);
5852
}
5953
if (maximize){
@@ -71,7 +65,7 @@ typename std::enable_if<
7165
}
7266

7367
lpVec exp_avg_lpvec = lpVec::loadu(exp_avg_ptr + d);
74-
std::tie(exp_avg_vec1, exp_avg_vec2) = vec::convert_to_float<scalar_t>(exp_avg_lpvec);
68+
auto [exp_avg_vec1, exp_avg_vec2] = vec::convert_to_float<scalar_t>(exp_avg_lpvec);
7569

7670
// exp_avg.lerp_(grad, 1 - beta1)
7771
const fVec lerp_weight = fVec(opmath_t(exp_avg_grad_coefficient));
@@ -85,7 +79,7 @@ typename std::enable_if<
8579
exp_avg_vec2 = vec::fmadd(coeff, grad_vec2 - exp_avg_vec2, base2);
8680

8781
lpVec exp_avg_sq_lpvec = lpVec::loadu(exp_avg_sq_ptr + d);
88-
std::tie(exp_avg_sq_vec1, exp_avg_sq_vec2) = vec::convert_to_float<scalar_t>(exp_avg_sq_lpvec);
82+
auto [exp_avg_sq_vec1, exp_avg_sq_vec2] = vec::convert_to_float<scalar_t>(exp_avg_sq_lpvec);
8983
exp_avg_sq_vec1 = exp_avg_sq_vec1 * fVec(opmath_t(beta2)) +
9084
fVec(opmath_t(exp_avg_sq_grad_coefficient)) * grad_vec1 * grad_vec1;
9185
exp_avg_sq_vec2 = exp_avg_sq_vec2 * fVec(opmath_t(beta2)) +
@@ -97,7 +91,7 @@ typename std::enable_if<
9791
fVec denom_vec1, denom_vec2;
9892
if (amsgrad) {
9993
lpVec max_exp_avg_sq_lpvec = lpVec::loadu(max_exp_avg_sq_ptr + d);
100-
std::tie(max_exp_avg_sq_vec1, max_exp_avg_sq_vec2) = vec::convert_to_float<scalar_t>(max_exp_avg_sq_lpvec);
94+
auto [max_exp_avg_sq_vec1, max_exp_avg_sq_vec2] = vec::convert_to_float<scalar_t>(max_exp_avg_sq_lpvec);
10195
max_exp_avg_sq_vec1 = maximum(max_exp_avg_sq_vec1, exp_avg_sq_vec1);
10296
max_exp_avg_sq_vec2 = maximum(max_exp_avg_sq_vec2, exp_avg_sq_vec2);
10397
vec::convert_from_float<scalar_t>(max_exp_avg_sq_vec1, max_exp_avg_sq_vec2).store(max_exp_avg_sq_ptr + d);
@@ -115,14 +109,12 @@ typename std::enable_if<
115109
param_vec2 = param_vec2 + fVec(opmath_t(-step_size)) * exp_avg_vec2 / denom_vec2;
116110
vec::convert_from_float<scalar_t>(param_vec1, param_vec2).store(param_ptr + d);
117111
}
118-
scalar_t grad_val_to_store;
119112
for (; d < size; d++) {
120113
opmath_t grad_val = grad_ptr[d];
121114
opmath_t param_val = param_ptr[d];
122115
if (grad_scale_ptr) {
123116
grad_val = grad_ptr[d] / float(*grad_scale_ptr);
124-
grad_val_to_store = scalar_t(grad_val);
125-
grad_ptr[d] = grad_val_to_store;
117+
grad_ptr[d] = grad_val;
126118
}
127119
if (maximize) grad_val = -grad_val;
128120
if (weight_decay != 0.f){
@@ -188,14 +180,13 @@ typename std::enable_if<
188180
){
189181
double step_size = lr / bias_correction1;
190182
using Vec = at::vec::Vectorized<scalar_t>;
191-
Vec grad_vec_to_store;
192183
int64_t d = 0;
193184
for (; d < size - (size % Vec::size()); d += Vec::size()) {
194185
Vec param_vec = Vec::loadu(param_ptr + d);
195186
Vec grad_vec = Vec::loadu(grad_ptr + d);
196187
if (grad_scale_ptr) {
197188
grad_vec = grad_vec / Vec(scalar_t(*grad_scale_ptr));
198-
grad_vec_to_store = grad_vec;
189+
Vec grad_vec_to_store = grad_vec;
199190
grad_vec_to_store.store(grad_ptr + d);
200191
}
201192
if (maximize) grad_vec = grad_vec * Vec(scalar_t(-1.0));
@@ -233,13 +224,11 @@ typename std::enable_if<
233224
param_vec = param_vec + Vec(scalar_t(-step_size)) * exp_avg_vec / denom_vec;
234225
param_vec.store(param_ptr + d);
235226
}
236-
scalar_t grad_val_to_store;
237227
for (; d < size; d++) {
238228
scalar_t grad_val = grad_ptr[d];
239229
if (grad_scale_ptr) {
240230
grad_val = grad_ptr[d] / scalar_t(*grad_scale_ptr);
241-
grad_val_to_store = grad_val;
242-
grad_ptr[d] = grad_val_to_store;
231+
grad_ptr[d] = grad_val;
243232
}
244233
if (maximize) grad_val = -grad_val;
245234
if (weight_decay != 0.f){

‎aten/src/ATen/native/cpu/FusedSGDKernel.cpp‎

Lines changed: 6 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -31,20 +31,16 @@ typename std::enable_if<
3131
){
3232
using lpVec = at::vec::Vectorized<scalar_t>;
3333
using fVec = at::vec::Vectorized<opmath_t>;
34-
lpVec grad_vec_to_store;
35-
fVec param_vec1, param_vec2;
36-
fVec grad_vec1, grad_vec2;
37-
fVec momentum_buffer_vec1, momentum_buffer_vec2;
3834
int64_t d = 0;
3935
for (; d < size - (size % lpVec::size()); d += lpVec::size()) {
4036
lpVec param_lpvec = lpVec::loadu(param_ptr + d);
41-
std::tie(param_vec1, param_vec2) = vec::convert_to_float<scalar_t>(param_lpvec);
37+
auto [param_vec1, param_vec2] = vec::convert_to_float<scalar_t>(param_lpvec);
4238
lpVec grad_lpvec = lpVec::loadu(grad_ptr + d);
43-
std::tie(grad_vec1, grad_vec2) = vec::convert_to_float<scalar_t>(grad_lpvec);
39+
auto [grad_vec1, grad_vec2] = vec::convert_to_float<scalar_t>(grad_lpvec);
4440
if (grad_scale_ptr) {
4541
grad_vec1 = grad_vec1 / fVec(float(*grad_scale_ptr));
4642
grad_vec2 = grad_vec2 / fVec(float(*grad_scale_ptr));
47-
grad_vec_to_store = vec::convert_from_float<scalar_t>(grad_vec1, grad_vec2);
43+
lpVec grad_vec_to_store = vec::convert_from_float<scalar_t>(grad_vec1, grad_vec2);
4844
grad_vec_to_store.store(grad_ptr + d);
4945
}
5046
if (maximize){
@@ -61,7 +57,6 @@ typename std::enable_if<
6157
momentum_vec1 = grad_vec1;
6258
momentum_vec2 = grad_vec2;
6359
} else {
64-
6560
momentum_vec1 = fVec::loadu(momentum_buf_ptr + d) * fVec(scalar_t(momentum));
6661
momentum_vec2 = fVec::loadu(momentum_buf_ptr + d + fVec::size()) * fVec(scalar_t(momentum));
6762
momentum_vec1 = vec::fmadd(fVec(scalar_t(1 - dampening)), grad_vec1, momentum_vec1);
@@ -77,14 +72,12 @@ typename std::enable_if<
7772
}
7873
}
7974
}
80-
scalar_t grad_val_to_store;
8175
for (; d < size; d++) {
8276
opmath_t grad_val = grad_ptr[d];
8377
opmath_t param_val = param_ptr[d];
8478
if (grad_scale_ptr) {
8579
grad_val = grad_ptr[d] / opmath_t(*grad_scale_ptr);
86-
grad_val_to_store = grad_val;
87-
grad_ptr[d] = grad_val_to_store;
80+
grad_ptr[d] = grad_val;
8881
}
8982
if (maximize) grad_val = -grad_val;
9083
if (weight_decay != 0.0){
@@ -129,14 +122,13 @@ typename std::enable_if<
129122
int64_t size
130123
){
131124
using Vec = at::vec::Vectorized<scalar_t>;
132-
Vec grad_vec_to_store;
133125
int64_t d = 0;
134126
for (; d < size - (size % Vec::size()); d += Vec::size()) {
135127
Vec param_vec = Vec::loadu(param_ptr + d);
136128
Vec grad_vec = Vec::loadu(grad_ptr + d);
137129
if (grad_scale_ptr) {
138130
grad_vec = grad_vec / Vec(scalar_t(*grad_scale_ptr));
139-
grad_vec_to_store = grad_vec;
131+
Vec grad_vec_to_store = grad_vec;
140132
grad_vec_to_store.store(grad_ptr + d);
141133
}
142134
if (maximize) grad_vec = grad_vec * Vec(scalar_t(-1.0));
@@ -162,13 +154,11 @@ typename std::enable_if<
162154
param_vec += grad_vec * Vec(scalar_t(-lr));
163155
param_vec.store(param_ptr + d);
164156
}
165-
scalar_t grad_val_to_store;
166157
for (; d < size; d++) {
167158
scalar_t grad_val = grad_ptr[d];
168159
if (grad_scale_ptr) {
169160
grad_val = grad_ptr[d] / scalar_t(*grad_scale_ptr);
170-
grad_val_to_store = grad_val;
171-
grad_ptr[d] = grad_val_to_store;
161+
grad_ptr[d] = grad_val;
172162
}
173163
if (maximize) grad_val = -grad_val;
174164
if (weight_decay != 0.0){

‎aten/src/ATen/native/nested/cuda/NestedTensorTransformerFunctions.cu‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -757,9 +757,7 @@ void jagged_dense_elementwise_dense_output_(
757757

758758
#define INVOKE_KERNEL_WITH_DIM(NUM_JAGGED_DIM) \
759759
{ \
760-
dim3 threads, blocks; \
761-
StackArray<int64_t> jagged_dims_tensor; \
762-
std::tie(threads, blocks, jagged_dims_tensor) = \
760+
auto [threads, blocks, jagged_dims_tensor] = \
763761
check_shape_and_partition_(x_values, x_offsets, y); \
764762
blocks.x = div_round_up(x_values.size(0), threads.y); \
765763
std::vector<Tensor> x_offsets_contig; \

‎aten/src/ATen/native/nested/cuda/NestedTensorTransformerUtils.cpp‎

Lines changed: 2 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -412,24 +412,8 @@ sdpa_nested_preprocessing(
412412
Tensor k_t = key.transpose(1, 2);
413413
Tensor v_t = value.transpose(1, 2);
414414

415-
auto cumulative_and_max_q_and_nnz_q = cumulative_and_max_seq_len_nnz(q_t);
416-
auto cumulative_and_max_kv_and_nnz_kv = cumulative_and_max_seq_len_nnz(k_t);
417-
418-
// [TODO] K and V have to have the same Nnz, should probably torch_check
419-
// assume in order to not iterate over v
420-
421-
Tensor cumulative_sequence_length_q =
422-
std::get<0>(cumulative_and_max_q_and_nnz_q);
423-
Tensor cumulative_sequence_length_kv =
424-
std::get<0>(cumulative_and_max_kv_and_nnz_kv);
425-
426-
const int64_t max_seqlen_batch_q =
427-
std::get<1>(cumulative_and_max_q_and_nnz_q);
428-
const int64_t max_seqlen_batch_kv =
429-
std::get<1>(cumulative_and_max_kv_and_nnz_kv);
430-
431-
const int64_t Nnz_q = std::get<2>(cumulative_and_max_q_and_nnz_q);
432-
const int64_t Nnz_kv = std::get<2>(cumulative_and_max_kv_and_nnz_kv);
415+
auto [cumulative_sequence_length_q, max_seqlen_batch_q, Nnz_q] = cumulative_and_max_seq_len_nnz(q_t);
416+
auto [cumulative_sequence_length_kv, max_seqlen_batch_kv, Nnz_kv]= cumulative_and_max_seq_len_nnz(k_t);
433417

434418
Tensor query_buffer_reshaped;
435419
Tensor key_buffer_reshaped;

0 commit comments

Comments
 (0)