* sim/ucsim/sim.src/memcl.h: added get_decoder() to cl_address_space

* sim/ucsim/sim.src/mem.cc: implemented cl_address_space::get_decoder,
  (cl_address_space constructor): removed expensive initialization,
  (cl_address_space::get_cell): extended for late initialization,
  (cl_address_space::*): use late initialization,
  (cl_address_decoder::activate): removed expensive initialization,
  This reduced regression test running time by 25%

git-svn-id: https://sdcc.svn.sourceforge.net/svnroot/sdcc/trunk/sdcc@4167 4a8a32a2-be11-0410-ad9d-d568d2c75423

diff --git a/ChangeLog b/ChangeLog
index baa90c4669e6c1f98300f6ba2b699135231e3f33..433e7b30d6645587e6e6599510edcfadb0d225e2 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,13 @@
+2006-05-11 Maarten Brock <sourceforge.brock AT dse.nl>
+
+       * sim/ucsim/sim.src/memcl.h: added get_decoder() to cl_address_space
+       * sim/ucsim/sim.src/mem.cc: implemented cl_address_space::get_decoder,
+         (cl_address_space constructor): removed expensive initialization,
+         (cl_address_space::get_cell): extended for late initialization,
+         (cl_address_space::*): use late initialization,
+         (cl_address_decoder::activate): removed expensive initialization,
+         This reduced regression test running time by 25%
+
 2006-05-11 Bernhard Held <bernhard AT bernhardheld.de>
 
        * packihx/,

diff --git a/sim/ucsim/sim.src/mem.cc b/sim/ucsim/sim.src/mem.cc
index 6be08f6460a2f7873e59538b8633411f8fe271dc..fc67632ac368c7ce0b11c324cb838cd69744d7f0 100644 (file)
--- a/sim/ucsim/sim.src/mem.cc
+++ b/sim/ucsim/sim.src/mem.cc
@@ -702,13 +702,8 @@ cl_address_space::cl_address_space(char *id,
 {
   start_address= astart;
   decoders= new cl_decoder_list(2, 2, DD_FALSE);
-  cells= (class cl_memory_cell **)malloc(size * sizeof(class cl_memory_cell*));
-  int i;
-  for (i= 0; i < size; i++)
-    {
-      cells[i]= new cl_memory_cell();
-      cells[i]->init();
-    }
+  cells= (class cl_memory_cell **)calloc(size, sizeof(class cl_memory_cell*));
+
   dummy= new cl_dummy_cell();
 }
 
@@ -726,79 +721,42 @@ cl_address_space::~cl_address_space(void)
 t_mem
 cl_address_space::read(t_addr addr)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    {
-      err_inv_addr(addr);
-      return(dummy->read());
-    }
-  return(cells[idx]->read());
+  return get_cell(addr)->read();
 }
 
 t_mem
 cl_address_space::read(t_addr addr, enum hw_cath skip)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
+  cl_memory_cell *cell = get_cell(addr);
+  if (cell == dummy)
     {
-      err_inv_addr(addr);
-      return(dummy->read());
+      return dummy->read();
     }
-  return(cells[idx]->read(skip));
+  return cell->read(skip);
 }
 
 t_mem
 cl_address_space::get(t_addr addr)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    {
-      err_inv_addr(addr);
-      return(dummy->get());
-    }
-  return(cells[idx]->get());
+  return get_cell(addr)->get();
 }
 
 t_mem
 cl_address_space::write(t_addr addr, t_mem val)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    {
-      err_inv_addr(addr);
-      return(dummy->write(val));
-    }
-  return(cells[idx]->write(val));
+  return get_cell(addr)->write(val);
 }
 
 void
 cl_address_space::set(t_addr addr, t_mem val)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    {
-      err_inv_addr(addr);
-      dummy->set(val);
-      return;
-    }
-  cells[idx]->set(val);
+  get_cell(addr)->set(val);
 }
 
 t_mem
 cl_address_space::wadd(t_addr addr, long what)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    {
-      err_inv_addr(addr);
-    }
-  return(cells[idx]->wadd(what));
+  return get_cell(addr)->wadd(what);
 }
 
 /* Set or clear bits, without callbacks */
@@ -806,25 +764,42 @@ cl_address_space::wadd(t_addr addr, long what)
 void
 cl_address_space::set_bit1(t_addr addr, t_mem bits)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
+  cl_memory_cell *cell = get_cell(addr);
+  if (cell == dummy)
+    {
     return;
-  class cl_memory_cell *cell= cells[idx];
+    }
   cell->set_bit1(bits);
 }
 
 void
 cl_address_space::set_bit0(t_addr addr, t_mem bits)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    return;
-  class cl_memory_cell *cell= cells[idx];
+  cl_memory_cell *cell = get_cell(addr);
+  if (cell == dummy)
+    {
+      return;
+    }
   cell->set_bit0(bits);
 }
 
+class cl_address_decoder *
+cl_address_space::get_decoder(t_addr addr)
+{
+  int i;
+  for (i= 0; i < decoders->count; i++)
+    {
+      class cl_address_decoder *d=
+       dynamic_cast<class cl_address_decoder *>(decoders->object_at(i));
+      if (!d)
+       continue;
+      if (d->covers(addr, addr))
+       {
+         return d;
+       }
+    }
+    return NULL;
+}
 
 class cl_memory_cell *
 cl_address_space::get_cell(t_addr addr)
@@ -836,6 +811,18 @@ cl_address_space::get_cell(t_addr addr)
       err_inv_addr(addr);
       return(dummy);
     }
