Its time to revisit the the question, “How much compute/ RAM can we get in a 42U rack ? ”

Using the SunBlade 6000 chassis you can get 10 in Blades in 10U. When we fully populate the rack with T4-1B blades we get 40 SPARC procs @ 2.85GHz ( 2560 threads)

…and 256GB of RAM * 40 machines = 10240 GB of RAM i.e. 10TB !

Given the SPARC road map, and the likely doubling of the core count (achievable following a die shrink to 25NM) for T5 chips, we could see a doubling of that thread count!

Its interesting to think that these machines can saturate 10GBe easily with plenty of CPU time to spare. This in mind, that would be 80 *  10Gbe ports, so you’ll need some decent network equipment to keep all those machines fed!

Anyone working in a services / performance tuning role will quickly understand the value of the title.

For any problem solving to start, its critical for you to have a clear idea about what you think the problem actually is. That might sound obvious to you, but its very easy to get lost in someones description of  whats happening.

Imagine the scene where you get a phone call and someone says “you need to fix the network, it seems broken…”

What does that sentence really mean? You won’t find out until you start asking sensible questions about what the stakeholder is seeing. If the user was on a 10/100 Mbit and they were seeing about 10-12 MBs a second then thats probably about as fast as its going to go (note Mbit vs MB). To get over this “problem” we have to make a decision; compress the files, use a different machine etc etc.

Until you know the root cause of the problem, you can’t suggest a fix. You can’t even mitigate the issue.

Let’s say the above network was using an ACME switch, known to not be fully non-blocking. If you don’t know how much bandwidth is in use, then can you say for sure that just swapping out the switch for a brand new switch (of the same model) is going to fix it? No. So if you did that, you’d be swapping out a perfectly ok switch for a brand new one which is going to experience exactly the same behaviour.

Below is a video which is ficticious scenario, but fairly realistic. A user calls up and complains about the website being “down”. The webserver seems to be working, but he user insists that an action be taken. The analyst doesn’t take the time to actually determine what problem the user is seeing, and instead simply complies with the request to action. Watch the video to see the rest!

Jumping to cause broke the website completely, and could have been averted if the analyst stuck to his guns and produced a proper problem statement and description.

Keep in mind that the true root cause will explain the symptoms that are seen. So when someone makes a suggestion about what the cause could be, test it against the specification and see if it seems true.

Well, its a while now but new hardware has been anounced and it really is quite impressive!

Key Stats

Theres more than the list that I’m showing, but theses are the most interesting ones. Among other bits are the X4170, X6270 and some new NEMS for the SunBlade 6000 chasis.

X4800

• 5 Rack Units high
• 1 TB of RAM (With 8GB DIMMS, 128 slots)
• 4 or 8 * Xeon 7600 CPUS (each with 8 cores)
• 8 PCIe slots
• Up to 8 * 300GB   2.5 inch SAS-2 disks
• Two NEMS, each with four 10Gb Ethernet ports
• Redundant power supplies

X4470

• 3 Rack Units high
• 512 GB RAM (with 8GB DIMMS, 64 slots)
• 2 or 4 Xeon 7500 series CPUS (each 8 cores)
• 10 PCIe slots
• Up to 6 * 300GB 2.5 inch SAS-2 disks
• Redundant power supplies

X4170M2 / X4270 M2

• 1 and 2 Rack units respectively
• Up to 12 * 300GB SAS-2 2.5 inch , or up to 24 * 300GB SAS-2 2.5 inch disks
• 2 CPUs each
• 144GB RAM each
• 4 Gb Ethernet onboard each

These images were shamlesly copied from www.c0t0d0s0.org, who also wrote a far better artcile than I did!

Well, it appears that google chrome is faster than alot of things. Namely:

1. Potatoes fired from a cannon
2. Paint shot by sound wave energy
3. Lightning striking a little ship (big ships untested)

All is explained and proved in the following little video. Credit to the editor of this filming, but I do have to say, the final test doesn’t look 100% fair, the mouse may have been clicked a split second too soon.

“:” is a little known Bourne Shell operator which is actually quite handy. However, like a alot of other short hand operators, its easy to forget, especially when its not used that much.

So what can it do?

• You can replace the true command with it, letting you write something like:

while :
do
some_commands
done


• Leave the then part of an if statement empty:

if :
then :
else :
fi

I agree, that example is probably useless for now, but amusing none the less.

So there you are! Next time you fancy steering from the norm of using true, you know what to do!

Oracle recently made a set of presentations which outlined what their strategy was in terms of hardware, software, markets etc.. Each speaker had a slide show to accompany their talks, and each of the slideshows was quite extensive.

Well, all but one. Larry’s!

