FORTH DAY 2009


PLEASE CLICK ON AN IMAGE TO ENARGE

So we start around 9:00am

Kevin Appert Starts off the Meeting


George Perry - Long Standing Member of FIG


Masa Kasahara was selling FIG T-Shirts. I bought one. They were a hit. And I thought these were impossible to get.


C.H. Ting Presents his eForth in C


Ting has recently undergone bypass surgery, and now we are glad that he is doing better. This is why it took so long to make progress for eForth in C

SOME BACKGROUND
  • A simple Forth system which can be compiled by a standard C compiler
  • Portable to various microprocessors
  • C compiler was specifically designed so that it is impossible to write FORTH systems ( or so it seems )
  • One cannot write into code space to add new code at runtime
  • One cannot execute code added into data space

DESIGN PROBLEMS
  • How many FORTH words?
  • How to interact with operating system?
  • How to interact with users?
  • 16-bits? 32-bits?
  • Direct or indirect threading?
  • token or subroutine threading

It takes maybe 10 years of daily C usage to know a C compiler well enough to get around it's protections and idiosyncrasies

EXISTING FORTH IN C IMPLEMENTATIONS
  • TOO COMPLICATED!!
  • TOO MANY WORDS
  • CONFORMING TO UNIX SYSTEM
  • IMPOSSIBLE TO UNDERSTAND

FORTH dictionary is a data structure, although many fields are of variable length. A FORTH dictionary can be constructed outside of a C compiler and then imported as a data array. A Virtual FORTH Machine can be implemented trivially, which then "interprets" the data in a FORTH dictionary. A Virtual FORTH Machine can interpret byte code.

Ting notes that a virtual machine is trivial yet the compiler is not because of how C protects the dataspace.

VIRTUAL FORTH ENGINE
  • An execution table or a switch structure can be used to execute byte code
  • An elementary implementation uses 32 byte code
  • An optimized implementation uses 64 byte code.
  • Room to expand to 256 byte code.

VIRTUAL FORTH MACHINE
  • Use eP32 chip design as model
  • A 32-bit word contains 1-4 byte code, executed consecutively
  • Data stack and return stack are 32 levels deep
  • data stack and return stack are connected to TOP register

Ting Explains his inner execution engine, which I won't repeat here.

to support the engine, a data structure is needed.

FORTH Dictionary
  • Linked list of FORTH words
  • Each words has:
    • - Link field
    • - Name field
    • - Code field
    • - Parameter field

this particular FORTH Dictionary
  • 218 words are implemented, according to original eForth Model
  • It is constructed outside the C compiler by an eForth metacompiler, adopted from eP32 project
  • it is saved and imported to compiler to fill a data array in 32-bit words

eForth C Implementation
  • It is compiled by gcc in cygwin

Conclusions
  • it is by far the simplest FORTH in C
  • it leaves lots of room for enhancements
  • I need experience C programmers to help compiling the FORTH dictionary locally so that we do not have to construct it externally.

What Ting needs is experienced C programmers to see how to generate this datastructure natively.
Questions:
This system is about 10 times slower than native Forth
Apparently C likes to keep data and code separate, Forth does put them together.
In C, people say that users and programmers can't be trusted.
Ting Shows the Forth system he made in C and eForth metacompiler he types in WORDS and the screen shows all of the words



David Kilbridge Presents PACE figFORTH Implementation


Adapting the figFORTH Glossary to a word-addressing computer

He was one of the first FIG Forth implementers.

Nine reference implementations
* All written to a common API specification, figFORTH

DESIGN ISSUES
* How are data to be represented in memory?

Data representation: obvious choices
  • One stack cell per 16-bit word
    • Stack pointers are native addresses
    • Change by 1 to push or pop
  • One dictionary field per 16 bit world

How to store text data?
- One character per word
- Two characters packed into 1 word

One character per word
  • Probably the best choice today
  • Storage is cheap
  • Allows i18n via UTF-16 encoding
  • Each character gets a native address
  • Possible issues with data exchange
    • may have to unpack characters on input, pack on output

Two characters per word
  • My choice at the time
  • Most efficient use of expensive storage
  • Unicode, ISO-8859 didn't exist
  • Allowed (FIND) to compare 2 bytes at at time

Implications of packed characters
  • need a way to address each byte of a word
  • Forced to add abstract addresses for bytes
  • How does byte addressing work?

