Changeset 2789 in webkit for trunk/JavaScriptCore


Ignore:
Timestamp:
Nov 20, 2002, 2:59:04 PM (23 years ago)
Author:
darin
Message:
  • kjs/types.cpp: Keep ref count for the whole lists of nodes. Doesn't speed things up much, less than 1%.
Location:
trunk/JavaScriptCore
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/JavaScriptCore/ChangeLog

    r2788 r2789  
     12002-11-20  Darin Adler  <[email protected]>
     2
     3        * kjs/types.cpp: Keep ref count for the whole lists of nodes.
     4        Doesn't speed things up much, less than 1%.
     5
    162002-11-20  Maciej Stachowiak  <[email protected]>
    27

  • trunk/JavaScriptCore/ChangeLog-2002-12-03

    r2788 r2789  
     12002-11-20  Darin Adler  <[email protected]>
     2
     3        * kjs/types.cpp: Keep ref count for the whole lists of nodes.
     4        Doesn't speed things up much, less than 1%.
     5
    162002-11-20  Maciej Stachowiak  <[email protected]>
    27

  • trunk/JavaScriptCore/ChangeLog-2003-10-25

    r2788 r2789  
     12002-11-20  Darin Adler  <[email protected]>
     2
     3        * kjs/types.cpp: Keep ref count for the whole lists of nodes.
     4        Doesn't speed things up much, less than 1%.
     5
    162002-11-20  Maciej Stachowiak  <[email protected]>
    27

  • trunk/JavaScriptCore/kjs/types.cpp

    r2777 r2789  
    3737#include "nodes.h"
    3838
    39 using namespace KJS;
    40 
    4139namespace KJS {
    4240
    43   class ListNode {
    44     friend class List;
    45     friend class ListIterator;
    46   protected:
     41  struct ListNode {
    4742    ListNode(const Value &val, ListNode *p, ListNode *n)
    48       : member(val.imp()), prev(p), next(n) {};
     43      : member(val.imp()), prev(p), next(n) { }
    4944    ListNode(ValueImp *val, ListNode *p, ListNode *n)
    50       : member(val), prev(p), next(n) {};
     45      : member(val), prev(p), next(n) { }
    5146    ValueImp *member;
    5247    ListNode *prev, *next;
    5348  };
    5449
    55   class ListHookNode : public ListNode {
    56     friend class List;
    57    
    58     ListHookNode() : ListNode(Value(), NULL, NULL), refcount(1) { prev = this; next = this; }
    59     int refcount;
     50  struct ListHookNode : public ListNode {
     51    ListHookNode(bool needsMarking) : ListNode(Value(), this, this),
     52        listRefCount(1), nodesRefCount(needsMarking ? 0 : 1) { }
     53    int listRefCount;
     54    int nodesRefCount;
    6055  };
    61   }
    62 
    6356
    6457// ------------------------------ ListIterator ---------------------------------
    … …  
    10295// ------------------------------ List -----------------------------------------
    10396
    104 List::List(bool needsMarking)
    105   : hook(new ListHookNode()),
    106     m_needsMarking(needsMarking)
    107 {
    108   if (!m_needsMarking) {
     97List::List(bool needsMarking) : hook(new ListHookNode(needsMarking)), m_needsMarking(needsMarking)
     98{
     99}
     100
     101List::List(const List& l) : hook(l.hook), m_needsMarking(false)
     102{
     103  ++hook->listRefCount;
     104  if (hook->nodesRefCount++ == 0)
    109105    refAll();
    110   }
    111 }
    112 
    113 
    114 List::List(const List& l)
    115   : hook(l.hook),
    116     m_needsMarking(false)
    117 { 
    118   hook->refcount++;
    119   if (!m_needsMarking) {
    120     refAll();
    121   }
    122106}
    123107
    124108List& List::operator=(const List& l)
    125109{
    126   List tmp(l);
    127 
    128   tmp.swap(*this);
    129 
     110  List(l).swap(*this);
    130111  return *this;
    131112}
    132      
     113
    133114List::~List()
    134115{
    135   if (!m_needsMarking) {
    136     derefAll();
    137   }
     116  if (!m_needsMarking)
     117    if (--hook->nodesRefCount == 0)
     118      derefAll();
    138119 
    139   hook->refcount--;
    140   if (hook->refcount == 0) {
     120  if (--hook->listRefCount == 0) {
     121    assert(hook->nodesRefCount == 0);
    141122    clearInternal();
    142123    delete hook;
    … …  
    157138{
    158139  ListNode *n = new ListNode(val, hook->prev, hook);
    159   if (!m_needsMarking) {
     140  if (hook->nodesRefCount)
    160141    n->member->ref();
    161   }
    162142  hook->prev->next = n;
    163143  hook->prev = n;
    … …  
    167147{
    168148  ListNode *n = new ListNode(val, hook->prev, hook);
    169   if (!m_needsMarking) {
     149  if (hook->nodesRefCount)
    170150    val->ref();
    171   }
    172151  hook->prev->next = n;
    173152  hook->prev = n;
    … …  
    177156{
    178157  ListNode *n = new ListNode(val, hook, hook->next);
    179   if (!m_needsMarking) {
     158  if (hook->nodesRefCount)
    180159    n->member->ref();
    181   }
    182160  hook->next->prev = n;
    183161  hook->next = n;
    … …  
    187165{
    188166  ListNode *n = new ListNode(val, hook, hook->next);
    189   if (!m_needsMarking) {
     167  if (hook->nodesRefCount)
    190168    val->ref();
    191   }
    192169  hook->next->prev = n;
    193170  hook->next = n;
    … …  
    218195  if (val.isNull())
    219196    return;
    220   ListNode *n = hook->next;
    221   while (n != hook) {
     197  for (ListNode *n = hook->next; n != hook; n = n->next)
    222198    if (n->member == val.imp()) {
    223199      erase(n);
    224200      return;
    225201    }
    226     n = n->next;
    227   }
    228202}
    229203
    230204void List::clear()
    231205{
    232   if (!m_needsMarking) {
     206  if (hook->nodesRefCount)
    233207    derefAll();
    234   }
    235208  clearInternal();
    236209}
    … …  
    267240bool List::isEmpty() const
    268241{
    269   return (hook->prev == hook);
     242  return hook->prev == hook;
    270243}
    271244
    … …  
    273246{
    274247  int s = 0;
    275   ListNode *node = hook;
    276   while ((node = node->next) != hook)
     248  for (ListNode *n = hook->next; n != hook; n = n->next)
    277249    s++;
    278 
    279250  return s;
    280251}
    … …  
    307278{
    308279  if (n != hook) {
    309     if (!m_needsMarking) {
     280    if (hook->nodesRefCount)
    310281      n->member->deref();
    311     }
    312282    n->next->prev = n->prev;
    313283    n->prev->next = n->next;
    … …  
    318288void List::refAll()
    319289{
    320   ListNode *n = hook->next;
    321 
    322   while (n != hook) {
     290  for (ListNode *n = hook->next; n != hook; n = n->next)
    323291    n->member->ref();
    324     n = n->next;
    325   }
    326292}
    327293
    328294void List::derefAll()
    329295{
    330   ListNode *n = hook->next;
    331 
    332   while (n != hook) {
     296  for (ListNode *n = hook->next; n != hook; n = n->next)
    333297    n->member->deref();
    334     n = n->next;
    335   }
    336298}
    337299
    338300void List::swap(List &other)
    339301{
    340   if (m_needsMarking && !other.m_needsMarking) {
    341     refAll();
    342     other.derefAll();
    343   } else if (!m_needsMarking && other.m_needsMarking) {
    344     other.refAll();
    345     derefAll();
    346   }
     302  if (!m_needsMarking)
     303    if (other.hook->nodesRefCount++ == 0)
     304      other.refAll();
     305  if (!other.m_needsMarking)
     306    if (hook->nodesRefCount++ == 0)
     307      refAll();
     308
     309  if (!m_needsMarking)
     310    if (--hook->nodesRefCount == 0)
     311      derefAll();
     312  if (!other.m_needsMarking)
     313    if (--other.hook->nodesRefCount == 0)
     314      other.derefAll();
    347315
    348316  ListHookNode *tmp = hook;
    … …  
    353321void List::replaceFirst(ValueImp *v)
    354322{
    355     ListNode *n = hook->next;
    356     if (!m_needsMarking) {
    357       v->ref();
    358       n->member->deref();
    359     }
    360     n->member = v;
     323  ListNode *n = hook->next;
     324  if (hook->nodesRefCount) {
     325    v->ref();
     326    n->member->deref();
     327  }
     328  n->member = v;
    361329}
    362330
    363331void List::replaceLast(ValueImp *v)
    364332{
    365     ListNode *n = hook->prev;
    366     if (!m_needsMarking) {
    367       v->ref();
    368       n->member->deref();
    369     }
    370     n->member = v;
    371 }
     333  ListNode *n = hook->prev;
     334  if (hook->nodesRefCount) {
     335    v->ref();
     336    n->member->deref();
     337  }
     338  n->member = v;
     339}
     340
     341} // namespace KJS
Note: See TracChangeset for help on using the changeset viewer.