Rocksolid Light

Welcome to novaBBS (click a section below)

mail  files  register  newsreader  groups  login

Message-ID:  

//GO.SYSIN DD *, DOODAH, DOODAH


devel / comp.arch / Comparing Today's PC to the IBM 704

SubjectAuthor
* Comparing Today's PC to the IBM 704Quadibloc
+- Re: Comparing Today's PC to the IBM 704JimBrakefield
+* Re: Comparing Today's PC to the IBM 704John Levine
|`- Re: Comparing Today's PC to the IBM 704EricP
+* Re: Comparing Today's PC to the IBM 704MitchAlsup
|`- Re: Comparing Today's PC to the IBM 704BGB
`* Re: Comparing Today's PC to the IBM 704antispam
 `- Re: Comparing Today's PC to the IBM 704chris

1
Comparing Today's PC to the IBM 704

<2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=21943&group=comp.arch#21943

 copy link   Newsgroups: comp.arch
X-Received: by 2002:a37:a790:: with SMTP id q138mr115223qke.405.1636554884140; Wed, 10 Nov 2021 06:34:44 -0800 (PST)
X-Received: by 2002:a9d:4d8b:: with SMTP id u11mr282106otk.144.1636554883851; Wed, 10 Nov 2021 06:34:43 -0800 (PST)
Path: i2pn2.org!i2pn.org!paganini.bofh.team!news.dns-netz.com!news.freedyn.net!newsfeed.xs4all.nl!newsfeed7.news.xs4all.nl!tr1.eu1.usenetexpress.com!feeder.usenetexpress.com!tr1.iad1.usenetexpress.com!border1.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.arch
Date: Wed, 10 Nov 2021 06:34:43 -0800 (PST)
Injection-Info: google-groups.googlegroups.com; posting-host=2001:56a:fa3a:e00:f57d:7484:614d:53cf; posting-account=1nOeKQkAAABD2jxp4Pzmx9Hx5g9miO8y
NNTP-Posting-Host: 2001:56a:fa3a:e00:f57d:7484:614d:53cf
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>
Subject: Comparing Today's PC to the IBM 704
From: jsav...@ecn.ab.ca (Quadibloc)
Injection-Date: Wed, 10 Nov 2021 14:34:44 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 30
 by: Quadibloc - Wed, 10 Nov 2021 14:34 UTC

The IBM 704 was a computer that used vacuum tubes for its logic
elements.
In some ways, it was one of the first computers to be similar to the
computers that came after it up to the present day. Older computers
sometimes used recirculating memories of some kind - drum memory,
or mercury delay lines, or magnetostrictive delay lines. Some had
Williams tubes, an early form of random access memory that was
finicky and unreliable, due to pattern sensitivity. The IBM had core
memory, which was a highly-reliable form of random-access memory.
Also, it had a hardware floating-point unit. While it only had instructions
to perform single-precision floating arithmetic, these instructions were
designed to retain information generated during the calculation that made
it easier to perform double-precision calculations.
I recently looked at a video about the experimental chess-playing program
tried on an IBM 704 computer. In the video, it was mentioned that when
calculating a satellite orbit, an IBM 704 performed one billiion calculations
in a single day.
I assume that means one billion instructions were executed.
This figure was also cited in a paper about the chess program, which
is probably where the text of the narration came from.
Today, a typical PC might have a clock rate of 3 GHz or thereabouts.
But most instructions take more than three cycles to execute.
Out-of-order execution attempts to approach the ideal of letting a
single thread still use every cycle to start a new instruction, but I
doubt it is approached that closely in practice.
So instead of being 200,000 times faster, or even 86,400 (the number
of seconds in a day) times faster, than an IBM 704, perhaps one of
today's PCs is closer to 10,000 or 20,000 times faster than a 704 in
single-threaded performance.

John Savard

Re: Comparing Today's PC to the IBM 704

<e0bb04f7-9e14-485d-8c61-b4fc25f45b8fn@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=21945&group=comp.arch#21945

 copy link   Newsgroups: comp.arch
X-Received: by 2002:a37:712:: with SMTP id 18mr145123qkh.366.1636558360559;
Wed, 10 Nov 2021 07:32:40 -0800 (PST)
X-Received: by 2002:a4a:6342:: with SMTP id r2mr98655oof.54.1636558360215;
Wed, 10 Nov 2021 07:32:40 -0800 (PST)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.arch
Date: Wed, 10 Nov 2021 07:32:40 -0800 (PST)
In-Reply-To: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=136.50.253.102; posting-account=AoizIQoAAADa7kQDpB0DAj2jwddxXUgl
NNTP-Posting-Host: 136.50.253.102
References: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <e0bb04f7-9e14-485d-8c61-b4fc25f45b8fn@googlegroups.com>
Subject: Re: Comparing Today's PC to the IBM 704
From: jim.brak...@ieee.org (JimBrakefield)
Injection-Date: Wed, 10 Nov 2021 15:32:40 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 46
 by: JimBrakefield - Wed, 10 Nov 2021 15:32 UTC

On Wednesday, November 10, 2021 at 8:34:45 AM UTC-6, Quadibloc wrote:
> The IBM 704 was a computer that used vacuum tubes for its logic
> elements.
> In some ways, it was one of the first computers to be similar to the
> computers that came after it up to the present day. Older computers
> sometimes used recirculating memories of some kind - drum memory,
> or mercury delay lines, or magnetostrictive delay lines. Some had
> Williams tubes, an early form of random access memory that was
> finicky and unreliable, due to pattern sensitivity. The IBM had core
> memory, which was a highly-reliable form of random-access memory.
> Also, it had a hardware floating-point unit. While it only had instructions
> to perform single-precision floating arithmetic, these instructions were
> designed to retain information generated during the calculation that made
> it easier to perform double-precision calculations.
> I recently looked at a video about the experimental chess-playing program
> tried on an IBM 704 computer. In the video, it was mentioned that when
> calculating a satellite orbit, an IBM 704 performed one billiion calculations
> in a single day.
> I assume that means one billion instructions were executed.
> This figure was also cited in a paper about the chess program, which
> is probably where the text of the narration came from.
> Today, a typical PC might have a clock rate of 3 GHz or thereabouts.
> But most instructions take more than three cycles to execute.
> Out-of-order execution attempts to approach the ideal of letting a
> single thread still use every cycle to start a new instruction, but I
> doubt it is approached that closely in practice.
> So instead of being 200,000 times faster, or even 86,400 (the number
> of seconds in a day) times faster, than an IBM 704, perhaps one of
> today's PCs is closer to 10,000 or 20,000 times faster than a 704 in
> single-threaded performance.
>
> John Savard
In painting the history of computers in broad brush strokes, three orders of magnitude seems to work.
At one time much was made of the 3M computer:
a million "instructions" per second, a mega byte of memory and a mega pixel display
Going backwards in time, the 3K computer:
thousands of instructions per second, kilobytes of memory and an ASCI display
and the 3U computer:
the adding machine and the abacus, paper and pencil
We are currently at the tail end of the 3G era and 3T single chip machines are appearing

It is clear that different problems have different needs, as in compute speed, memory size and IO bandwidth.
The "power" of a given computer is some complicated and nonlinear function of these three items?
So historically one can try to place different technologies into these eras:
vacuum tubes, relays, electro-mechanical, tape drives, core memory, flash memory etc.
Again one can use broad brush strokes and get some semblance of order.

Re: Comparing Today's PC to the IBM 704

