[sanitizer] s/TestOnlyInit/Init for the allocator ByteMap (NFC)

[cryptoad]

Summary

The TestOnlyInit function of {Flat,TwoLevel}ByteMap seems to be a misnomer
since the function is used outside of tests as well, namely in
SizeClassAllocator32::Init. Rename it to Init and update the callers.

[vitalybuka]

lib/sanitizer_common/sanitizer_allocator_bytemap.h

21

I'd call it Reset().

[cryptoad]

lib/sanitizer_common/sanitizer_allocator_bytemap.h

21

I feel like Reset could be confusing as it could lead someone to think it can be called for more purposes than initialization.

[vitalybuka]

lib/sanitizer_common/sanitizer_allocator_bytemap.h

21

Up to you, but I see no issues if it called for more purposes.

lib/sanitizer_common/sanitizer_allocator_bytemap.h

 #ifndef SANITIZER_ALLOCATOR_H
 #error This file must be included inside sanitizer_allocator.h
 #endif
 
 // Maps integers in rage [0, kSize) to u8 values.
 template<u64 kSize>
 class FlatByteMap {
  public:
-  void TestOnlyInit() {
+  void Init() {
     internal_memset(map_, 0, sizeof(map_));
   }
 
   void set(uptr idx, u8 val) {
     CHECK_LT(idx, kSize);
     CHECK_EQ(0U, map_[idx]);
     map_[idx] = val;
   }

 // TwoLevelByteMap maps integers in range [0, kSize1*kSize2) to u8 values.
 // It is implemented as a two-dimensional array: array of kSize1 pointers
 // to kSize2-byte arrays. The secondary arrays are mmaped on demand.
 // Each value is initially zero and can be set to something else only once.
 // Setting and getting values from multiple threads is safe w/o extra locking.
 template <u64 kSize1, u64 kSize2, class MapUnmapCallback = NoOpMapUnmapCallback>
 class TwoLevelByteMap {
  public:
-  void TestOnlyInit() {
+  void Init() {
     internal_memset(map1_, 0, sizeof(map1_));
     mu_.Init();
   }
 
   void TestOnlyUnmap() {
     for (uptr i = 0; i < kSize1; i++) {
       u8 *p = Get(i);
       if (!p) continue;

lib/sanitizer_common/sanitizer_allocator_primary32.h

static uptr ClassIdToSize(uptr class_id) {
     return (class_id == SizeClassMap::kBatchClassID) ?
         kBatchSize : SizeClassMap::Size(class_id);
   }
 
   typedef SizeClassAllocator32<Params> ThisT;
   typedef SizeClassAllocator32LocalCache<ThisT> AllocatorCache;
 
   void Init(s32 release_to_os_interval_ms) {
-    possible_regions.TestOnlyInit();
+    possible_regions.Init();
     internal_memset(size_class_info_array, 0, sizeof(size_class_info_array));
   }
 
   s32 ReleaseToOSIntervalMs() const {
     return kReleaseToOSIntervalNever;
   }
 
   void SetReleaseToOSIntervalMs(s32 release_to_os_interval_ms) {

lib/sanitizer_common/tests/sanitizer_allocator_test.cc

 #endif  // !SANITIZER_ANDROID
 
 #endif  // SANITIZER_CAN_USE_ALLOCATOR64
 
 TEST(SanitizerCommon, TwoLevelByteMap) {
   const u64 kSize1 = 1 << 6, kSize2 = 1 << 12;
   const u64 n = kSize1 * kSize2;
   TwoLevelByteMap<kSize1, kSize2> m;
-  m.TestOnlyInit();
+  m.Init();
   for (u64 i = 0; i < n; i += 7) {
     m.set(i, (i % 100) + 1);
   }
   for (u64 j = 0; j < n; j++) {
     if (j % 7)
       EXPECT_EQ(m[j], 0);
     else
       EXPECT_EQ(m[j], (j % 100) + 1);
for (size_t i = p->shard; i < p->m->size(); i += p->num_shards) {
     p->m->set(i, val);
     EXPECT_EQ((*p->m)[i], val);
   }
   return 0;
 }
 
 TEST(SanitizerCommon, ThreadedTwoLevelByteMap) {
   TestByteMap m;
-  m.TestOnlyInit();
+  m.Init();
   TestMapUnmapCallback::map_count = 0;
   TestMapUnmapCallback::unmap_count = 0;
   static const int kNumThreads = 4;
   pthread_t t[kNumThreads];
   TestByteMapParam p[kNumThreads];
   for (int i = 0; i < kNumThreads; i++) {
     p[i].m = &m;
     p[i].shard = i;