Update UT environment, add SectorMap performance test,

Update UT environment, add new UT

9 files changed, 205 insertions, 99 deletions

diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp
index ee9fa6aa086..28e3e6057e5 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut.cpp
@@ -44,38 +44,38 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(TestPDiskActorErrorState) {
-        TActorTestContext testCtx(true);
+        TActorTestContext testCtx({ true });
 
         const TVDiskID vDiskID(0, 1, 0, 0, 0);
-        testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(1, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvCheckSpaceResult>(
+        testCtx.TestResponse<NPDisk::TEvCheckSpaceResult>(
                 new NPDisk::TEvCheckSpace(1, 1),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvLogResult>(
+        testCtx.TestResponse<NPDisk::TEvLogResult>(
                 new NPDisk::TEvLog(1, 1, 0, TContiguousData(TString()), TLsnSeg(1, 1), nullptr),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvReadLogResult>(
+        testCtx.TestResponse<NPDisk::TEvReadLogResult>(
                 new NPDisk::TEvReadLog(1, 1, NPDisk::TLogPosition{0, 0}),
                 NKikimrProto::CORRUPTED);
 
-        testCtx.TestResponce<NPDisk::TEvChunkWriteResult>(
+        testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(
                 new NPDisk::TEvChunkWrite(1, 1, 1, 0, nullptr, nullptr, false, 1),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvChunkReadResult>(
+        testCtx.TestResponse<NPDisk::TEvChunkReadResult>(
                 new NPDisk::TEvChunkRead(1, 1, 17, 0, 4096, 1, nullptr),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvHarakiriResult>(
+        testCtx.TestResponse<NPDisk::TEvHarakiriResult>(
                 new NPDisk::TEvHarakiri(1, 1),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvSlayResult>(
+        testCtx.TestResponse<NPDisk::TEvSlayResult>(
                 new NPDisk::TEvSlay(vDiskID, 1, 1, 1),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvChunkReserveResult>(
+        testCtx.TestResponse<NPDisk::TEvChunkReserveResult>(
                 new NPDisk::TEvChunkReserve(1, 1, 3),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvYardControlResult>(
+        testCtx.TestResponse<NPDisk::TEvYardControlResult>(
                 new NPDisk::TEvYardControl(NPDisk::TEvYardControl::ActionPause, nullptr),
                 NKikimrProto::CORRUPTED);
 
@@ -83,22 +83,22 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(TestPDiskActorPDiskStopStart) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
 
         const TVDiskID vDiskID(0, 1, 0, 0, 0);
-        testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(2, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::OK);
-        testCtx.TestResponce<NPDisk::TEvYardControlResult>(
+        testCtx.TestResponse<NPDisk::TEvYardControlResult>(
                 new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStop, nullptr),
                 NKikimrProto::OK);
-        testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(3, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvYardControlResult>(
+        testCtx.TestResponse<NPDisk::TEvYardControlResult>(
                 new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStart, reinterpret_cast<void*>(&testCtx.MainKey)),
                 NKikimrProto::OK);
-        testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(3, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::OK);
 
@@ -112,44 +112,44 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(TestPDiskOwnerRecreation) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
 
         const TVDiskID vDiskID(0, 1, 0, 0, 0);
         for (ui32 i = 2; i < 2000; ++i) {
-            const auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+            const auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                     new NPDisk::TEvYardInit(i, vDiskID, testCtx.TestCtx.PDiskGuid),
                     NKikimrProto::OK);
 
-            testCtx.TestResponce<NPDisk::TEvSlayResult>(
+            testCtx.TestResponse<NPDisk::TEvSlayResult>(
                     new NPDisk::TEvSlay(vDiskID, evInitRes->PDiskParams->OwnerRound + 1, 0, 0),
                     NKikimrProto::OK);
         }
     }
 
     Y_UNIT_TEST(TestPDiskOwnerRecreationWithStableOwner) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
 
         // Create "stable" owner, who will be alive during all test
         ui32 i = 2;
         const TVDiskID vDiskID_stable(0, 1, 0, 0, 0);
-        testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(i++, vDiskID_stable, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::OK);
 
         const TVDiskID vDiskID(1, 1, 0, 0, 0);
         for (; i < 2000; ++i) {
-            const auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+            const auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                     new NPDisk::TEvYardInit(i, vDiskID, testCtx.TestCtx.PDiskGuid),
                     NKikimrProto::OK);
 
-            testCtx.TestResponce<NPDisk::TEvSlayResult>(
+            testCtx.TestResponse<NPDisk::TEvSlayResult>(
                     new NPDisk::TEvSlay(vDiskID, evInitRes->PDiskParams->OwnerRound + 1, 0, 0),
                     NKikimrProto::OK);
         }
     }
 
     Y_UNIT_TEST(TestPDiskManyOwnersInitiation) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
 
         TVector<TVDiskIDOwnerRound> goodIds;
         ui64 badIdsCount = 0;
@@ -165,7 +165,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
                     ++badIdsCount;
                 }
             } else {
-                const auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+                const auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                         new NPDisk::TEvYardInit(i, vDiskID, testCtx.TestCtx.PDiskGuid),
                         NKikimrProto::ERROR);
                 ++badIdsCount;
@@ -176,14 +176,14 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
 
         UNIT_ASSERT(badIdsCount > 0 && goodIds.size() > 0);
         for (auto v : goodIds) {
-            testCtx.TestResponce<NPDisk::TEvSlayResult>(
+            testCtx.TestResponse<NPDisk::TEvSlayResult>(
                     new NPDisk::TEvSlay(v.VDiskID, v.OwnerRound + 1, 0, 0),
                     NKikimrProto::OK);
         }
     }
 
     Y_UNIT_TEST(TestVDiskMock) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         TVDiskMock mock(&testCtx);
 
         mock.InitFull();
@@ -202,7 +202,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
             return;
         }
 
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         TVDiskMock sporadicVDisk(&testCtx);
         TVDiskMock intensiveVDisk(&testCtx);
 
@@ -253,7 +253,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
             return;
         }
 
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         TVDiskMock sporadicVDisk(&testCtx);
         TVDiskMock moderateVDisk(&testCtx);
         TVDiskMock intensiveVDisk(&testCtx);
@@ -326,11 +326,11 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(TestFakeErrorPDiskManyLogWrite) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         testCtx.TestCtx.SectorMap->ImitateIoErrorProbability = 1e-4;
 
         const TVDiskID vDiskID(0, 1, 0, 0, 0);
-        const auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        const auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(2, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::OK);
 
@@ -351,7 +351,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(TestFakeErrorPDiskManyChunkRead) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         testCtx.TestCtx.SectorMap->ImitateReadIoErrorProbability = 1e-4;
 
         TVDiskMock vdisk(&testCtx);
@@ -365,7 +365,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
         const ui32 reservedChunk = *vdisk.Chunks[EChunkState::COMMITTED].begin();
 
         TString chunkWriteData = PrepareData(1024);
-        testCtx.TestResponce<NPDisk::TEvChunkWriteResult>(
+        testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(
                 new NPDisk::TEvChunkWrite(vdisk.PDiskParams->Owner, vdisk.PDiskParams->OwnerRound,
                     reservedChunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(chunkWriteData), nullptr, false, 0),
                 NKikimrProto::OK);
@@ -390,16 +390,16 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(TestFakeErrorPDiskManyChunkWrite) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         testCtx.TestCtx.SectorMap->ImitateIoErrorProbability = 1e-4;
 
         const TVDiskID vDiskID(0, 1, 0, 0, 0);
-        const auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        const auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(2, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::OK);
 
         ui32 errors = 0;
-        const auto evReserveRes = testCtx.TestResponce<NPDisk::TEvChunkReserveResult>(
+        const auto evReserveRes = testCtx.TestResponse<NPDisk::TEvChunkReserveResult>(
                 new NPDisk::TEvChunkReserve(evInitRes->PDiskParams->Owner, evInitRes->PDiskParams->OwnerRound, 1),
                 NKikimrProto::OK);
         UNIT_ASSERT(evReserveRes->ChunkIds.size() == 1);
@@ -427,9 +427,9 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(TestSIGSEGVInTUndelivered) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         const TVDiskID vDiskID(0, 1, 0, 0, 0);
-        const auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        const auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(2, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::OK);
 
@@ -445,7 +445,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(PDiskRestart) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         TVDiskMock vdisk(&testCtx);
         vdisk.InitFull();
         vdisk.SendEvLogSync();
@@ -456,11 +456,11 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(PDiskRestartManyLogWrites) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         testCtx.TestCtx.SectorMap->ImitateIoErrorProbability = 1e-4;
 
         const TVDiskID vDiskID(0, 1, 0, 0, 0);
-        const auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        const auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(2, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::OK);
 
@@ -488,7 +488,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(CommitDeleteChunks) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         TVDiskMock intensiveVDisk(&testCtx);
         intensiveVDisk.InitFull();
         intensiveVDisk.ReserveChunk();
@@ -505,7 +505,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
             return;
         }
 
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         TVDiskMock intensiveVDisk(&testCtx);    // idx# 1
         TVDiskMock formerVDisk(&testCtx);       // idx# 2
         TVDiskMock latterVDisk(&testCtx);       // idx# 3
@@ -610,7 +610,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     Y_UNIT_TEST(SpaceColor) {
         return; // Enable test after KIKIMR-12880
 
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         TVDiskMock vdisk(&testCtx);
 
         using TColor = NKikimrBlobStorage::TPDiskSpaceColor;
@@ -630,14 +630,14 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
             testCtx.UpdateConfigRecreatePDisk(pdiskConfig);
 
             vdisk.InitFull();
-            auto initialSpace = testCtx.TestResponce<NPDisk::TEvCheckSpaceResult>(
+            auto initialSpace = testCtx.TestResponse<NPDisk::TEvCheckSpaceResult>(
                     new NPDisk::TEvCheckSpace(vdisk.PDiskParams->Owner, vdisk.PDiskParams->OwnerRound),
                     NKikimrProto::OK);
             for (ui32 i = 0; i < initialSpace->FreeChunks + 1; ++i) {
                 vdisk.ReserveChunk();
             }
             vdisk.CommitReservedChunks();
-            auto resultSpace = testCtx.TestResponce<NPDisk::TEvCheckSpaceResult>(
+            auto resultSpace = testCtx.TestResponse<NPDisk::TEvCheckSpaceResult>(
                     new NPDisk::TEvCheckSpace(vdisk.PDiskParams->Owner, vdisk.PDiskParams->OwnerRound),
                     NKikimrProto::OK);
             UNIT_ASSERT(color == StatusFlagToSpaceColor(resultSpace->StatusFlags));
@@ -646,7 +646,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(DeviceHaltTooLong) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         testCtx.TestCtx.SectorMap->ImitateRandomWait = {TDuration::Seconds(1), TDuration::Seconds(2)};
 
         TVDiskMock mock(&testCtx);
@@ -662,14 +662,14 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     }
 
     Y_UNIT_TEST(TestPDiskOnDifferentKeys) {
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
 
         int round = 2;
         const TVDiskID vDiskID(0, 1, 0, 0, 0);
-        auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(round, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::OK);
-        testCtx.TestResponce<NPDisk::TEvCheckSpaceResult>(
+        testCtx.TestResponse<NPDisk::TEvCheckSpaceResult>(
                 new NPDisk::TEvCheckSpace(evInitRes->PDiskParams->Owner, evInitRes->PDiskParams->OwnerRound),
                 NKikimrProto::OK);
         round = evInitRes->PDiskParams->OwnerRound + 1;
@@ -677,10 +677,10 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
         testCtx.MainKey[0] += 123;
         testCtx.UpdateConfigRecreatePDisk(testCtx.GetPDiskConfig());
 
-        evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+        evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(round, vDiskID, testCtx.TestCtx.PDiskGuid),
                 NKikimrProto::CORRUPTED);
-        testCtx.TestResponce<NPDisk::TEvCheckSpaceResult>(
+        testCtx.TestResponse<NPDisk::TEvCheckSpaceResult>(
                 new NPDisk::TEvCheckSpace(evInitRes->PDiskParams->Owner, evInitRes->PDiskParams->OwnerRound),
                 NKikimrProto::CORRUPTED);
     }
@@ -688,7 +688,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     Y_UNIT_TEST(ChangePDiskKey) {
         const TString data = PrepareData(4096);
 
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         
         TVDiskMock mock(&testCtx);
         mock.InitFull();
@@ -697,7 +697,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
         const ui32 chunk = *mock.Chunks[EChunkState::RESERVED].begin();
 
         auto readChunk = [&]() {
-            auto evReadRes = testCtx.TestResponce<NPDisk::TEvChunkReadResult>(
+            auto evReadRes = testCtx.TestResponse<NPDisk::TEvChunkReadResult>(
                     new NPDisk::TEvChunkRead(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
                             chunk, 0, data.size(), 0, nullptr),
                     NKikimrProto::OK);
@@ -705,7 +705,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
         };
 
         TString dataCopy = data;
-        testCtx.TestResponce<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
+        testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
             chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0), 
             NKikimrProto::OK);
         mock.CommitReservedChunks();
@@ -742,7 +742,7 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
     Y_UNIT_TEST(WrongPDiskKey) {
         const TString data = PrepareData(4096);
 
-        TActorTestContext testCtx(false);
+        TActorTestContext testCtx({ false });
         
         TVDiskMock mock(&testCtx);
         mock.InitFull();
@@ -751,24 +751,24 @@ Y_UNIT_TEST_SUITE(TPDiskTest) {
         const ui32 chunk = *mock.Chunks[EChunkState::RESERVED].begin();
 
         TString dataCopy = data;
-        testCtx.TestResponce<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
+        testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
             chunk, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), nullptr, false, 0), 
             NKikimrProto::OK);
         mock.CommitReservedChunks();
-        testCtx.TestResponce<NPDisk::TEvCheckSpaceResult>(
+        testCtx.TestResponse<NPDisk::TEvCheckSpaceResult>(
                 new NPDisk::TEvCheckSpace(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound),
                 NKikimrProto::OK);
-        testCtx.TestResponce<NPDisk::TEvChunkReadResult>(
+        testCtx.TestResponse<NPDisk::TEvChunkReadResult>(
                 new NPDisk::TEvChunkRead(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
                         chunk, 0, data.size(), 0, nullptr),
                 NKikimrProto::OK);
 
         testCtx.MainKey = { 0xABCDEF };
-        testCtx.TestResponce<NPDisk::TEvYardControlResult>(
+        testCtx.TestResponse<NPDisk::TEvYardControlResult>(
                 new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStop, nullptr),
                 NKikimrProto::OK);
             
-        testCtx.TestResponce<NPDisk::TEvYardControlResult>(
+        testCtx.TestResponse<NPDisk::TEvYardControlResult>(
                 new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStart, (void*)(&testCtx.MainKey)),
                 NKikimrProto::CORRUPTED);
     }
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_context.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_context.h
index ee61f6df889..538c73b6b50 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_context.h
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_context.h
@@ -15,13 +15,14 @@ public:
     TIntrusivePtr<NPDisk::TSectorMap> SectorMap;
     THolder<TTempDir> TempDir;
 
-    TTestContext(bool makeTempDir, bool useSectorMap, NPDisk::NSectorMap::EDiskMode diskMode = NPDisk::NSectorMap::DM_NONE) {
+    using EDiskMode = NPDisk::NSectorMap::EDiskMode;
+    TTestContext(bool makeTempDir, bool useSectorMap, EDiskMode diskMode = EDiskMode::DM_NONE, ui64 sectorMapSize = 0) {
         if (makeTempDir) {
             TempDir.Reset(new TTempDir);
             Dir = TempDir->Name().c_str();
         }
         if (useSectorMap) {
-            SectorMap = new NPDisk::TSectorMap(0, diskMode);
+            SectorMap = new NPDisk::TSectorMap(sectorMapSize, diskMode);
         }
     }
 
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.cpp
index ff82c35caf0..e339bb88f68 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.cpp
@@ -2,11 +2,11 @@
 
 namespace NKikimr {
 void RecreateOwner(TActorTestContext& testCtx, TVDiskIDOwnerRound& vdisk) {
-    testCtx.TestResponce<NPDisk::TEvSlayResult>(
+    testCtx.TestResponse<NPDisk::TEvSlayResult>(
             new NPDisk::TEvSlay(vdisk.VDiskID, vdisk.OwnerRound + 1, 0, 0),
             NKikimrProto::OK);
 
-    const auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+    const auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
             new NPDisk::TEvYardInit(vdisk.OwnerRound + 1, vdisk.VDiskID, testCtx.TestCtx.PDiskGuid),
             NKikimrProto::OK);
 
@@ -14,13 +14,13 @@ void RecreateOwner(TActorTestContext& testCtx, TVDiskIDOwnerRound& vdisk) {
 }
 
 void TestChunkWriteReleaseRun() {
-    TActorTestContext testCtx(false);
+    TActorTestContext testCtx({ false });
 
     const TVDiskID vDiskID(0, 1, 0, 0, 0);
-    const auto evInitRes = testCtx.TestResponce<NPDisk::TEvYardInitResult>(
+    const auto evInitRes = testCtx.TestResponse<NPDisk::TEvYardInitResult>(
             new NPDisk::TEvYardInit(2, vDiskID, testCtx.TestCtx.PDiskGuid),
             NKikimrProto::OK);
-    const auto evReserveRes = testCtx.TestResponce<NPDisk::TEvChunkReserveResult>(
+    const auto evReserveRes = testCtx.TestResponse<NPDisk::TEvChunkReserveResult>(
             new NPDisk::TEvChunkReserve(evInitRes->PDiskParams->Owner, evInitRes->PDiskParams->OwnerRound, 1),
             NKikimrProto::OK);
     UNIT_ASSERT(evReserveRes->ChunkIds.size() == 1);
@@ -28,12 +28,12 @@ void TestChunkWriteReleaseRun() {
     const ui32 reservedChunk = evReserveRes->ChunkIds.front();
     NPDisk::TCommitRecord commitRecord;
     commitRecord.CommitChunks.push_back(reservedChunk);
-    testCtx.TestResponce<NPDisk::TEvLogResult>(
+    testCtx.TestResponse<NPDisk::TEvLogResult>(
             new NPDisk::TEvLog(evInitRes->PDiskParams->Owner, evInitRes->PDiskParams->OwnerRound, 0, commitRecord,
                     TContiguousData(TString()), TLsnSeg(1, 1), nullptr),
             NKikimrProto::OK);
 
-    const auto evControlRes = testCtx.TestResponce<NPDisk::TEvYardControlResult>(
+    const auto evControlRes = testCtx.TestResponse<NPDisk::TEvYardControlResult>(
             new NPDisk::TEvYardControl(NPDisk::TEvYardControl::GetPDiskPointer, nullptr),
             NKikimrProto::OK);
     auto *pDisk = reinterpret_cast<NPDisk::TPDisk*>(evControlRes->Cookie);
@@ -62,10 +62,10 @@ void TestChunkWriteReleaseRun() {
 
     pDisk->ProcessChunkWriteQueue();
 
-    testCtx.TestResponce<NPDisk::TEvLogResult>(
+    testCtx.TestResponse<NPDisk::TEvLogResult>(
             nullptr,
             NKikimrProto::OK);
-    testCtx.TestResponce<NPDisk::TEvChunkWriteResult>(
+    testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(
             nullptr,
             NKikimrProto::ERROR);
 
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h
index 86e989c4a70..f05e0da4f01 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_env.h
@@ -2,6 +2,7 @@
 
 #include <ydb/core/blobstorage/pdisk/mock/pdisk_mock.h>
 #include "blobstorage_pdisk_ut.h"
+#include "blobstorage_pdisk_ut_defs.h"
 
 #include "blobstorage_pdisk_abstract.h"
 #include "blobstorage_pdisk_impl.h"
@@ -14,37 +15,48 @@
 namespace NKikimr {
 
 struct TActorTestContext {
+    using EDiskMode = NPDisk::NSectorMap::EDiskMode;
+public:
+    struct TSettings {
+        bool IsBad;
+        bool UsePDiskMock = false;
+        ui64 DiskSize = 0;
+        EDiskMode DiskMode = EDiskMode::DM_NONE;
+        ui32 ChunkSize = MIN_CHUNK_SIZE;
+    };
+
 private:
     std::optional<TActorId> PDiskActor;
     THolder<TTestActorRuntime> Runtime;
     std::shared_ptr<NPDisk::IIoContextFactory> IoContext;
     NPDisk::TPDisk *PDisk = nullptr;
-    bool UsePDiskMock;
 
 public:
     TActorId Sender;
     NPDisk::TMainKey MainKey = { NPDisk::YdbDefaultPDiskSequence };
-    TTestContext TestCtx{false, /*use sector map*/ true};
+    TTestContext TestCtx;
+    TSettings Settings;
 
     TIntrusivePtr<TPDiskConfig> DefaultPDiskConfig(bool isBad) {
         TString path;
         EntropyPool().Read(&TestCtx.PDiskGuid, sizeof(TestCtx.PDiskGuid));
         ui64 formatGuid = TestCtx.PDiskGuid + static_cast<ui64>(isBad);
-        FormatPDiskForTest(path, formatGuid, MIN_CHUNK_SIZE, false, TestCtx.SectorMap);
+        FormatPDiskForTest(path, formatGuid, Settings.ChunkSize, false, TestCtx.SectorMap);
 
         ui64 pDiskCategory = 0;
         TIntrusivePtr<TPDiskConfig> pDiskConfig = new TPDiskConfig(path, TestCtx.PDiskGuid, 1, pDiskCategory);
         pDiskConfig->GetDriveDataSwitch = NKikimrBlobStorage::TPDiskConfig::DoNotTouch;
         pDiskConfig->WriteCacheSwitch = NKikimrBlobStorage::TPDiskConfig::DoNotTouch;
-        pDiskConfig->ChunkSize = MIN_CHUNK_SIZE;
+        pDiskConfig->ChunkSize = Settings.ChunkSize;
         pDiskConfig->SectorMap = TestCtx.SectorMap;
         pDiskConfig->EnableSectorEncryption = !pDiskConfig->SectorMap;
         return pDiskConfig;
     }
 
-    TActorTestContext(bool isBad, bool usePDiskMock = false)
+    TActorTestContext(TSettings settings)
         : Runtime(new TTestActorRuntime(1, true))
-        , UsePDiskMock(usePDiskMock)
+        , TestCtx(false, true, settings.DiskMode, settings.DiskSize)
+        , Settings(settings)
     {
         auto appData = MakeHolder<TAppData>(0, 0, 0, 0, TMap<TString, ui32>(), nullptr, nullptr, nullptr, nullptr);
         IoContext = std::make_shared<NPDisk::TIoContextFactoryOSS>();
@@ -57,12 +69,12 @@ public:
         Runtime->SetLogPriority(NKikimrServices::BS_PDISK_TEST, NLog::PRI_DEBUG);
         Sender = Runtime->AllocateEdgeActor();
 
-        TIntrusivePtr<TPDiskConfig> cfg = DefaultPDiskConfig(isBad);
+        TIntrusivePtr<TPDiskConfig> cfg = DefaultPDiskConfig(Settings.IsBad);
         UpdateConfigRecreatePDisk(cfg);
     }
 
     TIntrusivePtr<TPDiskConfig> GetPDiskConfig() {
-        if (!UsePDiskMock) {
+        if (!Settings.UsePDiskMock) {
             return GetPDisk()->Cfg;
         }
         return nullptr;
@@ -70,14 +82,14 @@ public:
 
     void UpdateConfigRecreatePDisk(TIntrusivePtr<TPDiskConfig> cfg) {
         if (PDiskActor) {
-            TestResponce<NPDisk::TEvYardControlResult>(
+            TestResponse<NPDisk::TEvYardControlResult>(
                     new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStop, nullptr),
                     NKikimrProto::OK);
             PDisk = nullptr;
             Runtime->Send(new IEventHandle(*PDiskActor, Sender, new TKikimrEvents::TEvPoisonPill));
         }
 
-        if (UsePDiskMock) {
+        if (Settings.UsePDiskMock) {
             ui32 nodeId = 1;
             ui64 size = ui64(10) << 40;
             TPDiskMockState::TPtr state(new TPDiskMockState((ui32)nodeId, (ui32)cfg->PDiskId, (ui64)cfg->PDiskGuid, (ui64)size, (ui32)cfg->ChunkSize));
@@ -94,13 +106,13 @@ public:
     }
 
     NPDisk::TPDisk *GetPDisk() {
-        if (!PDisk && !UsePDiskMock) {
+        if (!PDisk && !Settings.UsePDiskMock) {
             // To be sure that pdisk actor is in StateOnline
-            TestResponce<NPDisk::TEvYardControlResult>(
+            TestResponse<NPDisk::TEvYardControlResult>(
                     new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStart, (void*)(&MainKey)),
                     NKikimrProto::OK);
 
-            const auto evControlRes = TestResponce<NPDisk::TEvYardControlResult>(
+            const auto evControlRes = TestResponse<NPDisk::TEvYardControlResult>(
                     new NPDisk::TEvYardControl(NPDisk::TEvYardControl::GetPDiskPointer, nullptr),
                     NKikimrProto::OK);
             PDisk = reinterpret_cast<NPDisk::TPDisk*>(evControlRes->Cookie);
@@ -115,8 +127,8 @@ public:
     }
 
     void RestartPDiskSync() {
-        if (!UsePDiskMock) {
-            TestResponce<NPDisk::TEvYardControlResult>(
+        if (!Settings.UsePDiskMock) {
+            TestResponse<NPDisk::TEvYardControlResult>(
                     new NPDisk::TEvYardControl(NPDisk::TEvYardControl::PDiskStop, nullptr),
                     NKikimrProto::OK);
             PDisk = nullptr;
@@ -131,7 +143,7 @@ public:
     }
 
     template<typename TRes>
-    THolder<TRes> TestResponce(IEventBase* ev, NKikimrProto::EReplyStatus status) {
+    THolder<TRes> TestResponse(IEventBase* ev, NKikimrProto::EReplyStatus status) {
         if (ev) {
             Send(ev);
         }
@@ -190,7 +202,7 @@ struct TVDiskMock {
     }
 
     void Init() {
-        const auto evInitRes = TestCtx->TestResponce<NPDisk::TEvYardInitResult>(
+        const auto evInitRes = TestCtx->TestResponse<NPDisk::TEvYardInitResult>(
                 new NPDisk::TEvYardInit(OwnerRound.fetch_add(1), VDiskID, TestCtx->TestCtx.PDiskGuid),
                 NKikimrProto::OK);
         PDiskParams = evInitRes->PDiskParams;
@@ -205,7 +217,7 @@ struct TVDiskMock {
 
 
     void ReserveChunk() {
-        const auto evReserveRes = TestCtx->TestResponce<NPDisk::TEvChunkReserveResult>(
+        const auto evReserveRes = TestCtx->TestResponse<NPDisk::TEvChunkReserveResult>(
                 new NPDisk::TEvChunkReserve(PDiskParams->Owner, PDiskParams->OwnerRound, 1),
                 NKikimrProto::OK);
         UNIT_ASSERT(evReserveRes->ChunkIds.size() == 1);
@@ -238,7 +250,7 @@ struct TVDiskMock {
         bool endOfLog = false;
         do {
             UNIT_ASSERT(PDiskParams);
-            auto logReadRes = TestCtx->TestResponce<NPDisk::TEvReadLogResult>(
+            auto logReadRes = TestCtx->TestResponse<NPDisk::TEvReadLogResult>(
                 new NPDisk::TEvReadLog(PDiskParams->Owner, PDiskParams->OwnerRound, position),
                 NKikimrProto::OK);
             UNIT_ASSERT(position == logReadRes->Position);
@@ -278,7 +290,7 @@ private:
             evLog->CommitRecord = std::move(*commitRec);
         }
 
-        TestCtx->TestResponce<NPDisk::TEvLogResult>(evLog.Release(), NKikimrProto::OK);
+        TestCtx->TestResponse<NPDisk::TEvLogResult>(evLog.Release(), NKikimrProto::OK);
     }
 
     void SendEvLogImpl(const ui64 size, TMaybe<ui64> firstLsnToKeep, bool isStartingPoint) {
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_races.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_races.cpp
index bb1e680b192..f1f435dd898 100644
--- a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_races.cpp
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_races.cpp
@@ -16,7 +16,7 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
     void TestKillOwnerWhileDeletingChunk(bool usePDiskMock, ui32 timeLimit, ui32 inflight, ui32 reservedChunks, ui32 vdisksNum) {
         THPTimer timer;
         while (timer.Passed() < timeLimit) {
-            TActorTestContext testCtx(false, usePDiskMock);
+            TActorTestContext testCtx({ false, usePDiskMock });
             const TString data = PrepareData(4096);
 
             auto logNoTest = [&](TVDiskMock& mock, NPDisk::TCommitRecord rec) {
@@ -92,7 +92,7 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
     void TestDecommit(bool usePDiskMock, ui32 timeLimit, ui32 inflight, ui32 reservedChunks) {
         THPTimer timer;
         while (timer.Passed() < timeLimit) {
-            TActorTestContext testCtx(false, usePDiskMock);
+            TActorTestContext testCtx({ false, usePDiskMock });
             const TString data = PrepareData(4096);
 
             auto logNoTest = [&](TVDiskMock& mock, NPDisk::TCommitRecord rec) {
@@ -129,7 +129,7 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
                 auto& chunkIds = mock.Chunks[EChunkState::COMMITTED];
                 for (auto it = chunkIds.begin(); it != chunkIds.end(); ++it) {
                     TString dataCopy = data;
-                    testCtx.TestResponce<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
+                    testCtx.TestResponse<NPDisk::TEvChunkWriteResult>(new NPDisk::TEvChunkWrite(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound,
                         *it, 0, new NPDisk::TEvChunkWrite::TStrokaBackedUpParts(dataCopy), (void*)10, false, 0),
                         NKikimrProto::OK);
                 }
@@ -166,7 +166,7 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
                 }
             } 
             for (ui32 i = 0; i < reservedChunks; ++i) {
-                testCtx.TestResponce<NPDisk::TEvChunkForgetResult>(new NPDisk::TEvChunkForget(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound),
+                testCtx.TestResponse<NPDisk::TEvChunkForgetResult>(new NPDisk::TEvChunkForget(mock.PDiskParams->Owner, mock.PDiskParams->OwnerRound),
                         NKikimrProto::OK);
             }
         }
@@ -187,7 +187,7 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
     void TestKillOwnerWhileDecommitting(bool usePDiskMock, ui32 timeLimit, ui32 inflight, ui32 reservedChunks, ui32 vdisksNum) {
         THPTimer timer;
         while (timer.Passed() < timeLimit) {
-            TActorTestContext testCtx(false, usePDiskMock);
+            TActorTestContext testCtx({ false, usePDiskMock });
             const TString data = PrepareData(4096);
 
             auto logNoTest = [&](TVDiskMock& mock, NPDisk::TCommitRecord rec) {
@@ -262,7 +262,7 @@ Y_UNIT_TEST_SUITE(TPDiskRaces) {
     }
 
     void OwnerRecreationRaces(bool usePDiskMock, ui32 timeLimit, ui32 vdisksNum) {
-        TActorTestContext testCtx(false, usePDiskMock);
+        TActorTestContext testCtx({ false, usePDiskMock });
         const TString data = PrepareData(8);
 
         std::vector<TVDiskMock> mocks;
diff --git a/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_sectormap.cpp b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_sectormap.cpp
new file mode 100644
index 00000000000..1b97c4dc792
--- /dev/null
+++ b/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_sectormap.cpp
@@ -0,0 +1,90 @@
+#include "blobstorage_pdisk_ut.h"
+
+#include "blobstorage_pdisk_abstract.h"
+#include "blobstorage_pdisk_impl.h"
+#include "blobstorage_pdisk_ut_env.h"
+
+#include <ydb/core/blobstorage/crypto/default.h>
+#include <ydb/core/testlib/actors/test_runtime.h>
+
+#include <util/system/hp_timer.h>
+
+namespace NKikimr {
+
+Y_UNIT_TEST_SUITE(TSectorMap) {
+
+    bool TestSectorMapPerformance(NPDisk::NSectorMap::EDiskMode diskMode, ui64 diskSizeGb, ui64 dataSizeMb, bool toFirstSector,
+            bool testRead, ui32 tries, double deviationRange = 0.05, std::pair<double, double>* time = nullptr) {
+        ui64 dataSize = dataSizeMb * 1024 * 1024;
+        ui64 deviceSize = diskSizeGb * 1024 * 1024 * 1024;
+
+        ui64 diskRate = toFirstSector ? 200 * 1024 * 1024 : 66 * 1024 * 1024;
+        ui64 sectorsNum = deviceSize / NPDisk::NSectorMap::SECTOR_SIZE;
+        ui64 sectorPos = toFirstSector ? 0 : sectorsNum - dataSize / NPDisk::NSectorMap::SECTOR_SIZE - 2;
+        double timeExpected = (double)dataSize / diskRate;
+        double timeSum = 0;
+        for (ui32 i = 0; i < tries; ++i) {
+            THPTimer timer1;
+            TString data = PrepareData(dataSize);
+            NPDisk::TSectorMap sectorMap(deviceSize, diskMode);
+            sectorMap.ZeroInit(100);
+
+            double timeElapsed = 0;
+            if (testRead) {
+                TString buf;
+                buf.reserve(dataSize);
+                sectorMap.Write((ui8*)data.data(), dataSize, sectorPos * NPDisk::NSectorMap::SECTOR_SIZE);
+                THPTimer timer;
+                sectorMap.Read((ui8*)buf.data(), dataSize, sectorPos * NPDisk::NSectorMap::SECTOR_SIZE);
+                timeElapsed = timer.Passed();
+            } else {
+                THPTimer timer;
+                sectorMap.Write((ui8*)data.data(), dataSize, sectorPos * NPDisk::NSectorMap::SECTOR_SIZE);
+                timeElapsed = timer.Passed();
+            }
+
+            timeSum += timeElapsed;
+        }
+        double timeAvg = timeSum / tries;
+        double relativeDeviation = (timeAvg - timeExpected) / timeExpected;
+        if (time) {
+            *time = { timeExpected, timeAvg };
+        }
+
+        return std::abs(relativeDeviation) <= deviationRange;
+    }
+
+    Y_UNIT_TEST(SectorMapPerformance) {
+        std::vector<TString> failedTests;
+
+        std::pair<double, double> time;
+
+        using EDiskMode = NPDisk::NSectorMap::EDiskMode;
+        auto test = [&](EDiskMode diskMode, ui32 diskSizeGb, ui32 dataSizeMb, bool toFirstSector, bool testRead, ui32 tries) {
+            if (!TestSectorMapPerformance(diskMode, diskSizeGb, dataSizeMb, toFirstSector, testRead, tries, 0.05, &time)) {
+                failedTests.push_back(TStringBuilder() << diskSizeGb << "GB " << NPDisk::NSectorMap::DiskModeToString(diskMode) <<    
+                        (testRead ? " read " : " write ") << dataSizeMb << " MB to" << (toFirstSector ? " first " : " last ") << 
+                        "sector, timeExpected=" << time.first << ", timeAverage=" << time.second);
+            }
+        };
+
+        for (auto diskMode : { EDiskMode::DM_HDD}) {
+            for (ui32 dataSizeMb : { 1, 10 }) {
+                for (bool testRead : { false, true }) {
+                    test(diskMode, 1960, dataSizeMb, true, testRead, 5);
+                }
+            }
+        }
+        
+        test(EDiskMode::DM_HDD, 1960, 100, true, true, 3);
+        test(EDiskMode::DM_HDD, 1960, 100, true, false, 3);
+        test(EDiskMode::DM_HDD, 1960, 100, false, true, 3);
+        test(EDiskMode::DM_HDD, 1960, 100, false, false, 3);
+
+        for (auto& testName : failedTests) {
+            Cerr << testName << Endl;
+        }
+        UNIT_ASSERT(failedTests.empty());
+    }
+}
+}
diff --git a/ydb/core/blobstorage/pdisk/ut/CMakeLists.darwin.txt b/ydb/core/blobstorage/pdisk/ut/CMakeLists.darwin.txt
index 1c8d218ee03..2610a15c2e7 100644
--- a/ydb/core/blobstorage/pdisk/ut/CMakeLists.darwin.txt
+++ b/ydb/core/blobstorage/pdisk/ut/CMakeLists.darwin.txt
@@ -40,6 +40,7 @@ target_sources(ydb-core-blobstorage-pdisk-ut PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_actions.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_helpers.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_run.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_sectormap.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_restore_ut.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/mock/pdisk_mock.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_yard.cpp
diff --git a/ydb/core/blobstorage/pdisk/ut/CMakeLists.linux-aarch64.txt b/ydb/core/blobstorage/pdisk/ut/CMakeLists.linux-aarch64.txt
index a1ef21ea903..61e95b215cb 100644
--- a/ydb/core/blobstorage/pdisk/ut/CMakeLists.linux-aarch64.txt
+++ b/ydb/core/blobstorage/pdisk/ut/CMakeLists.linux-aarch64.txt
@@ -42,6 +42,7 @@ target_sources(ydb-core-blobstorage-pdisk-ut PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_actions.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_helpers.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_run.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_sectormap.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_restore_ut.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/mock/pdisk_mock.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_yard.cpp
diff --git a/ydb/core/blobstorage/pdisk/ut/CMakeLists.linux.txt b/ydb/core/blobstorage/pdisk/ut/CMakeLists.linux.txt
index 461e7bdd4bf..54dd2066f57 100644
--- a/ydb/core/blobstorage/pdisk/ut/CMakeLists.linux.txt
+++ b/ydb/core/blobstorage/pdisk/ut/CMakeLists.linux.txt
@@ -44,6 +44,7 @@ target_sources(ydb-core-blobstorage-pdisk-ut PRIVATE
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_actions.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_helpers.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_run.cpp
+  ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_sectormap.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_restore_ut.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/mock/pdisk_mock.cpp
   ${CMAKE_SOURCE_DIR}/ydb/core/blobstorage/pdisk/blobstorage_pdisk_ut_yard.cpp