Databases
StackOverflow2013
Postsdbo
PO
 

Note that there are some explanatory texts on larger screens.

plurals
  1. PO
    primarykey
    data
    text
    <p>I've got two suggestions to try: </p> <p>Firstly, what about using Reflector or ILSpy to look inside Generic <code>List&lt;T&gt;</code>? I assume that implementation isn't in the CF or you could use it. Generic <code>List&lt;T&gt;</code> is array backed and uses a doubling algorithm starting at length 4 array, every call to .Add over the Capacity causes it to double and perform an Array.Copy into the new array. It doesn't resize unless you explicitly set Capacity to zero so beware from a memory point of view. Adds are one thing but each Remove will cause the array to be copied and left-shifted after the index that was removed. </p> <p>The second suggestion is this - what about about creating a custom class which wraps an integer array to handle this which uses a similar double algorithm (or quadrupling) to Generic <code>List&lt;T&gt;</code> (to handle resizing) but starts at say size 256. You could add object integer id's to this out of order as fast as you like and it won't double too often. You could also simulate a remove by designating (int)-1 or uint.MaxValue as a "null index" meaning no Array.Copy on remove. Then, apply some sort of fast sorting per frame to sort the object index array before drawing. If you sort ascending all your -1s will appear at the start (or uint.MaxValues at end) and can be ignored. You can periodically "collect" the index array by resizing and removing the preceeding <code>-1</code>'s on a separate thread (beware - use locking ;)</p> <p>What do you think? Just thinking you will offset some computation once per frame for fast sorting (not expensive on xbox vs. memory allocation/collection on each Remove and some Adds (expensive). </p> <p><strong>UPDATE - BlockArray - List&lt;T[]&gt; where T is fixed size array</strong></p> <p>A further comment on this. I was recently experimenting with the most efficient data-structure for dynamically sized lists and discovered by experimentation that array blocks - a class which is backed by a List of T[], where each T[] was an array of fixed size block, e.g. 512, 4096, 8192 as several advantages over a plain List&lt;T&gt;. </p> <p>I found that an implementation of Add() (where size is unknown) in a List&lt;T[]&gt; vastly outperformed Add() for List&lt;T&gt;, especially when the total size became larger. This is due to List&lt;T&gt;'s doubling algorithm which requests a new array 2x the size of the old, and memcpy's the old array over whenever size is exceeded. </p> <p>Iterating speed is similar. Pre-allocation (pre-defined capacity) was much slower than List&lt;T&gt; for small block sizes (512), but only slightly slower for large block sizes (8192). Removes are problematic, as require copying/left shifting many blocks.</p> <p>What's interesting is in a List&lt;T[]&gt; (block list), you can cache/pool the blocks. If small enough, blocks of T[] fit into the small object heap (favouring compaction, quicker allocation), may fit into the L2 cache and a number of blocks could be pre-allocated and pooled</p>
    singulars
    1. This table or related slice is empty.
    1. POCollection with very fast iterating and good addition and remove speeds
      singulars
      1. PTQuestion
    1. PTAnswer
    1. USDr. ABT
    1. USDr. ABT
    plurals
    1. This table or related slice is empty.
    1. This table or related slice is empty.
    1. POCollection with very fast iterating and good addition and remove speeds
      singulars
      1. PTQuestion
    1. This table or related slice is empty.
    1. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    2. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTAcceptedByOriginator
    3. VO
      singulars
      1. PO
      1. This table or related slice is empty.
      1. VTUpMod
    1. COI really like the idea of using a list and just invalidating elements for removal at a later time. I think when iterating i'd just skip the invalid ones so i don't need to sort, then periodically i'd shift all elements down when i found an invalid one to effectively remove them.
      singulars
      1. PO
      1. USGeorge Duckett
    2. CO@GeorgeDuckett thanks! Yes you'll need to sort so you can get your scene graph in render order. The plus side to this solution is you can add just to the end of the array (out of order) without performing a sort on each Add and remove is just setting the array value to -1. Perhaps to make it more performant dont search the array for object index Id = 123 but store the index to the IndexArray on the object too? Just things to try really. .NET is a powerful language and I've written simulation software before that was highly performant in C#. Just need to squeeze the cycles out by reducing GCs
      singulars
      1. PO
      1. USDr. ABT
    3. CO... to which I should add, perf enhancement in C# is the same as in C++. If you write native code that goes new() new() new() delete delete delete you wouldn't be surprised if it was slow, I wonder why people feel .NET should be any different? ;-P
      singulars
      1. PO
      1. USDr. ABT
 

Querying!

 
Guidance
A row detail

Detail views are divided into sections. All the information in the data section comes from columns in the selected row. The other sections display data from other, related rows.

Related data can be related in a to-one or a to-many fashion. Captions of data related in a to-many fashion link to a list view showing a filtered view of the table.

Try moving around until you find a non-empty to-many entry and click on the label to get to one. You can move back to the root by clicking on the database name in the header.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload