Skip to content

Commit 120f8d0

Browse files
va-kuznecovva-kuznecov
authored
Add new UT in PDisk for TEvChunkWrite contract (#12298)
1 parent f3b158a commit 120f8d0

8 files changed

+142
-60
lines changed

‎ydb/core/blobstorage/pdisk/blobstorage_pdisk.h

Lines changed: 10 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -976,46 +976,20 @@ struct TEvChunkWrite : public TEventLocal<TEvChunkWrite, TEvBlobStorage::EvChunk
976976
class TBufBackedUpParts : public IParts {
977977
public:
978978
TBufBackedUpParts(TTrackableBuffer &&buf)
979-
: Buffers({std::move(buf)})
979+
: Buffer(std::move(buf))
980980
{}
981981

982-
virtual TDataRef operator[] (ui32 i) const override {
983-
Y_DEBUG_ABORT_UNLESS(i < Buffers.size());
984-
return TDataRef(Buffers[i].Data(), Buffers[i].Size());
985-
}
986-
987-
virtual ui32 Size() const override {
988-
return Buffers.size();
989-
}
990-
991-
void AppendBuffer(TTrackableBuffer&& buffer) {
992-
Buffers.push_back(std::move(buffer));
993-
}
994-
995-
private:
996-
TVector<TTrackableBuffer> Buffers;
997-
};
998-
999-
///////////////////// TStrokaBackedUpParts //////////////////////////////
1000-
class TStrokaBackedUpParts : public IParts {
1001-
public:
1002-
TStrokaBackedUpParts(TString &buf)
1003-
: Buf()
1004-
{
1005-
Buf.swap(buf);
1006-
}
1007-
1008982
virtual TDataRef operator[] (ui32 i) const override {
1009983
Y_DEBUG_ABORT_UNLESS(i == 0);
1010-
return TDataRef(Buf.data(), (ui32)Buf.size());
984+
return TDataRef(Buffer.Data(), Buffer.Size());
1011985
}
1012986

1013987
virtual ui32 Size() const override {
1014988
return 1;
1015989
}
1016990

1017991
private:
1018-
TString Buf;
992+
TTrackableBuffer Buffer;
1019993
};
1020994

1021995
///////////////////// TAlignedParts //////////////////////////////
@@ -1024,6 +998,11 @@ struct TEvChunkWrite : public TEventLocal<TEvChunkWrite, TEvBlobStorage::EvChunk
1024998
size_t FullSize;
1025999

10261000
public:
1001+
TAlignedParts(TString&& data)
1002+
: Data(std::move(data))
1003+
, FullSize(Data.size())
1004+
{}
1005+
10271006
TAlignedParts(TString&& data, size_t fullSize)
10281007
: Data(std::move(data))
10291008
, FullSize(fullSize)
@@ -1046,7 +1025,7 @@ struct TEvChunkWrite : public TEventLocal<TEvChunkWrite, TEvBlobStorage::EvChunk
10461025
}
10471026
};
10481027

