reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

    1
    2
    3
    4
    5
    6
    7
    8
    9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19
   20
   21
   22
   23
   24
   25
   26
   27
   28
   29
   30
   31
   32
   33
   34
   35
   36
   37
   38
   39
   40
   41
   42
   43
   44
   45
   46
   47
   48
   49
   50
   51
   52
   53
   54
   55
   56
   57
   58
   59
   60
   61
   62
   63
   64
   65
   66
   67
   68
   69
   70
   71
   72
   73
   74

//===-- bytemap_test.cpp ----------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "bytemap.h"

#include "gtest/gtest.h"

#include <string.h>

template <typename T> void testMap(T &Map, scudo::uptr Size) {
  Map.init();
  for (scudo::uptr I = 0; I < Size; I += 7)
    Map.set(I, (I % 100) + 1);
  for (scudo::uptr J = 0; J < Size; J++) {
    if (J % 7)
      EXPECT_EQ(Map[J], 0);
    else
      EXPECT_EQ(Map[J], (J % 100) + 1);
  }
}

TEST(ScudoByteMapTest, FlatByteMap) {
  const scudo::uptr Size = 1U << 10;
  scudo::FlatByteMap<Size> Map;
  testMap(Map, Size);
  Map.unmapTestOnly();
}

TEST(ScudoByteMapTest, TwoLevelByteMap) {
  const scudo::uptr Size1 = 1U << 6, Size2 = 1U << 12;
  scudo::TwoLevelByteMap<Size1, Size2> Map;
  testMap(Map, Size1 * Size2);
  Map.unmapTestOnly();
}

using TestByteMap = scudo::TwoLevelByteMap<1U << 12, 1U << 13>;

struct TestByteMapParam {
  TestByteMap *Map;
  scudo::uptr Shard;
  scudo::uptr NumberOfShards;
};

void *populateByteMap(void *Param) {
  TestByteMapParam *P = reinterpret_cast<TestByteMapParam *>(Param);
  for (scudo::uptr I = P->Shard; I < P->Map->size(); I += P->NumberOfShards) {
    scudo::u8 V = static_cast<scudo::u8>((I % 100) + 1);
    P->Map->set(I, V);
    EXPECT_EQ((*P->Map)[I], V);
  }
  return 0;
}

TEST(ScudoByteMapTest, ThreadedTwoLevelByteMap) {
  TestByteMap Map;
  Map.init();
  static const scudo::uptr NumberOfThreads = 16U;
  pthread_t T[NumberOfThreads];
  TestByteMapParam P[NumberOfThreads];
  for (scudo::uptr I = 0; I < NumberOfThreads; I++) {
    P[I].Map = &Map;
    P[I].Shard = I;
    P[I].NumberOfShards = NumberOfThreads;
    pthread_create(&T[I], 0, populateByteMap, &P[I]);
  }
  for (scudo::uptr I = 0; I < NumberOfThreads; I++)
    pthread_join(T[I], 0);
  Map.unmapTestOnly();
}