His slideshow has one slide; a picture of a racing yacht with Oracle and Sun logos on it! This for me sums up his character. Hes got a ton of energy and sees his company more like something that he needs to guide and be successful with, and at the same time looks good whilst doing it!

In this respect, Oracle have made it very clear what they want to do with the portfolio they have acquired from Sun, and this does include investing heavily in SPARC processors. Given the kind of performance we saw with the T1000 on Heanets review, I’m personally looking forward to the day when Oracle manage to further commoditise this cool hardware

This little box seems to be quite far ahead of its time. I can imagine that there must be so many futurologist out there just waiting to see their ideas come into the mainstream, and then jump for joy when it finally does!

It has been announced today that approval has finally been given for Oracle to merge with Sun Microsystems. The process began in September 2009 which means that its been long enough for plenty of rumours to go around about whats going to happen both internally with head count cuts, and of course with the product line itself. Most importantly, the people with power to make decisions in these two structures now actually have the opportunity to go ahead and make those decisions.

If Larry is true to his word about what he sees for the future of the Sun product line, I for one would certainly say that the future is going to be fairly bright.

Mr Ellisons (CEO of Oracle) own words:

“We are keeping everything. We are keeping tape, we are keeping storage, we are keeping x86 technology, we’re keeping SPARC technology, we’re going to increase the investment in it…”

“…we are NOT going to spin anything off.”

The discussions about improving data center power consumption efficiency and increasing demand for online services place the T-series equipment very well for those who know just how good they are. Coupled with the fact that Sun had famously invested early in the R+D for this kind of technology, theres also a great opportunity to get OpenSolaris beefed up in terms of packages and installers, and deployed in these environments.

I’m looking forward to seeing how its all going to pan out!

Python comes with an HTTP server built in, making sharing directories on your *nix machines as easy as:

anton@opensolaris:~/mess/test$ python -m SimpleHTTPServer
Serving HTTP on 0.0.0.0 port 8000 …
localhost – - [26/Sep/2009 00:23:47] “GET / HTTP/1.0″ 200 -
localhost – - [26/Sep/2009 00:24:24] “GET / HTTP/1.1″ 200 -

So now when we go to localhost:8000 , we get the directory!:

anton@opensolaris:~/mess$ lynx -dump localhost:8000
Directory listing for /
__________________________________________________________________

* [1]lalala
__________________________________________________________________

References

1. http://localhost:8000/lalala

…or…

anton@opensolaris:~$ lynx -source localhost:8000
<title>Directory listing for /</title>
<h2>Directory listing for /</h2>
<hr>
<ul>
<li><a href=”lalala”>lalala</a>
</ul>
<hr>

…for those of you that want to see the source it produced! A very quick short term solution if you don’t want to go about setting up apache or change your apache settings!

Ten days ago we had a look at Java’s ability to deal with numbers which had alot of decimal places. Liam pointed out that having to loop through a variety of operations is longer than performing a more efficient operation once.

With Liams magical formula, we get the following Java, with no loop:

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
31

import java.math.BigDecimal;
 
public class The_proper_half {
 
    public static Integer times_to_loop;
 
    /**
     * @param args the number of times you want to run the loop
     */
    public static void main(String[] args) {
        calculate(Integer.valueOf(args[0]));
 
    }
 
    public static void calculate(int times_to_loop) {
        //The Number we want to half
        BigDecimal number_to_half = new BigDecimal("10");
        //The result of doing the half
        BigDecimal the_half = new BigDecimal("0");
        //The number we want to divide by
        BigDecimal divider = new BigDecimal("2");
 
        the_half = (number_to_half.divide(divider.pow(times_to_loop)));
 
        System.out.println("The last number has " +
                ((Integer) number_to_half.subtract(the_half).toString().length()
                - 2) + " decimal places: ");
 
        System.out.println(number_to_half.subtract(the_half));
    }
}

As you can see, we only perform the opertation once (line 23), but admitadly, to get the correct number at the end, we still do the subtraction at the end!

Regarding optimisation, there are huge benefits. It turns out that the old way if hugely costly for thousands of iterations. These are the results for 10000 iterations, the old way:

anton@anton-laptop classes $ time java Half_of_a_half 10000 > /dev/null

real    5m22.714s
user    5m21.320s
sys    0m1.052s

The results for the new way are much better:

anton@anton-laptop classes $ time java The_proper_half 10000 > /dev/null

real    0m1.019s
user    0m1.248s
sys    0m0.052s

So it went from over five minutes, down to just a second. That was just by changing from a loop a single statement. Thats pretty cool stuff!

I have to admit here, the difficult bit is probably not the code. Its the abillity to see how a problem may be translated from one way of expressing it to another. Its that bit of genius thats really done the work here. Credit to Liam for the genius!