BYTE addr -- baddr (= addr*2)
CELL baddr --- addr (= baddr /2)

Words that uses byte addresses:
C@ C! CMOVE COUNT ENCLOSE EXPECT HLD@

Word Addresses Used For:
SP RP IP W UP @ !
DP and all dictionary fields
TIB, PAD and disk buffers
Most words in the figFORTH glossary

Objections to byte addressing
  • Creates a 32K-word barrier in memory
    • a problem we wished we had!
    • No worse off than with a byte-addressed machine with 64K bytes of memory
  • Schizophrenic API
    • have to distinct pointer types without strong-typing support from the language
    • Forces programmer to remember which type of address to use where

PACE architecture
* Unit of addressing = 16-bit inline addresses or extension words
- No inline addresses or extension words
- All EAs are short offsets from a base...

He talks about the instruction format and registers of the PACE chip
AC0 - working accumulator AC1 - IP AC2 - W AC3 - SP
[Program Counter] [Ten-Word LIFO Stack] Scratch [LINK] [CRY] [OVF]

Use the internal stack as a parameter or a return stack?
  • Only 10 words deep
  • Only top word is accessible
  • not easily extended into memory
    • would need to enable and service stack full/empty interrupts

So, we can just use it for register saving, JSRs and interrupts.



Eric Smith Talks about figFORTH


He talks about the M16 processor which is alot like the PACE but which is not compatible.
He wrote a simulator and assembler in C for the M16.
This can cause 2 or 3 places for problems to exist.
He typed the Forth in by hand.
Most errors were in the simulator.
There were typos from typing in Fig Forth.

1 2 + . was not working

U/ had a bug in it, in PACE Fig Forth
That was probably fixed a little later.

Eric got everything to work great.

Eric wrote another assembler and simulator for the M16, the first one was for PACE.

The biggest difference between the two processors are flags and shift and rotate instructions.

His later system limps along and he will get it to go first. He wants to bring the M16 down to show us sometime.

What is the easiest way to get the code into the M16 he asks?

Maybe Eric will load it into the ROM card, then move it out to disk.

This machine uses 8 inch floppies.

The hardware was build by someone locally who built a computer from scratch, John List(sp?)

All bit banging is used, there are no serial ports.

These two chips were mostly used for imbedded control, not for personal computers.



John E. Harbold - Forth Foundation Library Overview


This is a really neat and full Object-Oriented system, which while being ample, maintains the character of Forth.

This is a an Extensive Class Library.

It is supported on Several Forth Engines.
  • Object-Oriented
  • FFL is a Class Library
  • Objects have Data and Methods
  • Objects can be static and dynamic
  • New objects can be created from other objects using inheritance

Extensive Class Library
  • tst - Module Testing
  • xis - XML/HTML Reader
  • zif - gzip File Reader
  • trm - Terminal Escape Sequence Outputter
  • xis - XML/HTML Reader
  • str - Dynamic Text Strings
  • snl - Generic Single Linked List
  • tmr - Timer Module
  • tis - Text Input Stream
  • stt - Stringable Module
  • stc - ANS Structure Module
  • str - Dynamic Text String
  • snl - generic Single Linked List
  • snn - Generic Single Linked List Node
  • spf - Sprintf String Formatter
  • sni - Generic Single Linged List Iterator
  • scl - Single Linked Call List
  • sci - Single Linked Cell List Iterator
  • scn - Single Linked Cell Node
  • sh2 - SHA-256 Module
  • nnn - Generic n-Tree Node
  • ncn - n-Tree Cell Node
  • nfe - Non-deterministic Finite Automata Expression
  • nfs - Non-deterministic Finite automatic State
  • msc - Message Catalog
  • nct - Hash Cell Table
  • hnn - Generic Hash Table Node
  • fsm - Finite State Machine
  • est - String with Escaped Characters
  • frc - Fraction Module
  • bis - Bit Input Stream Module
  • cbf - Circular Buffer Module
  • arg - Arguments Parser
  • bcn - Binary Cell Tree Node
  • bci - Binary Cell Tree Iterator

and MOAR

He showed a Text Input Stream Example.
You can read lines, and characters as much as you like.
John prepared this presentation in spite of a heavy work load of his own.
One uses the regular ANSI INCLUDE word to link to this.
Each type has it's own include file. ( neat )
This system retains Forth RPN notation, instead of being tempted into going ahead in the input stream. ( yeah! )

