public void AddItemToBuilder(IItem item, string name, SolutionMessage.Builder builder) {
IStringConvertibleValue value = (item as IStringConvertibleValue);
if (value != null) {
SolutionMessage.Types.StringVariable.Builder var = SolutionMessage.Types.StringVariable.CreateBuilder();
var.SetName(name).SetData(value.GetValue());
builder.AddStringVars(var.Build());
} else {
IStringConvertibleArray array = (item as IStringConvertibleArray);
if (array != null) {
SolutionMessage.Types.StringArrayVariable.Builder var = SolutionMessage.Types.StringArrayVariable.CreateBuilder();
var.SetName(name).SetLength(array.Length);
for (int i = 0; i < array.Length; i++)
var.AddData(array.GetValue(i));
builder.AddStringArrayVars(var.Build());
} else {
IStringConvertibleMatrix matrix = (item as IStringConvertibleMatrix);
if (matrix != null) {
SolutionMessage.Types.StringArrayVariable.Builder var = SolutionMessage.Types.StringArrayVariable.CreateBuilder();
var.SetName(name).SetLength(matrix.Columns);
for (int i = 0; i < matrix.Rows; i++)
for (int j = 0; j < matrix.Columns; j++)
var.AddData(matrix.GetValue(i, j));
builder.AddStringArrayVars(var.Build());
} else {
throw new ArgumentException(ItemName + ": Item is not of a supported type.", "item");
}
}
}
}
public QualityMessage Evaluate(SolutionMessage solution, ExtensionRegistry qualityExtensions)
{
int tries = 0, maxTries = RetryParameter.Value.Value;
bool success = false;
QualityMessage result = null;
while (!success)
{
try {
tries++;
CheckAndOpenChannel();
Channel.Send(solution);
result = (QualityMessage)Channel.Receive(QualityMessage.CreateBuilder(), qualityExtensions);
success = true;
} catch (InvalidOperationException) {
throw;
} catch {
if (tries >= maxTries)
{
throw;
}
}
}
if (result != null && result.SolutionId != solution.SolutionId)
{
throw new InvalidDataException(Name + ": Received a quality for a different solution.");
}
return(result);
}
private QualityMessage EvaluateOnNextAvailableClient(SolutionMessage message)
{
IEvaluationServiceClient client = null;
lock (clientLock) {
client = Clients.CheckedItems.FirstOrDefault(c => !activeClients.Contains(c));
while (client == null && Clients.CheckedItems.Any())
{
Monitor.Wait(clientLock);
client = Clients.CheckedItems.FirstOrDefault(c => !activeClients.Contains(c));
}
if (client != null)
{
activeClients.Add(client);
}
}
try {
return(client.Evaluate(message, GetQualityMessageExtensions()));
} finally {
lock (clientLock) {
activeClients.Remove(client);
Monitor.PulseAll(clientLock);
}
}
}
protected override void ConvertSymbolicExpressionTree(SymbolicExpressionTree tree, string name, SolutionMessage.Builder builder) {
string stringRep = formatter.Format(tree);
stringRep.Replace(Environment.NewLine, "");
SolutionMessage.Types.StringVariable.Builder stringVariable = SolutionMessage.Types.StringVariable.CreateBuilder();
stringVariable.SetName(name).SetData(stringRep);
builder.AddStringVars(stringVariable.Build());
}
protected override void ConvertSymbolicExpressionTree(SymbolicExpressionTree tree, string name, SolutionMessage.Builder builder) {
using (MemoryStream memoryStream = new MemoryStream()) {
Persistence.Default.Xml.XmlGenerator.Serialize(tree, memoryStream);
byte[] byteRep = memoryStream.ToArray();
SolutionMessage.Types.RawVariable.Builder rawVariable = SolutionMessage.Types.RawVariable.CreateBuilder();
rawVariable.SetName(name).SetData(ByteString.CopyFrom(byteRep));
builder.AddRawVars(rawVariable.Build());
}
}
public void AddItemToBuilder(IItem item, string name, SolutionMessage.Builder builder) {
DateTimeValue date = (item as DateTimeValue);
if (date != null) {
SolutionMessage.Types.StringVariable.Builder var = SolutionMessage.Types.StringVariable.CreateBuilder();
var.SetName(name).SetData(date.Value.ToString(@"d\.hh\:mm\:ss"));
builder.AddStringVars(var.Build());
} else {
throw new ArgumentException(ItemName + ": Item is not of a supported type.", "item");
}
}
public void AddToMessage(IItem item, string name, SolutionMessage.Builder builder) {
if (dispatcher == null) BuildDispatcher();
Type itemType = item.GetType();
while (!dispatcher.ContainsKey(itemType)) {
if (itemType.BaseType != null) itemType = itemType.BaseType;
else break;
}
if (itemType.BaseType == null && !dispatcher.ContainsKey(itemType)) {
IEnumerable<Type> interfaces = item.GetType().GetInterfaces().Where(x => dispatcher.ContainsKey(x));
if (interfaces.Count() != 1) throw new ArgumentException(Name + ": No converter for type " + itemType.FullName + " defined.", "item");
else itemType = interfaces.Single();
}
dispatcher[itemType](item, name, builder);
}
private SolutionMessage BuildSolutionMessage(Individual individual, int solutionId = 0)
{
lock (clientLock) {
SolutionMessage.Builder protobufBuilder = SolutionMessage.CreateBuilder();
protobufBuilder.SolutionId = solutionId;
foreach (var variable in individual.Values)
{
try {
MessageBuilder.AddToMessage(variable.Value, variable.Key, protobufBuilder);
}
catch (ArgumentException ex) {
throw new InvalidOperationException(string.Format("ERROR while building solution message: Parameter {0} cannot be added to the message", Name), ex);
}
}
return(protobufBuilder.Build());
}
}
public QualityMessage Evaluate(SolutionMessage solution, ExtensionRegistry qualityExtensions) {
int tries = 0, maxTries = RetryParameter.Value.Value;
bool success = false;
QualityMessage result = null;
while (!success) {
try {
tries++;
CheckAndOpenChannel();
Channel.Send(solution);
result = (QualityMessage)Channel.Receive(QualityMessage.CreateBuilder(), qualityExtensions);
success = true;
} catch (InvalidOperationException) {
throw;
} catch {
if (tries >= maxTries)
throw;
}
}
if (result != null && result.SolutionId != solution.SolutionId) throw new InvalidDataException(Name + ": Received a quality for a different solution.");
return result;
}
protected virtual SolutionMessage BuildSolutionMessage()
{
lock (clientLock) {
SolutionMessage.Builder protobufBuilder = SolutionMessage.CreateBuilder();
protobufBuilder.SolutionId = 0;
foreach (IParameter param in CollectedValues)
{
IItem value = param.ActualValue;
if (value != null)
{
ILookupParameter lookupParam = param as ILookupParameter;
string name = lookupParam != null ? lookupParam.TranslatedName : param.Name;
try {
MessageBuilder.AddToMessage(value, name, protobufBuilder);
} catch (ArgumentException ex) {
throw new InvalidOperationException(string.Format("ERROR while building solution message: Parameter {0} cannot be added to the message", name), ex);
}
}
}
return(protobufBuilder.Build());
}
}
public void EvaluateAsync(SolutionMessage solution, ExtensionRegistry qualityExtensions, Action <QualityMessage> callback)
{
int tries = 0, maxTries = RetryParameter.Value.Value;
bool success = false;
while (!success)
{
try {
tries++;
CheckAndOpenChannel();
Channel.Send(solution);
success = true;
} catch (InvalidOperationException) {
throw;
} catch {
if (tries >= maxTries)
{
throw;
}
}
}
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(ReceiveAsync), new ReceiveAsyncInfo(solution, callback, qualityExtensions));
}
public void AddItemToBuilder(IItem item, string name, SolutionMessage.Builder builder) {
ValueTypeValue<double> value = (item as ValueTypeValue<double>);
if (value != null) {
SolutionMessage.Types.DoubleVariable.Builder var = SolutionMessage.Types.DoubleVariable.CreateBuilder();
var.SetName(name).SetData(value.Value);
builder.AddDoubleVars(var.Build());
} else {
ValueTypeArray<double> array = (item as ValueTypeArray<double>);
if (array != null) {
SolutionMessage.Types.DoubleArrayVariable.Builder var = SolutionMessage.Types.DoubleArrayVariable.CreateBuilder();
var.SetName(name).AddRangeData(array).SetLength(array.Length);
builder.AddDoubleArrayVars(var.Build());
} else {
ValueTypeMatrix<double> matrix = (item as ValueTypeMatrix<double>);
if (matrix != null) {
SolutionMessage.Types.DoubleArrayVariable.Builder var = SolutionMessage.Types.DoubleArrayVariable.CreateBuilder();
var.SetName(name).AddRangeData(matrix.AsEnumerable()).SetLength(matrix.Columns);
builder.AddDoubleArrayVars(var.Build());
} else {
throw new ArgumentException(ItemName + ": Item is not of a supported type.", "item");
}
}
}
}
public ReceiveAsyncInfo(SolutionMessage solutionMessage, Action<QualityMessage> callbackDelegate, ExtensionRegistry qualityExtensions) {
SolutionMessage = solutionMessage;
CallbackDelegate = callbackDelegate;
QualityExtensions = qualityExtensions;
}
public void EvaluateAsync(SolutionMessage solution, ExtensionRegistry qualityExtensions, Action<QualityMessage> callback) {
int tries = 0, maxTries = RetryParameter.Value.Value;
bool success = false;
while (!success) {
try {
tries++;
CheckAndOpenChannel();
Channel.Send(solution);
success = true;
} catch (InvalidOperationException) {
throw;
} catch {
if (tries >= maxTries)
throw;
}
}
System.Threading.ThreadPool.QueueUserWorkItem(new System.Threading.WaitCallback(ReceiveAsync), new ReceiveAsyncInfo(solution, callback, qualityExtensions));
}
public virtual QualityMessage Evaluate(SolutionMessage solutionMessage)
{
return(Cache == null
? EvaluateOnNextAvailableClient(solutionMessage)
: Cache.GetValue(solutionMessage, EvaluateOnNextAvailableClient, GetQualityMessageExtensions()));
}
public QualityMessage GetValue(SolutionMessage message, Evaluator evaluate, ExtensionRegistry extensions) {
var entry = new CacheEntry(message.ToString());
bool lockTaken = false;
bool waited = false;
try {
Monitor.Enter(cacheLock, ref lockTaken);
while (true) {
LinkedListNode<CacheEntry> node;
if (index.TryGetValue(entry, out node)) {
list.Remove(node);
list.AddLast(node);
Hits++;
lockTaken = false;
Monitor.Exit(cacheLock);
OnChanged();
return node.Value.GetMessage(extensions);
} else {
if (!waited && activeEvaluations.Contains(entry.Key)) {
while (activeEvaluations.Contains(entry.Key))
Monitor.Wait(cacheLock);
waited = true;
} else {
activeEvaluations.Add(entry.Key);
lockTaken = false;
Monitor.Exit(cacheLock);
OnChanged();
try {
entry.SetMessage(evaluate(message));
Monitor.Enter(cacheLock, ref lockTaken);
index[entry] = list.AddLast(entry);
Trim();
} finally {
if (!lockTaken)
Monitor.Enter(cacheLock, ref lockTaken);
activeEvaluations.Remove(entry.Key);
Monitor.PulseAll(cacheLock);
lockTaken = false;
Monitor.Exit(cacheLock);
}
OnChanged();
return entry.GetMessage(extensions);
}
}
}
} finally {
if (lockTaken)
Monitor.Exit(cacheLock);
}
}
public ReceiveAsyncInfo(SolutionMessage solutionMessage, Action <QualityMessage> callbackDelegate, ExtensionRegistry qualityExtensions)
{
SolutionMessage = solutionMessage;
CallbackDelegate = callbackDelegate;
QualityExtensions = qualityExtensions;
}
protected abstract void ConvertSymbolicExpressionTree(SymbolicExpressionTree tree, string name, SolutionMessage.Builder builder);
public void AddItemToBuilder(IItem item, string name, SolutionMessage.Builder builder) {
SymbolicExpressionTree tree = (item as SymbolicExpressionTree);
if (tree != null) {
ConvertSymbolicExpressionTree(tree, name, builder);
}
}
public QualityMessage GetValue(SolutionMessage message, Evaluator evaluate, ExtensionRegistry extensions)
{
var entry = new CacheEntry(message.ToString());
bool lockTaken = false;
bool waited = false;
try {
Monitor.Enter(cacheLock, ref lockTaken);
while (true)
{
LinkedListNode <CacheEntry> node;
if (index.TryGetValue(entry, out node))
{
list.Remove(node);
list.AddLast(node);
Hits++;
lockTaken = false;
Monitor.Exit(cacheLock);
OnChanged();
return(node.Value.GetMessage(extensions));
}
else
{
if (!waited && activeEvaluations.Contains(entry.Key))
{
while (activeEvaluations.Contains(entry.Key))
{
Monitor.Wait(cacheLock);
}
waited = true;
}
else
{
activeEvaluations.Add(entry.Key);
lockTaken = false;
Monitor.Exit(cacheLock);
OnChanged();
try {
entry.SetMessage(evaluate(message));
Monitor.Enter(cacheLock, ref lockTaken);
index[entry] = list.AddLast(entry);
Trim();
} finally {
if (!lockTaken)
{
Monitor.Enter(cacheLock, ref lockTaken);
}
activeEvaluations.Remove(entry.Key);
Monitor.PulseAll(cacheLock);
lockTaken = false;
Monitor.Exit(cacheLock);
}
OnChanged();
return(entry.GetMessage(extensions));
}
}
}
} finally {
if (lockTaken)
{
Monitor.Exit(cacheLock);
}
}
}
protected virtual QualityMessage EvaluateOnNextAvailableClient(SolutionMessage message) {
IEvaluationServiceClient client = null;
lock (clientLock) {
client = Clients.CheckedItems.FirstOrDefault(c => !activeClients.Contains(c));
while (client == null && Clients.CheckedItems.Count() > 0) {
Monitor.Wait(clientLock);
client = Clients.CheckedItems.FirstOrDefault(c => !activeClients.Contains(c));
}
if (client != null)
activeClients.Add(client);
}
try {
return client.Evaluate(message, GetQualityMessageExtensions());
} finally {
lock (clientLock) {
activeClients.Remove(client);
Monitor.PulseAll(clientLock);
}
}
}
