Added a faster random number generator, many performance improvements.

Luaancz · Luaancz · commit 13fcb60780fc · 2015-01-31T11:39:44.000+01:00
diff --git a/SalemOptimizer.sln b/SalemOptimizer.sln
@@ -19,4 +19,7 @@ Global
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
 	EndGlobalSection
+	GlobalSection(Performance) = preSolution
+		HasPerformanceSessions = true
+	EndGlobalSection
 EndGlobal
diff --git a/SalemOptimizer/EvaluationState.cs b/SalemOptimizer/EvaluationState.cs
@@ -9,22 +9,26 @@ public class EvaluationState
         private int[] proficiencies = new int[15];
         private int[] inspirationalUses = new int[InspirationalDatabase.Inspirationals.Count];
 
-        void AddProficiency(int kind, int value, double weight)
-        {
-            proficiencies[kind] += value;
-
-            Inspiration += (int)(value * weight);
-        }
-
         public void AddInspirational(Inspirational inspirational)
         {
             var uses = inspirationalUses[inspirational.Id]++;
-            var modifier = Math.Min(4d, 1d + uses * 0.5d);
+            var modifier = Math.Min(8, 2 + uses);
+            var givenProficiencies = inspirational.Proficiencies;
 
-            for (var i = 0; i < inspirational.Proficiencies.Length; i++)
+            var inspiration = 0;
+
+            for (var i = 0; i < givenProficiencies.Length; i++)
             {
-                AddProficiency(i, inspirational.Proficiencies[i], modifier);
+                var val = givenProficiencies[i];
+
+                if (val != 0)
+                {
+                    proficiencies[i] += val;
+                    inspiration += val * modifier;
+                }
             }
+
+            Inspiration += inspiration / 2;
         }
         
         public int GetValue(ProficiencyKind kind)
diff --git a/SalemOptimizer/Helper.cs b/SalemOptimizer/Helper.cs
diff --git a/SalemOptimizer/InspirationalBranch.cs b/SalemOptimizer/InspirationalBranch.cs
@@ -14,13 +14,13 @@ public InspirationalBranch(Solver solver)
         {
             this.solver = solver;
 
-            Inspirational = solver.AvailableInspirationals[Helper.GetInt(solver.AvailableInspirationals.Length)];
+            Inspirational = solver.AvailableInspirationals[solver.RandomHelper.GetShort(solver.AvailableInspirationals.Length)];
         }
 
         public InspirationalBranch CreateRandomNode()
         {
             var newNode = new InspirationalBranch(solver);
-            newNode.Inspirational = solver.AvailableInspirationals[Helper.GetInt(solver.AvailableInspirationals.Length)];
+            newNode.Inspirational = solver.AvailableInspirationals[solver.RandomHelper.GetShort(solver.AvailableInspirationals.Length)];
 
             return newNode;
         }
@@ -43,32 +43,32 @@ public IEnumerable<string> GetNames()
         
         public void Mutate()
         {
-            if (Helper.Mutate(100))
+            if (solver.RandomHelper.Mutate(100))
             {
-                Inspirational = solver.AvailableInspirationals[Helper.GetInt(solver.AvailableInspirationals.Length)];
+                Inspirational = solver.AvailableInspirationals[solver.RandomHelper.GetShort(solver.AvailableInspirationals.Length)];
             }
 
             if (LeftNode != null) LeftNode.Mutate();
             if (RightNode != null) RightNode.Mutate();
 
             if (LeftNode == null)
             {
-                if (Helper.Mutate(20)) LeftNode = CreateRandomNode();
-                else if (Helper.Mutate(20)) LeftNode = this.Clone();
+                if (solver.RandomHelper.Mutate(20)) LeftNode = CreateRandomNode();
+                else if (solver.RandomHelper.Mutate(20)) LeftNode = this.Clone(solver);
             }
             else
             {
-                if (Helper.Mutate(50)) LeftNode = null;
+                if (solver.RandomHelper.Mutate(50)) LeftNode = null;
             }
 
             if (RightNode == null)
             {
-                if (Helper.Mutate(20)) RightNode = CreateRandomNode();
-                else if (Helper.Mutate(20)) RightNode = this.Clone();
+                if (solver.RandomHelper.Mutate(20)) RightNode = CreateRandomNode();
+                else if (solver.RandomHelper.Mutate(20)) RightNode = this.Clone(solver);
             }
             else
             {
-                if (Helper.Mutate(50)) RightNode = null;
+                if (solver.RandomHelper.Mutate(50)) RightNode = null;
             }
         }
         
@@ -83,13 +83,13 @@ public void Evaluate(EvaluationState engine)
             }
         }
 
-        public InspirationalBranch Clone()
+        public InspirationalBranch Clone(Solver solver)
         {
             InspirationalBranch clone = new InspirationalBranch(solver);
             clone.Inspirational = Inspirational;
 
-            if (LeftNode != null) clone.LeftNode = LeftNode.Clone();
-            if (RightNode != null) clone.RightNode = RightNode.Clone();
+            if (LeftNode != null) clone.LeftNode = LeftNode.Clone(solver);
+            if (RightNode != null) clone.RightNode = RightNode.Clone(solver);
 
             return clone;
         }
@@ -102,7 +102,7 @@ public InspirationalBranch GetRandomNode()
             var nodes = new List<InspirationalBranch>();
             TraverseNode(this, nodes);
 
-            var index = Helper.GetInt(nodes.Count);
+            var index = solver.RandomHelper.GetShort(nodes.Count);
             return nodes[index];
         }
 
diff --git a/SalemOptimizer/Leaderboard.cs b/SalemOptimizer/Leaderboard.cs
@@ -27,7 +27,7 @@ public void AddOrganism(Organism organism)
             {
                 var tmp =
                     organisms
-                    .Union(new[] { organism.Clone() })
+                    .Union(new[] { organism.Clone(null) })
                     .GroupBy(i => i == null ? null : i.ToString())
                     .Select(i => i.First());
 
diff --git a/SalemOptimizer/MainForm.cs b/SalemOptimizer/MainForm.cs
@@ -186,7 +186,7 @@ private async Task FindSolution(bool useLastBest)
 
                 var bestOfAll = leaderboard.GetBest();
 
-                bestOrganisms = bestOfAll.Select(i => i.Clone()).ToArray();
+                bestOrganisms = bestOfAll.Select(i => i.Clone(null)).ToArray();
 
                 lvSolutions.Items.Clear();
 
diff --git a/SalemOptimizer/Organism.cs b/SalemOptimizer/Organism.cs
@@ -67,14 +67,14 @@ public void Tick()
         {
             InspirationalBranch clone = null;
 
-            clone = (InspirationalBranch)root.Clone();
+            clone = (InspirationalBranch)root.Clone(solver);
             clone.Mutate();
             
             var stateNew = new EvaluationState();
 
             var newResult = Evaluate(clone, stateNew, problem);
 
-            if (newResult.CostTotal < Solution.CostTotal || Helper.Mutate(10))
+            if (newResult.CostTotal < Solution.CostTotal || solver.RandomHelper.Mutate(10))
             {
                 root = clone;
                 Solution = newResult;
@@ -84,10 +84,10 @@ public void Tick()
             }
         }
 
-        public Organism Clone()
+        public Organism Clone(Solver solver)
         {
-            Organism clone = new Organism(solver, problem);
-            clone.root = this.root.Clone();
+            Organism clone = new Organism(solver ?? this.solver, problem);
+            clone.root = this.root.Clone(solver ?? this.solver);
             clone.Solution = this.Solution;
             clone.lastEvaluation = lastEvaluation;
             clone.cachedNames = cachedNames;
@@ -96,8 +96,8 @@ public Organism Clone()
 
         public Organism MakeCrossOver(Organism father)
         {
-            var child = this.Clone();
-            var fatherDna = father.GetRandomNode().Clone();
+            var child = this.Clone(solver);
+            var fatherDna = father.GetRandomNode().Clone(solver);
             var motherDna = child.GetRandomNode();
             motherDna.LeftNode = fatherDna.LeftNode;
             motherDna.RightNode = fatherDna.RightNode;
diff --git a/SalemOptimizer/RandomHelper.cs b/SalemOptimizer/RandomHelper.cs
@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace SalemOptimizer
+{
+    public class RandomHelper
+    {
+        private static Random basicRandom = new Random();
+        private RndXorshift rnd;
+
+        public RandomHelper()
+        {
+            lock (basicRandom)
+            {
+                rnd = new RndXorshift(basicRandom);
+            }
+        }
+
+        public ushort GetShort(int chance)
+        {
+            return (ushort)(rnd.Next() % chance);
+            //return (ushort)Math.Min(chance - 1, ((rnd.Next() * chance) / ushort.MaxValue));
+        }
+
+        public bool Mutate(int chance)
+        {
+            return GetShort(chance) == 1;
+        }
+    }
+}
diff --git a/SalemOptimizer/SalemOptimizer.csproj b/SalemOptimizer/SalemOptimizer.csproj
@@ -30,6 +30,7 @@
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <PropertyGroup>
     <StartupObject />
@@ -72,7 +73,8 @@
     </Compile>
     <Compile Include="SolutionInformation.cs" />
     <Compile Include="Solver.cs" />
-    <Compile Include="Helper.cs" />
+    <Compile Include="RandomHelper.cs" />
+    <Compile Include="Xorshift.cs" />
     <EmbeddedResource Include="MainForm.resx">
       <DependentUpon>MainForm.cs</DependentUpon>
     </EmbeddedResource>
diff --git a/SalemOptimizer/Solver.cs b/SalemOptimizer/Solver.cs
@@ -13,13 +13,15 @@ public class Solver
         private readonly Inspirational[] availableInspirationals;
         private readonly CancellationToken cancellationToken;
         private readonly Organism[] includedOrganisms;
+        public readonly RandomHelper RandomHelper;
 
         public Solver(Problem problem, Inspirational[] availableInspirationals, CancellationToken cancellationToken, Organism[] includedOrganisms)
         {
             this.problem = problem;
             this.availableInspirationals = availableInspirationals;
             this.cancellationToken = cancellationToken;
             this.includedOrganisms = includedOrganisms;
+            this.RandomHelper = new RandomHelper();
         }
 
         public Inspirational[] AvailableInspirationals { get { return availableInspirationals; } }
@@ -40,7 +42,7 @@ public Organism[] Solve(bool prune)
 
             if (includedOrganisms != null)
             {
-                foreach (var organism in includedOrganisms.Select(i => i.Clone()))
+                foreach (var organism in includedOrganisms.Select(i => i.Clone(this)))
                 {
                     organisms.Add(organism);
                     leaderboard.AddOrganism(organism);
@@ -83,24 +85,25 @@ public Organism[] Solve(bool prune)
                     }
                 }
 
-                if (Helper.GetInt(10) == 1)
+                if (RandomHelper.GetShort(10) == 1)
                 {
                     organisms.Remove(worst);
-                    Organism clone = best.Clone();
+                    Organism clone = best.Clone(this);
                     organisms.Add(clone);
                 }
-                else if (Helper.GetInt(30) == 1)
+                else if (RandomHelper.GetShort(30) == 1)
                 {
                     organisms.Remove(worst);
-                    int index = Helper.GetInt(organisms.Count);
-                    Organism clone = organisms[index].Clone();
+
+                    var index = RandomHelper.GetShort(organisms.Count);
+                    Organism clone = organisms[index].Clone(this);
                     organisms.Add(clone);
                 }
-                else if (Helper.GetInt(100) == 1)
+                else if (RandomHelper.GetShort(100) == 1)
                 {
                     organisms.Remove(worst);
 
-                    int index = Helper.GetInt(organisms.Count);
+                    int index = RandomHelper.GetShort(organisms.Count);
                     Organism mother = best;
                     Organism father = organisms[index];
 
diff --git a/SalemOptimizer/Xorshift.cs b/SalemOptimizer/Xorshift.cs

Original file line number	Diff line number	Diff line change
`@@ -14,13 +14,13 @@ public InspirationalBranch(Solver solver)`
`14`	`14`	`{`
`15`	`15`	`this.solver = solver;`
`16`	`16`
`17`		`- Inspirational = solver.AvailableInspirationals[Helper.GetInt(solver.AvailableInspirationals.Length)];`
	`17`	`+ Inspirational = solver.AvailableInspirationals[solver.RandomHelper.GetShort(solver.AvailableInspirationals.Length)];`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`public InspirationalBranch CreateRandomNode()`
`21`	`21`	`{`
`22`	`22`	`var newNode = new InspirationalBranch(solver);`
`23`		`- newNode.Inspirational = solver.AvailableInspirationals[Helper.GetInt(solver.AvailableInspirationals.Length)];`
	`23`	`+ newNode.Inspirational = solver.AvailableInspirationals[solver.RandomHelper.GetShort(solver.AvailableInspirationals.Length)];`
`24`	`24`
`25`	`25`	`return newNode;`
`26`	`26`	`}`
`@@ -43,32 +43,32 @@ public IEnumerable<string> GetNames()`
`43`	`43`
`44`	`44`	`public void Mutate()`
`45`	`45`	`{`
`46`		`- if (Helper.Mutate(100))`
	`46`	`+ if (solver.RandomHelper.Mutate(100))`
`47`	`47`	`{`
`48`		`- Inspirational = solver.AvailableInspirationals[Helper.GetInt(solver.AvailableInspirationals.Length)];`
	`48`	`+ Inspirational = solver.AvailableInspirationals[solver.RandomHelper.GetShort(solver.AvailableInspirationals.Length)];`
`49`	`49`	`}`
`50`	`50`
`51`	`51`	`if (LeftNode != null) LeftNode.Mutate();`
`52`	`52`	`if (RightNode != null) RightNode.Mutate();`
`53`	`53`
`54`	`54`	`if (LeftNode == null)`
`55`	`55`	`{`
`56`		`- if (Helper.Mutate(20)) LeftNode = CreateRandomNode();`
`57`		`- else if (Helper.Mutate(20)) LeftNode = this.Clone();`
	`56`	`+ if (solver.RandomHelper.Mutate(20)) LeftNode = CreateRandomNode();`
	`57`	`+ else if (solver.RandomHelper.Mutate(20)) LeftNode = this.Clone(solver);`
`58`	`58`	`}`
`59`	`59`	`else`
`60`	`60`	`{`
`61`		`- if (Helper.Mutate(50)) LeftNode = null;`
	`61`	`+ if (solver.RandomHelper.Mutate(50)) LeftNode = null;`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`if (RightNode == null)`
`65`	`65`	`{`
`66`		`- if (Helper.Mutate(20)) RightNode = CreateRandomNode();`
`67`		`- else if (Helper.Mutate(20)) RightNode = this.Clone();`
	`66`	`+ if (solver.RandomHelper.Mutate(20)) RightNode = CreateRandomNode();`
	`67`	`+ else if (solver.RandomHelper.Mutate(20)) RightNode = this.Clone(solver);`
`68`	`68`	`}`
`69`	`69`	`else`
`70`	`70`	`{`
`71`		`- if (Helper.Mutate(50)) RightNode = null;`
	`71`	`+ if (solver.RandomHelper.Mutate(50)) RightNode = null;`
`72`	`72`	`}`
`73`	`73`	`}`
`74`	`74`
`@@ -83,13 +83,13 @@ public void Evaluate(EvaluationState engine)`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
`86`		`- public InspirationalBranch Clone()`
	`86`	`+ public InspirationalBranch Clone(Solver solver)`
`87`	`87`	`{`
`88`	`88`	`InspirationalBranch clone = new InspirationalBranch(solver);`
`89`	`89`	`clone.Inspirational = Inspirational;`
`90`	`90`
`91`		`- if (LeftNode != null) clone.LeftNode = LeftNode.Clone();`
`92`		`- if (RightNode != null) clone.RightNode = RightNode.Clone();`
	`91`	`+ if (LeftNode != null) clone.LeftNode = LeftNode.Clone(solver);`
	`92`	`+ if (RightNode != null) clone.RightNode = RightNode.Clone(solver);`
`93`	`93`
`94`	`94`	`return clone;`
`95`	`95`	`}`
`@@ -102,7 +102,7 @@ public InspirationalBranch GetRandomNode()`
`102`	`102`	`var nodes = new List<InspirationalBranch>();`
`103`	`103`	`TraverseNode(this, nodes);`
`104`	`104`
`105`		`- var index = Helper.GetInt(nodes.Count);`
	`105`	`+ var index = solver.RandomHelper.GetShort(nodes.Count);`
`106`	`106`	`return nodes[index];`
`107`	`107`	`}`
`108`	`108`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public void AddOrganism(Organism organism)`
`27`	`27`	`{`
`28`	`28`	`var tmp =`
`29`	`29`	`organisms`
`30`		`- .Union(new[] { organism.Clone() })`
	`30`	`+ .Union(new[] { organism.Clone(null) })`
`31`	`31`	`.GroupBy(i => i == null ? null : i.ToString())`
`32`	`32`	`.Select(i => i.First());`
`33`	`33`
Original file line number	Diff line number	Diff line change
`@@ -67,14 +67,14 @@ public void Tick()`
`67`	`67`	`{`
`68`	`68`	`InspirationalBranch clone = null;`
`69`	`69`
`70`		`- clone = (InspirationalBranch)root.Clone();`
	`70`	`+ clone = (InspirationalBranch)root.Clone(solver);`
`71`	`71`	`clone.Mutate();`
`72`	`72`
`73`	`73`	`var stateNew = new EvaluationState();`
`74`	`74`
`75`	`75`	`var newResult = Evaluate(clone, stateNew, problem);`
`76`	`76`
`77`		`- if (newResult.CostTotal < Solution.CostTotal \|\| Helper.Mutate(10))`
	`77`	`+ if (newResult.CostTotal < Solution.CostTotal \|\| solver.RandomHelper.Mutate(10))`
`78`	`78`	`{`
`79`	`79`	`root = clone;`
`80`	`80`	`Solution = newResult;`
`@@ -84,10 +84,10 @@ public void Tick()`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`		`- public Organism Clone()`
	`87`	`+ public Organism Clone(Solver solver)`
`88`	`88`	`{`
`89`		`- Organism clone = new Organism(solver, problem);`
`90`		`- clone.root = this.root.Clone();`
	`89`	`+ Organism clone = new Organism(solver ?? this.solver, problem);`
	`90`	`+ clone.root = this.root.Clone(solver ?? this.solver);`
`91`	`91`	`clone.Solution = this.Solution;`
`92`	`92`	`clone.lastEvaluation = lastEvaluation;`
`93`	`93`	`clone.cachedNames = cachedNames;`
`@@ -96,8 +96,8 @@ public Organism Clone()`
`96`	`96`
`97`	`97`	`public Organism MakeCrossOver(Organism father)`
`98`	`98`	`{`
`99`		`- var child = this.Clone();`
`100`		`- var fatherDna = father.GetRandomNode().Clone();`
	`99`	`+ var child = this.Clone(solver);`
	`100`	`+ var fatherDna = father.GetRandomNode().Clone(solver);`
`101`	`101`	`var motherDna = child.GetRandomNode();`
`102`	`102`	`motherDna.LeftNode = fatherDna.LeftNode;`
`103`	`103`	`motherDna.RightNode = fatherDna.RightNode;`
Original file line number	Diff line number	Diff line change
`@@ -13,13 +13,15 @@ public class Solver`
`13`	`13`	`private readonly Inspirational[] availableInspirationals;`
`14`	`14`	`private readonly CancellationToken cancellationToken;`
`15`	`15`	`private readonly Organism[] includedOrganisms;`
	`16`	`+ public readonly RandomHelper RandomHelper;`
`16`	`17`
`17`	`18`	`public Solver(Problem problem, Inspirational[] availableInspirationals, CancellationToken cancellationToken, Organism[] includedOrganisms)`
`18`	`19`	`{`
`19`	`20`	`this.problem = problem;`
`20`	`21`	`this.availableInspirationals = availableInspirationals;`
`21`	`22`	`this.cancellationToken = cancellationToken;`
`22`	`23`	`this.includedOrganisms = includedOrganisms;`
	`24`	`+ this.RandomHelper = new RandomHelper();`
`23`	`25`	`}`
`24`	`26`
`25`	`27`	`public Inspirational[] AvailableInspirationals { get { return availableInspirationals; } }`
`@@ -40,7 +42,7 @@ public Organism[] Solve(bool prune)`
`40`	`42`
`41`	`43`	`if (includedOrganisms != null)`
`42`	`44`	`{`
`43`		`- foreach (var organism in includedOrganisms.Select(i => i.Clone()))`
	`45`	`+ foreach (var organism in includedOrganisms.Select(i => i.Clone(this)))`
`44`	`46`	`{`
`45`	`47`	`organisms.Add(organism);`
`46`	`48`	`leaderboard.AddOrganism(organism);`
`@@ -83,24 +85,25 @@ public Organism[] Solve(bool prune)`
`83`	`85`	`}`
`84`	`86`	`}`
`85`	`87`
`86`		`- if (Helper.GetInt(10) == 1)`
	`88`	`+ if (RandomHelper.GetShort(10) == 1)`
`87`	`89`	`{`
`88`	`90`	`organisms.Remove(worst);`
`89`		`- Organism clone = best.Clone();`
	`91`	`+ Organism clone = best.Clone(this);`
`90`	`92`	`organisms.Add(clone);`
`91`	`93`	`}`
`92`		`- else if (Helper.GetInt(30) == 1)`
	`94`	`+ else if (RandomHelper.GetShort(30) == 1)`
`93`	`95`	`{`
`94`	`96`	`organisms.Remove(worst);`
`95`		`- int index = Helper.GetInt(organisms.Count);`
`96`		`- Organism clone = organisms[index].Clone();`
	`97`	`+`
	`98`	`+ var index = RandomHelper.GetShort(organisms.Count);`
	`99`	`+ Organism clone = organisms[index].Clone(this);`
`97`	`100`	`organisms.Add(clone);`
`98`	`101`	`}`
`99`		`- else if (Helper.GetInt(100) == 1)`
	`102`	`+ else if (RandomHelper.GetShort(100) == 1)`
`100`	`103`	`{`
`101`	`104`	`organisms.Remove(worst);`
`102`	`105`
`103`		`- int index = Helper.GetInt(organisms.Count);`
	`106`	`+ int index = RandomHelper.GetShort(organisms.Count);`
`104`	`107`	`Organism mother = best;`
`105`	`108`	`Organism father = organisms[index];`
`106`	`109`