Today is ...

Well, what better way to start off my blog than to launch it concurrently with the new UltraSPARC T1 processor?

If you haven't heard so already, Sun is launching a new line of servers called the Sun Fire CoolThreads servers that feature the new UltraSPARC T1 processor. What is so cool about this server that it runs 4 hardware threads concurrently per core instead of sequentially. The results? Greater efficiency and throughput with much lower power consumption.

I'll leave the nitty gritty details about the chip to more qualified sources, but I wanted to blog about how this relates back to the work that I am currently doing with Java performance. I have been looking at XML performance with XMLTest, a benchmark we have been using to measure parsing performance with a different battery of XML documents. (You can get more details about XMLTest on java.net). Specifically, we have been measuring how different XML parsing technologies scale on the Sun Fire CoolThreads server: Sun's implementation of the Streaming XML API for XML (StAX) called Sun Java Streaming XML Parser (SJSXP), Java Architecture for XML Binding (JAXB).

I wanted to focus specifically on the scalability of these parsers on this server. What is scalability? In this case, I am focusing on vertical scalability. If I add additional processing power within the same server machine, can I get additional throughput for my application? This would depend on the ability of the application to take advantage of the additional processing power by running different threads on different CPUs (or cores) within the same machine.

If I can get linear scalability, what does this mean? This typically refers to the ability to increase the throughput of an application in direct proportion to the additional processing power added (eg. hardware threads). For example, say I can get a throughput of 40 transactions per sec with 4 threads. With perfect linear scalability, if I double my processing power to 8 threads, then I could expect to double my throughput to 80 transactions per second. Recall that with the new Sun Fire UltraSPARC T1 server, you get 4 threads per core. If you are concerned with throughput on a large server, this is a GREAT thing. I can adjust to an increase demand by simply adding processing power, which unfortunately, is not always the case. Bottlenecks may arise and decrease throughput with increasing number of processors which may be due different reasons such as lock contention.

So back to the XML processing world and the UltraSPARC T1 processor. As I mentioned before, this server runs 4 hardware threads per core. The 8 core machine that we used with 4 hardware threads essentially functions as a 32 way box! We have done experiments that show perfect scalability for JAXB and StAX as we increase the number of hardware threads. The figure below the scalability for JAXB1.0:





We used a 100KB XML document for this study. We did not need to adjust any Java tunings as we scaled up. With our initial tunings (-server option with JDK 1.5), we were able to scale the performance out-of-the-box. (For more information on the JVM and CoolThreads, please check out ions, take a look at Dave Dagastine and Brian Doherty's blogs)

You can expect more details about this in later entries, but the take home message is clear: with our benchmark framework (feel free to check out the code and take a look what we are doing under the covers), JAXB and StAX can scale linearly up to 32 hardware threads.

Comments:

Post a Comment:
Comments are closed for this entry.
About

klichong

Search

Categories
Archives
« April 2014
SunMonTueWedThuFriSat
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
   
       
Today
Bookmarks