1049-
///////////////////// TAlignedParts //////////////////////////////
1028+
///////////////////// TRopeAlignedParts //////////////////////////////
10501029
class TRopeAlignedParts : public IParts {
10511030
TRope Data; // we shall keep the rope here to prevent it from being freed
10521031
TVector<TDataRef> Refs;
@@ -1567,7 +1546,7 @@ struct TEvWriteMetadataResult : TEventLocal<TEvWriteMetadataResult, TEvBlobStora
15671546
struct TPDiskCtx {
15681547
TActorSystem * const ActorSystem = nullptr;
15691548
const ui32 PDiskId = 0;
1570-
const TActorId PDiskActor;
1549+
const TActorId PDiskActor;
15711550
// TPDiskMon * const Mon = nullptr; TODO implement it
15721551

15731552
TPDiskCtx() = default;

‎ydb/core/blobstorage/pdisk/blobstorage_pdisk_impl.cpp

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2864,6 +2864,13 @@ bool TPDisk::PreprocessRequest(TRequestBase *request) {
28642864
delete request;
28652865
return false;
28662866
}
2867+
if (ev.Offset % GetChunkAppendBlockSize() != 0) {
2868+
err << Sprintf("Can't write chunkIdx# %" PRIu32 " with not aligned offset# %" PRIu32 " ownerId# %"
2869+
PRIu32, ev.ChunkIdx, ev.Offset, (ui32)ev.Owner);
2870+
SendChunkWriteError(ev, err.Str(), NKikimrProto::ERROR);
2871+
delete request;
2872+
return false;
2873+
}
28672874
if (ev.ChunkIdx > ChunkState.size()) {
28682875
err << Sprintf("Can't write chunk: chunkIdx# %" PRIu32
28692876
" is too large (total# %" PRIu32 ") ownerId# %" PRIu32,

‎ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp

Lines changed: 112 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -448,10 +448,9 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
448448
UNIT_ASSERT(vdisk.Chunks[EChunkState::COMMITTED].size() == 1);
449449
const ui32 reservedChunk = *vdisk.Chunks[EChunkState::COMMITTED].begin();
450450

451-
TString chunkWriteData = PrepareData(1024);
452451
testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(
453452
new NPDisk::TEvChunkWrite(vdisk.PDiskParams->Owner, vdisk.PDiskParams->OwnerRound,
454-
reservedChunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(chunkWriteData), nullptr, false, 0),
453+
reservedChunk, 0, new NPDisk::TEvChunkWrite::TAlignedParts(PrepareData(1024)), nullptr, false, 0),
455454
NKikimrProto::OK);
456455

457456
bool printed = false;
@@ -493,9 +492,8 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
493492
ui32 errors = 0;
494493
bool printed = false;
495494
for (ui32 i = 0; i < 10'000; ++i) {
496-
TString data = PrepareData(1024);
497495
testCtx.Send(new NPDisk::TEvChunkWrite(evInitRes->PDiskParams->Owner, evInitRes->PDiskParams->OwnerRound,
498-
reservedChunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(data), nullptr, false, 0));
496+
reservedChunk, 0, new NPDisk::TEvChunkWrite::TAlignedParts(PrepareData(1024)), nullptr, false, 0));
499497

500498
const auto res = testCtx.Recv<NPDisk::TEvChunkWriteResult>();
501499
//Ctest << res->ToString() << Endl;
@@ -796,9 +794,8 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
796794
UNIT_ASSERT_VALUES_EQUAL(evReadRes->Data.ToString(), data);
797795
};
798796

799-
TString dataCopy = data;
800797
testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
801-
chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0),
798+
chunk, 0, new NPDisk::TEvChunkWrite::TAlignedParts(TString(data)), nullptr, false, 0),
802799
NKikimrProto::OK);
803800
mock.CommitReservedChunks();
804801

@@ -842,9 +839,8 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
842839
mock.ReserveChunk();
843840
const ui32 chunk = *mock.Chunks[EChunkState::RESERVED].begin();
844841

