Lines Matching defs:table

5 #include "src/objects/string-table.h"
21 #include "src/objects/string-table-inl.h"
59   // Only shrink if the table is very empty to avoid performance penalty.
81 // Data holds the actual data of the string table, including capacity and number
88 // The elements themselves are stored as an open-addressed hash table, with
204 void StringTable::Data::operator delete(void* table) { AlignedFree(table); }
257   // EnsureCapacity will guarantee the hash table is never full.
273   // EnsureCapacity will guarantee the hash table is never full.
289   // EnsureCapacity will guarantee the hash table is never full.
349     // When sharing the string table, it's possible that another thread already
373         // are sure that we are going to insert the string into the table.
377         // string table and allowing concurrent internalization.
412       // Migrations to thin are impossible, as we only call this method on table
435   // When sharing the string table, internalization is allowed to be concurrent
453   //    table sharing. The map mutation is threadsafe even with relaxed memory
454   //    order, because for concurrent table lookups, the "losing" thread will be
479   // String table lookups are allowed to be concurrent, assuming that:
483   //   - All writes to the string table are guarded by the Isolate string table
485   //   - Resizes of the string table first copies the old contents to the new
486   //     table, and only then sets the new string table pointer to the new
487   //     table,
488   //   - Only GCs can remove elements from the string table.
494   //    longer in the table)"
496   // This is because we _know_ that if we find an entry in the string table, any
501   // We therefore try to optimistically read from the string table without
507   // the string table lock. This applies to both allocation of new strings, and
508   // re-allocation of the string table on resize. So, we optimistically allocate
513   // Load the current string table data, in case another thread updates the
517   // First try to find the string in the table. This is safe to do even if the
518   // table is now reallocated; we won't find a stale entry in the old table
519   // because the new table won't delete it's corresponding entry until the
520   // string is dead, in which case it will die in this table too and worst
537     // Check one last time if the key is present in the table, in case it was
589   // This load can be relaxed as the table pointer can only be modified while
593   // Grow or shrink table if needed. We first try to shrink the table, if it
618     // acquire-loaded by other threads. This string table becomes the owner of
675     // A string that's not an array index, and not in the string table,
682   // If we found and entry in the string table and string is not internalized,
698     // string could be internalized, if the string table is shared and another