<smgou9$1rg5$1@gal.iecc.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=21946&group=comp.arch#21946

 copy link   Newsgroups: comp.arch
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!news.iecc.com!.POSTED.news.iecc.com!not-for-mail
From: joh...@taugh.com (John Levine)
Newsgroups: comp.arch
Subject: Re: Comparing Today's PC to the IBM 704
Date: Wed, 10 Nov 2021 15:36:41 -0000 (UTC)
Organization: Taughannock Networks
Message-ID: <smgou9$1rg5$1@gal.iecc.com>
References: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>
Injection-Date: Wed, 10 Nov 2021 15:36:41 -0000 (UTC)
Injection-Info: gal.iecc.com; posting-host="news.iecc.com:2001:470:1f07:1126:0:676f:7373:6970";
logging-data="60933"; mail-complaints-to="abuse@iecc.com"
In-Reply-To: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>
Cleverness: some
X-Newsreader: trn 4.0-test77 (Sep 1, 2010)
Originator: johnl@iecc.com (John Levine)
 by: John Levine - Wed, 10 Nov 2021 15:36 UTC

According to Quadibloc <jsavard@ecn.ab.ca>:
>I recently looked at a video about the experimental chess-playing program
>tried on an IBM 704 computer. In the video, it was mentioned that when
>calculating a satellite orbit, an IBM 704 performed one billiion calculations
>in a single day.

The 704's cycle time was 12us. Most fixed point instructions took two or three
cycles, floating add or subtract 7 cycles, floating multiply or divide 17 or
18, and fixed multiply or divide 20 cycles.

Divide 12us into a day and you get 7.2 billion cycles, so if we assume an instruction
mix that didn't have a lot of multiplying and dividing, 7 cycles per instruction and
a billion instructions per day seems about right.

Instruction timings are on pp 28-29 of the manual:

http://bitsavers.org/pdf/ibm/704/24-6661-2_704_Manual_1955.pdf

The cycle time was about 800Khz, so a 3Ghz PC cycles 36000 times faster but it
will issue instructions a lot faster than one every 7 cycles, so I'd say it's
more like 100,000 times faster.

--
Regards,
John Levine, johnl@taugh.com, Primary Perpetrator of "The Internet for Dummies",
Please consider the environment before reading this e-mail. https://jl.ly

Re: Comparing Today's PC to the IBM 704

<%nSiJ.36997$OB3.18552@fx06.iad>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=21947&group=comp.arch#21947

 copy link   Newsgroups: comp.arch
Path: i2pn2.org!i2pn.org!usenet.goja.nl.eu.org!3.eu.feeder.erje.net!feeder.erje.net!newsfeed.xs4all.nl!newsfeed9.news.xs4all.nl!feeder1.feed.usenet.farm!feed.usenet.farm!peer03.ams4!peer.am4.highwinds-media.com!peer01.iad!feed-me.highwinds-media.com!news.highwinds-media.com!fx06.iad.POSTED!not-for-mail
From: ThatWoul...@thevillage.com (EricP)
User-Agent: Thunderbird 2.0.0.24 (Windows/20100228)
MIME-Version: 1.0
Newsgroups: comp.arch
Subject: Re: Comparing Today's PC to the IBM 704
References: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com> <smgou9$1rg5$1@gal.iecc.com>
In-Reply-To: <smgou9$1rg5$1@gal.iecc.com>
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
Lines: 32
Message-ID: <%nSiJ.36997$OB3.18552@fx06.iad>
X-Complaints-To: abuse@UsenetServer.com
NNTP-Posting-Date: Wed, 10 Nov 2021 16:25:31 UTC
Date: Wed, 10 Nov 2021 11:25:15 -0500
X-Received-Bytes: 2133
 by: EricP - Wed, 10 Nov 2021 16:25 UTC

