Pharo-dev
By thread
pharo-dev@lists.pharo.org
By month
Messages by month
- ----- 2026 -----
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2025 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2024 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2023 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2022 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2021 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2020 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2019 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2018 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2017 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2016 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2015 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2014 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2013 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2012 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2011 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2010 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2009 -----
- December
- November
- October
- September
- August
- July
- June
- May
- April
- March
- February
- January
- ----- 2008 -----
- December
- November
- October
- September
- August
- July
- June
- May
- 3 participants
- 144636 messages
Re: [Pharo-dev] InfoWorld on Redline Smalltalk
by horrido
kilon.alios wrote
> It took python 24 years to get as popular as it is nowdays, the most
> popular languages have a similar lifespan if not more in some cases. Its a
> really long process and its full of compromises and ugly truths.
Longevity is not a strategy for success. There are many old languages that
have been around forever, and they have never become mainstream. Python,
along with a handful of other languages, are exceptions.
Smalltalk has had 40 years to get popular. It almost achieved it in the
1990s, but IBM dropped the ball and Sun kicked their ass. The last 20 years
have been dismal for Smalltalk; it's all but a forgotten language. (Not so
much in the past month. ;-)
> PS: Just a clarification because people love to put words on other people
> mouths, I never said that languages like Clojure and Scheme has been
> miserable failures generally, but based on the hype of how popular they
> will become. Both Clojure and Sceme are great language with continuously
> expanding communities . I was merely wanted to point out how hype does not
> help and there was tons of hype when Java allowed for the creation of
> those
> languages. Jython for example is one of the oldest Java languages (2001),
> and there was tons of hype when the project started that Jython could
> become at worst an equal to Cpython on terms of popularity and even more
> popular than Java at best. Sun even funded the development of Jython back
> in 2008.
Hype does not help if *all* it does is attract public attention. Hype helps
a great deal if it's backed up by tangible results; the product you're
hyping must deliver!
Hype is about growing mindshare from which springs many other benefits, /if
you play your cards right/.
--
View this message in context: http://forum.world.st/InfoWorld-on-Redline-Smalltalk-tp4799612p4800040.html
Sent from the Pharo Smalltalk Developers mailing list archive at Nabble.com.
Jan. 16, 2015
Re: [Pharo-dev] Implementing lazy loading for expandable collections (part 2)
by Jimmie Houchin
On 1/16/2015 12:55 PM, Nicolas Cellier wrote:
> 2015-01-16 0:48 GMT+01:00 Jimmie Houchin <jlhouchin(a)gmail.com
> <mailto:jlhouchin@gmail.com>>:
>
> Hello,
>
> Yes, I understand this is a micro-benchmark. And yes I know that
> micro-benchmarks can be dangerous and sometimes worthless.
> However, financial trading, which is the app I am working on, does
> this a lot. This is precisely where most of the time is spent.
> Adding data (numbers) or accessing data in arrays or matrices.
> This is where my app lives. And performance is important.
>
> Regarding my running of the test and the variety of loop sizes.
> From what I see in the test there is only one loop size. 10000
> There are differing initial OrderedCollection sizes. Unless I am
> misreading the code.
>
> OrderedCollection new: 100. (capacity 100).
>
> I don't understand how this could be a capacity of 100 by what
> seems to me to be a normal understanding when its initial size is
> 0 and it can grow infinitely beyond 100.
>
> To me if it has a capacity of 100, immediately after creation its
> size should be 100
> and its initial 100 elements should be accessible.
> oc at: 1 put: 1 should work.
> So I do not understand where this supposed capacity enters into
> anything. It is neither immediately accessible, nor does it limit.
>
>
> It's not specific to OrderedCollection.
> Dictionary new: 100 and Set new: 100 also behave the same.
>
> It's rather Array that behaves differently than the rest of Collection
> zoo, because an Array of capacity 100 is also an Array of size 100,
> same for other ArrayedCollection.
>
> So if you re-think of it, you should always understand new: as
> reserving a certain capacity, which can casually also result in a
> collection of same size.
>
> You should notice the #ofSize: message that was added once upon a time...
Yes, after writing the email when I went back into the image and browsed
OrderedCollection, I saw the #ofSize: message which does exactly what I
naively thought #new: would do.
I ran the tests with #ofSize: and #at:put: and got a reasonably
nice improvement over any of the #new: implementations. It wasn't
anywhere near the tests done using an Array, but better.
Dictionaries and Sets are very different creatures from Array and
OrderedCollection. An OrderedCollection could just as easily be named
GrowableArray or some such. At least from my understanding.
So, yes, I need to change my naive understanding to a now slightly
better informed understanding.
There is much to learn.
Thanks for your input.
Jimmie
Jan. 16, 2015
Re: [Pharo-dev] Implementing lazy loading for expandable collections (part 2)
by Stephan Eggermont
Eliot wrote:
>About 90% of the entire time is in the string copying primitive.
>Not much to be done there. Sista could speed this up by eliminating
>the validation overhead of the primitive. But with our current VM technology
>there's not a lot one can do given that OrderedCollection is organized as a flat stack.
> This is probably a case where an ordered tree would be faster, albeit have a lot more space overhead.
Switching collections backing store to a chunked representation once they grow
beyond a certain threshold is probably the best thing to support larger collections.
Stephan
Jan. 16, 2015
Re: [Pharo-dev] Implementing lazy loading for expandable collections (part 2)
by Nicolas Cellier
2015-01-16 0:48 GMT+01:00 Jimmie Houchin <jlhouchin(a)gmail.com>:
> Hello,
>
> Yes, I understand this is a micro-benchmark. And yes I know that
> micro-benchmarks can be dangerous and sometimes worthless. However,
> financial trading, which is the app I am working on, does this a lot. This
> is precisely where most of the time is spent. Adding data (numbers) or
> accessing data in arrays or matrices. This is where my app lives. And
> performance is important.
>
> Regarding my running of the test and the variety of loop sizes. From what
> I see in the test there is only one loop size. 10000
> There are differing initial OrderedCollection sizes. Unless I am
> misreading the code.
>
> OrderedCollection new: 100. (capacity 100).
>
> I don't understand how this could be a capacity of 100 by what seems to me
> to be a normal understanding when its initial size is 0 and it can grow
> infinitely beyond 100.
>
> To me if it has a capacity of 100, immediately after creation its size
> should be 100
> and its initial 100 elements should be accessible.
> oc at: 1 put: 1 should work.
> So I do not understand where this supposed capacity enters into anything.
> It is neither immediately accessible, nor does it limit.
>
>
It's not specific to OrderedCollection.
Dictionary new: 100 and Set new: 100 also behave the same.
It's rather Array that behaves differently than the rest of Collection zoo,
because an Array of capacity 100 is also an Array of size 100, same for
other ArrayedCollection.
So if you re-think of it, you should always understand new: as reserving a
certain capacity, which can casually also result in a collection of same
size.
You should notice the #ofSize: message that was added once upon a time...
When I create an Array, it has a capacity with an understanding that I have.
> a := Array new: 100.
> size a. "100"
> a at: 1. "nil" "works"
> a at: 1 put: 1. "works"
>
> I naively expect the same from another Collection which looks like
> oc := OrderedCollection new: 100.
> Since it is a collection with an initial size (capacity). But because it
> is an OrderedCollection and not an Array, it is not limited by its initial
> capacity.
> Apparently my understanding faulty. I just wanted to express how this
> would potentially/probably be understood by someone who does not know this
> peculiarity of OrderedCollection.
>
> Regarding the comparison to Python and Julia.
> Mea Culpa, mea culpa, maxima mea culpa.
>
> While I thought I duplicated the Pharo code. I did not.
> I duplicated the inner loop which created and populated the array.
> I completely left off the outer loop which ran the inner loop 10000 times.
>
> The Python code is simple.
>
> def t(n):
> s = time.time()
> for x in range(0,10000):
> l = []
> for i in range(1,10001):
> l.append(i)
> e = time.time()
> print(e-s, len(l))
> return l
>
> list_test(10000) # == 15.5 seconds
>
> Julia
> function test_array(asize)
> for i = 1:10000
> a = Array(Int64, asize)
> for i = 1:asize
> a[i]=i
> end
> end
> end
>
> @time(test_array(10000)) # 0.9 seconds
>
> So Pharo at 1.6 seconds (Array time) is respectable compared to Julia's
> highly optimized preallocated arrays and thoroughly keeps Python in its
> place.
>
> And if I start Julia off with an Array(Int64,0) and do append!(a,[i,]).
> Julia's time plummets to 19seconds.
>
> I feel much better. Thanks for challenging my numbers and insuring my
> comparisons were correct.
>
> Jimmie
>
>
>
>
> On 1/15/2015 1:13 PM, Sven Van Caekenberghe wrote:
>
>> Jimmy,
>>
>> On 15 Jan 2015, at 19:46, Jimmie Houchin <jlhouchin(a)gmail.com> wrote:
>>>
>>> I do not understand what is happening here.
>>>
>>> oc := OrderedCollection new: 10000.
>>> oc size. "0"
>>>
>>> a := Array new: 10000.
>>> a size. "10000"
>>>
>>> So it seems that the #new: isn't creating an OrderedCollection of the
>>> size we pass in.
>>>
>>> I discovered this when I attempted to do the identical test but with an
>>> Array instead of an OrderedCollection. Since the Array doesn't #add: I
>>> had to change the code to #at:put:.
>>>
>> This is all normal and by design.
>>
>> OrderedCollection is a growable collection, designed so you can add
>> elements at either end. The thread's discussion is about growing strategies.
>>
>> Consider,
>>
>> (OrderedCollection new: 100) capacity = 100
>>
>> it means it has preallocated room for a 100 elements, but the way it is
>> managed is tricky, as people discovered.
>>
>>> When I noticed all of the OC code did #add: even if supposedly setting
>>> its size to 10000(0). I tried to use #at:put: in the OrderedCollection but
>>> it failed because their was no index 1, because the size was still 0.
>>>
>>> I naively would have thought that OrderedCollection new: 10000 would
>>> return an OrderedCollection of 10000 empty/nil elements and that I could
>>> #at:put: into any of those 10000 slots and #add if I needed to go beyond
>>> those 10000.
>>>
>>> Tests done on a laptop with Windows 7, Pharo 4 latest image, latest
>>> stable vm, 3rd gen i7 processor, 12gb ram.
>>>
>>> I did all of the tests in Pharo 4 and added my Array test.
>>> 0:00:00:04.37
>>> 0:00:00:03.183
>>> 0:00:00:03.674
>>> 0:00:00:03.753
>>> 0:00:00:01.647 and with an Array instead of OrderedCollection
>>>
>>> So we can see if we know the max size and create the collection with
>>> that size it should improve performance.
>>>
>>> I also do not understand why Pharo is so slow on this?
>>>
>>> With the preallocated Array above it took 1.647 seconds.
>>>
>>> Python 3.4.2, 0.003 seconds with 10,000 ints, and 0.17 with 1,000,000
>>> ints.
>>> Julia 3.5, 0.005 seconds with 1,000,000 Int64.
>>>
>>> Now I don't expect Pharo to keep up with Julia. But we aren't even in
>>> the neighborhood with Python.
>>>
>>> I really would like to use Pharo. It really is my favorite language and
>>> environment. But these performance numbers give me pause.
>>>
>> There are differently sized loops in this thread, what exactly did you
>> try ?
>>
>> What is the Python code that you ran ?
>>
>> Benchmarking is always dangerous, you must make absolutely clear what you
>> are running and comparing.
>>
>> Sven
>>
>> Jimmie
>>>
>>>
>>> On 1/14/2015 3:53 AM, Max Leske wrote:
>>>
>>>> Hi Alex
>>>>
>>>> I thought the following little experiment might interest you.
>>>>
>>>> I was trying to find out (as per your suggestion) how big the
>>>> difference would be between:
>>>> - setting the array in OrderedCollection to nil and initializing it to
>>>> size 10 on first access
>>>> - initializing the array in OrderedCollection to size 0.
>>>>
>>>> Expectation: #grow will take time, ergo, using an empty array should be
>>>> slower than using
>>>> a preallocated array.
>>>>
>>>> Experiment (Pharo 1.3 on SqueakVM):
>>>>
>>>>
>>>> [ 10000 timesRepeat: [ | c | c := OrderedCollection new: 100000.
>>>> 1 to: 10000 do: [ :i | c add: i ] ] ] timeToRun 17566
>>>>
>>>> [ 10000 timesRepeat: [ | c | c := OrderedCollection new: 10000.
>>>> 1 to: 10000 do: [ :i | c add: i ] ] ] timeToRun 19717
>>>>
>>>> [ 10000 timesRepeat: [ | c | c := OrderedCollection new: 0.
>>>> 1 to: 10000 do: [ :i | c add: i ] ] ] timeToRun 17598
>>>>
>>>>
>>>>
>>>> [ 10000 timesRepeat: [ | c | c := OrderedCollection new: 1000.
>>>> 1 to: 10000 do: [ :i | c add: i ] ] ] timeToRun 18084
>>>>
>>>>
>>>>
>>>> Result: growing a collection is always faster (or at least nearly
>>>> equally fast)!
>>>>
>>>> Explanation: What makes preinitialized collections so slow is the fact
>>>> the the firstIndex variable will be set to
>>>> the first third of the array (3333 in this case). When the last
>>>> position in the array is reached, all elements
>>>> are copied to the beginning of the array (2n operations). This
>>>> copy operation is really slow (which can be seen
>>>> from the first example with an oversized collection that does
>>>> not require copying because the last position
>>>> of the array is never reached).
>>>>
>>>>
>>>> Experiment (Pharo 4 on PharoVM):
>>>> (Iâm using bigger numbers here to compensate for the faster VM :) )
>>>>
>>>>
>>>> [ 10000 timesRepeat: [ | c | c := OrderedCollection new: 1000000.
>>>> 1 to: 100000 do: [ :i | c add: i ] ] ] timeToRun "0:00:01:09.225"
>>>>
>>>> [ 10000 timesRepeat: [ | c | c := OrderedCollection new: 100000.
>>>> 1 to: 100000 do: [ :i | c add: i ] ] ] timeToRun "0:00:00:37.653"
>>>>
>>>> [ 10000 timesRepeat: [ | c | c := OrderedCollection new: 0.
>>>> 1 to: 100000 do: [ :i | c add: i ] ] ] timeToRun "0:00:00:40.152"
>>>>
>>>>
>>>>
>>>> [ 10000 timesRepeat: [ | c | c := OrderedCollection new: 10000.
>>>> 1 to: 100000 do: [ :i | c add: i ] ] ] timeToRun "0:00:00:42.121â
>>>>
>>>>
>>>>
>>>> Result: growing a collection is easily fast enough, although minute
>>>> performance gains are possible with preinitialized collections.
>>>>
>>>> Explanation: #makeRoomAtLast has been improved. Also: firstIndex is now
>>>> set to the beginning of the array, preventing the copy
>>>> operation that made the former measurements so slow.
>>>> The run with the oversized collection is only so slow because
>>>> it apparently takes a lot of time to assign the large array (?).
>>>>
>>>>
>>>> Consequence of my little experiment: My initial implementation of the
>>>> idea in you paper set the array in OrderedCollection to nil
>>>> under the assumption that grow operations are very costly. That
>>>> choice leads to many changes in methods of OrderedCollection
>>>> where it is necessary to check if the array has been
>>>> initialized yet. This introduces overhead and makes the code more error
>>>> prone.
>>>> I see now that it makes much more sense to use an empty array,
>>>> the performance lost by growing ist neglectable.
>>>>
>>>> It is also interesting to note that there almost never seems to
>>>> be a good reason to initialize an OrderedCollection with a large array.
>>>>
>>>>
>>>> Cheers,
>>>> Max
>>>>
>>>
>>>
>>
>
>
Jan. 16, 2015
Re: [Pharo-dev] [squeak-dev] Understanding Object Structures
by Chris Muller
> I presume that for someone approaching the system given only a textual description of object structures, through class comments and method source it is difficult to develop a good picture or mental model. For me, I read the blue book first, which is replete with pictures.
I like to envision the physical model in my mind. I look at the class
definitions to identify the object links (for pointer objects) and
then the methods which modifies those vars.
Once I have that picture of the physical model in my head, I then in
my mind think about that shape model with each node "suited up" with
its behaviors. Knowing their underlying links to other objects even
helps me evaluate the consistency and nuance of the API).
> I know that historically visual inspector frameworks such as Jun have been able to auto-generate pictorial representations of specific object graphs. I wonder how useful it would be to provide support for designers to include pictorial representations in class comments.
For years, I have been /totally/ interested in Alexandre's project,
not just to represent in-memory models but large Magma models,
visually. Roassal might struggle to perform with millions of nodes, I
don't know, but I know Craig used Walrus to render a large model.
Unfortunately I just haven't had the time to dig into these projects..
> Again I presume that the text model would have to support inclusion of simple bitmaps (to avoid having to include a full drawing framework in the system) and that the designer would construct a sample graph, generate a diagram using a visual inspector framework using eg Jun, render it to a bitmap and include it in the class comment.
Squeak's Text model actually supports the inclusion of any Morph
embedded as a single character. Maui uses that for its "documents" it
actually works very well. Seeing animated, fully-functioning Morphs
as characters in a document is kind'a cool.
> A more elaborate system could of course include the sample graph and render it dynamically, that would allow exploration.
>
> Either approach would make an interesting project, yes?
>
>>> Best,
>>> Marcel
>>>
>>>
>>>
>>> --
>>> View this message in context: http://forum.world.st/The-Trunk-Collections-mt-593-mcz-tp4799750p4799893.ht…
>>> Sent from the Squeak - Dev mailing list archive at Nabble.com.
>>>
>
Jan. 16, 2015
Re: [Pharo-dev] [Pharo4] Slots: GTInspector support
by Andrei Chis
On Fri, Jan 16, 2015 at 4:22 PM, Marcus Denker <marcus.denker(a)inria.fr>
wrote:
>
> > On 16 Jan 2015, at 12:12, Andrei Chis <chisvasileandrei(a)gmail.com>
> wrote:
> >
> > For me it's ok like it is now.
> >
> >
> > I updated the GTDebuggers to use slots.
> > For example you can use the bytecode one to see what actually gets
> executed (and even step into the code of the slot).
> >
> > <Screen Shot 2015-01-16 at 4.06.03 PM.png>
> >
>
> Wow! And just like that, the byte code debugger is actually very useful to
> see what happens for real with Slotsâ¦. very useful especially when
> you emit you own byte code for a Slot.
>
> > Now the other problem is that because reading a slot uses #send:read:
> the debugger will now stop at that instruction so one has to do an explicit
> step over to read the actual slot.
> > The logic that performs this check is now isolated in
> #stepToFirstInterestingBytecodeIn: so we could updated it to take slots
> into account.
> >
>
> Yes, that would be nice.
>
I made an issue:
https://pharo.fogbugz.com/f/cases/14743/The-debugger-should-skip-the-readin…
Now there is still the issue of stepping into a slot write, when stepping
into instructions.
One solution could be to have a setting that makes the debugger slot
sensitive (stepping into enters both slot reads and slot writes).
However, with the bytecode debugger one can easily step into slots.
Cheers,
Andrei
>
> Marcus
>
Jan. 16, 2015
Re: [Pharo-dev] Understanding Object Structures
by Eliot Miranda
Hi Thierry,
On Jan 16, 2015, at 8:10 AM, Thierry Goubier <thierry.goubier(a)gmail.com> wrote:
>
>
> 2015-01-16 16:55 GMT+01:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
>> Hi All,
>>
>> On Jan 16, 2015, at 7:36 AM, Eliot Miranda <eliot.miranda(a)gmail.com> wrote:
>>
>> > Hi Marcel,
>> >
>> > On Jan 16, 2015, at 5:54 AM, Marcel Taeumel <marcel.taeumel(a)student.hpi.uni-potsdam.de> wrote:
>> >
>> >> Ah, okay. I was curious about the performance of iterating over an array vs.
>> >> the linked list:
>> >>
>> >> a := Array new: 1000.
>> >> l := LinkedList new.
>> >>
>> >> 1000 timesRepeat: [l add: (StackLink with: nil)].
>> >>
>> >> [a do: [:ea | 1 + 2]] bench. "'94,600 per second.'"
>> >>
>> >> [l do: [:ea | 1 + 2]] bench. "'159,000 per second.'"
>> >>
>> >> I expected the opposite! :-O Why is that so?
>> >
>> > Look at the implementations of do:.
>> >
>> > In the Array case we iterate over the indices using SmallIntegers (fast arithmetic with no allocation) and dereference each element using the Object>>at: primitive, which (apart from type and bounds checking) is simple indexed memory access. So one read per element.
>> >
>> > In the LinkedList case each list element is fetched from the previous element and each value fetched from the element, so two reads per element.
>>
>> This is interesting. (Marcel, Chris, forgive me; I'm presuming; please don't take this personally). Marcel above appears to lack an intuition about the structure of Array vs LinkedList. And in developing a hash algorithm for a 32-bit subset of Floats a few weeks ago Chris appeared to lack an I tuition about Floats being boxed, assuming they were value types, not containers.
>>
>> As a VM implementer I carry around a clear picture (literally, I am a visual thinker) of objects in my head. Those pictures are key to my approach to design and optimization.
>>
>> I presume that for someone approaching the system given only a textual description of object structures, through class comments and method source it is difficult to develop a good picture or mental model. For me, I read the blue book first, which is replete with pictures.
>>
>> I know that historically visual inspector frameworks such as Jun have been able to auto-generate pictorial representations of specific object graphs. I wonder how useful it would be to provide support for designers to include pictorial representations in class comments.
>>
>> Again I presume that the text model would have to support inclusion of simple bitmaps (to avoid having to include a full drawing framework in the system) and that the designer would construct a sample graph, generate a diagram using a visual inspector framework using eg Jun, render it to a bitmap and include it in the class comment.
>
>
>
>>
>> A more elaborate system could of course include the sample graph and render it dynamically, that would allow exploration.
>>
>> Either approach would make an interesting project, yes?
>
> I would prefer something conceptually simpler and worthwhile: the ability to embed a morph as a character in the text (would do the two approaches easily). And a bit of marshalling/text representation to make a completely textual representation possible.
Yes that's a *much* better idea and one we could realize v quickly.
>
> I used to have that for hypermedia (i.e. a drawing editor with text frame objects, and text frames able to display GUI components... in ParcPlace Smalltalk)
>
> Now I dream a bit of having something like TiddlyWiki in Pharo ;)
>
> Thierry
>
Jan. 16, 2015
Re: [Pharo-dev] Understanding Object Structures
by Thierry Goubier
2015-01-16 16:55 GMT+01:00 Eliot Miranda <eliot.miranda(a)gmail.com>:
> Hi All,
>
> On Jan 16, 2015, at 7:36 AM, Eliot Miranda <eliot.miranda(a)gmail.com>
> wrote:
>
> > Hi Marcel,
> >
> > On Jan 16, 2015, at 5:54 AM, Marcel Taeumel <
> marcel.taeumel(a)student.hpi.uni-potsdam.de> wrote:
> >
> >> Ah, okay. I was curious about the performance of iterating over an
> array vs.
> >> the linked list:
> >>
> >> a := Array new: 1000.
> >> l := LinkedList new.
> >>
> >> 1000 timesRepeat: [l add: (StackLink with: nil)].
> >>
> >> [a do: [:ea | 1 + 2]] bench. "'94,600 per second.'"
> >>
> >> [l do: [:ea | 1 + 2]] bench. "'159,000 per second.'"
> >>
> >> I expected the opposite! :-O Why is that so?
> >
> > Look at the implementations of do:.
> >
> > In the Array case we iterate over the indices using SmallIntegers (fast
> arithmetic with no allocation) and dereference each element using the
> Object>>at: primitive, which (apart from type and bounds checking) is
> simple indexed memory access. So one read per element.
> >
> > In the LinkedList case each list element is fetched from the previous
> element and each value fetched from the element, so two reads per element.
>
> This is interesting. (Marcel, Chris, forgive me; I'm presuming; please
> don't take this personally). Marcel above appears to lack an intuition
> about the structure of Array vs LinkedList. And in developing a hash
> algorithm for a 32-bit subset of Floats a few weeks ago Chris appeared to
> lack an I tuition about Floats being boxed, assuming they were value types,
> not containers.
>
> As a VM implementer I carry around a clear picture (literally, I am a
> visual thinker) of objects in my head. Those pictures are key to my
> approach to design and optimization.
>
> I presume that for someone approaching the system given only a textual
> description of object structures, through class comments and method source
> it is difficult to develop a good picture or mental model. For me, I read
> the blue book first, which is replete with pictures.
>
> I know that historically visual inspector frameworks such as Jun have been
> able to auto-generate pictorial representations of specific object graphs.
> I wonder how useful it would be to provide support for designers to include
> pictorial representations in class comments.
>
> Again I presume that the text model would have to support inclusion of
> simple bitmaps (to avoid having to include a full drawing framework in the
> system) and that the designer would construct a sample graph, generate a
> diagram using a visual inspector framework using eg Jun, render it to a
> bitmap and include it in the class comment.
>
>
> A more elaborate system could of course include the sample graph and
> render it dynamically, that would allow exploration.
>
> Either approach would make an interesting project, yes?
>
I would prefer something conceptually simpler and worthwhile: the ability
to embed a morph as a character in the text (would do the two approaches
easily). And a bit of marshalling/text representation to make a completely
textual representation possible.
I used to have that for hypermedia (i.e. a drawing editor with text frame
objects, and text frames able to display GUI components... in ParcPlace
Smalltalk)
Now I dream a bit of having something like TiddlyWiki in Pharo ;)
Thierry
Jan. 16, 2015
Understanding Object Structures
by Eliot Miranda
Hi All,
On Jan 16, 2015, at 7:36 AM, Eliot Miranda <eliot.miranda(a)gmail.com> wrote:
> Hi Marcel,
>
> On Jan 16, 2015, at 5:54 AM, Marcel Taeumel <marcel.taeumel(a)student.hpi.uni-potsdam.de> wrote:
>
>> Ah, okay. I was curious about the performance of iterating over an array vs.
>> the linked list:
>>
>> a := Array new: 1000.
>> l := LinkedList new.
>>
>> 1000 timesRepeat: [l add: (StackLink with: nil)].
>>
>> [a do: [:ea | 1 + 2]] bench. "'94,600 per second.'"
>>
>> [l do: [:ea | 1 + 2]] bench. "'159,000 per second.'"
>>
>> I expected the opposite! :-O Why is that so?
>
> Look at the implementations of do:.
>
> In the Array case we iterate over the indices using SmallIntegers (fast arithmetic with no allocation) and dereference each element using the Object>>at: primitive, which (apart from type and bounds checking) is simple indexed memory access. So one read per element.
>
> In the LinkedList case each list element is fetched from the previous element and each value fetched from the element, so two reads per element.
This is interesting. (Marcel, Chris, forgive me; I'm presuming; please don't take this personally). Marcel above appears to lack an intuition about the structure of Array vs LinkedList. And in developing a hash algorithm for a 32-bit subset of Floats a few weeks ago Chris appeared to lack an I tuition about Floats being boxed, assuming they were value types, not containers.
As a VM implementer I carry around a clear picture (literally, I am a visual thinker) of objects in my head. Those pictures are key to my approach to design and optimization.
I presume that for someone approaching the system given only a textual description of object structures, through class comments and method source it is difficult to develop a good picture or mental model. For me, I read the blue book first, which is replete with pictures.
I know that historically visual inspector frameworks such as Jun have been able to auto-generate pictorial representations of specific object graphs. I wonder how useful it would be to provide support for designers to include pictorial representations in class comments.
Again I presume that the text model would have to support inclusion of simple bitmaps (to avoid having to include a full drawing framework in the system) and that the designer would construct a sample graph, generate a diagram using a visual inspector framework using eg Jun, render it to a bitmap and include it in the class comment.
A more elaborate system could of course include the sample graph and render it dynamically, that would allow exploration.
Either approach would make an interesting project, yes?
>> Best,
>> Marcel
>>
>>
>>
>> --
>> View this message in context: http://forum.world.st/The-Trunk-Collections-mt-593-mcz-tp4799750p4799893.ht…
>> Sent from the Squeak - Dev mailing list archive at Nabble.com.
>>
Jan. 16, 2015
Re: [Pharo-dev] review request
by Ben Coman
I know everyone is busy and working in their own domains not having the
time to review a lot of other people's issues. However I am on my own, not
part of a team where I can walk over and tap someone on the shoulder to ask
for review of an issue I've resolved. It is a bit discouraging not to be
able to proceed for lack of review. I'd be glad for any feedback including
"its crap, do it a different way". So consider this a virtual should tap.
I have...
* refactored the two calls to #forMilliseconds: out to a single call
* replaced call to #wait with #waitOr:
* added #waitOr:
Here is the diff...
WorldState >> interCyclePause: milliSecs
| currentTime wait |
self serverMode
ifFalse: [
(lastCycleTime notNil and: [CanSurrenderToOS ~~ false]) ifTrue: [
currentTime := Time millisecondClockValue.
wait := lastCycleTime + milliSecs - currentTime.
+ "wait is the time remaining until milliSecs has passed
+ since lastCycle. If wait is zero or less, no need to Delay"
+ "If wait is greater than milliSeconds then bypass Delay,
+ by setting wait to zero."
- (wait > 0 and: [ wait <= milliSecs ] ) ifTrue: [
- (Delay forMilliseconds: wait) wait ] ] ]
+ wait > milliSecs ifTrue: [ wait := 0 ] ] ] "btw, wait>milliSecs can only
occur when clock rolls over. Eliminate after integrating issue 14353 ?"
- ifTrue: [ (Delay forMilliseconds: 50) wait ].
+ ifTrue: [ wait := 50 ].
+ wait > 0 ifTrue: [
+ (Delay forMilliseconds: wait) waitOr: [
+ self inform: 'WorldState>>interCyclePause failed.' ]
].
lastCycleTime := Time millisecondClockValue.
CanSurrenderToOS := true.
"--------------------------"
+Delay >> waitOr: anErrorBlock
+ self schedule.
+ [ beingWaitedOn
+ ifTrue: [ delaySemaphore wait ]
+ ifFalse:[ anErrorBlock value ]
+ ] ifCurtailed:[self unschedule].
+"Only the high priority timer event loop (TEL) signals /delaySempahore/.
If the
+ TEL is not running, a delay will block forever (for example the UI will
lock up).
+ /beingWaitedOn/ is only set to true from the TEL (via
+ DelayScheduler>>scheduleDelay: and Delay>>timingPriorityWaitedOn:) so
test
+ this to determine if TEL is running. Avoid waiting when the TEL is not
running."
"--------------------------"
This is for issue 14669 "Delay refactoring (part 2a) - avoid UI locking up
when timer event loop is stopped" that is required to facilitate
integration of issue 14353 "Delay refactoring (part 2) - change from
milliseconds to microseconds.
cheers -ben
https://pharo.fogbugz.com/default.asp?14669
https://pharo.fogbugz.com/default.asp?14353
Jan. 16, 2015