v8::internal::RegExpResultsCache Class Reference

#include <heap.h>

Collaboration diagram for v8::internal::RegExpResultsCache:

Public Types
enum	ResultsCacheType { REGEXP_MULTIPLE_INDICES , STRING_SPLIT_SUBSTRINGS }

Static Public Member Functions
static Object *	Lookup (Heap *heap, String *key_string, Object *key_pattern, ResultsCacheType type)
static void	Enter (Isolate *isolate, Handle< String > key_string, Handle< Object > key_pattern, Handle< FixedArray > value_array, ResultsCacheType type)
static void	Clear (FixedArray *cache)

Static Public Attributes
static const int	kRegExpResultsCacheSize = 0x100

Static Private Attributes
static const int	kArrayEntriesPerCacheEntry = 4
static const int	kStringOffset = 0
static const int	kPatternOffset = 1
static const int	kArrayOffset = 2

Detailed Description

Definition at line 2366 of file heap.h.

Member Enumeration Documentation

ResultsCacheType

enum v8::internal::RegExpResultsCache::ResultsCacheType

Enumerator
REGEXP_MULTIPLE_INDICES
STRING_SPLIT_SUBSTRINGS

Definition at line 2368 of file heap.h.

{ REGEXP_MULTIPLE_INDICES, STRING_SPLIT_SUBSTRINGS };

Member Function Documentation

Clear()

void v8::internal::RegExpResultsCache::Clear ( FixedArray *  cache )

static

Definition at line 3031 of file heap.cc.

                                                {
  for (int i = 0; i < kRegExpResultsCacheSize; i++) {
    cache->set(i, Smi::FromInt(0));
  }
}

References v8::internal::Smi::FromInt(), kRegExpResultsCacheSize, and v8::internal::FixedArray::set().

Referenced by v8::internal::Heap::MarkCompactPrologue().

Here is the call graph for this function:

Here is the caller graph for this function:

Enter()

void v8::internal::RegExpResultsCache::Enter ( Isolate *  isolate, Handle< String >  key_string, Handle< Object >  key_pattern, Handle< FixedArray >  value_array, ResultsCacheType  type  )

static

Definition at line 2977 of file heap.cc.

                                                      {
  Factory* factory = isolate->factory();
  Handle<FixedArray> cache;
  if (!key_string->IsInternalizedString()) return;
  if (type == STRING_SPLIT_SUBSTRINGS) {
    DCHECK(key_pattern->IsString());
    if (!key_pattern->IsInternalizedString()) return;
    cache = factory->string_split_cache();
  } else {
    DCHECK(type == REGEXP_MULTIPLE_INDICES);
    DCHECK(key_pattern->IsFixedArray());
    cache = factory->regexp_multiple_cache();
  }
 
  uint32_t hash = key_string->Hash();
  uint32_t index = ((hash & (kRegExpResultsCacheSize - 1)) &
                    ~(kArrayEntriesPerCacheEntry - 1));
  if (cache->get(index + kStringOffset) == Smi::FromInt(0)) {
    cache->set(index + kStringOffset, *key_string);
    cache->set(index + kPatternOffset, *key_pattern);
    cache->set(index + kArrayOffset, *value_array);
  } else {
    uint32_t index2 =
        ((index + kArrayEntriesPerCacheEntry) & (kRegExpResultsCacheSize - 1));
    if (cache->get(index2 + kStringOffset) == Smi::FromInt(0)) {
      cache->set(index2 + kStringOffset, *key_string);
      cache->set(index2 + kPatternOffset, *key_pattern);
      cache->set(index2 + kArrayOffset, *value_array);
    } else {
      cache->set(index2 + kStringOffset, Smi::FromInt(0));
      cache->set(index2 + kPatternOffset, Smi::FromInt(0));
      cache->set(index2 + kArrayOffset, Smi::FromInt(0));
      cache->set(index + kStringOffset, *key_string);
      cache->set(index + kPatternOffset, *key_pattern);
      cache->set(index + kArrayOffset, *value_array);
    }
  }
  // If the array is a reasonably short list of substrings, convert it into a
  // list of internalized strings.
  if (type == STRING_SPLIT_SUBSTRINGS && value_array->length() < 100) {
    for (int i = 0; i < value_array->length(); i++) {
      Handle<String> str(String::cast(value_array->get(i)), isolate);
      Handle<String> internalized_str = factory->InternalizeString(str);
      value_array->set(i, *internalized_str);
    }
  }
  // Convert backing store to a copy-on-write array.
  value_array->set_map_no_write_barrier(*factory->fixed_cow_array_map());
}

