The speed of MC

[Ray Horsley]

I thoroughly enjoyed reading through this.

Thanks, Wil


Ray Horsley
Developer, LinkIt! Software


> 
>> -----Original Message-----
>> From: metacard-admin at lists.runrev.com
>> [mailto:metacard-admin at lists.runrev.com] On Behalf Of Wil Dijkstra
>> Sent: Monday, March 31, 2003 10:16 AM
>> To: metacard at lists.runrev.com
>> Subject: The speed of MC
>> 
>> 
>> 
>> How to speed up MC
>> 
>> All those guys that migrated from good old HyperCard to MC,
>> were delighted by the speed enhancement. Nevertheless, in a
>> number of cases, MC is slow compared to languages like Pascal
>> or C. Scott Raney gives some good advice about how to speed
>> up your scripts. However, there are some of less known tricks
>> that can speed up your scripts amazingly. Suppose you want to
>> create a list consisting of a number of lines with something
>> put into each line. For the sake of simplicity, let us create
>> a list of 10000 random numbers between 1 and 1000. If your
>> script looks like this:
>> 
>> script A
>> 
>> repeat with i = 1 to 10000
>> put random (1000) into line i of randList
>> end repeat
>> 
>> and are eager to know how to write a script that executes
>> more then ten times as fast, you should read on! But first
>> some  questions. Do you think  that the same script, but now
>> generating random numbers between 1 and 1000000 (one million)
>> takes more time? If your answer is "yes", you're right. It
>> will take about twice as much time. Do you think that's
>> because generating a random number between 1 and 1000000
>> takes more time than generating a random number between 1 and
>> 1000? If your answer is "yes", you're wrong. It takes about
>> the same amount of time. To write scripts that executes as
>> fast as possible, you should know something about how a
>> computer (or MetaCard) works, how data are stored, etc. I'm
>> going to tell you that in a very, very simplified way. But
>> first, the fast script:
>> 
>> script B
>> 
>> repeat with i = 1 to 10000
>> put random (1000) & cr after randList
>> end repeat
>> delete last char of theList
>> 
>> Script B yields exactly the same result as script A, but is
>> more then ten times as fast. If we wanted to generate random
>> numbers between 1 and 1000000, it is even more then 20 times as fast.
>> 
>> Here is the reason why.
>> Data are stored in memory. Each piece of data has a
>> particular length. For example, in script A, the 75th call to
>> random (1000) may yield 234, which is three characters long.
>> This piece of data had to be put after the CR (carriage
>> return) at the end of line number 74. But where in memory is
>> that? The computer can only figure that out by counting the
>> number of CR's from the start of 'randList'. And that takes
>> time. And each call to random (1000) the computer (the poor
>> thing) starts counting the CR's again. Script B does not have
>> this drawback. The computer does not have to bother about
>> counting CR's, but can just put the result of random (1000)
>> after the last char of 'randList'. In script B a CR is placed
>> after this line, to warrant that each new result of random
>> (1000) appears on a new line. Finally, the last cr is
>> deleted, to ensure that the results of script A and B are
>> exactly the same. To count the number of CR's in script A,
>> the computer has to walk through all characters of 'randList'
>> and to decide whether or not the character is a CR. If we
>> generated random numbers between 1 and 1000000, the computer
>> has to walk through about twice (actually, less than twice,
>> because also the CR's are characters) as much characters than
>> in case of generating random numbers between 1 and 1000.
>> Hence generating random numbers between 1 and 1000000 with
>> script A takes about twice as much time than generating
>> random numbers between 1 and 1000 with script A. In script B
>> there is no difference of course. If you understand the
>> principle, you can easily imagine that the speed increase
>> will become negligible if the number of characters on a line
>> is very small, but very large if the mean number of
>> characters on each line as large.
>> 
>> Moreover, you will also understand why using array variables
>> is so fast. Array variables are indexed. If the variable AR
>> is an array variable, AR[345] directly points to the correct
>> position in memory. Hence, a statement like 'get AR [345]' is
>> very fast. On the other hand, the statement 'get line 345 of
>> randList' is much slower: again, the computer has to count
>> 344 CR's, walking through the data of 'randlist'.
>> 
>> Similarly, if you want to perfom some action on each number
>> in 'randList' using the script:
>> 
>> script C
>> 
>> repeat for each line randNumber in randList
>> put randNumber into temp
>> -- do something
>> end repeat
>> 
>> is much faster then
>> 
>> script D
>> 
>> repeat with i = 1 to the number of lines of randList
>> put line i of randList into temp
>> -- do something with temp
>> end repeat
>> 
>> Why? In script D the computer has to count CR's to get the
>> i's line. In script D, the computer 'remembers' where it is,
>> getting lines; it just proceeds through the lines and doesn't
>> count CR's. Moreover, of course, the statement 'put
>> randNumber into temp' is superfluous.
>> 
>> A strategy that can give good results, is:
>> (1) Put a list into an array, using the 'repeat for each'
>> approach. Note that you can also use items, or words.
>> (2) Perform actions on the content of the array.
>> (3) Put it back into the list, e.g. to display it in a field.
>> This approach is especially useful if you want to change the
>> contents of the list, because you cannot use 'repeat for
>> each' and at the same time change the contents (you should
>> now understand why).
>> 
>> There are more tricks, but maybe all this stuff is quite
>> familiar to you and offers nothing new. Please let me know if
>> you appreciate information like this. If not, that's fine. It
>> will save me time. If yes, I will tell you the next time how
>> to speed up calculations. And I will tell you about some
>> limits (for example, the largest number MC can handle). And,
>> for the happy few who can write C or Pascal, how to use
>> externals or how self-written programs in C or Pascal can be
>> approached using Apple events. (but don't expect me to
>> contribute daily!) My aim is not to give you just tricks, but
>> to give you some understanding of the mechanisms. If you
>> grasp the difference between the A and B scripts, and the C
>> and D scripts, and when it makes a difference and when not,
>> you can yourself carefully inspect your scripts and improve them.
>> 
>> Happy programming,
>> 
>> Wil Dijkstra
>> _______________________________________________
>> metacard mailing list
>> metacard at lists.runrev.com
>> http://lists.runrev.com/mailman/listinfo/metac> ard
>> 
> 
> _______________________________________________
> metacard mailing list
> metacard at lists.runrev.com
> http://lists.runrev.com/mailman/listinfo/metacard
>