Understanding Trends of SPEC CPU 2006

Synopisis

This is a quick look at trends in CPU performance based on the set of published SPECCPU2006 benchmark. The results are pulled directly from those published on the SPEC.org website, where you can read more about the benchmark and data collection.

CINT2006rate and CFP2006rate, studied here, measure important characteristics of computer performance and are widely followed benchmarks with a long history.

In the last few years it both MHz and core count of processors have been increasing. The question addressed here is “which factors have contributed most to increases in CPU performance over time?”
The approach is to look at the causes of performance increases (namely core count and frequency) and then examine 1. their correlation to performance increases, and then 2. their behavior over time.

The main conclusion is that core count and CPU frequency contribute to performance gains since 2006, with increases in core count playing the larger role. But together these contributions explain only about half of the observed increase in performance, suggesting further investigation is required.

Data Processing

The program relies on web download for data.
It checks for the existence of SPECCPU2006.csv on the local drive and will use it if available. If the file is not found, the program downloads the data to teh local drive and then reads it into memory. To ensure the most current version of the data delete the local copy.

The file contains about 30,000 observations.
The data as downloaded are already very clean. The only cleaning modifications are:
- date columns translated to R data format.
- eliminate some zero Result values.
- filter for the rate measurements.

## data are located at the SPEC website
url <- "http://spec.org/cgi-bin/osgresults?conf=cpu2006;op=dump;format=csvdump"
destfile <- "SPECCPU2006.csv"

## check if the data are stored locally, and if not download
if(!file.exists(destfile)) download.file(url, destfile)

##read the data as a .csv file
SPECdata <- read.csv(destfile)
## the structure of the raw data
str(SPECdata)

## 'data.frame':    29285 obs. of  33 variables:
##  $ Benchmark                : Factor w/ 4 levels "CFP2006","CFP2006rate",..: 3 3 3 3 3 3 3 3 3 3 ...
##  $ Hardware.Vendor.         : Factor w/ 49 levels "Acer Incorporated",..: 2 2 2 5 5 5 5 5 5 5 ...
##  $ System                   : Factor w/ 8028 levels "(A1SAi-2750F , Intel Atom C2750)",..: 406 435 476 638 654 655 656 618 619 639 ...
##  $ Result                   : num  35.8 41.5 37.5 0 20.5 22.6 18.5 17.3 18.3 0 ...
##  $ Baseline                 : num  32.8 38.9 35.9 13.1 18.3 20.2 16.5 15.5 16.4 11.4 ...
##  $ X..Cores                 : int  12 12 12 2 2 2 4 2 2 2 ...
##  $ X..Chips.                : int  2 2 2 1 1 1 1 1 1 1 ...
##  $ X..Cores.Per.Chip.       : int  6 6 6 2 2 2 4 2 2 2 ...
##  $ X..Threads.Per.Core      : int  2 2 2 1 1 1 1 1 1 1 ...
##  $ Processor.               : Factor w/ 817 levels "AMD A10-5700",..: 527 557 781 263 249 250 283 265 271 15 ...
##  $ Processor.MHz            : int  1900 2300 2667 2167 2666 3000 2400 2400 2600 2800 ...
##  $ Processor.Characteristics: Factor w/ 414 levels "","1.4GHz/12MB, 400MHz FSB",..: 310 318 323 90 137 201 113 121 133 167 ...
##  $ CPU.s..Orderable         : Factor w/ 145 levels "","1 ,2 chips",..: 44 44 44 4 4 4 4 4 4 4 ...
##  $ Auto.Parallelization     : Factor w/ 2 levels "No","Yes": 2 2 2 1 1 1 1 1 1 1 ...
##  $ Base.Pointer.Size        : Factor w/ 3 levels "32-bit","32/64-bit",..: 1 1 2 1 1 1 1 1 1 1 ...
##  $ Peak.Pointer.Size        : Factor w/ 4 levels "32-bit","32/64-bit",..: 2 2 2 4 1 1 1 1 1 4 ...
##  $ X1st.Level.Cache         : Factor w/ 23 levels "12 K micro-ops I + 16 KB D on chip per chip",..: 15 15 15 15 15 15 15 15 15 22 ...
##  $ X2nd.Level.Cache         : Factor w/ 39 levels " 12 MB I+D on chip per chip, 2 MB shared / 2 cores",..: 23 23 23 25 25 25 38 25 25 9 ...
##  $ X3rd.Level.Cache         : Factor w/ 35 levels "10 MB I+D on chip per chip",..: 7 7 3 35 35 35 35 35 35 35 ...
##  $ Other.Cache              : Factor w/ 9 levels "1200 GB I+D off chip per system",..: 9 9 9 9 9 9 9 9 9 9 ...
##  $ Memory                   : Factor w/ 1497 levels "1 GB (2x512 MB Samsung* PC2-4200s DDR2-533 4-4-4-12)",..: 1490 108 1077 488 480 480 480 481 481 460 ...
##  $ Operating.System         : Factor w/ 601 levels "(Santiago), 2.6.32-431.el6.x86_64",..: 495 495 459 589 590 590 590 590 590 593 ...
##  $ File.System              : Factor w/ 26 levels "(See additional details below)",..: 5 5 5 15 15 15 15 15 15 15 ...
##  $ Compiler                 : Factor w/ 713 levels "C/C++: Version 11.1 of IBM XL C/C++ for AIX",..: 24 24 554 428 414 415 415 415 415 377 ...
##  $ HW.Avail                 : Factor w/ 118 levels "Apr-1997","Apr-2003",..: 86 76 6 60 50 50 50 60 60 49 ...
##  $ SW.Avail                 : Factor w/ 97 levels "Apr-2006","Apr-2007",..: 28 28 35 23 9 9 9 65 65 9 ...
##  $ License                  : int  9008 9008 9008 13 13 13 13 13 13 13 ...
##  $ Tested.By                : Factor w/ 52 levels "Acer Incorporated",..: 3 3 3 31 31 31 31 31 31 31 ...
##  $ Test.Sponsor             : Factor w/ 46 levels "Acer Incorporated",..: 3 3 3 26 26 26 26 26 26 26 ...
##  $ Test.Date                : Factor w/ 107 levels "Apr-2006","Apr-2007",..: 97 97 60 56 47 47 47 56 56 10 ...
##  $ Published                : Factor w/ 98 levels "Apr-2007","Apr-2008",..: 24 24 46 10 10 10 10 10 10 90 ...
##  $ Updated.                 : Factor w/ 22 levels "Apr-2012","Apr-2013",..: 11 11 1 14 14 14 14 14 14 11 ...
##  $ X                        : logi  NA NA NA NA NA NA ...

