public List <ComputationResult> PerformCalculations(int workerID, List <ComputationTask> tasks,
MatrixCalculation calculation)
{
var results = new List <ComputationResult>();
var n = calculation.A.Size;
foreach (var computationTask in tasks)
{
var res = 0L;
for (var i = 0; i < n; i++)
{
var a = calculation.A.Data[computationTask.X][i];
var b = calculation.B.Data[i][computationTask.Y];
res += a * b;
}
results.Add(new ComputationResult
{
X = computationTask.X,
Y = computationTask.Y,
Result = res
});
}
return(results);
}
public Dictionary <int, List <ComputationTask> > BuildTasks(int workerCount, MatrixCalculation calculation)
{
var tasks = new Dictionary <int, List <ComputationTask> >();
var n = calculation.A.Size;
var cnt = 0;
for (var x = 0; x < n; x++)
{
for (var y = 0; y < n; y++)
{
var workerNo = cnt % workerCount;
if (!tasks.ContainsKey(workerNo))
{
tasks[workerNo] = new List <ComputationTask>();
}
tasks[workerNo].Add(new ComputationTask
{
X = (ushort)x,
Y = (ushort)y
});
cnt++;
}
}
return(tasks);
}
public void StoreCalculation(string id, MatrixCalculation calculation)
{
var memoryStream = new MemoryStream();
serializer.Serialize(calculation, memoryStream);
memoryStream.Seek(0, SeekOrigin.Begin);
transferUtility.Upload(memoryStream, bucketName, id);
}
void Start()
{
m_timer = GameObject.Find("GeneralManager").GetComponent <TimeManager>();
m_outputWriter = GameObject.Find("GeneralManager").GetComponent <OutputWriter>();
m_playSequenceManager = GameObject.Find("GeneralManager").GetComponent <PlaySequenceManager>();
m_matrixCalculation = GameObject.Find("GeneralManager").GetComponent <MatrixCalculation>();
m_targetManager = GameObject.Find("TARGETS").GetComponent <TargetManager>();
m_HUD = GameObject.Find("HUD").GetComponent <HUDManager>();
}
public void StoreCalculation(string id, MatrixCalculation calculation)
{
Console.WriteLine("Attempting to store config in object storage");
var data = JsonConvert.SerializeObject(calculation);
var ms = new MemoryStream();
ms.Write(Encoding.UTF8.GetBytes(data));
ms.Seek(0, SeekOrigin.Begin);
Task.WaitAll(_client.PutObjectAsync(_bucketName, id, ms, ms.Length));
}
public static Matrix SerialMultiply([ActivityTrigger] MatrixCalculation calculation, ILogger log)
{
var repo = new InMemoryMatrixMulRepository();
repo.StoreCalculation("an_id", calculation);
var hndlr = new FunctionHandler(repo);
log.LogInformation("Serially multiplying two matrices");
hndlr.SerialMultiply("an_id");
return(repo.GetResultMatrix("an_id"));
}
public Matrix BuildResultMatrix(MatrixCalculation calculation, List <List <ComputationResult> > results)
{
var n = calculation.A.Size;
var resultMatrix = Util.GenerateMatrix(n, (x, y) => 0);
foreach (var workerResults in results)
{
foreach (var result in workerResults)
{
resultMatrix.Data[result.X][result.Y] = result.Result;
}
}
return(resultMatrix);
}
public Matrix SerialMultiply(MatrixCalculation calculation)
{
var n = calculation.A.Size;
var matrix = Util.GenerateMatrix(n, (x, y) => 0);
for (var x = 0; x < n; x++)
{
for (var y = 0; y < n; y++)
{
var res = 0L;
for (var i = 0; i < n; i++)
{
var a = calculation.A.Data[x][i];
var b = calculation.B.Data[i][y];
res += a * b;
}
matrix.Data[x][y] = res;
}
}
return(matrix);
}
public string CreateMatrix(int size, int maxValue = 50000, long seed = -1,
Func <int, int, long> genFuncA = null, Func <int, int, long> genFuncB = null)
{
if (seed == -1)
{
seed = Util.GetUnixTimestamp();
}
Random rnd = new Random((int)seed);
Func <int, int, long> funca = (x, y) => rnd.Next(maxValue);
Func <int, int, long> funcb = (x, y) => rnd.Next(maxValue);
if (genFuncA != null)
{
funca = genFuncA;
}
if (genFuncB != null)
{
funcb = genFuncB;
}
var uid = Guid.NewGuid().ToString();
var mtxA = Util.GenerateMatrix(size, funca);
var mtxB = Util.GenerateMatrix(size, funcb);
var c = new MatrixCalculation
{
A = mtxA,
B = mtxB
};
datastore.StoreCalculation(uid, c);
return(uid);
}
public void StoreCalculation(string id, MatrixCalculation calculation)
{
_calculations.Add(id, calculation);
}
