/// <summary>
/// Initializes memory manager
/// </summary>
/// <param name="databaseName">datbase name</param>
public Manager(IRlmNetwork network, bool trackStats = false)
{
Network = network;
bcSessionsToCreate = new BlockingCollection <Session>();
bcSessionsToUpdate = new BlockingCollection <Session>();
bcCasesQueue = new BlockingCollection <Case>();
rlmDb = new RlmDbMgr(network.RlmDBData, network.PersistData);
rlmDbEnqueuer = new RlmObjectEnqueuer();
progressUpdater.Interval = 1000;
progressUpdater.Elapsed += ProgressUpdater_Elapsed;
if (trackStats)
{
GetRneuronTimes = new List <TimeSpan>();
RebuildCacheboxTimes = new List <TimeSpan>();
SwGetRneuron = new System.Diagnostics.Stopwatch();
SwRebuildCache = new System.Diagnostics.Stopwatch();
}
MASTER_CASE_QUEUE.Enqueue(caseQueue = new Queue <Case>());
if (network.GPURneuronProcessor == null)
{
rneuronProcessor = new RlmRneuronGetter(this);
}
else
{
GPUMode = true;
rneuronProcessor = network.GPURneuronProcessor;
}
}
/// <summary>
/// Initializes memory manager
/// </summary>
/// <param name="databaseName">datbase name</param>
public Manager(IRlmNetwork network, bool trackStats = false)
{
Network = network;
rneuron_queue = new BlockingCollection <Rneuron>();
session_queue = new BlockingCollection <Session>();
savedSession_queue = new BlockingCollection <Session>();
solution_queue = new BlockingCollection <Solution>();
case_queue = new BlockingCollection <Case>();
rlmDb = new RlmDbMgr(network.DatabaseName);
rlmDbEnqueuer = new RlmObjectEnqueuer();
ctSourceSessions = new CancellationTokenSource();
tokenSessions = ctSourceSessions.Token;
ctSourceCases = new CancellationTokenSource();
tokenCases = ctSourceCases.Token;
progressUpdater.Interval = 1000;
progressUpdater.Elapsed += ProgressUpdater_Elapsed;
if (trackStats)
{
GetRneuronTimes = new List <TimeSpan>();
RebuildCacheboxTimes = new List <TimeSpan>();
SwGetRneuron = new System.Diagnostics.Stopwatch();
SwRebuildCache = new System.Diagnostics.Stopwatch();
}
MASTER_CASE_QUEUE.Enqueue(caseQueue = new Queue <Case>());
}
public bool LoadNetwork(IRlmNetwork networkToCopy)
{
MemoryManager.Sessions = new ConcurrentDictionary <long, Session>(networkToCopy.MemoryManager.Sessions.ToList());
MemoryManager.BestSolutions = new ConcurrentDictionary <long, Dictionary <long, BestSolution> >(networkToCopy.MemoryManager.BestSolutions.ToList());
MemoryManager.Rneurons = new ConcurrentDictionary <long, Rneuron>(networkToCopy.MemoryManager.Rneurons.ToList());
MemoryManager.Solutions = new ConcurrentDictionary <long, Solution>(networkToCopy.MemoryManager.Solutions.ToList());
MemoryManager.DynamicInputs = new SortedList <RlmInputKey, RlmInputValue>(networkToCopy.MemoryManager.DynamicInputs.Comparer);
foreach (var item in networkToCopy.MemoryManager.DynamicInputs)
{
MemoryManager.DynamicInputs.Add(item.Key, item.Value);
}
MemoryManager.DynamicOutputs = new ConcurrentDictionary <long, HashSet <SolutionOutputSet> >(networkToCopy.MemoryManager.DynamicOutputs.ToList());
CurrentNetworkID = networkToCopy.CurrentNetworkID;
CurrentNetworkName = networkToCopy.CurrentNetworkName;
CaseOrder = networkToCopy.CaseOrder;
SessionCountInitial = SessionCount = networkToCopy.SessionCount;
Inputs = networkToCopy.Inputs.ToList();
Outputs = networkToCopy.Outputs.ToList();
InputMomentums = new Dictionary <long, RlmInputMomentum>();
foreach (var item in networkToCopy.InputMomentums)
{
InputMomentums.Add(item.Key, new RlmInputMomentum()
{
InputID = item.Value.InputID
});
}
return(true);
}
/// <summary>
/// Initializes memory manager
/// </summary>
/// <param name="databaseName">datbase name</param>
public Manager(IRlmNetwork network)
{
Network = network;
rneuron_queue = new BlockingCollection <Rneuron>();
session_queue = new BlockingCollection <Session>();
savedSession_queue = new BlockingCollection <Session>();
solution_queue = new BlockingCollection <Solution>();
case_queue = new BlockingCollection <Case>();
rlmDb = new RlmDbMgr(network.DatabaseName);
rlmDbEnqueuer = new RlmObjectEnqueuer();
ctSourceSessions = new CancellationTokenSource();
tokenSessions = ctSourceSessions.Token;
ctSourceCases = new CancellationTokenSource();
tokenCases = ctSourceCases.Token;
progressUpdater.Interval = 1000;
progressUpdater.Elapsed += ProgressUpdater_Elapsed;
}
/// <summary>
/// Save the new network and send it to a task. It also starts the database workers
/// </summary>
/// <param name="rnetwork"></param>
/// <param name="io_types"></param>
/// <param name="inputs"></param>
/// <param name="outputs"></param>
/// <param name="rnn_net"></param>
public void NewNetwork(Rnetwork rnetwork, List <Input_Output_Type> io_types, List <Input> inputs, List <Output> outputs, IRlmNetwork rnn_net)
{
//todo: rnn dbmanager and save
dbSavingTime.Start();
RlmDbLogger.Info("\n" + string.Format("[{0:G}]: Started saving data for {1}...", DateTime.Now, Network.DatabaseName), Network.DatabaseName);
Task t1 = Task.Run(() =>
{
rlmDb.SaveNetwork(rnetwork, io_types, inputs, outputs, rnn_net);
});
t1.Wait();
StartRlmDbWorkers();
}
/// <summary>
/// object type that stores cycle outputs with the rlm network
/// </summary>
/// <param name="cycleOutput"></param>
/// <param name="network">current RLM Network</param>
/// <param name="rnnType">current RLM Network Type</param>
public RlmCyclecompleteArgs(RlmCycleOutput cycleOutput, IRlmNetwork network, RlmNetworkType rnnType)
{
CycleOutput = cycleOutput;
RlmNetwork = network;
RlmType = rnnType;
}
//load network
public LoadRnetworkResult LoadNetwork(string name, IRlmNetwork rnetwork)
{
var retVal = new LoadRnetworkResult();
IRlmNetwork rnn = rnetwork;
List <Input> inputs = new List <Input>();
List <Output> outputs = new List <Output>();
var watch = new Stopwatch();
watch.Start();
Rnetwork network;
try
{
using (RlmDbEntities db = new RlmDbEntities(databaseName))
{
//find network by name
network = db.Rnetworks.FirstOrDefault(a => a.Name == name);
}
if (network == null)
{
//Throw an error
Console.WriteLine("Network name '" + name + "' does not exist in the database:" + databaseName);
}
else
{
this.rlm = network;
// set rnetwork details
retVal.CurrentNetworkId = networkID = this.rlm.ID;
retVal.CurrentNetworkName = this.rlm.Name;
List <Input> rnnInputs = null;
List <Output> rnnOutputs = null;
var tasks = new List <Task>();
int taskCnt = Environment.ProcessorCount / 2;
int batchSizeRn = 0;
int batchSizeIvr = 0;
var rnCountTask = Task.Run(() =>
{
Stopwatch cntWatch = new Stopwatch();
cntWatch.Start();
var subTasks = new Task[3];
int totalInputs = 0;
int totalRneurons = 0;
int totalIvrs = 0;
subTasks[0] = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
totalInputs = ctx.Inputs.Count();
}
});
subTasks[1] = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
totalRneurons = ctx.Rneurons.Count();
}
});
subTasks[2] = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
totalIvrs = ctx.Input_Values_Reneurons.Count();
}
});
Task.WaitAll(subTasks);
batchSizeRn = Convert.ToInt32(Math.Ceiling(totalRneurons / (double)taskCnt));
batchSizeIvr = Convert.ToInt32(Math.Ceiling(totalIvrs / (double)taskCnt));
while (batchSizeIvr % totalInputs != 0)
{
batchSizeIvr++;
}
cntWatch.Stop();
System.Diagnostics.Debug.WriteLine($"Count elapsed: {cntWatch.Elapsed}");
});
tasks.Add(rnCountTask);
var bestSolTask = Task.Run(() =>
{
IEnumerable <BestSolution> bestSolutions = null;
using (var ctx = new RlmDbEntities(databaseName))
{
bestSolutions = ctx.Database.SqlQuery <BestSolution>(@"
SELECT
main.[Rneuron_ID] as [RneuronId],
main.[Solution_ID] as [SolutionId],
MAX(main.[CycleScore]) as [CycleScore],
MAX(sess.[SessionScore]) as [SessionScore],
MAX(main.[CycleEndTime]) as [CycleEndTime]
FROM [Cases] main
INNER JOIN [Sessions] sess ON main.[Session_ID] = sess.[ID]
GROUP BY main.[Rneuron_ID], main.[Solution_ID]").ToList();
}
if (bestSolutions != null)
{
foreach (var item in bestSolutions)
{
rnetwork.MemoryManager.SetBestSolution(item);
}
}
});
tasks.Add(bestSolTask);
var inputTask = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
// get inputs
rnnInputs = ctx.Inputs
.Include(a => a.Input_Output_Type)
.OrderBy(a => a.Order)
.ToList();
}
retVal.Inputs = rnetwork.Inputs = rnnInputs.Select(a => new RlmIO()
{
ID = a.ID,
Name = a.Name,
DotNetType = a.Input_Output_Type.DotNetTypeName,
Min = a.Min,
Max = a.Max,
Type = a.Type
});
rnetwork.InputMomentums.Clear();
foreach (var item in rnetwork.Inputs)
{
if (item.Type == Enums.RlmInputType.Linear)
{
rnetwork.InputMomentums.Add(item.ID, new RlmInputMomentum()
{
InputID = item.ID
});
}
}
retVal.InputMomentums = rnetwork.InputMomentums;
});
tasks.Add(inputTask);
var outputTask = Task.Run(() =>
{
using (var ctx = new RlmDbEntities(databaseName))
{
// get outputs
rnnOutputs = ctx.Outputs
.Include(a => a.Input_Output_Type)
.OrderBy(a => a.Order)
.ToList();
}
retVal.Outputs = rnetwork.Outputs = rnnOutputs.Select(a => new RlmIO()
{
ID = a.ID,
Name = a.Name,
DotNetType = a.Input_Output_Type.DotNetTypeName,
Min = a.Min,
Max = a.Max
});
foreach (var output in rnetwork.Outputs)
{
// add dynamic output collection
rnetwork.MemoryManager.DynamicOutputs.TryAdd(output.ID, new HashSet <SolutionOutputSet>());
}
});
tasks.Add(outputTask);
var sessionsTask = Task.Run(() =>
{
IEnumerable <Session> sessions = null;
using (var ctx = new RlmDbEntities(databaseName))
{
// get sessions and save to MemoryManager cache
sessions = ctx.Sessions.OrderBy(a => a.DateTimeStart).ToList();
// set CaseOrder to the last case saved in db
retVal.CaseOrder = ctx.Cases.OrderByDescending(a => a.Order).Select(a => a.Order).FirstOrDefault();
}
if (sessions != null)
{
//set sessions count
retVal.SessionCount = sessions.Count();
foreach (var item in sessions)
{
rnetwork.MemoryManager.Sessions.TryAdd(item.ID, item);
}
}
});
tasks.Add(sessionsTask);
var rneuronsTask = Task.WhenAll(inputTask, rnCountTask).ContinueWith((t) =>
{
Stopwatch rn_sw = new Stopwatch();
rn_sw.Start();
var subTasks = new List <Task>();
// made input dictionary to help in setting the Dynamic inputs
var inputDic = rnnInputs.ToDictionary(a => a.ID, a => a);
var rneurons = new ConcurrentBag <Rneuron>();
var ivrs = new ConcurrentDictionary <long, List <Input_Values_Rneuron> >();
//IEnumerable<Rneuron> rneurons = null;
Stopwatch subProcessWatch = new Stopwatch();
subProcessWatch.Start();
for (int i = 0; i < taskCnt; i++)
{
int batchNum = i;
subTasks.Add(Task.Run(() =>
{
Rneuron[] results;
using (var ctx = new RlmDbEntities(databaseName))
{
results = ctx.Rneurons.OrderBy(a => a.ID).Skip(batchNum * batchSizeRn).Take(batchSizeRn).ToArray();
}
foreach (var item in results)
{
rneurons.Add(item);
}
}));
subTasks.Add(Task.Run(() =>
{
Input_Values_Rneuron[] results;
using (var ctx = new RlmDbEntities(databaseName))
{
results = ctx.Input_Values_Reneurons.OrderBy(a => a.Rneuron_ID).Skip(batchNum * batchSizeIvr).Take(batchSizeIvr).ToArray();
}
foreach (var item in results.GroupBy(a => a.Rneuron_ID))
{
ivrs.TryAdd(item.Key, item.ToList());
}
}));
}
Task.WaitAll(subTasks.ToArray());
subProcessWatch.Stop();
System.Diagnostics.Debug.WriteLine($"Get data: {subProcessWatch.Elapsed}");
subTasks.Clear();
subProcessWatch.Restart();
for (int i = 0; i < taskCnt; i++)
{
int batchNum = i;
subTasks.Add(Task.Run(() =>
{
//Stopwatch sw = new Stopwatch();
//sw.Start();
//IEnumerable<Rneuron> rneurons = null;
//using (var ctx = new RlmDbEntities(databaseName))
//{
// rneurons = ctx.Rneurons
// .Include(a => a.Input_Values_Reneurons)
// .OrderBy(a => a.ID)
// .Skip(batchNum * batchSizeRn)
// .Take(batchSizeRn)
// .ToList();
//}
//sw.Stop();
//System.Diagnostics.Debug.WriteLine($"Task: {Task.CurrentId}, Get Data: {sw.Elapsed}");
//sw.Restart();
//sw.Start();
foreach (var item in rneurons.Skip(batchNum * batchSizeRn).Take(batchSizeRn))
{
// set input type and dotnettype
item.Input_Values_Reneurons = ivrs[item.ID];
foreach (var ivr in item.Input_Values_Reneurons)
{
var input = inputDic[ivr.Input_ID];
ivr.InputType = input.Type;
ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
ivr.Input = input;
}
item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
rnetwork.MemoryManager.SetRneuronWithInputs(item);
}
//sw.Stop();
//System.Diagnostics.Debug.WriteLine($"Task: {Task.CurrentId}, Process Data: {sw.Elapsed}");
}));
}
/** old batching code
* int totalRneurons = db.Rneurons.Count();
* int pageCount = 100;
* var helper = new StaticPagedList<Rneuron>(
* Enumerable.Empty<Rneuron>(), 1, pageCount, totalRneurons);
* Parallel.For(1, helper.PageCount + 1, i =>
* {
*
* using (var rdb = new RlmDbEntities(databaseName))
* {
* var data = rdb.Rneurons.Include(a => a.Input_Values_Reneurons).OrderBy(u => u.ID).ToPagedList(i, helper.PageSize).ToList();
*
* foreach (var item in data)
* {
* // set input type and dotnettype
* foreach (var ivr in item.Input_Values_Reneurons)
* {
* var input = inputDic[ivr.Input_ID];
* ivr.InputType = input.Type;
* ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
* ivr.Input = input;
* }
*
* item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
*
* rnetwork.MemoryManager.SetRneuronWithInputs(item);
* }
* }
* });
*
* if (rneurons != null)
* {
* foreach (var item in rneurons)
* {
* // set input type and dotnettype
* foreach (var ivr in item.Input_Values_Reneurons)
* {
* var input = inputDic[ivr.Input_ID];
* ivr.InputType = input.Type;
* ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
* ivr.Input = input;
* }
*
* item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
*
* rnetwork.MemoryManager.SetRneuronWithInputs(item);
* }
* } */
Task.WaitAll(subTasks.ToArray());
subProcessWatch.Stop();
System.Diagnostics.Debug.WriteLine($"Process data: {subProcessWatch.Elapsed}");
rn_sw.Stop();
System.Diagnostics.Debug.WriteLine($"Total rneuron task elapsed: {rn_sw.Elapsed}");
;
});
tasks.Add(rneuronsTask);
var solutionTask = outputTask.ContinueWith((t) =>
{
IEnumerable <Solution> solutions = null;
using (var ctx = new RlmDbEntities(databaseName))
{
// get solutions and save to MemoryManager cache
solutions = ctx.Solutions.Include(a => a.Output_Values_Solutions).ToList();
}
if (solutions != null)
{
foreach (var item in solutions)
{
rnetwork.MemoryManager.SetSolutionWithOutputs(item);
}
}
});
tasks.Add(solutionTask);
Task.WaitAll(tasks.ToArray());
retVal.Loaded = true;
}
}
catch (Exception ex)
{
RlmDbLogger.Error(ex, databaseName, "LoadNetwork");
}
watch.Stop();
System.Diagnostics.Debug.WriteLine($"Load Network Elapsed: {watch.Elapsed}");
return(retVal);
}
public void SaveNetwork(Rnetwork rnetwork, List <Input_Output_Type> io_types, List <Input> inputs, List <Output> outputs, IRlmNetwork rnn_net)
{
using (RlmDbEntities db = new RlmDbEntities(databaseName))
{
try
{
//ready network for saving
Rnetwork _newNetwork = db.Rnetworks.Add(rnetwork);
foreach (var _in in inputs)
{
Input_Output_Type _iotype = io_types.FirstOrDefault(a => a.DotNetTypeName == _in.Input_Output_Type.DotNetTypeName);
_in.Input_Output_Type = _iotype;
db.Inputs.Add(_in);
}
foreach (var _out in outputs)
{
Input_Output_Type _iotype = io_types.FirstOrDefault(a => a.DotNetTypeName == _out.Input_Output_Type.DotNetTypeName);
_out.Input_Output_Type = _iotype;
db.Outputs.Add(_out);
}
//save to database
db.SaveChanges();
rlm = _newNetwork;
networkID = _newNetwork.ID;
networkLoaded = true;
rnn_net.MemoryManager.InitStorage(inputs, outputs);
}
catch (Exception ex)
{
networkLoaded = false;
RlmDbLogger.Error(ex, databaseName, "SaveNetwork");
}
}
}
//load network
public LoadRnetworkResult LoadNetwork(string name, IRlmNetwork rnetwork)
{
var retVal = new LoadRnetworkResult();
IRlmNetwork rnn = rnetwork;
List <Input> inputs = new List <Input>();
List <Output> outputs = new List <Output>();
using (RlmDbEntities db = new RlmDbEntities(databaseName))
{
try
{
//find network by name
var network = from net in db.Rnetworks
where net.Name.ToLower() == name.ToLower()
select net;
if (network.Count() == 0)
{
//Throw an error
Console.WriteLine("Network name '" + name + "' does not exist in the database:" + db.Database.Connection.ToString());
}
else
{
var rnetworkFromDb = network.First <Rnetwork>();
this.rlm = rnetworkFromDb;
// set rnetwork details
retVal.CurrentNetworkId = networkID = this.rlm.ID;
retVal.CurrentNetworkName = this.rlm.Name;
// get inputs
var rnnInputs = db.Inputs
.Include(a => a.Input_Output_Type)
.OrderBy(a => a.Order)
.ToList();
rnetwork.Inputs = rnnInputs.Select(a => new RlmIO()
{
ID = a.ID,
Name = a.Name,
DotNetType = a.Input_Output_Type.DotNetTypeName,
Min = a.Min,
Max = a.Max,
Type = a.Type
});
rnetwork.InputMomentums.Clear();
foreach (var item in rnetwork.Inputs)
{
if (item.Type == Enums.RlmInputType.Linear)
{
rnetwork.InputMomentums.Add(item.ID, new RlmInputMomentum()
{
InputID = item.ID
});
}
}
// get outputs
var rnnOutputs = db.Outputs
.Include(a => a.Input_Output_Type)
.OrderBy(a => a.Order)
.ToList();
rnetwork.Outputs = rnnOutputs.Select(a => new RlmIO()
{
ID = a.ID,
Name = a.Name,
DotNetType = a.Input_Output_Type.DotNetTypeName,
Min = a.Min,
Max = a.Max
});
foreach (var output in rnetwork.Outputs)
{
// add dynamic output collection
rnetwork.MemoryManager.DynamicOutputs.TryAdd(output.ID, new HashSet <SolutionOutputSet>());
}
// initialize MemoryManager dictionaries (Rneurons, Solutions, etc...)
//rnetwork.MemoryManager.InitStorage(rnetwork.Inputs.Select(a =>
//{
// return new Input
// {
// ID = a.ID,
// Max = a.Max,
// Min = a.Min,
// Name = a.Name,
// Rnetwork_ID = rnetwork.CurrentNetworkID,
// Type = a.Type
// };
//}).ToList(), rnetwork.Outputs.Select(a => {
// return new Output
// {
// ID = a.ID,
// Max = a.Max,
// Min = a.Min,
// Name = a.Name,
// Rnetwork_ID = rnetwork.CurrentNetworkID
// };
//}).ToList());
// get sessions and save to MemoryManager cache
var sessions = db.Sessions.OrderBy(a => a.DateTimeStart).ToList();
foreach (var item in sessions)
{
rnetwork.MemoryManager.Sessions.TryAdd(item.ID, item);
}
//set sessions count
retVal.SessionCount = sessions.Count;
// set CaseOrder to the last case saved in db
var lastCase = db.Cases.OrderByDescending(a => a.Order).FirstOrDefault();
if (lastCase != null)
{
retVal.CaseOrder = lastCase.Order;
}
// made input dictionary to help in setting the Dynamic inputs
var inputDic = rnnInputs.ToDictionary(a => a.ID, a => a);
// get Rneurons and save to MemoryManager cache
//var rneurons = db.Rneurons.Include(a => a.Input_Values_Reneurons).ToList();
//batching
int totalRneurons = db.Rneurons.Count();
int pageCount = 100;
var helper = new StaticPagedList <Rneuron>(
Enumerable.Empty <Rneuron>(), 1, pageCount, totalRneurons);
Parallel.For(1, helper.PageCount + 1, i =>
{
using (var rdb = new RlmDbEntities(databaseName))
{
var data = rdb.Rneurons.Include(a => a.Input_Values_Reneurons).OrderBy(u => u.ID).ToPagedList(i, helper.PageSize).ToList();
foreach (var item in data)
{
// set input type and dotnettype
foreach (var ivr in item.Input_Values_Reneurons)
{
var input = inputDic[ivr.Input_ID];
ivr.InputType = input.Type;
ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
ivr.Input = input;
}
item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
rnetwork.MemoryManager.SetRneuronWithInputs(item);
}
}
});
//end batching
//foreach (var item in rneurons)
//{
// // set input type and dotnettype
// foreach (var ivr in item.Input_Values_Reneurons)
// {
// var input = inputDic[ivr.Input_ID];
// ivr.InputType = input.Type;
// ivr.DotNetType = input.Input_Output_Type.DotNetTypeName;
// ivr.Input = input;
// }
// item.Input_Values_Reneurons = item.Input_Values_Reneurons.OrderBy(a => a.Input.Order).ToList();
// rnetwork.MemoryManager.SetRneuronWithInputs(item);
//}
// get solutions and save to MemoryManager cache
var solutions = db.Solutions.Include(a => a.Output_Values_Solutions).ToList();
foreach (var item in solutions)
{
rnetwork.MemoryManager.SetSolutionWithOutputs(item);
}
// get best solutions and save to MemoryManager cache
//var solCount = db.Database.SqlQuery<Int32>(@"SELECT COUNT(*) FROM(SELECT
// main.[Rneuron_ID] as [RneuronId],
// main.[Solution_ID] as [SolutionId],
// MAX(main.[CycleScore]) as [CycleScore],
// MAX(sess.[SessionScore]) as [SessionScore],
// MAX(main.[CycleEndTime]) as [CycleEndTime]
// FROM[Cases] main
// INNER JOIN[Sessions] sess ON main.[Session_ID] = sess.[ID]
// GROUP BY main.[Rneuron_ID], main.[Solution_ID]) AS a").First();
var bestSolutions = db.Database.SqlQuery <BestSolution>(@"
SELECT
main.[Rneuron_ID] as [RneuronId],
main.[Solution_ID] as [SolutionId],
MAX(main.[CycleScore]) as [CycleScore],
MAX(sess.[SessionScore]) as [SessionScore],
MAX(main.[CycleEndTime]) as [CycleEndTime]
FROM [Cases] main
INNER JOIN [Sessions] sess ON main.[Session_ID] = sess.[ID]
GROUP BY main.[Rneuron_ID], main.[Solution_ID]")
.ToList();
foreach (var item in bestSolutions)
{
rnetwork.MemoryManager.SetBestSolution(item);
}
retVal.Loaded = true;
}
}
catch (Exception ex)
{
RlmDbLogger.Error(ex, databaseName, "LoadNetwork");
}
}
return(retVal);
}