datasize<-dim(SPECdata)

This gives an idea of the structure of the data in the SPECdata file.
There are 29285 by 33 elements in all.

##convert data to dates in R format
        ##The incoming data are in a mmm-YYYY format. 
        ##I had to append a day to the date data (which I chose as the 15th (arbitrarily))
        ## All date data in the file are converted, though not all are necessarily used in the current analysis.

        ## HW.Avail data
        SPECdata$HW.Avail <- as.character(SPECdata$HW.Avail)
        SPECdata$HW.Avail <- paste0("15-", SPECdata$HW.Avail)
        SPECdata$HW.Avail<- as.Date(SPECdata$HW.Avail, format="%d-%b-%Y")

        ## SW.Avail date
        SPECdata$SW.Avail <- as.character(SPECdata$SW.Avail)
        SPECdata$SW.Avail <- paste0("15-", SPECdata$SW.Avail)
        SPECdata$SW.Avail<- as.Date(SPECdata$SW.Avail, format="%d-%b-%Y")

        ## Test Date
        SPECdata$Test.Date <- as.character(SPECdata$Test.Date)
        SPECdata$Test.Date <- paste0("15-", SPECdata$Test.Date)
        SPECdata$Test.Date<- as.Date(SPECdata$Test.Date, format="%d-%b-%Y")

        ## Publication date
        SPECdata$Published <- as.character(SPECdata$Published)
        SPECdata$Published <- paste0("15-", SPECdata$Published)
        SPECdata$Published<- as.Date(SPECdata$Published, format="%d-%b-%Y")

##clean up results 
        ## Some spurious zero values need to be eliminated.To do that set high pass filter
        SPECdata<-SPECdata[SPECdata$Result>3,]
        ## eliminate data with 15 cores per chip (obviously a typo since those do not exist).
        SPECdata<-SPECdata[!SPECdata$X..Cores.Per.Chip.==15,]

        ##Select only the RATE version of the benchmarks
        SPECdata<-SPECdata[as.character(SPECdata$Benchmark)=="CFP2006rate"|as.character(SPECdata$Benchmark)=="CINT2006rate",]