FORTH FOUNDATION LIBRARY

This system supports many Forth engines.



BREAK


Dave Jaffe

Dave Jaffe gave info about informing FIG as to who you are and what your relation to Forth is. Then there can be website pages in the FIG website about you. You may give information about yourself on a paper form as well as a photo, to Dave. Then you can be associated with Forth in the FIG website. Dave is the FIG Webmaster.


Bob Nash talks about integrating hardware and software


This as to do with integrating hardware and software.

Bob says that some programmers want to assume that the hardware doesn't exist.

He has made working prototypes as well as. hardware to deliver to clients.

He has done this professionally and as a hobby.

He designs boards.

There are free tools and inexpensive products which may be of use here.

* Tool Stick - This is a development system which produces ( it's a small board with USB connector ) assembly code.

The tool stick 362 provides 25 IO ports and plugs into a motherboard which can be a custom motherboard.
This device can plug into a $1 incrementer encoder with a switch, or a $7 led screen.
This system is inexpensive and easy to develop for.

We were shown a Tool Stick which was plugged into a motherboard while the display and incremental encoder were attached.

Also the Tool Stick can be used interactively with Forth!

FEATURES
  • powered by USB
  • this is for the 8051 processor
  • 100 MIPS 8051
  • most instructions optimized for single cycle - a few instructions use alot of cycles
  • DACs and A/D converters - crossbar switch - very flexible
  • 280 bytes of internal RAM mapped as external RAM
  • 32K of memory
  • this thing is about $10
  • can drive LEDs directly
  • very flexible system
  • capture compare registers - 3 of them can trigger an event
  • internal or external clock
  • pretty lower power
  • wide variety of packaging

In using this thing he has not gone over 8K except for streaming out waveforms.

Silicon Laboratories also creates a blue board for $35

* you can put custom circuitry on it
* LCD plugs right in

Bob did a commercial project with it and has made a daughter board for it. He uses the company Express PCB for his daughter boards.
They are cheap and they do a good job. What you get is professional looking.
He has an Ethernet module driver software in his Forth. The top of the line processor board has 100mhz and 120K RAM.
He uses the company Front Panel Express to produce a nice looking panel which is better than a home brew looking one.
Three panels cost about $50. There is a 5 day turn around.
There is free software to download, and then you do the panel layout with it.
You can use this to make templates if you want to want to cut your own panels, or they can cut it for you for a low price. You can get any finish, natural or black, including anodizing in any color you want.
So, by using these companies you can create very inexpensive professional custom projects!
The controls for his project include a knob to scroll the options with, and then you hit the button. You can set times and delays and such. This project uses a blinking block curser for the menu.

Here are images of the hardware which Bob showed us



Brad Nelson presents Icon Forth


What ever for?
  • Test: is a picture worth a thousand words?
  • Icons allow everyone to share one large namespace
  • Disappointment with limited collaboration potential in web-based Rainbow Forth

Brad was disappointed in the shared environment of Rainbow Forth, you can save to shared sets of blocks, but it was hard to share somebody own block #5.

Technologies
  • Virtual Machine on top of Javascript for Forth execution
  • Canvas tag for icon editor and Forth program graphics
  • Chrome Frame for Internet Explorer support
  • Python under Google AppEngine for hosting and back-end

Maybe alot of people can use this, as it is scalable.

What kind of Icons?
  • don't spend hours on each icon
  • Make each icon unique and distinct
  • 16 x 16 pixels icons
  • 10 colors (7 colors + black, gray, white)

Icon Editor
  • Select one of 10 colors
  • click to draw
  • Bare minimum

What about text?
  • allow a description
  • provide keyword text search

Locating Icons
  • show 8 recently created icons
  • show other icons ranked by popularity
  • Allow keyword text search

Viewing an Icon
  • show definition
  • Show text description
  • Show who is using it

Rainbow Forth requires that you log in, with Icon Forth logging in is optional.
If you log in you can own a word, if you don't then you are not given credit for creating it.

There is a simple user guide available.

The website shows the editor, it shows the icon editor and also a search prompt.

You can search for a word, and then it show the word definition, which is defined in terms of images.

Brad presents a word called TEN.

How do you input numbers? With icons as well. You use an icon to push a number ten onto the stack.

You can give a comment to the icons that you make.

You make a word by drawing an icon, giving it a comment, picking some other icons which where defined before, and there you go.

This system was inspired by ColorForth a little bit.

This would be great for teaching children.

Ting jokes about 'trying to reinvent Chinese'

Some of the icons are combinations of other icons, sort of like Chinese characters.

Somebody suggests dictionarys of icons.

What conclusions did Brad have? This reinforced the value of language.

He was surprised at how difficult it is to find the right picture VS the right word.

Ting: How to implement a Forth in Chinese? Each Forth word can be assigned a Chinese character. Each forth word as a single Chinese character. The problem is that when there are too many images that it's hard to work with them.

One might apply object orientated programming to this.

This is an Icon Forth website.

ICON FORTH



Sandy Bumgarner


Sandy talks about stand alone Forth computers.

The ASUS Eee PC could be a stand alone Forth computer.

He went to work for Chuck in 1977, 32 years ago, during disco days. :^)

