Last 2 digits of OEM String – Carrier
00 – Unlocked
21 – O2 UK
31 – AT&T
32 – Rogers
33 – T-Mobile

Enjoy,

Karl

I discovered quite by accident that the Clockwork recovery image allows adb to connect to it while sitting at the recovery menu. The adb shell is a root shell. You can use clockwork to mount whatever filesystems you may need to work on. This means that you can take any of the su binaries floating around the net, or even hack a bit and then build the su thats in the Android tree,  and dump it in /system/bin/su while in the recovery menu and then chmod it 4755 to suid it root.

So basically:

• boot nexus S into fastboot with vol up and  power
• pick recovery off the menu
• from the recovery menu:
  • mount /system partition
• from adb:
  • adb push /path/to/your/su/binary  /system/bin/su
  • adb shell
    • chmod 4755 /system/bin/su
• from the recovery menu:
  • reboot device

When the handset comes back up, adb in as normal, and then issue an su command and you should be root.

>>>Karl

I’m assuming you have basic knowledge of how to use EC2, but if not, in very very generalized terms (and from memory):

• Go register for an account
• Add EC2 to your account
• Select the EC2 dashboard.
• Select volumes and create an EBS volume for your build partition.
  • I used a 50G partition
• Select AMIs and search for the particular flavor of Ubuntu you’re after
  • You may need to change the filters at the top of the results box to get it to display all of the options, I believe it defaults on just your own.
  • I used 10.04 64 bit ami, specifically ami-be0ffed7
  • Make sure its an EBS ami and not an instance image, the difference being the EBS is permanent and your changes will not be lost across reboots
• Hit the launch button and then answer the questions about the type of machine you wish to run on.
• You will need to create a set of keypairs used to log in to the machine once its up on the network.
• You will also probably be asked questions about the security groups at some point during the question and answer process. 
  • All I did for my EC2 instance was add ssh so I could get into it remotely. For all I know I’ve left a truck sized security hole in the config.
• Go back to the volumes and associate your build partition with the AMI you just built. It will ask you to assign a device path, I used /dev/sdf
  
• At some point on the instances panel you will see that your instance is up and running, select the instance, select actions and pick connect. Follow the instructions and log in.
  • use the user ubuntu and not root.

By now you should be sitting at a prompt on your freshly started instance. Go ahead and label, mkfs, and mount the build volume and then cd into that partition.

I originally used the instance hosts instead of the EBS hosts, so I had to rebuild the environment every time I used the instance. I’d since figured out how to use an EBS ami but I’d done it so often that I’d written the script below to handle installing all the packages that were required. I pulled the java package from java.sun.com.

#!/bin/sh

#update the repos, I had some issues with the ec2 default ubuntu repos, this fixed it.
sudo aptitude update

# any bitness
sudo apt-get install git-core gnupg flex bison gperf libsdl-dev libesd0-dev libwxgtk2.6-dev build-essential zip curl libncurses5-dev zlib1g-dev

#generally useful for all
sudo apt-get install valgrind

#64bit
sudo apt-get install ia32-libs lib32z1-dev lib32ncurses5-dev gcc-multilib g++-multilib

#java
echo “Installing already unpackaged java to /usr/local/”
sudo tar -cpvf – jdk1.5.0_22 |sudo  tar -C /usr/local -xpf -

echo “Adding export JAVA_HOME=/usr/local/jdk1.5.0_22 to your .bashrc”
echo “Adding export ANDROID_JAVA_HOME=\$JAVA_HOME to your .bashrc”

echo “export JAVA_HOME=/usr/local/jdk1.5.0_22″ >> ~/.bashrc
echo “export ANDROID_JAVA_HOME=\$JAVA_HOME ” >> ~/.bashrc

echo “Updating your path”
echo “export PATH=/build/codeaurora/prebuilt/linux-x86/toolchain/arm-eabi-4.4.0/bin/:/usr/local/jdk1.5.0_22/bin:$PATH” >> ~/.bashrc~