As a first look at the data just consider the Result (performance) versus date for the entire population of systems with four or fewer processors.

#Plot Data as function of date by various facets

        library(ggplot2)
        ##reduce chip count to less than five.
        SPECdataX<-SPECdata[SPECdata$X..Chips.< 5,]

        ## create plot of results versus date
        P1 <- ggplot(SPECdataX, aes(x=HW.Avail, y=Result))+geom_point(shape=1)
        P1 <- P1 + scale_y_log10()
        P1<- P1+ geom_point(aes(colour = factor(X..Cores.Per.Chip.)))
        P1<-P1+xlab("Date")+ylab("SPEC CPU Result")+ggtitle("SPEC CPU 2006 rate vs. Date/nfor systems with fewer than 4 chips")

##Try an exponential fit based on a factor of two
        # some starting values
        #   Pick sensisible starting values
        #   start date of 1 Jan 2006
        #   doubling time constant of 2 years
        #   convert to numerical values of days
        tzero = as.numeric(as.Date("2006-01-01"), units = "days")
        tau <- as.Date("2014-01-01")-as.Date("2006-01-01")
        tau <- as.numeric(tau, units = "days")

#as.numeric((SPECdata_x$HW.Avail[100])
#tau
        coredata <- as.numeric(SPECdataX$Result)
        datedata <- as.numeric(SPECdataX$HW.Avail, units = "days")
#Initialize the start value
        Ainitial<-coredata[1]
# do the fit
        fit = nls(coredata ~ A*2^((datedata - tzero)/tau), start=list(A=Ainitial,tau=tau))

        ## get fit parameters
        taufit <- summary(fit)$parameters[2,1]
        Afit<-summary(fit)$parameters[1,1]
        #pick 20 xdata points along x axis
        fitframe <- data.frame(xdata = seq(min(datedata),max(datedata),len=20))
        #define fit function to calculate fit output
        fit<-function(x, tau=taufit, A=Afit){
                A*2^((x-tzero)/tau)
        }
        #apply it to the xdata
        fitdata<-sapply(fitframe, fit)
        
        
        #convert xdata column to dates
        fitframe$xdata<-as.Date(fitframe$xdata, origin="1970-01-01")
        #bind columns
        fitframe<-cbind(fitframe, fitdata)
        #correct column names
        colnames(fitframe)<-c("xdata", "fitdata")
        #add data to plot

        P1<-P1+geom_line(aes(x=fitframe$xdata, y = fitframe$fitdata, colour="Fit"), fitframe, size=2)

        print(P1)

plot of chunk a_fit

        ##make a tau overall for later use
        tauoverall<-taufit

# summarise

The above graph plots the SPECCPUrate results (both integer and floating point) versus time. To simplify the plot this data has been filtered for systems with four chips and fewer and the data factored for cores per chip.
Note the log scale for the y-axis, which ranges over a factor of 100. Judging from this data, computing performance at a gross level has increased between a factor of ten and one hundred since 2006, when the benchmark was first introduced. The data show an approximate doubling time of 2.5694 years. Core count seems to play a role in the performance increase, but other factors may as well. For instance processor frequency has long been associated with performance gains and has an obvious and direct correlation to processing speed.

Analysis and Results

Role of Core Count for Intel Xeon and Core processors

Here we start to look deeper into the data. For specificity we look at Intel Xeon (server) and Core (personal computer) microprocessors individually. To keep comparisons unambiguous we look at only systems with single chips in them, since multiple chips will confound the analysis. The graph below shows clearly the dependency of performance on core count in each family.

##Define required analysis functions

        ##Define ComputerType_x: a function to reduce data based on substring
        
                ##name_string is the string used to catergorize results (e.g. "Core")
                ##search string is what is used to select elements for the category (e.g. "cor")
                ##output specifies the data aggregation file. Note it should be set to NULL prior to running this for the first time.
                ##input is the raw data file
                ##The Outputfile adds a column to the input data with the output name_string

                ComputerType_x <- function(name_string, search_string, output=SPECdata_x, input=SPECdata) { 
                        temp <- input[grepl(search_string, input$Processor., ignore.case=TRUE), ]
                        names <- rep(name_string, dim(temp)[1])
                        temp<- cbind (names, temp)
                        rbind(temp, output)
                        }

