dart::BitmapBuilder Class Reference

#include <bitmap.h>

Inheritance diagram for dart::BitmapBuilder:

Public Member Functions
	BitmapBuilder ()
	BitmapBuilder (const BitmapBuilder &other)
intptr_t	Length () const
void	SetLength (intptr_t length)
bool	Get (intptr_t bit_offset) const
void	Set (intptr_t bit_offset, bool value)
intptr_t	Maximum () const
intptr_t	Minimum () const
void	SetRange (intptr_t min, intptr_t max, bool value)
void	Print () const
void	AppendAsBytesTo (BaseWriteStream *stream) const
void	Write (BaseWriteStream *stream) const
void	Read (ReadStream *stream)
Public Member Functions inherited from dart::ZoneAllocated
	ZoneAllocated ()
void *	operator new (size_t size)
void *	operator new (size_t size, Zone *zone)
void	operator delete (void *pointer)

Detailed Description

Definition at line 18 of file bitmap.h.

Constructor & Destructor Documentation

BitmapBuilder() [1/2]

dart::BitmapBuilder::BitmapBuilder ( )

inline

Definition at line 20 of file bitmap.h.

                  : length_(0), data_size_in_bytes_(kInlineCapacityInBytes) {
    memset(data_.inline_, 0, data_size_in_bytes_);
  }

BitmapBuilder() [2/2]

dart::BitmapBuilder::BitmapBuilder ( const BitmapBuilder &  other )

inline

Definition at line 24 of file bitmap.h.

      : ZoneAllocated(),
        length_(other.length_),
        data_size_in_bytes_(other.data_size_in_bytes_) {
    if (data_size_in_bytes_ == kInlineCapacityInBytes) {
      memmove(data_.inline_, other.data_.inline_, kInlineCapacityInBytes);
    } else {
      data_.ptr_ = AllocBackingStore(data_size_in_bytes_);
      memmove(data_.ptr_, other.data_.ptr_, data_size_in_bytes_);
    }
  }

Member Function Documentation

AppendAsBytesTo()

void dart::BitmapBuilder::AppendAsBytesTo

(

BaseWriteStream *

stream

)

const

Definition at line 91 of file bitmap.cc.

                                                                 {
  // Early return if there are no bits in the payload to copy.
  if (Length() == 0) return;
 
  const intptr_t total_size =
      Utils::RoundUp(Length(), kBitsPerByte) / kBitsPerByte;
  intptr_t payload_size;
  intptr_t extra_size;
  if (total_size > data_size_in_bytes_) {
    // A [BitmapBuilder] does not allocate storage for the trailing 0 bits in
    // the backing store, so we need to add additional empty bytes here.
    payload_size = data_size_in_bytes_;
    extra_size = total_size - data_size_in_bytes_;
  } else {
    payload_size = total_size;
    extra_size = 0;
  }
#if defined(DEBUG)
  // Make sure any bits in the payload beyond the bit length if we're not
  // appending trailing zeroes are cleared to ensure deterministic snapshots.
  if (extra_size == 0 && Length() % kBitsPerByte != 0) {
    const int8_t mask = (1 << (Length() % kBitsPerByte)) - 1;
    ASSERT_EQUAL(BackingStore()[payload_size - 1],
                 (BackingStore()[payload_size - 1] & mask));
  }
#endif
  stream->WriteBytes(BackingStore(), payload_size);
  for (intptr_t i = 0; i < extra_size; i++) {
    stream->WriteByte(0U);
  }
}

Get()

bool dart::BitmapBuilder::Get

(

intptr_t

bit_offset

)

const

Definition at line 35 of file bitmap.cc.

                                                 {
  if (!InRange(bit_offset)) {
    return false;
  }
  intptr_t byte_offset = bit_offset >> kBitsPerByteLog2;
  // Bits not covered by the backing store are implicitly false.
  return (byte_offset < data_size_in_bytes_) && GetBit(bit_offset);
}

Length()

intptr_t dart::BitmapBuilder::Length ( ) const

inline

Definition at line 36 of file bitmap.h.

{ return length_; }

Maximum()

intptr_t dart::BitmapBuilder::Maximum

(

)

const

Minimum()

intptr_t dart::BitmapBuilder::Minimum

(

)

const

Print()

void dart::BitmapBuilder::Print

(

)