Now you should be able to checkout and build whatever flavor of Android you’re working with. I used the froyo-almod from the codeaurora forums.

>>>Karl

majer@ubuntu:~/android$ sudo ~/bin/adb devices

List of devices attached ????????????    no permissions

After a considerable amount of digging I found the one line change that needed to be made on both OSes. Add the following to /etc/udev/rules.d/51-android.rules:

SUBSYSTEM=="usb", SYSFS{idVendor}=="0bb4", MODE="0666"

And then restart the adb services with a:

[majer@ubuntu:~/android/] sudo ~/bin/adb kill-server

[majer@ubuntu:~/android/] sudo ~/bin/adb start-server

The adb command will work as expected now.

>>> Karl

Context is everything with this device. If you were hoping to replace a laptop or skip out on getting that netbook by buying an iPad, I’m afraid you’re in for a rude awakening. I have gotten in the habit of reading technical manuals on my laptop prior to going to bed at night. I wanted to simplify things and purchase something smaller and lighter to let me continue my light reading in the evenings. I contemplated buying a Kindle at first, but decided to hold off after Apple first made mention of their device.

With that point of view in mind, the device has been quite successful in meeting, if not exceeding, my expectations. I have iBooks, Kindle for iPad, and GoodReader for iPad installed on the iPad and between the three applications, there is little I cannot read. I do wish that the iTunes Bookstore carried technical books, but I can always pull down the kindle versions of those, or buy pdf versions and view them in GoodReader.

Just a quick kudos to the GoodReader guys. The app offers almost a dozen different ways to get data into it from your iPad. When I first tried it, I was having issues with the iTunes integrated sync, but then realized that the app has an integrated webserver that can be connected to as a network folder (I’m on a mac) and then it was literally just drag and drop. I’ve also have yet to find a pdf that it can’t open and read. Well done guys.

So, using the iPad as an ebook works splendidly. The screen doesn’t require ambient light like the kindle does, and the controls on the various readers let you adjust the brightness/contrast as needed. I’ve already chewed through a few books in my nightly habit of reading for at least an hour.

As to the bonuses, the iPad is just the right size to comfortably lay in bed and watch content from iTunes U. Some of the Stanford lectures are outstanding and are free as an added bonus. I have also found its just the right size to keep up with my RSS feeds that I tend to consume as well. And when I feel like relaxing, the free Netflix client (account required) streams a decent selection of movies right to me.

There are a few downsides. The iWorks suite that can be purchased is tolerable at best on the virtual keyboard. I’m used to Excel and so caught a double whammy with the mind shift to how Numbers does things, and not having a full keyboard for data entry. Keynote was actually the best of the three, I was able to throw together a quick presentation without too much effort, and Pages works fine for a quick note, but I wouldn’t want to try and take notes in a class or a meeting on the device. I can almost touch type on the virtual keyboard until I hit a need for a special character. Then you’re flipping to another keyboard screen to get access to those. They should really move the apostrophe to the first keyboard.

So as I said, based on what I intended to use the device for, the iPad exceeds my expectations. I know there are other people whining about not being able to code on it, and/or it still being limited because its running iPhoneOS instead of MacOSX (which would have absolutely rocked), but frankly, at the end of the day I’d rather read a book than stare at more code.

>>> Karl

OSX 10.6.2 + SCR3110 CAC reader + new GX4 CAC card == No love on OSX. Keychain sees the card as empty.

However, 10.6.2 + VMWare + win7-64 + reader + CAC card + IE works just fine without any of the add-on software used on XP. You’ll need to pass the reader through to the VM by clicking on the little USB icons in the bottom right.

On another note, a Verisign EAC Certificate loaded in your keychain will cause codesign to hang for 8-10 minutes while it asks oscpd to validate the cert. This also happens when you use Keychain Access to go try and figure out why its taking so long to sign things. Work around it by either dropping your network when you need to sign things, or more permanently, drop your network and then use Keychain Access to remove the cert altogether. Save yourself the pain and load the EAC cert directly into firefox and use that browser to access the EAC enabled sites.