##Analysis
        ##Take only single chip systems
        SPECdataReduce<-SPECdata[SPECdata$X..Chips.==1,]
        ##initialize data frame
        SPECdata_x<-NULL

        SPECdata_x<-ComputerType_x("Intel Core", "core", input=SPECdataReduce)
        SPECdata_x<-ComputerType_x("Intel Xeon", "xeon", input=SPECdataReduce)

        #plot
        P1 <- ggplot(SPECdata_x, aes(x=HW.Avail, y=Result))+geom_point(shape=1)
        P1<-P1+ coord_cartesian(ylim = c(10, 1000)) 
        P1 <- P1 + scale_y_log10(breaks=c(10,50, 100,500,1000))
        P1<- P1+ geom_point(aes(colour = factor(X..Cores.Per.Chip.)))
        P1<- P1 + facet_grid(. ~ names)
        P1<-P1+xlab("Date")+ylab("SPEC CPU Result")+ggtitle("SPEC CPU 2006 rate vs. processor family")

datadim<-dim(SPECdata_x)

print(P1)

plot of chunk Intel_Core_and_Xeon

After filtering data we have 3888 elements.

What is interesting is that the results for Xeon and Core are comparable where core count overlaps. This makes sense as they share a common core architecture. The Xeon product family has higher core count and thus extends to higher performance.

Exploring the role of core count on Xeon Performance

We can get a looking at the role core count plays by looking at a trend of the benchmarks as a function of core count directly. In the below graph the integer and floating point benchmarks are shown based on core count. The upward trend is unmistakable. The apparent “roll-off” of the curve with core count is an artefact of the way the data are analyzed, i.e. the horizontal axis is linear and the vertical axis is logarithmic.

        ##take only single chip systems
        SPECdataReduce<-SPECdata[SPECdata$X..Chips.==1,]
        ##initialize results data.frame
        SPECdata_x<-NULL
        ##select Xeon processors
        SPECdata_x<-ComputerType_x("Intel Xeon", "xeon", input=SPECdataReduce)

        ##create plot of cores and results
        P1 <- ggplot(SPECdata_x, aes(x=factor(X..Cores.Per.Chip.), y=Result))
        P1<-P1+ coord_cartesian(ylim = c(10, 1000)) 
        P1 <- P1 + scale_y_log10(breaks=c(10,50, 100,500,1000))
        P1<- P1+ geom_boxplot(aes(fill=Benchmark))
        P1<-P1+xlab("Cores")+ylab("SPEC CPU Result")+ggtitle("SPEC CPU 2006 rate vs. core count\nfor Intel Xeon")

print(P1)

plot of chunk Intel_Core_CoreCount

As we expect, the data show that as core count increases, so does performance. But this only resolves part of our question about whether this is contributing to observed increase in performance over time, namely are core counts increasing over time?

Trends of Number of Cores

        ##Reduce data to single chip and and CINT2006rate

        SPECdataReduce<-SPECdata[SPECdata$X..Chips.==1,]
        SPECdataReduce<-SPECdataReduce[as.character(SPECdataReduce$Benchmark)=="CINT2006rate",]
        ##clear data 
        SPECdata_x<-NULL
        #Select Xeon and Core
        SPECdata_x<-ComputerType_x("Intel Xeon", "xeon", input=SPECdataReduce)
        #SPECdata_x<-ComputerType_x("Intel Core", "core", input=SPECdataReduce)

        dim(SPECdata_x)

## [1] 1674   34

        #since a fit line is picked 

        P1 <- ggplot(SPECdata_x, aes(x=HW.Avail,y=X..Cores.Per.Chip. ))
        P1<-P1+ coord_cartesian(ylim = c(1, 16)) 
        P1 <- P1 + scale_y_log10(breaks=c(1,2, 4,8,16))
        P1<-P1+ geom_point(aes(colour = factor(names)), pch=1)
        P1<-P1+xlab("Date")+ylab("Number of Cores")+ggtitle("Cores vs. Date\nfor single socket Xeon")
 
#print(P1)

datadim=dim(SPECdata_x)

