PERFORMANCE - Comparison of windows 2000 and linux

PERFORMANCE:
Performance benchmarking is subjective. So the only way of proving this is to try two systems and compare the response time, the requirements, and ultimately, the cost; even if Linux systems were to run half as effectively as a Windows equivalent, the low cost of implementation still means that a solution involving two systems will work out cheaper to install and maintain. There is currently almost no situation or scenario that shows Linux to be anywhere near as poor in performance as half that of an equivalent Windows system - the balance lies very much in the opposite direction.
As a direct comparison, using equivalent hardware in both, it has been shown time and again that Linux will not only install, but perform adequately, on a system that Win2k will not even be able to grace with its presence. It of course depends somewhat on the requirements. Though, Windows 2000 has brought the Windows family to almost the same level of reliability as Unix systems, making it a potential contender for deployment as a server, but in the server room, there is very little Linux systems cannot do more efficiently than a Windows system, and at a far lower cost. However, major omissions from an administrative point of view in Windows include granular system automation and scripting support - it is difficult to run scheduled tasks more than once a day.
Given below are some of the performance comparisons:
STABILITY:
When compared to Windows Linux is far more stable. Windows NT has 16 million lines of code while Windows 2000 has 32 million lines of code. This large size mainly contributes to the instability of Windows 2000.
PLUG ’N PLAY:
As we all know Windows supports, in majority cases, the policy of plug and play but Linux, as it all started from scratch, still lags behind windows 2000 in this aspect.
SYSTEM RESILIENCE:
While comparing these two operating systems on the system resilience functions like the component failure resilience, dynamic reconfiguration and such functions, Windows 2000 looks ok while Linux is still developing.
WORK LOAD MANAGEMENT:
The work load management in both the operating systems is developing and for both these systems, it can’t be stated that the workload management has reached an appreciably enough state.
PARTITIONING SUPPORT:
Both the systems in this aspect works fine.
WEB SERVICE SUPPORT:
The web service support for these two operating systems is good as both these systems provide a good IP support, IP multi-path routing and such things but the web application server availability is just ok with Linux with PERL and J2EE but it is very good with Windows 2000 with. NET. Both these systems provide a good heterogeneous platform interoperability.
FLEXIBILITY OF COMMANDS:
The Linux commands are highly flexible. In Linux, unlike Windows 2000, for example, each task does not have it’s own command. Users can extend commands to perform tasks that were not thought of by the programmer. For example, the user can issue the copy command and then rename the destination file so that one command actually copies and renames a file at the same time. However, in Windows 2000, a user has to copy a file to the destination and then open up
the destination location and then rename the file. The steps required to do certain tasks are reduced because of this command extensibility that Linux provides with pipes and redirection.
COMPLEXITY:
The extensibility that Linux provides gives a way for users to perform complex operations using the same commands that they use for simple tasks. Linux provides a way for users to combine two commands using pipes or redirection, whereas in Windows 2000 this type of command-combined operation is almost impossible. For example, to search for a particular process id of a command that you have entered in Linux, you can type ‘ps –e | grep “”’, which would filter the output of ps and display only results that match , which makes it easy for the user to see the process id without having to look through many of them. In Windows 2000, however, the user has to manually search for the process id using the list of processes that is displayed in the Windows Task Manger.
SPEED OF EXECUTION:
Power users who probably know most of the important commands would be able to work quickly in the Linux environment as opposed to the Windows 2000 GUI. For example, if a user wants to move a file, he has to make sure they can see the source and destination and then they have to drag the file from one place to another. In the command-line however, the move command is called and the source and destination are passed in one line as arguments— something that is faster for a power user to do. Most tasks can be completed quickly and correctly because of the way the commands are designed. For example, deleting a file in both environments would cause the system to display a command confirmation before actually deleting the file (even if the user picked a time-saving shortcut method to delete the file).
For example, in Linux there exists a ‘kill’ command to end currently running processes. If a programmer were to implement a different way of killing threads, for instance, then he would be forced to use a command like ‘killt’ instead of ‘killthread’ because the former is easier to type and could save time and user performance even though the latter is easier to remember. However in Windows 2000, since commands are usually labeled according to full phrases, one could implement a “Kill Process” and a “Kill Thread” button that is easy for the user to remember and recall.
The really compelling reason to use Windows 2000 in the server room is for the speed of application development, especially in the areas of web and web-enabled desktop applications. Active Server Pages coupled with SQL server and IIS allow us to rapidly churn out web applications.
|