He shows a netbook, which is a small laptop.

He not a fan of PCs, he is a Mac guy.

When Sandy whet traveling he wanted a basic computer and wanted to save some space. The Macbook is too bulky.
He bought netbook at Best Buy with a 160GB drive.
His wife's large purse holds it nicely.
He uses it while traveling.
His wife likes to play cards online while on the go and this machine can do that.

Inadvertently Sandy found a very flexible computer.

There are guys who run Mac OS on this.

You can run Linux on it, or whatever. This sets his mind to working.

Why not run native Forth on this pup?

He has been spoiled by working with Chuck.

He went to work with Forth Inc. because of the possibilities.

In order to get Forth into the 1160, be blew it in through the busy bit.

Chuck had a sort of portable computer with a computer in one bag, and a memory drive in another bag. ( luggable? )

He worked at start up companies with Forth. Forward Technology used a native Forth for example.

Then he went to work for Apple. You once could boot up in Native Forth by holding down keystrokes, on the Power PC Macs.

He taught Forth at Berkley Extension, in maybe 84, 85, back when not everybody had a computer.

There is a Jupiter Ace emulator for the Mac.

He loads the Jupiter Ace emulator on the big screen in our conference room.
This machine was a small cheap z80 machine with a Forth Rom.

He creates a simple demo Forth word on the emulator for us.

On the Ace you could use the word EDIT to bring up and edit a word that has already been compiled.

Sandy's thesis is THIS . . .

There are lots of PC Forths around.

Consider the Cannon Cat system which he worked on for 7 years at Information Appliances.
The Cat was a complete forth machine running native. There where peripheral and graphics words and the whole bit.

He suggests porting the Cat software to the new hardware, the ASUS Eee PC.

Someone who is good at using a Cat can edit text faster than by using anything else.

We could have cheap $300 machine that would run Forth natively if we wanted to do the work.

We would need to do alot of work to deal with all of the hardware and things that have been invented after Information Appliances died.

The ASUS uses an Atom which is a 32bit class processor.

the only hard barrier with this system is the 3 flavors of USB, then there is the screen to deal with.
What are ways to deal with WiFi?

What do we do about a browser?

ECOS is a Forth with drivers and a browser so some of the tools are laying around for us.

This is like a Macbook air for $300, and its the right size!!!!

It's a good industrial design.
There are good ports.
The keyboard is 80% the size, but you won't notice. There is a nice track pad.
Hardware wise it has alot going for it.

The Cannon Cat is deader than a DoDo bird, as it should be.
Please note that there is a Google group for Canon Cats.

Sandy would also be willing to let a Canon Cat go, he has several of them.



A Moment of Remembrance and Celebration for Dave Boulton

Memorial Card

Dave was with the original FIG group.

The old FIGsters knew him from about 35 years ago.

Dave died a few weeks ago.

He was one of the intellectual lights of Forth.
He was a man who would not suffer any fools.

Dave was extremely bright and wonderful friend.

Dave had a stroke.
After this he spent the last 10 months of his life in a bed at Keiser hospital. He lost half of his mental capability.

[ now his cousin Bette is invited forward to speak ]

Dave was an incredible guy.
There was a memorial service a few weeks ago.
She passes out memorial booklets.

She has a PH.D. in computer science.
Dave was Mr. smart person.

She was looking after Dave, she is 10 years older, he was like a little brother to her.
During the last 3 years of his life, he had an appendanoma.

Just having alot of friends and acquaintances sign the memorial book would be important for the family.
He was cremated and is at Skylon, his mom is right across from him.