##Try an exponential fit based on a factor of two
        # some starting values
        #   Pick sensisible starting values
        #   start date of 1 Jan 2006
        #   doubling time constant of 2 years
        #   convert to numerical values of days
        tzero = as.numeric(as.Date("2006-01-01"), units = "days")
        tau <- as.Date("2008-01-01")-as.Date("2006-01-01")
        tau <- as.numeric(tau, units = "days")
#as.numeric((SPECdata_x$HW.Avail[100])
#tau
        coredata <- as.numeric(SPECdata_x$X..Cores.Per.Chip.)
        datedata <- as.numeric(SPECdata_x$HW.Avail, units = "days")
# do the fit
        fit = nls(coredata ~ 2^((datedata - tzero)/tau), start=list(tzero=tzero,tau=tau))

        ## get fit parameters
        taufit <- summary(fit)$parameters[2,1]
        tzerofit<-summary(fit)$parameters[1,1]
        #pick 20 xdata points along x axis
        fitframe <- data.frame(xdata = seq(min(datedata),max(datedata),len=20))
        #define fit function to calculate fit output
        fit<-function(x, tau=taufit, tzero=tzerofit){
                2^((x-tzero)/tau)
        }
        #apply it to the xdata
        fitdata<-sapply(fitframe, fit)
        
        
        #convert xdata column to dates
        fitframe$xdata<-as.Date(fitframe$xdata, origin="1970-01-01")
        #bind columns
        fitframe<-cbind(fitframe, fitdata)
        #correct column names
        colnames(fitframe)<-c("xdata", "fitdata")
        #add data to plot

        P1<-P1+geom_line(aes(x=fitframe$xdata, y = fitframe$fitdata, colour="Fit"), fitframe, size=2)

        print(P1)

plot of chunk try_a_fit

        #make a tau cores variable for later use
        taucores<-taufit

# summarise

The data now reflect 1674 measurements, this time of single chip Xeon-based systems for a single benchamrk CINT2006rate.
A clear upward trend in the number of cores is evident. Note that core number is plotted on a logarithmic scale.
A fit line is included which reflects a core count doubling time of 6.967 years. Thus, based on this analysis cores contribute to increased performance, and the number of cores is increasing in a roughly exponential manner with time.
The observation that performance increases with time correlates with the obersation that performance is increasing.

The role of MHz

We can also look at the effect of processor speed (MHz) on the benchmark. The tie between MHz and performance is intuitively obvious. We can demonstrate it easily by looking at the data.

To simplify the picture we’lll look at only two and four core parts. In addition, we’ll only look at the Integer benchmark CINT2006rate though similar conclusions hold for CFP2006rate.

        ##keep single chip systems with four or fewer processors and only the INT benchmark
        SPECdataReduce<-SPECdata[SPECdata$X..Chips.==1,]
        SPECdataReduce<-SPECdataReduce[SPECdataReduce$X..Cores.Per.Chip.<5,]
        SPECdataReduce<-SPECdataReduce[as.character(SPECdataReduce$Benchmark)=="CINT2006rate",]

        ##clear the results data frame
        SPECdata_x<-NULL
        ##select only core processors
        SPECdata_x<-ComputerType_x("Intel Core", "core", input=SPECdataReduce)
        ##cleate plot of Results v. MHz
        P1 <- ggplot(SPECdata_x, aes(x=Processor.MHz, y=Result))
        P1<-P1+ coord_cartesian(ylim = c(10, 1000)) 
        P1 <- P1 + scale_y_log10(breaks=c(10,50, 100,500,1000))
        P1<- P1+ geom_point(aes(colour = factor(X..Cores.Per.Chip.)))
        P1<-P1+xlab("MHz")+ylab("SPECint Result")+ggtitle("CINT2006rate vs. MHz\nfor 1 and 2 threads per core")
        P1 <- P1 + facet_grid(.~X..Threads.Per.Core)
        P1<- P1 + theme(axis.text.x = element_text(angle = 0))
    
print(P1)

plot of chunk Intel_Core_MHz

str(SPECdataReduce)

