@@ -31,8 +31,11 @@ void sort0ByKeyIterative(Array<Tk> okey, Array<Tv> oval)
31
31
Tk *okey_ptr = okey.get ();
32
32
Tv *oval_ptr = oval.get ();
33
33
34
- std::vector<IndexPair<Tk, Tv> > X;
35
- X.reserve (okey.dims ()[0 ]);
34
+ typedef IndexPair<Tk, Tv> CurrentPair;
35
+
36
+ dim_t size = okey.dims ()[0 ];
37
+ size_t bytes = size * sizeof (CurrentPair);
38
+ CurrentPair *pairKeyVal = (CurrentPair *)memAlloc<char >(bytes);
36
39
37
40
for (dim_t w = 0 ; w < okey.dims ()[3 ]; w++) {
38
41
dim_t okeyW = w * okey.strides ()[3 ];
@@ -47,23 +50,24 @@ void sort0ByKeyIterative(Array<Tk> okey, Array<Tv> oval)
47
50
dim_t okeyOffset = okeyWZ + y * okey.strides ()[1 ];
48
51
dim_t ovalOffset = ovalWZ + y * oval.strides ()[1 ];
49
52
50
- X. clear () ;
51
- std::transform (okey_ptr + okeyOffset, okey_ptr + okeyOffset + okey. dims ()[ 0 ],
52
- oval_ptr + ovalOffset,
53
- std::back_inserter (X),
54
- [](Tk v_, Tv i_) { return std::make_pair (v_, i_); }
55
- );
53
+ Tk *okey_col_ptr = okey_ptr + okeyOffset ;
54
+ Tv *oval_col_ptr = oval_ptr + ovalOffset;
55
+
56
+ for ( dim_t x = 0 ; x < size; x++) {
57
+ pairKeyVal[x] = std::make_tuple (okey_col_ptr[x], oval_col_ptr[x]);
58
+ }
56
59
57
- std::stable_sort (X. begin (), X. end () , IPCompare<Tk, Tv, isAscending>());
60
+ std::stable_sort (pairKeyVal, pairKeyVal + size , IPCompare<Tk, Tv, isAscending>());
58
61
59
- for (unsigned it = 0 ; it < X. size (); it ++) {
60
- okey_ptr[okeyOffset + it ] = X[it]. first ;
61
- oval_ptr[ovalOffset + it ] = X[it]. second ;
62
+ for (unsigned x = 0 ; x < size; x ++) {
63
+ okey_ptr[okeyOffset + x ] = std::get< 0 >(pairKeyVal[x]) ;
64
+ oval_ptr[ovalOffset + x ] = std::get< 1 >(pairKeyVal[x]) ;
62
65
}
63
66
}
64
67
}
65
68
}
66
69
70
+ memFree ((char *)pairKeyVal);
67
71
return ;
68
72
}
69
73
@@ -108,24 +112,27 @@ void sortByKeyBatched(Array<Tk> okey, Array<Tv> oval)
108
112
Tk *okey_ptr = okey.get ();
109
113
Tv *oval_ptr = oval.get ();
110
114
111
- std::vector<KeyIndexPair<Tk, Tv> > X;
112
- X.reserve (okey.elements ());
115
+ typedef KeyIndexPair<Tk, Tv> CurrentTuple;
116
+ size_t size = okey.elements ();
117
+ size_t bytes = okey.elements () * sizeof (CurrentTuple);
118
+ CurrentTuple *tupleKeyValIdx = (CurrentTuple *)memAlloc<char >(bytes);
113
119
114
- for (unsigned i = 0 ; i < okey. elements () ; i++) {
115
- X. push_back ( std::make_pair ( std::make_pair ( okey_ptr[i], oval_ptr[i]) , key[i]) );
120
+ for (unsigned i = 0 ; i < size ; i++) {
121
+ tupleKeyValIdx[i] = std::make_tuple ( okey_ptr[i], oval_ptr[i], key[i]);
116
122
}
117
123
118
124
memFree (key); // key is no longer required
119
125
120
- std::stable_sort (X. begin (), X. end () , KIPCompareV<Tk, Tv, isAscending>());
126
+ std::stable_sort (tupleKeyValIdx, tupleKeyValIdx + size , KIPCompareV<Tk, Tv, isAscending>());
121
127
122
- std::stable_sort (X. begin (), X. end () , KIPCompareK<Tk, Tv, true >());
128
+ std::stable_sort (tupleKeyValIdx, tupleKeyValIdx + size , KIPCompareK<Tk, Tv, true >());
123
129
124
- for (unsigned it = 0 ; it < okey.elements (); it ++) {
125
- okey_ptr[it ] = X[it]. first . first ;
126
- oval_ptr[it ] = X[it]. first . second ;
130
+ for (unsigned x = 0 ; x < okey.elements (); x ++) {
131
+ okey_ptr[x ] = std::get< 0 >(tupleKeyValIdx[x]) ;
132
+ oval_ptr[x ] = std::get< 1 >(tupleKeyValIdx[x]) ;
127
133
}
128
134
135
+ memFree ((char *)tupleKeyValIdx);
129
136
return ;
130
137
}
131
138
@@ -163,4 +170,3 @@ void sort0ByKey(Array<Tk> okey, Array<Tv> oval)
163
170
INSTANTIATE (Tk, uintl , dr)
164
171
}
165
172
}
166
-
0 commit comments