John Levine wrote:
> According to Quadibloc <jsavard@ecn.ab.ca>:
>> I recently looked at a video about the experimental chess-playing program
>> tried on an IBM 704 computer. In the video, it was mentioned that when
>> calculating a satellite orbit, an IBM 704 performed one billiion calculations
>> in a single day.
>
> The 704's cycle time was 12us. Most fixed point instructions took two or three
> cycles, floating add or subtract 7 cycles, floating multiply or divide 17 or
> 18, and fixed multiply or divide 20 cycles.
>
> Divide 12us into a day and you get 7.2 billion cycles, so if we assume an instruction
> mix that didn't have a lot of multiplying and dividing, 7 cycles per instruction and
> a billion instructions per day seems about right.
>
> Instruction timings are on pp 28-29 of the manual:
>
> http://bitsavers.org/pdf/ibm/704/24-6661-2_704_Manual_1955.pdf
>
> The cycle time was about 800Khz, so a 3Ghz PC cycles 36000 times faster but it
> will issue instructions a lot faster than one every 7 cycles, so I'd say it's
> more like 100,000 times faster.

704 is doing 1 billion per day.
x64 with an IPC of 2 is doing 2*3 billion per second
= a factor of 6*86400 = 518,400 faster.
That's over 60 or so years.

518,400 = (1.0 + i)^60, i = 0.25 = 25% compound annual growth.
That gives a doubling time of 3.11 years.

Re: Comparing Today's PC to the IBM 704

<641732a3-f571-4ec3-aeeb-1b20b9ebce21n@googlegroups.com>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=21948&group=comp.arch#21948

 copy link   Newsgroups: comp.arch
X-Received: by 2002:ac8:4111:: with SMTP id q17mr1549554qtl.407.1636572780331;
Wed, 10 Nov 2021 11:33:00 -0800 (PST)
X-Received: by 2002:a4a:c596:: with SMTP id x22mr929095oop.59.1636572780039;
Wed, 10 Nov 2021 11:33:00 -0800 (PST)
Path: i2pn2.org!i2pn.org!weretis.net!feeder6.news.weretis.net!news.misty.com!border2.nntp.dca1.giganews.com!nntp.giganews.com!news-out.google.com!nntp.google.com!postnews.google.com!google-groups.googlegroups.com!not-for-mail
Newsgroups: comp.arch
Date: Wed, 10 Nov 2021 11:32:59 -0800 (PST)
In-Reply-To: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>
Injection-Info: google-groups.googlegroups.com; posting-host=104.59.204.55; posting-account=H_G_JQkAAADS6onOMb-dqvUozKse7mcM
NNTP-Posting-Host: 104.59.204.55
References: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>
User-Agent: G2/1.0
MIME-Version: 1.0
Message-ID: <641732a3-f571-4ec3-aeeb-1b20b9ebce21n@googlegroups.com>
Subject: Re: Comparing Today's PC to the IBM 704
From: MitchAl...@aol.com (MitchAlsup)
Injection-Date: Wed, 10 Nov 2021 19:33:00 +0000
Content-Type: text/plain; charset="UTF-8"
Lines: 42
 by: MitchAlsup - Wed, 10 Nov 2021 19:32 UTC

On Wednesday, November 10, 2021 at 8:34:45 AM UTC-6, Quadibloc wrote:
> The IBM 704 was a computer that used vacuum tubes for its logic
> elements.
> In some ways, it was one of the first computers to be similar to the
> computers that came after it up to the present day. Older computers
> sometimes used recirculating memories of some kind - drum memory,
> or mercury delay lines, or magnetostrictive delay lines. Some had
> Williams tubes, an early form of random access memory that was
> finicky and unreliable, due to pattern sensitivity. The IBM had core
> memory, which was a highly-reliable form of random-access memory.
> Also, it had a hardware floating-point unit. While it only had instructions
> to perform single-precision floating arithmetic, these instructions were
> designed to retain information generated during the calculation that made
> it easier to perform double-precision calculations.
> I recently looked at a video about the experimental chess-playing program
> tried on an IBM 704 computer. In the video, it was mentioned that when
> calculating a satellite orbit, an IBM 704 performed one billiion calculations
> in a single day.
> I assume that means one billion instructions were executed.
> This figure was also cited in a paper about the chess program, which
> is probably where the text of the narration came from.
> Today, a typical PC might have a clock rate of 3 GHz or thereabouts.
<
OK enough
<
> But most instructions take more than three cycles to execute.
<
3 cycles of latency, but as many as 3-4 instructions start every cycle.
<
> Out-of-order execution attempts to approach the ideal of letting a
> single thread still use every cycle to start a new instruction, but I
> doubt it is approached that closely in practice.
<
About 50% of the instructions issued into the window complete.
<
> So instead of being 200,000 times faster, or even 86,400 (the number
> of seconds in a day) times faster, than an IBM 704, perhaps one of
> today's PCs is closer to 10,000 or 20,000 times faster than a 704 in
> single-threaded performance.
<
As stated above, I bet the number is closer to 200,000-1,000,000 faster.
>
> John Savard

