Skip to content

Commit b2acc91

Browse files
jasperzhongjasperzhong
authored
rename: more readable (#13)
1 parent 96c4154 commit b2acc91

File tree

7 files changed

+68
-54
lines changed

7 files changed

+68
-54
lines changed

‎byteps/common/compressor/strategy/onebit.cc

Lines changed: 31 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -40,9 +40,9 @@ OnebitCompressor::OnebitCompressor(bool use_scale) : _use_scale(use_scale){};
4040

4141
OnebitCompressor::~OnebitCompressor() = default;
4242

43-
template <typename T>
44-
static size_t _Packing(T* data, size_t len) {
45-
constexpr int PACKING_SIZE = sizeof(T) * 8;
43+
template <typename scalar_t>
44+
size_t OnebitCompressor::PackingImpl(scalar_t* data, size_t len) {
45+
constexpr int PACKING_SIZE = sizeof(scalar_t) * 8;
4646
size_t padding_len = (PACKING_SIZE - (len % PACKING_SIZE)) % PACKING_SIZE;
4747
size_t chunk_size = (len + padding_len) / PACKING_SIZE;
4848

@@ -53,22 +53,22 @@ static size_t _Packing(T* data, size_t len) {
5353
}
5454
}
5555

56-
return chunk_size * sizeof(T);
56+
return chunk_size * sizeof(scalar_t);
5757
}
5858

59-
static size_t Packing(void* data, size_t len, int dtype) {
59+
size_t OnebitCompressor::Packing(void* data, size_t len, int dtype) {
6060
switch (dtype) {
6161
case BYTEPS_INT8:
6262
case BYTEPS_UINT8:
63-
return _Packing(reinterpret_cast<int8_t*>(data), len);
63+
return PackingImpl(reinterpret_cast<int8_t*>(data), len);
6464
case BYTEPS_FLOAT16:
65-
return _Packing(reinterpret_cast<int16_t*>(data), len);
65+
return PackingImpl(reinterpret_cast<int16_t*>(data), len);
6666
case BYTEPS_INT32:
6767
case BYTEPS_FLOAT32:
68-
return _Packing(reinterpret_cast<int32_t*>(data), len);
68+
return PackingImpl(reinterpret_cast<int32_t*>(data), len);
6969
case BYTEPS_INT64:
7070
case BYTEPS_FLOAT64:
71-
return _Packing(reinterpret_cast<int64_t*>(data), len);
71+
return PackingImpl(reinterpret_cast<int64_t*>(data), len);
7272
default:
7373
BPS_CHECK(0) << "Unsupported data type: " << dtype;
7474
}
@@ -95,11 +95,13 @@ void OnebitCompressor::Compress(ByteBuf grad, int dtype, ByteBuf& compressed) {
9595
compressed.size = compressed_size + sizeof(float);
9696
}
9797

98-
template <typename T1, typename T2>
99-
static size_t _Unpacking(T1* dst, const T2* src, size_t size) {
100-
static_assert(sizeof(T1) == sizeof(T2), "T1 should be the same size as T2");
101-
constexpr int PACKING_SIZE = sizeof(T2) * 8;
102-
auto chunk_size = (size - sizeof(float)) / sizeof(T2);
98+
template <typename scalar_t, typename packing_t>
99+
size_t OnebitCompressor::UnpackingImpl(scalar_t* dst, const packing_t* src,
100+
size_t size) {
101+
static_assert(sizeof(scalar_t) == sizeof(packing_t),
102+
"scalar_t should be the same size as packing_t");
103+
constexpr int PACKING_SIZE = sizeof(packing_t) * 8;
104+
auto chunk_size = (size - sizeof(float)) / sizeof(packing_t);
103105

104106
float scale;
105107
auto pf = reinterpret_cast<const float*>(src + chunk_size);
@@ -118,30 +120,31 @@ static size_t _Unpacking(T1* dst, const T2* src, size_t size) {
118120
return chunk_size;
119121
}
120122

121-
static size_t Unpacking(void* dst, const void* src, size_t len, int dtype) {
123+
size_t OnebitCompressor::Unpacking(void* dst, const void* src, size_t len,
124+
int dtype) {
122125
switch (dtype) {
123126
case BYTEPS_INT8:
124-
return _Unpacking(reinterpret_cast<int8_t*>(dst),
125-
reinterpret_cast<const int8_t*>(src), len);
127+
return UnpackingImpl(reinterpret_cast<int8_t*>(dst),
128+
reinterpret_cast<const int8_t*>(src), len);
126129
case BYTEPS_UINT8:
127-
return _Unpacking(reinterpret_cast<uint8_t*>(dst),
128-
reinterpret_cast<const int8_t*>(src), len);
130+
return UnpackingImpl(reinterpret_cast<uint8_t*>(dst),
131+
reinterpret_cast<const int8_t*>(src), len);
129132
// TODO:
130133
// case BYTEPS_FLOAT16:
131-
// return _Unpacking(reinterpret_cast<uint16_t*>(dst),
134+
// return UnpackingImpl(reinterpret_cast<uint16_t*>(dst),
132135
// reinterpret_cast<const int16_t*>(src), len);
133136
case BYTEPS_INT32:
134-
return _Unpacking(reinterpret_cast<int32_t*>(dst),
135-
reinterpret_cast<const int32_t*>(src), len);
137+
return UnpackingImpl(reinterpret_cast<int32_t*>(dst),
138+
reinterpret_cast<const int32_t*>(src), len);
136139
case BYTEPS_FLOAT32:
137-
return _Unpacking(reinterpret_cast<float*>(dst),
138-
reinterpret_cast<const int32_t*>(src), len);
140+
return UnpackingImpl(reinterpret_cast<float*>(dst),
141+
reinterpret_cast<const int32_t*>(src), len);
139142
case BYTEPS_INT64:
140-
return _Unpacking(reinterpret_cast<int64_t*>(dst),
141-
reinterpret_cast<const int64_t*>(src), len);
143+
return UnpackingImpl(reinterpret_cast<int64_t*>(dst),
144+
reinterpret_cast<const int64_t*>(src), len);
142145
case BYTEPS_FLOAT64:
143-
return _Unpacking(reinterpret_cast<double*>(dst),
144-
reinterpret_cast<const int64_t*>(src), len);
146+
return UnpackingImpl(reinterpret_cast<double*>(dst),
147+
reinterpret_cast<const int64_t*>(src), len);
145148
default:
146149
BPS_CHECK(0) << "Unsupported data type: " << dtype;
147150
}

‎byteps/common/compressor/strategy/onebit.h

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ namespace compressor {
3838
*/
3939
class OnebitCompressor : public BaseCompressor {
4040
public:
41-
OnebitCompressor(bool use_scale=false);
41+
OnebitCompressor(bool use_scale = false);
4242
virtual ~OnebitCompressor();
4343

4444
/*!
@@ -65,6 +65,17 @@ class OnebitCompressor : public BaseCompressor {
6565
void Decompress(ByteBuf compressed, int dtype,
6666
ByteBuf& decompressed) override;
6767

68+
private:
69+
size_t Packing(void* data, size_t len, int dtype);
70+
71+
template <typename scalar_t>
72+
size_t PackingImpl(scalar_t* data, size_t len);
73+
74+
size_t Unpacking(void* dst, const void* src, size_t len, int dtype);
75+
76+
template <typename scalar_t, typename packing_t>
77+
size_t UnpackingImpl(scalar_t* dst, const packing_t* src, size_t size);
78+
6879
private:
6980
bool _use_scale;
7081
};

‎byteps/common/compressor/strategy/randomk.cc

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ RandomkCompressor::RandomkCompressor(int k) : _k(k) { _gen.seed(_rd()); };
4141

4242
RandomkCompressor::~RandomkCompressor() = default;
4343
template <typename index_t, typename scalar_t>
44-
size_t RandomkCompressor::_Packing(index_t* dst, const scalar_t* src,
44+
size_t RandomkCompressor::PackingImpl(index_t* dst, const scalar_t* src,
4545
size_t len) {
4646
static_assert(sizeof(index_t) == sizeof(scalar_t),
4747
"index_t should be the same size as scalar_t");
@@ -61,22 +61,22 @@ size_t RandomkCompressor::_Packing(index_t* dst, const scalar_t* src,
6161
size_t RandomkCompressor::Packing(const void* src, size_t size, int dtype) {
6262
switch (dtype) {
6363
case BYTEPS_INT8:
64-
return _Packing(reinterpret_cast<int8_t*>(_buf.get()),
64+
return PackingImpl(reinterpret_cast<int8_t*>(_buf.get()),
6565
reinterpret_cast<const int8_t*>(src),
6666
size / sizeof(int8_t));
6767
case BYTEPS_UINT8:
68-
return _Packing(reinterpret_cast<uint8_t*>(_buf.get()),
68+
return PackingImpl(reinterpret_cast<uint8_t*>(_buf.get()),
6969
reinterpret_cast<const uint8_t*>(src),
7070
size / sizeof(uint8_t));
7171
// case BYTEPS_FLOAT16:
7272
// return _Packing(reinterpret_cast<int8_t*>(_buf.get()),
7373
// reinterpret_cast<const int8_t*>(src), size);
7474
case BYTEPS_FLOAT32:
75-
return _Packing(reinterpret_cast<int32_t*>(_buf.get()),
75+
return PackingImpl(reinterpret_cast<int32_t*>(_buf.get()),
7676
reinterpret_cast<const float*>(src),
7777
size / sizeof(int32_t));
7878
case BYTEPS_FLOAT64:
79-
return _Packing(reinterpret_cast<int64_t*>(_buf.get()),
79+
return PackingImpl(reinterpret_cast<int64_t*>(_buf.get()),
8080
reinterpret_cast<const double*>(src),
8181
size / sizeof(int64_t));
8282
default:
@@ -91,7 +91,7 @@ void RandomkCompressor::Compress(ByteBuf grad, int dtype, ByteBuf& compressed) {
9191
}
9292

9393
template <typename index_t, typename scalar_t>
94-
size_t RandomkCompressor::_Unpacking(scalar_t* dst, const index_t* src,
94+
size_t RandomkCompressor::UnpackingImpl(scalar_t* dst, const index_t* src,
9595
size_t len) {
9696
static_assert(sizeof(index_t) == sizeof(scalar_t),
9797
"index_t should be the same size as scalar_t");
@@ -116,22 +116,22 @@ size_t RandomkCompressor::Unpacking(void* dst, const void* src, size_t size,
116116
int dtype) {
117117
switch (dtype) {
118118
case BYTEPS_INT8:
119-
return _Unpacking(reinterpret_cast<int8_t*>(dst),
119+
return UnpackingImpl(reinterpret_cast<int8_t*>(dst),
120120
reinterpret_cast<const int8_t*>(src),
121121
size / sizeof(int8_t) / 2);
122122
case BYTEPS_UINT8:
123-
return _Unpacking(reinterpret_cast<uint8_t*>(dst),
123+
return UnpackingImpl(reinterpret_cast<uint8_t*>(dst),
124124
reinterpret_cast<const uint8_t*>(src),
125125
size / sizeof(uint8_t) / 2);
126126
// case BYTEPS_FLOAT16:
127127
// return _Unpacking(reinterpret_cast<int8_t*>(_buf.get()),
128128
// reinterpret_cast<const int8_t*>(src), size);
129129
case BYTEPS_FLOAT32:
130-
return _Unpacking(reinterpret_cast<float*>(dst),
130+
return UnpackingImpl(reinterpret_cast<float*>(dst),
131131
reinterpret_cast<const int32_t*>(src),
132132
size / sizeof(float) / 2);
133133
case BYTEPS_FLOAT64:
134-
return _Unpacking(reinterpret_cast<double*>(dst),
134+
return UnpackingImpl(reinterpret_cast<double*>(dst),
135135
reinterpret_cast<const int64_t*>(src),
136136
size / sizeof(double) / 2);
137137
default:

‎byteps/common/compressor/strategy/randomk.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -64,12 +64,12 @@ class RandomkCompressor : public BaseCompressor {
6464
size_t Packing(const void* src, size_t size, int dtype);
6565

6666
template <typename index_t, typename scalar_t>
67-
size_t _Packing(index_t* dst, const scalar_t* src, size_t len);
67+
size_t PackingImpl(index_t* dst, const scalar_t* src, size_t len);
6868

6969
size_t Unpacking(void* dst, const void* src, size_t size, int dtype);
7070

7171
template <typename index_t, typename scalar_t>
72-
size_t _Unpacking(scalar_t* dst, const index_t* src, size_t len);
72+
size_t UnpackingImpl(scalar_t* dst, const index_t* src, size_t len);
7373

7474
private:
7575
int _k;

‎byteps/common/compressor/strategy/topk.cc

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -43,7 +43,7 @@ TopkCompressor::TopkCompressor(int k) : _k(k){};
4343
TopkCompressor::~TopkCompressor() = default;
4444

4545
template <typename index_t, typename scalar_t>
46-
size_t TopkCompressor::_Packing(index_t* dst, const scalar_t* src, size_t len) {
46+
size_t TopkCompressor::PackingImpl(index_t* dst, const scalar_t* src, size_t len) {
4747
static_assert(sizeof(index_t) == sizeof(scalar_t),
4848
"index_t should be the same size as scalar_t");
4949
BPS_CHECK_LE(this->_k, len / 2);
@@ -78,22 +78,22 @@ size_t TopkCompressor::_Packing(index_t* dst, const scalar_t* src, size_t len) {
7878
size_t TopkCompressor::Packing(const void* src, size_t size, int dtype) {
7979
switch (dtype) {
8080
case BYTEPS_INT8:
81-
return _Packing(reinterpret_cast<int8_t*>(_buf.get()),
81+
return PackingImpl(reinterpret_cast<int8_t*>(_buf.get()),
8282
reinterpret_cast<const int8_t*>(src),
8383
size / sizeof(int8_t));
8484
case BYTEPS_UINT8:
85-
return _Packing(reinterpret_cast<uint8_t*>(_buf.get()),
85+
return PackingImpl(reinterpret_cast<uint8_t*>(_buf.get()),
8686
reinterpret_cast<const uint8_t*>(src),
8787
size / sizeof(uint8_t));
8888
// case BYTEPS_FLOAT16:
8989
// return _Packing(reinterpret_cast<int8_t*>(_buf.get()),
9090
// reinterpret_cast<const int8_t*>(src), size);
9191
case BYTEPS_FLOAT32:
92-
return _Packing(reinterpret_cast<int32_t*>(_buf.get()),
92+
return PackingImpl(reinterpret_cast<int32_t*>(_buf.get()),
9393
reinterpret_cast<const float*>(src),
9494
size / sizeof(int32_t));
9595
case BYTEPS_FLOAT64:
96-
return _Packing(reinterpret_cast<int64_t*>(_buf.get()),
96+
return PackingImpl(reinterpret_cast<int64_t*>(_buf.get()),
9797
reinterpret_cast<const double*>(src),
9898
size / sizeof(int64_t));
9999
default:
@@ -108,7 +108,7 @@ void TopkCompressor::Compress(ByteBuf grad, int dtype, ByteBuf& compressed) {
108108
}
109109

110110
template <typename index_t, typename scalar_t>
111-
size_t TopkCompressor::_Unpacking(scalar_t* dst, const index_t* src,
111+
size_t TopkCompressor::UnpackingImpl(scalar_t* dst, const index_t* src,
112112
size_t len) {
113113
static_assert(sizeof(index_t) == sizeof(scalar_t),
114114
"index_t should be the same size as scalar_t");
@@ -133,22 +133,22 @@ size_t TopkCompressor::Unpacking(void* dst, const void* src, size_t size,
133133
int dtype) {
134134
switch (dtype) {
135135
case BYTEPS_INT8:
136-
return _Unpacking(reinterpret_cast<int8_t*>(dst),
136+
return UnpackingImpl(reinterpret_cast<int8_t*>(dst),
137137
reinterpret_cast<const int8_t*>(src),
138138
size / sizeof(int8_t) / 2);
139139
case BYTEPS_UINT8:
140-
return _Unpacking(reinterpret_cast<uint8_t*>(dst),
140+
return UnpackingImpl(reinterpret_cast<uint8_t*>(dst),
141141
reinterpret_cast<const uint8_t*>(src),
142142
size / sizeof(uint8_t) / 2);
143143
// case BYTEPS_FLOAT16:
144144
// return _Unpacking(reinterpret_cast<int8_t*>(_buf.get()),
145145
// reinterpret_cast<const int8_t*>(src), size);
146146
case BYTEPS_FLOAT32:
147-
return _Unpacking(reinterpret_cast<float*>(dst),
147+
return UnpackingImpl(reinterpret_cast<float*>(dst),
148148
reinterpret_cast<const int32_t*>(src),
149149
size / sizeof(float) / 2);
150150
case BYTEPS_FLOAT64:
151-
return _Unpacking(reinterpret_cast<double*>(dst),
151+
return UnpackingImpl(reinterpret_cast<double*>(dst),
152152
reinterpret_cast<const int64_t*>(src),
153153
size / sizeof(double) / 2);
154154
default:

‎byteps/common/compressor/strategy/topk.h

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -65,12 +65,12 @@ class TopkCompressor : public BaseCompressor {
6565
size_t Packing(const void* src, size_t size, int dtype);
6666

6767
template <typename index_t, typename scalar_t>
68-
size_t _Packing(index_t* dst, const scalar_t* src, size_t len);
68+
size_t PackingImpl(index_t* dst, const scalar_t* src, size_t len);
6969

7070
size_t Unpacking(void* dst, const void* src, size_t size, int dtype);
7171

7272
template <typename index_t, typename scalar_t>
73-
size_t _Unpacking(scalar_t* dst, const index_t* src, size_t len);
73+
size_t UnpackingImpl(scalar_t* dst, const index_t* src, size_t len);
7474

7575
private:
7676
int _k;

‎byteps/common/global.cc

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -216,8 +216,8 @@ void BytePSGlobal::Init() {
216216
size_t pool_size = 4;
217217
if (getenv("BYTEPS_THREADPOOL_SIZE")) {
218218
pool_size = atoi(getenv("BYTEPS_THREADPOOL_SIZE"));
219+
_thread_pool.reset(new ThreadPool(pool_size));
219220
}
220-
_thread_pool.reset(new ThreadPool(pool_size));
221221
}
222222

223223
// ReadyTable for cross-PCIe-switch reduce

0 commit comments

Comments
 (0)