+  if (cells[idx] == NULL)
+    {
+      cells[idx]= new cl_memory_cell();
+      cells[idx]->init();
+      class cl_address_decoder *decoder;
+      decoder = get_decoder(addr);
+      if (decoder && decoder->activated)
+        {
+          decode_cell(addr, decoder->memchip,
+                      addr - decoder->as_begin + decoder->chip_begin);
+        }
+    }
   return(cells[idx]);
 }
 
@@ -843,41 +830,19 @@ cl_address_space::get_cell(t_addr addr)
 int
 cl_address_space::get_cell_flag(t_addr addr)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    {
-      return(dummy->get_flags());
-    }
-  return(cells[addr]->get_flags());
+  return get_cell(addr)->get_flags();
 }
 
 bool
 cl_address_space::get_cell_flag(t_addr addr, enum cell_flag flag)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    {
-      return(dummy->get_flag(flag));
-    }
-  return(cells[addr]->get_flag(flag));
+  return get_cell(addr)->get_flag(flag);
 }
 
 void
 cl_address_space::set_cell_flag(t_addr addr, bool set_to, enum cell_flag flag)
 {
-  t_addr idx= addr-start_address;
-  class cl_memory_cell *cell;
-  
-  if (idx >= size ||
-      addr < start_address)
-    {
-      cell= dummy;
-    }
-  else
-    cell= cells[addr];
-  cell->set_flag(flag, set_to);
+  get_cell(addr)->set_flag(flag, set_to);
 }
 
 
@@ -885,11 +850,11 @@ bool
 cl_address_space::decode_cell(t_addr addr,
                              class cl_memory_chip *chip, t_addr chipaddr)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    return(DD_FALSE);
-  class cl_memory_cell *cell= cells[idx];
+  cl_memory_cell *cell = get_cell(addr);
+  if (cell == dummy)
+    {
+      return(DD_FALSE);
+    }
 
   if (!cell->get_flag(CELL_NON_DECODED))
     {
@@ -907,10 +872,15 @@ cl_address_space::undecode_cell(t_addr addr)
   t_addr idx= addr-start_address;
   if (idx >= size ||
       addr < start_address)
-    return;
-  class cl_memory_cell *cell= cells[idx];
-
-  cell->un_decode();
+    {
+      err_inv_addr(addr);
+      return;
+    }
+  if (cells[idx] == NULL)
+    {
+      return;
+    }
+  cells[idx]->un_decode();
 }
 
 void
@@ -984,11 +954,11 @@ cl_address_space::register_hw(t_addr addr, class cl_hw *hw,
                              int *ith,
                              bool announce)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    return(0);
-  class cl_memory_cell *cell= cells[idx];
+  cl_memory_cell *cell = get_cell(addr);
+  if (cell == dummy)
+    {
+      return(NULL);
+    }
   cell->add_hw(hw, ith, addr);
   //printf("adding hw %s to cell 0x%x(%d) of %s\n", hw->id_string, addr, idx, get_name("as"));
   if (announce)
@@ -1000,11 +970,12 @@ cl_address_space::register_hw(t_addr addr, class cl_hw *hw,
 void
 cl_address_space::set_brk(t_addr addr, class cl_brk *brk)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    return;
-  class cl_memory_cell *cell= cells[idx];
+  cl_memory_cell *cell = get_cell(addr);
+  if (cell == dummy)
+    {
+      return;
+    }
+
   class cl_memory_operator *op;
 
   switch (brk->get_event())
@@ -1035,11 +1006,11 @@ cl_address_space::set_brk(t_addr addr, class cl_brk *brk)
 void
 cl_address_space::del_brk(t_addr addr, class cl_brk *brk)
 {
-  t_addr idx= addr-start_address;
-  if (idx >= size ||
-      addr < start_address)
-    return;
-  class cl_memory_cell *cell= cells[idx];
+  cl_memory_cell *cell = get_cell(addr);
+  if (cell == dummy)
+    {
+      return;
+    }
 
   switch (brk->get_event())
     {
@@ -1240,16 +1211,6 @@ cl_address_decoder::activate(class cl_console *con)
 
   address_space->undecode_area(this, as_begin, as_end, con);
 
-  t_addr asa, ca;
-  for (asa= as_begin, ca= chip_begin;
-       asa <= as_end;
-       asa++, ca++)
-    {
-      if (!address_space->decode_cell(asa, memchip, ca))
-       {
-         D("Decoding 0x%06x->0x%06x failed\n", asa, ca);
-       }
-    }
   activated= DD_TRUE;
 
 #undef D

diff --git a/sim/ucsim/sim.src/memcl.h b/sim/ucsim/sim.src/memcl.h
index e12819b7b2507743531cd0fe45bdf1a8a664bfa0..625808db8a3ce258104cf10e0bbbe7a06ebf0764 100644 (file)
--- a/sim/ucsim/sim.src/memcl.h
+++ b/sim/ucsim/sim.src/memcl.h
@@ -292,6 +292,8 @@ public:
   virtual void set_bit1(t_addr addr, t_mem bits);
   virtual void set_bit0(t_addr addr, t_mem bits);
 
+  virtual class cl_address_decoder *get_decoder(t_addr addr);
+
   virtual class cl_memory_cell *get_cell(t_addr addr);
   virtual int get_cell_flag(t_addr addr);
   virtual bool get_cell_flag(t_addr addr, enum cell_flag flag);