On Wed, Feb 15, 2017 at 12:29 AM, Ben Coman <btc@openinworld.com> wrote:

On Tue, Feb 14, 2017 at 11:01 PM, sergio ruiz <sergio.rrd@gmail.com> wrote:

Hey, all..

I have ��been working on creating a REST interface using Teapot. In learning how to handle exceptions, I have been following along with the library example.��

One of the things i noticed was that, in the library example, they are modeling that data a little differently than i have been..

to persist a list of items (and easily retrieve them), i just gave the object an ��id��, and store them on a class variable as an OrderedCollection..

in the library example, I see something i really like. rather than saving an ordered collection, they save it as a dictionary.

This dictionary goes { id -> object }.. this takes the id out of the the object (which i really like) and makes the id generation pretty much irrelevant..

my question.. is there any performance hit either way once this list grows to tens of thousands of records?

I was curious, so nothing better than to experiment...

myClass := Object subclass: #AA

instanceVariableNames: 'id data'

classVariableNames: ''

package: 'AAAA'.

myClass compile: 'id: i id:= i'.

myClass compile: 'data: d data:= d'.

N := 10 raisedTo: 7.

o := OrderedCollection new.

d := Dictionary new.

{ Time millisecondsToRun: [

1 to: N do: [:id| o add: (AA new id: id; data: 'blahblah')]].

Time millisecondsToRun: [

1 to: N do: [:id| d at: id put: (AA new data: 'blahblah')]].

} inspect.

o := nil.

d := nil.

Smalltalk garbageCollect.

N=5 ==>��"#(5 42)"

N=6 ==> "#(434 839)"��

N=7 ==>��"#(5733 17208)"

Slight modification to pre-allocate space to ignore dynamic growth cost...

o := OrderedCollection new: 2 * N.

d := Dictionary new: ��2 * N.

N=5 ==> "#(7 33)"

N=6 ==> "#(411 802)"

N=7 ==>��"#(5892 15141)"

cheers -ben

Lets also bench Arrays, and be a nicer with cleaning up memory...

N := 10 raisedTo: 7.

a := Array new: 2 * N.

atime := Smalltalk vm totalGCTime + (Time millisecondsToRun: [

1 to: N do: [:id| a at: id put: (AA new data: 'blahblah')]]) - Smalltalk vm totalGCTime.

a := nil.��

Smalltalk garbageCollect.

o := OrderedCollection new: 2 * N.

otime := Smalltalk vm totalGCTime + (Time millisecondsToRun: [

1 to: N do: [:id| o add: (AA new id: id; data: 'blahblah')]]) - Smalltalk vm totalGCTime.

o := nil.��

Smalltalk garbageCollect.

d := Dictionary new: 2 * N.

dtime := Smalltalk vm totalGCTime + (Time millisecondsToRun: [

1 to: N do: [:id| d at: id put: (AA new data: 'blahblah')]]) - Smalltalk vm totalGCTime.

d := nil.��

Smalltalk garbageCollect.

{atime. otime. dtime} inspect.

N=5 ==>��"#(2 4 13)" ��"#(2 4 13)" ��"#(2 5 13)"

N=6 ==> "#(30 48 131)" "#(28 48 131)" "#(29 47 128)"

N=7 ==> ��"#(274 470 1313)"��"#(259 456 1340)"��"#(269 467 1306)"

So insertions into Dictionaries are��

two to three ��times slower than OrderedCollection, and��

five to six times slower than Arrays.

Now this is milliseconds, so even at the 100,000 level Dictionary performance��

may be a reasonable tradeoff for other benefits.

cheers -ben