Subject: Re: Simplest (practical) file system

From: Al Kossow <[email-masked]>
Date: Wed Jul 30 22:31:55 2003

The biggest problem that I see here is that Bob wants to be able to use
this OS on systems that have as little as 16k words but still use LARGE
modern drives.

--

I have been thinking about this a LOT lately relating to using older
CPUs with few or none of the original peripherals, and it may make
sense, since you're building an IDE interface anyway, to build a 
file level interface onto the card, rather than talking to the drive
as an unstructured block device. The idea I've been toying with is
building an interface card like this with a local processor, disc,
ethernet, etc. and using it in conjuction with a remote system that
would provide the console / debugging UI / shared peripherals for
a bunch of different processors that I have.

This would also reduce the in-core footprint of the OS, since
the file system (and networking in my case) is handled on the
interface card.

---

From: Bob Shannon <[email-masked]>
Date: Wed Jul 30 22:42:00 2003

>this OS on systems that have as little as 16k words but still use LARGE
Well, thats not quite right.

I have long understood that real disk file system functionality will 
require 32K words at a minimum.
For the HP 1000's, the 21MX processors offer some microcode tricks in 
the DMS instructions that
greatly simplify building a DOS, but using these eliminates large 2116's 
and 2100A/S's from running
the code.

The core O/S as it stands now already provides very usable and realistic 
support for smaller and slower
CPU's.  Whats missing now is the DOS functionality for 'larger' machines.

We may end up limiting DOS functionality to 21MX machines with DMS, but 
will make an effort not to.

This is exactly the genisis of what we call HP-IPL/OS.

At one time, when I still had my NOVA's, there was going to be a 
parallel effort on DG-IPL/OS.
Similar vairents could be generated for any vintage machine, like 
IMLAC-IPL/OS, etc. in exactly the
same way that FORTH is bootstrapped onto a new CPU.

In fact, much of the IPL language is written in IPL, not unlike a LISP 
machine O/S being written in LISP.

Being a modular threaded interpreter, you can take a single binary 
kernel that runs on anything from a 4K 2114
up to a 21MX processor, and load just whats needed for your configuration.  

Because you first bootstrap the HP processor from a host, IPL/OS can run 
as a parasite machine hung from a
serial port with no vintage peripherals (other than serial interfaces). 
 As you bring peripherals on-line, or build
emulations, you download new code blocks until you have a totally 
self-sufficient operating system with a DOS
and source-code editor, etc.

Its just a series of layers wrapped around the same common threaded 
engine at the core.  I think the inner interpreter
is only 23 words or so.

>the file system (and networking in my case) is handled on the
An excellent approach for machines without native peripherals.

In the case of the HP 1000's there is an I/O card that is ideal for 
this, its a 4 Mhz Z80 with 16 mb of DRAM, and 16K
of EPROM.  It has a fast DMA interface to the HP backplane, and several 
advanced Z80 SIO-type chips to talk
to an external system.

The problem is developing the Z80 code to talk to something outside the 
box.  but should you come across the documentation
for HP's programmable serial interface board, I've got the hardware.