public Disassembler(CPU cpu, MemorySpace.Memory memory)
{
_cpu = cpu;
_memory = memory;
Reset();
}
public void SaveVariableToMemorySpace()
{
MemorySpaceNodeListCache cache = new MemorySpaceNodeListCache();
AST root = new AST();
MemorySpace memorySpace = new MemorySpace("globals", root, new Scope(Scope.ScopeType.MAIN_SCOPE, "blah"), cache);
object val = 5.9f;
memorySpace.setValue("x", val);
Assert.AreEqual(typeof(float), memorySpace.getValue("x").GetType());
Assert.AreEqual(5.9f, (float)memorySpace.getValue("x"));
}
public void SaveVariableToMemorySpace()
{
MemorySpaceNodeListCache cache = new MemorySpaceNodeListCache();
AST root = new AST();
MemorySpace memorySpace = new MemorySpace("globals", root, new Scope(Scope.ScopeType.MAIN_SCOPE, "blah"), cache);
ReturnValue val = new ReturnValue(5.9f);
memorySpace.setValue("x", val);
Assert.AreEqual(ReturnValueType.NUMBER, memorySpace.getValue("x").getReturnValueType());
Assert.AreEqual(5.9f, memorySpace.getValue("x").NumberValue);
}
private void Assign(Ast ast, dynamic value, MemorySpace space = null)
{
if (value is ValueMemory)
{
var tup = value as ValueMemory;
tup.Memory.Assign(ast.Token.TokenValue, tup.Value);
return;
}
if (space != null)
{
space.Assign(ast.Token.TokenValue, value);
return;
}
MemorySpaces.Current.Assign(ast.Token.TokenValue, value);
}
public ValueMemory(dynamic value, MemorySpace memory)
{
this.Value = value;
this.Memory = memory;
}
private static extern unsafe int _AllocHostRaw(ref PtrT pointer, uint size, MemorySpace memorySpace, MathDomain mathDomain);
public void SetMemorySpace(string name, MemorySpace space)
{
arrayLocations[name] = space;
}
private static extern unsafe int _EyeRaw(PtrT pointer, uint nRows, MemorySpace memorySpace, MathDomain mathDomain);
private static extern unsafe int _ScaleRaw(PtrT z, uint size, MemorySpace memorySpace, MathDomain mathDomain, double alpha);
private static extern unsafe int _SubtractEqualRaw(PtrT z, PtrT x, uint size, MemorySpace memorySpace, MathDomain mathDomain);
private static extern unsafe int _AddEqualMatrixRaw(PtrT A, PtrT B, uint nRows, uint nCols, MemorySpace memorySpace, MathDomain mathDomain, MatrixOperation aOperation, MatrixOperation bOperation, double alpha, double beta);
private static extern unsafe int _AddEqualRaw(PtrT z, PtrT x, uint size, MemorySpace memorySpace, MathDomain mathDomain, double alpha);
private static extern unsafe int _IsNonZeroRaw(PtrT z, PtrT x, uint size, MemorySpace memorySpace, MathDomain mathDomain);
private static extern unsafe int _InvertRaw(PtrT A, uint nRows, uint nCols, MemorySpace memorySpace, MathDomain mathDomain, MatrixOperation aOperation);
private static extern unsafe int _SparseAddRaw(PtrT z, PtrT x, PtrT y, uint nNonZeros, PtrT nonZeroIndices, MemorySpace memorySpace, MathDomain mathDomain, uint size, double alpha);
private static extern unsafe int _SparseDotRaw(PtrT y, PtrT A, PtrT x, uint nNonZeros, PtrT nonZeroColumnIndices, PtrT nNonZeroRows, uint nRows, uint nCols, MemorySpace memorySpace, MathDomain mathDomain, MatrixOperation aOperation, double alpha);
private static extern unsafe int _ElementwiseProductRaw(PtrT z, PtrT x, PtrT y, uint size, MemorySpace memorySpace, MathDomain mathDomain, double alpha = 1.0);
public ValueMemory(dynamic value, MemorySpace memory)
{
Value = value;
Memory = memory;
}
internal ContiguousMemoryBuffer(bool isOwner = true, MemorySpace memorySpace = MemorySpace.Device, MathDomain mathDomain = MathDomain.Float)
{
this.isOwner = isOwner;
this.memorySpace = memorySpace;
this.mathDomain = mathDomain;
}
public Tensor(int nRows, int nCols, int nCubes, double value, MemorySpace memorySpace = MemorySpace.Device, MathDomain mathDomain = MathDomain.Float)
: this(nRows, nCols, nCubes, memorySpace, mathDomain)
{
Set(value);
}
private static extern unsafe int _InitializeRaw(PtrT pointer, uint size, MemorySpace memorySpace, MathDomain mathDomain, double value);
private static extern unsafe int _LinSpaceRaw(PtrT pointer, uint size, MemorySpace memorySpace, MathDomain mathDomain, double x0, double x1);
private static extern unsafe int _RandNormalRaw(PtrT pointer, uint size, MemorySpace memorySpace, MathDomain mathDomain, int seed);
private static extern unsafe int _AutoCopyRaw(PtrT destPointer, PtrT sourcePointer, uint size, MemorySpace memorySpace, MathDomain mathDomain);
protected void MakeStackOp(StackOp op, int size, MemorySpace space, int offset, Expr indexExpr, ArrayList bytecodeList)
{
// Not for MemorySpace.MEM ops.
if (indexExpr != null)
{
indexExpr.MakeByteCode(true, bytecodeList);
}
int opcode;
if (offset < 32
&& size == 4
&& (space == MemorySpace.VAR || space == MemorySpace.LOCAL)
&& indexExpr == null)
{ // Use the short form if possible
if ((offset & 3) != 0)
throw new ParseException("Non-long offset", Token);
opcode = space == MemorySpace.VAR ? 0x40 : 0x60; // VAR / LOCAL
opcode |= (byte)op;
bytecodeList.Add((byte)(opcode + offset));
}
else // we have to use the long form
{
opcode = 0x80 | ((size >> 1) << 5) | ((int)space << 2) | (int)op;
if (indexExpr != null)
{
opcode |= 0x10;
}
if (offset < 128)
{
bytecodeList.Add((byte)opcode);
bytecodeList.Add((byte)offset);
}
else
{
bytecodeList.Add((byte)opcode);
bytecodeList.Add((byte)(offset >> 8 | 0x80));
bytecodeList.Add((byte)offset);
}
}
}
private static extern unsafe int _FreeRaw(PtrT pointer, uint size, MemorySpace memorySpace, MathDomain mathDomain);
public ValueMemory(dynamic value, MemorySpace memory)
{
Value = value;
Memory = memory;
}
public SparseVector(int denseSize, int nNonZeroIndices, MemorySpace memorySpace, MathDomain mathDomain)
: this(denseSize, new Vector(nNonZeroIndices, memorySpace, MathDomain.Int), mathDomain)
{
}
public static ColumnWiseMatrix LinSpace(int nRows, int nCols, double x0, double x1, MemorySpace memorySpace = MemorySpace.Device, MathDomain mathDomain = MathDomain.Float)
{
var mat = new ColumnWiseMatrix(nRows, nCols, memorySpace, mathDomain);
mat.LinSpace(x0, x1);
return(mat);
}
private object NewDo(NewAst ast)
{
var className = Resolve(ast);
var classType = (className as ClassSymbol).Src as ClassAst;
var space = new MemorySpace();
var oldSpace = MemorySpaces.Current;
MemorySpaces.Current = space;
foreach (var symbol in classType.Body.ScopedStatements)
{
Exec(symbol);
}
if (classType.Constructor != null)
{
var funcInvoke = new FuncInvoke(classType.Constructor.Token, ast.Args);
funcInvoke.CurrentScope = classType.Body.CurrentScope;
Exec(funcInvoke);
}
MemorySpaces.Current = oldSpace;
return space;
}
public static ColumnWiseMatrix RandomGaussian(int nRows, int nCols, int seed, MemorySpace memorySpace = MemorySpace.Device, MathDomain mathDomain = MathDomain.Float)
{
var mat = new ColumnWiseMatrix(nRows, nCols, memorySpace, mathDomain);
mat.RandomGaussian(seed);
return(mat);
}
private static extern unsafe int _SparseSubtractRaw(PtrT z, PtrT x, PtrT y, uint nNonZeros, PtrT nonZeroIndices, MemorySpace memorySpace, MathDomain mathDomain, uint size);
public ColumnWiseMatrix(int nRows, int nCols, double value, MemorySpace memorySpace = MemorySpace.Device, MathDomain mathDomain = MathDomain.Float)
: this(nRows, nCols, memorySpace, mathDomain)
{
Set(value);
}
private static extern unsafe int _SparseMultiplyRaw(PtrT A, PtrT B, PtrT C, uint nNonZeros, PtrT nonZeroColumnIndices, PtrT nNonZeroRows, uint nRowsB, uint nRowsC, uint nColsC, MemorySpace memorySpace, MathDomain mathDomain, uint leadingDimensionB, uint leadingDimensionC, MatrixOperation bOperation, double alpha);
public static Tensor LinSpace(int nRows, int nCols, int nCubes, double x0, double x1, MemorySpace memorySpace = MemorySpace.Device, MathDomain mathDomain = MathDomain.Float)
{
var tensor = new Tensor(nRows, nCols, nCubes, memorySpace, mathDomain);
tensor.LinSpace(x0, x1);
return(tensor);
}
/// <summary>
/// Class constructor.
/// </summary>
/// <param name="memory">The memory referenced by the CPU core.</param>
internal InterruptController(MemorySpace.Memory memory)
{
this.memory = memory;
}
public static Tensor RandomGaussian(int nRows, int nCols, int nCubes, int seed, MemorySpace memorySpace = MemorySpace.Device, MathDomain mathDomain = MathDomain.Float)
{
var tensor = new Tensor(nRows, nCols, nCubes, memorySpace, mathDomain);
tensor.RandomGaussian(seed);
return(tensor);
}
public CPU(MemorySpace.Memory memory)
{
this._memory = memory;
this._interruptController = new InterruptController(this._memory);
// Initialize registers
Reset();
ResetBreakpoints();
}
private static extern unsafe int _CumulativeRowSumRaw(PtrT A, uint nRows, uint nCols, MemorySpace memorySpace, MathDomain mathDomain);
