Index: trunk/sources/HeuristicLab 3.3.sln
===================================================================
--- trunk/sources/HeuristicLab 3.3.sln	(revision 7001)
+++ trunk/sources/HeuristicLab 3.3.sln	(revision 7006)
@@ -311,4 +311,8 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Clients.Hive.Administrator-3.3", "HeuristicLab.Clients.Hive.Administrator\3.3\HeuristicLab.Clients.Hive.Administrator-3.3.csproj", "{5211F1AD-BBA2-4C62-8749-DCA0A25CF5D8}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.Benchmarks-3.3", "HeuristicLab.Algorithms.Benchmarks\3.3\HeuristicLab.Algorithms.Benchmarks-3.3.csproj", "{068C70A7-8CAF-4AB6-8721-4564D62292BC}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.Benchmarks.Views-3.3", "HeuristicLab.Algorithms.Benchmarks.Views\3.3\HeuristicLab.Algorithms.Benchmarks.Views-3.3.csproj", "{3C906172-E044-4DF0-B4FD-AA21192D5D3E}"
 EndProject
 Global
@@ -1519,4 +1523,20 @@
 		{5211F1AD-BBA2-4C62-8749-DCA0A25CF5D8}.Release|x86.ActiveCfg = Release|x86
 		{5211F1AD-BBA2-4C62-8749-DCA0A25CF5D8}.Release|x86.Build.0 = Release|x86