Re: Comparing Today's PC to the IBM 704

<smlt2f$ip9$1@z-news.wcss.wroc.pl>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=21968&group=comp.arch#21968

 copy link   Newsgroups: comp.arch
Path: i2pn2.org!i2pn.org!news.swapon.de!2.eu.feeder.erje.net!feeder.erje.net!newsfeed.pionier.net.pl!pwr.wroc.pl!news.wcss.wroc.pl!not-for-mail
From: antis...@math.uni.wroc.pl
Newsgroups: comp.arch
Subject: Re: Comparing Today's PC to the IBM 704
Date: Fri, 12 Nov 2021 14:17:51 +0000 (UTC)
Organization: Politechnika Wroclawska
Lines: 43
Message-ID: <smlt2f$ip9$1@z-news.wcss.wroc.pl>
References: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>
NNTP-Posting-Host: hera.math.uni.wroc.pl
X-Trace: z-news.wcss.wroc.pl 1636726671 19241 156.17.86.1 (12 Nov 2021 14:17:51 GMT)
X-Complaints-To: abuse@news.pwr.wroc.pl
NNTP-Posting-Date: Fri, 12 Nov 2021 14:17:51 +0000 (UTC)
Cancel-Lock: sha1:Dg+dPuROKh32reg0SLG9HlmYDxs=
User-Agent: tin/2.4.3-20181224 ("Glen Mhor") (UNIX) (Linux/4.19.0-10-amd64 (x86_64))
 by: antis...@math.uni.wroc.pl - Fri, 12 Nov 2021 14:17 UTC

Quadibloc <jsavard@ecn.ab.ca> wrote:
> The IBM 704 was a computer that used vacuum tubes for its logic
> elements.
> In some ways, it was one of the first computers to be similar to the
> computers that came after it up to the present day. Older computers
> sometimes used recirculating memories of some kind - drum memory,
> or mercury delay lines, or magnetostrictive delay lines. Some had
> Williams tubes, an early form of random access memory that was
> finicky and unreliable, due to pattern sensitivity. The IBM had core
> memory, which was a highly-reliable form of random-access memory.
> Also, it had a hardware floating-point unit. While it only had instructions
> to perform single-precision floating arithmetic, these instructions were
> designed to retain information generated during the calculation that made
> it easier to perform double-precision calculations.
> I recently looked at a video about the experimental chess-playing program
> tried on an IBM 704 computer. In the video, it was mentioned that when
> calculating a satellite orbit, an IBM 704 performed one billiion calculations
> in a single day.
> I assume that means one billion instructions were executed.
> This figure was also cited in a paper about the chess program, which
> is probably where the text of the narration came from.
> Today, a typical PC might have a clock rate of 3 GHz or thereabouts.
> But most instructions take more than three cycles to execute.
> Out-of-order execution attempts to approach the ideal of letting a
> single thread still use every cycle to start a new instruction, but I
> doubt it is approached that closely in practice.
> So instead of being 200,000 times faster, or even 86,400 (the number
> of seconds in a day) times faster, than an IBM 704, perhaps one of
> today's PCs is closer to 10,000 or 20,000 times faster than a 704 in
> single-threaded performance.

