Metrics
Metric index
There Are Four Key Performance Metrics That Most of You Are INTERESTED IN AS You Develop your XML-based Web Application:
When developing XML-based web applications, most people are interested in the following four main performance metrics:
· Working set: The peak amount of memory used by MSXML to process requests Once the working set exceeds available RAM, performance usually declines sharply as the operating system starts paging memory out to disk..
• Work Set: MSXML Processing Peak Memory Space. Once the processing space exceeds the available RAM, the operating system scheders to disk, and performance is usually dropped sharply.
· Megabytes per second: Simply a measure of raw speed for a given operation, such as the document load method By itself it is interesting, but to get the real picture for a production application, you really need to consider the next two metrics as. Well.
• 100Mb bytes per second: simply measure the speed of a given operation (such as a file LOAD method). But in practical applications, you also need to consider the following two measurements.
· Requests per second:. A measure of how many requests the XML parser can handle per second An XML parser might have a high megabytes-per-second rate, but if it is expensive to set up and tear down that parser, it will still have a low throughput in requests per second. This metric can help you calculate how many clients your server can handle under a peak load. Obviously, this depends on how heavily the clients are going to load up your server. For example, if the clients Hit The Server at a peak rate of one request per second, and if the server can do 150 requests per second, the server can probably handle up to 150 clients.
· Number of requests per second: used to represent the number of requests that the XML parser can process per second. An XML parser may have a high amount of 100m per second, but if the cost of initialization and closing the parser is large, then its second processing request number is still very low. This metric can help you calculate how many customers can accept under peak loads. Obviously, this depends on the frequency of the client access server. For example, if each client clicks on the peak of the server is a request per second, the server can handle 150 requests within a second, then the server can handle 150 customers at the same time. · Scaling: A measure of how well your server can process requests in parallel If your server is processing 150 client requests in parallel, then it is doing a lot of multi-threading Processing 150 threads in parallel is rather much for one processor,.. Which Will Spend A Lot of Time Just Switching Between these Threads. in this Scenario, you might add more processors to the computer to share.
• Scalability: This is the ability to demonstrate the server parallel processing request. If your server can process 150 client requests in parallel, it will handle many threads at the same time. 150 threads in parallel have a large load for a processor, and most of the time is consumed on the thread switching. In this case, you must add more processors to assume the load.
For example, a quad-processor server would need to process only 37 threads per processor-a more reasonable amount. (Scaling beyond this can be done with Web farms.) The goal is to scale linearly with the number of processors you add (for example, a quad-processor server should be four times faster than a single-processor computer). However, this is rarely achieved because there is usually some sort of contention for shared resources, such as memory, file system, registry, and network. Most components also contend for their own internal shared resources (for example, a global state that is protected by locks). Typically, when you add processors, scaling problems become a lot more obvious. for more information on scaling up and scaling out, see The duwamish diary column.
For example, for a four-processor server, each processor only needs to process 37 threads, which is a more reasonable amount. (Web Farm can be used to handle higher levels of scalability.) Our goal is to make the increase in the number of processors and performance to be proportional (for example, the server of a four-processor should be faster than the single processor computer. Time a time). However, this is usually not done because there are still many types of content to share, such as memory, file systems, registry, and networks. Most components also compete for some internal shared resources (for example, a global state is locked). Usually, the scalability problem becomes significantly when you increase the processor. For more information on more scalability, please check the column articles of Duwamish Diary. Disclaimer: I want you to understand that the numbers published here are not official in any way, but are intended to paint the overall picture so that you can get a feel for what kinds of things to expect and be able to make the right design choices While Building your XML Applications.
Disclaimer: I want you to understand that the data published here is not official, just to make you a global feel: When you establish an XML application, what you have to consider, what should I do, what should I do? select.
