private int SetupConfigurationDevices(Xgminer.Data.Configuration.Miner minerConfiguration, DeviceKind deviceKinds, IList <Engine.Data.Configuration.Device> deviceConfigurations)
{
int deviceCount = 0;
for (int i = 0; i < deviceConfigurations.Count; i++)
{
Engine.Data.Configuration.Device enabledConfiguration = deviceConfigurations[i];
Xgminer.Data.Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration));
if ((deviceKinds & device.Kind) == 0)
{
continue;
}
deviceCount++;
//don't actually add stratum device as a device index
if (device.Kind != DeviceKind.PXY)
{
minerConfiguration.DeviceDescriptors.Add(device);
}
else
{
//only enable the stratum proxy if these devices contain the PXY device
minerConfiguration.StratumProxy = engineConfiguration.XgminerConfiguration.StratumProxy;
minerConfiguration.StratumProxyPort = engineConfiguration.XgminerConfiguration.StratumProxyPort;
minerConfiguration.StratumProxyStratumPort = engineConfiguration.XgminerConfiguration.StratumProxyStratumPort;
}
}
return(deviceCount);
}
private int SetupConfigurationDevices(Xgminer.Data.Configuration.Miner minerConfiguration, DeviceKind deviceKind, IList <Engine.Data.Configuration.Device> deviceConfigurations)
{
int deviceCount = 0;
for (int i = 0; i < deviceConfigurations.Count; i++)
{
Engine.Data.Configuration.Device enabledConfiguration = deviceConfigurations[i];
Xgminer.Data.Device device = devices.SingleOrDefault(d => d.Equals(enabledConfiguration));
if (deviceKind != device.Kind)
{
continue;
}
deviceCount++;
minerConfiguration.DeviceDescriptors.Add(device);
}
return(deviceCount);
}
public void UpdateDevicesForProxySettings(List <Device> devices, bool mining)
{
if (xgminerConfiguration.StratumProxy)
{
for (int i = 0; i < xgminerConfiguration.StratumProxies.Count; i++)
{
Engine.Data.Configuration.Xgminer.ProxyDescriptor proxyDescriptor = xgminerConfiguration.StratumProxies[i];
Xgminer.Data.Device proxyDevice = new Xgminer.Data.Device()
{
Kind = DeviceKind.PXY,
Driver = "proxy",
Name = String.Format("Stratum Proxy #{0}", (i + 1)),
//we want the path in the ViewModel for Remoting
//can't rely on having the Stratum Proxy settings
Path = String.Format("{0}:{1}", proxyDescriptor.GetworkPort, proxyDescriptor.StratumPort),
RelativeIndex = i
};
if (!devices.Any(d => d.Equals(proxyDevice)))
{
devices.Add(proxyDevice);
}
}
}
if (!mining)
{
devices.RemoveAll(d =>
(d.Kind == DeviceKind.PXY) &&
(
(!xgminerConfiguration.StratumProxy) ||
(!xgminerConfiguration.StratumProxies.Any(sp => String.Format("{0}:{1}", sp.GetworkPort, sp.StratumPort).Equals(d.Path)))
)
);
}
SortDevices(devices);
}
public void UpdateDevicesForProxySettings(List<Device> devices, bool mining)
{
if (xgminerConfiguration.StratumProxy)
{
for (int i = 0; i < xgminerConfiguration.StratumProxies.Count; i++)
{
Engine.Data.Configuration.Xgminer.ProxyDescriptor proxyDescriptor = xgminerConfiguration.StratumProxies[i];
Xgminer.Data.Device proxyDevice = new Xgminer.Data.Device()
{
Kind = DeviceKind.PXY,
Driver = "proxy",
Name = String.Format("Stratum Proxy #{0}", (i + 1)),
//we want the path in the ViewModel for Remoting
//can't rely on having the Stratum Proxy settings
Path = String.Format("{0}:{1}", proxyDescriptor.GetworkPort, proxyDescriptor.StratumPort),
RelativeIndex = i
};
if (!devices.Any(d => d.Equals(proxyDevice)))
devices.Add(proxyDevice);
}
}
if (!mining)
{
devices.RemoveAll(d =>
(d.Kind == DeviceKind.PXY) &&
(
(!xgminerConfiguration.StratumProxy) ||
(!xgminerConfiguration.StratumProxies.Any(sp => String.Format("{0}:{1}", sp.GetworkPort, sp.StratumPort).Equals(d.Path)))
)
);
}
SortDevices(devices);
}
private List <Engine.Data.Configuration.Device> CreateDeviceConfigurationForProfitableCoins(List <CoinInformation> allProfitableCoins,
List <CoinInformation> sha256ProfitableCoins, List <CoinInformation> scryptProfitableCoins)
{
List <Engine.Data.Configuration.Device> newConfiguration = new List <Engine.Data.Configuration.Device>();
CoinInformation profitableCoin = null;
int comboAlgoIterator = 0;
int sha256Iterator = 0;
int scryptIterator = 0;
for (int i = 0; i < devices.Count; i++)
{
Xgminer.Data.Device device = devices[i];
//there should be a 1-to-1 relationship of devices and device configurations
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations[i];
if (existingConfiguration.Enabled)
{
profitableCoin = null;
if (device.Kind == DeviceKind.PXY)
{
Data.Configuration.Coin existingCoinConfig = engineConfiguration.CoinConfigurations.Single(cc => cc.CryptoCoin.Symbol.Equals(existingConfiguration.CoinSymbol, StringComparison.OrdinalIgnoreCase));
//keep Proxies on the same algo - don't know what is pointed at them
if (existingCoinConfig.CryptoCoin.Algorithm == CoinAlgorithm.Scrypt)
{
profitableCoin = ChooseCoinFromList(scryptProfitableCoins, scryptIterator);
scryptIterator++;
}
else
{
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, sha256Iterator);
sha256Iterator++;
}
}
else if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && !device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//scrypt only
profitableCoin = ChooseCoinFromList(scryptProfitableCoins, scryptIterator);
scryptIterator++;
}
else if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//sha256 or scrypt
profitableCoin = ChooseCoinFromList(allProfitableCoins, comboAlgoIterator);
comboAlgoIterator++;
}
else if (sha256ProfitableCoins.Count > 0)
{
//sha256 only
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, sha256Iterator);
sha256Iterator++;
}
if (comboAlgoIterator >= allProfitableCoins.Count())
{
comboAlgoIterator = 0;
}
if (sha256Iterator >= sha256ProfitableCoins.Count())
{
sha256Iterator = 0;
}
if (scryptIterator >= scryptProfitableCoins.Count())
{
scryptIterator = 0;
}
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = profitableCoin == null ? string.Empty : profitableCoin.Symbol;
newConfiguration.Add(configEntry);
}
else
{
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = existingConfiguration.CoinSymbol;
configEntry.Enabled = false;
newConfiguration.Add(configEntry);
}
}
return(newConfiguration);
}
private List <Engine.Data.Configuration.Device> CreateDeviceConfigurationForProfitableCoins(List <CoinInformation> allProfitableCoins, List <CoinInformation> sha256ProfitableCoins)
{
List <Engine.Data.Configuration.Device> newConfiguration = new List <Engine.Data.Configuration.Device>();
CoinInformation profitableCoin = null;
int gpuIterator = 0;
int amuIterator = 0;
for (int i = 0; i < devices.Count; i++)
{
Xgminer.Data.Device device = devices[i];
//there should be a 1-to-1 relationship of devices and device configurations
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations[i];
if (existingConfiguration.Enabled)
{
profitableCoin = null;
if (device.Kind == DeviceKind.GPU)
{
//sha256 or scrypt
profitableCoin = ChooseCoinFromList(allProfitableCoins, gpuIterator);
gpuIterator++;
if (gpuIterator >= allProfitableCoins.Count())
{
gpuIterator = 0;
}
}
else if (sha256ProfitableCoins.Count > 0)
{
//sha256 only
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, amuIterator);
amuIterator++;
if (amuIterator >= sha256ProfitableCoins.Count())
{
amuIterator = 0;
}
}
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = profitableCoin == null ? string.Empty : profitableCoin.Symbol;
newConfiguration.Add(configEntry);
}
else
{
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = existingConfiguration.CoinSymbol;
configEntry.Enabled = false;
newConfiguration.Add(configEntry);
}
}
return(newConfiguration);
}
private List <Engine.Data.Configuration.Device> CreateDeviceConfigurationForProfitableCoins(List <CoinInformation> allProfitableCoins,
List <CoinInformation> sha256ProfitableCoins, List <CoinInformation> scryptProfitableCoins)
{
List <Engine.Data.Configuration.Device> newConfiguration = new List <Engine.Data.Configuration.Device>();
CoinInformation profitableCoin = null;
int comboAlgoIterator = 0;
int sha256Iterator = 0;
int scryptIterator = 0;
for (int i = 0; i < devices.Count; i++)
{
Xgminer.Data.Device device = devices[i];
//there should be a 1-to-1 relationship of devices and device configurations
Engine.Data.Configuration.Device existingConfiguration = engineConfiguration.DeviceConfigurations[i];
if (existingConfiguration.Enabled)
{
profitableCoin = null;
if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && !device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//scrypt only
profitableCoin = ChooseCoinFromList(scryptProfitableCoins, scryptIterator);
scryptIterator++;
if (scryptIterator >= scryptProfitableCoins.Count())
{
scryptIterator = 0;
}
}
else if (device.SupportsAlgorithm(CoinAlgorithm.Scrypt) && device.SupportsAlgorithm(CoinAlgorithm.SHA256))
{
//sha256 or scrypt
profitableCoin = ChooseCoinFromList(allProfitableCoins, comboAlgoIterator);
comboAlgoIterator++;
if (comboAlgoIterator >= allProfitableCoins.Count())
{
comboAlgoIterator = 0;
}
}
else if (sha256ProfitableCoins.Count > 0)
{
//sha256 only
profitableCoin = ChooseCoinFromList(sha256ProfitableCoins, sha256Iterator);
sha256Iterator++;
if (sha256Iterator >= sha256ProfitableCoins.Count())
{
sha256Iterator = 0;
}
}
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = profitableCoin == null ? string.Empty : profitableCoin.Symbol;
newConfiguration.Add(configEntry);
}
else
{
Engine.Data.Configuration.Device configEntry = new Engine.Data.Configuration.Device();
configEntry.Assign(device);
configEntry.CoinSymbol = existingConfiguration.CoinSymbol;
configEntry.Enabled = false;
newConfiguration.Add(configEntry);
}
}
return(newConfiguration);
}