David was a very private person, but boisterous about what he was doing.
He was 52 years old, he had alot of health issues.
She says, look after your health first.

We lost Don Colburn and Mike Lamona. We have lost 4-5 of our early pioneers.
We were young when we implemented FIG Forth, 20 years old or about that.
There were about 4 or 5 people who created FIG.


Lunch in Gibbons Grove :)



Leon Wagner


We were given a note book handout called SwiftX for CFV1CORE_ALTERA. This pertains to putting this particular core onto a FPGA and then loading SwiftX into that.

This project was funded by NASA, so Leon has permission to show this work.

There is a whole family of cross compilers called SwiftX.

SwiftX will run on the Freescale Coldfile.

NASA wants to be able to use a FPGA, putting a CPU into that part in order to run Forth on a rad hard part and get the part count down.

Folks at NASA know and love the Coldfire.

IP Extreme came out with Coldfire Core.

A NASA guy contacted Leon about why the IP Extreme core was not working on the FPGA.

Leon showed us how to get a Forth running on the FPGA :) step by step.

The IP Extreme Core runs on the Altera Cyclone 3. You can get a starter kit for $199 bucks from DigiKey.

You can get an evaluation version of SwiftX for free.

This project will be packaged up with the SwiftX eval version.

Quartus II can be downloaded for free as well.

The Coldfire is descended from the 68K but is RISC. It's like a brain dead 68K. They take away all of the great addressing modes.

He is using Quartus II to do the project with as well as another program called SIPC Builder

Lets run the Quarus II program.
  • open new project wizard
  • name a new project - cfv1
  • we need to get the basic structure set up for the project
    • we need to add some files that we know we need
    • We get an encrypted Verilog file from IP Extreme to add to the project
    • tell it what part we are using
    • give it the speed grade and pin count

  • now using SIPC Builder - targeting Verilog
  • add all components in a panel which pops up
    • a core
    • a few clocks
    • timer
    • Parallel IO
    • Ram and Rom
  • adding the clocks and setting the speed
    • one clock for the CPU core, and one for an interface system
    • CPU 40 MHZ clock and interface 10 MHZ clock
  • created the Verilog file is what we just did

  • adding some emulated memory, some ROM - 8K worth
  • give it some RAM, 8K worth

  • Peripherals to add
    • Microcontroler
    • Interval Timer
    • 1 millisecond timer
    • simple periodic interrupt
    • PIO ( Parallel I/O )
    • 4 bit port
    • inputs and outputs
    • read to pins
    • write to latch

  • now on a screen for dealing with memory connections, internal wiring, memory maps
  • assigning clocks - gives the clocks easy to remember names
  • assign base addresses to the components
  • boot memory has to start at 0 so it is left at that

The final step is to run generate.
This will send out all necessary Verilog files for the project.

We get the message "system generation was successful"

BACK INTO QUARTUS
  • then we add in the files we just created with the SIPC Builder, into Quartus
  • run the analysis and elaboration step. Checks your connections and design to see if something is really wrong
  • we have to bring out the internal connections to outside pins
  • for this we will just connect up the PIO pins
  • Assignment Editor: To field : Node finder: look at all of the pins - pick the ones you want
  • then must give a value to each of the pins that were selected
  • now writing to the FPGA takes about 6 minutes

It was programmed with a blank memory image.
So then Leon drags over the object file for Forth and it copies to the FPGA.

We try connecting to the part.
We have a connection to the part
We establish a connection through the debug interface.
We get the message 'BDM connected on USB1'

So let us try some Forth

SEE GREET
( decompiles GREET on screen )

WORDS LED LED-CHASE /LEDS !LEDS
1 !LEDS
2 !LEDS
( turn the LEDS on )

Leon shows a bit of code
: !LEDS ( x -- ) INVERT PIO_BASE ! ;
: /LEDS ( -- ) 0 !LEDS ;

The size of the Forth image is
  • the code section is 6342 bytes for a complete Forth system as it exists on the part
  • 150 bytes of RAM were used to substantiate the Forth and to do the tiny app

Leon is basically a Software guy but after a few tries he can get this to work because the tools are so advanced and high level.

This was a proof of concept and more needs to be done at NASA before it can be used.
This will be a standard part used by NASA which will be in a RAD Hard FPGA.
NASA likes the Actel Radhard parts.



