Skip to content

Commit 84980cf

Browse files
maximyurchukmaximyurchuk
authored
Remove KIKIMR_PDISK_ENABLE_T1HA_HASH_WRITING (#6439)
1 parent 5d591e7 commit 84980cf

19 files changed

+65
-127
lines changed

‎ydb/core/base/compile_time_flags.h

-4
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,3 @@
1717
#ifndef KIKIMR_ALLOW_SSREPLICA_PROBES
1818
#define KIKIMR_ALLOW_SSREPLICA_PROBES 0
1919
#endif
20-
// This feature flag enables PDisk to use t1ha hash in sector footer checksums
21-
#ifndef KIKIMR_PDISK_ENABLE_T1HA_HASH_WRITING
22-
#define KIKIMR_PDISK_ENABLE_T1HA_HASH_WRITING true
23-
#endif

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

+2-3
Original file line numberDiff line numberDiff line change
@@ -116,7 +116,7 @@ void TCompletionLogWrite::Release(TActorSystem *actorSystem) {
116116

117117
TCompletionChunkReadPart::TCompletionChunkReadPart(TPDisk *pDisk, TIntrusivePtr<TChunkRead> &read, ui64 rawReadSize,
118118
ui64 payloadReadSize, ui64 commonBufferOffset, TCompletionChunkRead *cumulativeCompletion, bool isTheLastPart,
119-
const TControlWrapper& useT1ha0Hasher, NWilson::TSpan&& span)
119+
NWilson::TSpan&& span)
120120
: TCompletionAction()
121121
, PDisk(pDisk)
122122
, Read(read)
@@ -126,7 +126,6 @@ TCompletionChunkReadPart::TCompletionChunkReadPart(TPDisk *pDisk, TIntrusivePtr<
126126
, CumulativeCompletion(cumulativeCompletion)
127127
, Buffer(PDisk->BufferPool->Pop())
128128
, IsTheLastPart(isTheLastPart)
129-
, UseT1ha0Hasher(useT1ha0Hasher)
130129
, Span(std::move(span))
131130
{
132131
if (!IsTheLastPart) {
@@ -192,7 +191,7 @@ void TCompletionChunkReadPart::Exec(TActorSystem *actorSystem) {
192191
format, actorSystem, PDisk->PDiskActor, PDisk->PDiskId, &PDisk->Mon, PDisk->BufferPool.Get());
193192
ui64 lastNonce = Min((ui64)0, chunkNonce - 1);
194193
restorator.Restore(source, format.Offset(Read->ChunkIdx, sectorIdx), format.MagicDataChunk, lastNonce,
195-
UseT1ha0Hasher, Read->Owner);
194+
Read->Owner);
196195

197196
const ui32 sectorCount = 1;
198197
if (restorator.GoodSectorCount != sectorCount) {

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

+2-3
Original file line numberDiff line numberDiff line change
@@ -224,12 +224,11 @@ class TCompletionChunkReadPart : public TCompletionAction {
224224
TCompletionChunkRead *CumulativeCompletion;
225225
TBuffer::TPtr Buffer;
226226
bool IsTheLastPart;
227-
TControlWrapper UseT1ha0Hasher;
228227
NWilson::TSpan Span;
229228
public:
230229
TCompletionChunkReadPart(TPDisk *pDisk, TIntrusivePtr<TChunkRead> &read, ui64 rawReadSize, ui64 payloadReadSize,
231-
ui64 commonBufferOffset, TCompletionChunkRead *cumulativeCompletion, bool isTheLastPart,
232-
const TControlWrapper& useT1ha0Hasher, NWilson::TSpan&& span);
230+
ui64 commonBufferOffset, TCompletionChunkRead *cumulativeCompletion, bool isTheLastPart,
231+
NWilson::TSpan&& span);
233232

234233

235234
bool CanHandleResult() const override {

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

-2
Original file line numberDiff line numberDiff line change
@@ -128,7 +128,6 @@ struct TPDiskConfig : public TThrRefBase {
128128
ui32 BufferPoolBufferCount = 256;
129129
ui32 MaxQueuedCompletionActions = 128; // BufferPoolBufferCount / 2;
130130
bool UseSpdkNvmeDriver;
131-
TControlWrapper UseT1ha0HashInFooter;
132131

133132
ui64 ExpectedSlotCount = 0;
134133

@@ -161,7 +160,6 @@ struct TPDiskConfig : public TThrRefBase {
161160
, PDiskGuid(pDiskGuid)
162161
, PDiskId(pdiskId)
163162
, PDiskCategory(pDiskCategory)
164-
, UseT1ha0HashInFooter(KIKIMR_PDISK_ENABLE_T1HA_HASH_WRITING, 0, 1)
165163
{
166164
Initialize();
167165
}

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

+3-22
Original file line numberDiff line numberDiff line change
@@ -12,17 +12,7 @@ namespace NPDisk {
1212
////////////////////////////////////////////////////////////////////////////
1313

1414
class TPDiskHashCalculator : public THashCalculator {
15-
bool UseT1ha0Hasher;
16-
1715
public:
18-
TPDiskHashCalculator(bool useT1ha0Hasher)
19-
: UseT1ha0Hasher(useT1ha0Hasher)
20-
{}
21-
22-
void SetUseT1ha0Hasher(bool x) {
23-
UseT1ha0Hasher = x;
24-
};
25-
2616
ui64 OldHashSector(const ui64 sectorOffset, const ui64 magic, const ui8 *sector,
2717
const ui32 sectorSize) {
2818
REQUEST_VALGRIND_CHECK_MEM_IS_DEFINED(&sectorOffset, sizeof sectorOffset);
@@ -50,25 +40,16 @@ class TPDiskHashCalculator : public THashCalculator {
5040

5141
ui64 HashSector(const ui64 sectorOffset, const ui64 magic, const ui8 *sector,
5242
const ui32 sectorSize) {
53-
if (UseT1ha0Hasher) {
54-
return T1ha0HashSector<TT1ha0NoAvxHasher>(sectorOffset, magic, sector, sectorSize);
55-
} else {
56-
return OldHashSector(sectorOffset, magic, sector, sectorSize);
57-
}
43+
return T1ha0HashSector<TT1ha0NoAvxHasher>(sectorOffset, magic, sector, sectorSize);
5844
}
5945

6046
bool CheckSectorHash(const ui64 sectorOffset, const ui64 magic, const ui8 *sector,
6147
const ui32 sectorSize, const ui64 sectorHash) {
6248
// On production servers may be two versions.
6349
// If by default used OldHash version, then use it first
6450
// If by default used T1ha0NoAvx version, then use it
65-
if (UseT1ha0Hasher) {
66-
return sectorHash == T1ha0HashSector<TT1ha0NoAvxHasher>(sectorOffset, magic, sector, sectorSize)
67-
|| sectorHash == OldHashSector(sectorOffset, magic, sector, sectorSize);
68-
} else {
69-
return sectorHash == OldHashSector(sectorOffset, magic, sector, sectorSize)
70-
|| sectorHash == T1ha0HashSector<TT1ha0NoAvxHasher>(sectorOffset, magic, sector, sectorSize);
71-
}
51+
return sectorHash == T1ha0HashSector<TT1ha0NoAvxHasher>(sectorOffset, magic, sector, sectorSize)
52+
|| sectorHash == OldHashSector(sectorOffset, magic, sector, sectorSize);
7253
}
7354
};
7455

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

+4-4
Original file line numberDiff line numberDiff line change
@@ -659,7 +659,7 @@ struct TDiskFormat {
659659

660660
void InitMagic() {
661661
MagicFormatChunk = MagicFormatChunkId;
662-
NPDisk::TPDiskHashCalculator hash(false);
662+
NPDisk::TPDiskHashCalculator hash;
663663
hash.Hash(&Guid, sizeof(Guid));
664664
hash.Hash(&MagicNextLogChunkReferenceId, sizeof(MagicNextLogChunkReferenceId));
665665
MagicNextLogChunkReference = hash.GetHashResult();
@@ -686,7 +686,7 @@ struct TDiskFormat {
686686
}
687687

688688
bool IsHashOk(ui64 bufferSize) const {
689-
NPDisk::TPDiskHashCalculator hashCalculator(false);
689+
NPDisk::TPDiskHashCalculator hashCalculator;
690690
if (Version == 2) {
691691
ui64 size = (char*)&HashVersion2 - (char*)this;
692692
hashCalculator.Hash(this, size);
@@ -709,7 +709,7 @@ struct TDiskFormat {
709709
void SetHash() {
710710
// Set an invalid HashVersion2 to prevent Version2 code from trying to read incompatible disks
711711
{
712-
NPDisk::TPDiskHashCalculator hashCalculator(false);
712+
NPDisk::TPDiskHashCalculator hashCalculator;
713713
ui64 size = (char*)&HashVersion2 - (char*)this;
714714
hashCalculator.Hash(this, size);
715715
HashVersion2 = hashCalculator.GetHashResult();
@@ -718,7 +718,7 @@ struct TDiskFormat {
718718
}
719719
// Set Hash
720720
{
721-
NPDisk::TPDiskHashCalculator hashCalculator(false);
721+
NPDisk::TPDiskHashCalculator hashCalculator;
722722
Y_ABORT_UNLESS(DiskFormatSize > sizeof(THash));
723723
ui64 size = DiskFormatSize - sizeof(THash);
724724
hashCalculator.Hash(this, size);

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

+4-5
Original file line numberDiff line numberDiff line change
@@ -838,7 +838,7 @@ bool TPDisk::ChunkWritePiece(TChunkWrite *evChunkWrite, ui32 pieceShift, ui32 pi
838838
ui32 dataChunkSizeSectors = Format.ChunkSize / Format.SectorSize;
839839
TChunkWriter writer(Mon, *BlockDevice.Get(), Format, state.CurrentNonce, Format.ChunkKey, BufferPool.Get(),
840840
desiredSectorIdx, dataChunkSizeSectors, Format.MagicDataChunk, chunkIdx, nullptr, desiredSectorIdx,
841-
nullptr, ActorSystem, PDiskId, &DriveModel, Cfg->UseT1ha0HashInFooter, Cfg->EnableSectorEncryption);
841+
nullptr, ActorSystem, PDiskId, &DriveModel, Cfg->EnableSectorEncryption);
842842

843843
guard.Release();
844844

@@ -1012,7 +1012,7 @@ TPDisk::EChunkReadPieceResult TPDisk::ChunkReadPiece(TIntrusivePtr<TChunkRead> &
10121012
NWilson::TSpan span(TWilson::PDiskBasic, std::move(traceId), "PDisk.CompletionChunkReadPart", NWilson::EFlags::NONE, ActorSystem);
10131013
traceId = span.GetTraceId();
10141014
THolder<TCompletionChunkReadPart> completion(new TCompletionChunkReadPart(this, read, bytesToRead,
1015-
payloadBytesToRead, payloadOffset, read->FinalCompletion, isTheLastPart, Cfg->UseT1ha0HashInFooter, std::move(span)));
1015+
payloadBytesToRead, payloadOffset, read->FinalCompletion, isTheLastPart, std::move(span)));
10161016
completion->CostNs = DriveModel.TimeForSizeNs(bytesToRead, read->ChunkIdx, TDriveModel::OP_TYPE_READ);
10171017
Y_ABORT_UNLESS(bytesToRead <= completion->GetBuffer()->Size());
10181018
ui8 *data = completion->GetBuffer()->Data();
@@ -1620,7 +1620,7 @@ void TPDisk::WriteApplyFormatRecord(TDiskFormat format, const TKey &mainKey) {
16201620
bool encrypt = true; // Always write encrypter format because some tests use wrong main key to initiate errors
16211621
TSysLogWriter formatWriter(Mon, *BlockDevice.Get(), Format, nonce, mainKey, BufferPool.Get(),
16221622
0, ReplicationFactor, Format.MagicFormatChunk, 0, nullptr, 0, nullptr, ActorSystem, PDiskId,
1623-
&DriveModel, Cfg->UseT1ha0HashInFooter, encrypt);
1623+
&DriveModel, encrypt);
16241624

16251625
if (format.IsFormatInProgress()) {
16261626
// Fill first bytes with magic pattern
@@ -1708,7 +1708,7 @@ void TPDisk::WriteDiskFormat(ui64 diskSizeBytes, ui32 sectorSizeBytes, ui32 user
17081708
// Fill the cyclic log with initial SysLogRecords
17091709
SysLogger.Reset(new TSysLogWriter(Mon, *BlockDevice.Get(), Format, SysLogRecord.Nonces.Value[NonceSysLog],
17101710
Format.SysLogKey, BufferPool.Get(), firstSectorIdx, endSectorIdx, Format.MagicSysLogChunk, 0,
1711-
nullptr, firstSectorIdx, nullptr, ActorSystem, PDiskId, &DriveModel, Cfg->UseT1ha0HashInFooter,
1711+
nullptr, firstSectorIdx, nullptr, ActorSystem, PDiskId, &DriveModel,
17121712
Cfg->EnableSectorEncryption));
17131713

17141714
bool isFull = false;
@@ -2590,7 +2590,6 @@ bool TPDisk::Initialize(TActorSystem *actorSystem, const TActorId &pDiskActor) {
25902590
REGISTER_LOCAL_CONTROL(ForsetiMaxLogBatchNs);
25912591
REGISTER_LOCAL_CONTROL(ForsetiOpPieceSizeSsd);
25922592
REGISTER_LOCAL_CONTROL(ForsetiOpPieceSizeRot);
2593-
REGISTER_LOCAL_CONTROL(Cfg->UseT1ha0HashInFooter);
25942593

25952594
if (Cfg->SectorMap) {
25962595
auto diskModeParams = Cfg->SectorMap->GetDiskModeParams();

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

-1
Original file line numberDiff line numberDiff line change
@@ -152,7 +152,6 @@ class TPDisk : public IPDisk {
152152
ui64 SysLogLsn = 0;
153153
TNonceSet LoggedNonces; // Latest on-disk Nonce set
154154
ui64 CostLimitNs;
155-
TControlWrapper UseT1ha0HashInFooter;
156155

157156
TDriveData DriveData;
158157
TAtomic EstimatedLogChunkIdx = 0; // For cost estimation only TDriveData DriveData;

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

+3-3
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,7 @@ void TPDisk::InitSysLogger() {
4848
SysLogger.Reset(new TSysLogWriter(Mon, *BlockDevice.Get(), Format,
4949
SysLogRecord.Nonces.Value[NonceSysLog], Format.SysLogKey, BufferPool.Get(),
5050
beginSectorIdx, endSectorIdx, Format.MagicSysLogChunk, 0, nullptr, writeSectorIdx, nullptr, ActorSystem, PDiskId,
51-
&DriveModel, Cfg->UseT1ha0HashInFooter, Cfg->EnableSectorEncryption));
51+
&DriveModel, Cfg->EnableSectorEncryption));
5252
}
5353

5454
bool TPDisk::InitCommonLogger() {
@@ -67,7 +67,7 @@ bool TPDisk::InitCommonLogger() {
6767
CommonLogger.Reset(new TLogWriter(Mon, *BlockDevice.Get(), Format,
6868
SysLogRecord.Nonces.Value[NonceLog], Format.LogKey, BufferPool.Get(), 0, UsableSectorsPerLogChunk(),
6969
Format.MagicLogChunk, chunkIdx, info, std::min(sectorIdx, UsableSectorsPerLogChunk()),
70-
InitialTailBuffer, ActorSystem, PDiskId, &DriveModel, Cfg->UseT1ha0HashInFooter, Cfg->EnableSectorEncryption));
70+
InitialTailBuffer, ActorSystem, PDiskId, &DriveModel, Cfg->EnableSectorEncryption));
7171
InitialTailBuffer = nullptr;
7272
if (sectorIdx >= UsableSectorsPerLogChunk()) {
7373
if (!AllocateLogChunks(1, 0, OwnerSystem, 0, EOwnerGroupType::Static, true)) {
@@ -1290,7 +1290,7 @@ void TPDisk::MarkChunksAsReleased(TReleaseChunks& req) {
12901290
ui32 dataChunkSizeSectors = Format.ChunkSize / Format.SectorSize;
12911291
TLogWriter writer(Mon, *BlockDevice.Get(), Format, nonce, Format.LogKey, BufferPool.Get(), desiredSectorIdx,
12921292
dataChunkSizeSectors, Format.MagicLogChunk, req.GapStart->ChunkIdx, nullptr, desiredSectorIdx,
1293-
nullptr, ActorSystem, PDiskId, &DriveModel, Cfg->UseT1ha0HashInFooter, Cfg->EnableSectorEncryption);
1293+
nullptr, ActorSystem, PDiskId, &DriveModel, Cfg->EnableSectorEncryption);
12941294

12951295
Y_VERIFY_S(req.GapEnd->DesiredPrevChunkLastNonce, "PDiskId# " << PDiskId
12961296
<< "Zero GapEnd->DesiredPrevChunkLastNonce, chunkInfo# " << *req.GapEnd);

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

+3-3
Original file line numberDiff line numberDiff line change
@@ -799,7 +799,7 @@ bool TLogReader::ProcessSectorSet(TSectorData *sector) {
799799
const ui64 magic = format.MagicLogChunk;
800800
TSectorRestorator restorator(false, LogErasureDataParts, false, format,
801801
PDisk->ActorSystem, PDisk->PDiskActor, PDisk->PDiskId, &PDisk->Mon, PDisk->BufferPool.Get());
802-
restorator.Restore(sector->GetData(), sector->Offset, magic, LastNonce, PDisk->Cfg->UseT1ha0HashInFooter, Owner);
802+
restorator.Restore(sector->GetData(), sector->Offset, magic, LastNonce, Owner);
803803

804804
if (!restorator.GoodSectorFlags) {
805805
if (IsInitial) {
@@ -1117,7 +1117,7 @@ bool TLogReader::ProcessSectorSet(TSectorData *sector) {
11171117

11181118
void TLogReader::ReplyOk() {
11191119
{
1120-
TPDiskHashCalculator hasher(PDisk->Cfg->UseT1ha0HashInFooter);
1120+
TPDiskHashCalculator hasher;
11211121
TGuard<TMutex> guard(PDisk->StateMutex);
11221122
if (!IsInitial) {
11231123
TOwnerData &ownerData = PDisk->OwnerData[Owner];
@@ -1188,7 +1188,7 @@ bool TLogReader::ProcessNextChunkReference(TSectorData& sector) {
11881188
PDisk->Format, PDisk->ActorSystem, PDisk->PDiskActor, PDisk->PDiskId, &PDisk->Mon,
11891189
PDisk->BufferPool.Get());
11901190
restorator.Restore(sector.GetData(), sector.Offset, format.MagicNextLogChunkReference, LastNonce,
1191-
PDisk->Cfg->UseT1ha0HashInFooter, Owner);
1191+
Owner);
11921192
LOG_DEBUG_S(*PDisk->ActorSystem, NKikimrServices::BS_PDISK, SelfInfo() << " ProcessNextChunkReference");
11931193

11941194
if (restorator.LastGoodIdx < ReplicationFactor) {

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

+2-2
Original file line numberDiff line numberDiff line change
@@ -32,10 +32,10 @@ TSectorRestorator::TSectorRestorator(const bool isTrippleCopy, const ui32 erasur
3232
{}
3333

3434
void TSectorRestorator::Restore(ui8 *source, const ui64 offset, const ui64 magic, const ui64 lastNonce,
35-
const bool useT1ha0Hash, TOwner owner) {
35+
TOwner owner) {
3636
ui32 sectorCount = IsErasureEncode ? (IsTrippleCopy ? ReplicationFactor : (ErasureDataParts + 1)) : 1;
3737
ui64 maxNonce = 0;
38-
TPDiskHashCalculator hasher(useT1ha0Hash);
38+
TPDiskHashCalculator hasher;
3939
for (ui32 i = 0; i < sectorCount; ++i) {
4040
TDataSectorFooter *sectorFooter = (TDataSectorFooter*)
4141
(source + (i + 1) * Format.SectorSize - sizeof(TDataSectorFooter));

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

+1-2
Original file line numberDiff line numberDiff line change
@@ -34,8 +34,7 @@ struct TSectorRestorator {
3434
const bool isErasureEncode, const TDiskFormat &format);
3535

3636

37-
void Restore(ui8 *source, const ui64 offset, const ui64 magic, const ui64 lastNonce, const bool useT1ha0Hash,
38-
TOwner owner);
37+
void Restore(ui8 *source, const ui64 offset, const ui64 magic, const ui64 lastNonce, TOwner owner);
3938

4039
void WriteSector(ui8 *sectorData, ui64 writeOffset);
4140
};

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -159,7 +159,7 @@ void TSysLogReader::RestoreSectorSets() {
159159
const bool isErasureEncode = format.IsErasureEncodeSysLog();
160160
TSectorRestorator restorator(true, LogErasureDataParts, isErasureEncode, format,
161161
PDisk->ActorSystem, PDisk->PDiskActor, PDisk->PDiskId, &PDisk->Mon, PDisk->BufferPool.Get());
162-
restorator.Restore(sectorSetData, sectorIdx * format.SectorSize, magic, 0, PDisk->Cfg->UseT1ha0HashInFooter, 0);
162+
restorator.Restore(sectorSetData, sectorIdx * format.SectorSize, magic, 0, 0);
163163

164164
if (!restorator.GoodSectorFlags) {
165165
continue;

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

+1-1
Original file line numberDiff line numberDiff line change
@@ -215,7 +215,7 @@ bool ReadPDiskFormatInfo(const TString &path, const NPDisk::TMainKey &mainKey, T
215215
(sector + format.SectorSize - sizeof(NPDisk::TDataSectorFooter));
216216

217217
ui64 sectorOffset = sysLogOffset + (ui64)((idx / 3) * 3) * (ui64)format.SectorSize;
218-
bool isCrcOk = NPDisk::TPDiskHashCalculator(KIKIMR_PDISK_ENABLE_T1HA_HASH_WRITING).CheckSectorHash(
218+
bool isCrcOk = NPDisk::TPDiskHashCalculator().CheckSectorHash(
219219
sectorOffset, format.MagicSysLogChunk, sector, format.SectorSize, logFooter->Hash);
220220
outInfo.SectorInfo.push_back(TPDiskInfo::TSectorInfo(logFooter->Nonce, logFooter->Version, isCrcOk));
221221
}

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

-1
Original file line numberDiff line numberDiff line change
@@ -85,7 +85,6 @@ void Run(TVector<IActor*> tests, TTestRunConfig runCfg) {
8585
pDiskConfig->ChunkSize = runCfg.ChunkSize;
8686
pDiskConfig->SectorMap = runCfg.TestContext->SectorMap;
8787
pDiskConfig->EnableSectorEncryption = !pDiskConfig->SectorMap;
88-
pDiskConfig->UseT1ha0HashInFooter = runCfg.UseT1ha0Hasher;
8988
pDiskConfig->FeatureFlags.SetEnableSmallDiskOptimization(false);
9089

9190
NPDisk::TMainKey mainKey{ .Keys = {NPDisk::YdbDefaultPDiskSequence}, .IsInitialized = true };

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

-1
Original file line numberDiff line numberDiff line change
@@ -22,7 +22,6 @@ struct TTestRunConfig {
2222
bool IsBad = false;
2323
bool IsErasureEncodeUserLog = false;
2424
ui32 BeforeTestSleepMs = 100;
25-
bool UseT1ha0Hasher = KIKIMR_PDISK_ENABLE_T1HA_HASH_WRITING;
2625
};
2726

2827
void Run(TVector<IActor*> tests, TTestRunConfig runCfg);

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

-22
Original file line numberDiff line numberDiff line change
@@ -145,28 +145,6 @@ YARD_UNIT_TEST(TestSysLogReordering) {
145145
}
146146
}
147147

148-
YARD_UNIT_TEST(TestLogWriteReaDifferentHashers) {
149-
for (ui32 i = 0; i < 4; ++i) {
150-
TTestContext tc(false, true);
151-
TTestRunConfig cfg(&tc);
152-
153-
cfg.UseT1ha0Hasher = i / 2;
154-
Run<TTestLogWriteRead<6000>>(cfg);
155-
cfg.UseT1ha0Hasher = i % 2;
156-
Run<TTestWholeLogRead>(cfg);
157-
}
158-
}
159-
160-
YARD_UNIT_TEST(TestChunkWriteReadDifferentHashers) {
161-
for (ui32 i = 0; i < 2; ++i) {
162-
TTestContext tc(false, true);
163-
TTestRunConfig cfg(&tc);
164-
165-
cfg.UseT1ha0Hasher = i;
166-
Run<TTestChunkWriteRead<1000000, 1500000>>(cfg);
167-
}
168-
}
169-
170148
YARD_UNIT_TEST(TestLogWriteCutUnequal) {
171149
TTestContext tc(false, true);
172150
FillDeviceWithZeroes(&tc, MIN_CHUNK_SIZE);

0 commit comments

Comments
 (0)