References DCHECK, v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), kArrayEntriesPerCacheEntry, kArrayOffset, kPatternOffset, kRegExpResultsCacheSize, kStringOffset, REGEXP_MULTIPLE_INDICES, and STRING_SPLIT_SUBSTRINGS.

Referenced by v8::internal::RUNTIME_FUNCTION(), and v8::internal::SearchRegExpMultiple().

Here is the call graph for this function:

Here is the caller graph for this function:

Lookup()

Object * v8::internal::RegExpResultsCache::Lookup ( Heap *  heap, String *  key_string, Object *  key_pattern, ResultsCacheType  type  )

static

Definition at line 2946 of file heap.cc.

                                                                               {
  FixedArray* cache;
  if (!key_string->IsInternalizedString()) return Smi::FromInt(0);
  if (type == STRING_SPLIT_SUBSTRINGS) {
    DCHECK(key_pattern->IsString());
    if (!key_pattern->IsInternalizedString()) return Smi::FromInt(0);
    cache = heap->string_split_cache();
  } else {
    DCHECK(type == REGEXP_MULTIPLE_INDICES);
    DCHECK(key_pattern->IsFixedArray());
    cache = heap->regexp_multiple_cache();
  }
 
  uint32_t hash = key_string->Hash();
  uint32_t index = ((hash & (kRegExpResultsCacheSize - 1)) &
                    ~(kArrayEntriesPerCacheEntry - 1));
  if (cache->get(index + kStringOffset) == key_string &&
      cache->get(index + kPatternOffset) == key_pattern) {
    return cache->get(index + kArrayOffset);
  }
  index =
      ((index + kArrayEntriesPerCacheEntry) & (kRegExpResultsCacheSize - 1));
  if (cache->get(index + kStringOffset) == key_string &&
      cache->get(index + kPatternOffset) == key_pattern) {
    return cache->get(index + kArrayOffset);
  }
  return Smi::FromInt(0);
}

References DCHECK, v8::internal::Smi::FromInt(), v8::internal::FixedArray::get(), v8::internal::Name::Hash(), kArrayEntriesPerCacheEntry, kArrayOffset, kPatternOffset, kRegExpResultsCacheSize, kStringOffset, REGEXP_MULTIPLE_INDICES, and STRING_SPLIT_SUBSTRINGS.

Referenced by v8::internal::RUNTIME_FUNCTION(), and v8::internal::SearchRegExpMultiple().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

kArrayEntriesPerCacheEntry

const int v8::internal::RegExpResultsCache::kArrayEntriesPerCacheEntry = 4

staticprivate

Definition at line 2383 of file heap.h.

Referenced by Enter(), and Lookup().

kArrayOffset

const int v8::internal::RegExpResultsCache::kArrayOffset = 2

staticprivate

Definition at line 2386 of file heap.h.

Referenced by Enter(), and Lookup().

kPatternOffset

const int v8::internal::RegExpResultsCache::kPatternOffset = 1

staticprivate

Definition at line 2385 of file heap.h.

Referenced by Enter(), and Lookup().

kRegExpResultsCacheSize

const int v8::internal::RegExpResultsCache::kRegExpResultsCacheSize = 0x100

static

Definition at line 2380 of file heap.h.

Referenced by Clear(), v8::internal::Heap::CreateInitialObjects(), Enter(), and Lookup().

kStringOffset

const int v8::internal::RegExpResultsCache::kStringOffset = 0

staticprivate

Definition at line 2384 of file heap.h.

Referenced by Enter(), and Lookup().

---

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

• /mnt/V8SourceCode/src/heap/heap.h
• /mnt/V8SourceCode/src/heap/heap.cc