VENTURE FORTH TOYS - Dennis Ruffer


Dennis did some "toys" for Chucks hardware.
They can be found at vf-plugins

Three packages are available for download and a PolyForth database package is there.

He used latex and wrote a support routine. So he has produced latex documentation.

Each little dinky piece of the plugin architecture is structured like the FFL. You just INCLUDE the part that you need.

Dennis has a way to avoid mismatched plugins based on version. He keeps track of the version number in the pieces

He was working on wireless speakers which communicated with each other and knew where they were in the room.

He shows documentation for the Floor Plan. ( how the nodes are arranged in the application )

He started out with a 4x4 in a FPGA package.

He made it up to the 24 node chip, not to the 40 node chip.

This has been done in Venture Forth

Here are a few commands
< noname >
< name ... >
< rgb r g b >
< status ... >
< function ... >
< title ... >
< read ... >
< write ... >

There are words to generate a floor plan.

He shows us some Venture Forth and how to set up nodes and such.

He shows us a diagram of the floor plan, all 24 nodes with a color for each node.

He shows some code which adds functions to a project.

Dennis now shows us a Test Suite.

There is a test word which goes around to various nodes and gives us some information about what is going on with that node.

.?.
This word puts a 'fence post' at this location in the target image that will display the data stack when the simulator steps over that location.
CHECKSUM ( 1 .?. )
dumps the stack as soon as the checksum was done.

( ASSERT: T @ 0= ; )
| ASSERT: FINISHTESTS ; )

CR .( Running simulation testing ... ) CR 1 GOES DECIMAL CR SUMMARY CR
goes until the finished test has executed this many times

Next Plug In Is .... the TIMING SUITE

TPL is still trying to patent this.
Each one of these tools have to hook into the Venture Forth compiler.
Its user interface shows that the simulator is running.
This thing watches the simulator run.
This tool also hooks into the simulator.
He shows a diagram of how the cores interact with each other over time.

( more is shown which goes over my head )



HEARING AIDS WITH SEAforth - Michael Montvelishsky


There were alot of challenges involved, and this was alot of fun and very interesting for Michael.

He used SEAforth.

This language is able to create great applications, and this hearing aid application has proven it.

He shows a diagram of the human ear.

TYPES OF HEARING LOSS
  • Conductive
  • Sensory
  • Neural

The outer and middle ear are a physical connection to the inner ear.

The Cochlea is a converter for converting mechanical sound pressure to electrical signals.

Depending upon which part of the system is damaged, that determines which type of hearing loss one has.
  • outer ear - Conductive
  • cochlea damaged - Sensory
  • nerve - Neural

The Cochlea is a spiral like organ.

Cochlea Functions
  • Bandpass filtering - takes sound mechanical pressures
  • Detection - understanding how loud each vibration is - different nerves for each vibration
  • Compressing

We can not hear greater than the 60-90db range.

The signal goes to the brain in a compressed form.

When the cochlea malfunctions or is damaged, one of the functions does not operate well.
And when this happens, we need to compensate for this.
Aiding the impaired cochlea is what this application is about.

( He shows alot of diagrams which I don't understand. )

Implement Band filters
  • Bands 1
  • Bands 2-7, highpass
  • Bands 2-7, lowpass
  • Band 8

Compressor
There is an instant compression scheme which does not need to accumulate a portion of the sample.
It can calculate from a single point.
It does not use square root, instead it uses cordic.
It works pretty good, it's fast enough.
It uses an algorithmic method for the exponential function.
It uses divide instead of multiply which is sometimes better when using fixed point.

Analytic Signal Calculator
This changes face characteristic only.

Directional Microphone
This part does not compensate for damaged cochlea.
This helps people to focus on the sounds that they are interested in.
This helps alot and is a very important part of the device.

Subsample Delays
This subtracts one signal from another signal.
This method has been used to create directional microphones for a long time.

Everything is done on the multicore chip.

On a multicore chip there is something called a floorplan, which shows where each core is and how it operates in relation to the others.
He shows the floorplan - Mapping to SEAforth - s40

SEAforth is very power and cheap, it provides massive amount of MIPS.

The biggest problem with sever farms, data centers, is that they don't scale very well.
If the farms are running computational intensive tasks, they get very hot, and so must use cooling.
If the farms are idle, they don't go to sleep, they will still run hot, they will still using alot of juice.

Chuck has invented the Greenest Cheapest Microprocessor array in the world :)