And finally, if you have the reader plugged in with a card in it and try to sign an iPhone application you will probably get the error: CSSMERR_DL_MISSING_VALUE. Keychain Access on 10.6.2 recognizes the reader and if the card is plugged in, Keychain Access seems to want to try and use it for signing. Take the card out of the reader and try again.

>>> Karl

Client Side:

Wget – A non-interactive command line tool to fetch https, http, and ftp items. It can easily be run from inside a script in a tight loop or used in recursive/mirror mode for crawling. It can be found at http://www.gnu.org/software/wget/.
cURL- Another non-interactive command line tool. Much more extensive in its protocol support. Available from http://curl.haxx.se/. This tool was designed to fetch single URLs. It requires integration into a script to mirror/copy websites if such a behavior is desired.

The server side has several options depending on the OS being run. There are a few commands that are present on all OSes by default, and then there are OS specific commands as well.

Server Side:

Iostat provides thorough IO statstics for the machine. The command is native on Solaris as well as linux with the installation of the sysstat package. After watching the output run over time you can tell if the disk is lightly used, overloaded, or somewhere in-between. You can also tell if the drives are overwhelmed with many small transactions or content with large streaming writes. This is a good all round tool to get familiar with.

Next in line in the *stat family is vmstat. While iostat gives us a view into the disk subsystem, vmstat provides similar insight into the memory subsystem on the host. The command is natively present on Solaris and Linux. Vmstat is capable of showing you statistics on swap, memory paging characteristics, memory fault characteristics, and some additional information about run queues on the machine and CPU utilization. This is another good general tool to be familiar with.

Top is the next tool I used, and is probably the single most popular tool for getting an at-a-glance view to what the system is doing. It is a curses based application that periodically updates itself and constantly shows the top 20ish running items sorted by CPU utilization. While present in Linux, the application is not in the default Solaris installation. www.sunfreeware.com offers the package for download. Top typically requires minimal skill to interpret its output which makes it a good first line tool to see why a machine is behaving oddly.

Solaris offers two additional tools for observing system behavior: prstat and mpstat [edit: Seems Linux offers mpstat as well. It contains similar information to the Solaris version].

Prstat is very similar to top and shows the top 20 or so processes by CPU utilization but through various command line options, can provide insight into threads and offer microstate accounting information as well.

Mpstat is more in line with the vm/iostat line of commands and shows per cpu, or processor set, statistics such as context switches, systems calls, etc. The command can be used to determine if an application is thrashing the cpus in the machine or generally what the machine’s CPUs are doing.

Netstat is a utility which allows the user to see what the network stack on a machine is doing. It is useful for looking at the number of open sessions as well as the number of sessions in TIME_WAIT.

Finally, the sar command is also available to see what a given host is doing. The command is natively present on both linux and solaris. I personally tend not to use that as I can generally determine what I need from watching the *stat commands .

There is one additional tool which I use on Solaris and OSX, and that is dtrace. Dtrace is capable of instrumenting virtually anything on the fly and can provide amazing insight into what an application, or even the host, is doing at that moment without resulting to the instrumentation of binaries or adding typical splatterprint debug code to the binaries.

Essentially, I use the commands in approximately this order: top/prstat first to get a general overview of what the machine is doing. For more insight I open additional sessions on the machine and run iostat, vmstat, netstat, and possibly mpstat if available. Finally if I’m still unable to determine what the host is doing, and the server is running Solaris or OSX, I’ll use dtrace to look into the kernel or at the application for insight into whatever problem I’m chasing.

Whichever commands you decide to use, and whatever order you run them in, keep in mind one important point. Observing an experiment can affect the output of said experiment. This means that running all of those tools on a very burdened server may be enough to push the machine over the edge of unresponsiveness.

This concludes our brief introduction to the tools of the trade. If there is a demand and time permits I intend to write articles on the best practices for each of the commands.

If you like what you’ve read, please share the blog with others. If you have any questions or comments, feel free to send me email at kmajer at karlmajer dot com.