+		{068C70A7-8CAF-4AB6-8721-4564D62292BC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{068C70A7-8CAF-4AB6-8721-4564D62292BC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{068C70A7-8CAF-4AB6-8721-4564D62292BC}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{068C70A7-8CAF-4AB6-8721-4564D62292BC}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{068C70A7-8CAF-4AB6-8721-4564D62292BC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{068C70A7-8CAF-4AB6-8721-4564D62292BC}.Release|Any CPU.Build.0 = Release|Any CPU
+		{068C70A7-8CAF-4AB6-8721-4564D62292BC}.Release|x64.ActiveCfg = Release|Any CPU
+		{068C70A7-8CAF-4AB6-8721-4564D62292BC}.Release|x86.ActiveCfg = Release|Any CPU
+		{3C906172-E044-4DF0-B4FD-AA21192D5D3E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3C906172-E044-4DF0-B4FD-AA21192D5D3E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3C906172-E044-4DF0-B4FD-AA21192D5D3E}.Debug|x64.ActiveCfg = Debug|Any CPU
+		{3C906172-E044-4DF0-B4FD-AA21192D5D3E}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{3C906172-E044-4DF0-B4FD-AA21192D5D3E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3C906172-E044-4DF0-B4FD-AA21192D5D3E}.Release|Any CPU.Build.0 = Release|Any CPU
+		{3C906172-E044-4DF0-B4FD-AA21192D5D3E}.Release|x64.ActiveCfg = Release|Any CPU
+		{3C906172-E044-4DF0-B4FD-AA21192D5D3E}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/BenchmarkView.Designer.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/BenchmarkView.Designer.cs	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/BenchmarkView.Designer.cs	(revision 7006)
@@ -0,0 +1,40 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+namespace HeuristicLab.Algorithms.Benchmarks.Views {
+  partial class BenchmarkView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+
+    }
+
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/BenchmarkView.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/BenchmarkView.cs	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/BenchmarkView.cs	(revision 7006)
@@ -0,0 +1,39 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Windows.Forms;
+using HeuristicLab.MainForm;
+using HeuristicLab.Optimization.Views;
+
+namespace HeuristicLab.Algorithms.Benchmarks.Views {
+  [View("Benchmark View")]
+  [Content(typeof(Benchmark), true)]
+  public partial class BenchmarkView : AlgorithmView {
+    public new Benchmark Content {
+      get { return (Benchmark)base.Content; }
+      set { base.Content = value; }
+    }
+    public BenchmarkView() {
+      InitializeComponent();
+      tabControl.TabPages.Remove(this.problemTabPage);
+    }
+  }
+}
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/BenchmarkView.resx
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/BenchmarkView.resx	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/BenchmarkView.resx	(revision 7006)
@@ -0,0 +1,129 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <metadata name="toolTip.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>17, 17</value>
+  </metadata>
+  <metadata name="openFileDialog.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>230, 17</value>
+  </metadata>
+  <metadata name="errorProvider.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
+    <value>107, 17</value>
+  </metadata>
+</root>
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/HeuristicLab.Algorithms.Benchmarks.Views-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/HeuristicLab.Algorithms.Benchmarks.Views-3.3.csproj	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/HeuristicLab.Algorithms.Benchmarks.Views-3.3.csproj	(revision 7006)
@@ -0,0 +1,183 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{3C906172-E044-4DF0-B4FD-AA21192D5D3E}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.Benchmarks.Views</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.Benchmarks.Views-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>
+    </DocumentationFile>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="BenchmarkView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="BenchmarkView.Designer.cs">
+      <DependentUpon>BenchmarkView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Algorithms.Benchmarks\3.3\HeuristicLab.Algorithms.Benchmarks-3.3.csproj">
+      <Project>{068C70A7-8CAF-4AB6-8721-4564D62292BC}</Project>
+      <Name>HeuristicLab.Algorithms.Benchmarks-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core.Views\3.3\HeuristicLab.Core.Views-3.3.csproj">
+      <Project>{E226881D-315F-423D-B419-A766FE0D8685}</Project>
+      <Name>HeuristicLab.Core.Views-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.MainForm.WindowsForms\3.3\HeuristicLab.MainForm.WindowsForms-3.3.csproj">
+      <Project>{AB687BBE-1BFE-476B-906D-44237135431D}</Project>
+      <Name>HeuristicLab.MainForm.WindowsForms-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.MainForm\3.3\HeuristicLab.MainForm-3.3.csproj">
+      <Project>{3BD61258-31DA-4B09-89C0-4F71FEF5F05A}</Project>
+      <Name>HeuristicLab.MainForm-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization.Views\3.3\HeuristicLab.Optimization.Views-3.3.csproj">
+      <Project>{662B4B15-8F4D-4AE5-B3EB-D91C215F5AF2}</Project>
+      <Name>HeuristicLab.Optimization.Views-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="BenchmarkView.resx">
+      <DependentUpon>BenchmarkView.cs</DependentUpon>
+    </EmbeddedResource>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/Plugin.cs.frame
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/Plugin.cs.frame	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/Plugin.cs.frame	(revision 7006)
@@ -0,0 +1,37 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Algorithms.Benchmarks.Views {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Algorithms.Benchmarks plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Algorithms.Benchmarks.Views", "Provides views for benchmarking algorithms.", "3.3.5.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.Benchmarks.Views-3.3.dll", PluginFileType.Assembly)]  
+  [PluginDependency("HeuristicLab.MainForm", "3.3")]
+  [PluginDependency("HeuristicLab.MainForm.WindowsForms", "3.3")] 
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Optimization.Views", "3.3")]
+  [PluginDependency("HeuristicLab.Algorithms.Benchmarks", "3.3")] 
+  public class HeuristicLabAlgorithmsBenchmarksViewsPlugin : PluginBase {
+  }
+}
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/Properties/AssemblyInfo.cs.frame	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks.Views/3.3/Properties/AssemblyInfo.cs.frame	(revision 7006)
@@ -0,0 +1,55 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Algorithms.Benchmarks.Views")]
+[assembly: AssemblyDescription("Benchmarking")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2011 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("3E422463-0CE0-400D-9544-5C11D5818769")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.5.$WCREV$")]
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Benchmark.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Benchmark.cs	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Benchmark.cs	(revision 7006)
@@ -0,0 +1,562 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using HeuristicLab.Collections;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Algorithms.Benchmarks {
+  /// <summary>
+  /// A base class for benchmarks.
+  /// </summary>
+  [Item("Benchmark", "A wrapper for benchmark algorithms.")]
+  [Creatable("Benchmarks")]
+  [StorableClass]
+  public class Benchmark : IAlgorithm {
+    private Random random = new Random();
+
+    [Storable]
+    private DateTime lastUpdateTime;
+
+    [Storable]
+    private IBenchmark benchmarkAlgorithm;
+    public IBenchmark BenchmarkAlgorithm {
+      get { return benchmarkAlgorithm; }
+      set {
+        if (value == null) throw new ArgumentNullException();
+        benchmarkAlgorithm = value;
+      }
+    }
+
+    private CancellationTokenSource cancellationTokenSource;
+
+    [Storable]
+    private ExecutionState executionState;
+    public ExecutionState ExecutionState {
+      get { return executionState; }
+      private set {
+        if (executionState != value) {
+          executionState = value;
+          OnExecutionStateChanged();
+          OnItemImageChanged();
+        }
+      }
+    }
+
+    [Storable]
+    private TimeSpan executionTime;
+    public TimeSpan ExecutionTime {
+      get { return executionTime; }
+      protected set {
+        executionTime = value;
+        OnExecutionTimeChanged();
+      }
+    }
+
+    [Storable]
+    private bool storeAlgorithmInEachRun;
+    public bool StoreAlgorithmInEachRun {
+      get { return storeAlgorithmInEachRun; }
+      set {
+        if (storeAlgorithmInEachRun != value) {
+          storeAlgorithmInEachRun = value;
+          OnStoreAlgorithmInEachRunChanged();
+        }
+      }
+    }
+
+    [Storable]
+    protected int runsCounter;
+
+    [Storable]
+    private RunCollection runs = new RunCollection();
+    public RunCollection Runs {
+      get { return runs; }
+      protected set {
+        if (value == null) throw new ArgumentNullException();
+        if (runs != value) {
+          if (runs != null) DeregisterRunsEvents();
+          runs = value;
+          if (runs != null) RegisterRunsEvents();
+        }
+      }
+    }
+
+    [Storable]
+    private ResultCollection results;
+    public ResultCollection Results {
+      get { return results; }
+    }
+
+    [Storable]
+    private IProblem problem;
+    public IProblem Problem {
+      get { return problem; }
+      set {
+        if (problem != value) {
+          if ((value != null) && !ProblemType.IsInstanceOfType(value)) throw new ArgumentException("Invalid problem type.");
+          if (problem != null) DeregisterProblemEvents();
+          problem = value;
+          if (problem != null) RegisterProblemEvents();
+          OnProblemChanged();
+          Prepare();
+        }
+      }
+    }
+
+    public Type ProblemType {
+      get { return typeof(IProblem); }
+    }
+
+    [Storable]
+    protected string name;
+
+    public string Name {
+      get { return name; }
+      set {
+        if (!CanChangeName) throw new NotSupportedException("Name cannot be changed.");
+        if (!(name.Equals(value) || (value == null) && (name == string.Empty))) {
+          CancelEventArgs<string> e = value == null ? new CancelEventArgs<string>(string.Empty) : new CancelEventArgs<string>(value);
+          OnNameChanging(e);
+          if (!e.Cancel) {
+            name = value == null ? string.Empty : value;
+            OnNameChanged();
+          }
+        }
+      }
+    }
+
+    public bool CanChangeName {
+      get { return false; }
+    }
+
+    [Storable]
+    protected string description;
+    public string Description {
+      get { return description; }
+      set {
+        if (!CanChangeDescription) throw new NotSupportedException("Description cannot be changed.");
+        if (!(description.Equals(value) || (value == null) && (description == string.Empty))) {
+          description = value == null ? string.Empty : value;
+          OnDescriptionChanged();
+        }
+      }
+    }
+
+    public bool CanChangeDescription {
+      get { return false; }
+    }
+
+    public string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+
+    public string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+
+    public Image ItemImage {
+      get {
+        if (ExecutionState == ExecutionState.Prepared) return HeuristicLab.Common.Resources.VSImageLibrary.ExecutablePrepared;
+        else if (ExecutionState == ExecutionState.Started) return HeuristicLab.Common.Resources.VSImageLibrary.ExecutableStarted;
+        else if (ExecutionState == ExecutionState.Paused) return HeuristicLab.Common.Resources.VSImageLibrary.ExecutablePaused;
+        else if (ExecutionState == ExecutionState.Stopped) return HeuristicLab.Common.Resources.VSImageLibrary.ExecutableStopped;
+        else return HeuristicLab.Common.Resources.VSImageLibrary.Event;
+      }
+    }
+
+    [Storable]
+    private ParameterCollection parameters = new ParameterCollection();
+
+    public IKeyedItemCollection<string, IParameter> Parameters {
+      get { return parameters; }
+    }
+
+    private ReadOnlyKeyedItemCollection<string, IParameter> readOnlyParameters;
+
+    IKeyedItemCollection<string, IParameter> IParameterizedItem.Parameters {
+      get {
+        if (readOnlyParameters == null) readOnlyParameters = parameters.AsReadOnly();
+        return readOnlyParameters;
+      }
+    }
+
+    public IEnumerable<IOptimizer> NestedOptimizers {
+      get { return Enumerable.Empty<IOptimizer>(); }
+    }
+
+    #region Parameter Properties
+
+    public ConstrainedValueParameter<IBenchmark> BenchmarkAlgorithmParameter {
+      get { return (ConstrainedValueParameter<IBenchmark>)Parameters["BenchmarkAlgorithm"]; }
+    }
+
+    private ValueParameter<IntValue> ChunkSizeParameter {
+      get { return (ValueParameter<IntValue>)Parameters["ChunkSize"]; }
+    }
+
+    private ValueParameter<DoubleValue> TimeLimitParameter {
+      get { return (ValueParameter<DoubleValue>)Parameters["TimeLimit"]; }
+    }
+
+    #endregion
+
+    #region Constructors
+
+    [StorableConstructor]
+    public Benchmark(bool deserializing) { }
+
+    public Benchmark() {
+      name = ItemName;
+      description = ItemDescription;
+      parameters = new ParameterCollection();
+      readOnlyParameters = null;
+      executionState = ExecutionState.Stopped;
+      executionTime = TimeSpan.Zero;
+      storeAlgorithmInEachRun = false;
+      runsCounter = 0;
+      Runs = new RunCollection();
+      results = new ResultCollection();
+      CreateParameters();
+      DiscoverBenchmarks();
+      Prepare();
+    }
+
+    public Benchmark(Benchmark original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+      name = original.name;
+      description = original.description;
+      parameters = cloner.Clone(original.parameters);
+      readOnlyParameters = null;
+      if (ExecutionState == ExecutionState.Started) throw new InvalidOperationException(string.Format("Clone not allowed in execution state \"{0}\".", ExecutionState));
+      executionState = original.executionState;
+      executionTime = original.executionTime;
+      storeAlgorithmInEachRun = original.storeAlgorithmInEachRun;
+      runsCounter = original.runsCounter;
+      runs = cloner.Clone(original.runs);
+      Initialize();
+
+      results = cloner.Clone(original.results);
+      DiscoverBenchmarks();
+      Prepare();
+    }
+
+    #endregion
+
+    private void CreateParameters() {
+      Parameters.Add(new ValueParameter<IntValue>("ChunkSize", "The size (MB) of the chunk array that gets generated", new IntValue(0)));
+      Parameters.Add(new ValueParameter<DoubleValue>("TimeLimit", "The time limit (in minutes) for a benchmark run. Zero means a fixed number of iterations", new DoubleValue(0)));
+    }
+
+    private void DiscoverBenchmarks() {
+      var benchmarks = from t in ApplicationManager.Manager.GetTypes(typeof(IBenchmark))
+                       select t;
+      ItemSet<IBenchmark> values = new ItemSet<IBenchmark>();
+      foreach (var benchmark in benchmarks) {
+        IBenchmark b = (IBenchmark)Activator.CreateInstance(benchmark);
+        values.Add(b);
+      }
+      string paramName = "BenchmarkAlgorithm";
+      if (!Parameters.ContainsKey(paramName)) {
+        if (values.Count > 0) {
+          Parameters.Add(new ConstrainedValueParameter<IBenchmark>(paramName, values, values.First(a => a is IBenchmark)));
+        } else {
+          Parameters.Add(new ConstrainedValueParameter<IBenchmark>(paramName, values));
+        }
+      }
+    }
+
+    private void Initialize() {
+      if (problem != null) RegisterProblemEvents();
+      if (runs != null) RegisterRunsEvents();
+    }
+
+    public virtual void Prepare() {
+      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused) && (ExecutionState != ExecutionState.Stopped))
+        throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
+      results.Clear();
+      OnPrepared();
+    }
+
+    public void Prepare(bool clearRuns) {
+      if ((ExecutionState != ExecutionState.Prepared) && (ExecutionState != ExecutionState.Paused) && (ExecutionState != ExecutionState.Stopped))
+        throw new InvalidOperationException(string.Format("Prepare not allowed in execution state \"{0}\".", ExecutionState));
+      if (clearRuns) runs.Clear();
+      Prepare();
+    }
+
+    public virtual void Pause() {
+      if (ExecutionState != ExecutionState.Started)
+        throw new InvalidOperationException(string.Format("Pause not allowed in execution state \"{0}\".", ExecutionState));
+    }
+    public virtual void Stop() {
+      if ((ExecutionState != ExecutionState.Started) && (ExecutionState != ExecutionState.Paused))
+        throw new InvalidOperationException(string.Format("Stop not allowed in execution state \"{0}\".", ExecutionState));
+      cancellationTokenSource.Cancel();
+    }
+
+    public virtual void Start() {
+      cancellationTokenSource = new CancellationTokenSource();
+      OnStarted();
+      Task task = Task.Factory.StartNew(Run, cancellationTokenSource.Token, cancellationTokenSource.Token);
+      task.ContinueWith(t => {
+        try {
+          t.Wait();
+        }
+        catch (AggregateException ex) {
+          try {
+            ex.Flatten().Handle(x => x is OperationCanceledException);
+          }
+          catch (AggregateException remaining) {
+            if (remaining.InnerExceptions.Count == 1) OnExceptionOccurred(remaining.InnerExceptions[0]);
+            else OnExceptionOccurred(remaining);
+          }
+        }
+
+        cancellationTokenSource.Dispose();
+        cancellationTokenSource = null;
+        OnStopped();
+      });
+    }
+
+    protected virtual void Run(object state) {
+      CancellationToken cancellationToken = (CancellationToken)state;
+      lastUpdateTime = DateTime.Now;
+      System.Timers.Timer timer = new System.Timers.Timer(250);
+      timer.AutoReset = true;
+      timer.Elapsed += new System.Timers.ElapsedEventHandler(timer_Elapsed);
+      timer.Start();
+      try {
+        BenchmarkAlgorithm = (IBenchmark)BenchmarkAlgorithmParameter.ActualValue;
+        int chunkSize = ((IntValue)ChunkSizeParameter.ActualValue).Value;
+        if (chunkSize > 0) {
+          BenchmarkAlgorithm.ChunkData = CreateDataChuck(chunkSize);
+        } else if (chunkSize < 0) {
+          throw new ArgumentException("ChunkSize must not be negativ.");
+        }
+        TimeSpan timelimit = TimeSpan.FromMinutes(((DoubleValue)TimeLimitParameter.ActualValue).Value);
+        if (timelimit.TotalMilliseconds < 0) {
+          throw new ArgumentException("TimeLimit must not be negativ. ");
+        }
+        BenchmarkAlgorithm.TimeLimit = timelimit;
+        BenchmarkAlgorithm.Run(cancellationToken, results);
+      }
+      catch (OperationCanceledException) {
+      }
+      finally {
+        timer.Elapsed -= new System.Timers.ElapsedEventHandler(timer_Elapsed);
+        timer.Stop();
+        ExecutionTime += DateTime.Now - lastUpdateTime;
+      }
+    }
+
+    private void timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) {
+      System.Timers.Timer timer = (System.Timers.Timer)sender;
+      timer.Enabled = false;
+      DateTime now = DateTime.Now;
+      ExecutionTime += now - lastUpdateTime;
+      lastUpdateTime = now;
+      timer.Enabled = true;
+    }
+
+    public virtual void CollectResultValues(IDictionary<string, IItem> values) {
+      values.Add("Execution Time", new TimeSpanValue(ExecutionTime));
+      CollectResultsRecursively("", Results, values);
+    }
+
+    private void CollectResultsRecursively(string path, ResultCollection results, IDictionary<string, IItem> values) {
+      foreach (IResult result in results) {
+        values.Add(path + result.Name, result.Value);
+        ResultCollection childCollection = result.Value as ResultCollection;
+        if (childCollection != null) {
+          CollectResultsRecursively(path + result.Name + ".", childCollection, values);
+        }
+      }
+    }
+
+    public virtual void CollectParameterValues(IDictionary<string, IItem> values) {
+      foreach (IValueParameter param in parameters.OfType<IValueParameter>()) {
+        if (param.GetsCollected && param.Value != null) values.Add(param.Name, param.Value);
+        if (param.Value is IParameterizedItem) {
+          Dictionary<string, IItem> children = new Dictionary<string, IItem>();
+          ((IParameterizedItem)param.Value).CollectParameterValues(children);
+          foreach (string key in children.Keys)
+            values.Add(param.Name + "." + key, children[key]);
+        }
+      }
+    }
+
+    private byte[][] CreateDataChuck(int megaBytes) {
+      if (megaBytes <= 0) {
+        throw new ArgumentException("MegaBytes must be greater than zero", "megaBytes");
+      }
+      byte[][] chunk = new byte[megaBytes][];
+      for (int i = 0; i < chunk.Length; i++) {
+        chunk[i] = new byte[1024 * 1024];
+        random.NextBytes(chunk[i]);
+      }
+      return chunk;
+    }
+
+    #region Events
+
+    public event EventHandler ExecutionStateChanged;
+    protected virtual void OnExecutionStateChanged() {
+      EventHandler handler = ExecutionStateChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ExecutionTimeChanged;
+    protected virtual void OnExecutionTimeChanged() {
+      EventHandler handler = ExecutionTimeChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ProblemChanged;
+    protected virtual void OnProblemChanged() {
+      EventHandler handler = ProblemChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler StoreAlgorithmInEachRunChanged;
+    protected virtual void OnStoreAlgorithmInEachRunChanged() {
+      EventHandler handler = StoreAlgorithmInEachRunChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Prepared;
+    protected virtual void OnPrepared() {
+      ExecutionState = ExecutionState.Prepared;
+      ExecutionTime = TimeSpan.Zero;
+      foreach (IStatefulItem statefulObject in this.GetObjectGraphObjects().OfType<IStatefulItem>()) {
+        statefulObject.InitializeState();
+      }
+      EventHandler handler = Prepared;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Started;
+    protected virtual void OnStarted() {
+      ExecutionState = ExecutionState.Started;
+      EventHandler handler = Started;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Paused;
+    protected virtual void OnPaused() {
+      ExecutionState = ExecutionState.Paused;
+      EventHandler handler = Paused;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler Stopped;
+    protected virtual void OnStopped() {
+      ExecutionState = ExecutionState.Stopped;
+      foreach (IStatefulItem statefulObject in this.GetObjectGraphObjects().OfType<IStatefulItem>()) {
+        statefulObject.ClearState();
+      }
+      runsCounter++;
+      runs.Add(new Run(string.Format("{0} Run {1}", Name, runsCounter), this));
+      EventHandler handler = Stopped;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler<EventArgs<Exception>> ExceptionOccurred;
+    protected virtual void OnExceptionOccurred(Exception exception) {
+      EventHandler<EventArgs<Exception>> handler = ExceptionOccurred;
+      if (handler != null) handler(this, new EventArgs<Exception>(exception));
+    }
+
+    public event EventHandler<CancelEventArgs<string>> NameChanging;
+    protected virtual void OnNameChanging(CancelEventArgs<string> e) {
+      var handler = NameChanging;
+      if (handler != null) handler(this, e);
+    }
+
+    public event EventHandler NameChanged;
+    protected virtual void OnNameChanged() {
+      var handler = NameChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+      OnToStringChanged();
+    }
+
+    public event EventHandler DescriptionChanged;
+    protected virtual void OnDescriptionChanged() {
+      var handler = DescriptionChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    protected virtual void DeregisterProblemEvents() {
+      problem.OperatorsChanged -= new EventHandler(Problem_OperatorsChanged);
+      problem.Reset -= new EventHandler(Problem_Reset);
+    }
+    protected virtual void RegisterProblemEvents() {
+      problem.OperatorsChanged += new EventHandler(Problem_OperatorsChanged);
+      problem.Reset += new EventHandler(Problem_Reset);
+    }
+    protected virtual void Problem_OperatorsChanged(object sender, EventArgs e) { }
+    protected virtual void Problem_Reset(object sender, EventArgs e) {
+      Prepare();
+    }
+
+    protected virtual void DeregisterRunsEvents() {
+      runs.CollectionReset -= new CollectionItemsChangedEventHandler<IRun>(Runs_CollectionReset);
+    }
+    protected virtual void RegisterRunsEvents() {
+      runs.CollectionReset += new CollectionItemsChangedEventHandler<IRun>(Runs_CollectionReset);
+    }
+    protected virtual void Runs_CollectionReset(object sender, CollectionItemsChangedEventArgs<IRun> e) {
+      runsCounter = runs.Count;
+    }
+
+    #endregion
+
+    #region Clone
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new Benchmark(this, cloner);
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/DhrystoneBenchmark.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/DhrystoneBenchmark.cs	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/DhrystoneBenchmark.cs	(revision 7006)
@@ -0,0 +1,421 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using System.Threading;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.Benchmarks {
+  [Item("Dhrystone Algorithm", "Dhrystone benchmarking algorithm.")]
+  [StorableClass]
+  public class DhrystoneBenchmark : IBenchmark {
+    [Storable]
+    private byte[][] chunk;
+    public byte[][] ChunkData {
+      get { return chunk; }
+      set { chunk = value; }
+    }
+
+    [Storable]
+    private TimeSpan timeLimit;
+    public TimeSpan TimeLimit {
+      get { return timeLimit; }
+      set { timeLimit = value; }
+    }
+
+    private bool stopBenchmark;
+
+    private CancellationToken cancellationToken;
+
+    public string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+
+    public string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+
+    public Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Event; }
+    }
+
+    #region Benchmark Fields
+
+    private const int Ident_1 = 0;
+    private const int Ident_2 = 1;
+    private const int Ident_3 = 2;
+    private const int Ident_4 = 3;
+    private const int Ident_5 = 4;
+
+    private Record_Type Record_Glob;
+    private Record_Type Next_Record_Glob;
+
+    private int Int_Glob;
+    private Boolean Bool_Glob;
+
+    private char Char_Glob_1;
+    private char Char_Glob_2;
+
+    private int[] Array_Glob_1 = new int[128];
+    private int[][] Array_Glob_2 = new int[128][];
+
+    private Record_Type First_Record = new Record_Type();
+    private Record_Type Second_Record = new Record_Type();
+
+    private long Default_Number_Of_Runs = 10000000;
+
+    #endregion
+
+    #region Costructors
+
+    [StorableConstructor]
+    public DhrystoneBenchmark(bool deserializing) { }
+
+    public DhrystoneBenchmark() { }
+
+    protected DhrystoneBenchmark(DhrystoneBenchmark original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+    }
+
+    #endregion
+
+    #region Benchmark Methods
+    // implementation based on Java version: http://www.okayan.jp/DhrystoneApplet/dhry_src.jar
+
+    public void Run(CancellationToken token, ResultCollection results) {
+      cancellationToken = token;
+      stopBenchmark = false;
+
+      int Int_Loc_1;
+      int Int_Loc_2;
+      int Int_Loc_3;
+
+      int[] Int_Loc_1_Ref = new int[1];
+      int[] Int_Loc_3_Ref = new int[1];
+
+      char Char_Index;
+      int[] Enum_Loc = new int[1];
+
+      string String_Loc_1;
+      string String_Loc_2;
+
+      long total_time;
+
+      long Run_Index;
+
+      Next_Record_Glob = Second_Record;
+      Record_Glob = First_Record;
+
+      Record_Glob.Record_Comp = Next_Record_Glob;
+      Record_Glob.Discr = Ident_1;
+      Record_Glob.Enum_Comp = Ident_3;
+      Record_Glob.Int_Comp = 40;
+      Record_Glob.String_Comp = "DHRYSTONE PROGRAM, SOME STRING";
+      String_Loc_1 = "DHRYSTONE PROGRAM, 1'ST STRING";
+
+      for (int i = 0; i < 128; i++) {
+        Array_Glob_2[i] = new int[128];
+      }
+
+      Stopwatch sw = new Stopwatch();
+      sw.Start();
+
+      Run_Index = 1;
+      while (!stopBenchmark) {
+        Proc_5();
+        Proc_4();
+
+        Int_Loc_1 = 2;
+        Int_Loc_2 = 3;
+
+        String_Loc_2 = "DHRYSTONE PROGRAM, 2'ND STRING";
+
+        Enum_Loc[0] = Ident_2;
+        Bool_Glob = !Func_2(String_Loc_1, String_Loc_2);
+
+        while (Int_Loc_1 < Int_Loc_2) {
+          Int_Loc_3_Ref[0] = 5 * Int_Loc_1 - Int_Loc_2;
+          Proc_7(Int_Loc_1, Int_Loc_2, Int_Loc_3_Ref);
+          Int_Loc_1 += 1;
+        }
+
+        Int_Loc_3 = Int_Loc_3_Ref[0];
+        Proc_8(Array_Glob_1, Array_Glob_2, Int_Loc_1, Int_Loc_3);
+        Proc_1(Record_Glob);
+
+        for (Char_Index = 'A'; Char_Index <= Char_Glob_2; ++Char_Index) {
+          if (Enum_Loc[0] == Func_1(Char_Index, 'C'))
+            Proc_6(Ident_1, Enum_Loc);
+        }
+
+        Int_Loc_3 = Int_Loc_2 * Int_Loc_1;
+        Int_Loc_2 = Int_Loc_3 / Int_Loc_1;
+        Int_Loc_2 = 7 * (Int_Loc_3 - Int_Loc_2) - Int_Loc_1;
+
+        Int_Loc_1_Ref[0] = Int_Loc_1;
+        Proc_2(Int_Loc_1_Ref);
+        Int_Loc_1 = Int_Loc_1_Ref[0];
+
+        if (cancellationToken.IsCancellationRequested) {
+          throw new OperationCanceledException(cancellationToken);
+        }
+
+        if ((timeLimit == null) || (timeLimit.TotalMilliseconds == 0)) {
+          if (Run_Index > Default_Number_Of_Runs) {
+            stopBenchmark = true;
+          }
+        } else if (sw.Elapsed > timeLimit) {
+          stopBenchmark = true;
+        }
+
+        Run_Index++;
+      }
+
+      sw.Stop();
+      total_time = sw.ElapsedMilliseconds;
+
+      results.Add(new Result("DIPS", new DoubleValue(Run_Index * 1000 / total_time)));
+
+    }
+
+    private int Func_1(char Char_Par_1_Val, char Char_Par_2_Val) {
+      char Char_Loc_1;
+      char Char_Loc_2;
+
+      Char_Loc_1 = Char_Par_1_Val;
+      Char_Loc_2 = Char_Loc_1;
+      if (Char_Loc_2 != Char_Par_2_Val)
+        return Ident_1;
+      else
+        return Ident_2;
+    }
+
+    private bool Func_2(string String_Par_1_Ref, string String_Par_2_Ref) {
+      int Int_Loc;
+      char Char_Loc = '\0';
+
+      Int_Loc = 2;
+
+      while (Int_Loc <= 2) {
+        if (Func_1(String_Par_1_Ref[Int_Loc], String_Par_2_Ref[Int_Loc + 1]) == Ident_1) {
+          Char_Loc = 'A';
+          Int_Loc += 1;
+        }
+      }
+      if (Char_Loc >= 'W' && Char_Loc < 'z')
+        Int_Loc = 7;
+      if (Char_Loc == 'X')
+        return true;
+      else {
+        if (String_Par_1_Ref.CompareTo(String_Par_2_Ref) > 0) {
+          Int_Loc += 7;
+          return true;
+        } else
+          return false;
+      }
+    }
+
+    private bool Func_3(int Enum_Par_Val) {
+      int Enum_Loc;
+
+      Enum_Loc = Enum_Par_Val;
+      if (Enum_Loc == Ident_3)
+        return true;
+      else
+        return false;
+    }
+
+    private void Proc_1(Record_Type Pointer_Par_Val) {
+      Record_Type Next_Record = Pointer_Par_Val.Record_Comp;
+
+      Pointer_Par_Val.Record_Comp = Record_Glob;
+
+      Pointer_Par_Val.Int_Comp = 5;
+
+      Next_Record.Int_Comp = Pointer_Par_Val.Int_Comp;
+      Next_Record.Record_Comp = Pointer_Par_Val.Record_Comp;
+      Proc_3(Next_Record.Record_Comp);
+
+      int[] Int_Ref = new int[1];
+
+      if (Next_Record.Discr == Ident_1) {
+        Next_Record.Int_Comp = 6;
+        Int_Ref[0] = Next_Record.Enum_Comp;
+        Proc_6(Pointer_Par_Val.Enum_Comp, Int_Ref);
+        Next_Record.Enum_Comp = Int_Ref[0];
+        Next_Record.Record_Comp = Record_Glob.Record_Comp;
+        Int_Ref[0] = Next_Record.Int_Comp;
+        Proc_7(Next_Record.Int_Comp, 10, Int_Ref);
+        Next_Record.Int_Comp = Int_Ref[0];
+      } else
+        Pointer_Par_Val = Pointer_Par_Val.Record_Comp;
+    }
+
+    private void Proc_2(int[] Int_Par_Ref) {
+      int Int_Loc;
+      int Enum_Loc;
+
+      Int_Loc = Int_Par_Ref[0] + 10;
+      Enum_Loc = 0;
+
+      do
+        if (Char_Glob_1 == 'A') {
+          Int_Loc -= 1;
+          Int_Par_Ref[0] = Int_Loc - Int_Glob;
+          Enum_Loc = Ident_1;
+        }
+      while (Enum_Loc != Ident_1);
+    }
+
+    private void Proc_3(Record_Type Pointer_Par_Ref) {
+      if (Record_Glob != null)
+        Pointer_Par_Ref = Record_Glob.Record_Comp;
+      else
+        Int_Glob = 100;
+
+      int[] Int_Comp_Ref = new int[1];
+      Int_Comp_Ref[0] = Record_Glob.Int_Comp;
+      Proc_7(10, Int_Glob, Int_Comp_Ref);
+      Record_Glob.Int_Comp = Int_Comp_Ref[0];
+    }
+
+    private void Proc_4() {
+      bool Bool_Loc;
+
+      Bool_Loc = Char_Glob_1 == 'A';
+      Bool_Loc = Bool_Loc || Bool_Glob;
+      Char_Glob_2 = 'B';
+    }
+
+    private void Proc_5() {
+      Char_Glob_1 = 'A';
+      Bool_Glob = false;
+    }
+
+    private void Proc_6(int Enum_Par_Val, int[] Enum_Par_Ref) {
+
+      Enum_Par_Ref[0] = Enum_Par_Val;
+
+      if (!Func_3(Enum_Par_Val))
+        Enum_Par_Ref[0] = Ident_4;
+
+      switch (Enum_Par_Val) {
+        case Ident_1:
+          Enum_Par_Ref[0] = Ident_1;
+          break;
+
+        case Ident_2:
+          if (Int_Glob > 100)
+            Enum_Par_Ref[0] = Ident_1;
+          else
+            Enum_Par_Ref[0] = Ident_4;
+          break;
+
+        case Ident_3:
+          Enum_Par_Ref[0] = Ident_2;
+          break;
+
+        case Ident_4:
+          break;
+
+        case Ident_5:
+          Enum_Par_Ref[0] = Ident_3;
+          break;
+      }
+    }
+
+    private void Proc_7(int Int_Par_Val1, int Int_Par_Val2, int[] Int_Par_Ref) {
+      int Int_Loc;
+      Int_Loc = Int_Par_Val1 + 2;
+      Int_Par_Ref[0] = Int_Par_Val2 + Int_Loc;
+    }
+
+    private void Proc_8(int[] Array_Par_1_Ref, int[][] Array_Par_2_Ref, int Int_Par_Val_1, int Int_Par_Val_2) {
+      int Int_Index;
+      int Int_Loc;
+
+      Int_Loc = Int_Par_Val_1 + 5;
+      Array_Par_1_Ref[Int_Loc] = Int_Par_Val_2;
+      Array_Par_1_Ref[Int_Loc + 1] = Array_Par_1_Ref[Int_Loc];
+      Array_Par_1_Ref[Int_Loc + 30] = Int_Loc;
+
+      for (Int_Index = Int_Loc; Int_Index <= Int_Loc + 1; ++Int_Index)
+        Array_Par_2_Ref[Int_Loc][Int_Index] = Int_Loc;
+      Array_Par_2_Ref[Int_Loc][Int_Loc - 1] += 1;
+      Array_Par_2_Ref[Int_Loc + 20][Int_Loc] = Array_Par_1_Ref[Int_Loc];
+      Int_Glob = 5;
+    }
+
+    #endregion
+
+    #region Private Class
+
+    private class Record_Type {
+      public Record_Type Record_Comp;
+      public int Discr;
+      public int Enum_Comp;
+      public int Int_Comp;
+      public string String_Comp;
+    }
+
+    #endregion
+
+    #region Clone
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new DhrystoneBenchmark(this, cloner);
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    #endregion
+
+    #region Events
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    #endregion
+
+
+  }
+}
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/HeuristicLab.Algorithms.Benchmarks-3.3.csproj
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/HeuristicLab.Algorithms.Benchmarks-3.3.csproj	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/HeuristicLab.Algorithms.Benchmarks-3.3.csproj	(revision 7006)
@@ -0,0 +1,178 @@
+﻿<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{068C70A7-8CAF-4AB6-8721-4564D62292BC}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>HeuristicLab.Algorithms.Benchmarks</RootNamespace>
+    <AssemblyName>HeuristicLab.Algorithms.Benchmarks-3.3</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+    <DocumentationFile>
+    </DocumentationFile>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <DocumentationFile>
+    </DocumentationFile>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Core" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Xml.Linq" />
+    <Reference Include="System.Data.DataSetExtensions" />
+    <Reference Include="Microsoft.CSharp" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Benchmark.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="DhrystoneBenchmark.cs" />
+    <Compile Include="IBenchmark.cs" />
+    <Compile Include="LinpackBenchmark.cs" />
+    <Compile Include="Plugin.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="WhetstoneBenchmark.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="HeuristicLab.snk" />
+    <None Include="Plugin.cs.frame" />
+    <None Include="Properties\AssemblyInfo.cs.frame" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
+      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
+      <Name>HeuristicLab.Collections-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
+      <Project>{0E27A536-1C4A-4624-A65E-DC4F4F23E3E1}</Project>
+      <Name>HeuristicLab.Common.Resources-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
+      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
+      <Name>HeuristicLab.Common-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
+      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
+      <Name>HeuristicLab.Core-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
+      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
+      <Name>HeuristicLab.Data-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Operators\3.3\HeuristicLab.Operators-3.3.csproj">
+      <Project>{23DA7FF4-D5B8-41B6-AA96-F0561D24F3EE}</Project>
+      <Name>HeuristicLab.Operators-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
+      <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
+      <Name>HeuristicLab.Optimization-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
+      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
+      <Name>HeuristicLab.Parameters-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
+      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
+      <Name>HeuristicLab.Persistence-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
+      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
+      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
+      <Private>False</Private>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <PropertyGroup>
+    <PreBuildEvent>set Path=%25Path%25;$(ProjectDir);$(SolutionDir)
+set ProjectDir=$(ProjectDir)
+set SolutionDir=$(SolutionDir)
+set Outdir=$(Outdir)
+
+call PreBuildEvent.cmd
+</PreBuildEvent>
+  </PropertyGroup>
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/IBenchmark.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/IBenchmark.cs	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/IBenchmark.cs	(revision 7006)
@@ -0,0 +1,32 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Threading;
+using HeuristicLab.Core;
+using HeuristicLab.Optimization;
+namespace HeuristicLab.Algorithms.Benchmarks {
+  public interface IBenchmark : IItem {
+    byte[][] ChunkData { get; set; }
+    TimeSpan TimeLimit { get; set; }
+    void Run(CancellationToken cancellationToken, ResultCollection resuls);
+  }
+}
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/LinpackBenchmark.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/LinpackBenchmark.cs	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/LinpackBenchmark.cs	(revision 7006)
@@ -0,0 +1,564 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using System.Threading;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.Benchmarks {
+  [Item("Linpack Algorithm", "Linpack benchmarking algorithm.")]
+  [StorableClass]
+  public class LinpackBenchmark : IBenchmark {
+    [Storable]
+    private byte[][] chunk;
+    public byte[][] ChunkData {
+      get { return chunk; }
+      set { chunk = value; }
+    }
+
+    [Storable]
+    private TimeSpan timeLimit;
+    public TimeSpan TimeLimit {
+      get { return timeLimit; }
+      set { timeLimit = value; }
+    }
+
+    private bool stopBenchmark;
+
+    private CancellationToken cancellationToken;
+
+    public string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+
+    public string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+
+    public Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Event; }
+    }
+
+    #region Benchmark Fields
+
+    private const int DEFAULT_PSIZE = 1500;
+
+    private double eps_result = 0.0;
+    private double mflops_result = 0.0;
+    private double residn_result = 0.0;
+    private double time_result = 0.0;
+    private double total = 0.0;
+
+    private Stopwatch sw = new Stopwatch();
+
+    #endregion
+
+    #region Costructors
+
+    [StorableConstructor]
+    public LinpackBenchmark(bool deserializing) { }
+
+    public LinpackBenchmark() { }
+
+    public LinpackBenchmark(LinpackBenchmark original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+    }
+
+    #endregion
+
+    #region Linpack Benchmark
+    // implementation based on Java version: http://www.netlib.org/benchmark/linpackjava/
+
+    public void Run(CancellationToken token, ResultCollection results) {
+      cancellationToken = token;
+      stopBenchmark = false;
+      TimeSpan executionTime = new TimeSpan();
+      bool resultAchieved = false;
+      do {
+        int n = DEFAULT_PSIZE;
+        int ldaa = DEFAULT_PSIZE;
+        int lda = DEFAULT_PSIZE + 1;
+
+        double[][] a = new double[ldaa][];
+        double[] b = new double[ldaa];
+        double[] x = new double[ldaa];
+
+        double ops;
+        double norma;
+        double normx;
+        double resid;
+        int i;
+        int info;
+        int[] ipvt = new int[ldaa];
+
+        for (i = 0; i < ldaa; i++) {
+          a[i] = new double[lda];
+        }
+
+        ops = (2.0e0 * (((double)n) * n * n)) / 3.0 + 2.0 * (n * n);
+
+        norma = mathGen(a, lda, n, b);
+
+        if (cancellationToken.IsCancellationRequested) {
+          throw new OperationCanceledException(cancellationToken);
+        }
+
+        sw.Reset();
+        sw.Start();
+
+        info = dgefa(a, lda, n, ipvt);
+
+        if (cancellationToken.IsCancellationRequested) {
+          throw new OperationCanceledException(cancellationToken);
+        }
+
+        dgesl(a, lda, n, ipvt, b, 0);
+
+        sw.Stop();
+        total = sw.Elapsed.TotalMilliseconds / 1000;
+
+        if (cancellationToken.IsCancellationRequested) {
+          throw new OperationCanceledException(cancellationToken);
+        }
+
+        for (i = 0; i < n; i++) {
+          x[i] = b[i];
+        }
+
+        norma = mathGen(a, lda, n, b);
+
+        for (i = 0; i < n; i++) {
+          b[i] = -b[i];
+        }
+
+        dmxpy(n, b, n, lda, x, a);
+
+        resid = 0.0;
+        normx = 0.0;
+
+        for (i = 0; i < n; i++) {
+          resid = (resid > abs(b[i])) ? resid : abs(b[i]);
+          normx = (normx > abs(x[i])) ? normx : abs(x[i]);
+        }
+
+        eps_result = epslon((double)1.0);
+
+        residn_result = resid / (n * norma * normx * eps_result);
+        residn_result += 0.005; // for rounding
+        residn_result = (int)(residn_result * 100);
+        residn_result /= 100;
+
+        time_result = total;
+        time_result += 0.005; // for rounding
+        time_result = (int)(time_result * 100);
+        time_result /= 100;
+
+        mflops_result = ops / (1.0e6 * total);
+        mflops_result += 0.0005; // for rounding
+        mflops_result = (int)(mflops_result * 1000);
+        mflops_result /= 1000;
+
+        if (!resultAchieved) {
+          results.Add(new Result("Mflops/s", new DoubleValue(mflops_result)));
+          results.Add(new Result("total Mflops/s", new DoubleValue(mflops_result * Environment.ProcessorCount)));
+          resultAchieved = true;
+        }
+
+        executionTime += sw.Elapsed;
+        if ((timeLimit == null) || (timeLimit.TotalMilliseconds == 0))
+          stopBenchmark = true;
+        else if (executionTime > timeLimit)
+          stopBenchmark = true;
+      } while (!stopBenchmark);
+    }
+
+    private double abs(double d) {
+      return (d >= 0) ? d : -d;
+    }
+
+    private double mathGen(double[][] a, int lda, int n, double[] b) {
+      Random gen;
+      double norma;
+      int init, i, j;
+
+      init = 1325;
+      norma = 0.0;
+
+      gen = new Random(init);
+
+      if (cancellationToken.IsCancellationRequested) {
+        throw new OperationCanceledException(cancellationToken);
+      }
+
+      // Next two for() statements switched.  Solver wants
+      // matrix in column order. --dmd 3/3/97
+
+      for (i = 0; i < n; i++) {
+        for (j = 0; j < n; j++) {
+          a[j][i] = gen.NextDouble() - .5;
+          norma = (a[j][i] > norma) ? a[j][i] : norma;
+        }
+      }
+
+      for (i = 0; i < n; i++) {
+        b[i] = 0.0;
+      }
+
+      for (j = 0; j < n; j++) {
+        for (i = 0; i < n; i++) {
+          b[i] += a[j][i];
+        }
+      }
+
+      return norma;
+    }
+
+    private int dgefa(double[][] a, int lda, int n, int[] ipvt) {
+      double[] col_k, col_j;
+      double t;
+      int j, k, kp1, l, nm1;
+      int info;
+
+      if (cancellationToken.IsCancellationRequested) {
+        throw new OperationCanceledException(cancellationToken);
+      }
+
+      // gaussian elimination with partial pivoting
+
+      info = 0;
+      nm1 = n - 1;
+      if (nm1 >= 0) {
+        for (k = 0; k < nm1; k++) {
+          col_k = a[k];
+          kp1 = k + 1;
+
+          // find l = pivot index
+
+          l = idamax(n - k, col_k, k, 1) + k;
+          ipvt[k] = l;
+
+          // zero pivot implies this column already triangularized
+
+          if (col_k[l] != 0) {
+            // interchange if necessary
+
+            if (l != k) {
+              t = col_k[l];
+              col_k[l] = col_k[k];
+              col_k[k] = t;
+            }
+
+            if (cancellationToken.IsCancellationRequested) {
+              throw new OperationCanceledException(cancellationToken);
+            }
+
+            // compute multipliers
+
+            t = -1.0 / col_k[k];
+            dscal(n - (kp1), t, col_k, kp1, 1);
+
+            if (cancellationToken.IsCancellationRequested) {
+              throw new OperationCanceledException(cancellationToken);
+            }
+
+            // row elimination with column indexing
+
+            for (j = kp1; j < n; j++) {
+              col_j = a[j];
+              t = col_j[l];
+              if (l != k) {
+                col_j[l] = col_j[k];
+                col_j[k] = t;
+              }
+              daxpy(n - (kp1), t, col_k, kp1, 1,
+                col_j, kp1, 1);
+            }
+          } else {
+            info = k;
+          }
+        }
+      }
+
+      ipvt[n - 1] = n - 1;
+      if (a[(n - 1)][(n - 1)] == 0) info = n - 1;
+
+      return info;
+    }
+
+    private void dgesl(double[][] a, int lda, int n, int[] ipvt, double[] b, int job) {
+      double t;
+      int k, kb, l, nm1, kp1;
+
+      if (cancellationToken.IsCancellationRequested) {
+        throw new OperationCanceledException(cancellationToken);
+      }
+
+      nm1 = n - 1;
+      if (job == 0) {
+        // job = 0 , solve  a * x = b.  first solve  l*y = b
+
+        if (nm1 >= 1) {
+          for (k = 0; k < nm1; k++) {
+            l = ipvt[k];
+            t = b[l];
+            if (l != k) {
+              b[l] = b[k];
+              b[k] = t;
+            }
+            kp1 = k + 1;
+            daxpy(n - (kp1), t, a[k], kp1, 1, b, kp1, 1);
+          }
+        }
+
+        if (cancellationToken.IsCancellationRequested) {
+          throw new OperationCanceledException(cancellationToken);
+        }
+
+        // now solve  u*x = y
+
+        for (kb = 0; kb < n; kb++) {
+          k = n - (kb + 1);
+          b[k] /= a[k][k];
+          t = -b[k];
+          daxpy(k, t, a[k], 0, 1, b, 0, 1);
+        }
+      } else {
+        // job = nonzero, solve  trans(a) * x = b.  first solve  trans(u)*y = b
+
+        for (k = 0; k < n; k++) {
+          t = ddot(k, a[k], 0, 1, b, 0, 1);
+          b[k] = (b[k] - t) / a[k][k];
+        }
+
+        if (cancellationToken.IsCancellationRequested) {
+          throw new OperationCanceledException(cancellationToken);
+        }
+
+        // now solve trans(l)*x = y 
+
+        if (nm1 >= 1) {
+          //for (kb = 1; kb < nm1; kb++) {
+          for (kb = 0; kb < nm1; kb++) {
+            k = n - (kb + 1);
+            kp1 = k + 1;
+            b[k] += ddot(n - (kp1), a[k], kp1, 1, b, kp1, 1);
+            l = ipvt[k];
+            if (l != k) {
+              t = b[l];
+              b[l] = b[k];
+              b[k] = t;
+            }
+          }
+        }
+      }
+    }
+
+    private void daxpy(int n, double da, double[] dx, int dx_off, int incx, double[] dy, int dy_off, int incy) {
+      int i, ix, iy;
+
+      if (cancellationToken.IsCancellationRequested) {
+        throw new OperationCanceledException(cancellationToken);
+      }
+
+      if ((n > 0) && (da != 0)) {
+        if (incx != 1 || incy != 1) {
+
+          // code for unequal increments or equal increments not equal to 1
+
+          ix = 0;
+          iy = 0;
+          if (incx < 0) ix = (-n + 1) * incx;
+          if (incy < 0) iy = (-n + 1) * incy;
+          for (i = 0; i < n; i++) {
+            dy[iy + dy_off] += da * dx[ix + dx_off];
+            ix += incx;
+            iy += incy;
+          }
+          return;
+        } else {
+          // code for both increments equal to 1
+
+          for (i = 0; i < n; i++)
+            dy[i + dy_off] += da * dx[i + dx_off];
+        }
+      }
+    }
+
+    private double ddot(int n, double[] dx, int dx_off, int incx, double[] dy, int dy_off, int incy) {
+      double dtemp = 0;
+      int i, ix, iy;
+
+      if (cancellationToken.IsCancellationRequested) {
+        throw new OperationCanceledException(cancellationToken);
+      }
+
+      if (n > 0) {
+        if (incx != 1 || incy != 1) {
+          // code for unequal increments or equal increments not equal to 1
+
+          ix = 0;
+          iy = 0;
+          if (incx < 0) ix = (-n + 1) * incx;
+          if (incy < 0) iy = (-n + 1) * incy;
+          for (i = 0; i < n; i++) {
+            dtemp += dx[ix + dx_off] * dy[iy + dy_off];
+            ix += incx;
+            iy += incy;
+          }
+        } else {
+          // code for both increments equal to 1
+
+          for (i = 0; i < n; i++)
+            dtemp += dx[i + dx_off] * dy[i + dy_off];
+        }
+      }
+      return (dtemp);
+    }
+
+    private void dscal(int n, double da, double[] dx, int dx_off, int incx) {
+      int i, nincx;
+
+      if (cancellationToken.IsCancellationRequested) {
+        throw new OperationCanceledException(cancellationToken);
+      }
+
+      if (n > 0) {
+        if (incx != 1) {
+          // code for increment not equal to 1
+
+          nincx = n * incx;
+          for (i = 0; i < nincx; i += incx)
+            dx[i + dx_off] *= da;
+        } else {
+          // code for increment equal to 1
+
+          for (i = 0; i < n; i++)
+            dx[i + dx_off] *= da;
+        }
+      }
+    }
+
+    private int idamax(int n, double[] dx, int dx_off, int incx) {
+      double dmax, dtemp;
+      int i, ix, itemp = 0;
+
+      if (cancellationToken.IsCancellationRequested) {
+        throw new OperationCanceledException(cancellationToken);
+      }
+
+      if (n < 1) {
+        itemp = -1;
+      } else if (n == 1) {
+        itemp = 0;
+      } else if (incx != 1) {
+        // code for increment not equal to 1
+
+        dmax = (dx[dx_off] < 0.0) ? -dx[dx_off] : dx[dx_off];
+        ix = 1 + incx;
+        for (i = 0; i < n; i++) {
+          dtemp = (dx[ix + dx_off] < 0.0) ? -dx[ix + dx_off] : dx[ix + dx_off];
+          if (dtemp > dmax) {
+            itemp = i;
+            dmax = dtemp;
+          }
+          ix += incx;
+        }
+      } else {
+        // code for increment equal to 1
+
+        itemp = 0;
+        dmax = (dx[dx_off] < 0.0) ? -dx[dx_off] : dx[dx_off];
+        for (i = 0; i < n; i++) {
+          dtemp = (dx[i + dx_off] < 0.0) ? -dx[i + dx_off] : dx[i + dx_off];
+          if (dtemp > dmax) {
+            itemp = i;
+            dmax = dtemp;
+          }
+        }
+      }
+      return (itemp);
+    }
+
+    private double epslon(double x) {
+      double a, b, c, eps;
+
+      a = 4.0e0 / 3.0e0;
+      eps = 0;
+      while (eps == 0) {
+        b = a - 1.0;
+        c = b + b + b;
+        eps = abs(c - 1.0);
+      }
+      return (eps * abs(x));
+    }
+
+    private void dmxpy(int n1, double[] y, int n2, int ldm, double[] x, double[][] m) {
+      int j, i;
+
+      // cleanup odd vector
+      for (j = 0; j < n2; j++) {
+        for (i = 0; i < n1; i++) {
+          y[i] += x[j] * m[j][i];
+        }
+      }
+    }
+
+    #endregion
+
+    #region Clone
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new LinpackBenchmark(this, cloner);
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    #endregion
+
+    #region Events
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Plugin.cs.frame
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Plugin.cs.frame	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Plugin.cs.frame	(revision 7006)
@@ -0,0 +1,40 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.PluginInfrastructure;
+
+namespace HeuristicLab.Algorithms.Benchmarks {
+  /// <summary>
+  /// Plugin class for HeuristicLab.Algorithms.Benchmark plugin.
+  /// </summary>
+  [Plugin("HeuristicLab.Algorithms.Benchmarks", "Provides different benchmarking algorithms", "3.3.5.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.Benchmarks-3.3.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.Collections", "3.3")]
+  [PluginDependency("HeuristicLab.Common", "3.3")]
+  [PluginDependency("HeuristicLab.Common.Resources", "3.3")]
+  [PluginDependency("HeuristicLab.Core", "3.3")]
+  [PluginDependency("HeuristicLab.Data", "3.3")]   
+  [PluginDependency("HeuristicLab.Optimization", "3.3")]
+  [PluginDependency("HeuristicLab.Parameters", "3.3")]
+  [PluginDependency("HeuristicLab.Persistence", "3.3")] 
+  public class HeuristicLabAlgorithmsBenchmarksPlugin : PluginBase {
+  }
+}
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Properties/AssemblyInfo.cs.frame	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/Properties/AssemblyInfo.cs.frame	(revision 7006)
@@ -0,0 +1,55 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("HeuristicLab.Algorithms.Benchmarks")]
+[assembly: AssemblyDescription("Benchmarking")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("HeuristicLab")]
+[assembly: AssemblyCopyright("(c) 2002-2011 HEAL")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("3E422463-0CE0-400D-9544-5C11D5818769")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Revision and Build Numbers 
+// by using the '*' as shown below:
+[assembly: AssemblyVersion("3.3.0.0")]
+[assembly: AssemblyFileVersion("3.3.5.$WCREV$")]
Index: trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/WhetstoneBenchmark.cs
===================================================================
--- trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/WhetstoneBenchmark.cs	(revision 7006)
+++ trunk/sources/HeuristicLab.Algorithms.Benchmarks/3.3/WhetstoneBenchmark.cs	(revision 7006)
@@ -0,0 +1,323 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Diagnostics;
+using System.Drawing;
+using System.Threading;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Optimization;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.Benchmarks {
+  [Item("Whetstone Algorithm", "Whetstone benchmarking algorithm.")]
+  [StorableClass]
+  public class WhetstoneBenchmark : IBenchmark {
+    [Storable]
+    private byte[][] chunk;
+    public byte[][] ChunkData {
+      get { return chunk; }
+      set { chunk = value; }
+    }
+
+    [Storable]
+    private TimeSpan timeLimit;
+    public TimeSpan TimeLimit {
+      get { return timeLimit; }
+      set { timeLimit = value; }
+    }
+
+    private bool stopBenchmark;
+
+    private CancellationToken cancellationToken;
+
+    public string ItemName {
+      get { return ItemAttribute.GetName(this.GetType()); }
+    }
+
+    public string ItemDescription {
+      get { return ItemAttribute.GetDescription(this.GetType()); }
+    }
+
+    public Version ItemVersion {
+      get { return ItemAttribute.GetVersion(this.GetType()); }
+    }
+
+    public Image ItemImage {
+      get { return HeuristicLab.Common.Resources.VSImageLibrary.Event; }
+    }
+
+    #region Benchmark Fields
+
+    private long begin_time;
+    private long end_time;
+
+    private int ITERATIONS;
+    private int numberOfCycles;
+    private int cycleNo;
+    private double x1, x2, x3, x4, x, y, t, t1, t2;
+    private double[] z = new double[1];
+    private double[] e1 = new double[4];
+    private int i, j, k, l, n1, n2, n3, n4, n6, n7, n8, n9, n10, n11;
+
+    #endregion
+
+    #region Costructors
+
+    [StorableConstructor]
+    public WhetstoneBenchmark(bool deserializing) { }
+
+    public WhetstoneBenchmark() { }
+
+    protected WhetstoneBenchmark(WhetstoneBenchmark original, Cloner cloner) {
+      cloner.RegisterClonedObject(original, this);
+    }
+
+    #endregion
+
+    #region Whetstone Benchmark
+    // implementation based on Java version: www.aicas.com/download/Whetstone.java
+
+    public void Run(CancellationToken token, ResultCollection results) {
+      cancellationToken = token;
+      stopBenchmark = false;
+
+      ITERATIONS = 100; // ITERATIONS / 10 = Millions Whetstone instructions
+
+      numberOfCycles = 100;
+      int defaultNumberOfRuns = 10;
+      float elapsedTime = 0;
+      float meanTime = 0;
+      float rating = 0;
+      float meanRating = 0;
+      int intRating = 0;
+
+      long runNumber = 1;
+      Stopwatch sw = new Stopwatch();
+      sw.Start();
+
+      while (!stopBenchmark) {
+        elapsedTime = (float)(MainCalc() / 1000);
+        meanTime = meanTime + (elapsedTime * 1000 / numberOfCycles);
+        rating = (1000 * numberOfCycles) / elapsedTime;
+        meanRating = meanRating + rating;
+        intRating = (int)rating;
+        numberOfCycles += 10;
+
+        if (cancellationToken.IsCancellationRequested) {
+          throw new OperationCanceledException(cancellationToken);
+        }
+
+        if ((timeLimit == null) || (timeLimit.TotalMilliseconds == 0)) {
+          if (runNumber > defaultNumberOfRuns) {
+            stopBenchmark = true;
+          }
+        } else if (sw.Elapsed > timeLimit) {
+          stopBenchmark = true;
+        }
+
+        runNumber++;
+      }
+      sw.Stop();
+      meanTime = meanTime / runNumber;
+      meanRating = meanRating / runNumber;
+      intRating = (int)meanRating;
+
+      results.Add(new Result("MWIPS", new IntValue(intRating / 1000)));
+    }
+
+    private double MainCalc() {
+      // initialize constants
+      t = 0.499975;
+      t1 = 0.50025;
+      t2 = 2.0;
+
+      // set values of module weights
+      n1 = 0 * ITERATIONS;
+      n2 = 12 * ITERATIONS;
+      n3 = 14 * ITERATIONS;
+      n4 = 345 * ITERATIONS;
+      n6 = 210 * ITERATIONS;
+      n7 = 32 * ITERATIONS;
+      n8 = 899 * ITERATIONS;
+      n9 = 616 * ITERATIONS;
+      n10 = 0 * ITERATIONS;
+      n11 = 93 * ITERATIONS;
+
+      begin_time = DateTime.Now.Ticks / 10000; // get ms
+
+      for (cycleNo = 1; cycleNo <= numberOfCycles; cycleNo++) {
+        /* MODULE 1: simple identifiers */
+        x1 = 1.0;
+        x2 = x3 = x4 = -1.0;
+        for (i = 1; i <= n1; i += 1) {
+          x1 = (x1 + x2 + x3 - x4) * t;
+          x2 = (x1 + x2 - x3 + x4) * t; // correction: x2 = ( x1 + x2 - x3 - x4 ) * t;
+          x3 = (x1 - x2 + x3 + x4) * t; // correction: x3 = ( x1 - x2 + x3 + x4 ) * t;
+          x4 = (-x1 + x2 + x3 + x4) * t;
+        }
+
+        /* MODULE 2: array elements */
+        e1[0] = 1.0;
+        e1[1] = e1[2] = e1[3] = -1.0;
+        for (i = 1; i <= n2; i += 1) {
+          e1[0] = (e1[0] + e1[1] + e1[2] - e1[3]) * t;
+          e1[1] = (e1[0] + e1[1] - e1[2] + e1[3]) * t;
+          e1[2] = (e1[0] - e1[1] + e1[2] + e1[3]) * t;
+          e1[3] = (-e1[0] + e1[1] + e1[2] + e1[3]) * t;
+        }
+
+        /* MODULE 3: array as parameter */
+        for (i = 1; i <= n3; i += 1)
+          pa(e1);
+
+        /* MODULE 4: conditional jumps */
+        j = 1;
+        for (i = 1; i <= n4; i += 1) {
+          if (j == 1)
+            j = 2;
+          else
+            j = 3;
+          if (j > 2)
+            j = 0;
+          else
+            j = 1;
+          if (j < 1)
+            j = 1;
+          else
+            j = 0;
+        }
+
+        /* MODULE 5: omitted */
+
+        /* MODULE 6: integer arithmetic */
+        j = 1;
+        k = 2;
+        l = 3;
+        for (i = 1; i <= n6; i += 1) {
+          j = j * (k - j) * (l - k);
+          k = l * k - (l - j) * k;
+          l = (l - k) * (k + j);
+          e1[l - 2] = j + k + l; /* C arrays are zero based */
+          e1[k - 2] = j * k * l;
+        }
+
+        /* MODULE 7: trig. functions */
+        x = y = 0.5;
+        for (i = 1; i <= n7; i += 1) {
+          x = t * Math.Atan(t2 * Math.Sin(x) * Math.Cos(x) / (Math.Cos(x + y) + Math.Cos(x - y) - 1.0));
+          y = t * Math.Atan(t2 * Math.Sin(y) * Math.Cos(y) / (Math.Cos(x + y) + Math.Cos(x - y) - 1.0));
+        }
+
+        /* MODULE 8: procedure calls */
+        x = y = z[0] = 1.0;
+        for (i = 1; i <= n8; i += 1)
+          p3(x, y, z);
+
+        /* MODULE9: array references */
+        j = 0;
+        k = 1;
+        l = 2;
+        e1[0] = 1.0;
+        e1[1] = 2.0;
+        e1[2] = 3.0;
+        for (i = 1; i <= n9; i++)
+          p0();
+
+        /* MODULE10: integer arithmetic */
+        j = 2;
+        k = 3;
+        for (i = 1; i <= n10; i += 1) {
+          j = j + k;
+          k = j + k;
+          j = k - j;
+          k = k - j - j;
+        }
+
+        /* MODULE11: standard functions */
+        x = 0.75;
+        for (i = 1; i <= n11; i += 1)
+          x = Math.Sqrt(Math.Exp(Math.Log(x) / t1));
+      } /* for */
+
+      end_time = DateTime.Now.Ticks / 10000; // get ms
+
+      return (end_time - begin_time);
+    }
+
+    public void pa(double[] e) {
+      int j;
+      j = 0;
+      do {
+        e[0] = (e[0] + e[1] + e[2] - e[3]) * t;
+        e[1] = (e[0] + e[1] - e[2] + e[3]) * t;
+        e[2] = (e[0] - e[1] + e[2] + e[3]) * t;
+        e[3] = (-e[0] + e[1] + e[2] + e[3]) / t2;
+        j += 1;
+      }
+      while (j < 6);
+    }
+
+    public void p3(double x, double y, double[] z) {
+      x = t * (x + y);
+      y = t * (x + y);
+      z[0] = (x + y) / t2;
+    }
+
+    public void p0() {
+      e1[j] = e1[k];
+      e1[k] = e1[l];
+      e1[l] = e1[j];
+    }
+
+    #endregion
+
+    #region Clone
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new WhetstoneBenchmark(this, cloner);
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
+
+    #endregion
+
+    #region Events
+
+    public event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged() {
+      EventHandler handler = ItemImageChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public event EventHandler ToStringChanged;
+    protected virtual void OnToStringChanged() {
+      EventHandler handler = ToStringChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    #endregion
+  }
+}
Index: trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj
===================================================================
--- trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 7001)
+++ trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj	(revision 7006)
@@ -570,4 +570,12 @@
   </ItemGroup>
   <ItemGroup>
+    <ProjectReference Include="..\HeuristicLab.Algorithms.Benchmarks.Views\3.3\HeuristicLab.Algorithms.Benchmarks.Views-3.3.csproj">
+      <Project>{3C906172-E044-4DF0-B4FD-AA21192D5D3E}</Project>
+      <Name>HeuristicLab.Algorithms.Benchmarks.Views-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\HeuristicLab.Algorithms.Benchmarks\3.3\HeuristicLab.Algorithms.Benchmarks-3.3.csproj">
+      <Project>{068C70A7-8CAF-4AB6-8721-4564D62292BC}</Project>
+      <Name>HeuristicLab.Algorithms.Benchmarks-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\HeuristicLab.Algorithms.DataAnalysis.Views\3.4\HeuristicLab.Algorithms.DataAnalysis.Views-3.4.csproj">
       <Project>{A2330DB0-413D-4424-B4E6-591118E2B9F8}</Project>
