Last updated on 15 January 1992.

If you have corrections, clarifications, additions, comments or
updates, please send them to one or more of the addresses at the end
of this note.

This is the second of two regularly posted articles to comp.lang.forth.
Both of these messages are posted on or about the 1st and the 15th of
each month.  The other article's subject is:

        Forth On-line Resource/Technical Help Letter

It describes what ForthNet is and how to access it.  It may be helpful
to read it before reading this message.

List of questions answered, in order of appearance, (*) denotes new or
modified entries:

    How can I contact FIG (Forth Interest Group)?
    What other organizations and publications write about,
            sponsor or promote Forth?
    What other Internet/UseNet Forth mailing lists are there?
    Where can I find the latest BASIS for ANSI Forth?
    Where can I find a Forth for the 8051/8031?
    Where can I find a Forth for the SUN?
    Where can I find a Forth for the MAC?
    Where can I find a Forth for a DSP?
    Where can I find a Forth for a Transputer?
    Where can I find a Forth for a Tandy TRS-80?
    Where can I find a Forth written in C?
    How can I find an anonymous FTP or email server that
        has "foo"?  (Or, just what is "archie" anyway?)
(*) Where can I find programs for Unix that can understand
        .ARC, .ZOO and .ZIP files?
    What if I want to find a PD/ShareWare Forth for the BrouHaHa-7245?

QUESTION:       How can I contact FIG (Forth Interest Group)?

ANSWER:         Forth Interest Group
                P.O Box 8231
                San Jose, CA  95155
                (408) 277-0668
                (408) 286-8988 FAX
                [Information supplied by Dennis Ruffer]

QUESTION:       What other organizations and publications write about,
                sponsor or promote Forth?

ANSWER:         The Computer Journal
                P. O. Box 12
                S. Plainfield, NJ  07080-0012
                - U. S. A. -  
                Phone: (US access) 908-755-6186
                ISSN # ????

                Association for Computing Machinery
                Special Interest Group on Forth (SIGForth)
                11 West 42nd St.
                New York, NY 10036 USA
                (212)869-7440
                ISSN # ????
                [ACM info supplied by Alan T. Furman]

                The Journal of Forth Application and Research [JFAR]
                The Institute for Applied Forth Research, Inc.
                70 Elmwood Avenue
                Rochester, NY  14611 USA
                ISSN #0738-2022
                [JFAR info is from 1989, please correct me if it has
                 changed.  -dwp]

                Dr. Dobb's Journal has the occasional article or two.
                PO Box 56188
                Boulder, CO  80322-6188  USA
                800-456-1215 (USA and Canada)
                303-447-9330 (All other countries)
                ISSN # 1044-789X

                Embedded Systems Programming has the occasional article.
                Embedded Systems Programming
                Miller Freeman Publications
                600 Harrison St.
                San Francisco, CA 94107
                (415) 905-2200

                [E.S.P. info courtesy of Jack Woehr and Paul Zander]

                Mountain View Press
                Box 429 Route 2
                La Honda, CA 94020  USA
                voice/fax/modem (via menu)  (415) 747-0760
                [ MVP info curtesy of Phil Koopman]

QUESTION:       What other Internet/UseNet Forth mailing lists are there?

ANSWER:

QUESTION:       Where can I find the latest BASIS for ANSI Forth?

ANSWER:         As of this writing the latest version of BASIS is 17.
                You can get it from FIG's library on GEnie.
                You can order a printed copy from FIG (see above for
                  how to contact FIG).
                You can FTP a copy from cpsc.ucalgary.ca, anonymous FTP,
                    directory /pub/forth, file basis17.arc.
                You can get a copy emailed from FNEAS:

                    To do so you *MUST* include in the BODY of your message:
                        your email address relative to the Internet
                    AND the name of the file you want
                        (in this case BASIS17.ARC)

QUESTION:       Where can I find a Forth for the 8051/8031?

ANSWER:

                                    'uunet!willett!fneas'.
To do so you *MUST* include in the BODY of your message:
     your email address relative to the Internet
AND  the name of the file you want (in this case EFORTH51.ZIP).

QUESTION:       Where can I find a Forth for the SUN?

ANSWER:

TILE is also posted to alt.sources and should be available through any
of the alt.sources archives.

                                        'uunet!willett!fneas'.
To do so you *MUST* include in the BODY of your message:
     your email
...

read more »

writes:
|> Uwe Kloss asks about performance comparisons with various implementation
|> techniques.  According to Guy Kelly's research (published in FD Jan/Feb)
|> there's relatively small (but some!) difference on a PC.  But on "strange"
|> chips such as the Forth processors as well as RISCs, the difference can be
|> very large, as much as x10.

I have done some empirical measurements in order to exorcise another
RISC myth. For the hasty ones, here are the numbers:

                           R3000                   68040
                        Time    Factor          Time    Factor
subroutine threading    19.8s   1.12            38.3s   1.72
direct threading        17.7s   1.00            22.3s   1.00
indirect threading      25.8s   1.46            30.1s   1.35
switch threading        46.5s   2.63            63.5s   2.84

And here are the explanations:

The RISC machine is the DECStation 5000/125 under Ultrix 4.2, which
uses a 25MHz R3000. The CISC is a HP/Apollo 425 under Domain/OS 10.3
(25Mhz 68040). Sorry, I don't have a PC available.

