Re: Linux betas NT in TPC testing, running Oracle8
Date: Fri, 07 May 1999 15:13:11 GMT
Message-ID: <7guvu2$bi9$1_at_nnrp1.deja.com>
In article <m1emkwpwy5.fsf_at_inconnu.isu.edu>,
Craig Kelley <ink_at_inconnu.isu.edu> wrote:
> r.e.ballard_at_usa.net writes:
>
> [snip]
>
> > It isn't a true "conspiracy", but the folks who audit these results
> > cannot accept the Linux terms as legitimate results. If one were to
> > consider only the raw hardware costs - which could be competitively
> > obtained for $50k-$60k and the software costs which are in the $2k
> > range, and the mainenance contracts available from companies like
> > Flagship ($6,000-$20,000 for 5 years) this is typical of Linux
> > "bargain basement" environments, a total of $80k. If Linux were
> > able to crank out 8,000 TPC/M (plausable when you compare the SCO
> > numbers), then Linux would still be in the $10/TPC range. Just
> > looking at one of the "low-end" NT machines, it's easy to see how
> > Linux could generate some rediculously low $/TPC numbers. NT
> > generates $30/TPC with it's bottom of the line systems.
>
> And in this day-and-age, benchmarks are becoming worthless. If they
> were so important, nobody would even use Windows NT, Microsoft's SQL
> Server or MySQL. People want *reasonable* solutions to their
> problems, both in terms of performance and price. Linux only needs to
> meet this requirement in order to satisfy the majority.
It's rather interesting that when you Compare Linux to NT using nearly any
metric other than training expense in the first 60 days, Linux comes up a
clear winner. This goes beyond simple benchmarks as well.
Web Server Benchmarks - Linux carries as much as 8 times the capacity
of Windows NT. At very low levels, NT gives
slightly better response times, but Linux/Apache
response time is nearly flat or linear while NT
deteriorates at an exponential rate.
Availability - NT Availability has improved from 95% in 1996 to nearly
99.7% in 1999. Linux has gone from 99.98% to 99.998% this means Linux is
down for about 5 minutes every 3 months. NT is down 5 minutes per week. In
response to Linux stability, Commercial UNIX systems are targeting 5
minutes/year.
Total Cost of Ownership (TCO). Due partly to the lower cost of Linux, but mostly due to the high reliability and "self sustaining" maintenence scripting, Linux has shown itself to be as much as 1/10th the cost of NT Servers. In the workstation environment, Linux has shown after the first 60 days, to be 1/5 the the cost of NT. Most NT TCO studies are limited to 90 days againts commercial UNIX systems such as Solaris, AIX, or HP_UX.
Total Benefit of Ownership (TBO). Again, due to the lower cost, high reliability, and low management costs, Linux has been able to pack "more bang per buck" into it's system. A reliable NT configuration requires separate router, firewall, naming service, web server, and database machines. Linux configurations can easily fit all of these functions into a single machine and still run reliably. Scalability. NT has a "scalability wall" of about 100 concurrent usersper machine. This assumes that each server is dedicated to a single function and that threads will be heavily used by the application (which means the application must perform buffer management, mutex management, resource control, and inter-thread communications functions (some of this may be supplied by libraries, but happens in the application process). As these machines are "daisy chained", the reliability goes down (any single machine failure results in a system-wide failure). WolfPack provides hot-standby, but no scalability gain because the hot standby system is passive. MTS improves thread management, but still lacks load balancing, cluster management, and fallback/recovery.
Linux has shown itself to be extremely scalable. Linux can run effectively on an 80386 machine with as little as 8 meg and a 20 meg hard drive (using network support). It can be scaled up to Alpha, UltraSparc, or PPC G3 chips with a gigabyte of RAM and both RAID in software and RAID in hardware, including multiple SCSI and network cards (ethernet or ATM). Linux also supports SMP systems of up to 16 processors and can run number crunching applications in clusters of over 128 processors. Linux alsosupports a number of pipelining and delegation models that allow it to scale to thousands of processors such as clusters used for cracking RC5 and DES messages.
Most important of course is that when the scalability walls of Linux are reached, the applications can be trivially ported to Solaris, AIX, HP_UX, or Digital UNIX as well as OS/390 Open Edition. A port from NT to these platforms requires total reengineering and a different programming staff (since most NT engineers can't grok the Linux/Unix programming paradigms - the try to use threads and shared memory instead of using forks and pipes.
> Back in the days of measuring CPU times to the cycle, benchmarks were
> shown to save money by increasing the longetivity of your hardware.
> Today, you just plunk down a few thousand dollars to buy more
> machine.
Unfortunately, this is exactly the thinking that allowed NT to become the bloated engine that it is. The Microsoft management assumed that memory would be cheap, cpu cycles would be cheap, and disk drives would be cheap. All three were correct assumptions, but because NT squanders these resources while UNIX and Linux implementations use them very efficiently, Linux running on the same hardware SEEMS 10 times faster. In reality, the key difference is that the NT system, at about 100 concurrent processess/threads/cursers... eventually goes into "digital gridlock" as application threads and processes queue up for mutexes that are locked by processes waiting for disk drives, network responses, and user input. Eventually, the NT system degenerates into either a deadlock situation (resulting in undetected seized processes) or a race condition (Blue Screen of Death).
Unfortunately, throwing "bigger boxes" at a situation like this only makes matters worse. The same gridlock occurrs, but now you have more processors and memory "waiting for Godot - at the speed of light". The laws of physics limit the rotational speed of the hard drive. When the NT system deals with large objects, often over 1 megabyte/object, and each process or thread is dealing with as many as 3-5 objects, the system ultimately degenerates into paging, swapping, and heavy disk or database I/O. When the mutex locks are added to the mix, NT becomes either I/O bound, or memory bound (mallocs and frees).
Linux and UNIX rely on a "processes and pipes" paradigm that allows very small processes to communicate with each other through pipelines or streams of bytes that are often parsed into objects of less than 1 kilobyte. The kernel never needs to buffer more than 2 Kbytes/pipeline because the processess are parsing and processing output in small chunks.
A Microsoft application might use a SQL database to fill an excel spreadsheet which is then folded into a Word Document. A UNIX application could "grep" lines from a flat file, pipe them to an awk script that would format the chosen lines into fields, perform statistical calculations a line at a time, and format the output into HTML tables which would be fed through the web server to the web browser. On a very small result set of 10-20 lines, for 10-20 users, the NT is a better choice and the Linux/UNIX system seems like overkill. When you are in the Internet environment with result sets of 200 hits, and you are concurrently serving 200-400 users, the Linux/UNIX approach gives you immense capacity with minimal overhead.
> Craig Kelley -- kellcrai_at_isu.edu
> http://www.isu.edu/~kellcrai finger ink_at_inconnu.isu.edu for PGP block
-- Rex Ballard - Open Source Advocate, Internet Architect, MIS Director http://www.open4success.com -----------== Posted via Deja News, The Discussion Network ==---------- http://www.dejanews.com/ Search, Read, Discuss, or Start Your OwnReceived on Fri May 07 1999 - 17:13:11 CEST