845-
TString dataCopy = data;
846842
testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
847-
chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0),
843+
chunk, 0, new NPDisk::TEvChunkWrite::TAlignedParts(TString(data)), nullptr, false, 0),
848844
NKikimrProto::OK);
849845
mock.CommitReservedChunks();
850846
testCtx.TestResponse<NPDisk::TEvCheckSpaceResult>(
@@ -954,8 +950,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
954950
auto chunk1 = *vdisk1.Chunks[EChunkState::COMMITTED].begin();
955951
auto chunk2 = *vdisk2.Chunks[EChunkState::COMMITTED].begin();
956952

957-
TString data(123, '0');
958-
auto parts = MakeIntrusive<NPDisk::TEvChunkWrite::TStrokaBackedUpParts>(data);
953+
auto parts = MakeIntrusive<NPDisk::TEvChunkWrite::TAlignedParts>(TString(123, '0'));
959954

960955
// write to own chunk is OK
961956
testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(
@@ -996,8 +991,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
996991
for (ui32 i = 0; i < 100; ++i) {
997992
testCtx.Send(new NPDisk::TEvLog(
998993
vdisk.PDiskParams->Owner, vdisk.PDiskParams->OwnerRound, 0, TRcBuf(PrepareData(logBuffSize)), vdisk.GetLsnSeg(), nullptr));
999-
auto data = PrepareData(chunkBuffSize);
1000-
auto parts = MakeIntrusive<NPDisk::TEvChunkWrite::TStrokaBackedUpParts>(data);
994+
auto parts = MakeIntrusive<NPDisk::TEvChunkWrite::TAlignedParts>(PrepareData(chunkBuffSize));
1001995
testCtx.Send(new NPDisk::TEvChunkWrite(
1002996
vdisk.PDiskParams->Owner, vdisk.PDiskParams->OwnerRound,
1003997
chunk, 0, parts, nullptr, false, 0));
@@ -1028,6 +1022,112 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
10281022
Cerr << "all log writes are received" << Endl;
10291023
}
10301024
}
1025+
1026+
NPDisk::TEvChunkWrite::TPartsPtr GenParts(TReallyFastRng32& rng, size_t size) {
1027+
static int testCase = 0;
1028+
switch(testCase++) {
1029+
case 0: {
1030+
auto data = PrepareData(size);
1031+
1032+
auto counter = MakeIntrusive<::NMonitoring::TCounterForPtr>();
1033+
TMemoryConsumer consumer(counter);
1034+
TTrackableBuffer buffer(std::move(consumer), data.data(), data.size());
1035+
return MakeIntrusive<NPDisk::TEvChunkWrite::TBufBackedUpParts>(std::move(buffer));
1036+
}
1037+
case 1: {
1038+
size_t partsCount = rng.Uniform(1, 10);
1039+
TRope rope;
1040+
size_t createdBytes = 0;
1041+
if (size >= partsCount) {
1042+
for (size_t i = 0; i < partsCount - 1; ++i) {
1043+
TRope x(PrepareData(rng.Uniform(1, size / partsCount)));
1044+
createdBytes += x.size();
1045+
rope.Insert(rope.End(), std::move(x));
1046+
}
1047+
}
1048+
if (createdBytes < size) {
1049+
rope.Insert(rope.End(), TRope(PrepareData(size - createdBytes)));
1050+
}
1051+
return MakeIntrusive<NPDisk::TEvChunkWrite::TRopeAlignedParts>(std::move(rope), size);
1052+
}
1053+
case 2: {
1054+
testCase = 0;
1055+
return MakeIntrusive<NPDisk::TEvChunkWrite::TAlignedParts>(PrepareData(size));
1056+
}
1057+
}
1058+
UNIT_ASSERT(false);
1059+
return nullptr;
1060+
}
1061+
1062+
TString ConvertIPartsToString(NPDisk::TEvChunkWrite::IParts* parts) {
1063+
auto data = TString::Uninitialized(parts->ByteSize());
1064+
char *ptr = data.Detach();
1065+
for (ui32 i = 0; i < parts->Size(); ++i) {
1066+
auto [buf, bufSize] = (*parts)[i];
1067+
memcpy(ptr, buf, bufSize);
1068+
ptr += bufSize;
1069+
}
1070+
return data;
1071+
}
1072+
1073+
Y_UNIT_TEST(ChunkWriteDifferentOffsetAndSize) {
1074+
TActorTestContext testCtx{{}};
1075+
1076+
TVDiskMock vdisk(&testCtx);
1077+
vdisk.InitFull();
1078+
1079+
vdisk.ReserveChunk();
1080+
vdisk.CommitReservedChunks();
1081+
UNIT_ASSERT(vdisk.Chunks[EChunkState::COMMITTED].size() == 1);
1082+
const ui32 reservedChunk = *vdisk.Chunks[EChunkState::COMMITTED].begin();
1083+
1084+
auto seed = TInstant::Now().MicroSeconds();
1085+
Cerr << "seed# " << seed << Endl;
1086+
TReallyFastRng32 rng(seed);
1087+
1088+
auto blockSize = vdisk.PDiskParams->AppendBlockSize;
1089+
size_t maxSize = 8 * blockSize;
1090+
for (ui32 offset = 0; offset <= vdisk.PDiskParams->ChunkSize - maxSize; offset += rng.Uniform(vdisk.PDiskParams->ChunkSize / 100)) {
1091+
offset = offset / blockSize * blockSize;
1092+
auto size = rng.Uniform(1, maxSize + 1); // + 1 for maxSize to be included in distribution
1093+
NPDisk::TEvChunkWrite::TPartsPtr parts = GenParts(rng, size);
1094+
Ctest << "offset# " << offset << " size# " << size << Endl;
1095+
testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(
1096+
new NPDisk::TEvChunkWrite(vdisk.PDiskParams->Owner, vdisk.PDiskParams->OwnerRound,
1097+
reservedChunk, offset, parts, nullptr, false, 0),
1098+
NKikimrProto::OK);
1099+
auto res = testCtx.TestResponse<NPDisk::TEvChunkReadResult>(
1100+
new NPDisk::TEvChunkRead(vdisk.PDiskParams->Owner, vdisk.PDiskParams->OwnerRound,
1101+
reservedChunk, offset, size, 0, 0),
1102+
NKikimrProto::OK);
1103+
UNIT_ASSERT(ConvertIPartsToString(parts.Get()) == res->Data.ToString().Slice());
1104+
}
1105+
}
1106+
1107+
Y_UNIT_TEST(ChunkWriteBadOffset) {
1108+
TActorTestContext testCtx{{}};
1109+
1110+
TVDiskMock vdisk(&testCtx);
1111+
vdisk.InitFull();
1112+
1113+
vdisk.ReserveChunk();
1114+
vdisk.CommitReservedChunks();
1115+
UNIT_ASSERT(vdisk.Chunks[EChunkState::COMMITTED].size() == 1);
1116+
const ui32 reservedChunk = *vdisk.Chunks[EChunkState::COMMITTED].begin();
1117+
1118+
auto seed = TInstant::Now().MicroSeconds();
1119+
Cerr << "seed# " << seed << Endl;
1120+
TReallyFastRng32 rng(seed);
1121+
1122+
auto blockSize = vdisk.PDiskParams->AppendBlockSize;
1123+
for (ui32 offset = 1; offset < blockSize; offset += rng.Uniform(1, blockSize / 20)) {
1124+
NPDisk::TEvChunkWrite::TPartsPtr parts = GenParts(rng, 1);
1125+
testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(
1126+
new NPDisk::TEvChunkWrite(vdisk.PDiskParams->Owner, vdisk.PDiskParams->OwnerRound,
1127+
reservedChunk, offset, parts, nullptr, false, 0),
1128+
NKikimrProto::ERROR);
1129+
}
1130+
}
10311131
}
10321132