You are seriously underestimating modern machines. In addition
to what EricP and Mitch Alsup wrote, note that modern instructions
can do more than old ones. General registers and immediates
save many loads and stores. Addressing modes can do more than
simple index registers in 704. I would say that for given
work modern machine probably needs half of number of instructions
needed on 704. And that ignoring packed SIMD which can give
extra speedup. So I would say that modern machine is closer
to 1000000 (10^6) faster.

--
Waldek Hebisch

Re: Comparing Today's PC to the IBM 704

<smm5j9$1rqp$1@gioia.aioe.org>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=21970&group=comp.arch#21970

 copy link   Newsgroups: comp.arch
Path: i2pn2.org!i2pn.org!aioe.org!jazQyxryRFiI4FEZ51SAvA.user.46.165.242.75.POSTED!not-for-mail
From: chris-no...@tridac.net (chris)
Newsgroups: comp.arch
Subject: Re: Comparing Today's PC to the IBM 704
Date: Fri, 12 Nov 2021 16:43:21 +0000
Organization: Aioe.org NNTP Server
Message-ID: <smm5j9$1rqp$1@gioia.aioe.org>
References: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com> <smlt2f$ip9$1@z-news.wcss.wroc.pl>
Mime-Version: 1.0
Content-Type: text/plain; charset=ISO-8859-1; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Info: gioia.aioe.org; logging-data="61273"; posting-host="jazQyxryRFiI4FEZ51SAvA.user.gioia.aioe.org"; mail-complaints-to="abuse@aioe.org";
User-Agent: Mozilla/5.0 (X11; SunOS sun4u; rv:10.0.2) Gecko/20120216 Thunderbird/10.0.2
X-Notice: Filtered by postfilter v. 0.9.2
 by: chris - Fri, 12 Nov 2021 16:43 UTC

On 11/12/21 14:17, antispam@math.uni.wroc.pl wrote:
> Quadibloc<jsavard@ecn.ab.ca> wrote:
>> The IBM 704 was a computer that used vacuum tubes for its logic
>> elements.
>> In some ways, it was one of the first computers to be similar to the
>> computers that came after it up to the present day. Older computers
>> sometimes used recirculating memories of some kind - drum memory,
>> or mercury delay lines, or magnetostrictive delay lines. Some had
>> Williams tubes, an early form of random access memory that was
>> finicky and unreliable, due to pattern sensitivity. The IBM had core
>> memory, which was a highly-reliable form of random-access memory.
>> Also, it had a hardware floating-point unit. While it only had instructions
>> to perform single-precision floating arithmetic, these instructions were
>> designed to retain information generated during the calculation that made
>> it easier to perform double-precision calculations.
>> I recently looked at a video about the experimental chess-playing program
>> tried on an IBM 704 computer. In the video, it was mentioned that when
>> calculating a satellite orbit, an IBM 704 performed one billiion calculations
>> in a single day.
>> I assume that means one billion instructions were executed.
>> This figure was also cited in a paper about the chess program, which
>> is probably where the text of the narration came from.
>> Today, a typical PC might have a clock rate of 3 GHz or thereabouts.
>> But most instructions take more than three cycles to execute.
>> Out-of-order execution attempts to approach the ideal of letting a
>> single thread still use every cycle to start a new instruction, but I
>> doubt it is approached that closely in practice.
>> So instead of being 200,000 times faster, or even 86,400 (the number
>> of seconds in a day) times faster, than an IBM 704, perhaps one of
>> today's PCs is closer to 10,000 or 20,000 times faster than a 704 in
>> single-threaded performance.
>
> You are seriously underestimating modern machines. In addition
> to what EricP and Mitch Alsup wrote, note that modern instructions
> can do more than old ones. General registers and immediates
> save many loads and stores. Addressing modes can do more than
> simple index registers in 704. I would say that for given
> work modern machine probably needs half of number of instructions
> needed on 704. And that ignoring packed SIMD which can give
> extra speedup. So I would say that modern machine is closer
> to 1000000 (10^6) faster.
>