There is nothing stopping a tester from performing their load test using a browser or other GUI based load generation tool. Providing the tool has some manner of minimal controllability and repeatability, feel free to use any tool you so desire. Should you choose to use a browser, such as Firefox, be sure to recognize that the plugins are capable of altering the behavior and characteristics of the browser considerably and all future testing would need to be done using the same exact browser, machine, and plugin combination for the numbers to be comparable.

Essentially, I choose to use a CLI tool, such as wget, because it behaves the same every time and I can wrap the application in a shell script to guarantee both the same behavior, and instrument things further.

Second, the first cut performance numbers. When trying to rapidly determine a speed of light, its more important to get to the right magnitude first and then refine than it is to try and get the exact answer on the first pass.

For example, we know that we cannot move more packets across the network than we can fit through a single network interface. Therefore, if the size of the interface is N bytes per second, regardless of what we do, we will never be able to push more than N+1 total bytes through the interface. Similarly, if we know that we have M sized pages, then we will never be able to push N/M pages through the interface at a single point in time.

What this does for us is provide an upper bound for our testing. If our results indicated that we were able to do N/M + 5302 transactions per second, we know know that something was wrong with our calculation as those last 5302 operations/second would simply not fit through the pipe. However, if our results indicated 5302, and N/M is 8192, then we know that our result is a reasonable number.

It is important to obtain the speed of light at the start and then refine using the bounding boxes we know to be true. This ideal holds whether testing network, disk I/O, cpu, etc. If we know what the fastest possible speed of a given component is, then we know that if our results report numbers faster than what we know to be possible, then we must question the results and find them to be true because of another reason, or discard them and start over.

And a few thoughts just to provide a bit of context as to when speed of light may be false. When testing disk I/O, if the file size is sufficiently small, the file will be loaded directly into the buffer cache. This is a section of machine memory dedicated to buffering all disk I/O transactions and provides access times and speeds comparable to system memory and not the disk subsystem. Ie, the speed of light for the buffer cache is based off of a 50ns access time and not an 80ms access time.

I’d like to thank the reader that brought the questions to me and invite others to comment or email me with any questions they may have. I can be reached at kmajer at karlmajer dot com.

>>> Karl

The developers you support as a systems administrator are considering moving the static content for the company website www.somefamoussite.com to its own webserver to free up resources for the dynamic page generation and generally speed things up. They are curious how fast an apache serving only static content will be able to serve requests.

In order to accomplish this task, we must examine the steps of the scientific method and see how each plays its part in providing us a sound and thorough roadmap to provide the developers with their answer.

1. First, define the question: “How fast can an apache webserver go serving static content.”
2. Next gather information and resources:

It would benefit us to know the number of static items and the size of them to determine how best to answer the question, so we ask development that question and are handed a tarball containing 256 images with an average size of 6k each.

Since we setup the hardware that is being used, we know that the servers have gigabit ethernet cards in them. We also expand the tarball into the tree on our webserver and use a find to create a logfile full of relative links to use to fetch the static content.

find . -type f | awk ‘{print “/path/to/images/$1”}’ > logfile.out
cat logfile.out logfile.out logfile.out logfile.out > logfile.1k
cat logfile.1k logfile.1k logfile.1k logfile.1k > logfile.4k
cat logfile.4k logfile.4k logfile.4k logfile.4k > logfile.16k

3. Form the hypothesis:

Based on an average size of 6KBytes, and knowing that the hardware has gigabit ethernet, we can compute that in lab conditions with perfect network, the machines can do no more than approximately 21,845 requests/second.

( (1Gbit/sec == 128 MBytes/sec) / 6KBytes avg size == 21,845.3 objects/sec)

Our hypothesis, therefore, based solely on the network capacity of the hardware, is “A server can do no more than 21,845 operations/second.”

4. Perform the experiment(s) and collect data:

You’ll want to run top on the webserver to get a rough idea of how much free cpu there is.

Copy the logfile.16k to each of the load generators. In this example there will be 4 load generators.

Use wget on one of the load generators to mark the logfile with something we can search for later.

wget http://www.myserver.com/images/TESTSTARTEDHERE