10331133
Y_UNIT_TEST_SUITE(PDiskCompatibilityInfo) {

‎ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_actions.cpp

Lines changed: 6 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -267,16 +267,18 @@ void TTestIncorrectRequests::TestFSM(const TActorContext &ctx) {
267267
case 170:
268268
TEST_RESPONSE(EvChunkWriteResult, ERROR);
269269
VERBOSE_COUT(" Sending TEvChunkWrite that actually does the thing");
270-
ctx.Send(Yard, new NPDisk::TEvChunkWrite(Owner, OwnerRound, ChunkIdx0, ChunkWriteData.size(),
270+
ctx.Send(Yard, new NPDisk::TEvChunkWrite(Owner, OwnerRound, ChunkIdx0, 0,
271271
new NPDisk::TEvChunkWrite::TNonOwningParts(ChunkWriteParts.Get(), 1), (void*)42, false, 1));
272272
break;
273-
case 180:
273+
case 180: {
274274
TEST_RESPONSE(EvChunkWriteResult, OK);
275275
ChunkIdx = LastResponse.ChunkIdx;
276+
size_t blockSize = LastResponse.AppendBlockSize;
276277
VERBOSE_COUT(" Sending TEvChunkWrite");
277-
ctx.Send(Yard, new NPDisk::TEvChunkWrite(Owner, OwnerRound, ChunkIdx, ChunkWriteData.size() / 2,
278+
ctx.Send(Yard, new NPDisk::TEvChunkWrite(Owner, OwnerRound, ChunkIdx, ChunkWriteData.size() / 2 / blockSize * blockSize,
278279
new NPDisk::TEvChunkWrite::TNonOwningParts(ChunkWriteParts.Get(), 1), (void*)42, false, 1));
279280
break;
281+
}
280282
case 190:
281283
TEST_RESPONSE(EvChunkWriteResult, OK);
282284
VERBOSE_COUT(" Sending TEvInit for invalid id");
@@ -3411,7 +3413,7 @@ void TTestChunkDeletionWhileWritingIt::TestFSM(const TActorContext &ctx) {
34113413
ChunkWriteData = PrepareData(ChunkSize - 1);
34123414
ChunkWriteParts[0].Data = ChunkWriteData.data();
34133415
ChunkWriteParts[0].Size = (ui32)ChunkWriteData.size();
3414-
ctx.Send(Yard, new NPDisk::TEvChunkWrite(Owner, OwnerRound, ChunkIdx, 1,
3416+
ctx.Send(Yard, new NPDisk::TEvChunkWrite(Owner, OwnerRound, ChunkIdx, 0,
34153417
new NPDisk::TEvChunkWrite::TNonOwningParts(ChunkWriteParts.Get(), 1), (void*)42, false, 5));
34163418

34173419
VERBOSE_COUT(" Sending TEvLog to commit");

‎ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -52,9 +52,8 @@ void TestChunkWriteReleaseRun() {
5252
pDisk->ProcessLogWriteQueueAndCommits();
5353

5454
{
55-
TString chunkWriteData = PrepareData(1024);
5655
NPDisk::TEvChunkWrite ev(evInitRes->PDiskParams->Owner, evInitRes->PDiskParams->OwnerRound, reservedChunk,
57-
0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(chunkWriteData), nullptr, false, 0);
56+
0, new NPDisk::TEvChunkWrite::TAlignedParts(PrepareData(1024)), nullptr, false, 0);
5857
NPDisk::TChunkWrite *chunkWrite = new NPDisk::TChunkWrite(ev, testCtx.Sender, {}, {});
5958
bool ok = pDisk->PreprocessRequest(chunkWrite);
6059
UNIT_ASSERT(!ok);

‎ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_races.cpp

Lines changed: 4 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -45,9 +45,8 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
4545
while (mock.Chunks[EChunkState::COMMITTED].size() > 0) {
4646
auto it = mock.Chunks[EChunkState::COMMITTED].begin();
4747
for (ui32 i = 0; i < inflight; ++i) {
48-
TString dataCopy = data;
4948
testCtx.Send(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
50-
*it, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0));
49+
*it, 0, new NPDisk::TEvChunkWrite::TAlignedParts(TString(data)), nullptr, false, 0));
5150
}
5251
NPDisk::TCommitRecord rec;
5352
rec.DeleteChunks.push_back(*it);
@@ -112,9 +111,8 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
112111

113112
auto sendManyWrites = [&](TVDiskMock& mock, TChunkIdx chunk, ui32 number, ui64& cookie) {
114113
for (ui32 i = 0; i < number; ++i) {
115-
TString dataCopy = data;
116114
testCtx.Send(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
117-
chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), (void*)(cookie++), false, 0));
115+
chunk, 0, new NPDisk::TEvChunkWrite::TAlignedParts(TString(data)), (void*)(cookie++), false, 0));
118116
}
119117
};
120118

@@ -128,9 +126,8 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
128126
{
129127
auto& chunkIds = mock.Chunks[EChunkState::COMMITTED];
130128
for (auto it = chunkIds.begin(); it != chunkIds.end(); ++it) {
131-
TString dataCopy = data;
132129
testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
133-
*it, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), (void*)10, false, 0),
130+
*it, 0, new NPDisk::TEvChunkWrite::TAlignedParts(TString(data)), (void*)10, false, 0),
134131
NKikimrProto::OK);
135132
}
136133
}
@@ -216,9 +213,8 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
216213
while (mock.Chunks[EChunkState::COMMITTED].size() > 0) {
217214
auto it = mock.Chunks[EChunkState::COMMITTED].begin();
218215
for (ui32 i = 0; i < inflight; ++i) {
219-
TString dataCopy = data;
220216
testCtx.Send(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
221-
*it, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0));
217+
*it, 0, new NPDisk::TEvChunkWrite::TAlignedParts(TString(data)), nullptr, false, 0));
222218
}
223219
NPDisk::TCommitRecord rec;
224220
rec.DeleteChunks.push_back(*it);