Not only that, but convenience and total time to solution. Would guess
that a 704 class machine may have taken a day just to prepare a program
to run, then into the queue, debug, more work etc. A modern machine can
sit on your desk with high res monitor, high grade compilers and
effectively give instant results. That's before even thinking about
power consumption, floor area, reliability and cost of maintenance...

Chris

consumption, maintenance and

Re: Comparing Today's PC to the IBM 704

<smmfue$vqg$1@dont-email.me>

 copy mid

https://www.novabbs.com/devel/article-flat.php?id=21973&group=comp.arch#21973

 copy link   Newsgroups: comp.arch
Path: i2pn2.org!i2pn.org!eternal-september.org!reader02.eternal-september.org!.POSTED!not-for-mail
From: cr88...@gmail.com (BGB)
Newsgroups: comp.arch
Subject: Re: Comparing Today's PC to the IBM 704
Date: Fri, 12 Nov 2021 13:38:26 -0600
Organization: A noiseless patient Spider
Lines: 133
Message-ID: <smmfue$vqg$1@dont-email.me>
References: <2cdf1603-fe3a-482a-ad69-1dc0fce40b2an@googlegroups.com>
<641732a3-f571-4ec3-aeeb-1b20b9ebce21n@googlegroups.com>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 7bit
Injection-Date: Fri, 12 Nov 2021 19:39:58 -0000 (UTC)
Injection-Info: reader02.eternal-september.org; posting-host="ef110fc92d6ef7de0c1e75b60e69ff88";
logging-data="32592"; mail-complaints-to="abuse@eternal-september.org"; posting-account="U2FsdGVkX1+oqCR4d5FS4kmDF71Tbi+E"
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:91.0) Gecko/20100101
Thunderbird/91.3.0
Cancel-Lock: sha1:YDqKs+3Anie92EhJJ69xbZsuG9U=
In-Reply-To: <641732a3-f571-4ec3-aeeb-1b20b9ebce21n@googlegroups.com>
Content-Language: en-US
 by: BGB - Fri, 12 Nov 2021 19:38 UTC

On 11/10/2021 1:32 PM, MitchAlsup wrote:
> On Wednesday, November 10, 2021 at 8:34:45 AM UTC-6, Quadibloc wrote:
>> The IBM 704 was a computer that used vacuum tubes for its logic
>> elements.
>> In some ways, it was one of the first computers to be similar to the
>> computers that came after it up to the present day. Older computers
>> sometimes used recirculating memories of some kind - drum memory,
>> or mercury delay lines, or magnetostrictive delay lines. Some had
>> Williams tubes, an early form of random access memory that was
>> finicky and unreliable, due to pattern sensitivity. The IBM had core
>> memory, which was a highly-reliable form of random-access memory.
>> Also, it had a hardware floating-point unit. While it only had instructions
>> to perform single-precision floating arithmetic, these instructions were
>> designed to retain information generated during the calculation that made
>> it easier to perform double-precision calculations.
>> I recently looked at a video about the experimental chess-playing program
>> tried on an IBM 704 computer. In the video, it was mentioned that when
>> calculating a satellite orbit, an IBM 704 performed one billiion calculations
>> in a single day.
>> I assume that means one billion instructions were executed.
>> This figure was also cited in a paper about the chess program, which
>> is probably where the text of the narration came from.
>> Today, a typical PC might have a clock rate of 3 GHz or thereabouts.
> <
> OK enough
> <
>> But most instructions take more than three cycles to execute.
> <
> 3 cycles of latency, but as many as 3-4 instructions start every cycle.
> <
>> Out-of-order execution attempts to approach the ideal of letting a
>> single thread still use every cycle to start a new instruction, but I
>> doubt it is approached that closely in practice.
> <
> About 50% of the instructions issued into the window complete.
> <
>> So instead of being 200,000 times faster, or even 86,400 (the number
>> of seconds in a day) times faster, than an IBM 704, perhaps one of
>> today's PCs is closer to 10,000 or 20,000 times faster than a 704 in
>> single-threaded performance.
> <
> As stated above, I bet the number is closer to 200,000-1,000,000 faster.