The hearing aid uses a standard codec which has also been used in MP3 Players.

Chucks chip is 20 times more power efficent that a TI DSP, which a special chip meant for audio processing.
They consume 1 watt, we consume 55 mW.

MYTHS AND LEGENDS ABOUT THE S40
  • Amount of Local RAM is not enough for serious applications
  • Amount of I/O pins in not enough


JEFF FOX - New Hardware on New Software


Michael said that they solved alot of interesting technical problems.
Jeff wants to address human problems.
This whole thing started out in MatLab.
They were able to generate C code from MatLab.
But it was hard to get from an abstracted MatLab view to a real world picture of what was going on.
There are counter intuitive algorithms.
There are counter intuitive ways to correct hearing.

This last year Jeff has not been banging on bits and operating on technical stuff.
Has been given a chance to step back and look at it from a different view.
Forth does not have much language syntax.
In other languages you fit your problem into the syntax of the language.
But in Forth we can adjust the syntax to the problem.
By suppressing language we can accelerate some other area of the brain maybe by freeing up mind resources because we use so much of them for language.
One issue, texting while driving can get you killed.
This is also true in martial arts.

Forth is more than just syntax.
Forth is a methodology for solving problems.
Alot of language is left brain orientated.
But we are not entirely left brain orientated.
We have bigger boxes to work with.

Jeff shows the INCLUDE file for propagating code to nodes.

At iTV the point of that 'horror' story was that the code was made better, not that the code was crud to start with.

With the GA4, you can have your system distributed across several chips, a chip wherever you physically need it.
There is communication code on the new chips to accommodate this.
Read the port that the pins are on, go to sleep, wait until it changes, wake up and go.
This is like the intercore communication except that it is attached to an outside port.
Before communicating chip to chip as you would node to node could have left garbage to be read.
Chuck changed the hardware such that when the wakeup happens, it will read an instruction, instead of garbage.
This simplifies code.
There isn't separate code for processing program and data.

Jeff shows obsolete code as an example, this being boot code.
  • this code reads in program to go into a core
  • runs at 31 megawords / second
  • this is highly factored code, a little more than some are used to

He talks about sending packets to processors, either adjacent nodes or separate processors.

Jeff shows a routine which shifts 18 bits into a word.

BLUE WORDS ARE A NEW THING IN COLOR FORTH
We are presented with the Blue words this year.
Blue words execute when editing the screen.
Blue words format the screen.
Blue words execute Forth code from inside of the editor.
Blue words execute at edit time.
Chuck has done this and it is simple.

A LITTLE ABOUT STRUCTURES
Structures in Forth
Structures in the GUI
Structures in the network code
The network code was copied over from the C.
( I am assuming the GUI and network code refers to what was done at iTV )

We don't have structures or arrays in the core of Forth because there are many different ways to use them depending upon the context.

You can focus on the structures that are used most of the time.

By using the auto increment new Forth words, you can eliminate code from structure access code.

You can drop below the abstracted level of the structure code, to do something more efficiently.


Chuck said Forth can be 1% of the equivalent C code.
Alot of people want to just cut and paste bloated code.

What's wrong with C programs? Find out and then just don't do it in Forth Programs!

Chuck does not write a cross compiler by having several versions of DUP. Jeff's cross compiler was like 20K and Chucks was like 1K or something like that.

He shows an old board from Intellasys.

There has been alot of boards made, and they all have different purposes.

The old Intellasys boards do work with the new GA chips.

They want the GA chip to directly do USB.

There is a ColorForth editor which has blue words in it, which may be invisible These blue words can set up an IDE, with dumps and watch windows.



John Rible - SQUARE ROOT ROUTINE FOR THE C18 (S40 CPU)


At first John talks about his work with kids in the great outdoors.
He talks about a string walk.
The kids have to go along a string following it and paying attention. They are blindfolded following this string. Also they have to avoid a hole near the end.
The kids love it.
Why use the blindfold?
They tried it without the blindfold.
They found it to be much harder without the blindfold.
Without the blindfold, they were trying to use their eyes after dark and ignoring their other senses.
They did a better job when not using their eyes.
Same thing with language, using one thing excludes other things.

John starts up SwiftForth. Then he turns on Colorforth in Windows.

Typing in 200 LOAD in CF loads internal and external RAM on his s40 dev board.

He goes into eForth from SwiftForth.