The benchmark consists of a loop that contains nine NEXTs and a
looping instruction (a termination test and a jump back for subroutine
threaded code), i.e. it primarily measures NEXT speed. This loop
is executed 10,000,000 times (resulting in 100,000,000 NEXTs and a bit
of overhead). Note that this measurements are an upper bound for the
performance difference of different threading techniques. I did not
try to measure native code, since it does not make sense using this
benchmark.

The benchmarks were written in GNU C 2.x. GNU C 2.x extends C in
various ways, among them "labels as values" (computed gotos), which
allow the implementation of direct and indirect threading. The
benchmarks were compiled with GNU C 2.2.2 (gcc -O2 -fomit-frame-pointer).

I checked the produced assembly code and was pleasantly surprised, as
I did not find any significant opportunities to improve the compiler's
output. However, I had to unoptimize the assembly code for subroutine
threading on the 68040, since the compiler allocated the address of
the fuction "next" to a register (which is quite unrealistic for real
ubroutine-threaded code).

CONCLUSION:
The differences between the different techniques on a RISC are not
greater than the differences on a CISC.

Appendix
Here I give the GNU C code for the various programs, if you want to
experiment. I can post the assembly language code if somebody is
interested.

/***** subroutine.c *****/
main()
{
 start:
  next(); next(); next(); next(); next();
  next(); next(); next(); next();
  loop(); goto start;

next(){}

loop()
{
  static int count=10000000;

  if (count<=0)
    exit(0);
  count--;

/***** direct.c *****/
/* &&label gives you the address of label (as void *) */
/* "goto *&&label" is equivalent to "goto label" */
#define NEXT goto **ip++
main()
{
  static void  *prog[] = {&&next,&&next,&&next,&&next,&&next,
                          &&next,&&next,&&next,&&next,&&loop};
  void **ip=prog;
  int    count = 10000000;

 next:
  NEXT;
 loop:
  if (count>0) {
    count--;
    ip=prog;
    NEXT;
  }

/***** indirect.c *****/
#define NEXT goto ***ip++
main()
{
  static void *nextp=&&next;
  static void *loopp=&&loop;
  static void  **prog[] = {&nextp,&nextp,&nextp,&nextp,&nextp,
                           &nextp,&nextp,&nextp,&nextp,&loopp};
  void ***ip=prog;
  int    count = 10000000;

 next:
  NEXT;
 loop:
  if (count>0) {
    count--;
    ip=prog;
    NEXT;
  }

/***** switch.c *****/
#define NEXT break
#define I_NEXT 0
#define I_LOOP 1

main()
{
  static int prog[] = {I_NEXT,I_NEXT,I_NEXT,I_NEXT,I_NEXT,
                       I_NEXT,I_NEXT,I_NEXT,I_NEXT,I_LOOP};
  int *ip=prog;
  int  count = 10000000;

  for (;;) {
    switch (*ip++) {
    case I_NEXT:
      NEXT;
    case I_LOOP:
      if (count>0) {
        count--;
        ip=prog;
        NEXT;
      }
      else
        return;
/* the rest is to get gcc to make a realistic switch statement */
    case 21:
    case 19:
      count=25;
      NEXT;
    case 20:
      count--;
      NEXT;
    }
  }

--
M. Anton Ertl                    Some things have to be seen to be believed

Some new results on the threading speed of various processors:

                                        gcc     sub-
Machine                 Processor       version routine direct  indir.  switch
DECStation 5000/125     R3000 25MHz     2.2.2   19.8s   17.7s   25.8s   46.5s
HP/Apollo 425           68040 25MHz     2.2.2   38.3s   22.3s   30.1s   63.5s
HP/Apollo 720           HP-PA 50MHz     2.2.2   16.27s  N/A     N/A     27.45s
SPARCStation 1          Cypress 20MHz   2.2.2   31.2s   33.2s   47.9s   73.6s

Thanks to Bernd Paysan for the values on the SPARCStation and the HP 700.
Bernd does not know whether the SPARCStation is a 1 or 2; I guess from
its slowness that it's a SPARCStation 1.

Feel free to send me the results on your machine. You find the

All times are user time. The assembly code generated by the compiler
was inspected and found realistic, with one exception: I had to
unoptimize the assembly code for subroutine threading on the 68040,
since the compiler allocated the address of the fuction "next" to a
register.

The benchmark consists of a loop that contains nine NEXTs and a
looping instruction (a termination test and a jump back for subroutine
threaded code), i.e. it primarily measures NEXT speed. This loop
is executed 10,000,000 times (resulting in 100,000,000 NEXTs and a bit
of overhead).

Andi Krall points out a shortcoming of the benchmarks: The pure NEXT
contains delay slots (depending on machine and threading method), that
will be filled in realistic applications. Since the number of delay
slots may be different for the different threading techniques, the
overhead of threading in realistic applications may be somewhat
different from what you might infer from these numbers. This has
little effect on the original purpose of the benchmarks (giving an
upper bound for the differences between threading techniques), but you
should be cautious when using these numbers for other purposes.

E.g., on the R3000 the next takes 4 cycles for subroutine and direct
threading, but subroutine threading has 2 delay slots, while direct
threading has only one. So, Forths '+', which needs 2 instructions
(when the TOS is held in a register) and NEXT, will need 4 cycles
subroutine threaded and 5 cycles direct threaded.

- anton
--
M. Anton Ertl                    Some things have to be seen to be believed