## 'data.frame':    1895 obs. of  33 variables:
##  $ Benchmark                : Factor w/ 4 levels "CFP2006","CFP2006rate",..: 4 4 4 4 4 4 4 4 4 4 ...
##  $ Hardware.Vendor.         : Factor w/ 49 levels "Acer Incorporated",..: 2 2 2 2 2 2 2 2 2 2 ...
##  $ System                   : Factor w/ 8028 levels "(A1SAi-2750F , Intel Atom C2750)",..: 344 345 346 347 348 349 350 351 352 354 ...
##  $ Result                   : num  33.8 44.3 157 141 168 158 143 169 157 178 ...
##  $ Baseline                 : num  29.4 37.6 152 136 163 152 137 163 152 171 ...
##  $ X..Cores                 : int  2 2 4 4 4 4 4 4 4 4 ...
##  $ X..Chips.                : int  1 1 1 1 1 1 1 1 1 1 ...
##  $ X..Cores.Per.Chip.       : int  2 2 4 4 4 4 4 4 4 4 ...
##  $ X..Threads.Per.Core      : int  1 1 1 1 2 1 1 2 1 1 ...
##  $ Processor.               : Factor w/ 817 levels "AMD A10-5700",..: 251 258 481 480 491 481 480 491 481 482 ...
##  $ Processor.MHz            : int  2533 3167 3100 3100 3300 3100 3100 3300 3100 3100 ...
##  $ Processor.Characteristics: Factor w/ 414 levels "","1.4GHz/12MB, 400MHz FSB",..: 48 217 339 335 343 339 335 343 339 339 ...
##  $ CPU.s..Orderable         : Factor w/ 145 levels "","1 ,2 chips",..: 4 4 4 4 4 4 4 4 4 4 ...
##  $ Auto.Parallelization     : Factor w/ 2 levels "No","Yes": 2 2 1 1 1 1 1 1 1 1 ...
##  $ Base.Pointer.Size        : Factor w/ 3 levels "32-bit","32/64-bit",..: 1 1 1 1 1 1 1 1 1 1 ...
##  $ Peak.Pointer.Size        : Factor w/ 4 levels "32-bit","32/64-bit",..: 2 2 2 2 2 2 2 2 2 2 ...
##  $ X1st.Level.Cache         : Factor w/ 23 levels "12 K micro-ops I + 16 KB D on chip per chip",..: 15 15 15 15 15 15 15 15 15 15 ...
##  $ X2nd.Level.Cache         : Factor w/ 39 levels " 12 MB I+D on chip per chip, 2 MB shared / 2 cores",..: 24 33 23 23 23 23 23 23 23 23 ...
##  $ X3rd.Level.Cache         : Factor w/ 35 levels "10 MB I+D on chip per chip",..: 35 35 31 31 31 31 31 31 31 31 ...
##  $ Other.Cache              : Factor w/ 9 levels "1200 GB I+D off chip per system",..: 9 9 9 9 9 9 9 9 9 9 ...
##  $ Memory                   : Factor w/ 1497 levels "1 GB (2x512 MB Samsung* PC2-4200s DDR2-533 4-4-4-12)",..: 472 472 275 283 283 275 283 283 271 259 ...
##  $ Operating.System         : Factor w/ 601 levels "(Santiago), 2.6.32-431.el6.x86_64",..: 319 319 194 149 149 194 442 149 194 189 ...
##  $ File.System              : Factor w/ 26 levels "(See additional details below)",..: 17 17 6 6 6 6 5 6 6 6 ...
##  $ Compiler                 : Factor w/ 713 levels "C/C++: Version 11.1 of IBM XL C/C++ for AIX",..: 315 315 76 24 24 76 24 24 77 82 ...
##  $ HW.Avail                 : Date, format: "2007-12-15" "2007-12-15" ...
##  $ SW.Avail                 : Date, format: "2007-11-15" "2007-11-15" ...
##  $ License                  : int  9008 9008 9008 9008 9008 9008 9008 9008 9008 9008 ...
##  $ Tested.By                : Factor w/ 52 levels "Acer Incorporated",..: 41 41 3 3 3 3 3 3 3 3 ...
##  $ Test.Sponsor             : Factor w/ 46 levels "Acer Incorporated",..: 3 3 3 3 3 3 3 3 3 3 ...
##  $ Test.Date                : Date, format: "2008-08-15" "2008-08-15" ...
##  $ Published                : Date, format: "2008-09-15" "2008-09-15" ...
##  $ Updated.                 : Factor w/ 22 levels "Apr-2012","Apr-2013",..: 11 11 11 11 11 11 11 11 11 11 ...
##  $ X                        : logi  NA NA NA NA NA NA ...