Use wget on each load generator to fetch the images

wget -i logfile.16k -o wget.out

Fire off all four wget’s at the same time and let it run.

Watch top running on the webserver and keep rough track of our idle cpu. Time passes and the load generators will eventually run out of logs, probably within a few minutes.

Use wget to mark the logfile again.

wget http://www.myserver.com/images/TETENDEDHERE

5. Analyze the data:

With each load generator having a 16k logfile, we had the potential load capability of 64k instantaneous requests. This is unlikely, however, as there is a certain amount of overhead between requests that must be accounted for. A reasonable assumption would be that each generator could generate close to 8k instantaneous requests, the four of which still totaling over the ~22k maximum of the network.

Using the logfile from the apache we can determine how much traffic we received.

First use sed or perl or your language of choice and extract the logfile.

sed -n /TESTSTARTEDHERE/,/TESTENDEDHERE/p access.log > test.log

Next determine the starting time by looking at the next line after STARTED line in the test.log and looking at the timestamp on the line

head -2 test.log

Do the same for the ending time by looking at the second to last line of test.log.

tail -2 test.log

Determine the total test time by subtracting the two times from each other.

Determine the total number of lines in the logfile and removing 2 for the header and footers.

wc -l test.log

This will likely be 64k unless you interrupted the test prematurely.

Now extract the successful image retrievals using grep.

grep “HTTP/…. 200” test.log > 200.log

Count the number of successful requests

wc -l 200.log

Now compute the average request speed

Good Requests / Total Time in minutes == Average Good Requests/Minute

Next, determine the number of requests per unit. Typically a 5 minute unit works best but for simplicity we will use a 1 minute unit.
Extract column 4 (the timestamp in a CLF apache log) from the 200.log file

awk ‘{print $4}’ 200.log > timestamp.out

Truncate the seconds from the logfile using either cut or awk

cut -d: -f 1,2,3 timestamp.out > trunctime.out

Uniq and count the truncated timestampts to get the number occuring during each minute:

uniq -c trunctime.out > counttime.out

Now reverse the two columns to make the graphic easier and add a closing bracket.

awk ‘{print $2”] ”$1}’ counttime.out > graphdata.out

It is now possible to look through the logfile at this time and see a rough estimate of how the webserver did, however it is more valuable if we can graph this data and examine it visually.

Import the data into excel, pages, or use gnuplot on the command line and plot the graph using a line graph.



The graph above was manufactured to illustrate the desired point. Note that the middle of the graph plateaus around 8500 requests/second. The flatness of the graph suggests that we’ve hit a bottleneck of some point. Since we know that the network is capable of nearly 22k request/second, and the network on each load client is presumably similar, we know that we’re either hitting the limitations of the disk subsystem or that we’ve pushed the webserver out of CPU.

If, during the test, you saw the idle CPU approach single digits, then we have reasonable confidence that we pushed the machine to its limit of CPU otherwise we may be pushing the limits of I/O.

6. Interpret the data and draw conclusions:

Now, by using the graph, we can decide on a limit for the webserver. The flat line starts approximately around 8500 req/sec. A reasonable buffer is 10% of that number, and so we would say that the max capacity of the webserver is 7650 req/sec. If you wish to be more conservative, and you should, you could leave yourself 25% capacity and call it 6325.

As a general rule you want to leave sufficient capacity on the machines to handle any excess load from failed hosts. If you have 2 machines, each machine should be able to handle all of the load. If you have 3 machines, then each should be able to handle 66% of the total load, and so forth.

7. Publish Findings:

With this simplistic testing done, you could approach development and tell them that you have some confidence that based on the preliminary testing you’ve done, the webserver can do 6325 ops/sec. Additionally, you should then provide the developers with your step by step guide as to how to get their own numbers to both allow them to validate your work, and to enable them to do this level of testing on their own in the future.

This concludes our first example. There are several more to come.

If you like what you’ve read, please share the blog with others. If you have any questions or comments, feel free to send me email at kmajer at karlmajer dot com.

>>> Karl