‎ydb/core/blobstorage/ut_pdiskfit/lib/basic_test.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -787,7 +787,7 @@ class TFakeVDisk
787787
void *cookie = reinterpret_cast<void *>(NextWriteCookie++);
788788

789789
SendPDiskRequest(ctx, new NPDisk::TEvChunkWrite(PDiskParams->Owner, PDiskParams->OwnerRound, it->first,
790-
offsetInBlocks * PDiskParams->AppendBlockSize, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(data),
790+
offsetInBlocks * PDiskParams->AppendBlockSize, new NPDisk::TEvChunkWrite::TAlignedParts(TString(data)),
791791
cookie, true, NPriWrite::HullHugeAsyncBlob), [&] {
792792
State.WritesInFlight.push_back(TWriteRecord{it->first, offsetInBlocks, numBlocks, std::move(checksums),
793793
cookie});

‎ydb/core/load_test/pdisk_read.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -263,9 +263,8 @@ class TPDiskReaderLoadTestActor : public TActorBootstrapped<TPDiskReaderLoadTest
263263
TChunkIdx chunkIdx = msg->ChunkIds[i];
264264
Chunks[i].Idx = chunkIdx;
265265
ui64 requestIdx = NewTRequestInfo((ui32)DataBuffer.size(), chunkIdx, TAppData::TimeProvider->Now());
266-
TString tmp = DataBuffer;
267266
SendRequest(ctx, std::make_unique<NPDisk::TEvChunkWrite>(PDiskParams->Owner, PDiskParams->OwnerRound,
268-
chunkIdx, 0u, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(tmp),
267+
chunkIdx, 0u, new NPDisk::TEvChunkWrite::TAlignedParts(TString(DataBuffer)),
269268
reinterpret_cast<void*>(requestIdx), true, NPriWrite::HullHugeAsyncBlob, Sequential));
270269
++ChunkWrite_RequestsSent;
271270
}

0 commit comments

Comments
 (0)