Based on what I can gather (crude estimate):
7030 was ~ 10x faster than 704 (based on earlier benchmarks);
7030 got ~ 2k on Dhrystone;
Saw a video which claimed ~ 4.8k for a 386SX-25
BJX2 gets ~ 69k, ATM (50MHz);
Emulator gets ~ 154k at 100MHz (*1);
My desktop PC gets ~ 11M-45M.

Back-propagating, one can hand-wave the 704 as being ~ 200 Dhrystone,
for sake of argument.

The 11 to 45 million delta is mostly due to MSVC vs GCC issues (Clang
gives ~ 41 million). This is on a Ryzen-7 2700x running at 3.7 GHz.

GCC's score drops considerably with '-Os' (slightly below the MSVC
score; giving ~ 9M). Likewise, '-O0' is a little slower than this (~
6M). Clang results are mostly similar to GCC results, just a little bit
smaller. GCC seems to fall into two groups "-O2/-O3"="fast";
"-O1/-Os"="less fast".

The relative speed differences in MSVC settings seems to be somewhat
smaller (except /O0, which is also ~ 6M).

Though, this is for '/Os' and '/O1'; trying to test with '/O2' seems to
give broken output (the "should be" lines don't match up, then the
benchmark prints nonsense numbers and crashes). It is possible "/O2"
might be faster if it were working correctly in this case (well, and/or
it tries some rather misguided attempt to shove it into SSE instructions
or similar).

Not sure what is going on here exactly, usually GCC vs MSVC comparisons
are a lot closer than this (usually within 2x), and the effect of
optimization settings isn't usually so drastic. Both are targeting
x86-64, with GCC and Clang running in WSL.

But, in any case, a conservative estimate here would be 55000x to
225000x vs the 704...

If one is measuring floating-point, SIMD, ..., it is likely the
difference would be much bigger (well, and my PC has a lot more cores, ...).

*1:
Would measure JIT'ed speed for BJX2, except my JIT is kinda broke, and
my emulator isn't particularly fast due to its efforts to be
cycle-accurate (so I can't really crank it and still get real-time,
unless I go and fix these parts; otherwise it is painfully slow).

Doing a "what if" (sub real time emulation for BJX2):
1.0 GHz would give ~ 1.6M;
3.7 GHz would give ~ 5.9M.

Scores would be ~ 1.9M and ~ 7.0M if one models a 2-way (fully set
associative) L1 (rather than a direct-mapped L1).

Or, 2.0M and 7.2M if one assumes a 100% hit rate for the L1 caches.
Note that the emulator assumes a stalling pipeline, with fairly strict
interlock handling (interlock penalties are the main source of missed
clock-cycles behind cache misses).

Values seem to scale fairly linearly relative to clock speed.

Though, I still kinda suspect BGBCC is still pretty buggy here, and
could do a bit better here.

And recently I have been off trying to track down a bug where the
relative order of "when" type promotions are performed seems to change
the results of arithmetic expressions, which should not happen. I have
also seen some stuff that seems "rather suspicious" regarding register
allocation and write-back (in particular, that disabling some
optimizations to skip needless register spills leads to the compiled
programs crashing, which implies "something has gone wrong"; it would
appear as-if something is amiss with how temporaries are being assigned
or used, but some attempts to add "sanity tests" haven't turned up any
hits, such as the compilers stack machine encountering "free"
temporaries having been pushed onto the stack, ...).

I guess it is an open question how well the ISA could do "if my compiler
weren't buggy crap".

....

1
server_pubkey.txt

rocksolid light 0.9.7
clearnet tor