The data show a clear relationship between speed and performance, as expected.

The data are also factored by the number of threads per core. It’s interesting to note that the two thread per core two core parts have performance nearly equal to the four core parts with one thread per core, as expected. Although hyperthreading has an important impact on the performance benchmark, it’s impact is apparently reduced for higher core count.

Trend of MHz

With the relationship of MHz to performance established, the question is have MHz increased with time and do they play a strong role in the observed increase in performance.

Here is a graph of MHZ for two core parts over time. The speed of the processors has increased from about 2500 to 3500 MHz, but in what appears to be a linear manner. Thus, while MHz have played a role in increased performance, their contribution is linear and not exponential.

        ##Reduce data to two cores 

        SPECdataReduce<-SPECdata[SPECdata$X..Chips.==1,]
        SPECdataReduce<-SPECdataReduce[SPECdataReduce$X..Cores.Per.Chip.==2,]
        SPECdataReduce<-SPECdataReduce[as.character(SPECdataReduce$Benchmark)=="CINT2006rate",]

        ##CLEAR RESULTS MATRIX
        SPECdata_x<-NULL
        ## select only core processors
        SPECdata_x<-ComputerType_x("Intel Core", "core", input=SPECdataReduce)
        ##plot MHz versus time
        P1 <- ggplot(SPECdata_x, aes(x=HW.Avail,y=Processor.MHz ))
        #P1 <- P1 + stat_smooth(method="lm")
        P1<- P1+ geom_point()
        P1<-P1+xlab("Date")+ylab("MHz")+ggtitle("MHz vs. Date\nfor single thread two core parts")

        ##Add a fit line below

##Try an exponential fit based on a factor of two
        # some starting values
        #   Pick sensisible starting values
        #   start date of 1 Jan 2006
        #   doubling time constant of 2 years
        #   convert to numerical values of days
        tzero = as.numeric(as.Date("2006-01-01"), units = "days")
        tau <- as.Date("2008-01-01")-as.Date("2006-01-01")
        tau <- as.numeric(tau, units = "days")
#as.numeric((SPECdata_x$HW.Avail[100])
#tau
        mhzdata <- as.numeric(SPECdata_x$Processor.MHz)
        datedata <- as.numeric(SPECdata_x$HW.Avail, units = "days")
# do the fit
        fit = nls(mhzdata ~ 2500*2^((datedata - tzero)/tau), start=list(tzero=tzero,tau=tau))

        ## get fit parameters
        taufit <- summary(fit)$parameters[2,1]
        tzerofit<-summary(fit)$parameters[1,1]
        #pick 20 xdata points along x axis
        fitframe <- data.frame(xdata = seq(min(datedata),max(datedata),len=20))
        #define fit function to calculate fit output
        fit<-function(x, tau=taufit, tzero=tzerofit){
                2500*2^((x-tzero)/tau)
        }
        #apply it to the xdata
        fitdata<-sapply(fitframe, fit)
        
        
        #convert xdata column to dates
        fitframe$xdata<-as.Date(fitframe$xdata, origin="1970-01-01")
        #bind columns
        fitframe<-cbind(fitframe, fitdata)
        #correct column names
        colnames(fitframe)<-c("xdata", "fitdata")
        #add data to plot

        P1<-P1+geom_line(aes(x=fitframe$xdata, y = fitframe$fitdata, colour="Fit"), fitframe, size=2)

        print(P1)

plot of chunk try_another_fit

# summarise

Thus while MHz are increasing over time, the doubling time 13.5212 years is much longer than the doubling time for the cores, and thus accounts for a lower fraction of the gain in performance observed.

Conclusions

Published performance data show an increase of roughly a factor of ten in the performance (computing speed) of microprocessors in the last eight years.

A dominant contributor to the increase in capability has been the trend of increasing core count with core count being correlated to processor speed and core count has been increasing roughly exponentially with time. But n

An additonal contribution to the increase in MHz, which also correlate to processor speed. But this contribution is not as important as core count.

However, there are more factors to consider to explain the entire observed increase, given 2.5694 years oberved for overall doubling is much smaller than 4.5979 years calculated from the core and MHz contributions. This suggests further investigation is required. Place to investigate include system cache sizes and system scale.