const

Definition at line 81 of file bitmap.cc.

                                {
  for (intptr_t i = 0; i < Length(); i++) {
    if (Get(i)) {
      THR_Print("1");
    } else {
      THR_Print("0");
    }
  }
}

Read()

void dart::BitmapBuilder::Read

(

ReadStream *

stream

)

Definition at line 161 of file bitmap.cc.

                                           {
  length_ = stream->Read<intptr_t>();
  const intptr_t payload_size = stream->Read<intptr_t>();
  if (payload_size > data_size_in_bytes_) {
    data_size_in_bytes_ = payload_size;
    data_.ptr_ = AllocBackingStore(data_size_in_bytes_);
  } else {
    memset(BackingStore() + payload_size, 0,
           data_size_in_bytes_ - payload_size);
  }
  stream->ReadBytes(BackingStore(), payload_size);
}

Set()

void dart::BitmapBuilder::Set	(	intptr_t	bit_offset,
		bool	value
	)

Definition at line 44 of file bitmap.cc.

                                                       {
  if (!InRange(bit_offset)) {
    length_ = bit_offset + 1;
  }
 
  // Bits not covered by the backing store are implicitly false.
  // Grow the backing store if necessary.
  if (value) {
    if (!InBackingStore(bit_offset)) {
      intptr_t byte_offset = bit_offset >> kBitsPerByteLog2;
      uint8_t* old_data = BackingStore();
      intptr_t old_size = data_size_in_bytes_;
      data_size_in_bytes_ =
          Utils::RoundUp(byte_offset + 1, kIncrementSizeInBytes);
      ASSERT(data_size_in_bytes_ > 0);
      // Note: do not update data_ yet because it might overwrite old_data
      // contents.
      uint8_t* new_data = AllocBackingStore(data_size_in_bytes_);
      memmove(new_data, old_data, old_size);
      memset(&new_data[old_size], 0, (data_size_in_bytes_ - old_size));
      data_.ptr_ = new_data;
    }
    ASSERT(InBackingStore(bit_offset));
  }
 
  // Set bit if in backing store.
  if (InBackingStore(bit_offset)) {
    SetBit(bit_offset, value);
  }
}

SetLength()

void dart::BitmapBuilder::SetLength

(

intptr_t

length

)

Definition at line 13 of file bitmap.cc.

                                                 {
  // When this function is used to shorten the length, affected bits in the
  // backing store need to be cleared because the implementation assumes it.
  if (new_length < length_) {
    // Byte offset containing the first bit to be cleared.
    intptr_t byte_offset = new_length >> kBitsPerByteLog2;
    if (byte_offset < data_size_in_bytes_) {
      // First bit index (in the byte) to be cleared.
      intptr_t bit_index = new_length & (kBitsPerByte - 1);
      intptr_t mask = (1 << bit_index) - 1;
      BackingStore()[byte_offset] &= mask;
      // Clear the rest.
      ++byte_offset;
      if (byte_offset < data_size_in_bytes_) {
        memset(&BackingStore()[byte_offset], 0,
               data_size_in_bytes_ - byte_offset);
      }
    }
  }
  length_ = new_length;
}

SetRange()

void dart::BitmapBuilder::SetRange	(	intptr_t	min,
		intptr_t	max,
		bool	value
	)

Definition at line 75 of file bitmap.cc.

                                                                   {
  for (intptr_t i = min; i <= max; i++) {
    Set(i, value);
  }
}

Write()

void dart::BitmapBuilder::Write

(

BaseWriteStream *

stream

)

const

Definition at line 152 of file bitmap.cc.

                                                       {
  const intptr_t payload_size =
      Utils::Minimum(Utils::RoundUp(Length(), kBitsPerByte) / kBitsPerByte,
                     data_size_in_bytes_);
  stream->Write<intptr_t>(Length());
  stream->Write<intptr_t>(payload_size);
  stream->WriteBytes(BackingStore(), payload_size);
}

Member Data Documentation

inline_

uint8_t dart::BitmapBuilder::inline_[kInlineCapacityInBytes]

Definition at line 104 of file bitmap.h.

ptr_

uint8_t* dart::BitmapBuilder::ptr_

Definition at line 103 of file bitmap.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/bitmap.h
• third_party/dart-lang/sdk/runtime/vm/bitmap.cc