eForth runs on two nodes, 11 and 12. ( that seems pretty impressive to me )

This is bit differentiated, depending on the state of the bit, it is high level Forth or a micro coded subroutine.

You can call the neighbor port and sleep until there is something to execute.

What did he do to implement square root?

In eForth there is a word called TRY

He shows his venture Forth code.

He is using ColorForth and eForth from SwiftForth.

He is showing a CF screen with the block number in the background stretching across the screen.

John is now showing the CF screen with the 32-bit square root and multiply.

He is showing a CF screen which defines the word TRY which sends a result to eForth on node 12, by sending something to it's port.

He is explaining alot of code that you will need to watch the video to grasp, which I have been totally lost by.

He interfaces between c18 CF Forth and eForth through node 12 and the shared port.

That is a way to test code on the c18.



Greg Talks About Green Arrays


There will be a posting on the Green Arrays site. Softsim tools will be posted in about a month.

A shuttle run is coming back in a few weeks.

So you should keep an eye on the GA website.

There will be stuff to download.

They are working on documentation in HTML format.

An email address will be set up for suggestions.

There will be a Haypress Creek board for GA144 chips ( that's 1296 cores! )

There will be a system with GA4 and GA144 chips for practice in programming strung out chips. That is to say, GA4 chips can be placed in various physical locations all linking to a central GA144 chip.


GREEN ARRAYS

FIRE SIDE CHAT WITH CHUCK!!!!! :^)


Chuck has COLOR FORTH running, with the green red and blue screen, and the yellow letters in the lower right corner.

Chuck does not have to mess around with Windows(tm). He does not have to scroll through menus and tap on the right spots to make things work.

But he admits that CF is not perfect.

It does not take long for CF to boot.

Chuck showed his clock code. On the second screen, there are 8 red large digits, and the digits are showing hours, minutes, seconds and 60th of seconds.

The screen was refreshing at 60 hertz.

The first display is able to refresh at 60 hertz, full capability of motion here.

The screen was showing Pacific Standard time.

Then there was a screen showing a reading of the A/D ground reference. The value jitters, this would display temperature if it was calibrated correctly.

Then Chuck shows another GA application. This was reading and writing SDRAM.

Chuck shows contents of SDRAM, it's a screen dump. This application uses a smaller character set.

There is one more display which he can show. This is a protodisplay of the CF character set. This is a part of CF which will eventually reside on Haypress Creek.

Next he needs to put CF in SDRAM and display a block.

Chuck says that maybe they are a year behind schedule.

All of these displays are displayed dynamically, there is no frame buffer.

The computer is working very hard to maintain this display, computation power is being swapped for memory as far as resources are concerned.

Chuck then shows us a block of code. This presents loading blocks into nodes, it uses yellow text which is interpretive I believe, and new to me.

He shows code for a 'wire node' which is a node doing nothing but passing code through it.

Chuck shows code to drive a crystal to generate a clock.

Chuck proceeds to describe his crystal clock code, which I don't understand. This is the simplest crystal driver he can imagine.

ColorForth now has Grey Words.
What do they do? They display a location in memory at that point in the block.
Grey words are another kind of tagged words.
When the compiler encounters the gray word, it stores the current value of the program counter so we can see it later.

Chuck shows code for displaying characters on the screen.

The forth word O, is octal comma.

Chuck notes that it's better to use a neighbor as memory than as a wire, more efficient.

In a GA application, there are alot of nodes working together to accomplish something.

Each nodes code can be easy to write, easy to debug, and can run very fast!
But it's not all that easy to do.

Each application has it's own character set.
The smaller characters fit in a node, the larger ones need another node to store them in.

The wheels are grinding slowly with TPL.
Whenever he publishes anything about TPL, he gets static from lawyers.
But then the lawyers later say that there may be some benefit to having published that.

They are going to get 144 core chips soon, and there will be another Haypress Creek with 144 core chips in it.

Chuck says that they can't sell chips until they get production quantities and that they can't get production quantities until they get money to buy them with.
This is the chicken and egg problem.

144 core chips are being packed into 1mm square packages

They are talking to automobile battery people. ( sounds like a great idea )

The GA4 chips are very small and very low power and very cheap.


This is Haypress Creek, an array of Forth multicore computers


My best estimate is that there was about 35 people in attendance.

Afterwards, we all ate at a Chinese restaurant for dinner!