We continue our study of the WRL research report on the evaluation of the slowness of Operating systems as compared to the improvements in the hardware. We were evaluating one benchmark after another on a set of chosen RISC and CISC machines and their corresponding OS flavors. The last benchmark we were talking about was the read from File Cache. This benchmark consists of a program that opens a large file and reads the file repeatedly in 16kbyte blocks.The file size was chosen such that kernel copied the data from the file cache to a buffer in the program's address space.  It would be large enough that the data copied over was not resident in any hardware cache. Thus it measured the cost of each copy and entering the kernel. The receiving buffer was the same buffer and it was likely to stay in cache.The overall bandwidth of the data transfer was measured across a large number of kernel calls. The results indicated that the memory bandwidth was the same as in the previous benchmark involving the block copy. The M2000 RISC/os 4.0 and the 8800 Ultrix 3.0 had the highest throughput and the Sun4 and Sun3 had the lowest. Even though the latter had faster processors, it didn't seem affect any increase in memory bandwidth.  This was clearly visible by computing a metric as the uncached throughput and dividing by the MIPS rating . The memory intensive applications do not scale on these machines. The memory copying performance actually strictly drops with faster processors, both for RISC and CISC machines. The only other observation from the results that was significantly different from the previous file operation benchmark was that the Sun4 does relatively better due to its write back cache.
The next benchmark is modified Andrew Benchmark. This benchmark involves copying a directory hierarchy containing the source code for a program, stating every file in a new hierarchy, reading the contents of every copied file, and finally compiling the code in the copied hierarchy. In this case the program was compiled with the same compiler for a machine called SPUR and then run on target systems.The benchmark runs in two different phases - the copy phase which comprises of the copying and scanning operations and the other phase is the compilation phase. Since this tests the filesystem, it  matters whether the disk is local or remote. Hence the test was run in both configurations. In each of the remote cases, the server was the same kind of machine as the client. The file system protocol for remote file access was NFS.
The results from the benchmark runs showed several notable trends. First, no operating system scaled to match the hardware speedups. Second, Sprite comes out consistently faster than Ultrix or SunOS for remote access. NFS based RISC workstations slowed down 50% relative to local access.  Sometimes remote access was faster for some machines than local although this could not be explained. The DS3100-Ultrix combination was also somewhat slower than would have been expected.
#codingexercise

Double GetAlternateOddNumberRangeSumsqrtCube (Double [] A)

{

if (A == null) return 0;

Return A.AlternateOddNumberRangeSumSqrtCube();

}