i remember a fellow student debugging an lsi11 kernel using a form of analogue vectorscope.
i think it had a pair of DACs attached to the upper bits of the address bus. it generated a 2d pattern which you could recognise as particular code - interrupts are here, userspace is there, etc.
the brightness of the spot indicated the time spent, so you got a bit of profiling too - and deadlocks became obvious.
anyone remember these, what where they called? i think it was an HP or Tek product.
-Steve
Wanted to post my notes as plain text, but the bullets / sub-bullets get lost.
Here is a 2 page PDF with my notes on Research Datakit:
https://www.jslite.net/notes/rdk.pdf
The main takeaway is that connection build-up and tear-down is considerably more expensive than with TCP. The first cost is in the network, which builds up a dedicated path for each connection. Bandwidth is not allocated/reserved, but a path is and routing information is set up at each hop. The other cost is in the relatively verbose switch-host communication in this phase. This compares to the 3 packets exchanged at the hosts’ driver level to set up a TCP connection, with no permanent resources consumed in the network.
In compensation, the cost to use a connection is considerably lower: the routing is known and the host-host link protocol (“URP") can be light-weight, as the network guarantees in-order delivery without duplicates but packets may be corrupted or lost (i.e. as if the connection is a phone line with a modem). No need to deal with packet fragmentation, stream reassembly and congestion storms as in the TCP of the early 80’s.
Doing UDP traffic to a fixed remote host is easily mapped to using URP with no error correction and no flow control. Doing UDP where the remote host is different all the time is not practical on a Datakit network (i.e. a virtual circuit would be set up anyway).
A secondary takeaway is that Research Datakit eventually settled on a three-level ascii namespace: “area/trunk/switch”. On each switch, the hosts would be known by name, and each connection request had a service name as parameter. In an alternate reality we would maybe have used “ca/stclara/mtnview!google!www” to do a search.
> From: Rob Pike
> having the switch do some of the call validation and even maybe
> authentication (I'm not sure...) sounds like it takes load off the host.
I don't have enough information to express a judgement in this particular
case, but I can say a few things about how one would go about analyzing
questions of 'where should I put function [X]; in the host, or in the
'network' (which almost inevitably means 'in the switches')'.
It seems to me that one has to examine three points:
- What is the 'cost' to actually _do_ the thing (which might be in
transmission usage, or computing power, or memory, or delay), in each
alternative; these costs obviously generally cannot be amortized across
multiple similar transactions.
- What is the 'cost' of providing the _mechanism_ to do the thing, in each
alternative. This comes in three parts. The first is the engineering cost of
_designing_ the thing, in detail; this obviously is amortized across muiple
instances. The second is _producing_ the mechanism, in the places where it is
needed (for mechanisms in software, this cost is essentially zero, unless it
needs a lot of memory/computes/etc); this is not amortized across many. The
third is harder to measure: it's complexity.
This is probably a book by itself, but it has costs that are hard to
quantify, and are also very disparate: e.g. more complex designs are more
likely to have unforseen bugs, which is very different from the 'cost' that
more complex designs are probaly harder to evolve for new uses.
So far I haven't said anything that isn't applicable across a broad range of
information sytems. The last influence on where one puts functions is much
more common in communication systems: the Saltzer/Clark/Reed 'End-to-end
Arguments in System Design' questions. If one _has_ to put a function in the
host to get 'acceptable' performace of that function, the
operation/implementation/design cost implications are irrelevant: one has to
grit one's teeth and bear them.
This may then feed back to design questions in the other areas. E.g. the
Version 2 ring at MIT deliberately left out hardware packet checksums -
because it was mostly intended for use with TCP/IP traffic, which provided a
pseudo-End-to-End checksum, so the per-unit hardware costs didn't buy enough
to be worth the costs of a hardware CRC. (Which was the right call; I don't
recall the lack of a hardware checksum ever causing a problem.)
And then there's the 'techology is a moving target' point: something that
might be unacceptably expensive (in computing cost) in year X might be fine
in year X+10, when we're lighting our cigars with unneeded computing power.
So when one is designing a communication system with a likely lifetime in
many decades, one tends to bias one's judgement toward things like End-to-End
analysis - because those factors will be forever.
Sorry if I haven't offered any answer to your initial query: "having the
switch do some of the call validation ... sounds like it takes load off the
host", but as I have tried to explain, these 'where should one do [X]'
questions are very complicated, and one would need a lot more detail before
one could give a good answer.
But, in general, "tak[ing] load off the host" doesn't seem to rate
highly as a goal these days... :-) :-(
Noel
> From: Paul Ruizendaal
> Will read those RFC's, though -- thank you for pointing them out.
Oh, I wouldn't bother - unless you are really into routing (i.e. path
selection).
RFC-1992 in particular; it's got my name on it, but it was mostly written by
Martha and Isidro, and I'm not entirely happy with it. E.g. CSC mode and CSS
mode (roughly, strict source route and loose source route); I wasn't really
sold on them, but I was too tired to argue about it. Nimrod was complicated
enough without adding extra bells and whistles - and indeed, LSR and SSR are
basically unused to this day in the Internet (at least, at the internet
layer; MPLS does provide the ability to specify paths, which I gather is used
to some degree). I guess it's an OK overview of the architecture, though.
RFC-1753 is not the best overview, but it has interesting bits. E.g. 2.2
Packet Format Fields, Option 2: "The packet contains a stack of flow-ids,
with the current one on the top." If this reminds you of MPLS, it should!
(One can think of MPLS as Nimrod's packet-carrying subsystem, in some ways.)
I guess I should mention that Nimrod covers more stuff - a lot more - than
just path selection. That's because I felt that the architecture embodied in
IPv4 was missing lots of things which one would need to do the internet layer
'right' in a global-scale Internet (e.g. variable length 'addresses' - for
which we were forced to invent the term 'locator' because many nitwits in the
IETF couldn't wrap their minds around 'addresses' which weren't in every
packet header). And separation of location and identity; and the introduction
of traffic aggregates as first-class objects at the internet layer. Etc, etc,
etc.
Nimrod's main focus was really on i) providing a path-selection system which
allowed things like letting users have more input to selecting the path their
traffic took (just as when one gets into a car, one gets to pick the path
one's going to use), and ii) controlling the overhead of the routing.
Of course, on the latter point, in the real world, people just threw
resources (memory, computing power, bandwidth) at the problem. I'm kind of
blown away< that there are almost 1 million routes in the DFZ these days.
Boiling frogs...
Noel
I thought this comment was very good.
I went looking for “Clem’s Law” (presume Clem Cole) and struck out.
Any hints anyone can suggest or history on the comment?
steve j
==========
Larry McVoy wrote Fri Sep 17 10:44:25 AEST 2021
<https://minnie.tuhs.org/pipermail/tuhs/2021-September/024424.html>
Plan 9 is very cool but I am channeling my inner Clem,
Plan 9 didn't meet Clem's law.
It was never compelling enough to make the masses love it.
Linux was good enough.
==========
--
Steve Jenkin, IT Systems and Design
0412 786 915 (+61 412 786 915)
PO Box 38, Kippax ACT 2615, AUSTRALIA
mailto:sjenkin@canb.auug.org.au http://members.tip.net.au/~sjenkin
Just as the topic of TUHS isn't 'how _I_ could/would build a _better_ OS', but
'history of the OS that was _actually built_' (something that many posters
here seem to lose track of, to the my great irritation), so too the topic
isn't 'how to build a better network' - or actually, anything network-centric.
I'll make a few comments on a couple of things, though.
> From: steve jenkin
> packet switching won over Virtual Circuits in the now distant past but
> in small, local and un-congested networks without reliability
> constraints, any solution can look good. ... Packet switching
> hasn't scaled well to Global size, at least IMHO.
The internetworking architecture, circa 1978, has not scaled as well as would
have been optimal, for a number of reasons, among them:
- pure scaling effects (e.g. algorithms won't scale up; subsystems which
handle several different needs will often need to be separated out at a larger
scale; etc)
- inherent lack of hindsight (unknown unknowns, to use Rumsfeld's phrase; some
things you only learn in hindsight)
- insufficiently detailed knowledge of complete requirements for a
global-scale network (including O+M, eventual business model, etc)
- limited personnel resources at the time (some things we _knew_ were going to
be a problem we had to ignore because we didn't have people to throw at the
problem, then and there)
- rapid technological innovation (and nobody's crystal ball is 100% perfect)
It has been possible to fix some aspects of the ca. 1978 system - e.g. the
addition of DNS, which I think has worked _reasonably_ well - but in other
areas, changes weren't really adequate, often because they were constrained by
things like upward compatibility requirements (e.g. BGP, which, among numerous
other issues, had to live with existing IP addressing).
Having said all that, I think your assertion that virtual circuits would have
worked better in a global-scale network is questionable. The whole point of
networks which use unreliable datagrams as a fundamental building block is
that by moving a lot of functionality into the edge nodes, it makes the
switches a lot simpler. Contemporary core routers may be complex - but they
would be much worse if the network used virtual circuits.
Something I suspect you may be unaware of is that most of the people who
devised the unreliable datagram approach of the internetworking architecture
_had experience with an actual moderately-sized, operational virtual circuit
network_ - the ARPANET. (Yes, it was basically a VC network. Look at things
like RFNMs, links {the specific ARPANET mechanism referred to by this term,
not the general concept}, etc.) So they _knew_ what a VC network would
involve.
So, think about the 'core routers' in a network which used VC's. I guess a
typical core router tese days uses a couple of OC768 links. Assume an average
packet size of 100 bytes (probably roughly accurate, with the bimodal
distribution between data and acks). With 4 OC768's, that's 4*38.5G/800 =
~155M packets/second. I'm not sure of the average TCP connection length in
packets these days, but assume it's 100 packets or so (that's a 100KB Web
object). That's still roughly _1 million cicuit setups per second_.
If the answer is 'oh, we'll use aggregation so core routers don't see
individual connections - or their setup/tear-down' - well, the same
can be done with a datagram system; that's what MPLS does. Work
through the details - VCs were not preferred, for good reasons.
> Ethernet only became a viable LAN technology with advent of Twisted
> pair: point to point + Switches.
It's really irritating that a lot of things labelled 'Ethernet' these days
_aren't_ _real_ Ethernet (i.e. a common broadcast bus allocated via CSMA-CD).
They use the same _packet format_ as Ethernet (especially the 48-bit
globally-unique address, which can usefully be blown into things at
manufacture time), but it's not Ethernet. In some cases, they also retain the
host interface<->network physical interface - but the thing on the other side
of the interface is totally different (such as the hub-based systems commmon
now - as you indicate, it's a bunch of small datagram packet switches plugged
together with point-point links).
Interfaces are forever; like the screw in light-bulb. These days, it's likely
an LED bulb on one side, powered by a reactor on the other - two technologies
which were unforseen (and unforseeable) when the interface was defined, well
over 100 years ago.
Noel
On Tue, Jun 21, 2022 at 05:56:02PM -0600, Jacob Moody wrote:
> I recently stumbled across the existence of datakit
> when going through the plan9foundation source archives.
> Would be curious to hear more about its involvement
> with plan9.
There are at least 2 versions of Datakit. I my current understanding there are “Datakit” which is the research version, and “Datakit II” which seems to be the version that was broadly deployed into the AT&T network in the late 80’s -- but very likely the story is more complicated than that. Plan9 is contemporaneous with Datakit II.
In short, Sandy Fraser developed the “Spider” network in 1970-1974 and this was actively used with early Unix (at least V4, maybe earlier). Sandy was dissatisfied with Spider and used its learnings to start again. The key ideas seem to have gelled together around 1977 with the first switches being available in 1979 or so. The first deployment into the Bell system was around 1982 (initially connecting a handful of Bell sites).
In 1979/1980 there were two Datakit switches, one in the office of Greg Chesson who was writing the first iteration of its control software, and one in the office/lab of Gottfried Luderer et al., who used it to develop a distributed Unix.
Datakit at this time is well described in two papers that the ACM recently moved from behind its paywall:
https://dl.acm.org/doi/pdf/10.1145/1013879.802670 (mostly about 1980 Datakit)
https://dl.acm.org/doi/pdf/10.1145/800216.806604 (mostly about distributed Unix)
The Chesson control software was replaced by new code written by Lee McMahon around 1981 (note: this is still Datakit 1). The Datakit driver code in V8 is designed to work with this revised Datakit. Three aspects of Datakit show through in the design the V8-V10 networking code:
- a separation in control words and data words (this e.g. comes back in ‘streams')
- it works with virtual circuits; a connection is expensive to set up (‘dial’), but cheap to use
- it does not guarantee reliable packet delivery, but it does guarantee in-order delivery
Probably you will see echoes of this in early Plan9 network code, but I have not studied that.
> From: Paul Ruizendaal
> it would seem to me that Sandy had figured out a core problem some 30
> years before the TCP/IP world would come up with a similar solution. I
> would not even be surprised if I learned that modern telco routers
> transparantly set up virtual circuits for tcp traffic.
To fully explore this topic would take a book, which I don't have the energy
to write, and nobody would bother to read, but...
Anyway, I'm not upon the latest and greatest high-speed routers: I saw some
stuff from one major vendor under NDA about a decade ago, but that's my most
recent - but at that point there was nothing that looked even _vaguely_ like
virtual circuits. (The stuff Craig was alluding to was just about
connectivity for getting bitts from _interface_ to _interface_ - if you don't
have a giant crossbar - which is going to require buffering on each input
anyway - how exactly do you get bits from board A to board Q - a single
shared bus isn't going to do it...)
A problem with anything like VC's in core switches is the growth of per-VC
state - a major high-speed node will have packets from _millions_ of TCP
connections flowing through it at any time. In the late-80's/early-90's - well
over 30 years ago - I came up with an advanced routing architecture called
Nimrod (see RFC-1992, "The Nimrod Routing Architecture"; RFC-1753 may be of
interest too); it had things called 'flows' which were half way between pure
datagrams (i.e. no setup - you just stick the right destination address in the
header and send it off) and VCs (read the RFCs if you want to kow why), and it
went to a lot of trouble to allow flow aggregation in traffic going to core
switches _precisely_ to limit the growth of state in core switches, which
would have traffic from millions of connections going through them.
I have barely begun to even scratch the surface, here.
Noel
I’ve been wondering about the growth of Unix and if there’s any good data available.
There’s the Early Unix Epoch, which probably ends with the Unix Support Group assuming the distribution role, plus providing / distributing their version of the code.
Later there’s commercial Unix:
System III and System V, I guess.
BSD, until the lawsuit was resolved, required a Source code license, but their installation count is important in pre-Commercial Unix.
Large licensees like SUN, HP & IBM (AIX) may not have published license counts for their versions - but then, were their derivatives “Unix” or something else?
Warner Loch’s paper has data to around 1978 [below].
I’ve no idea where to find data for USG issued licences, or if the number of binary & source licences were ever reported in the Commercial Era by AT&T.
I’ll not be the first person who’s gone down this road, but my Search Fu isn’t good enough to find them.
Wondering if anyone on the list can point me at resources, even a bunch of annual reports.
I don’t mind manually pulling out the data I’m interested in. But why reinvent the wheel if the work is already done?
steve
===============
numbers extracted from Warner Loch’s paper.
<https://papers.freebsd.org/2020/FOSDEM/losh-Hidden_early_history_of_Unix.fi…>
2nd Edn June 1972 10 installations
3rd Edn February 1973 16
4th Edn November 1973 >20, or 25
July 74 CACM paper "Unix Time Sharing System” after which external interest exploded
6th Edn 1975 ???
7th Edn March 1978 600+, >300 inside Bell System, "even more have been licensed to outside users”
===============
--
Steve Jenkin,
0412 786 915 (+61 412 786 915)
PO Box 38, Kippax ACT 2615, AUSTRALIA
mailto:sjenkin@canb.auug.org.au http://members.tip.net.au/~sjenkin
> From: Dan Cross
> I believe that's actually a menu
Hence the "erroneous _impression_" (emphasis added).
I'm curious as to how they decided which models to run which editions on.
Although V4 _ran_ on the /45, split I+D wasn't supported - for user or kernel
- until V6. (I'm assuming a number of things - both in the kernel, and
applications - started hitting the 64KB limit, which led to its support.)
Speaking of split I+D, there's an interesting little mystery in V6 that at
one point in time I thought involved split I+D - but now that I look closely,
apparently not. The mystery involves a 'tombstone' in the V6 buf.h:
#define B_RELOC 0200 /* no longer used */
I had created (in my mind) an explanation what this is all about - but now
that I look, it's probably all wrong!
My explanation involves the slightly odd layout of the kernel in physical
memory, with split I+D; data below the code, at physical 0. This actually
makes a lot of sense; it means the virtual address of any data (e.g. a
buffer) is the same as its physical address (needed for DMA). It does require
the oddness of 'sysfix', to invert the order of code+data in the system
binary, plus odd little quirks in the assembler startup (e.g. copying the
code up to make room for BSS).
So I thought that B_RELOC was a hangover from a time, at the start of split
I+D, when data _wasn't_ at physical 0, so a buffer's virtual and phsyical
addresses differed.
But that must be wrong (at least in any simple way). B_RELOC was in buf.h as
of V4 - the first kernel version in C - with no split I+D. So my theory has
to be wrong.
However, I am unable to find any code in the V4 kernel which uses it! So
unless someone who remembers the very early PDP-11 kernel can enlighten us,
its purpose will always remain a mystery!
Noel
